libburnia/libisofs-legacy
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Got rid by soft means of assert() in async.c

Browse Source
This commit is contained in:
Thomas Schmitt
2006-10-07 06:23:31 +00:00
parent 16d3089ba8
commit 91f2a231f3
3 changed files with 92 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
libburn/asserts.txt
View File

@@ -4,7 +4,8 @@ Format:
------------------------------------------------------------------------------
Number) grep'ed line
Number) grep'ed line
(++ before number means: is fully done, + means is done so far )
function():
Description of abort condition.
@@ -13,9 +14,11 @@ Possible callers and their relation to the abort condition.
: Error Evaluation
=> Consequences
Eventual implementation timestamp
------------------------------------------------------------------------------
1) libburn/async.c: assert(a != NULL); /* wasn't found.. this should not be possible */
++ 1) libburn/async.c: assert(a != NULL); /* wasn't found.. this should not be possible */
static remove_worker():
A thread describing structure (struct w_list) could not be found in
order to be released.
@@ -26,12 +29,13 @@ Called by static write_disc_worker_func(), thread under API burn_disc_write()
All three want to clean up after they are done.
: Severe Libburn Error
=> Plain burn_finish() is admissible.
=> But a mere LIBDAX_MSGS_SEV_WARNING could be justified, too.
=> issue LIBDAX_MSGS_SEV_WARNING
ts A61006
------------------------------------------------------------------------------
2) libburn/async.c: assert(!(workers && workers->drive));
++ 2) libburn/async.c: assert(!(workers && workers->drive));
API burn_drive_scan():
Before spawning a thread, the function refuses work because another
drive activity is going on.
@@ -39,9 +43,11 @@ drive activity is going on.
: Severe Application Error
=> return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_SORRY
ts A61006
------------------------------------------------------------------------------
3) libburn/async.c: assert(workers == NULL);
+ 3) libburn/async.c: assert(workers == NULL);
API burn_drive_scan():
After thread is done and remover_worker() succeeded, there is still a
worker registered. Shall probably detect roguely appeared burn or
@@ -50,9 +56,11 @@ erase runs. (I consider to install a mutex shielded function for that.)
: Severe Libburn Error
=> Same as 1)
ts A61006
------------------------------------------------------------------------------
4) libburn/async.c: assert(drive);
++ 4) libburn/async.c: assert(drive);
libburn/async.c: assert(!SCAN_GOING());
libburn/async.c: assert(!find_worker(drive));
API burn_disc_erase():
@@ -63,9 +71,11 @@ a parallel activity on another drive.
: Severe Application Error
=> (no return value), issue LIBDAX_MSGS_SEV_SORRY
ts A61006
------------------------------------------------------------------------------
5) libburn/async.c: assert(!SCAN_GOING());
++ 5) libburn/async.c: assert(!SCAN_GOING());
libburn/async.c: assert(!find_worker(opts->drive));
API burn_disc_write():
Same as 4)
@@ -73,6 +83,8 @@ Same as 4)
: Severe Application Error
=> Same as 4)
ts A61006
---------------------------------------------------------------------
6) libburn/drive.c: assert(d->busy == BURN_DRIVE_IDLE);

73
libburn/async.c
View File

@@ -8,9 +8,14 @@
#include "async.h"
#include <pthread.h>
#include <assert.h>
#include <stdlib.h>
/*
#include <a ssert.h>
*/
#include "libdax_msgs.h"
extern struct libdax_msgs *libdax_messenger;
#define SCAN_GOING() (workers && !workers->drive)
typedef void *(*WorkerFunc) (void *);
@@ -100,7 +105,13 @@ static void remove_worker(pthread_t th)
free(a);
break;
}
assert(a != NULL); /* wasn't found.. this should not be possible */
/* ts A61006 */
/* a ssert(a != NULL);/ * wasn't found.. this should not be possible */
if (a == NULL)
libdax_msgs_submit(libdax_messenger, -1, 0x00020101,
LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
"remove_worker() cannot find given worker item", 0, 0);
}
static void *scan_worker_func(struct w_list *w)
@@ -116,7 +127,17 @@ int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
int ret = 0;
/* cant be anything working! */
assert(!(workers && workers->drive));
/* ts A61006 */
/* a ssert(!(workers && workers->drive)); */
if (workers != NULL && workers->drive != NULL) {
libdax_msgs_submit(libdax_messenger,
workers->drive->global_index, 0x00020102,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"A drive operation is still going on (want to scan)",
0, 0);
return -1;
}
if (!workers) {
/* start it */
@@ -128,7 +149,16 @@ int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
/* its done */
ret = workers->u.scan.done;
remove_worker(workers->thread);
assert(workers == NULL);
/* ts A61006 */
/* a ssert(workers == NULL); */
if (workers != NULL)
libdax_msgs_submit(libdax_messenger, -1, 0x00020101,
LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
"After scan a drive operation is still going on",
0, 0);
return -1;
} else {
/* still going */
}
@@ -146,9 +176,25 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
{
struct erase_opts o;
assert(drive);
assert(!SCAN_GOING());
assert(!find_worker(drive));
/* ts A61006 */
/* a ssert(drive); */
/* a ssert(!SCAN_GOING()); */
/* a ssert(!find_worker(drive)); */
if((drive == NULL)) {
libdax_msgs_submit(libdax_messenger, drive->global_index,
0x00020104,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"NULL pointer caught in burn_disc_erase", 0, 0);
return;
}
if ((SCAN_GOING()) || find_worker(drive)) {
libdax_msgs_submit(libdax_messenger, drive->global_index,
0x00020102,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"A drive operation is still going on (want to erase)",
0, 0);
return;
}
o.drive = drive;
o.fast = fast;
@@ -171,8 +217,17 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
{
struct write_opts o;
assert(!SCAN_GOING());
assert(!find_worker(opts->drive));
/* ts A61006 */
/* a ssert(!SCAN_GOING()); */
/* a ssert(!find_worker(opts->drive)); */
if ((SCAN_GOING()) || find_worker(opts->drive)) {
libdax_msgs_submit(libdax_messenger, opts->drive->global_index,
0x00020102,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"A drive operation is still going on (want to write)",
0, 0);
return;
}
o.drive = opts->drive;
o.opts = opts;
o.disc = disc;

8
libburn/libdax_msgs.h
View File

@@ -293,6 +293,8 @@ Range "elmom" : 0x00010000 to 0x0001ffff
------------------------------------------------------------------------------
Range "scdbackup" : 0x00020000 to 0x0002ffff
Acessing and defending drives:
0x00020001 (SORRY,LOW) = Cannot open busy device
0x00020002 (SORRY,HIGH) = Encountered error when closing drive
0x00020003 (FATAL,HIGH) = Could not grab drive
@@ -301,6 +303,12 @@ Range "scdbackup" : 0x00020000 to 0x0002ffff
0x00020006 (FATAL,HIGH) = Too many scsi siblings
0x00020007 (NOTE,HIGH) = Closed O_EXCL scsi siblings
From the hunt on assert:
0x00020101 (WARNING,HIGH) = Cannot find given worker item
0x00020102 (SORRY,HIGH) = A drive operation is still going on
0x00020103 (WARNING,HIGH) = After scan a drive operation is still going on
0x00020104 (SORRY,HIGH) = NULL pointer caught
------------------------------------------------------------------------------