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

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

Browse Source
This commit is contained in:
Thomas Schmitt 2006-10-07 12:29:22 +00:00
parent 91f2a231f3
commit ff0be0eeae
9 changed files with 198 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cdrskin/cdrskin_timestamp.h
View File

@ -1 +1 @@
#define Cdrskin_timestamP "2006.10.05.142628"
#define Cdrskin_timestamP "2006.10.07.121234"

56
libburn/asserts.txt
View File

@ -87,16 +87,18 @@ ts A61006
---------------------------------------------------------------------
6) libburn/drive.c: assert(d->busy == BURN_DRIVE_IDLE);
++ 6) libburn/drive.c: assert(d->busy == BURN_DRIVE_IDLE);
API burn_drive_release():
A drive is not idle on release.
: Severe Application Error
=> Same as 4)
ts A61007
------------------------------------------------------------------------------
7) libburn/drive.c: assert(d->released);
++ 7) libburn/drive.c: assert(d->released);
burn_wait_all()
A drive is found grabbed.
@ -104,12 +106,16 @@ Called by burn_drive_scan_sync(), thread under API burn_drive_scan()
Called by API burn_finish
: Severe Application Error
=> rename and redefine burn_wait_all() : now burn_drives_are_clear()
=> change all use of burn_wait_all()
=> Move tests up to burn_drive_scan()
=> There: return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_SORRY
=> There: return -1; issue LIBDAX_MSGS_SEV_SORRY
ts A61007
------------------------------------------------------------------------------
8) libburn/drive.c: assert(!d->released);
++ 8) libburn/drive.c: assert(!d->released);
API burn_disc_get_status()
Attempt to read status of non-grabbed drive.
@ -117,20 +123,24 @@ Attempt to read status of non-grabbed drive.
=> extend enum burn_disc_status by BURN_DISC_UNGRABBED
=> return BURN_DISC_UNGRABBED, issue LIBDAX_MSGS_SEV_SORRY
ts A61007
------------------------------------------------------------------------------
9) libburn/drive.c: assert( /* (write_type >= BURN_WRITE_PACKET) && */
++ 9) libburn/drive.c: assert( /* (write_type >= BURN_WRITE_PACKET) && */
burn_drive_get_block_types():
Will not work on BURN_WRITE_RAW.
Will not work on BURN_WRITE below BURN_WRITE_RAW.
Called by -nobody- ?
: Severe Application Error
=> inactivate unused function
ts A61007
------------------------------------------------------------------------------
10) libburn/drive.c: assert(d->idata);
++ 10) libburn/drive.c: assert(d->idata);
libburn/drive.c: assert(d->mdata);
static drive_getcaps():
sg.c:enumerate_common() did not succeed in creating a proper struct burn_drive
@ -139,11 +149,14 @@ Called by burn_drive_scan_sync()
: Severe System Error
=> This could possibly really stay an abort() because the reason is
a plain failure of the system's memory management.
=> ? Detect this failure already in enumerate_common() ?
=> Detect this failure already in enumerate_common(),
issue LIBDAX_MSGS_SEV_FATAL, return
ts A61007
------------------------------------------------------------------------------
11) libburn/drive.c: assert(burn_running);
++ 11) libburn/drive.c: assert(burn_running);
burn_drive_scan_sync():
The library was not initialized.
@ -151,20 +164,24 @@ Called as thread by API burn_drive_scan()
: Severe Application Error
=> Move this test up to burn_drive_scan()
=> There: return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_SORRY
=> There: return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_FATAL
ts A61007
------------------------------------------------------------------------------
12) libburn/drive.c: assert(d->released == 1);
++ 12) libburn/drive.c: assert(d->released == 1);
burn_drive_scan_sync():
Inactivated
: (Severe Application Error)
=> Same as 7)
=> throw out inactivated code
ts A61007
------------------------------------------------------------------------------
13) libburn/drive.c: assert(strlen(d->devname) < BURN_DRIVE_ADR_LEN);
++ 13) libburn/drive.c: assert(strlen(d->devname) < BURN_DRIVE_ADR_LEN);
burn_drive_raw_get_adr():
An enumerated device address is longer than the API's maximum length
@ -172,18 +189,21 @@ Called by API burn_drive_get_adr()
Called by API burn_drive_obtain_scsi_adr()
: Severe Libburn Error
=> return -1; in all three functions, enhance API @return docs
=> return -1; in all three functions, enhance burn_drive_get_adr @return docs
=> issue LIBDAX_MSGS_SEV_SORRY
ts A61007
------------------------------------------------------------------------------
14) libburn/drive.c: assert(drive_info->drive!=NULL);
++ 14) libburn/drive.c: assert(drive_info->drive!=NULL);
API burn_drive_get_adr():
Drive info has no drive attached.
: Severe Libburn Error
=> return -1; enhance API @return docs
=> issue LIBDAX_MSGS_SEV_SORRY
: Severe Libburn Error (unlikely, will eventually SIGSEGV on NULL)
=> delete assert
ts A61007
------------------------------------------------------------------------------

30
libburn/async.c
View File

@ -6,6 +6,7 @@
#include "write.h"
#include "options.h"
#include "async.h"
#include "init.h"
#include <pthread.h>
#include <stdlib.h>
@ -126,21 +127,41 @@ int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
struct scan_opts o;
int ret = 0;
/* ts A61006 : moved up from burn_drive_scan_sync , former assert */
if (!burn_running) {
libdax_msgs_submit(libdax_messenger, -1, 0x00020109,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
"Library not running", 0, 0);
*drives = NULL;
*n_drives = 0;
return -1;
}
/* cant be anything working! */
/* ts A61006 */
/* a ssert(!(workers && workers->drive)); */
if (workers != NULL && workers->drive != NULL) {
libdax_msgs_submit(libdax_messenger,
workers->drive->global_index, 0x00020102,
drive_is_active:;
libdax_msgs_submit(libdax_messenger, -1, 0x00020102,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"A drive operation is still going on (want to scan)",
0, 0);
*drives = NULL;
*n_drives = 0;
return -1;
}
if (!workers) {
/* start it */
/* ts A61007 : test moved up from burn_drive_scan_sync()
was burn_wait_all() */
if (!burn_drives_are_clear())
goto drive_is_active;
*drives = NULL;
*n_drives = 0;
o.drives = drives;
o.n_drives = n_drives;
o.done = 0;
@ -152,12 +173,13 @@ int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
/* ts A61006 */
/* a ssert(workers == NULL); */
if (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;
return -1;
}
} else {
/* still going */

131
libburn/drive.c
View File

@ -5,7 +5,10 @@
#include <malloc.h>
#include <unistd.h>
#include <signal.h>
#include <assert.h>
/* ts A61007 */
/* #include <a ssert.h> */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
@ -261,11 +264,26 @@ int burn_drive_unregister(struct burn_drive *d)
void burn_drive_release(struct burn_drive *d, int le)
{
if (d->released)
burn_print(1, "second release on drive!\n");
if (d->released) {
/* ts A61007 */
/* burn_print(1, "second release on drive!\n"); */
libdax_msgs_submit(libdax_messenger,
d->global_index, 0x00020105,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"Drive is already released", 0, 0);
return;
}
/* ts A61007 */
/* ts A60906: one should not assume BURN_DRIVE_IDLE == 0 */
assert(d->busy == BURN_DRIVE_IDLE);
/* a ssert(d->busy == BURN_DRIVE_IDLE); */
if (d->busy != BURN_DRIVE_IDLE) {
libdax_msgs_submit(libdax_messenger,
d->global_index, 0x00020106,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"Drive is busy on attempt to close", 0, 0);
return;
}
d->unlock(d);
if (le)
@ -285,6 +303,26 @@ void burn_drive_release(struct burn_drive *d, int le)
}
}
/* ts A61007 : former void burn_wait_all() */
int burn_drives_are_clear(void)
{
int i;
for (i = burn_drive_count() - 1; i >= 0; --i) {
/* ts A60904 : ticket 62, contribution by elmom */
if (drive_array[i].global_index == -1)
continue;
if (drive_array[i].released)
continue;
return 0;
}
return 1;
}
#if 0
void burn_wait_all(void)
{
unsigned int i;
@ -300,12 +338,14 @@ void burn_wait_all(void)
if (d->global_index==-1)
continue;
assert(d->released);
a ssert(d->released);
}
if (!finished)
sleep(1);
}
}
#endif
void burn_disc_erase_sync(struct burn_drive *d, int fast)
{
@ -346,7 +386,17 @@ void burn_disc_erase_sync(struct burn_drive *d, int fast)
enum burn_disc_status burn_disc_get_status(struct burn_drive *d)
{
assert(!d->released);
/* ts A61007 */
/* a ssert(!d->released); */
if (d->released) {
libdax_msgs_submit(libdax_messenger,
d->global_index, 0x00020108,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"Drive is not grabbed on disc status inquiry",
0, 0);
return BURN_DISC_UNGRABBED;
}
return d->status;
}
@ -371,12 +421,13 @@ void burn_drive_cancel(struct burn_drive *d)
pthread_mutex_unlock(&d->access_lock);
}
#ifdef NIX
/* ts A61007 : defunct because unused */
#if 0
int burn_drive_get_block_types(struct burn_drive *d,
enum burn_write_types write_type)
{
burn_print(12, "write type: %d\n", write_type);
assert( /* (write_type >= BURN_WRITE_PACKET) && */
a ssert( /* (write_type >= BURN_WRITE_PACKET) && */
(write_type <= BURN_WRITE_RAW));
return d->block_types[write_type];
}
@ -407,8 +458,12 @@ static int drive_getcaps(struct burn_drive *d, struct burn_drive_info *out)
{
struct scsi_inquiry_data *id;
assert(d->idata);
assert(d->mdata);
/* ts A61007 : now prevented in enumerate_common() */
#if 0
a ssert(d->idata);
a ssert(d->mdata);
#endif
if (!d->idata->valid || !d->mdata->valid)
return 0;
@ -454,27 +509,21 @@ int burn_drive_scan_sync(struct burn_drive_info *drives[],
static int scanning = 0, scanned = 0, found = 0;
static unsigned num_scanned = 0, count = 0;
unsigned int i;
#ifdef Libburn_ticket_62_enable_redundant_asserT
struct burn_drive *d;
#endif
assert(burn_running);
/* ts A61007 : moved up to burn_drive_scan() */
/* a ssert(burn_running); */
if (!scanning) {
scanning = 1;
/* ts A61007 : test moved up to burn_drive_scan()
burn_wait_all() is obsoleted */
#if 0
/* make sure the drives aren't in use */
burn_wait_all(); /* make sure the queue cleans up
before checking for the released
state */
/* ts A60904 : ticket 62, contribution by elmom */
/* this is redundant with what is done in burn_wait_all() */
#ifdef Libburn_ticket_62_enable_redundant_asserT
d = drive_array;
count = burn_drive_count();
for (i = 0; i < count; ++i, ++d)
assert(d->released == 1);
#endif /* Libburn_ticket_62_enable_redundant_asserT */
#endif /* 0 */
/* refresh the lib's drives */
sg_enumerate();
@ -520,7 +569,7 @@ void burn_drive_info_free(struct burn_drive_info drive_infos[])
burn_drive_info is not the manager of burn_drive but only its
spokesperson. To my knowlege drive_infos from burn_drive_scan()
are not memorized globally. */
if(drive_infos != NULL) /* and this NULL test is deadly necessary */
if(drive_infos != NULL)
free((void *) drive_infos);
burn_drive_free_all();
@ -650,27 +699,20 @@ int burn_drive_scan_and_grab(struct burn_drive_info *drive_infos[], char* adr,
fprintf(stderr,"libburn: experimental: burn_drive_scan_and_grab(%s)\n",
adr);
*/
while (!burn_drive_scan(drive_infos, &n_drives))
while (1) {
ret = burn_drive_scan(drive_infos, &n_drives);
if (ret < 0)
return -1;
if (ret > 0)
break;
usleep(1002);
}
if (n_drives <= 0)
return 0;
/*
fprintf(stderr, "libburn: experimental: n_drives == %d\n",n_drives);
*/
/* ts A60908 : seems we get rid of this :) */
#ifdef Libburn_grab_release_and_grab_agaiN
if (load) {
/* RIP-14.5 + LITE-ON 48125S produce a false status
if tray was unloaded */
/* Therefore the first grab is just for loading */
ret= burn_drive_grab(drive_infos[0]->drive, 1);
if (ret != 1)
return -1;
burn_drive_release(drive_infos[0]->drive,0);
}
#endif /* Libburn_grab_release_and_grab_agaiN */
ret = burn_drive_grab(drive_infos[0]->drive, load);
if (ret != 1)
return -1;
@ -704,7 +746,13 @@ int burn_drive_adr_debug_msg(char *fmt, char *arg)
/** Inquire the persistent address of the given drive. */
int burn_drive_raw_get_adr(struct burn_drive *d, char adr[])
{
assert(strlen(d->devname) < BURN_DRIVE_ADR_LEN);
if (strlen(d->devname) >= BURN_DRIVE_ADR_LEN) {
libdax_msgs_submit(libdax_messenger, d->global_index,
0x00020110,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
"Persistent drive address too long", 0, 0);
return -1;
}
strcpy(adr,d->devname);
return 1;
}
@ -715,7 +763,6 @@ int burn_drive_get_adr(struct burn_drive_info *drive_info, char adr[])
{
int ret;
assert(drive_info->drive!=NULL);
ret = burn_drive_raw_get_adr(drive_info->drive, adr);
return ret;
}
@ -818,7 +865,9 @@ int burn_drive_obtain_scsi_adr(char *path,
if (drive_array[i].global_index < 0)
continue;
ret = burn_drive_raw_get_adr(&(drive_array[i]),adr);
if (ret <= 0)
if (ret < 0)
return -1;
if (ret == 0)
continue;
if (strcmp(adr, path) == 0) {
*host_no = drive_array[i].host;

6
libburn/drive.h
View File

@ -38,7 +38,11 @@ struct burn_drive *burn_drive_register(struct burn_drive *);
int burn_drive_unregister(struct burn_drive *d);
unsigned int burn_drive_count(void);
void burn_wait_all(void);
/* ts A61007 */
/* void burn_wait_all(void); */
int burn_drives_are_clear(void);
int burn_sector_length_write(struct burn_drive *d);
int burn_track_control(struct burn_drive *d, int);
void burn_write_empty_sector(int fd);

10
libburn/init.c
View File

@ -81,7 +81,15 @@ void burn_finish(void)
{
assert(burn_running);
burn_wait_all();
/* ts A61007 */
/* burn_wait_all(); */
if (!burn_drives_are_clear()) {
libdax_msgs_submit(libdax_messenger, -1, 0x00020107,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
"Drive is busy on attempt to shut down library",
0, 0);
return;
}
/* ts A60904 : ticket 62, contribution by elmom : name addon "_all" */
burn_drive_free_all();

17
libburn/libburn.h
View File

@ -172,7 +172,11 @@ enum burn_disc_status
/** There is an incomplete disc in the drive */
BURN_DISC_APPENDABLE,
/** There is a disc with data on it in the drive */
BURN_DISC_FULL
BURN_DISC_FULL,
/* ts A61007 */
/** The drive was not grabbed when the status was inquired */
BURN_DISC_UNGRABBED
};
@ -419,7 +423,8 @@ int burn_abort(int patience,
int burn_abort_pacifier(void *handle, int patience, int elapsed);
/** Set the verbosity level of the library. The default value is 0, which means
/** ts A61006 : This is for development only. Not suitable for applications.
Set the verbosity level of the library. The default value is 0, which means
that nothing is output on stderr. The more you increase this, the more
debug output should be displayed on stderr for you.
@param level The verbosity level desired. 0 for nothing, higher positive
@ -510,7 +515,9 @@ void burn_drive_clear_whitelist(void);
before burn_finish(), and also before calling this function
burn_drive_scan() again.
@param n_drives Returns the number of drive items in drive_infos.
@return Zero while scanning is not complete; non-zero when it is finished.
@return 0 while scanning is not complete
>0 when it is finished sucessfully,
<0 when finished but failed.
*/
int burn_drive_scan(struct burn_drive_info *drive_infos[],
unsigned int *n_drives);
@ -545,6 +552,7 @@ void burn_drive_info_free(struct burn_drive_info drive_infos[]);
@param drive_info The drive to inquire. Usually some &(drive_infos[driveno])
@param adr An application provided array of at least BURN_DRIVE_ADR_LEN
characters size. The persistent address gets copied to it.
@return >0 success , <=0 error (due to libburn internal problem)
*/
int burn_drive_get_adr(struct burn_drive_info *drive_info, char adr[]);
@ -615,6 +623,7 @@ void burn_drive_release(struct burn_drive *drive, int eject);
for details.
@param drive The drive to query for a disc.
@return The status of the drive, or what kind of disc is in it.
Note: BURN_DISC_UNGRABBED indicates wrong API usage
*/
enum burn_disc_status burn_disc_get_status(struct burn_drive *drive);
@ -643,7 +652,7 @@ struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive);
*/
void burn_write_opts_free(struct burn_write_opts *opts);
/** Creates a write_opts struct for reading from the specified drive
/** Creates a read_opts struct for reading from the specified drive
must be freed with burn_write_opts_free
@param drive The drive to read from
@return The read_opts

7
libburn/libdax_msgs.h
View File

@ -309,6 +309,13 @@ Range "scdbackup" : 0x00020000 to 0x0002ffff
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
0x00020105 (SORRY,HIGH) = Drive is already released
0x00020106 (SORRY,HIGH) = Drive is busy on attempt to close
0x00020107 (SORRY,HIGH) = Drive is busy on attempt to shut down library
0x00020108 (SORRY,HIGH) = Drive is not grabbed on disc status inquiry
0x00020108 (FATAL,HIGH) = Could not allocate new drive object
0x00020109 (FATAL,HIGH) = Library not running
0x00020110 (FATAL,HIGH) = Persistent drive address too long
------------------------------------------------------------------------------

9
libburn/sg.c
View File

@ -450,6 +450,15 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
out.idata->valid = 0;
out.mdata = malloc(sizeof(struct scsi_mode_data));
out.mdata->valid = 0;
/* ts A61007 : obsolete assert() in drive_getcaps() */
if(out.idata == NULL || out.mdata == NULL) {
libdax_msgs_submit(libdax_messenger, -1, 0x00020108,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
"Could not allocate new drive object", 0, 0);
return;
}
memset(&out.params, 0, sizeof(struct params));
t = burn_drive_register(&out);