xfsdump: Ouchie! My bleeding eyes!

From: Dave Chinner <[email protected]>

ASSERT comes from the xfs/xfs.h include, and we don't ever define DEBUG so we never get asserts built in. We want asserts built in for testing, but not for distro packages. The debian package already tries to do this by using "export DEBUG=-DNDEBUG" for the build context, but seeing as we pull in #define ASSERT(ex) (0) from the XFS headers it's a no-op.

Convert all the ASSERT calls to assert to remove this conflict with the xfsprogs headers and so local developer builds are built with asserts enabled.

Signed-off-by Dave Chinner <[email protected]>

---

 common/arch_xlate.c     |   1 +
 common/cldmgr.c         |   3 +-
 common/cleanup.c        |   7 +-
 common/content_common.c |  13 +-
 common/content_inode.h  |   4 +-
 common/dlog.c           |  13 +-
 common/drive.c          |  17 ++-
 common/drive_minrmt.c   | 369 ++++++++++++++++++++++-----------------------
 common/drive_scsitape.c | 389 ++++++++++++++++++++++++------------------------
 common/drive_simple.c   | 151 +++++++++----------
 common/fs.c             |  23 +--
 common/global.c         |  13 +-
 common/hsmapi.c         |   1 +
 common/inventory.c      |  33 ++--
 common/lock.c           |   3 +-
 common/main.c           |  99 ++++++------
 common/media.c          |  21 +--
 common/mlog.c           |  21 +--
 common/openutil.c       |   3 +-
 common/path.c           |  25 ++--
 common/qlock.c          |  29 ++--
 common/ring.c           |  65 ++++----
 common/stream.c         |  15 +-
 common/util.c           |  41 ++---
 dump/content.c          | 239 ++++++++++++++---------------
 dump/inomap.c           |  19 +--
 inventory/inv_api.c     |  33 ++--
 inventory/inv_core.c    |   7 +-
 inventory/inv_files.c   |   9 +-
 inventory/inv_fstab.c   |   5 +-
 inventory/inv_idx.c     |  11 +-
 inventory/inv_mgr.c     |   7 +-
 inventory/inv_oref.c    |  51 +++----
 inventory/inv_oref.h    |  24 +--
 inventory/inv_stobj.c   |  23 +--
 inventory/testmain.c    |  25 ++--
 librmt/rmtioctl.c       |   1 +
 restore/bag.c           |  19 +--
 restore/content.c       | 309 +++++++++++++++++++-------------------
 restore/dirattr.c       | 113 +++++++-------
 restore/inomap.c        |  25 ++--
 restore/namreg.c        |  39 ++---
 restore/node.c          |  79 +++++-----
 restore/tree.c          | 219 +++++++++++++--------------
 restore/win.c           |  65 ++++----
 45 files changed, 1362 insertions(+), 1319 deletions(-)

common/arch_xlate.c +1 -0

index bafc1a6..e6f897e 100644
@@ -18,6 +18,7 @@
 
 #include <xfs/xfs.h>
 #include <xfs/jdm.h>
+#include <assert.h>
 
 #include "arch_xlate.h"
 #include "types.h"

common/cldmgr.c +2 -1

index be7de34..df33a3f 100644
@@ -25,6 +25,7 @@
 #include <sys/prctl.h>
 #include <errno.h>
 #include <pthread.h>
+#include <assert.h>
 
 #include "exit.h"
 #include "types.h"

@@ -79,7 +80,7 @@ cldmgr_create( int ( * entry )( void *arg1 ),
 	cld_t *cldp;
 	intgen_t rval;
 
-	ASSERT( pthread_equal( pthread_self( ), cldmgr_parenttid ) );
+	assert( pthread_equal( pthread_self( ), cldmgr_parenttid ) );
 
 	cldp = cldmgr_getcld( );
 	if ( ! cldp ) {

common/cleanup.c +4 -3

index 42e8750..523f164 100644
@@ -17,6 +17,7 @@
  */
 
 #include <stdlib.h>
+#include <assert.h>
 
 #include "cleanup.h"
 

@@ -51,7 +52,7 @@ cleanup_register_base( void ( * funcp )( void *arg1, void *arg2 ),
 	cu_t *p;
 
 	p = ( cu_t * )calloc( 1, sizeof( cu_t ));
-	ASSERT( p );
+	assert( p );
 	p->cu_funcp = funcp;
 	p->cu_arg1 = arg1;
 	p->cu_arg2 = arg2;

@@ -94,7 +95,7 @@ cleanup_cancel( cleanup_t *cleanupp )
 	cu_t *nextp;
 	cu_t *prevp;
 
-	ASSERT( cu_rootp );
+	assert( cu_rootp );
 
 	for ( prevp = 0, nextp = cu_rootp
 	      ;

@@ -103,7 +104,7 @@ cleanup_cancel( cleanup_t *cleanupp )
 	      prevp = nextp, nextp = nextp->cu_nextp )
 	;
 
-	ASSERT( nextp );
+	assert( nextp );
 	if ( prevp ) {
 		prevp->cu_nextp = p->cu_nextp;
 	} else {

common/content_common.c +7 -6

index 993ddae..65be31f 100644
@@ -24,6 +24,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <signal.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -66,7 +67,7 @@ retry:
 	preamblestr[ preamblecnt++ ] = "\n";
 	preamblestr[ preamblecnt++ ] = fold;
 	preamblestr[ preamblecnt++ ] = "\n\n";
-	ASSERT( preamblecnt <= PREAMBLEMAX );
+	assert( preamblecnt <= PREAMBLEMAX );
 	dlog_begin( preamblestr, preamblecnt );
 
 	/* query: ask if media changed or declined

@@ -77,13 +78,13 @@ retry:
 		 (unsigned int)drivep->d_index );
 	querycnt = 0;
 	querystr[ querycnt++ ] = question;
-	ASSERT( querycnt <= QUERYMAX );
+	assert( querycnt <= QUERYMAX );
 	choicecnt = 0;
 	dontix = choicecnt;
 	choicestr[ choicecnt++ ] = _("media change declined");
 	doix = choicecnt;
 	choicestr[ choicecnt++ ] = _("media changed");
-	ASSERT( choicecnt <= CHOICEMAX );
+	assert( choicecnt <= CHOICEMAX );
 	sigintix = IXMAX - 1;
 
 	responseix = dlog_multi_query( querystr,

@@ -105,11 +106,11 @@ retry:
 	} else if ( responseix == dontix ) {
 		ackstr[ ackcnt++ ] = _("media change aborted\n");
 	} else {
-		ASSERT( responseix == sigintix );
+		assert( responseix == sigintix );
 		ackstr[ ackcnt++ ] = _("keyboard interrupt\n");
 	}
 
-	ASSERT( ackcnt <= ACKMAX );
+	assert( ackcnt <= ACKMAX );
 	dlog_multi_ack( ackstr,
 			ackcnt );
 

@@ -118,7 +119,7 @@ retry:
 	postamblestr[ postamblecnt++ ] = "\n";
 	postamblestr[ postamblecnt++ ] = fold;
 	postamblestr[ postamblecnt++ ] = "\n\n";
-	ASSERT( postamblecnt <= POSTAMBLEMAX );
+	assert( postamblecnt <= POSTAMBLEMAX );
 	dlog_end( postamblestr,
 		  postamblecnt );
 

common/content_inode.h +2 -2

index 8f0390c..9013ca4 100644
@@ -389,7 +389,7 @@ calc_checksum(void *bufp, size_t len)
 	u_int32_t sum = 0;
 	u_int32_t *sump = bufp;
 	u_int32_t *endp = sump + len / sizeof(u_int32_t);
-	ASSERT(len % sizeof(u_int32_t) == 0);
+	assert(len % sizeof(u_int32_t) == 0);
 	while (sump < endp)
 		sum += *sump++;
 	return ~sum + 1;

@@ -401,7 +401,7 @@ is_checksum_valid(void *bufp, size_t len)
 	u_int32_t sum = 0;
 	u_int32_t *sump = bufp;
 	u_int32_t *endp = sump + len / sizeof(u_int32_t);
-	ASSERT(len % sizeof(u_int32_t) == 0);
+	assert(len % sizeof(u_int32_t) == 0);
 	while (sump < endp)
 		sum += *sump++;
 	return sum == 0 ? BOOL_TRUE : BOOL_FALSE;

common/dlog.c +7 -6

index ac0cafc..6220cfe 100644
@@ -26,6 +26,7 @@
 #include <time.h>
 #include <errno.h>
 #include <signal.h>
+#include <assert.h>
 
 #include "types.h"
 #include "mlog.h"

@@ -57,7 +58,7 @@ dlog_init( int argc, char *argv[ ] )
 
 	/* can only call once
 	 */
-	ASSERT( dlog_ttyfd == -1 );
+	assert( dlog_ttyfd == -1 );
 
 	/* initially allow dialog, use stdin fd
 	 */

@@ -104,7 +105,7 @@ dlog_init( int argc, char *argv[ ] )
 		struct stat statbuf;
 		int rval;
 
-		ASSERT( dlog_ttyfd >= 0 );
+		assert( dlog_ttyfd >= 0 );
 		rval = fstat( dlog_ttyfd, &statbuf );
 		if ( rval ) {
 			mlog( MLOG_VERBOSE | MLOG_WARNING,

@@ -186,7 +187,7 @@ dlog_multi_query( char *querystr[ ],
 
 	/* sanity
 	 */
-	ASSERT( dlog_allowed_flag );
+	assert( dlog_allowed_flag );
 
 	/* display query description strings
 	 */

@@ -295,7 +296,7 @@ dlog_string_query( dlog_ucbp_t ucb, /* user's print func */
 
 	/* sanity
 	 */
-	ASSERT( dlog_allowed_flag );
+	assert( dlog_allowed_flag );
 
 	/* call the caller's callback with his context, print context, and
 	 * print operator

@@ -359,7 +360,7 @@ dlog_string_query_print( void *ctxp, char *fmt, ... )
 {
 	va_list args;
 
-	ASSERT( ! ctxp );
+	assert( ! ctxp );
 
 	va_start( args, fmt );
 	mlog_va( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE, fmt, args );

@@ -510,7 +511,7 @@ promptinput( char *buf,
 		}
 		return BOOL_FALSE;
 	} else {
-		ASSERT( dlog_signo_received == -1 );
+		assert( dlog_signo_received == -1 );
 		*exceptionixp = 0;
 		return BOOL_TRUE;
 	}

common/drive.c +9 -8

index 32a7191..f9ba851 100644
@@ -21,6 +21,7 @@
 
 #include <sys/stat.h>
 #include <time.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -88,7 +89,7 @@ drive_init1( int argc, char *argv[ ] )
 
 	/* sanity check asserts
 	 */
-	ASSERT( sizeof( drive_hdr_t ) == DRIVE_HDR_SZ );
+	assert( sizeof( drive_hdr_t ) == DRIVE_HDR_SZ );
 
 	/* count drive arguments
 	 */

@@ -107,7 +108,7 @@ drive_init1( int argc, char *argv[ ] )
 	 */
 	if (drivecnt > 0) {
 		drivepp = ( drive_t ** )calloc( drivecnt, sizeof( drive_t * ));
-		ASSERT( drivepp );
+		assert( drivepp );
 	}
 
 	/* initialize the partialmax value.  Each drive can be completing a file

@@ -142,7 +143,7 @@ drive_init1( int argc, char *argv[ ] )
 			break;
 		}
 	}
-	ASSERT( driveix == drivecnt );
+	assert( driveix == drivecnt );
 
 	/* the user may specify stdin as the source, by
 	 * a single dash ('-') with no option letter. This must appear

@@ -169,7 +170,7 @@ drive_init1( int argc, char *argv[ ] )
 		 * allocate an array to hold ptrs to drive descriptors
 		 */
 		drivepp = ( drive_t ** )calloc( drivecnt, sizeof( drive_t * ));
-		ASSERT( drivepp );
+		assert( drivepp );
 
 		drivepp[ 0 ] = drive_alloc( "stdio", 0 );
 

@@ -215,7 +216,7 @@ drive_init1( int argc, char *argv[ ] )
 				bestscore = score;
 			}
 		}
-		ASSERT( bestsp );
+		assert( bestsp );
 		drivep->d_strategyp = bestsp;
 		drivep->d_recmarksep = bestsp->ds_recmarksep;
 		drivep->d_recmfilesz = bestsp->ds_recmfilesz;

@@ -356,7 +357,7 @@ drive_alloc( char *pathname, ix_t driveix )
 	/* allocate the descriptor
 	 */
 	drivep = ( drive_t * )calloc( 1, sizeof( drive_t ));
-	ASSERT( drivep );
+	assert( drivep );
 
 	/* convert the pathname to an absolute pathname
 	 * NOTE: string "stdio" is reserved to mean send to standard out

@@ -397,7 +398,7 @@ drive_allochdrs( drive_t *drivep, global_hdr_t *gwhdrtemplatep, ix_t driveix )
 	/* allocate the read header
 	 */
 	grhdrp = ( global_hdr_t * )calloc( 1, sizeof( global_hdr_t ));
-	ASSERT( grhdrp );
+	assert( grhdrp );
 	gwhdrp = NULL;
 	dwhdrp = NULL;
 

@@ -411,7 +412,7 @@ drive_allochdrs( drive_t *drivep, global_hdr_t *gwhdrtemplatep, ix_t driveix )
 		/* allocate the write header
 		 */
 		gwhdrp = ( global_hdr_t * )calloc( 1, sizeof( global_hdr_t ));
-		ASSERT( gwhdrp );
+		assert( gwhdrp );
 
 		/* copy the template
 		 */

common/drive_minrmt.c +185 -184

index 8c57699..6d58f1f 100644
@@ -29,6 +29,7 @@
 #include <sys/sysmacros.h>
 #include <malloc.h>
 #include <sched.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -471,11 +472,11 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 
 	/* opportunity for sanity checking
 	 */
-	ASSERT( sizeof( global_hdr_t ) <= STAPE_HDR_SZ );
-	ASSERT( sizeof( rec_hdr_t )
+	assert( sizeof( global_hdr_t ) <= STAPE_HDR_SZ );
+	assert( sizeof( rec_hdr_t )
 		==
 		sizeofmember( drive_hdr_t, dh_specific ));
-	ASSERT( ! ( STAPE_MAX_RECSZ % PGSZ ));
+	assert( ! ( STAPE_MAX_RECSZ % PGSZ ));
 
 	/* hook up the drive ops
 	 */

@@ -484,7 +485,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 	/* allocate context for the drive manager
 	 */
 	contextp = ( drive_context_t * )calloc( 1, sizeof( drive_context_t ));
-	ASSERT( contextp );
+	assert( contextp );
 	memset( ( void * )contextp, 0, sizeof( *contextp ));
 
 	/* do not enable a separate I/O thread,

@@ -583,7 +584,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 	 */
 	if ( contextp->dc_singlethreadedpr ) {
 		contextp->dc_bufp = ( char * )memalign( PGSZ, STAPE_MAX_RECSZ );
-		ASSERT( contextp->dc_bufp );
+		assert( contextp->dc_bufp );
 	} else {
 		intgen_t rval;
 		mlog( (MLOG_NITTY + 1) | MLOG_DRIVE,

@@ -611,7 +612,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 				      _("not allowed "
 				      "to pin down I/O buffer ring\n") );
 			} else {
-				ASSERT( 0 );
+				assert( 0 );
 			}
 			return BOOL_FALSE;
 		}

@@ -721,18 +722,18 @@ do_begin_read( drive_t *drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( drivep->d_capabilities & DRIVE_CAP_READ );
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( ! contextp->dc_recp );
+	assert( drivep->d_capabilities & DRIVE_CAP_READ );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( ! contextp->dc_recp );
 
 	/* get a record buffer to use during initialization.
 	 */
 	if ( contextp->dc_singlethreadedpr ) {
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
-		ASSERT( contextp->dc_ringp );
+		assert( contextp->dc_ringp );
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 

@@ -742,7 +743,7 @@ do_begin_read( drive_t *drivep )
 	 */
 	contextp->dc_iocnt = 0;
 	if ( contextp->dc_fd < 0 ) {
-		ASSERT( contextp->dc_fd == -1 );
+		assert( contextp->dc_fd == -1 );
 		rval = prepare_drive( drivep );
 		if ( rval ) {
 			if ( ! contextp->dc_singlethreadedpr ) {

@@ -763,7 +764,7 @@ do_begin_read( drive_t *drivep )
 			return rval;
 		}
 	}
-	ASSERT( contextp->dc_iocnt == 1 );
+	assert( contextp->dc_iocnt == 1 );
 					/* set by prepare_drive or read_label */
 
 	/* all is well. adjust context. don't kick off read-aheads just yet;

@@ -824,10 +825,10 @@ do_read( drive_t *drivep,
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( wantedcnt > 0 );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( wantedcnt > 0 );
 
 	/* clear the return status field
 	 */

@@ -853,7 +854,7 @@ do_read( drive_t *drivep,
 	 */
 	contextp->dc_ownedp = contextp->dc_nextp;
 	contextp->dc_nextp += actualcnt;
-	ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
+	assert( contextp->dc_nextp <= contextp->dc_dataendp );
 
 	mlog( MLOG_NITTY | MLOG_DRIVE,
 	      "rmt drive op read actual == %d (0x%x)\n",

@@ -886,16 +887,16 @@ do_return_read_buf( drive_t *drivep, char *bufp, size_t retcnt )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( contextp->dc_ownedp );
-	ASSERT( bufp == contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( contextp->dc_ownedp );
+	assert( bufp == contextp->dc_ownedp );
 
 	/* calculate how much the caller owns
 	 */
-	ASSERT( contextp->dc_nextp >= contextp->dc_ownedp );
+	assert( contextp->dc_nextp >= contextp->dc_ownedp );
 	ownedcnt = ( size_t )( contextp->dc_nextp - contextp->dc_ownedp );
-	ASSERT( ownedcnt == retcnt );
+	assert( ownedcnt == retcnt );
 
 	/* take possession of buffer portion
 	 */

@@ -905,7 +906,7 @@ do_return_read_buf( drive_t *drivep, char *bufp, size_t retcnt )
 	 * and (if ring in use) give buffer to ring for read-ahead.
 	 */
 	if ( contextp->dc_nextp >= contextp->dc_dataendp ) {
-		ASSERT( contextp->dc_nextp == contextp->dc_dataendp );
+		assert( contextp->dc_nextp == contextp->dc_dataendp );
 		if ( ! contextp->dc_singlethreadedpr ) {
 			contextp->dc_msgp->rm_op = RING_OP_READ;
 			Ring_put( contextp->dc_ringp, contextp->dc_msgp );

@@ -936,9 +937,9 @@ do_get_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 	/* the mark is simply the offset into the media file of the
 	 * next byte to be read.

@@ -977,9 +978,9 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 
 	/* the desired mark is passed by reference, and is really just an

@@ -1002,18 +1003,18 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		rec_hdr_t *rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 #endif
 
-		ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+		assert( contextp->dc_nextp >= contextp->dc_recp );
 		recoff = ( u_int32_t )( contextp->dc_nextp
 					-
 					contextp->dc_recp );
-		ASSERT( recoff <= tape_recsz );
-		ASSERT( rechdrp->rec_used <= tape_recsz );
-		ASSERT( recoff >= STAPE_HDR_SZ );
-		ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-		ASSERT( recoff <= rechdrp->rec_used );
+		assert( recoff <= tape_recsz );
+		assert( rechdrp->rec_used <= tape_recsz );
+		assert( recoff >= STAPE_HDR_SZ );
+		assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+		assert( recoff <= rechdrp->rec_used );
 		currentoffset += ( off64_t )recoff;
 	}
-	ASSERT( wantedoffset >= currentoffset );
+	assert( wantedoffset >= currentoffset );
 
 	/* if we are currently holding a record and the desired offset
 	 * is not within the current record, eat the current record.

@@ -1036,12 +1037,12 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			 * must be just after it.
 			 */
 			if ( rechdrp->rec_used < tape_recsz ) {
-				ASSERT( wantedoffset == nextrecoffset );
+				assert( wantedoffset == nextrecoffset );
 			}
 
 			/* figure how much to ask for
 			 */
-			ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+			assert( contextp->dc_nextp >= contextp->dc_recp );
 			recoff = ( u_int32_t )( contextp->dc_nextp
 						-
 						contextp->dc_recp );

@@ -1059,13 +1060,13 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			if ( rval ) {
 				return rval;
 			}
-			ASSERT( actualcnt == wantedcnt );
+			assert( actualcnt == wantedcnt );
 			do_return_read_buf( drivep, dummybufp, actualcnt );
 			currentoffset += ( off64_t )actualcnt;
-			ASSERT( currentoffset == nextrecoffset );
-			ASSERT( wantedoffset >= currentoffset );
-			ASSERT( ! contextp->dc_recp );
-			ASSERT( currentoffset
+			assert( currentoffset == nextrecoffset );
+			assert( wantedoffset >= currentoffset );
+			assert( ! contextp->dc_recp );
+			assert( currentoffset
 				==
 				contextp->dc_reccnt * ( off64_t )tape_recsz );
 		}

@@ -1084,14 +1085,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		off64_t wantedreccnt;
 		seekmode_t seekmode;
 
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 		wantedreccnt = wantedoffset / ( off64_t )tape_recsz;
 		if ( contextp->dc_singlethreadedpr ) {
 			seekmode = SEEKMODE_RAW;
 		} else {
 			seekmode = SEEKMODE_BUF;
 		}
-		ASSERT( wantedreccnt != 0 ); /* so NOP below can be
+		assert( wantedreccnt != 0 ); /* so NOP below can be
 					      * distinguished from use
 					      * in do_begin_read
 					      */

@@ -1101,7 +1102,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 
 			if ( seekmode == SEEKMODE_BUF ) {
 				ring_stat_t rs;
-				ASSERT( ! contextp->dc_msgp );
+				assert( ! contextp->dc_msgp );
 				contextp->dc_msgp =
 						Ring_get( contextp->dc_ringp );
 				rs = contextp->dc_msgp->rm_stat;

@@ -1114,7 +1115,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				     rs != RING_STAT_INIT
 				     &&
 				     rs != RING_STAT_NOPACK ) {
-					ASSERT( 0 );
+					assert( 0 );
 					contextp->dc_errorpr = BOOL_TRUE;
 					return DRIVE_ERROR_CORE;
 				}

@@ -1136,8 +1137,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				continue;
 			}
 
-			ASSERT( contextp->dc_reccnt == contextp->dc_iocnt );
-			ASSERT( wantedreccnt > contextp->dc_reccnt );
+			assert( contextp->dc_reccnt == contextp->dc_iocnt );
+			assert( wantedreccnt > contextp->dc_reccnt );
 			recskipcnt64 = wantedreccnt - contextp->dc_reccnt;
 			recskipcnt64remaining = recskipcnt64;
 			while ( recskipcnt64remaining ) {

@@ -1145,14 +1146,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				intgen_t saved_errno;
 				intgen_t rval;
 
-				ASSERT( recskipcnt64remaining > 0 );
+				assert( recskipcnt64remaining > 0 );
 				if ( recskipcnt64remaining > INTGENMAX ) {
 					recskipcnt = INTGENMAX;
 				} else {
 					recskipcnt = ( intgen_t )
 						     recskipcnt64remaining;
 				}
-				ASSERT( recskipcnt > 0 );
+				assert( recskipcnt > 0 );
 				rval = mt_op( contextp->dc_fd,
 					      MTFSR,
 					      recskipcnt );

@@ -1174,8 +1175,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			currentoffset = contextp->dc_reccnt
 					*
 					( off64_t )tape_recsz;
-			ASSERT( wantedoffset >= currentoffset );
-			ASSERT( wantedoffset - currentoffset
+			assert( wantedoffset >= currentoffset );
+			assert( wantedoffset - currentoffset
 				<
 				( off64_t )tape_recsz );
 		}

@@ -1190,7 +1191,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		size_t actualcnt;
 		intgen_t rval;
 
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 
 		/* figure how much to ask for. to eat an entire record,
 		 * ask for a record sans the header. do_read will eat

@@ -1205,11 +1206,11 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		if ( rval ) {
 			return rval;
 		}
-		ASSERT( actualcnt == wantedcnt );
+		assert( actualcnt == wantedcnt );
 		do_return_read_buf( drivep, dummybufp, actualcnt );
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 		currentoffset += ( off64_t )tape_recsz;
-		ASSERT( currentoffset
+		assert( currentoffset
 			==
 			contextp->dc_reccnt * ( off64_t )tape_recsz );
 	}

@@ -1222,8 +1223,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		char *dummybufp;
 		size_t actualcnt;
 
-		ASSERT( wantedoffset > currentoffset );
-		ASSERT( wantedoffset - currentoffset < ( off64_t )tape_recsz );
+		assert( wantedoffset > currentoffset );
+		assert( wantedoffset - currentoffset < ( off64_t )tape_recsz );
 		wantedcnt = ( size_t )( wantedoffset - currentoffset );
 		if ( contextp->dc_recp ) {
 			u_int32_t recoff;

@@ -1233,14 +1234,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			recoff = ( u_int32_t )( contextp->dc_nextp
 						-
 						contextp->dc_recp );
-			ASSERT( recoff <= tape_recsz );
-			ASSERT( rechdrp->rec_used <= tape_recsz );
-			ASSERT( recoff >= STAPE_HDR_SZ );
-			ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-			ASSERT( recoff <= rechdrp->rec_used );
-			ASSERT( recoff + wantedcnt <= rechdrp->rec_used );
+			assert( recoff <= tape_recsz );
+			assert( rechdrp->rec_used <= tape_recsz );
+			assert( recoff >= STAPE_HDR_SZ );
+			assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+			assert( recoff <= rechdrp->rec_used );
+			assert( recoff + wantedcnt <= rechdrp->rec_used );
 		} else {
-			ASSERT( wantedcnt >= STAPE_HDR_SZ );
+			assert( wantedcnt >= STAPE_HDR_SZ );
 			wantedcnt -= STAPE_HDR_SZ;
 		}
 

@@ -1253,7 +1254,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		    if ( rval ) {
 			    return rval;
 		    }
-		    ASSERT( actualcnt == wantedcnt );
+		    assert( actualcnt == wantedcnt );
 		    do_return_read_buf( drivep, dummybufp, actualcnt );
 		}
 	}

@@ -1268,18 +1269,18 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		rec_hdr_t *rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 #endif
 
-		ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+		assert( contextp->dc_nextp >= contextp->dc_recp );
 		recoff = ( u_int32_t )( contextp->dc_nextp
 					-
 					contextp->dc_recp );
-		ASSERT( recoff <= tape_recsz );
-		ASSERT( rechdrp->rec_used <= tape_recsz );
-		ASSERT( recoff >= STAPE_HDR_SZ );
-		ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-		ASSERT( recoff <= rechdrp->rec_used );
+		assert( recoff <= tape_recsz );
+		assert( rechdrp->rec_used <= tape_recsz );
+		assert( recoff >= STAPE_HDR_SZ );
+		assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+		assert( recoff <= rechdrp->rec_used );
 		currentoffset += ( off64_t )recoff;
 	}
-	ASSERT( wantedoffset == currentoffset );
+	assert( wantedoffset == currentoffset );
 
 	return 0;
 }

@@ -1310,9 +1311,9 @@ do_next_mark( drive_t *drivep )
 
 	/* assert protocol being followed.
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "rmt drive op: next mark\n" );

@@ -1335,7 +1336,7 @@ noerrorsearch:
 		}
 		rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 
-		ASSERT( rechdrp->first_mark_offset != 0 );
+		assert( rechdrp->first_mark_offset != 0 );
 		if ( rechdrp->first_mark_offset > 0 ) {
 			 off64_t markoff = rechdrp->first_mark_offset
 					   -

@@ -1343,8 +1344,8 @@ noerrorsearch:
 			 off64_t curoff = ( off64_t )( contextp->dc_nextp
 						       -
 						       contextp->dc_recp );
-			 ASSERT( markoff > 0 );
-			 ASSERT( curoff > 0 );
+			 assert( markoff > 0 );
+			 assert( curoff > 0 );
 			 if ( markoff >= curoff ) {
 				break;
 			}

@@ -1359,7 +1360,7 @@ noerrorsearch:
 		contextp->dc_reccnt++;
 	}
 
-	ASSERT( rechdrp->first_mark_offset - rechdrp->file_offset
+	assert( rechdrp->first_mark_offset - rechdrp->file_offset
 		<=
 		( off64_t )tape_recsz );
 	contextp->dc_nextp = contextp->dc_recp

@@ -1367,8 +1368,8 @@ noerrorsearch:
 			     ( size_t )( rechdrp->first_mark_offset
 					 -
 					 rechdrp->file_offset );
-	ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
-	ASSERT( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
+	assert( contextp->dc_nextp <= contextp->dc_dataendp );
+	assert( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
 	if ( contextp->dc_nextp == contextp->dc_dataendp ) {
 		if ( ! contextp->dc_singlethreadedpr ) {
 			Ring_put( contextp->dc_ringp,

@@ -1394,7 +1395,7 @@ resetring:
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 	rechdrp = ( rec_hdr_t * )contextp->dc_recp;

@@ -1417,7 +1418,7 @@ validateread:
 	}
 
 	if ( nread >= 0 ) {
-		ASSERT( ( size_t )nread <= tape_recsz );
+		assert( ( size_t )nread <= tape_recsz );
 		mlog( MLOG_DEBUG | MLOG_DRIVE,
 		      "short read (nread == %d, record size == %d)\n",
 		      nread,

@@ -1460,24 +1461,24 @@ validatehdr:
 		goto readrecord;
 	}
 
-	ASSERT( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
+	assert( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
 	markoff = rechdrp->first_mark_offset - rechdrp->file_offset;
-	ASSERT( markoff >= ( off64_t )STAPE_HDR_SZ );
-	ASSERT( markoff < ( off64_t )tape_recsz );
-	ASSERT( rechdrp->rec_used > STAPE_HDR_SZ );
-	ASSERT( rechdrp->rec_used < tape_recsz );
+	assert( markoff >= ( off64_t )STAPE_HDR_SZ );
+	assert( markoff < ( off64_t )tape_recsz );
+	assert( rechdrp->rec_used > STAPE_HDR_SZ );
+	assert( rechdrp->rec_used < tape_recsz );
 
 	goto alliswell;
 
 alliswell:
 	contextp->dc_nextp = contextp->dc_recp + ( size_t )markoff;
-	ASSERT( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
+	assert( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
 	contextp->dc_reccnt = rechdrp->file_offset / ( off64_t )tape_recsz;
 	contextp->dc_iocnt = contextp->dc_reccnt + 1;
 	contextp->dc_recendp = contextp->dc_recp + tape_recsz;
 	contextp->dc_dataendp = contextp->dc_recp + rechdrp->rec_used;
-	ASSERT( contextp->dc_dataendp <= contextp->dc_recendp );
-	ASSERT( contextp->dc_nextp < contextp->dc_dataendp );
+	assert( contextp->dc_dataendp <= contextp->dc_recendp );
+	assert( contextp->dc_nextp < contextp->dc_dataendp );
 	contextp->dc_errorpr = BOOL_FALSE;
 
 	mlog( MLOG_NORMAL | MLOG_DRIVE,

@@ -1553,8 +1554,8 @@ do_end_read( drive_t *drivep )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
 
 	/* In the scsi version, read_label() does a status command to the
 	 * drive to then decide if doing a 'fsf' is appropriate.  For minrmt,

@@ -1608,9 +1609,9 @@ do_begin_write( drive_t *drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( ! drivep->d_markrecheadp );
-	ASSERT( ! contextp->dc_recp );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( ! drivep->d_markrecheadp );
+	assert( ! contextp->dc_recp );
 
 	/* get pointers into global write header
 	 */

@@ -1621,7 +1622,7 @@ do_begin_write( drive_t *drivep )
 	/* must already be open. The only way to open is to do a begin_read.
 	 * so all interaction with tape requires reading first.
 	 */
-	ASSERT( contextp->dc_fd != -1 );
+	assert( contextp->dc_fd != -1 );
 
 	/* fill in write header's drive specific info
 	 */

@@ -1637,15 +1638,15 @@ do_begin_write( drive_t *drivep )
 	/* get a record buffer. will be used for the media file header,
 	 * and is needed to "prime the pump" for first call to do_write.
 	 */
-	ASSERT( ! contextp->dc_recp );
+	assert( ! contextp->dc_recp );
 	if ( contextp->dc_singlethreadedpr ) {
-		ASSERT( contextp->dc_bufp );
+		assert( contextp->dc_bufp );
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
-		ASSERT( contextp->dc_ringp );
-		ASSERT( ! contextp->dc_msgp );
+		assert( contextp->dc_ringp );
+		assert( ! contextp->dc_msgp );
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 

@@ -1690,7 +1691,7 @@ do_begin_write( drive_t *drivep )
 	/* prepare the drive context. must have a record buffer ready to
 	 * go, header initialized.
 	 */
-	ASSERT( ! contextp->dc_ownedp );
+	assert( ! contextp->dc_ownedp );
 	contextp->dc_reccnt = 1; /* count the header record */
 	contextp->dc_recendp = contextp->dc_recp + tape_recsz;
 	contextp->dc_nextp = contextp->dc_recp + STAPE_HDR_SZ;

@@ -1735,15 +1736,15 @@ do_set_mark( drive_t *drivep,
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
 
 	/* calculate and fill in the mark record offset
 	 */
-	ASSERT( contextp->dc_recp );
+	assert( contextp->dc_recp );
 	nextoff = contextp->dc_reccnt * ( off64_t )tape_recsz
 		  +
 		  ( off64_t )( contextp->dc_nextp - contextp->dc_recp );

@@ -1758,7 +1759,7 @@ do_set_mark( drive_t *drivep,
 	 */
 	rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 	if ( rechdrp->first_mark_offset == -1LL ) {
-		ASSERT( nextoff != -1LL );
+		assert( nextoff != -1LL );
 		rechdrp->first_mark_offset = nextoff;
 	}
 

@@ -1771,7 +1772,7 @@ do_set_mark( drive_t *drivep,
 		drivep->d_markrecheadp = markrecp;
 		drivep->d_markrectailp = markrecp;
 	} else {
-		ASSERT( drivep->d_markrectailp );
+		assert( drivep->d_markrectailp );
 		drivep->d_markrectailp->dm_nextp = markrecp;
 		drivep->d_markrectailp = markrecp;
 	}

@@ -1798,12 +1799,12 @@ do_get_write_buf( drive_t *drivep, size_t wantedcnt, size_t *actualcntp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* figure how much is available; supply the min of what is
 	 * available and what is wanted.

@@ -1864,17 +1865,17 @@ do_write( drive_t *drivep, char *bufp, size_t retcnt )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp <= contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp <= contextp->dc_recendp );
 
 	/* verify the caller is returning exactly what is held
 	 */
-	ASSERT( bufp == contextp->dc_ownedp );
-	ASSERT( retcnt == heldcnt );
+	assert( bufp == contextp->dc_ownedp );
+	assert( retcnt == heldcnt );
 
 	/* take it back
 	 */

@@ -1915,7 +1916,7 @@ do_write( drive_t *drivep, char *bufp, size_t retcnt )
 			rval = contextp->dc_msgp->rm_rval;
 			break;
 		default:
-			ASSERT( 0 );
+			assert( 0 );
 			return DRIVE_ERROR_CORE;
 		}
 	}

@@ -1979,12 +1980,12 @@ do_get_align_cnt( drive_t * drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* calculate the next alignment point at or beyond the current nextp.
 	 * the following algorithm works because all buffers are page-aligned

@@ -1994,11 +1995,11 @@ do_get_align_cnt( drive_t * drivep )
 	next_alignment_off +=  PGMASK;
 	next_alignment_off &= ~PGMASK;
 	next_alignment_point = ( char * )next_alignment_off;
-	ASSERT( next_alignment_point <= contextp->dc_recendp );
+	assert( next_alignment_point <= contextp->dc_recendp );
 
 	/* return the number of bytes to the next alignment offset
 	 */
-	ASSERT( next_alignment_point >= contextp->dc_nextp );
+	assert( next_alignment_point >= contextp->dc_nextp );
 	return ( size_t )( next_alignment_point - contextp->dc_nextp );
 }
 

@@ -2025,12 +2026,12 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* pre-initialize return of count of bytes committed to media
 	 */

@@ -2072,7 +2073,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 					     contextp->dc_recp,
 					     BOOL_TRUE, BOOL_TRUE );
 		} else {
-			ASSERT( contextp->dc_msgp );
+			assert( contextp->dc_msgp );
 			contextp->dc_msgp->rm_op = RING_OP_WRITE;
 			contextp->dc_msgp->rm_user = contextp->dc_reccnt;
 			Ring_put( contextp->dc_ringp,

@@ -2088,7 +2089,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 				rval = contextp->dc_msgp->rm_rval;
 				break;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_recp = 0;
 				return DRIVE_ERROR_CORE;
 			}

@@ -2115,7 +2116,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 	}
 	if ( ! contextp->dc_singlethreadedpr ) {
 		while ( ! rval ) {
-			ASSERT( contextp->dc_msgp );
+			assert( contextp->dc_msgp );
 			contextp->dc_msgp->rm_op = RING_OP_TRACE;
 			Ring_put( contextp->dc_ringp,
 				  contextp->dc_msgp );

@@ -2127,14 +2128,14 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 			switch( contextp->dc_msgp->rm_stat ) {
 			case RING_STAT_OK:
 			case RING_STAT_INIT:
-				ASSERT( rval == 0 );
+				assert( rval == 0 );
 				break;
 			case RING_STAT_ERROR:
 				rval = contextp->dc_msgp->rm_rval;
 				first_rec_w_err = contextp->dc_msgp->rm_user;
 				break;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_recp = 0;
 				return DRIVE_ERROR_CORE;
 			}

@@ -2182,11 +2183,11 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 	 * to tape.
 	 */
 	if ( rval ) {
-		ASSERT( first_rec_w_err >= 0 );
+		assert( first_rec_w_err >= 0 );
 		recs_wtn_wo_err = first_rec_w_err;
 		recs_guaranteed = recs_wtn_wo_err - contextp->dc_lostrecmax;
 	} else {
-		ASSERT( first_rec_w_err == -1 );
+		assert( first_rec_w_err == -1 );
 		recs_wtn_wo_err = contextp->dc_iocnt;
 		recs_guaranteed = recs_wtn_wo_err;
 	}

@@ -2217,14 +2218,14 @@ do_fsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_mode == OM_NONE );
 
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "rmt drive op: fsf: count %d\n",
 	      count );
 
-	ASSERT( count );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( count );
+	assert( contextp->dc_mode == OM_NONE );
 
 	for ( i = 0 ; i < count; i++ ) {
 		done = 0;

@@ -2243,7 +2244,7 @@ do_fsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 			      _("advancing tape to next media file\n") );
 
 			op_failed = 0;
-			ASSERT( contextp->dc_fd >= 0 );
+			assert( contextp->dc_fd >= 0 );
 			if ( mt_op( contextp->dc_fd, MTFSF, 1 ) ) {
 				op_failed = 1;
 			}

@@ -2294,14 +2295,14 @@ do_bsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 	      "rmt drive op: bsf: count %d\n",
 	      count );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_mode == OM_NONE );
 
 	*statp = 0;
 
 	/* back space - places us to left of previous file mark
 	 * if we hit BOT, return
 	 */
-	ASSERT( drivep->d_capabilities & DRIVE_CAP_BSF );
+	assert( drivep->d_capabilities & DRIVE_CAP_BSF );
 	rval = bsf_and_verify( drivep );
 	if (rval) {
 		if (errno == ENOSPC/*IRIX*/ || errno == EIO/*Linux*/) {

@@ -2379,8 +2380,8 @@ do_rewind( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "rmt drive op: rewind\n" );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
 
 	/* use validating tape rewind util func
 	 */

@@ -2405,8 +2406,8 @@ do_erase( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "rmt drive op: erase\n" );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
 
 	/* use validating tape rewind util func
 	 */

@@ -2443,8 +2444,8 @@ do_eject_media( drive_t *drivep )
 
 	/* drive must be open
 	 */
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
 
 	/* issue tape unload
 	 */

@@ -2563,7 +2564,7 @@ read_label( drive_t *drivep )
 	/* if a read error, get status
 	 */
 	if ( nread != ( intgen_t )tape_recsz ) {
-		ASSERT( nread < ( intgen_t )tape_recsz );
+		assert( nread < ( intgen_t )tape_recsz );
 	} 
 
 	/* check for an unexpected errno

@@ -2720,7 +2721,7 @@ get_tpcaps( drive_t *drivep )
 #ifdef DEBUG
 	drive_context_t	*contextp = ( drive_context_t * )drivep->d_contextp;
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 #endif
 
 	/* can't ask about blksz, can't set blksz, can't ask about

@@ -2796,7 +2797,7 @@ mt_op(intgen_t fd, intgen_t sub_op, intgen_t param )
 	mop.mt_op   	= (short )sub_op;
 	mop.mt_count	= param;
 
-	ASSERT( fd >= 0 );
+	assert( fd >= 0 );
 
 	switch ( sub_op ) {
 	case MTSEEK:

@@ -3074,7 +3075,7 @@ prepare_drive( drive_t *drivep )
 
 	/* shouldn't be here if drive is open
 	 */
-	ASSERT( contextp->dc_fd == -1 );
+	assert( contextp->dc_fd == -1 );
 
 	mlog( MLOG_VERBOSE | MLOG_DRIVE,
 	      _("preparing drive\n") );

@@ -3181,7 +3182,7 @@ prepare_drive( drive_t *drivep )
 			      contextp->dc_recp,
 			      tape_recsz,
 			      &saved_errno );
-		ASSERT( saved_errno == 0 || nread < 0 );
+		assert( saved_errno == 0 || nread < 0 );
 
 		/* RMT can require a retry
 		 */

@@ -3340,7 +3341,7 @@ checkhdr:
 			rec_hdr_t *tprhdrp;
 			drhdrp = drivep->d_readhdrp;
 			tprhdrp = ( rec_hdr_t * )drhdrp->dh_specific;
-			ASSERT( tprhdrp->recsize >= 0 );
+			assert( tprhdrp->recsize >= 0 );
 			tape_recsz = ( size_t )tprhdrp->recsize;
 			break;
 		}

@@ -3410,7 +3411,7 @@ Open( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: opening drive\n" );
 
-	ASSERT( contextp->dc_fd == -1 );
+	assert( contextp->dc_fd == -1 );
 
 	errno = 0;
 	contextp->dc_fd = open( drivep->d_pathname, oflags );

@@ -3430,7 +3431,7 @@ Close( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: closing drive\n" );
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 
 	( void )close( contextp->dc_fd );
 

@@ -3447,8 +3448,8 @@ Read( drive_t *drivep, char *bufp, size_t cnt, intgen_t *errnop )
 	      "tape op: reading %u bytes\n",
 	      cnt );
 
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( bufp );
+	assert( contextp->dc_fd >= 0 );
+	assert( bufp );
 	*errnop = 0;
 	errno = 0;
 	nread = read( contextp->dc_fd, ( void * )bufp, cnt );

@@ -3483,8 +3484,8 @@ Write( drive_t *drivep, char *bufp, size_t cnt, intgen_t *errnop )
 	      "tape op: writing %u bytes\n",
 	      cnt );
 
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( bufp );
+	assert( contextp->dc_fd >= 0 );
+	assert( bufp );
 	*errnop = 0;
 	errno = 0;
 	nwritten = write( contextp->dc_fd, ( void * )bufp, cnt );

@@ -3664,7 +3665,7 @@ read_record(  drive_t *drivep, char *bufp )
 	/* short read
 	 */
 	if ( nread >= 0 ) {
-		ASSERT( nread <= ( intgen_t )tape_recsz );
+		assert( nread <= ( intgen_t )tape_recsz );
 		mlog( MLOG_DEBUG | MLOG_DRIVE,
 		      "short read record %lld (nread == %d)\n",
 		      contextp->dc_iocnt,

@@ -3726,7 +3727,7 @@ getrec( drive_t *drivep )
 				contextp->dc_errorpr = BOOL_TRUE;
 				return contextp->dc_msgp->rm_rval;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_errorpr = BOOL_TRUE;
 				return DRIVE_ERROR_CORE;
 			}

@@ -3739,7 +3740,7 @@ getrec( drive_t *drivep )
 		contextp->dc_nextp = contextp->dc_recp
 				     +
 				     STAPE_HDR_SZ;
-		ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
+		assert( contextp->dc_nextp <= contextp->dc_dataendp );
 	}
 
 	return 0;

@@ -3775,7 +3776,7 @@ write_record(  drive_t *drivep, char *bufp, bool_t chksumpr, bool_t xlatepr )
 	}
 
 	rval = determine_write_error( nwritten, saved_errno );
-	ASSERT(rval);
+	assert(rval);
 
 	return rval;
 }

@@ -3814,7 +3815,7 @@ Ring_reset(  ring_t *ringp, ring_msg_t *msgp )
 	mlog( (MLOG_NITTY + 1) | MLOG_DRIVE,
 	      "ring op: reset\n" );
 
-	ASSERT( ringp );
+	assert( ringp );
 
 	ring_reset( ringp, msgp );
 }

@@ -3845,14 +3846,14 @@ display_ring_metrics( drive_t *drivep, intgen_t mlog_flags )
 	char *bufszsfxp;
 
 	if ( tape_recsz == STAPE_MIN_MAX_BLKSZ ) {
-		ASSERT( ! ( STAPE_MIN_MAX_BLKSZ % 0x400 ));
+		assert( ! ( STAPE_MIN_MAX_BLKSZ % 0x400 ));
 		sprintf( bufszbuf, "%u", STAPE_MIN_MAX_BLKSZ / 0x400 );
-		ASSERT( strlen( bufszbuf ) < sizeof( bufszbuf ));
+		assert( strlen( bufszbuf ) < sizeof( bufszbuf ));
 		bufszsfxp = _("KB");
 	} else if ( tape_recsz == STAPE_MAX_RECSZ ) {
-		ASSERT( ! ( STAPE_MAX_RECSZ % 0x100000 ));
+		assert( ! ( STAPE_MAX_RECSZ % 0x100000 ));
 		sprintf( bufszbuf, "%u", STAPE_MAX_RECSZ / 0x100000 );
-		ASSERT( strlen( bufszbuf ) < sizeof( bufszbuf ));
+		assert( strlen( bufszbuf ) < sizeof( bufszbuf ));
 		bufszsfxp = _("MB");
 	} else {
 		sprintf( bufszbuf, "%u", (unsigned int)(tape_recsz / 0x400) );

common/drive_scsitape.c +195 -194

index 0abb5d0..3f45d01 100644
@@ -29,6 +29,7 @@
 #include <sys/sysmacros.h>
 #include <malloc.h>
 #include <sched.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -551,11 +552,11 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 
 	/* opportunity for sanity checking
 	 */
-	ASSERT( sizeof( global_hdr_t ) <= STAPE_HDR_SZ );
-	ASSERT( sizeof( rec_hdr_t )
+	assert( sizeof( global_hdr_t ) <= STAPE_HDR_SZ );
+	assert( sizeof( rec_hdr_t )
 		==
 		sizeofmember( drive_hdr_t, dh_specific ));
-	ASSERT( ! ( STAPE_MAX_RECSZ % PGSZ ));
+	assert( ! ( STAPE_MAX_RECSZ % PGSZ ));
 
 	/* hook up the drive ops
 	 */

@@ -564,7 +565,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 	/* allocate context for the drive manager
 	 */
 	contextp = ( drive_context_t * )calloc( 1, sizeof( drive_context_t ));
-	ASSERT( contextp );
+	assert( contextp );
 	memset( ( void * )contextp, 0, sizeof( *contextp ));
 
 	/* do not enable a separate I/O thread,

@@ -673,7 +674,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 	 */
 	if ( contextp->dc_singlethreadedpr ) {
 		contextp->dc_bufp = ( char * )memalign( PGSZ, STAPE_MAX_RECSZ );
-		ASSERT( contextp->dc_bufp );
+		assert( contextp->dc_bufp );
 	} else {
 		intgen_t rval;
 		mlog( (MLOG_NITTY + 1) | MLOG_DRIVE,

@@ -701,7 +702,7 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 				      _("not allowed "
 				      "to pin down I/O buffer ring\n") );
 			} else {
-				ASSERT( 0 );
+				assert( 0 );
 			}
 			return BOOL_FALSE;
 		}

@@ -834,18 +835,18 @@ do_begin_read( drive_t *drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( drivep->d_capabilities & DRIVE_CAP_READ );
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( ! contextp->dc_recp );
+	assert( drivep->d_capabilities & DRIVE_CAP_READ );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( ! contextp->dc_recp );
 
 	/* get a record buffer to use during initialization.
 	 */
 	if ( contextp->dc_singlethreadedpr ) {
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
-		ASSERT( contextp->dc_ringp );
+		assert( contextp->dc_ringp );
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 

@@ -855,7 +856,7 @@ do_begin_read( drive_t *drivep )
 	 */
 	contextp->dc_iocnt = 0;
 	if ( contextp->dc_fd < 0 ) {
-		ASSERT( contextp->dc_fd == -1 );
+		assert( contextp->dc_fd == -1 );
 		rval = prepare_drive( drivep );
 		if ( rval ) {
 			if ( ! contextp->dc_singlethreadedpr ) {

@@ -876,7 +877,7 @@ do_begin_read( drive_t *drivep )
 			return rval;
 		}
 	}
-	ASSERT( contextp->dc_iocnt == 1 );
+	assert( contextp->dc_iocnt == 1 );
 					/* set by prepare_drive or read_label */
 
 	/* all is well. adjust context. don't kick off read-aheads just yet;

@@ -937,10 +938,10 @@ do_read( drive_t *drivep,
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( wantedcnt > 0 );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( wantedcnt > 0 );
 
 	/* clear the return status field
 	 */

@@ -966,7 +967,7 @@ do_read( drive_t *drivep,
 	 */
 	contextp->dc_ownedp = contextp->dc_nextp;
 	contextp->dc_nextp += actualcnt;
-	ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
+	assert( contextp->dc_nextp <= contextp->dc_dataendp );
 
 	mlog( MLOG_NITTY | MLOG_DRIVE,
 	      "drive op read actual == %d (0x%x)\n",

@@ -999,16 +1000,16 @@ do_return_read_buf( drive_t *drivep, char *bufp, size_t retcnt )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( contextp->dc_ownedp );
-	ASSERT( bufp == contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( contextp->dc_ownedp );
+	assert( bufp == contextp->dc_ownedp );
 
 	/* calculate how much the caller owns
 	 */
-	ASSERT( contextp->dc_nextp >= contextp->dc_ownedp );
+	assert( contextp->dc_nextp >= contextp->dc_ownedp );
 	ownedcnt = ( size_t )( contextp->dc_nextp - contextp->dc_ownedp );
-	ASSERT( ownedcnt == retcnt );
+	assert( ownedcnt == retcnt );
 
 	/* take possession of buffer portion
 	 */

@@ -1018,7 +1019,7 @@ do_return_read_buf( drive_t *drivep, char *bufp, size_t retcnt )
 	 * and (if ring in use) give buffer to ring for read-ahead.
 	 */
 	if ( contextp->dc_nextp >= contextp->dc_dataendp ) {
-		ASSERT( contextp->dc_nextp == contextp->dc_dataendp );
+		assert( contextp->dc_nextp == contextp->dc_dataendp );
 		if ( ! contextp->dc_singlethreadedpr ) {
 			contextp->dc_msgp->rm_op = RING_OP_READ;
 			Ring_put( contextp->dc_ringp, contextp->dc_msgp );

@@ -1049,9 +1050,9 @@ do_get_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 	/* the mark is simply the offset into the media file of the
 	 * next byte to be read.

@@ -1090,9 +1091,9 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 
 	/* the desired mark is passed by reference, and is really just an

@@ -1115,18 +1116,18 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		rec_hdr_t *rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 #endif
 
-		ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+		assert( contextp->dc_nextp >= contextp->dc_recp );
 		recoff = ( u_int32_t )( contextp->dc_nextp
 					-
 					contextp->dc_recp );
-		ASSERT( recoff <= tape_recsz );
-		ASSERT( rechdrp->rec_used <= tape_recsz );
-		ASSERT( recoff >= STAPE_HDR_SZ );
-		ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-		ASSERT( recoff <= rechdrp->rec_used );
+		assert( recoff <= tape_recsz );
+		assert( rechdrp->rec_used <= tape_recsz );
+		assert( recoff >= STAPE_HDR_SZ );
+		assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+		assert( recoff <= rechdrp->rec_used );
 		currentoffset += ( off64_t )recoff;
 	}
-	ASSERT( wantedoffset >= currentoffset );
+	assert( wantedoffset >= currentoffset );
 
 	/* if we are currently holding a record and the desired offset
 	 * is not within the current record, eat the current record.

@@ -1149,12 +1150,12 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			 * must be just after it.
 			 */
 			if ( rechdrp->rec_used < tape_recsz ) {
-				ASSERT( wantedoffset == nextrecoffset );
+				assert( wantedoffset == nextrecoffset );
 			}
 
 			/* figure how much to ask for
 			 */
-			ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+			assert( contextp->dc_nextp >= contextp->dc_recp );
 			recoff = ( u_int32_t )( contextp->dc_nextp
 						-
 						contextp->dc_recp );

@@ -1172,13 +1173,13 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			if ( rval ) {
 				return rval;
 			}
-			ASSERT( actualcnt == wantedcnt );
+			assert( actualcnt == wantedcnt );
 			do_return_read_buf( drivep, dummybufp, actualcnt );
 			currentoffset += ( off64_t )actualcnt;
-			ASSERT( currentoffset == nextrecoffset );
-			ASSERT( wantedoffset >= currentoffset );
-			ASSERT( ! contextp->dc_recp );
-			ASSERT( currentoffset
+			assert( currentoffset == nextrecoffset );
+			assert( wantedoffset >= currentoffset );
+			assert( ! contextp->dc_recp );
+			assert( currentoffset
 				==
 				contextp->dc_reccnt * ( off64_t )tape_recsz );
 		}

@@ -1197,14 +1198,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		off64_t wantedreccnt;
 		seekmode_t seekmode;
 
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 		wantedreccnt = wantedoffset / ( off64_t )tape_recsz;
 		if ( contextp->dc_singlethreadedpr ) {
 			seekmode = SEEKMODE_RAW;
 		} else {
 			seekmode = SEEKMODE_BUF;
 		}
-		ASSERT( wantedreccnt != 0 ); /* so NOP below can be
+		assert( wantedreccnt != 0 ); /* so NOP below can be
 					      * distinguished from use
 					      * in do_begin_read
 					      */

@@ -1214,7 +1215,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 
 			if ( seekmode == SEEKMODE_BUF ) {
 				ring_stat_t rs;
-				ASSERT( ! contextp->dc_msgp );
+				assert( ! contextp->dc_msgp );
 				contextp->dc_msgp =
 						Ring_get( contextp->dc_ringp );
 				rs = contextp->dc_msgp->rm_stat;

@@ -1227,7 +1228,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				     rs != RING_STAT_INIT
 				     &&
 				     rs != RING_STAT_NOPACK ) {
-					ASSERT( 0 );
+					assert( 0 );
 					contextp->dc_errorpr = BOOL_TRUE;
 					return DRIVE_ERROR_CORE;
 				}

@@ -1249,8 +1250,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				continue;
 			}
 
-			ASSERT( contextp->dc_reccnt == contextp->dc_iocnt );
-			ASSERT( wantedreccnt > contextp->dc_reccnt );
+			assert( contextp->dc_reccnt == contextp->dc_iocnt );
+			assert( wantedreccnt > contextp->dc_reccnt );
 			recskipcnt64 = wantedreccnt - contextp->dc_reccnt;
 			recskipcnt64remaining = recskipcnt64;
 			while ( recskipcnt64remaining ) {

@@ -1258,14 +1259,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 				intgen_t saved_errno;
 				intgen_t rval;
 
-				ASSERT( recskipcnt64remaining > 0 );
+				assert( recskipcnt64remaining > 0 );
 				if ( recskipcnt64remaining > INTGENMAX ) {
 					recskipcnt = INTGENMAX;
 				} else {
 					recskipcnt = ( intgen_t )
 						     recskipcnt64remaining;
 				}
-				ASSERT( recskipcnt > 0 );
+				assert( recskipcnt > 0 );
 				rval = mt_op( contextp->dc_fd,
 					      MTFSR,
 					      recskipcnt );

@@ -1287,8 +1288,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			currentoffset = contextp->dc_reccnt
 					*
 					( off64_t )tape_recsz;
-			ASSERT( wantedoffset >= currentoffset );
-			ASSERT( wantedoffset - currentoffset
+			assert( wantedoffset >= currentoffset );
+			assert( wantedoffset - currentoffset
 				<
 				( off64_t )tape_recsz );
 		}

@@ -1303,7 +1304,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		size_t actualcnt;
 		intgen_t rval;
 
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 
 		/* figure how much to ask for. to eat an entire record,
 		 * ask for a record sans the header. do_read will eat

@@ -1318,11 +1319,11 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		if ( rval ) {
 			return rval;
 		}
-		ASSERT( actualcnt == wantedcnt );
+		assert( actualcnt == wantedcnt );
 		do_return_read_buf( drivep, dummybufp, actualcnt );
-		ASSERT( ! contextp->dc_recp );
+		assert( ! contextp->dc_recp );
 		currentoffset += ( off64_t )tape_recsz;
-		ASSERT( currentoffset
+		assert( currentoffset
 			==
 			contextp->dc_reccnt * ( off64_t )tape_recsz );
 	}

@@ -1335,8 +1336,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		char *dummybufp;
 		size_t actualcnt;
 
-		ASSERT( wantedoffset > currentoffset );
-		ASSERT( wantedoffset - currentoffset < ( off64_t )tape_recsz );
+		assert( wantedoffset > currentoffset );
+		assert( wantedoffset - currentoffset < ( off64_t )tape_recsz );
 		wantedcnt = ( size_t )( wantedoffset - currentoffset );
 		if ( contextp->dc_recp ) {
 			u_int32_t recoff;

@@ -1346,14 +1347,14 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 			recoff = ( u_int32_t )( contextp->dc_nextp
 						-
 						contextp->dc_recp );
-			ASSERT( recoff <= tape_recsz );
-			ASSERT( rechdrp->rec_used <= tape_recsz );
-			ASSERT( recoff >= STAPE_HDR_SZ );
-			ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-			ASSERT( recoff <= rechdrp->rec_used );
-			ASSERT( recoff + wantedcnt <= rechdrp->rec_used );
+			assert( recoff <= tape_recsz );
+			assert( rechdrp->rec_used <= tape_recsz );
+			assert( recoff >= STAPE_HDR_SZ );
+			assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+			assert( recoff <= rechdrp->rec_used );
+			assert( recoff + wantedcnt <= rechdrp->rec_used );
 		} else {
-			ASSERT( wantedcnt >= STAPE_HDR_SZ );
+			assert( wantedcnt >= STAPE_HDR_SZ );
 			wantedcnt -= STAPE_HDR_SZ;
 		}
 

@@ -1366,7 +1367,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		    if ( rval ) {
 			    return rval;
 		    }
-		    ASSERT( actualcnt == wantedcnt );
+		    assert( actualcnt == wantedcnt );
 		    do_return_read_buf( drivep, dummybufp, actualcnt );
 		}
 	}

@@ -1381,18 +1382,18 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 		rec_hdr_t *rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 #endif
 
-		ASSERT( contextp->dc_nextp >= contextp->dc_recp );
+		assert( contextp->dc_nextp >= contextp->dc_recp );
 		recoff = ( u_int32_t )( contextp->dc_nextp
 					-
 					contextp->dc_recp );
-		ASSERT( recoff <= tape_recsz );
-		ASSERT( rechdrp->rec_used <= tape_recsz );
-		ASSERT( recoff >= STAPE_HDR_SZ );
-		ASSERT( rechdrp->rec_used >= STAPE_HDR_SZ );
-		ASSERT( recoff <= rechdrp->rec_used );
+		assert( recoff <= tape_recsz );
+		assert( rechdrp->rec_used <= tape_recsz );
+		assert( recoff >= STAPE_HDR_SZ );
+		assert( rechdrp->rec_used >= STAPE_HDR_SZ );
+		assert( recoff <= rechdrp->rec_used );
 		currentoffset += ( off64_t )recoff;
 	}
-	ASSERT( wantedoffset == currentoffset );
+	assert( wantedoffset == currentoffset );
 
 	return 0;
 }

@@ -1425,9 +1426,9 @@ do_next_mark( drive_t *drivep )
 
 	/* assert protocol being followed.
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
 
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "drive op: next mark\n" );

@@ -1450,7 +1451,7 @@ noerrorsearch:
 		}
 		rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 
-		ASSERT( rechdrp->first_mark_offset != 0 );
+		assert( rechdrp->first_mark_offset != 0 );
 		if ( rechdrp->first_mark_offset > 0 ) {
 			 off64_t markoff = rechdrp->first_mark_offset
 					   -

@@ -1458,8 +1459,8 @@ noerrorsearch:
 			 off64_t curoff = ( off64_t )( contextp->dc_nextp
 						       -
 						       contextp->dc_recp );
-			 ASSERT( markoff > 0 );
-			 ASSERT( curoff > 0 );
+			 assert( markoff > 0 );
+			 assert( curoff > 0 );
 			 if ( markoff >= curoff ) {
 				break;
 			}

@@ -1474,7 +1475,7 @@ noerrorsearch:
 		contextp->dc_reccnt++;
 	}
 
-	ASSERT( rechdrp->first_mark_offset - rechdrp->file_offset
+	assert( rechdrp->first_mark_offset - rechdrp->file_offset
 		<=
 		( off64_t )tape_recsz );
 	contextp->dc_nextp = contextp->dc_recp

@@ -1482,8 +1483,8 @@ noerrorsearch:
 			     ( size_t )( rechdrp->first_mark_offset
 					 -
 					 rechdrp->file_offset );
-	ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
-	ASSERT( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
+	assert( contextp->dc_nextp <= contextp->dc_dataendp );
+	assert( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
 	if ( contextp->dc_nextp == contextp->dc_dataendp ) {
 		if ( ! contextp->dc_singlethreadedpr ) {
 			Ring_put( contextp->dc_ringp,

@@ -1509,7 +1510,7 @@ resetring:
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 	rechdrp = ( rec_hdr_t * )contextp->dc_recp;

@@ -1561,7 +1562,7 @@ validateread:
 	}
 
 	if ( nread >= 0 ) {
-		ASSERT( ( size_t )nread <= tape_recsz );
+		assert( ( size_t )nread <= tape_recsz );
 		mlog( MLOG_DEBUG | MLOG_DRIVE,
 		      "short read (nread == %d, record size == %d)\n",
 		      nread,

@@ -1604,24 +1605,24 @@ validatehdr:
 		goto readrecord;
 	}
 
-	ASSERT( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
+	assert( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
 	markoff = rechdrp->first_mark_offset - rechdrp->file_offset;
-	ASSERT( markoff >= ( off64_t )STAPE_HDR_SZ );
-	ASSERT( markoff < ( off64_t )tape_recsz );
-	ASSERT( rechdrp->rec_used > STAPE_HDR_SZ );
-	ASSERT( rechdrp->rec_used < tape_recsz );
+	assert( markoff >= ( off64_t )STAPE_HDR_SZ );
+	assert( markoff < ( off64_t )tape_recsz );
+	assert( rechdrp->rec_used > STAPE_HDR_SZ );
+	assert( rechdrp->rec_used < tape_recsz );
 
 	goto alliswell;
 
 alliswell:
 	contextp->dc_nextp = contextp->dc_recp + ( size_t )markoff;
-	ASSERT( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
+	assert( ! ( rechdrp->file_offset % ( off64_t )tape_recsz ));
 	contextp->dc_reccnt = rechdrp->file_offset / ( off64_t )tape_recsz;
 	contextp->dc_iocnt = contextp->dc_reccnt + 1;
 	contextp->dc_recendp = contextp->dc_recp + tape_recsz;
 	contextp->dc_dataendp = contextp->dc_recp + rechdrp->rec_used;
-	ASSERT( contextp->dc_dataendp <= contextp->dc_recendp );
-	ASSERT( contextp->dc_nextp < contextp->dc_dataendp );
+	assert( contextp->dc_dataendp <= contextp->dc_recendp );
+	assert( contextp->dc_nextp < contextp->dc_dataendp );
 	contextp->dc_errorpr = BOOL_FALSE;
 
 	mlog( MLOG_NORMAL | MLOG_DRIVE,

@@ -1696,8 +1697,8 @@ do_end_read( drive_t *drivep )
 
 	/* assert protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
 
 	if ( ! contextp->dc_singlethreadedpr ) {
 		Ring_reset( contextp->dc_ringp, contextp->dc_msgp );

@@ -1745,9 +1746,9 @@ do_begin_write( drive_t *drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( ! drivep->d_markrecheadp );
-	ASSERT( ! contextp->dc_recp );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( ! drivep->d_markrecheadp );
+	assert( ! contextp->dc_recp );
 
 	/* get pointers into global write header
 	 */

@@ -1758,7 +1759,7 @@ do_begin_write( drive_t *drivep )
 	/* must already be open. The only way to open is to do a begin_read.
 	 * so all interaction with scsi tape requires reading first.
 	 */
-	ASSERT( contextp->dc_fd != -1 );
+	assert( contextp->dc_fd != -1 );
 
 	/* get tape device status. verify tape is positioned
  	 */

@@ -1787,15 +1788,15 @@ do_begin_write( drive_t *drivep )
 	/* get a record buffer. will be used for the media file header,
 	 * and is needed to "prime the pump" for first call to do_write.
 	 */
-	ASSERT( ! contextp->dc_recp );
+	assert( ! contextp->dc_recp );
 	if ( contextp->dc_singlethreadedpr ) {
-		ASSERT( contextp->dc_bufp );
+		assert( contextp->dc_bufp );
 		contextp->dc_recp = contextp->dc_bufp;
 	} else {
-		ASSERT( contextp->dc_ringp );
-		ASSERT( ! contextp->dc_msgp );
+		assert( contextp->dc_ringp );
+		assert( ! contextp->dc_msgp );
 		contextp->dc_msgp = Ring_get( contextp->dc_ringp );
-		ASSERT( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
+		assert( contextp->dc_msgp->rm_stat == RING_STAT_INIT );
 		contextp->dc_recp = contextp->dc_msgp->rm_bufp;
 	}
 

@@ -1840,7 +1841,7 @@ do_begin_write( drive_t *drivep )
 	/* prepare the drive context. must have a record buffer ready to
 	 * go, header initialized.
 	 */
-	ASSERT( ! contextp->dc_ownedp );
+	assert( ! contextp->dc_ownedp );
 	contextp->dc_reccnt = 1; /* count the header record */
 	contextp->dc_recendp = contextp->dc_recp + tape_recsz;
 	contextp->dc_nextp = contextp->dc_recp + STAPE_HDR_SZ;

@@ -1885,15 +1886,15 @@ do_set_mark( drive_t *drivep,
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
 
 	/* calculate and fill in the mark record offset
 	 */
-	ASSERT( contextp->dc_recp );
+	assert( contextp->dc_recp );
 	nextoff = contextp->dc_reccnt * ( off64_t )tape_recsz
 		  +
 		  ( off64_t )( contextp->dc_nextp - contextp->dc_recp );

@@ -1908,7 +1909,7 @@ do_set_mark( drive_t *drivep,
 	 */
 	rechdrp = ( rec_hdr_t * )contextp->dc_recp;
 	if ( rechdrp->first_mark_offset == -1LL ) {
-		ASSERT( nextoff != -1LL );
+		assert( nextoff != -1LL );
 		rechdrp->first_mark_offset = nextoff;
 	}
 

@@ -1921,7 +1922,7 @@ do_set_mark( drive_t *drivep,
 		drivep->d_markrecheadp = markrecp;
 		drivep->d_markrectailp = markrecp;
 	} else {
-		ASSERT( drivep->d_markrectailp );
+		assert( drivep->d_markrectailp );
 		drivep->d_markrectailp->dm_nextp = markrecp;
 		drivep->d_markrectailp = markrecp;
 	}

@@ -1948,12 +1949,12 @@ do_get_write_buf( drive_t *drivep, size_t wantedcnt, size_t *actualcntp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* figure how much is available; supply the min of what is
 	 * available and what is wanted.

@@ -2014,17 +2015,17 @@ do_write( drive_t *drivep, char *bufp, size_t retcnt )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp <= contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp <= contextp->dc_recendp );
 
 	/* verify the caller is returning exactly what is held
 	 */
-	ASSERT( bufp == contextp->dc_ownedp );
-	ASSERT( retcnt == heldcnt );
+	assert( bufp == contextp->dc_ownedp );
+	assert( retcnt == heldcnt );
 
 	/* take it back
 	 */

@@ -2065,7 +2066,7 @@ do_write( drive_t *drivep, char *bufp, size_t retcnt )
 			rval = contextp->dc_msgp->rm_rval;
 			break;
 		default:
-			ASSERT( 0 );
+			assert( 0 );
 			return DRIVE_ERROR_CORE;
 		}
 	}

@@ -2129,12 +2130,12 @@ do_get_align_cnt( drive_t * drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_errorpr );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_errorpr );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* calculate the next alignment point at or beyond the current nextp.
 	 * the following algorithm works because all buffers are page-aligned

@@ -2144,11 +2145,11 @@ do_get_align_cnt( drive_t * drivep )
 	next_alignment_off +=  PGMASK;
 	next_alignment_off &= ~PGMASK;
 	next_alignment_point = ( char * )next_alignment_off;
-	ASSERT( next_alignment_point <= contextp->dc_recendp );
+	assert( next_alignment_point <= contextp->dc_recendp );
 
 	/* return the number of bytes to the next alignment offset
 	 */
-	ASSERT( next_alignment_point >= contextp->dc_nextp );
+	assert( next_alignment_point >= contextp->dc_nextp );
 	return ( size_t )( next_alignment_point - contextp->dc_nextp );
 }
 

@@ -2175,12 +2176,12 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_recp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
-	ASSERT( contextp->dc_nextp < contextp->dc_recendp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_recp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp >= contextp->dc_recp + STAPE_HDR_SZ );
+	assert( contextp->dc_nextp < contextp->dc_recendp );
 
 	/* pre-initialize return of count of bytes committed to media
 	 */

@@ -2222,7 +2223,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 					     contextp->dc_recp,
 					     BOOL_TRUE, BOOL_TRUE );
 		} else {
-			ASSERT( contextp->dc_msgp );
+			assert( contextp->dc_msgp );
 			contextp->dc_msgp->rm_op = RING_OP_WRITE;
 			contextp->dc_msgp->rm_user = contextp->dc_reccnt;
 			Ring_put( contextp->dc_ringp,

@@ -2238,7 +2239,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 				rval = contextp->dc_msgp->rm_rval;
 				break;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_recp = 0;
 				return DRIVE_ERROR_CORE;
 			}

@@ -2265,7 +2266,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 	}
 	if ( ! contextp->dc_singlethreadedpr ) {
 		while ( ! rval ) {
-			ASSERT( contextp->dc_msgp );
+			assert( contextp->dc_msgp );
 			contextp->dc_msgp->rm_op = RING_OP_TRACE;
 			Ring_put( contextp->dc_ringp,
 				  contextp->dc_msgp );

@@ -2277,14 +2278,14 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 			switch( contextp->dc_msgp->rm_stat ) {
 			case RING_STAT_OK:
 			case RING_STAT_INIT:
-				ASSERT( rval == 0 );
+				assert( rval == 0 );
 				break;
 			case RING_STAT_ERROR:
 				rval = contextp->dc_msgp->rm_rval;
 				first_rec_w_err = contextp->dc_msgp->rm_user;
 				break;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_recp = 0;
 				return DRIVE_ERROR_CORE;
 			}

@@ -2346,11 +2347,11 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 	 * to tape.
 	 */
 	if ( rval ) {
-		ASSERT( first_rec_w_err >= 0 );
+		assert( first_rec_w_err >= 0 );
 		recs_wtn_wo_err = first_rec_w_err;
 		recs_guaranteed = recs_wtn_wo_err - contextp->dc_lostrecmax;
 	} else {
-		ASSERT( first_rec_w_err == -1 );
+		assert( first_rec_w_err == -1 );
 		recs_wtn_wo_err = contextp->dc_iocnt;
 		recs_guaranteed = recs_wtn_wo_err;
 	}

@@ -2382,14 +2383,14 @@ do_fsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_mode == OM_NONE );
 
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "drive op: fsf: count %d\n",
 	      count );
 
-	ASSERT( count );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( count );
+	assert( contextp->dc_mode == OM_NONE );
 
 	/* get tape status
   	 */

@@ -2426,7 +2427,7 @@ do_fsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 			      _("advancing tape to next media file\n") );
 
 			op_failed = 0;
-			ASSERT( contextp->dc_fd >= 0 );
+			assert( contextp->dc_fd >= 0 );
 			if ( mt_op( contextp->dc_fd, MTFSF, 1 ) ) {
 				op_failed = 1;
 			}

@@ -2482,7 +2483,7 @@ do_bsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 	      "drive op: bsf: count %d\n",
 	      count );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_mode == OM_NONE );
 
 	*statp = 0;
 

@@ -2515,7 +2516,7 @@ do_bsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 			*statp = DRIVE_ERROR_DEVICE;
 			return 0;
 		}
-		ASSERT( IS_BOT(mtstat ));
+		assert( IS_BOT(mtstat ));
 
 
 		*statp = DRIVE_ERROR_BOM;

@@ -2531,7 +2532,7 @@ do_bsf( drive_t *drivep, intgen_t count, intgen_t *statp )
 
 	/* back space - places us to left of previous file mark
 	 */
-	ASSERT( drivep->d_capabilities & DRIVE_CAP_BSF );
+	assert( drivep->d_capabilities & DRIVE_CAP_BSF );
 	mtstat = bsf_and_verify( drivep );
 
 	/* check again for beginning-of-tape condition

@@ -2606,8 +2607,8 @@ do_rewind( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "drive op: rewind\n" );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
 
 	/* use validating tape rewind util func
 	 */

@@ -2637,8 +2638,8 @@ do_erase( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "drive op: erase\n" );
 
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
 
 	/* use validating tape rewind util func
 	 */

@@ -2681,8 +2682,8 @@ do_eject_media( drive_t *drivep )
 
 	/* drive must be open
 	 */
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
 
 	/* issue tape unload
 	 */

@@ -2913,7 +2914,7 @@ read_label( drive_t *drivep )
 	/* if a read error, get status
 	 */
 	if ( nread != ( intgen_t )tape_recsz ) {
-		ASSERT( nread < ( intgen_t )tape_recsz );
+		assert( nread < ( intgen_t )tape_recsz );
 		ok = mt_get_status( drivep, &mtstat );
 		if ( ! ok ) {
 			status_failed_message( drivep );

@@ -3135,10 +3136,10 @@ set_fixed_blksz( drive_t *drivep, size_t blksz )
 
 	/* sanity checks
 	 */
-	ASSERT( blksz );
-	ASSERT( contextp->dc_isvarpr == BOOL_FALSE );
-	ASSERT( contextp->dc_cansetblkszpr );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( blksz );
+	assert( contextp->dc_isvarpr == BOOL_FALSE );
+	assert( contextp->dc_cansetblkszpr );
+	assert( contextp->dc_fd >= 0 );
 
 	/* give it two tries: first without rewinding, second with rewinding
 	 */

@@ -3213,7 +3214,7 @@ get_tpcaps( drive_t *drivep )
 {
 	drive_context_t	*contextp = ( drive_context_t * )drivep->d_contextp;
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 
 	if ( contextp->dc_isrmtpr ) {
 		/* can't ask about blksz, can't set blksz, can't ask about

@@ -3386,7 +3387,7 @@ mt_op(intgen_t fd, intgen_t sub_op, intgen_t param )
 	mop.mt_op   	= (short )sub_op;
 	mop.mt_count	= param;
 
-	ASSERT( fd >= 0 );
+	assert( fd >= 0 );
 
 	switch ( sub_op ) {
 	case MTSEEK:

@@ -3458,7 +3459,7 @@ mt_get_fileno( drive_t *drivep, long *fileno)
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: get fileno\n" );
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 
 	if ( ioctl(contextp->dc_fd, MTIOCGET, &mt_stat) < 0 ) {
 		/* failure

@@ -3491,7 +3492,7 @@ mt_get_status( drive_t *drivep, long *status)
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: get status\n" );
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 
 	if (TS_ISDRIVER) {
 		/*

@@ -3864,7 +3865,7 @@ retry:
 
 	/* shouldn't be here if drive is open
 	 */
-	ASSERT( contextp->dc_fd == -1 );
+	assert( contextp->dc_fd == -1 );
 
 	mlog( MLOG_VERBOSE | MLOG_DRIVE,
 	      _("preparing drive\n") );

@@ -3966,7 +3967,7 @@ retry:
 
 		Close( drivep );
 	}
-	ASSERT( IS_ONL( mtstat ));
+	assert( IS_ONL( mtstat ));
 
 	/* determine tape capabilities. this will set the drivep->d_capabilities
 	 * and contextp->dc_{...}blksz and dc_isQICpr, as well as recommended

@@ -4156,7 +4157,7 @@ retry:
 			      contextp->dc_recp,
 			      tape_recsz,
 			      &saved_errno );
-		ASSERT( saved_errno == 0 || nread < 0 );
+		assert( saved_errno == 0 || nread < 0 );
 
 		/* RMT can require a retry
 		 */

@@ -4536,7 +4537,7 @@ checkhdr:
 			rec_hdr_t *tprhdrp;
 			drhdrp = drivep->d_readhdrp;
 			tprhdrp = ( rec_hdr_t * )drhdrp->dh_specific;
-			ASSERT( tprhdrp->recsize >= 0 );
+			assert( tprhdrp->recsize >= 0 );
 			tape_recsz = ( size_t )tprhdrp->recsize;
 			mlog( MLOG_DEBUG | MLOG_DRIVE,
 			      "tape record size set to header's "

@@ -4657,7 +4658,7 @@ Open( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: opening drive\n" );
 
-	ASSERT( contextp->dc_fd == -1 );
+	assert( contextp->dc_fd == -1 );
 
 	errno = 0;
 	contextp->dc_fd = open( drivep->d_pathname, oflags );

@@ -4678,7 +4679,7 @@ Close( drive_t *drivep )
 	mlog( MLOG_DEBUG | MLOG_DRIVE,
 	      "tape op: closing drive\n" );
 
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_fd >= 0 );
 
 	( void )close( contextp->dc_fd );
 

@@ -4695,8 +4696,8 @@ Read( drive_t *drivep, char *bufp, size_t cnt, intgen_t *errnop )
 	      "tape op: reading %u bytes\n",
 	      cnt );
 
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( bufp );
+	assert( contextp->dc_fd >= 0 );
+	assert( bufp );
 	*errnop = 0;
 	errno = 0;
 	nread = read( contextp->dc_fd, ( void * )bufp, cnt );

@@ -4731,8 +4732,8 @@ Write( drive_t *drivep, char *bufp, size_t cnt, intgen_t *errnop )
 	      "tape op: writing %u bytes\n",
 	      cnt );
 
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( bufp );
+	assert( contextp->dc_fd >= 0 );
+	assert( bufp );
 	*errnop = 0;
 	errno = 0;
 	nwritten = write( contextp->dc_fd, ( void * )bufp, cnt );

@@ -4944,7 +4945,7 @@ read_record(  drive_t *drivep, char *bufp )
 	/* short read
 	 */
 	if ( nread >= 0 ) {
-		ASSERT( nread <= ( intgen_t )tape_recsz );
+		assert( nread <= ( intgen_t )tape_recsz );
 		mlog( MLOG_DEBUG | MLOG_DRIVE,
 		      "short read record %lld (nread == %d)\n",
 		      contextp->dc_iocnt,

@@ -5006,7 +5007,7 @@ getrec( drive_t *drivep )
 				contextp->dc_errorpr = BOOL_TRUE;
 				return contextp->dc_msgp->rm_rval;
 			default:
-				ASSERT( 0 );
+				assert( 0 );
 				contextp->dc_errorpr = BOOL_TRUE;
 				return DRIVE_ERROR_CORE;
 			}

@@ -5019,7 +5020,7 @@ getrec( drive_t *drivep )
 		contextp->dc_nextp = contextp->dc_recp
 				     +
 				     STAPE_HDR_SZ;
-		ASSERT( contextp->dc_nextp <= contextp->dc_dataendp );
+		assert( contextp->dc_nextp <= contextp->dc_dataendp );
 	}
 
 	return 0;

@@ -5055,7 +5056,7 @@ write_record(  drive_t *drivep, char *bufp, bool_t chksumpr, bool_t xlatepr )
 	}
 
 	rval = determine_write_error( drivep, nwritten, saved_errno );
-	ASSERT( rval );
+	assert( rval );
 
 	return rval;
 }

@@ -5094,7 +5095,7 @@ Ring_reset(  ring_t *ringp, ring_msg_t *msgp )
 	mlog( (MLOG_NITTY + 1) | MLOG_DRIVE,
 	      "ring op: reset\n" );
 
-	ASSERT( ringp );
+	assert( ringp );
 
 	ring_reset( ringp, msgp );
 }

@@ -5125,19 +5126,19 @@ display_ring_metrics( drive_t *drivep, intgen_t mlog_flags )
 	char *bufszsfxp;
 
 	if ( tape_recsz == STAPE_MIN_MAX_BLKSZ ) {
-		ASSERT( ! ( STAPE_MIN_MAX_BLKSZ % 0x400 ));
+		assert( ! ( STAPE_MIN_MAX_BLKSZ % 0x400 ));
 		sprintf( bufszbuf, "%u", STAPE_MIN_MAX_BLKSZ / 0x400 );
-		ASSERT( strlen( bufszbuf ) < sizeof( bufszbuf ));
+		assert( strlen( bufszbuf ) < sizeof( bufszbuf ));
 		bufszsfxp = "KB";
 	} else if ( tape_recsz == STAPE_MAX_RECSZ ) {
-		ASSERT( ! ( STAPE_MAX_RECSZ % 0x100000 ));
+		assert( ! ( STAPE_MAX_RECSZ % 0x100000 ));
 		sprintf( bufszbuf, "%u", STAPE_MAX_RECSZ / 0x100000 );
-		ASSERT( strlen( bufszbuf ) < sizeof( bufszbuf ));
+		assert( strlen( bufszbuf ) < sizeof( bufszbuf ));
 		bufszsfxp = "MB";
 	} else if ( tape_recsz == STAPE_MAX_LINUX_RECSZ ) {
-		ASSERT( ! ( STAPE_MAX_LINUX_RECSZ % 0x100000 ));
+		assert( ! ( STAPE_MAX_LINUX_RECSZ % 0x100000 ));
 		sprintf( bufszbuf, "%u", STAPE_MAX_LINUX_RECSZ / 0x100000 );
-		ASSERT( strlen( bufszbuf ) < sizeof( bufszbuf ));
+		assert( strlen( bufszbuf ) < sizeof( bufszbuf ));
 		bufszsfxp = "MB";
 	} else {
 		bufszsfxp = "";

common/drive_simple.c +76 -75

index 2b0447d..2e57d8c 100644
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <malloc.h>
 #include <sched.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -185,7 +186,7 @@ ds_match( int argc, char *argv[], drive_t *drivep )
 
 	/* sanity checks
 	 */
-	ASSERT( ! ( sizeofmember( drive_context_t, dc_buf ) % PGSZ ));
+	assert( ! ( sizeofmember( drive_context_t, dc_buf ) % PGSZ ));
 
 	/* determine if this is an rmt file. if so, give a weak match:
 	 * might be an ordinary file accessed via the rmt protocol.

@@ -234,8 +235,8 @@ ds_instantiate( int argc, char *argv[], drive_t *drivep )
 	 */
 	contextp = ( drive_context_t * )memalign( PGSZ,
 						  sizeof( drive_context_t ));
-	ASSERT( contextp );
-	ASSERT( ( void * )contextp->dc_buf == ( void * )contextp );
+	assert( contextp );
+	assert( ( void * )contextp->dc_buf == ( void * )contextp );
 	memset( ( void * )contextp, 0, sizeof( *contextp ));
 
 	/* scan drive device pathname to see if remote tape

@@ -439,9 +440,9 @@ do_begin_read( drive_t *drivep )
 
 	/* verify protocol being followed
 	 */
-	ASSERT( dcaps & DRIVE_CAP_READ );
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( dcaps & DRIVE_CAP_READ );
+	assert( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
 
 	/* can only read one media file
 	 */

@@ -484,7 +485,7 @@ do_begin_read( drive_t *drivep )
 		free(tmphdr);
 		return rval;
 	}
-	ASSERT( ( size_t )nread == GLOBAL_HDR_SZ );
+	assert( ( size_t )nread == GLOBAL_HDR_SZ );
 
 	mlog(MLOG_NITTY, "do_begin_read: global_hdr\n"
 	     "\tgh_magic %.100s\n"

@@ -585,9 +586,9 @@ do_read( drive_t *drivep,
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( wantedcnt > 0 );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
+	assert( wantedcnt > 0 );
 
 	/* pre-initialize reference return
 	 */

@@ -595,7 +596,7 @@ do_read( drive_t *drivep,
 
 	/* count number of unread bytes in buffer
 	 */
-	ASSERT( contextp->dc_emptyp >= contextp->dc_nextp );
+	assert( contextp->dc_emptyp >= contextp->dc_nextp );
 	remainingcnt = ( size_t )( contextp->dc_emptyp - contextp->dc_nextp );
 
 	/* if no unread bytes in buffer, refill

@@ -628,7 +629,7 @@ do_read( drive_t *drivep,
 		/* record the ptrs to the first empty byte and the next
 		 * byte to be read
 		 */
-		ASSERT( nread <= BUFSZ );
+		assert( nread <= BUFSZ );
 		contextp->dc_emptyp = contextp->dc_buf + nread;
 		contextp->dc_nextp = contextp->dc_buf;
 

@@ -656,7 +657,7 @@ do_read( drive_t *drivep,
 	/* advance the next ptr to the next byte to be supplied
 	 */
 	contextp->dc_nextp += actualcnt;
-	ASSERT( contextp->dc_nextp <= contextp->dc_emptyp );
+	assert( contextp->dc_nextp <= contextp->dc_emptyp );
 
 	/* return the actual number of bytes supplied, and a ptr to the first
 	 */

@@ -681,17 +682,17 @@ do_return_read_buf( drive_t *drivep, char *retp, size_t retcnt )
 
 	/* verify protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( contextp->dc_ownedp );
 
 	/* verify returning right buffer
 	 */
-	ASSERT( retp == contextp->dc_ownedp );
+	assert( retp == contextp->dc_ownedp );
 
 	/* verify all of buffer provided is being returned
 	 */
 	ownedcnt = ( size_t )( contextp->dc_nextp - contextp->dc_ownedp );
-	ASSERT( retcnt == ownedcnt );
+	assert( retcnt == ownedcnt );
 
 	/* indicate nothing now owned by caller
 	 */

@@ -713,8 +714,8 @@ do_get_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
 
 	/* calculate the offset of the next byte to be supplied relative to
 	 * the beginning of the buffer and relative to the beginning of

@@ -746,8 +747,8 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
 
 	/* calculate the current offset within the media file
 	 * of the next byte to be read

@@ -784,7 +785,7 @@ do_seek_mark( drive_t *drivep, drive_mark_t *markp )
 	 */
 	nextoff = ( off64_t )( contextp->dc_nextp - contextp->dc_buf );
 	strmoff = contextp->dc_bufstroff + nextoff;
-	ASSERT( strmoff == mark );
+	assert( strmoff == mark );
 
 	return 0;
 }

@@ -808,9 +809,9 @@ do_next_mark( drive_t *drivep )
 
 	/* assert protocol
 	 */
-	ASSERT( dcaps & DRIVE_CAP_NEXTMARK );
-	ASSERT( contextp->dc_mode == OM_READ );
-	ASSERT( ! contextp->dc_ownedp );
+	assert( dcaps & DRIVE_CAP_NEXTMARK );
+	assert( contextp->dc_mode == OM_READ );
+	assert( ! contextp->dc_ownedp );
 
 	if ( ! mark ) {
 		return DRIVE_ERROR_EOF;

@@ -837,13 +838,13 @@ do_end_read( drive_t *drivep )
 
 	/* be sure we are following protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_READ );
+	assert( contextp->dc_mode == OM_READ );
 	contextp->dc_mode = OM_NONE;
 
 	/* bump the file mark cnt
 	 */
 	contextp->dc_fmarkcnt++;
-	ASSERT( contextp->dc_fmarkcnt == 1 );
+	assert( contextp->dc_fmarkcnt == 1 );
 }
 
 /* begin_write - prepare file for writing

@@ -871,12 +872,12 @@ do_begin_write( drive_t *drivep )
 
 	/* sanity checks
 	 */
-	ASSERT( dwhdrp->dh_strategyid == DRIVE_STRATEGY_SIMPLE );
+	assert( dwhdrp->dh_strategyid == DRIVE_STRATEGY_SIMPLE );
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_fd >= 0 );
-	ASSERT( contextp->dc_mode == OM_NONE );
+	assert( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
 
 	/* only one media file may be written
 	 */

@@ -918,7 +919,7 @@ do_begin_write( drive_t *drivep )
 	contextp->dc_mode = OM_WRITE;
 
 	tmphdr = (global_hdr_t *)malloc(GLOBAL_HDR_SZ);
-	ASSERT(tmphdr);
+	assert(tmphdr);
 	memset(tmphdr, 0, GLOBAL_HDR_SZ);
 	tmpdh = (drive_hdr_t *)tmphdr->gh_upper;
 	tmpmh = (media_hdr_t *)tmpdh->dh_upper;

@@ -997,9 +998,9 @@ do_set_mark( drive_t *drivep,
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_nextp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_nextp );
 
 	/* calculate the mark offset
 	 */

@@ -1053,7 +1054,7 @@ do_set_mark( drive_t *drivep,
 
 			/* assert the header has been flushed
 			 */
-			ASSERT( contextp->dc_bufstroff >= sizeof( *gwhdrp ));
+			assert( contextp->dc_bufstroff >= sizeof( *gwhdrp ));
 
 			/* record mark in hdr
 			 */

@@ -1082,7 +1083,7 @@ do_set_mark( drive_t *drivep,
 				content_hdr_t		*ch = (content_hdr_t *)mh->mh_upper;
 				content_inode_hdr_t	*cih = (content_inode_hdr_t *)ch->ch_specific;
 
-				ASSERT( newoff == 0 );
+				assert( newoff == 0 );
 
 				/* write and seek back to current offset
 				 */

@@ -1092,7 +1093,7 @@ do_set_mark( drive_t *drivep,
 				     "(on media)\n" );
 
 				tmphdr = (global_hdr_t *)malloc(GLOBAL_HDR_SZ);
-				ASSERT(tmphdr);
+				assert(tmphdr);
 				tmpdh = (drive_hdr_t *)tmphdr->gh_upper;
 				tmpmh = (media_hdr_t *)tmpdh->dh_upper;
 				tmpch = (content_hdr_t *)tmpmh->mh_upper;

@@ -1129,13 +1130,13 @@ do_set_mark( drive_t *drivep,
 				nwritten = write( contextp->dc_fd,
 						  tmphdr,
 						  sizeof( *tmphdr ));
-				ASSERT( ( size_t )nwritten == sizeof( *tmphdr ));
+				assert( ( size_t )nwritten == sizeof( *tmphdr ));
 				free(tmphdr);
 
 				newoff = lseek64( contextp->dc_fd,
 						  contextp->dc_bufstroff,
 						  SEEK_SET );
-				ASSERT( newoff == contextp->dc_bufstroff );
+				assert( newoff == contextp->dc_bufstroff );
 			}
 		}
 	}

@@ -1144,7 +1145,7 @@ do_set_mark( drive_t *drivep,
 	 * otherwise put the mark record on the tail of the queue.
 	 */
 	if ( contextp->dc_nextp == contextp->dc_buf ) {
-		ASSERT( drivep->d_markrecheadp == 0 );
+		assert( drivep->d_markrecheadp == 0 );
 		( * cbfuncp )( cbcontextp, markrecp, BOOL_TRUE );
 		return;
 	} else {

@@ -1155,7 +1156,7 @@ do_set_mark( drive_t *drivep,
 			drivep->d_markrecheadp = markrecp;
 			drivep->d_markrectailp = markrecp;
 		} else {
-			ASSERT( drivep->d_markrectailp );
+			assert( drivep->d_markrectailp );
 			drivep->d_markrectailp->dm_nextp = markrecp;
 			drivep->d_markrectailp = markrecp;
 		}

@@ -1180,11 +1181,11 @@ do_get_write_buf( drive_t *drivep, size_t wanted_bufsz, size_t *actual_bufszp )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_emptyp );
-	ASSERT( contextp->dc_ownedsz == 0 );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_emptyp );
+	assert( contextp->dc_ownedsz == 0 );
 
 	/* calculate how much buffer remains
 	 */

@@ -1237,18 +1238,18 @@ do_write( drive_t *drivep, char *bufp, size_t writesz )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( contextp->dc_ownedp );
-	ASSERT( bufp == contextp->dc_ownedp );
-	ASSERT( ! contextp->dc_nextp );
-	ASSERT( contextp->dc_ownedp < contextp->dc_emptyp );
-	ASSERT( writesz == contextp->dc_ownedsz );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( contextp->dc_ownedp );
+	assert( bufp == contextp->dc_ownedp );
+	assert( ! contextp->dc_nextp );
+	assert( contextp->dc_ownedp < contextp->dc_emptyp );
+	assert( writesz == contextp->dc_ownedsz );
 
 	/* calculate next portion of buffer available for get_write_buf,
 	 * and indicate no portion is owned.
 	 */
 	contextp->dc_nextp = contextp->dc_ownedp + writesz;
-	ASSERT( contextp->dc_nextp <= contextp->dc_emptyp );
+	assert( contextp->dc_nextp <= contextp->dc_emptyp );
 	contextp->dc_ownedp = 0;
 	contextp->dc_ownedsz = 0;
 

@@ -1304,10 +1305,10 @@ do_get_align_cnt( drive_t *drivep )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_emptyp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_emptyp );
 
 	/* calculate the next alignment point at or beyond the current nextp.
 	 * the following algorithm works because dc_buf is page-aligned and

@@ -1317,7 +1318,7 @@ do_get_align_cnt( drive_t *drivep )
 	next_alignment_off +=  PGMASK;
 	next_alignment_off &= ~PGMASK;
 	next_alignment_point = ( char * )next_alignment_off;
-	ASSERT( next_alignment_point <= contextp->dc_emptyp );
+	assert( next_alignment_point <= contextp->dc_emptyp );
 
 	/* return the number of bytes to the next alignment point
 	 */

@@ -1338,14 +1339,14 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_WRITE );
-	ASSERT( ! contextp->dc_ownedp );
-	ASSERT( contextp->dc_nextp );
-	ASSERT( contextp->dc_nextp < contextp->dc_emptyp );
+	assert( contextp->dc_mode == OM_WRITE );
+	assert( ! contextp->dc_ownedp );
+	assert( contextp->dc_nextp );
+	assert( contextp->dc_nextp < contextp->dc_emptyp );
 
 	/* calculate length of un-written portion of buffer
 	 */
-	ASSERT( contextp->dc_nextp >= contextp->dc_buf );
+	assert( contextp->dc_nextp >= contextp->dc_buf );
 	remaining_bufsz = ( size_t )( contextp->dc_nextp - contextp->dc_buf );
 
 	if ( remaining_bufsz ) {

@@ -1387,7 +1388,7 @@ do_end_write( drive_t *drivep, off64_t *ncommittedp )
 	/* bump the file mark cnt
 	 */
 	contextp->dc_fmarkcnt++;
-	ASSERT( contextp->dc_fmarkcnt == 1 );
+	assert( contextp->dc_fmarkcnt == 1 );
 
 	*ncommittedp = contextp->dc_bufstroff;
 	contextp->dc_mode = OM_NONE;

@@ -1410,15 +1411,15 @@ do_rewind( drive_t *drivep )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( dcaps & DRIVE_CAP_REWIND );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( dcaps & DRIVE_CAP_REWIND );
+	assert( contextp->dc_fd >= 0 );
 
 	/* seek to beginning of file
 	 */
 	newoff = lseek64( contextp->dc_fd, ( off64_t )0, SEEK_SET );
 	if ( newoff ) {
-		ASSERT( newoff < 0 );
+		assert( newoff < 0 );
 		mlog( MLOG_NORMAL | MLOG_WARNING | MLOG_DRIVE,
 		      _("could not rewind %s: %s\n"),
 		      drivep->d_pathname,

@@ -1446,15 +1447,15 @@ do_erase( drive_t *drivep )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( dcaps & DRIVE_CAP_ERASE );
-	ASSERT( contextp->dc_fd >= 0 );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( dcaps & DRIVE_CAP_ERASE );
+	assert( contextp->dc_fd >= 0 );
 
 	/* seek to beginning of file
 	 */
 	newoff = lseek64( contextp->dc_fd, ( off64_t )0, SEEK_SET );
 	if ( newoff ) {
-		ASSERT( newoff < 0 );
+		assert( newoff < 0 );
 		mlog( MLOG_NORMAL | MLOG_WARNING | MLOG_DRIVE,
 		      _("could not rewind %s in prep for erase: %s\n"),
 		      drivep->d_pathname,

@@ -1486,7 +1487,7 @@ do_get_device_class( drive_t *drivep )
 {
 	mlog( MLOG_NITTY | MLOG_DRIVE,
 	      "drive_simple get_device_class( )\n" );
-	ASSERT( drivep );
+	assert( drivep );
 	return DEVICE_NONREMOVABLE;
 }
 

@@ -1500,8 +1501,8 @@ do_quit( drive_t *drivep )
 
 	/* assert protocol
 	 */
-	ASSERT( contextp->dc_mode == OM_NONE );
-	ASSERT( contextp );
+	assert( contextp->dc_mode == OM_NONE );
+	assert( contextp );
 
 	/* close file
 	 */

common/fs.c +12 -11

index 6f4cb6c..b77f6cc 100644
@@ -27,6 +27,7 @@
 #include <fcntl.h>
 #include <mntent.h>
 #include <sys/ioctl.h>
+#include <assert.h>
 
 #include "types.h"
 #include "mlog.h"

@@ -127,11 +128,11 @@ fs_info( char *typb,		/* out */
 	if ( canstat && ( statb.st_mode & S_IFMT ) == S_IFBLK ) {
 		if ( ( tep = fs_tab_lookup_blk( usrs )) != 0 ) {
 			blks = tep->fte_blks;
-			ASSERT( strlen( blks ) < ( size_t )blkbz );
+			assert( strlen( blks ) < ( size_t )blkbz );
 			strcpy( blkb, blks );
 			mnts = tep->fte_mnts;
 			if ( mnts ) {
-				ASSERT( strlen( mnts ) < ( size_t )mntbz );
+				assert( strlen( mnts ) < ( size_t )mntbz );
 				strcpy( mntb, mnts );
 			} else {
 				mntb[ 0 ] = 0;

@@ -139,7 +140,7 @@ fs_info( char *typb,		/* out */
 			if ( ( typs = tep->fte_typs ) == 0 ) {
 				typs = typd;
 			}
-			ASSERT( strlen( typs ) < ( size_t )typbz );
+			assert( strlen( typs ) < ( size_t )typbz );
 			strcpy( typb, typs );
 			ok = BOOL_TRUE;
 		} else {

@@ -147,13 +148,13 @@ fs_info( char *typb,		/* out */
 		}
 	} else if ( ( tep = fs_tab_lookup_mnt( usrs )) != 0 ) {
 		blks = tep->fte_blks;
-		ASSERT( strlen( blks ) < ( size_t )blkbz );
+		assert( strlen( blks ) < ( size_t )blkbz );
 		strcpy( blkb, blks );
 		mnts = tep->fte_mnts;
-		ASSERT( strlen( mnts ) < ( size_t )mntbz );
+		assert( strlen( mnts ) < ( size_t )mntbz );
 		strcpy( mntb, mnts );
 		typs = tep->fte_typs;
-		ASSERT( strlen( typs ) < ( size_t )typbz );
+		assert( strlen( typs ) < ( size_t )typbz );
 		strcpy( typb, typs );
 		ok = BOOL_TRUE;
 	} else {

@@ -161,7 +162,7 @@ fs_info( char *typb,		/* out */
 	}
 
 	fs_tab_free( );
-	ASSERT( ok != BOOL_UNKNOWN );
+	assert( ok != BOOL_UNKNOWN );
 
 	if ( ok == BOOL_TRUE ) {
 		intgen_t rval = fs_getid( mntb, idb );

@@ -281,11 +282,11 @@ fs_tab_ent_build( struct mntent *mntentp )
 	char *cp;
 
 	tep = ( fs_tab_ent_t * )calloc( 1, sizeof( fs_tab_ent_t ));
-	ASSERT( tep );
+	assert( tep );
 
 	if ( mntentp->mnt_dir ) {
 		cp = calloc( 1, strlen( mntentp->mnt_dir ) + 1 );
-		ASSERT( cp );
+		assert( cp );
 		( void )strcpy( cp, mntentp->mnt_dir );
 		tep->fte_mnts = cp;
 	} else {

@@ -294,7 +295,7 @@ fs_tab_ent_build( struct mntent *mntentp )
 
 	if ( mntentp->mnt_type ) {
 		cp = calloc( 1, strlen( mntentp->mnt_type ) + 1 );
-		ASSERT( cp );
+		assert( cp );
 		( void )strcpy( cp, mntentp->mnt_type );
 		tep->fte_typs = cp;
 	} else {

@@ -303,7 +304,7 @@ fs_tab_ent_build( struct mntent *mntentp )
 
 	if ( mntentp->mnt_fsname ) {
 		cp = calloc( 1, strlen( mntentp->mnt_fsname ) + 1 );
-		ASSERT( cp );
+		assert( cp );
 		( void )strcpy( cp, mntentp->mnt_fsname );
 		tep->fte_blks = cp;
 	} else {

common/global.c +7 -6

index 8e49d8b..ed844cc 100644
@@ -22,6 +22,7 @@
 #include <sys/stat.h>
 #include <time.h>
 #include <errno.h>
+#include <assert.h>
 
 #include "types.h"
 #include "util.h"

@@ -67,13 +68,13 @@ global_hdr_alloc( intgen_t argc, char *argv[ ] )
 
 	/* sanity checks
 	 */
-	ASSERT( sizeof( time32_t ) == GLOBAL_HDR_TIME_SZ );
-	ASSERT( sizeof( uuid_t ) == GLOBAL_HDR_UUID_SZ );
+	assert( sizeof( time32_t ) == GLOBAL_HDR_TIME_SZ );
+	assert( sizeof( uuid_t ) == GLOBAL_HDR_UUID_SZ );
 
 	/* allocate a global hdr
 	 */
 	ghdrp = ( global_hdr_t * )calloc( 1, sizeof( global_hdr_t ));
-	ASSERT( ghdrp );
+	assert( ghdrp );
 
 	/* fill in the magic number
 	 */

@@ -326,7 +327,7 @@ prompt_label( char *bufp, size_t bufsz )
 	preamblestr[ preamblecnt++ ] = "\n";
 	preamblestr[ preamblecnt++ ] = fold;
 	preamblestr[ preamblecnt++ ] = "\n\n";
-	ASSERT( preamblecnt <= PREAMBLEMAX );
+	assert( preamblecnt <= PREAMBLEMAX );
 	dlog_begin( preamblestr, preamblecnt );
 
 	responseix = dlog_string_query( prompt_label_cb,

@@ -348,7 +349,7 @@ prompt_label( char *bufp, size_t bufsz )
 		ackstr[ ackcnt++ ] = _("session label left blank\n");
 	}
 
-	ASSERT( ackcnt <= ACKMAX );
+	assert( ackcnt <= ACKMAX );
 	dlog_string_ack( ackstr,
 			 ackcnt );
 

@@ -357,7 +358,7 @@ prompt_label( char *bufp, size_t bufsz )
 	postamblestr[ postamblecnt++ ] = "\n";
 	postamblestr[ postamblecnt++ ] = fold;
 	postamblestr[ postamblecnt++ ] = "\n\n";
-	ASSERT( postamblecnt <= POSTAMBLEMAX );
+	assert( postamblecnt <= POSTAMBLEMAX );
 	dlog_end( postamblestr,
 		  postamblecnt );
 

common/hsmapi.c +1 -0

index 7f9b45e..0bca9ff 100644
@@ -19,6 +19,7 @@
 #include <xfs/xfs.h>
 #include <attr/attributes.h>
 #include <xfs/jdm.h>
+#include <assert.h>
 
 #include "hsmapi.h"
 #include "mlog.h"

common/inventory.c +17 -16

index fb27048..681d28f 100644
@@ -27,6 +27,7 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
+#include <assert.h>
 
 #include "types.h"
 #include "inventory_priv.h"

@@ -51,7 +52,7 @@ inv_open( inv_predicate_t bywhat, void *pred )
 
 	int index = 0;
 
-	ASSERT ( pred );
+	assert ( pred );
 	if ((fd = init_idb ( pred, bywhat, uuname, &tok )) < 0 )
 		return tok;
 

@@ -66,7 +67,7 @@ inv_open( inv_predicate_t bywhat, void *pred )
 		return INV_TOKEN_NULL;
 	}
 
-	ASSERT ( index > 0 );
+	assert ( index > 0 );
 
 	/* Now we need to make sure that this has enough space */
 	num = GET_SESCOUNTERS( stobjfd, &sescnt );

@@ -145,7 +146,7 @@ inv_lasttime_level_lessthan(
 	time32_t **tm )
 {
 	int 	rval;
-	ASSERT ( tok != INV_TOKEN_NULL );
+	assert ( tok != INV_TOKEN_NULL );
 
 	rval =  search_invt( tok, level, (void **) tm,
 			 (search_callback_t) tm_level_lessthan );

@@ -170,7 +171,7 @@ inv_lastsession_level_lessthan(
 	inv_session_t 	**ses )
 {
 	int 	rval;
-	ASSERT ( tok != INV_TOKEN_NULL );
+	assert ( tok != INV_TOKEN_NULL );
 
 	rval = search_invt( tok, level, (void **) ses, 
 			  (search_callback_t) lastsess_level_lessthan );

@@ -197,7 +198,7 @@ inv_lastsession_level_equalto(
 	inv_session_t	**ses )
 {
 	int 	rval;
-	ASSERT ( tok != INV_TOKEN_NULL );
+	assert ( tok != INV_TOKEN_NULL );
 	rval = search_invt( tok, level, (void **) ses, 
 			  (search_callback_t) lastsess_level_equalto );
 

@@ -236,8 +237,8 @@ inv_writesession_open(
 	invt_seshdr_t  	hdr;
 	inv_sestoken_t	sestok;
 
-	ASSERT ( tok != INV_TOKEN_NULL );
-	ASSERT ( sesid && fsid && mntpt && devpath );
+	assert ( tok != INV_TOKEN_NULL );
+	assert ( sesid && fsid && mntpt && devpath );
 
 	if ( ! ( tok->d_update_flag & FSTAB_UPDATED ) ) {
 		if ( put_fstab_entry( fsid, mntpt, devpath ) < 0 ) {

@@ -264,7 +265,7 @@ inv_writesession_open(
 
 	fd = tok->d_stobj_fd;
 
-	ASSERT ( fd > 0 );
+	assert ( fd > 0 );
 
 	hdr.sh_time = time;
 	hdr.sh_level = level;	

@@ -286,7 +287,7 @@ inv_writesession_open(
 	/* create the writesession, and get ready for the streams to come 
 	   afterwards */
 	rval = create_session( sestok, fd, sescnt, ses, &hdr );
-	ASSERT (rval > 0);
+	assert (rval > 0);
 
 
 	INVLOCK( fd, LOCK_UN );

@@ -324,7 +325,7 @@ inv_writesession_close( inv_sestoken_t tok )
 {
 	int		rval;
 
-	ASSERT ( tok != INV_TOKEN_NULL );
+	assert ( tok != INV_TOKEN_NULL );
 
 	/* now update end_time in the inv index header */
 	rval = put_sesstime( tok, INVT_ENDTIME );

@@ -354,7 +355,7 @@ inv_stream_open(
 	invt_seshdr_t  seshdr;
 	int fd;
 
-	ASSERT ( tok != INV_TOKEN_NULL );
+	assert ( tok != INV_TOKEN_NULL );
 
 	stream.st_nmediafiles = 0;
 	stream.st_interrupted = BOOL_FALSE;

@@ -505,9 +506,9 @@ inv_put_mediafile(
 	int 		 rval;
 
 
-	ASSERT ( tok != INV_TOKEN_NULL );
-	ASSERT ( tok->md_sesstok->sd_invtok->d_update_flag & FSTAB_UPDATED );
-	ASSERT ( tok->md_sesstok->sd_invtok->d_stobj_fd >= 0 );
+	assert ( tok != INV_TOKEN_NULL );
+	assert ( tok->md_sesstok->sd_invtok->d_update_flag & FSTAB_UPDATED );
+	assert ( tok->md_sesstok->sd_invtok->d_stobj_fd >= 0 );
 
 	mf = (invt_mediafile_t *) calloc( 1, sizeof( invt_mediafile_t ) );
 

@@ -627,8 +628,8 @@ inv_get_session(
 	void		      **bufpp,	/* buf to fill */
 	size_t		       *bufszp )/* size of that buffer */
 {
-	ASSERT( tok != INV_TOKEN_NULL );
-	ASSERT( tok->sd_invtok );
+	assert( tok != INV_TOKEN_NULL );
+	assert( tok->sd_invtok );
 
 	/* First get the session header, and the session information. Then
 	   we can figure out how much space to allocate */

common/lock.c +2 -1

index ab5b210..347f6cd 100644
@@ -18,6 +18,7 @@
 
 #include <xfs/xfs.h>
 #include <xfs/jdm.h>
+#include <assert.h>
 
 #include "types.h"
 #include "qlock.h"

@@ -30,7 +31,7 @@ lock_init( void )
 {
 	/* initialization sanity checks
 	 */
-	ASSERT( lock_qlockh == QLOCKH_NULL );
+	assert( lock_qlockh == QLOCKH_NULL );
 
 	/* allocate a qlock
 	 */

common/main.c +50 -49

index 8e7451f..f392856 100644
@@ -33,6 +33,7 @@
 #include <stdint.h>
 #include <sched.h>
 #include <pthread.h>
+#include <assert.h>
 
 #include "exit.h"
 #include "types.h"

@@ -161,14 +162,14 @@ main( int argc, char *argv[] )
 
 	/* sanity checks
 	 */
-	ASSERT( sizeof( char_t ) == 1 );
-	ASSERT( sizeof( u_char_t ) == 1 );
-	ASSERT( sizeof( int32_t ) == 4 );
-	ASSERT( sizeof( u_int32_t ) == 4 );
-	ASSERT( sizeof( size32_t ) == 4 );
-	ASSERT( sizeof( int64_t ) == 8 );
-	ASSERT( sizeof( u_int64_t ) == 8 );
-	ASSERT( sizeof( size64_t ) == 8 );
+	assert( sizeof( char_t ) == 1 );
+	assert( sizeof( u_char_t ) == 1 );
+	assert( sizeof( int32_t ) == 4 );
+	assert( sizeof( u_int32_t ) == 4 );
+	assert( sizeof( size32_t ) == 4 );
+	assert( sizeof( int64_t ) == 8 );
+	assert( sizeof( u_int64_t ) == 8 );
+	assert( sizeof( size64_t ) == 8 );
 
 	/* record the command name used to invoke
 	 */

@@ -365,7 +366,7 @@ main( int argc, char *argv[] )
 	mlog( MLOG_DEBUG | MLOG_PROC,
 	      "getpagesize( ) returns %u\n",
 	      pgsz );
-	ASSERT( ( intgen_t )pgsz > 0 );
+	assert( ( intgen_t )pgsz > 0 );
 	pgmask = pgsz - 1;
 
 	/* report parent tid

@@ -792,7 +793,7 @@ main( int argc, char *argv[] )
 			mlog_exit_hint(RV_INTR);
 			stop_in_progress = BOOL_TRUE;
 			cldmgr_stop( );
-			ASSERT( stop_timeout >= 0 );
+			assert( stop_timeout >= 0 );
 			stop_deadline = now + ( time32_t )stop_timeout;
 		}
 

@@ -1146,7 +1147,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 				return BOOL_FALSE;
 			}
 			optfilename = optarg;
-			ASSERT( optind > 2 );
+			assert( optind > 2 );
 			optfileix = ( ix_t )optind - 2;
 			break;
 		}

@@ -1211,7 +1212,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 	/* allocate an argument buffer
 	 */
 	argbuf = ( char * )malloc( sz );
-	ASSERT( argbuf );
+	assert( argbuf );
 
 	/* copy arg0 (the executable's name ) in first
 	 */

@@ -1233,7 +1234,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 		close( fd );
 		return BOOL_FALSE;
 	}
-	ASSERT( ( off64_t )nread == stat.st_size );
+	assert( ( off64_t )nread == stat.st_size );
 	p += ( size_t )stat.st_size;
 	*p++ = ' ';
 

@@ -1251,7 +1252,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 	/* null-terminate the entire buffer
 	 */
 	*p++ = 0;
-	ASSERT( ( size_t )( p - argbuf ) <= sz );
+	assert( ( size_t )( p - argbuf ) <= sz );
 
 	/* change newlines and carriage returns into spaces
 	 */

@@ -1303,7 +1304,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 	/* allocate a new argv array to hold the tokens
 	 */
 	newargv = ( char ** )calloc( tokencnt, sizeof( char * ));
-	ASSERT( newargv );
+	assert( newargv );
 
 	/* null-terminate tokens and place in new argv, after
 	 * extracting quotes and escapes

@@ -1326,7 +1327,7 @@ loadoptfile( intgen_t *argcp, char ***argvp )
 
 		/* better not disagree with counting scan!
 		 */
-		ASSERT( i < ( intgen_t )tokencnt );
+		assert( i < ( intgen_t )tokencnt );
 
 		/* find the end of the first token
 		 */

@@ -1533,7 +1534,7 @@ sigint_dialog( void )
 			_("\nsession interrupt in progress\n");
 	}
 	preamblestr[ preamblecnt++ ] = "\n";
-	ASSERT( preamblecnt <= PREAMBLEMAX );
+	assert( preamblecnt <= PREAMBLEMAX );
 	dlog_begin( preamblestr, preamblecnt );
 
 	/* top-level query: a function of session interrupt status

@@ -1541,7 +1542,7 @@ sigint_dialog( void )
 	querycnt = 0;
 	querystr[ querycnt++ ] = _("please select one of "
 				 "the following operations\n");
-	ASSERT( querycnt <= QUERYMAX );
+	assert( querycnt <= QUERYMAX );
 	choicecnt = 0;
 	if ( ! stop_in_progress ) {
 		interruptix = choicecnt;

@@ -1564,7 +1565,7 @@ sigint_dialog( void )
 	choicestr[ choicecnt++ ] = _("other controls");
 	continueix = choicecnt;
 	choicestr[ choicecnt++ ] = _("continue");
-	ASSERT( choicecnt <= CHOICEMAX );
+	assert( choicecnt <= CHOICEMAX );
 
 	responseix = dlog_multi_query( querystr,
 				       querycnt,

@@ -1586,13 +1587,13 @@ sigint_dialog( void )
 				ackcnt );
 		querycnt = 0;
 		querystr[ querycnt++ ] = _("please confirm\n");
-		ASSERT( querycnt <= QUERYMAX );
+		assert( querycnt <= QUERYMAX );
 		choicecnt = 0;
 		interruptix = choicecnt;
 		choicestr[ choicecnt++ ] = _("interrupt this session");
 		nochangeix = choicecnt;
 		choicestr[ choicecnt++ ] = _("continue");
-		ASSERT( choicecnt <= CHOICEMAX );
+		assert( choicecnt <= CHOICEMAX );
 		responseix = dlog_multi_query( querystr,
 					       querycnt,
 					       choicestr,

@@ -1623,7 +1624,7 @@ sigint_dialog( void )
 		querycnt = 0;
 		querystr[ querycnt++ ] = _("please select one of "
 					 "the following subsystems\n");
-		ASSERT( querycnt <= QUERYMAX );
+		assert( querycnt <= QUERYMAX );
 		choicecnt = 0;
 		/* number of lines must match number of subsystems
 		 */

@@ -1634,7 +1635,7 @@ sigint_dialog( void )
 		choicestr[ choicecnt++ ] = _("all of the above");
 		nochangeix = choicecnt;
 		choicestr[ choicecnt++ ] = _("no change");
-		ASSERT( choicecnt <= CHOICEMAX );
+		assert( choicecnt <= CHOICEMAX );
 		responseix = dlog_multi_query( querystr,
 					       querycnt,
 					       choicestr,

@@ -1664,7 +1665,7 @@ sigint_dialog( void )
 			querycnt = 0;
 			querystr[ querycnt++ ] = ("please select one of the "
 						  "following verbosity levels\n");
-			ASSERT( querycnt <= QUERYMAX );
+			assert( querycnt <= QUERYMAX );
 			choicecnt = 0;
 			choicestr[ choicecnt++ ] = _("silent");
 			choicestr[ choicecnt++ ] = _("verbose");

@@ -1674,7 +1675,7 @@ sigint_dialog( void )
 			choicestr[ choicecnt++ ] = _("nitty + 1");
 			nochangeix = choicecnt;
 			choicestr[ choicecnt++ ] = _("no change");
-			ASSERT( choicecnt <= CHOICEMAX );
+			assert( choicecnt <= CHOICEMAX );
 			responseix = dlog_multi_query( querystr,
 						       querycnt,
 						       choicestr,

@@ -1708,7 +1709,7 @@ sigint_dialog( void )
 			} else {
 				if ( ssselected < 0 ) {
 					ix_t ssix;
-					ASSERT( ssselected == -1 );
+					assert( ssselected == -1 );
 					for ( ssix = 0
 					      ;
 					      ssix < MLOG_SS_CNT

@@ -1734,7 +1735,7 @@ sigint_dialog( void )
 		querycnt = 0;
 		querystr[ querycnt++ ] = _("please select one of "
 					  "the following metrics\n");
-		ASSERT( querycnt <= QUERYMAX );
+		assert( querycnt <= QUERYMAX );
 		choicecnt = 0;
 		ioix = choicecnt;
 		choicestr[ choicecnt++ ] = _("I/O");

@@ -1746,7 +1747,7 @@ sigint_dialog( void )
 #endif /* RESTORE */
 		nochangeix = choicecnt;
 		choicestr[ choicecnt++ ] = _("continue");
-		ASSERT( choicecnt <= CHOICEMAX );
+		assert( choicecnt <= CHOICEMAX );
 		responseix = dlog_multi_query( querystr,
 					       querycnt,
 					       choicestr,

@@ -1779,11 +1780,11 @@ sigint_dialog( void )
 		if ( responseix != nochangeix ) {
 			querycnt = 0;
 			querystr[ querycnt++ ] = "\n";
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

common/media.c +11 -10

index 4ad7776..53b94d1 100644

Lines of this file are not shown. View the raw message.

common/mlog.c +11 -10

index b0135b9..c546036 100644

Lines of this file are not shown. View the raw message.

common/openutil.c +2 -1

index 9a88d67..c3b8d9a 100644

Lines of this file are not shown. View the raw message.

common/path.c +13 -12

index ca24f6a..e40c473 100644

Lines of this file are not shown. View the raw message.

common/qlock.c +15 -14

index ae8466d..d88917c 100644

Lines of this file are not shown. View the raw message.

common/ring.c +33 -32

index 0d2feb0..f3de7c4 100644

Lines of this file are not shown. View the raw message.

common/stream.c +8 -7

index 6704661..0db1be3 100644

Lines of this file are not shown. View the raw message.

common/util.c +21 -20

index 73f18fe..1dc6d6c 100644

Lines of this file are not shown. View the raw message.

dump/content.c +120 -119

index 5f7b4d9..3682358 100644

Lines of this file are not shown. View the raw message.

dump/inomap.c +10 -9

index a35059a..7a3069f 100644

Lines of this file are not shown. View the raw message.

inventory/inv_api.c +17 -16

index 65102e6..bd473e9 100644

Lines of this file are not shown. View the raw message.

inventory/inv_core.c +4 -3

index 3f7edb6..a83e7ef 100644

Lines of this file are not shown. View the raw message.

inventory/inv_files.c +5 -4

index f77eeec..34b7aac 100644

Lines of this file are not shown. View the raw message.

inventory/inv_fstab.c +3 -2

index 6567846..e87152f 100644

Lines of this file are not shown. View the raw message.

inventory/inv_idx.c +6 -5

index 145745a..edb72b3 100644

Lines of this file are not shown. View the raw message.

inventory/inv_mgr.c +4 -3

index 1f4a425..926b4c8 100644

Lines of this file are not shown. View the raw message.

inventory/inv_oref.c +26 -25

index a124b07..b6cd61d 100644

Lines of this file are not shown. View the raw message.

inventory/inv_oref.h +12 -12

index 5f4ed68..2562500 100644

Lines of this file are not shown. View the raw message.

inventory/inv_stobj.c +12 -11

index becac17..42969b1 100644

Lines of this file are not shown. View the raw message.

inventory/testmain.c +13 -12

index cfd0654..d8c61e2 100644

Lines of this file are not shown. View the raw message.

librmt/rmtioctl.c +1 -0

index c49e96d..4c108fb 100644

Lines of this file are not shown. View the raw message.

restore/bag.c +10 -9

index b7d8fe2..8c7a216 100644

Lines of this file are not shown. View the raw message.

restore/content.c +155 -154

index f2d361b..4796aea 100644

Lines of this file are not shown. View the raw message.

restore/dirattr.c +57 -56

index fcfa0c8..c829808 100644

Lines of this file are not shown. View the raw message.

restore/inomap.c +13 -12

index 562492e..2c62afc 100644

Lines of this file are not shown. View the raw message.

restore/namreg.c +20 -19

index 41362d1..c64833d 100644

Lines of this file are not shown. View the raw message.

restore/node.c +40 -39

index 4cc8fb0..f0297a5 100644

Lines of this file are not shown. View the raw message.

restore/tree.c +110 -109

index 08e177f..d377590 100644

Lines of this file are not shown. View the raw message.

restore/win.c +33 -32

index 0f3b573..a9f0239 100644

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Signature · 6 lines

2.5.0

_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs