diff --git a/common/mlog.c b/common/mlog.c
index 0924bf2..e3cf69d 100644
--- a/common/mlog.c
+++ b/common/mlog.c
@@ -42,7 +42,7 @@
 #include "drive.h"
 
 extern char *progname;
-extern void usage( void );
+extern void usage(void);
 extern pthread_t parenttid;
 
 #ifdef DUMP
@@ -52,7 +52,7 @@ static FILE *mlog_fp = NULL; /* stderr */;
 static FILE *mlog_fp = NULL; /* stdout */;
 #endif /* RESTORE */
 
-int mlog_level_ss[ MLOG_SS_CNT ];
+int mlog_level_ss[MLOG_SS_CNT];
 
 int mlog_showlevel = BOOL_FALSE;
 
@@ -60,11 +60,11 @@ int mlog_showss = BOOL_FALSE;
 
 int mlog_timestamp = BOOL_FALSE;
 
-static int mlog_sym_lookup( char * );
+static int mlog_sym_lookup(char *);
 
 static size_t mlog_streamcnt;
 
-static char mlog_levelstr[ 3 ];
+static char mlog_levelstr[3];
 
 #define MLOG_SS_NAME_MAX	15
 #ifdef DUMP
@@ -76,9 +76,9 @@ static char mlog_levelstr[ 3 ];
 #endif /* DUMP */
 #define N(a) (sizeof((a)) / sizeof((a)[0]))
 
-static char mlog_ssstr[ MLOG_SS_NAME_MAX + 2 ];
+static char mlog_ssstr[MLOG_SS_NAME_MAX + 2];
 
-static char mlog_tsstr[ 10 ];
+static char mlog_tsstr[10];
 
 struct mlog_sym {
 	char *sym;
@@ -87,7 +87,7 @@ struct mlog_sym {
 
 typedef struct mlog_sym mlog_sym_t;
 
-char *mlog_ss_names[ MLOG_SS_CNT ] = {
+char *mlog_ss_names[MLOG_SS_CNT] = {
 	"general",	/* MLOG_SS_GEN */
 	"proc",		/* MLOG_SS_PROC */
 	"drive",	/* MLOG_SS_DRIVE */
@@ -102,7 +102,7 @@ char *mlog_ss_names[ MLOG_SS_CNT ] = {
 	"excluded_files" /* MLOG_SS_EXCLFILES */
 };
 
-static mlog_sym_t mlog_sym[ ] = {
+static mlog_sym_t mlog_sym[] = {
 	{"0",		MLOG_SILENT},
 	{"1",		MLOG_VERBOSE},
 	{"2",		MLOG_TRACE},
@@ -122,7 +122,7 @@ static rv_t mlog_main_exit_return = RV_NONE;
 static rv_t mlog_main_exit_hint = RV_NONE;
 
 void
-mlog_init0( void )
+mlog_init0(void)
 {
 	int i;
 
@@ -134,17 +134,17 @@ mlog_init0( void )
 #endif /* RESTORE */
 
 	/* initialize stream count. will be updated later by call to
-	 * mlog_tell_streamcnt( ), after drive layer has counted drives
+	 * mlog_tell_streamcnt(), after drive layer has counted drives
 	 */
 	mlog_streamcnt = 1;
 
-	for( i = 0 ; i < MLOG_SS_CNT ; i++ ) {
-		mlog_level_ss[ i ] = MLOG_VERBOSE;
+	for(i = 0 ; i < MLOG_SS_CNT ; i++) {
+		mlog_level_ss[i] = MLOG_VERBOSE;
 	}
 }
 
 bool_t
-mlog_init1( int argc, char *argv[ ] )
+mlog_init1(int argc, char *argv[])
 {
 	char **suboptstrs;
 	ix_t ssix;
@@ -154,105 +154,105 @@ mlog_init1( int argc, char *argv[ ] )
 
 	/* prepare an array of suboption token strings. this will be the
 	 * concatenation of the subsystem names with the verbosity symbols.
-	 * this array of char pts must be null terminated for getsubopt( 3 ).
+	 * this array of char pts must be null terminated for getsubopt(3).
 	 */
-	vsymcnt = sizeof( mlog_sym ) / sizeof( mlog_sym[ 0 ] );
-	suboptstrs = ( char ** )calloc( MLOG_SS_CNT + vsymcnt + 1,
-					sizeof( char * ));
-	assert( suboptstrs );
-	for ( soix = 0 ; soix < MLOG_SS_CNT ; soix++ ) {
-		assert( strlen( mlog_ss_names[ soix ] ) <= MLOG_SS_NAME_MAX );
+	vsymcnt = sizeof(mlog_sym) / sizeof(mlog_sym[0]);
+	suboptstrs = (char **)calloc(MLOG_SS_CNT + vsymcnt + 1,
+					sizeof(char *));
+	assert(suboptstrs);
+	for (soix = 0 ; soix < MLOG_SS_CNT ; soix++) {
+		assert(strlen(mlog_ss_names[soix]) <= MLOG_SS_NAME_MAX);
 			/* unrelated, but opportunity to chk */
-		suboptstrs[ soix ] = mlog_ss_names[ soix ];
+		suboptstrs[soix] = mlog_ss_names[soix];
 	}
-	for ( ; soix < MLOG_SS_CNT + vsymcnt ; soix++ ) {
-		suboptstrs[ soix ] = mlog_sym[ soix - MLOG_SS_CNT ].sym;
+	for (; soix < MLOG_SS_CNT + vsymcnt ; soix++) {
+		suboptstrs[soix] = mlog_sym[soix - MLOG_SS_CNT].sym;
 	}
-	suboptstrs[ soix ] = 0;
+	suboptstrs[soix] = 0;
 
 	/* set all of the subsystem log levels to -1, so we can see which
 	 * subsystems where explicitly called out. those which weren't will
 	 * be given the "general" level.
 	 */
-	for ( ssix = 0 ; ssix < MLOG_SS_CNT ; ssix++ ) {
-		mlog_level_ss[ ssix ] = -1;
+	for (ssix = 0 ; ssix < MLOG_SS_CNT ; ssix++) {
+		mlog_level_ss[ssix] = -1;
 	}
-	mlog_level_ss[ MLOG_SS_GEN ] = MLOG_VERBOSE;
+	mlog_level_ss[MLOG_SS_GEN] = MLOG_VERBOSE;
 
 	/* get command line options
 	 */
 	optind = 1;
 	opterr = 0;
-	while ( ( c = getopt( argc, argv, GETOPT_CMDSTRING )) != EOF ) {
+	while ((c = getopt(argc, argv, GETOPT_CMDSTRING)) != EOF) {
 		char *options;
 
-		switch ( c ) {
+		switch (c) {
 		case GETOPT_VERBOSITY:
-			if ( ! optarg || optarg[ 0 ] == '-' ) {
-				fprintf( stderr,
+			if (! optarg || optarg[0] == '-') {
+				fprintf(stderr,
 					 _("%s: -%c argument missing\n"),
 					 progname,
-					 c );
-				usage( );
+					 c);
+				usage();
 				return BOOL_FALSE;
 			}
 			options = optarg;
-			while ( *options ) {
+			while (*options) {
 				int suboptix;
 				char *valstr;
 
-				suboptix = getsubopt( &options,
+				suboptix = getsubopt(&options,
 						      (constpp)suboptstrs,
-						      &valstr );
-				if ( suboptix < 0 ) {
-					fprintf( stderr,
+						      &valstr);
+				if (suboptix < 0) {
+					fprintf(stderr,
 						 _("%s: -%c argument invalid\n"),
 						 progname,
-						 c );
-					usage( );
+						 c);
+					usage();
 					return BOOL_FALSE;
 				}
-				assert( ( ix_t )suboptix
+				assert((ix_t)suboptix
 					<
-					MLOG_SS_CNT + vsymcnt );
-				if ( suboptix < MLOG_SS_CNT ) {
-					if ( ! valstr ) {
-						fprintf( stderr,
+					MLOG_SS_CNT + vsymcnt);
+				if (suboptix < MLOG_SS_CNT) {
+					if (! valstr) {
+						fprintf(stderr,
 							 _("%s: -%c subsystem "
 							 "subargument "
 							 "%s requires a "
 							 "verbosity value\n"),
 							 progname,
 							 c,
-						mlog_ss_names[ suboptix ] );
-						usage( );
+						mlog_ss_names[suboptix]);
+						usage();
 						return BOOL_FALSE;
 					}
-					ssix = ( ix_t )suboptix;
-					mlog_level_ss[ ssix ] =
-						    mlog_sym_lookup( valstr );
+					ssix = (ix_t)suboptix;
+					mlog_level_ss[ssix] =
+						    mlog_sym_lookup(valstr);
 				} else {
-					if ( valstr ) {
-						fprintf( stderr,
+					if (valstr) {
+						fprintf(stderr,
 							 _("%s: -%c argument "
 							 "does not require "
 							 "a value\n"),
 							 progname,
-							 c );
-						usage( );
+							 c);
+						usage();
 						return BOOL_FALSE;
 					}
 					ssix = MLOG_SS_GEN;
-					mlog_level_ss[ ssix ] =
-				    mlog_sym_lookup( suboptstrs[ suboptix ] );
+					mlog_level_ss[ssix] =
+				    mlog_sym_lookup(suboptstrs[suboptix]);
 				}
-				if ( mlog_level_ss[ ssix ] < 0 ) {
-					fprintf( stderr,
+				if (mlog_level_ss[ssix] < 0) {
+					fprintf(stderr,
 						 _("%s: -%c argument "
 						 "invalid\n"),
 						 progname,
-						 c );
-					usage( );
+						 c);
+					usage();
 					return BOOL_FALSE;
 				}
 			}
@@ -269,25 +269,25 @@ mlog_init1( int argc, char *argv[ ] )
 		}
 	}
 
-	free( ( void * )suboptstrs );
+	free((void *)suboptstrs);
 
 	/* give subsystems not explicitly called out the "general" verbosity
 	 */
-	for ( ssix = 0 ; ssix < MLOG_SS_CNT ; ssix++ ) {
-		if ( mlog_level_ss[ ssix ] < 0 ) {
-			assert( mlog_level_ss[ ssix ] == -1 );
-			assert( mlog_level_ss[ MLOG_SS_GEN ] >= 0 );
-			mlog_level_ss[ ssix ] = mlog_level_ss[ MLOG_SS_GEN ];
+	for (ssix = 0 ; ssix < MLOG_SS_CNT ; ssix++) {
+		if (mlog_level_ss[ssix] < 0) {
+			assert(mlog_level_ss[ssix] == -1);
+			assert(mlog_level_ss[MLOG_SS_GEN] >= 0);
+			mlog_level_ss[ssix] = mlog_level_ss[MLOG_SS_GEN];
 		}
 	}
 
 	/* prepare a string for optionally displaying the log level
 	 */
-	mlog_levelstr[ 0 ] = 0;
-	mlog_levelstr[ 1 ] = 0;
-	mlog_levelstr[ 2 ] = 0;
-	if ( mlog_showlevel ) {
-		mlog_levelstr[ 0 ] = ':';
+	mlog_levelstr[0] = 0;
+	mlog_levelstr[1] = 0;
+	mlog_levelstr[2] = 0;
+	if (mlog_showlevel) {
+		mlog_levelstr[0] = ':';
 	}
 
 #ifdef DUMP
@@ -296,7 +296,7 @@ mlog_init1( int argc, char *argv[ ] )
 	 * mlog_fd set to stderr, see if we can switch
 	 * to stdout.
 	 */
-	if ( optind >= argc ||  strcmp( argv[ optind ], "-" )) {
+	if (optind >= argc ||  strcmp(argv[optind ], "-")) {
 		mlog_fp = stdout;
 	}
 #endif /* DUMP */
@@ -307,31 +307,31 @@ mlog_init1( int argc, char *argv[ ] )
 }
 
 bool_t
-mlog_init2( void )
+mlog_init2(void)
 {
 	/* allocate a qlock
 	 */
-	mlog_qlockh = qlock_alloc( QLOCK_ORD_MLOG );
+	mlog_qlockh = qlock_alloc(QLOCK_ORD_MLOG);
 
 	return BOOL_TRUE;
 }
 
 void
-mlog_tell_streamcnt( size_t streamcnt )
+mlog_tell_streamcnt(size_t streamcnt)
 {
 	mlog_streamcnt = streamcnt;
 }
 
 void
-mlog_lock( void )
+mlog_lock(void)
 {
-	qlock_lock( mlog_qlockh );
+	qlock_lock(mlog_qlockh);
 }
 
 void
-mlog_unlock( void )
+mlog_unlock(void)
 {
-	qlock_unlock( mlog_qlockh );
+	qlock_unlock(mlog_qlockh);
 }
 
 /*
@@ -341,122 +341,122 @@ mlog_unlock( void )
  * too much output.
  */
 void
-mlog_override_level( int levelarg )
+mlog_override_level(int levelarg)
 {
 	int level;
 	ix_t ss; /* SubSystem */
 
 	level = levelarg & MLOG_LEVELMASK;
-	ss = ( ix_t )( ( levelarg & MLOG_SS_MASK ) >> MLOG_SS_SHIFT );
+	ss = (ix_t)((levelarg & MLOG_SS_MASK) >> MLOG_SS_SHIFT);
 
 	if (ss == MLOG_SS_GEN) { /* do level for all subsys */
-	    for (ss = 0 ; ss < MLOG_SS_CNT ; ss++ ) {
-		mlog_level_ss[ ss ] = level;
+	    for (ss = 0 ; ss < MLOG_SS_CNT ; ss++) {
+		mlog_level_ss[ss] = level;
 	    }
 	}
 	else { /* do a particular subsys */
-	    mlog_level_ss[ ss ] = level;
+	    mlog_level_ss[ss] = level;
 	}
 }
 
 void
-mlog( int levelarg, char *fmt, ... )
+mlog(int levelarg, char *fmt, ...)
 {
 	va_list args;
-	va_start( args, fmt );
-	mlog_va( levelarg, fmt, args );
-	va_end( args );
+	va_start(args, fmt);
+	mlog_va(levelarg, fmt, args);
+	va_end(args);
 }
 
 void
-mlog_va( int levelarg, char *fmt, va_list args )
+mlog_va(int levelarg, char *fmt, va_list args)
 {
 	int level;
 	ix_t ss;
 
 	level = levelarg & MLOG_LEVELMASK;
-	ss = ( ix_t )( ( levelarg & MLOG_SS_MASK ) >> MLOG_SS_SHIFT );
+	ss = (ix_t)((levelarg & MLOG_SS_MASK) >> MLOG_SS_SHIFT);
 
-	assert( ss < MLOG_SS_CNT );
-	if ( level > mlog_level_ss[ ss ] ) {
+	assert(ss < MLOG_SS_CNT);
+	if (level > mlog_level_ss[ss]) {
 		return;
 	}
 
-	if ( ! ( levelarg & MLOG_NOLOCK )) {
-		mlog_lock( );
+	if (! (levelarg & MLOG_NOLOCK)) {
+		mlog_lock();
 	}
 
-	if ( ! ( levelarg & MLOG_BARE )) {
+	if (! (levelarg & MLOG_BARE)) {
 		int streamix;
-		streamix = stream_getix( pthread_self( ) );
+		streamix = stream_getix(pthread_self());
 
-		if ( mlog_showss ) {
-			sprintf( mlog_ssstr, ":%s", mlog_ss_names[ ss ] );
+		if (mlog_showss) {
+			sprintf(mlog_ssstr, ":%s", mlog_ss_names[ ss]);
 		} else {
-			mlog_ssstr[ 0 ] = 0;
+			mlog_ssstr[0] = 0;
 		}
 
-		if ( mlog_timestamp ) {
-			time_t now = time( 0 );
-			struct tm *tmp = localtime( &now );
-			sprintf( mlog_tsstr,
+		if (mlog_timestamp) {
+			time_t now = time(0);
+			struct tm *tmp = localtime(&now);
+			sprintf(mlog_tsstr,
 				 ":%02d.%02d.%02d",
 				 tmp->tm_hour,
 				 tmp->tm_min,
-				 tmp->tm_sec );
-			assert( strlen( mlog_tsstr ) < sizeof( mlog_tsstr ));
+				 tmp->tm_sec);
+			assert(strlen(mlog_tsstr) < sizeof(mlog_tsstr));
 		} else {
-			mlog_tsstr[ 0 ] = 0;
+			mlog_tsstr[0] = 0;
 		}
 
-		if ( mlog_showlevel ) {
-			mlog_levelstr[ 0 ] = ':';
-			if ( level > 9 ) {
-				mlog_levelstr[ 1 ] = '?';
+		if (mlog_showlevel) {
+			mlog_levelstr[0] = ':';
+			if (level > 9) {
+				mlog_levelstr[1] = '?';
 			} else {
-				mlog_levelstr[ 1 ] = ( char )
-						     ( level
+				mlog_levelstr[1] = (char)
+						     (level
 						       +
-						       ( int )'0' );
+						       (int)'0');
 			}
 		} else {
-			mlog_levelstr[ 0 ] = 0;
+			mlog_levelstr[0] = 0;
 		}
-		if ( streamix != -1 && mlog_streamcnt > 1 ) {
-			fprintf( mlog_fp,
+		if (streamix != -1 && mlog_streamcnt > 1) {
+			fprintf(mlog_fp,
 				 _("%s%s%s%s: drive %d: "),
 				 progname,
 				 mlog_tsstr,
 				 mlog_ssstr,
 				 mlog_levelstr,
-				 streamix );
+				 streamix);
 		} else {
-			fprintf( mlog_fp,
+			fprintf(mlog_fp,
 				 "%s%s%s%s: ",
 				 progname,
 				 mlog_tsstr,
 				 mlog_ssstr,
-				 mlog_levelstr );
+				 mlog_levelstr);
 		}
-		if ( levelarg & MLOG_NOTE ) {
-			fprintf( mlog_fp,
-				 "NOTE: " );
+		if (levelarg & MLOG_NOTE) {
+			fprintf(mlog_fp,
+				 "NOTE: ");
 		}
-		if ( levelarg & MLOG_WARNING ) {
-			fprintf( mlog_fp,
-				 "WARNING: " );
+		if (levelarg & MLOG_WARNING) {
+			fprintf(mlog_fp,
+				 "WARNING: ");
 		}
-		if ( levelarg & MLOG_ERROR ) {
-			fprintf( mlog_fp,
-				 "ERROR: " );
+		if (levelarg & MLOG_ERROR) {
+			fprintf(mlog_fp,
+				 "ERROR: ");
 		}
 	}
 
-	vfprintf( mlog_fp, fmt, args );
-	fflush( mlog_fp );
+	vfprintf(mlog_fp, fmt, args);
+	fflush(mlog_fp);
 
-	if ( ! ( levelarg & MLOG_NOLOCK )) {
-		mlog_unlock( );
+	if (! (levelarg & MLOG_NOLOCK)) {
+		mlog_unlock();
 	}
 }
 
@@ -569,7 +569,7 @@ rv_getdesc(rv_t rv)
  */
 
 int
-_mlog_exit( const char *file, int line, int exit_code, rv_t rv )
+_mlog_exit(const char *file, int line, int exit_code, rv_t rv)
 {
 	pthread_t tid;
 	const struct rv_map *rvp;
@@ -578,7 +578,7 @@ _mlog_exit( const char *file, int line, int exit_code, rv_t rv )
 	rvp = rv_getdesc(rv);
 
 
-	mlog( MLOG_DEBUG | MLOG_NOLOCK,
+	mlog(MLOG_DEBUG | MLOG_NOLOCK,
 	      "%s: %d: mlog_exit called: "
 	      "exit_code: %s return: %s (%s)\n",
 	      file, line,
@@ -586,7 +586,7 @@ _mlog_exit( const char *file, int line, int exit_code, rv_t rv )
 	      rvp->rv_string, rvp->rv_desc);
 
 	if (rv < 0 || rv >= _RV_NUM) {
-		mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,
+		mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,
 		      "mlog_exit(): bad return code");
 		return exit_code;
 	}
@@ -598,7 +598,7 @@ _mlog_exit( const char *file, int line, int exit_code, rv_t rv )
 	 * most accurate information about the termination condition.
 	 */
 
-	if ( pthread_equal( tid, parenttid ) ) {
+	if (pthread_equal(tid, parenttid)) {
 		if (mlog_main_exit_code == -1) {
 			mlog_main_exit_code = exit_code;
 			mlog_main_exit_return = rv;
@@ -631,7 +631,7 @@ _mlog_exit( const char *file, int line, int exit_code, rv_t rv )
 }
 
 void
-_mlog_exit_hint( const char *file, int line, rv_t rv )
+_mlog_exit_hint(const char *file, int line, rv_t rv)
 {
 	pthread_t tid;
 	const struct rv_map *rvp;
@@ -639,14 +639,14 @@ _mlog_exit_hint( const char *file, int line, rv_t rv )
 	tid = pthread_self();
 	rvp = rv_getdesc(rv);
 
-	mlog( MLOG_DEBUG | MLOG_NOLOCK,
+	mlog(MLOG_DEBUG | MLOG_NOLOCK,
 	      "%s: %d: mlog_exit_hint called: "
 	      "hint: %s (%s)\n",
 	      file, line,
 	      rvp->rv_string, rvp->rv_desc);
 
 	if (rv < 0 || rv >= _RV_NUM) {
-		mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,
+		mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,
 		      "mlog_exit_hint(): bad return code");
 		return;
 	}
@@ -658,22 +658,22 @@ _mlog_exit_hint( const char *file, int line, rv_t rv )
 	 * information about the termination condition.
 	 */
 
-	if ( pthread_equal( tid, parenttid ) )
+	if (pthread_equal(tid, parenttid))
 		mlog_main_exit_hint = rv;
 	else
-		stream_set_hint( tid, rv );
+		stream_set_hint(tid, rv);
 
 }
 
 rv_t
-mlog_get_hint( void )
+mlog_get_hint(void)
 {
 	stream_state_t states[] = { S_RUNNING };
 	/* REFERENCED */
 	bool_t ok;
 	rv_t hint;
 
-	if ( pthread_equal( pthread_self(), parenttid ) )
+	if (pthread_equal(pthread_self(), parenttid))
 		return mlog_main_exit_hint;
 
 	ok = stream_get_exit_status(pthread_self(), states, N(states),
@@ -720,7 +720,7 @@ mlog_exit_flush(void)
 	if (ntids > 0) {
 
 		/* print the state of all the streams */
-		fprintf(mlog_fp, _("%s: %s Summary:\n"), progname, PROGSTR_CAPS );
+		fprintf(mlog_fp, _("%s: %s Summary:\n"), progname, PROGSTR_CAPS);
 
 		for (i = 0; i < ntids; i++) {
 			stream_state_t state;
@@ -785,15 +785,15 @@ mlog_exit_flush(void)
 }
 
 static int
-mlog_sym_lookup( char *sym )
+mlog_sym_lookup(char *sym)
 {
 	mlog_sym_t *p = mlog_sym;
 	mlog_sym_t *ep = mlog_sym
 			 +
-			 sizeof( mlog_sym ) / sizeof( mlog_sym[ 0 ] );
+			 sizeof(mlog_sym) / sizeof(mlog_sym[0]);
 
-	for ( ; p < ep ; p++ ) {
-		if ( ! strcmp( sym, p->sym )) {
+	for (; p < ep ; p++) {
+		if (! strcmp(sym, p->sym)) {
 			return p->level;
 		}
 	}
@@ -802,7 +802,7 @@ mlog_sym_lookup( char *sym )
 }
 
 void
-fold_init( fold_t fold, char *infostr, char c )
+fold_init(fold_t fold, char *infostr, char c)
 {
 	size_t infolen;
 	size_t dashlen;
@@ -812,36 +812,36 @@ fold_init( fold_t fold, char *infostr, char c )
 	char *endp;
 	ix_t cnt;
 
-	assert( sizeof( fold_t ) == FOLD_LEN + 1 );
+	assert(sizeof(fold_t) == FOLD_LEN + 1);
 
-	infolen = strlen( infostr );
-	if ( infolen > FOLD_LEN - 4 ) {
+	infolen = strlen(infostr);
+	if (infolen > FOLD_LEN - 4) {
 		infolen = FOLD_LEN - 4;
 	}
 	dashlen = FOLD_LEN - infolen - 3;
 	predashlen = dashlen / 2;
 	postdashlen = dashlen - predashlen;
 
-	p = &fold[ 0 ];
-	endp = &fold[ sizeof( fold_t ) - 1 ];
+	p = &fold[0];
+	endp = &fold[sizeof(fold_t) - 1];
 
-	assert( p < endp );
+	assert(p < endp);
 	*p++ = ' ';
-	for ( cnt = 0 ; cnt < predashlen && p < endp ; cnt++, p++ ) {
+	for (cnt = 0 ; cnt < predashlen && p < endp ; cnt++, p++) {
 		*p = c;
 	}
-	assert( p < endp );
+	assert(p < endp);
 	*p++ = ' ';
-	assert( p < endp );
-	assert( p + infolen < endp );
-	strcpy( p, infostr );
+	assert(p < endp);
+	assert(p + infolen < endp);
+	strcpy(p, infostr);
 	p += infolen;
-	assert( p < endp );
+	assert(p < endp);
 	*p++ = ' ';
-	assert( p < endp );
-	for ( cnt = 0 ; cnt < postdashlen && p < endp ; cnt++, p++ ) {
+	assert(p < endp);
+	for (cnt = 0 ; cnt < postdashlen && p < endp ; cnt++, p++) {
 		*p = c;
 	}
-	assert( p <= endp );
+	assert(p <= endp);
 	*p = 0;
 }
diff --git a/common/mlog.h b/common/mlog.h
index 628dd28..f007761 100644
--- a/common/mlog.h
+++ b/common/mlog.h
@@ -60,27 +60,27 @@
 #define MLOG_SS_CNT	7		/* NOTE! bump this when adding ss */
 
 #define MLOG_SS_SHIFT	8
-#define MLOG_SS_MASK	( 0xff << MLOG_SS_SHIFT )
+#define MLOG_SS_MASK	(0xff << MLOG_SS_SHIFT)
 
-/* subsystem flags - NOTE! only one may be specified! use in mlog( first arg )
+/* subsystem flags - NOTE! only one may be specified! use in mlog(first arg)
  */
-#define MLOG_ALL	( MLOG_SS_GEN << MLOG_SS_SHIFT )
-#define MLOG_PROC	( MLOG_SS_PROC << MLOG_SS_SHIFT )
-#define MLOG_DRIVE	( MLOG_SS_DRIVE << MLOG_SS_SHIFT )
-#define MLOG_MEDIA	( MLOG_SS_MEDIA << MLOG_SS_SHIFT )
-#define MLOG_INV	( MLOG_SS_INV << MLOG_SS_SHIFT )
+#define MLOG_ALL	(MLOG_SS_GEN << MLOG_SS_SHIFT)
+#define MLOG_PROC	(MLOG_SS_PROC << MLOG_SS_SHIFT)
+#define MLOG_DRIVE	(MLOG_SS_DRIVE << MLOG_SS_SHIFT)
+#define MLOG_MEDIA	(MLOG_SS_MEDIA << MLOG_SS_SHIFT)
+#define MLOG_INV	(MLOG_SS_INV << MLOG_SS_SHIFT)
 #ifdef DUMP
-#define MLOG_INOMAP	( MLOG_SS_INOMAP << MLOG_SS_SHIFT )
+#define MLOG_INOMAP	(MLOG_SS_INOMAP << MLOG_SS_SHIFT)
 #endif /* DUMP */
 #ifdef RESTORE
-#define MLOG_TREE	( MLOG_SS_TREE << MLOG_SS_SHIFT )
+#define MLOG_TREE	(MLOG_SS_TREE << MLOG_SS_SHIFT)
 #endif /* RESTORE */
-#define MLOG_EXCLFILES	( MLOG_SS_EXCLFILES << MLOG_SS_SHIFT )
+#define MLOG_EXCLFILES	(MLOG_SS_EXCLFILES << MLOG_SS_SHIFT)
 
 /* mlog_level - set during initialization, exported to facilitate
  * message logging decisions. one per subsystem (see above)
  */
-extern int mlog_level_ss[ MLOG_SS_CNT ];
+extern int mlog_level_ss[MLOG_SS_CNT];
 
 /* made external so main.c sigint dialog can change
  */
@@ -90,43 +90,43 @@ extern int mlog_timestamp;
 
 /* mlog_ss_name - so main.c sigint dialog can allow changes
  */
-extern char *mlog_ss_names[ MLOG_SS_CNT ];
+extern char *mlog_ss_names[MLOG_SS_CNT];
 
 /* initializes the mlog abstraction. split into two phases to
  * unravel some initialization sequencing problems.
  */
-extern void mlog_init0( void );
-extern bool_t mlog_init1( int argc, char *argv[ ] );
-extern bool_t mlog_init2( void );
+extern void mlog_init0(void);
+extern bool_t mlog_init1(int argc, char *argv[]);
+extern bool_t mlog_init2(void);
 
 /* post-initialization, to tell mlog how many streams
  */
-extern void mlog_tell_streamcnt( size_t streamcnt );
+extern void mlog_tell_streamcnt(size_t streamcnt);
 
 /* override the -v option
  */
-void mlog_override_level( int levelarg );
+void mlog_override_level(int levelarg);
 
 /* vprintf-based message format
  */
-extern void mlog( int level, char *fmt, ... );
-extern void mlog_va( int levelarg, char *fmt, va_list args );
-#define mlog_exit( e, r ) _mlog_exit( __FILE__, __LINE__, (e), (r) )
-extern int  _mlog_exit( const char *file, int line, int exit_code, rv_t return_code );
-#define mlog_exit_hint( r ) _mlog_exit_hint( __FILE__, __LINE__, (r) )
-extern void _mlog_exit_hint( const char *file, int line, rv_t rv );
-extern rv_t mlog_get_hint( void );
-extern void mlog_exit_flush( void );
+extern void mlog(int level, char *fmt, ...);
+extern void mlog_va(int levelarg, char *fmt, va_list args);
+#define mlog_exit(e, r) _mlog_exit(__FILE__, __LINE__, (e), (r))
+extern int  _mlog_exit(const char *file, int line, int exit_code, rv_t return_code);
+#define mlog_exit_hint(r) _mlog_exit_hint(__FILE__, __LINE__, (r))
+extern void _mlog_exit_hint(const char *file, int line, rv_t rv);
+extern rv_t mlog_get_hint(void);
+extern void mlog_exit_flush(void);
 
 /* the following calls are exported ONLY to dlog.c!
  */
-extern void mlog_lock( void );
-extern void mlog_unlock( void );
+extern void mlog_lock(void);
+extern void mlog_unlock(void);
 
 /* fold_t - a character string made to look like a "fold here"
  */
 #define FOLD_LEN	79
-typedef char fold_t[ FOLD_LEN + 1 ];
-extern void fold_init( fold_t fold, char *infostr, char c );
+typedef char fold_t[FOLD_LEN + 1];
+extern void fold_init(fold_t fold, char *infostr, char c);
 
 #endif /* MLOG_H */
diff --git a/common/openutil.c b/common/openutil.c
index fcb52fc..6b7b1b6 100644
--- a/common/openutil.c
+++ b/common/openutil.c
@@ -32,15 +32,15 @@
 #include "mlog.h"
 
 char *
-open_pathalloc( char *dirname, char *basename, pid_t pid )
+open_pathalloc(char *dirname, char *basename, pid_t pid)
 {
 	size_t dirlen;
 	size_t pidlen;
 	size_t namelen;
 	char *namebuf;
 
-	if ( strcmp( dirname, "/" )) {
-		dirlen = strlen( dirname );
+	if (strcmp(dirname, "/")) {
+		dirlen = strlen(dirname);
 	} else {
 		dirlen = 0;
 		dirname = "";
@@ -54,111 +54,111 @@ open_pathalloc( char *dirname, char *basename, pid_t pid )
 	 * And if it ever became 64 bits,
 	 * 64 bits => trunc(log10(2^64))+1 = 20
          */
-  	if ( pid ) {
+  	if (pid) {
 		pidlen = 1 + 20;
   	} else {
   		pidlen = 0;
   	}
-	namelen = dirlen + 1 + strlen( basename ) + pidlen + 1;
-	namebuf = ( char * )calloc( 1, namelen );
-  	assert( namebuf );
+	namelen = dirlen + 1 + strlen(basename) + pidlen + 1;
+	namebuf = (char *)calloc(1, namelen);
+  	assert(namebuf);
 
-  	if ( pid ) {
-		( void )snprintf( namebuf, namelen, "%s/%s.%d", dirname, basename, pid );
+  	if (pid) {
+		(void )snprintf(namebuf, namelen, "%s/%s.%d", dirname, basename, pid);
   	} else {
-		( void )snprintf( namebuf, namelen, "%s/%s", dirname, basename );
+		(void )snprintf(namebuf, namelen, "%s/%s", dirname, basename);
   	}
 
   	return namebuf;
 }
 
 int
-open_trwp( char *pathname )
+open_trwp(char *pathname)
 {
 	int fd;
 
-	fd = open( pathname, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR );
-	if ( fd < 0 ) {
-		mlog( MLOG_NORMAL,
+	fd = open(pathname, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
+	if (fd < 0) {
+		mlog(MLOG_NORMAL,
 		      _("could not create %s: %s\n"),
 		      pathname,
-		      strerror( errno ));
+		      strerror(errno));
 	}
 
 	return fd;
 }
 
 int
-open_erwp( char *pathname )
+open_erwp(char *pathname)
 {
 	int fd;
 
-	fd = open( pathname, O_EXCL | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR );
-	if ( fd < 0 ) {
-		mlog( MLOG_NORMAL,
+	fd = open(pathname, O_EXCL | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+	if (fd < 0) {
+		mlog(MLOG_NORMAL,
 		      _("could not create %s: %s\n"),
 		      pathname,
-		      strerror( errno ));
+		      strerror(errno));
 	}
 
 	return fd;
 }
 
 int
-open_rwp( char *pathname )
+open_rwp(char *pathname)
 {
 	int fd;
 
-	fd = open( pathname, O_RDWR );
+	fd = open(pathname, O_RDWR);
 
 	return fd;
 }
 
 int
-mkdir_tp( char *pathname )
+mkdir_tp(char *pathname)
 {
 	int rval;
 
-	rval = mkdir( pathname, S_IRWXU );
+	rval = mkdir(pathname, S_IRWXU);
 
 	return rval;
 }
 
 int
-open_trwdb( char *dirname, char *basename, pid_t pid )
+open_trwdb(char *dirname, char *basename, pid_t pid)
 {
 	char *pathname;
 	int fd;
 
-	pathname = open_pathalloc( dirname, basename, pid );
-	fd = open_trwp( pathname );
-	free( ( void * )pathname );
+	pathname = open_pathalloc(dirname, basename, pid);
+	fd = open_trwp(pathname);
+	free((void *)pathname);
 
 	return fd;
 }
 
 int
-open_erwdb( char *dirname, char *basename, pid_t pid )
+open_erwdb(char *dirname, char *basename, pid_t pid)
 {
 	char *pathname;
 	int fd;
 
-	pathname = open_pathalloc( dirname, basename, pid );
-	fd = open_erwp( pathname );
-	free( ( void * )pathname );
+	pathname = open_pathalloc(dirname, basename, pid);
+	fd = open_erwp(pathname);
+	free((void *)pathname);
 
 	return fd;
 }
 
 int
-open_rwdb( char *dirname, char *basename, pid_t pid )
+open_rwdb(char *dirname, char *basename, pid_t pid)
 {
 	char *pathname;
 	int fd;
 
-	pathname = open_pathalloc( dirname, basename, pid );
-	fd = open_rwp( pathname );
-	free( ( void * )pathname );
+	pathname = open_pathalloc(dirname, basename, pid);
+	fd = open_rwp(pathname);
+	free((void *)pathname);
 
 	return fd;
 }
diff --git a/common/openutil.h b/common/openutil.h
index 587462c..0e418d4 100644
--- a/common/openutil.h
+++ b/common/openutil.h
@@ -28,35 +28,35 @@
  * representation of the pid will be appended to the pathname, beginning
  * with a '.'.
  */
-extern char *open_pathalloc( char *dirname, char *basename, pid_t pid );
+extern char *open_pathalloc(char *dirname, char *basename, pid_t pid);
 
 /* create the specified file, creating or truncating as necessary,
  * with read and write permissions, given a directory and base.
- * return the file descriptor, or -1 with errno set. uses mlog( MLOG_NORMAL...
+ * return the file descriptor, or -1 with errno set. uses mlog(MLOG_NORMAL...
  * if the creation fails.
  */
-extern int open_trwdb( char *dirname, char *basename, pid_t pid );
-extern int open_trwp( char *pathname );
+extern int open_trwdb(char *dirname, char *basename, pid_t pid);
+extern int open_trwp(char *pathname);
 
 
 /* open the specified file, with read and write permissions, given a
  * directory and base.* return the file descriptor, or -1 with errno set.
- * uses mlog( MLOG_NORMAL... if the open fails.
+ * uses mlog(MLOG_NORMAL... if the open fails.
  */
-extern int open_rwdb( char *dirname, char *basename, pid_t pid );
-extern int open_rwp( char *pathname );
+extern int open_rwdb(char *dirname, char *basename, pid_t pid);
+extern int open_rwp(char *pathname);
 
 
 /* create and open the specified file, failing if already exists
  */
-extern int open_erwp( char *pathname );
-extern int open_erwdb( char *dirname, char *basename, pid_t pid );
+extern int open_erwp(char *pathname);
+extern int open_erwdb(char *dirname, char *basename, pid_t pid);
 
 
 /* create the specified directory, guaranteed to be initially empty. returns
- * 0 on success, -1 if trouble. uses mlog( MLOG_NORMAL... if the creation fails.
+ * 0 on success, -1 if trouble. uses mlog(MLOG_NORMAL... if the creation fails.
  */
-extern int mkdir_tp( char *pathname );
+extern int mkdir_tp(char *pathname);
 
 
 #endif /* UTIL_H */
diff --git a/common/path.c b/common/path.c
index b234de1..fb1fcf0 100644
--- a/common/path.c
+++ b/common/path.c
@@ -33,143 +33,143 @@ struct pem {
 
 typedef struct pem pem_t;
 
-static pem_t * pem_alloc( char *path );
-static void pem_free( pem_t *pemp );
-static char * pem_next( pem_t *pemp );
+static pem_t * pem_alloc(char *path);
+static void pem_free(pem_t *pemp);
+static char * pem_next(pem_t *pemp);
 
 #define PAMAX	1024
 
 struct pa {
-	char *pa_array[ PAMAX ];
+	char *pa_array[PAMAX];
 	int pa_cnt;
 };
 
 typedef struct pa pa_t;
 
-static pa_t * pa_alloc( void );
-static void pa_free( pa_t *pap );
-static void pa_append( pa_t *pap, char *pep );
-static int pa_peel( pa_t *pap );
-static char * pa_gen( pa_t *pap );
+static pa_t * pa_alloc(void);
+static void pa_free(pa_t *pap);
+static void pa_append(pa_t *pap, char *pep);
+static int pa_peel(pa_t *pap);
+static char * pa_gen(pa_t *pap);
 
 char *
-path_diff( char *path, char *base )
+path_diff(char *path, char *base)
 {
 	char *diff;
 
-	assert( *base == '/' );
-	assert( *path == '/' );
+	assert(*base == '/');
+	assert(*path == '/');
 
-	if ( ! path_beginswith( path, base )) {
+	if (! path_beginswith(path, base)) {
 		return 0;
 	}
 
-	for ( ; *base && *path == *base ; path++, base++ )
+	for (; *base && *path == *base ; path++, base++)
 		;
 
-	if ( *path == 0 ) {
+	if (*path == 0) {
 		return 0;
 	}
 
-	if ( *path == '/' ) {
+	if (*path == '/') {
 		path++;
 	}
 
-	diff = ( char * )calloc( 1, strlen( path ) + 1 );
-	assert( diff );
-	strcpy( diff, path );
+	diff = (char *)calloc(1, strlen(path) + 1);
+	assert(diff);
+	strcpy(diff, path);
 
 	return diff;
 }
 
 int
-path_beginswith( char *path, char *base )
+path_beginswith(char *path, char *base)
 {
-	if ( ! base ) {
+	if (! base) {
 		return 0;
 	}
-	return ! strncmp( base, path, strlen( base ));
+	return ! strncmp(base, path, strlen(base));
 }
 
 char *
-path_reltoabs( char *dir, char *basedir )
+path_reltoabs(char *dir, char *basedir)
 {
 	char *absdir;
 
 	/* check if the path starts with a / or
-	 * is a remote path (i.e. contains  machine:/path/name ).
+	 * is a remote path (i.e. contains  machine:/path/name).
 	 */
-	if ( ( *dir != '/' ) && ( strchr(dir, ':') == 0 ) ) {
+	if ((*dir != '/') && (strchr(dir, ':') == 0)) {
 		char *absdir;
-		absdir = ( char * )malloc( strlen( basedir )
+		absdir = (char *)malloc(strlen(basedir)
 					   +
 					   1
 					   +
-					   strlen( dir )
+					   strlen(dir)
 					   +
-					   1 );
-		assert( absdir );
+					   1);
+		assert(absdir);
 
-		( void )sprintf( absdir, "%s/%s", basedir, dir );
+		(void )sprintf(absdir, "%s/%s", basedir, dir);
 
 		dir = absdir;
 	}
 
-	if ( strchr(dir, ':') == 0 ) {
-		absdir = path_normalize( dir );
+	if (strchr(dir, ':') == 0) {
+		absdir = path_normalize(dir);
 	} else {
-		absdir = ( char * )malloc( strlen( dir )  + 1);
-		( void )sprintf( absdir, "%s", dir);
+		absdir = (char *)malloc(strlen(dir)  + 1);
+		(void )sprintf(absdir, "%s", dir);
 	}
 
 	return absdir;
 }
 
 char *
-path_normalize( char *path )
+path_normalize(char *path)
 {
-	pem_t *pemp = pem_alloc( path );
-	pa_t *pap = pa_alloc( );
+	pem_t *pemp = pem_alloc(path);
+	pa_t *pap = pa_alloc();
 	char *pep;
 	char *npath;
 
-	assert( path[ 0 ] == '/' );
+	assert(path[0] == '/');
 
-	while ( ( pep = pem_next( pemp )) != 0 ) {
-		if ( ! strcmp( pep, "" )) {
-			free( ( void * )pep );
+	while ((pep = pem_next(pemp)) != 0) {
+		if (! strcmp(pep, "")) {
+			free((void *)pep);
 			continue;
 		}
-		if ( ! strcmp( pep, "." )) {
-			free( ( void * )pep );
+		if (! strcmp(pep, ".")) {
+			free((void *)pep);
 			continue;
 		}
-		if ( ! strcmp( pep, ".." )) {
+		if (! strcmp(pep, "..")) {
 			int ok;
-			free( ( void * )pep );
-			ok = pa_peel( pap );
-			if ( ! ok ) {
-				pa_free( pap );
-				pem_free( pemp );
+			free((void *)pep);
+			ok = pa_peel(pap);
+			if (! ok) {
+				pa_free(pap);
+				pem_free(pemp);
 				return 0;
 			}
 			continue;
 		}
-		pa_append( pap, pep );
+		pa_append(pap, pep);
 	}
 
-	npath = pa_gen( pap );
-	pa_free( pap );
-	pem_free( pemp );
+	npath = pa_gen(pap);
+	pa_free(pap);
+	pem_free(pemp);
 
 	return npath;
 }
 
 static pem_t *
-pem_alloc( char *path )
+pem_alloc(char *path)
 {
-	pem_t *pemp = ( pem_t * )calloc( 1, sizeof( pem_t ));
-	assert( pemp );
+	pem_t *pemp = (pem_t *)calloc(1, sizeof(pem_t));
+	assert(pemp);
 	pemp->pem_head = path;
 	pemp->pem_next = pemp->pem_head;
 
@@ -177,13 +177,13 @@ pem_alloc( char *path )
 }
 
 static void
-pem_free( pem_t *pemp )
+pem_free(pem_t *pemp)
 {
-	free( ( void * )pemp );
+	free((void *)pemp);
 }
 
 static char *
-pem_next( pem_t *pemp )
+pem_next(pem_t *pemp)
 {
 	char *nextnext;
 	size_t len;
@@ -191,37 +191,37 @@ pem_next( pem_t *pemp )
 
 	/* no more left
 	 */
-	if ( *pemp->pem_next == 0 ) {
+	if (*pemp->pem_next == 0) {
 		return 0;
 	}
 
 	/* find the following slash
 	 */
-	nextnext = strchr( pemp->pem_next + 1, '/' );
+	nextnext = strchr(pemp->pem_next + 1, '/');
 
 	/* if end of string encountered, place next next at end of string
 	 */
-	if ( ! nextnext ) {
-		for ( nextnext = pemp->pem_next ; *nextnext ; nextnext++ )
+	if (! nextnext) {
+		for (nextnext = pemp->pem_next ; *nextnext ; nextnext++)
 			;
 	}
 
 	/* determine the length of the path element, sans the leading slash
 	 */
-	len = ( size_t )( nextnext - pemp->pem_next - 1 );
+	len = (size_t)(nextnext - pemp->pem_next - 1);
 
 	/* allocate buffer to hold the path element, incl null termination
 	 */
-	p = ( char * )malloc( len + 1 );
-	assert( p );
+	p = (char *)malloc(len + 1);
+	assert(p);
 
 	/* copy the path element into the buffer
 	 */
-	strncpy( p, pemp->pem_next + 1, len );
+	strncpy(p, pemp->pem_next + 1, len);
 
 	/* null-terminate
 	 */
-	p[ len ] = 0;
+	p[len] = 0;
 
 	/* update next
 	 */
@@ -233,54 +233,54 @@ pem_next( pem_t *pemp )
 }
 
 static pa_t *
-pa_alloc( void )
+pa_alloc(void)
 {
-	pa_t *pap = ( pa_t * )calloc( 1, sizeof( pa_t ));
-	assert( pap );
+	pa_t *pap = (pa_t *)calloc(1, sizeof(pa_t));
+	assert(pap);
 
 	return pap;
 }
 
 static void
-pa_free( pa_t *pap )
+pa_free(pa_t *pap)
 {
 	int i;
 
-	for ( i = 0 ; i < pap->pa_cnt ; i++ ) {
-		free( ( void * )pap->pa_array[ i ] );
+	for (i = 0 ; i < pap->pa_cnt ; i++) {
+		free((void *)pap->pa_array[i]);
 	}
 
-	free( ( void * )pap );
+	free((void *)pap);
 }
 
 static void
-pa_append( pa_t *pap, char *pep )
+pa_append(pa_t *pap, char *pep)
 {
-	assert( pap->pa_cnt < PAMAX );
+	assert(pap->pa_cnt < PAMAX);
 
-	pap->pa_array[ pap->pa_cnt ] = pep;
+	pap->pa_array[pap->pa_cnt] = pep;
 
 	pap->pa_cnt++;
 }
 
 static int
-pa_peel( pa_t *pap )
+pa_peel(pa_t *pap)
 {
-	if ( pap->pa_cnt <= 0 ) {
-		assert( pap->pa_cnt == 0 );
+	if (pap->pa_cnt <= 0) {
+		assert(pap->pa_cnt == 0);
 		return 0;
 	}
 
 	pap->pa_cnt--;
-	assert( pap->pa_array[ pap->pa_cnt ] );
-	free( ( void * )pap->pa_array[ pap->pa_cnt ] );
-	pap->pa_array[ pap->pa_cnt ] = 0;
+	assert(pap->pa_array[pap->pa_cnt]);
+	free((void *)pap->pa_array[pap->pa_cnt]);
+	pap->pa_array[pap->pa_cnt] = 0;
 
 	return 1;
 }
 
 static char *
-pa_gen( pa_t *pap )
+pa_gen(pa_t *pap)
 {
 	size_t sz;
 	int i;
@@ -288,23 +288,23 @@ pa_gen( pa_t *pap )
 	char *p;
 
 	sz = 0;
-	for ( i = 0 ; i < pap->pa_cnt ; i++ ) {
-		sz += strlen( pap->pa_array[ i ] ) + 1;
+	for (i = 0 ; i < pap->pa_cnt ; i++) {
+		sz += strlen(pap->pa_array[i]) + 1;
 	}
-	if ( i == 0 )
+	if (i == 0)
 		sz++;
 	sz++;
 
-	retp = ( char * )malloc( sz );
+	retp = (char *)malloc(sz);
 
-	if (  pap->pa_cnt <= 0 ) {
-		assert(  pap->pa_cnt == 0 );
-		sprintf( retp, "/" );
+	if (pap->pa_cnt <= 0) {
+		assert(pap->pa_cnt == 0);
+		sprintf(retp, "/");
 	} else {
 		p = retp;
-		for ( i = 0 ; i < pap->pa_cnt ; i++ ) {
-			sprintf( p, "/%s", pap->pa_array[ i ] );
-			p += strlen( p );
+		for (i = 0 ; i < pap->pa_cnt ; i++) {
+			sprintf(p, "/%s", pap->pa_array[ i]);
+			p += strlen(p);
 		}
 	}
 
diff --git a/common/path.h b/common/path.h
index 9092233..f05f5c7 100644
--- a/common/path.h
+++ b/common/path.h
@@ -20,9 +20,9 @@
 
 /* various pathname helpers
  */
-extern char * path_reltoabs( char *dir, char *basedir );
-extern char *path_normalize( char *path );
-extern char * path_diff( char *path, char *base );
-extern int path_beginswith( char *path, char *base );
+extern char * path_reltoabs(char *dir, char *basedir);
+extern char *path_normalize(char *path);
+extern char * path_diff(char *path, char *base);
+extern int path_beginswith(char *path, char *base);
 
 #endif /* PATH_H */
diff --git a/common/qlock.c b/common/qlock.c
index 1db461d..ae36817 100644
--- a/common/qlock.c
+++ b/common/qlock.c
@@ -43,7 +43,7 @@ typedef size_t ordmap_t;
 	 * been allocated.
 	 */
 
-#define ORDMAX					( 8 * sizeof( ordmap_t ))
+#define ORDMAX					(8 * sizeof(ordmap_t))
 	/* ordinals must fit into a wordsize bitmap
 	 */
 
@@ -55,53 +55,53 @@ static __thread ordmap_t thread_ordmap;
 	/* holds the ordmap for each thread
 	 */
 
-#define QLOCK_ORDMAP_SET( ordmap, ord )	( ordmap |= 1U << ord )
+#define QLOCK_ORDMAP_SET(ordmap, ord)	(ordmap |= 1U << ord)
 	/* sets the ordinal bit in an ordmap
 	 */
 
-#define QLOCK_ORDMAP_CLR( ordmap, ord )	( ordmap &= ~( 1U << ord ))
+#define QLOCK_ORDMAP_CLR(ordmap, ord)	(ordmap &= ~(1U << ord))
 	/* clears the ordinal bit in an ordmap
 	 */
 
-#define QLOCK_ORDMAP_GET( ordmap, ord )	( ordmap & ( 1U << ord ))
+#define QLOCK_ORDMAP_GET(ordmap, ord)	(ordmap & (1U << ord))
 	/* checks if ordinal set in ordmap
 	 */
 
-#define QLOCK_ORDMAP_CHK( ordmap, ord )	( ordmap & (( 1U << ord ) - 1U ))
+#define QLOCK_ORDMAP_CHK(ordmap, ord)	(ordmap & ((1U << ord) - 1U))
 	/* checks if any bits less than ord are set in the ordmap
 	 */
 
 
 qlockh_t
-qlock_alloc( ix_t ord )
+qlock_alloc(ix_t ord)
 {
 	qlock_t *qlockp;
 
 	/* verify the ordinal is not already taken, and mark as taken
 	 */
-	assert( ! QLOCK_ORDMAP_GET( qlock_ordalloced, ord ));
-	QLOCK_ORDMAP_SET( qlock_ordalloced, ord );
+	assert(! QLOCK_ORDMAP_GET(qlock_ordalloced, ord));
+	QLOCK_ORDMAP_SET(qlock_ordalloced, ord);
 
 	/* allocate lock memory
 	 */
-	qlockp = ( qlock_t * )calloc( 1, sizeof( qlock_t ));
-	assert( qlockp );
+	qlockp = (qlock_t *)calloc(1, sizeof(qlock_t));
+	assert(qlockp);
 
 	/* initialize the mutex
 	 */
-	pthread_mutex_init( &qlockp->ql_mutex, NULL );
+	pthread_mutex_init(&qlockp->ql_mutex, NULL);
 
 	/* assign the ordinal position
 	 */
 	qlockp->ql_ord = ord;
 
-	return ( qlockh_t )qlockp;
+	return (qlockh_t)qlockp;
 }
 
 void
-qlock_lock( qlockh_t qlockh )
+qlock_lock(qlockh_t qlockh)
 {
-	qlock_t *qlockp = ( qlock_t * )qlockh;
+	qlock_t *qlockp = (qlock_t *)qlockh;
 	pthread_t tid;
 	/* REFERENCED */
 	int rval;
@@ -112,138 +112,138 @@ qlock_lock( qlockh_t qlockh )
 
 	/* assert that this lock not already held by this thread
 	 */
-	if ( QLOCK_ORDMAP_GET( thread_ordmap, qlockp->ql_ord )) {
-		mlog( MLOG_NORMAL | MLOG_WARNING | MLOG_NOLOCK,
+	if (QLOCK_ORDMAP_GET(thread_ordmap, qlockp->ql_ord)) {
+		mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_NOLOCK,
 		      _("lock already held: tid %lu ord %d map %x\n"),
 		      tid,
 		      qlockp->ql_ord,
-		      thread_ordmap );
+		      thread_ordmap);
 	}
-	assert( ! QLOCK_ORDMAP_GET( thread_ordmap, qlockp->ql_ord ));
+	assert(! QLOCK_ORDMAP_GET(thread_ordmap, qlockp->ql_ord));
 
 	/* assert that no locks with a lesser ordinal are held by this thread
 	 */
-	if ( QLOCK_ORDMAP_CHK( thread_ordmap, qlockp->ql_ord )) {
-		mlog( MLOG_NORMAL | MLOG_WARNING | MLOG_NOLOCK,
+	if (QLOCK_ORDMAP_CHK(thread_ordmap, qlockp->ql_ord)) {
+		mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_NOLOCK,
 		      _("lock ordinal violation: tid %lu ord %d map %x\n"),
 		      tid,
 		      qlockp->ql_ord,
-		      thread_ordmap );
+		      thread_ordmap);
 	}
-	assert( ! QLOCK_ORDMAP_CHK( thread_ordmap, qlockp->ql_ord ));
+	assert(! QLOCK_ORDMAP_CHK(thread_ordmap, qlockp->ql_ord));
 
 	/* acquire the lock
 	 */
-	rval = pthread_mutex_lock( &qlockp->ql_mutex );
-	assert( !rval );
+	rval = pthread_mutex_lock(&qlockp->ql_mutex);
+	assert(!rval);
 
 	/* add ordinal to this threads ordmap
 	 */
-	QLOCK_ORDMAP_SET( thread_ordmap, qlockp->ql_ord );
+	QLOCK_ORDMAP_SET(thread_ordmap, qlockp->ql_ord);
 }
 
 void
-qlock_unlock( qlockh_t qlockh )
+qlock_unlock(qlockh_t qlockh)
 {
-	qlock_t *qlockp = ( qlock_t * )qlockh;
+	qlock_t *qlockp = (qlock_t *)qlockh;
 	/* REFERENCED */
 	int rval;
 
 	/* verify lock is held by this thread
 	 */
-	assert( QLOCK_ORDMAP_GET( thread_ordmap, qlockp->ql_ord ));
+	assert(QLOCK_ORDMAP_GET(thread_ordmap, qlockp->ql_ord));
 
 	/* clear lock's ord from thread's ord map
 	 */
-	QLOCK_ORDMAP_CLR( thread_ordmap, qlockp->ql_ord );
+	QLOCK_ORDMAP_CLR(thread_ordmap, qlockp->ql_ord);
 
 	/* release the lock
 	 */
-	rval = pthread_mutex_unlock( &qlockp->ql_mutex );
-	assert( ! rval );
+	rval = pthread_mutex_unlock(&qlockp->ql_mutex);
+	assert(! rval);
 }
 
 qsemh_t
-qsem_alloc( ix_t cnt )
+qsem_alloc(ix_t cnt)
 {
 	sem_t *semp;
 	int rval;
 
 	/* allocate a semaphore
 	 */
-	semp = ( sem_t * )calloc( 1, sizeof( sem_t ));
-	assert( semp );
+	semp = (sem_t *)calloc(1, sizeof(sem_t));
+	assert(semp);
 
 	/* initialize the semaphore
 	 */
-	rval = sem_init( semp, 0, cnt );
-	assert( !rval );
+	rval = sem_init(semp, 0, cnt);
+	assert(!rval);
 
-	return ( qsemh_t )semp;
+	return (qsemh_t)semp;
 }
 
 void
-qsem_free( qsemh_t qsemh )
+qsem_free(qsemh_t qsemh)
 {
-	sem_t *semp = ( sem_t * )qsemh;
+	sem_t *semp = (sem_t *)qsemh;
 	int rval;
 
 	/* destroy the mutex and condition
 	 */
-	rval = sem_destroy( semp );
-	assert( !rval );
+	rval = sem_destroy(semp);
+	assert(!rval);
 
 	/* free the semaphore
 	 */
-	free( semp );
+	free(semp);
 }
 
 void
-qsemP( qsemh_t qsemh )
+qsemP(qsemh_t qsemh)
 {
-	sem_t *semp = ( sem_t * )qsemh;
+	sem_t *semp = (sem_t *)qsemh;
 	int rval;
 
 	/* "P" the semaphore
 	 */
-	rval = sem_wait( semp );
-	assert( !rval );
+	rval = sem_wait(semp);
+	assert(!rval);
 }
 
 void
-qsemV( qsemh_t qsemh )
+qsemV(qsemh_t qsemh)
 {
-	sem_t *semp = ( sem_t * )qsemh;
+	sem_t *semp = (sem_t *)qsemh;
 	int rval;
 
 	/* "V" the semaphore
 	 */
-	rval = sem_post( semp );
-	assert( !rval );
+	rval = sem_post(semp);
+	assert(!rval);
 }
 
 bool_t
-qsemPwouldblock( qsemh_t qsemh )
+qsemPwouldblock(qsemh_t qsemh)
 {
-	sem_t *semp = ( sem_t * )qsemh;
+	sem_t *semp = (sem_t *)qsemh;
 	int count;
 	int rval;
 
-	rval = sem_getvalue( semp, &count );
-	assert( !rval );
+	rval = sem_getvalue(semp, &count);
+	assert(!rval);
 
 	return count <= 0 ? BOOL_TRUE : BOOL_FALSE;
 }
 
 size_t
-qsemPavail( qsemh_t qsemh )
+qsemPavail(qsemh_t qsemh)
 {
-	sem_t *semp = ( sem_t * )qsemh;
+	sem_t *semp = (sem_t *)qsemh;
 	int count;
 	int rval;
 
-	rval = sem_getvalue( semp, &count );
-	assert( !rval );
+	rval = sem_getvalue(semp, &count);
+	assert(!rval);
 
 	return count < 0 ? 0 : count;
 }
diff --git a/common/qlock.h b/common/qlock.h
index 6c2dd18..52a8467 100644
--- a/common/qlock.h
+++ b/common/qlock.h
@@ -48,14 +48,14 @@ typedef void *qlockh_t;
 	/* opaque handle
 	 */
 
-extern qlockh_t qlock_alloc( ix_t ord );
+extern qlockh_t qlock_alloc(ix_t ord);
 	/* allocates a qlock with the specified ordinal. returns
 	 * NULL if lock can't be allocated.
 	 */
-extern void qlock_lock( qlockh_t qlockh );
+extern void qlock_lock(qlockh_t qlockh);
 	/* acquires the specified lock.
 	 */
-extern void qlock_unlock( qlockh_t qlockh );
+extern void qlock_unlock(qlockh_t qlockh);
 	/* releases the specified lock.
 	 */
 
@@ -64,23 +64,23 @@ typedef void *qsemh_t;
 	/* opaque handle
 	 */
 
-extern qsemh_t qsem_alloc( size_t cnt );
+extern qsemh_t qsem_alloc(size_t cnt);
 	/* allocates a counting semaphore initialized to the specified
 	 * count. returns a qsem handle
 	 */
-extern void qsem_free( qsemh_t qsemh );
+extern void qsem_free(qsemh_t qsemh);
 	/* frees the counting semaphore
 	 */
-extern void qsemP( qsemh_t qsemh );
+extern void qsemP(qsemh_t qsemh);
 	/* "P" (decrement) op
 	 */
-extern void qsemV( qsemh_t qsemh );
+extern void qsemV(qsemh_t qsemh);
 	/* "V" (increment) op
 	 */
-extern bool_t qsemPwouldblock( qsemh_t qsemh );
+extern bool_t qsemPwouldblock(qsemh_t qsemh);
 	/* returns true if a qsemP op would block
 	 */
-extern size_t qsemPavail( qsemh_t qsemh );
+extern size_t qsemPavail(qsemh_t qsemh);
 	/* number of resources available
 	 */
 
diff --git a/common/rec_hdr.h b/common/rec_hdr.h
index 1ab783c..a33c54e 100644
--- a/common/rec_hdr.h
+++ b/common/rec_hdr.h
@@ -51,7 +51,7 @@ struct rec_hdr {
 	int32_t capability;			/*   4  18 */
 		/* tape drive capabilities (from drive.h)
 		 */
-	char pad1[ 8 ];				/*   8  20 */
+	char pad1[8];				/*   8  20 */
 		/* padding
 		 */
 	off64_t file_offset;			/*   8  28 */
@@ -73,7 +73,7 @@ struct rec_hdr {
 
 	uuid_t dump_uuid;			/*  10  4c */
 
-	char pad2[ 0x1b4 ];			/* 1b4 200 */
+	char pad2[0x1b4];			/* 1b4 200 */
 };		/* pad to sizeof drive_hdr_t dh_specific */
 
 typedef struct rec_hdr rec_hdr_t;
diff --git a/common/ring.c b/common/ring.c
index 70c0f45..d1fbcb7 100644
--- a/common/ring.c
+++ b/common/ring.c
@@ -33,17 +33,17 @@
 #include "cldmgr.h"
 #include "ring.h"
 
-static int ring_slave_entry( void *ringctxp );
+static int ring_slave_entry(void *ringctxp);
 
 ring_t *
-ring_create( size_t ringlen,
+ring_create(size_t ringlen,
 	     size_t bufsz,
 	     bool_t pinpr,
 	     ix_t drive_index,
-	     int ( *readfunc )( void *clientctxp, char *bufp ),
-	     int ( *writefunc )( void *clientctxp, char *bufp ),
+	     int (*readfunc)(void *clientctxp, char *bufp),
+	     int (*writefunc)(void *clientctxp, char *bufp),
 	     void *clientctxp,
-	     int *rvalp )
+	     int *rvalp)
 {
 	bool_t ok;
 	ring_t *ringp;
@@ -55,8 +55,8 @@ ring_create( size_t ringlen,
 
 	/* allocate a ring descriptor
 	 */
-	ringp = ( ring_t * )calloc( 1, sizeof( ring_t ));
-	assert( ringp );
+	ringp = (ring_t *)calloc(1, sizeof(ring_t));
+	assert(ringp);
 	ringp->r_len = ringlen;
 	ringp->r_clientctxp = clientctxp;
 	ringp->r_readfunc = readfunc;
@@ -65,8 +65,8 @@ ring_create( size_t ringlen,
 	/* allocate counting semaphores for the ready and active queues,
 	 * and initialize the queue input and output indices.
 	 */
-	ringp->r_ready_qsemh = qsem_alloc( ringlen );
-	ringp->r_active_qsemh = qsem_alloc( 0 );
+	ringp->r_ready_qsemh = qsem_alloc(ringlen);
+	ringp->r_active_qsemh = qsem_alloc(0);
 	ringp->r_ready_in_ix = 0;
 	ringp->r_ready_out_ix = 0;
 	ringp->r_active_in_ix = 0;
@@ -85,87 +85,87 @@ ring_create( size_t ringlen,
 
 	/* allocate the ring messages
 	 */
-	ringp->r_msgp = ( ring_msg_t * )calloc( ringlen, sizeof( ring_msg_t ));
-	assert( ringp->r_msgp );
+	ringp->r_msgp = (ring_msg_t *)calloc(ringlen, sizeof(ring_msg_t));
+	assert(ringp->r_msgp);
 
 	/* allocate the buffers and initialize the messages
 	 */
-	for ( mix = 0 ; mix < ringlen ; mix++ ) {
-		ring_msg_t *msgp = &ringp->r_msgp[ mix ];
+	for (mix = 0 ; mix < ringlen ; mix++) {
+		ring_msg_t *msgp = &ringp->r_msgp[mix];
 		msgp->rm_mix = mix;
 		msgp->rm_op = RING_OP_NONE;
 		msgp->rm_stat = RING_STAT_INIT;
 		msgp->rm_user = 0;
 		msgp->rm_loc = RING_LOC_READY;
 
-		msgp->rm_bufp = ( char * )memalign( PGSZ, bufsz );
-		if ( ! msgp->rm_bufp ) {
+		msgp->rm_bufp = (char *)memalign(PGSZ, bufsz);
+		if (! msgp->rm_bufp) {
 			*rvalp = ENOMEM;
 			return 0;
 		}
-		if ( pinpr ) {
+		if (pinpr) {
 			int rval;
-			rval = mlock( ( void * )msgp->rm_bufp, bufsz );
-			if ( rval ) {
-				if ( errno == ENOMEM ) {
+			rval = mlock((void *)msgp->rm_bufp, bufsz);
+			if (rval) {
+				if (errno == ENOMEM) {
 					*rvalp = E2BIG;
 					return 0;
 				}
-				if ( errno == EPERM ) {
+				if (errno == EPERM) {
 					*rvalp = EPERM;
 					return 0;
 				}
-				assert( 0 );
+				assert(0);
 			}
 		}
 	}
 
 	/* kick off the slave thread
 	 */
-	ok = cldmgr_create( ring_slave_entry,
+	ok = cldmgr_create(ring_slave_entry,
 			    drive_index,
 			    _("slave"),
-			    ringp );
-	assert( ok );
+			    ringp);
+	assert(ok);
 
 	return ringp;
 }
 
 ring_msg_t *
-ring_get( ring_t *ringp )
+ring_get(ring_t *ringp)
 {
 	ring_msg_t *msgp;
 
 	/* assert client currently holds no messages
 	 */
-	assert( ringp->r_client_cnt == 0 );
+	assert(ringp->r_client_cnt == 0);
 
 	/* bump client message count and note if client needs to block
 	 */
 	ringp->r_client_msgcnt++;
-	if ( qsemPwouldblock( ringp->r_ready_qsemh )) {
+	if (qsemPwouldblock(ringp->r_ready_qsemh)) {
 		ringp->r_client_blkcnt++;
 	}
 
 	/* block until msg available on ready queue ("P")
 	 */
-	qsemP( ringp->r_ready_qsemh );
+	qsemP(ringp->r_ready_qsemh);
 
 	/* get a pointer to the next msg on the queue
 	 */
-	msgp = &ringp->r_msgp[ ringp->r_ready_out_ix ];
+	msgp = &ringp->r_msgp[ringp->r_ready_out_ix];
 
 	/* assert the message is where it belongs
 	 */
-	assert( msgp->rm_loc == RING_LOC_READY );
+	assert(msgp->rm_loc == RING_LOC_READY);
 
 	/* verify the message index has not become corrupted
 	 */
-	assert( msgp->rm_mix == ringp->r_ready_out_ix );
+	assert(msgp->rm_mix == ringp->r_ready_out_ix);
 
 	/* bump the output index
 	 */
-	ringp->r_ready_out_ix = ( ringp->r_ready_out_ix + 1 )
+	ringp->r_ready_out_ix = (ringp->r_ready_out_ix + 1)
 				%
 				ringp->r_len;
 
@@ -183,19 +183,19 @@ ring_get( ring_t *ringp )
 }
 
 void
-ring_put( ring_t *ringp, ring_msg_t *msgp )
+ring_put(ring_t *ringp, ring_msg_t *msgp)
 {
 	/* assert the client holds exactly one message
 	 */
-	assert( ringp->r_client_cnt == 1 );
+	assert(ringp->r_client_cnt == 1);
 
 	/* assert the client is returning the right message
 	 */
-	assert( msgp->rm_mix == ringp->r_active_in_ix );
+	assert(msgp->rm_mix == ringp->r_active_in_ix);
 
 	/* assert the message is where it belongs
 	 */
-	assert( msgp->rm_loc == RING_LOC_CLIENT );
+	assert(msgp->rm_loc == RING_LOC_CLIENT);
 
 	/* decrement the count of messages held by the client
 	 */
@@ -207,150 +207,150 @@ ring_put( ring_t *ringp, ring_msg_t *msgp )
 
 	/* bump the active queue input ix
 	 */
-	ringp->r_active_in_ix = ( ringp->r_active_in_ix + 1 )
+	ringp->r_active_in_ix = (ringp->r_active_in_ix + 1)
 				%
 				ringp->r_len;
 
 	/* bump the semaphore for the active queue ("V")
 	 */
-	qsemV( ringp->r_active_qsemh );
+	qsemV(ringp->r_active_qsemh);
 }
 
 void
-ring_reset( ring_t *ringp, ring_msg_t *msgp )
+ring_reset(ring_t *ringp, ring_msg_t *msgp)
 {
 	size_t mix;
 
 	/* if the client is not holding a message, get the next message
 	 */
-	if ( ringp->r_client_cnt == 0 ) {
-		assert( ! msgp );
-		msgp = ring_get( ringp );
-		assert( msgp );
-		assert( ringp->r_client_cnt == 1 );
+	if (ringp->r_client_cnt == 0) {
+		assert(! msgp);
+		msgp = ring_get(ringp);
+		assert(msgp);
+		assert(ringp->r_client_cnt == 1);
 	} else {
-		assert( msgp );
-		assert( ringp->r_client_cnt == 1 );
+		assert(msgp);
+		assert(ringp->r_client_cnt == 1);
 	}
 
 	/* tell the slave to abort
 	 */
 	msgp->rm_op = RING_OP_RESET;
-	ring_put( ringp, msgp );
+	ring_put(ringp, msgp);
 
 	/* wait for the reset to be acknowledged
 	 */
-	assert( ringp->r_client_cnt == 0 );
+	assert(ringp->r_client_cnt == 0);
 	do {
 		/* pull a message from the ready queue
 		 */
-		qsemP( ringp->r_ready_qsemh );
-		msgp = &ringp->r_msgp[ ringp->r_ready_out_ix ];
-		assert( msgp->rm_loc == RING_LOC_READY );
-		ringp->r_ready_out_ix = ( ringp->r_ready_out_ix + 1 )
+		qsemP(ringp->r_ready_qsemh);
+		msgp = &ringp->r_msgp[ringp->r_ready_out_ix];
+		assert(msgp->rm_loc == RING_LOC_READY);
+		ringp->r_ready_out_ix = (ringp->r_ready_out_ix + 1)
 					%
 					ringp->r_len;
 		ringp->r_client_cnt++;
-	} while ( msgp->rm_stat != RING_STAT_RESETACK );
-	assert( ringp->r_client_cnt == ringp->r_len );
+	} while (msgp->rm_stat != RING_STAT_RESETACK);
+	assert(ringp->r_client_cnt == ringp->r_len);
 
 	/* re-initialize the ring
 	 */
-	assert( qsemPavail( ringp->r_ready_qsemh ) == 0 );
-	assert( qsemPavail( ringp->r_active_qsemh ) == 0 );
+	assert(qsemPavail(ringp->r_ready_qsemh) == 0);
+	assert(qsemPavail(ringp->r_active_qsemh) == 0);
 	ringp->r_ready_in_ix = 0;
 	ringp->r_ready_out_ix = 0;
 	ringp->r_active_in_ix = 0;
 	ringp->r_active_out_ix = 0;
 	ringp->r_client_cnt = 0;
 	ringp->r_slave_cnt = 0;
-	for ( mix = 0 ; mix < ringp->r_len ; mix++ ) {
-		ring_msg_t *msgp = &ringp->r_msgp[ mix ];
+	for (mix = 0 ; mix < ringp->r_len ; mix++) {
+		ring_msg_t *msgp = &ringp->r_msgp[mix];
 		msgp->rm_mix = mix;
 		msgp->rm_op = RING_OP_NONE;
 		msgp->rm_stat = RING_STAT_INIT;
 		msgp->rm_user = 0;
 		msgp->rm_loc = RING_LOC_READY;
-		qsemV( ringp->r_ready_qsemh );
+		qsemV(ringp->r_ready_qsemh);
 	}
-	assert( qsemPavail( ringp->r_ready_qsemh ) == ringp->r_len );
-	assert( qsemPavail( ringp->r_active_qsemh ) == 0 );
+	assert(qsemPavail(ringp->r_ready_qsemh) == ringp->r_len);
+	assert(qsemPavail(ringp->r_active_qsemh) == 0);
 }
 
 void
-ring_destroy( ring_t *ringp )
+ring_destroy(ring_t *ringp)
 {
 	ring_msg_t *msgp;
 
 	/* the client must not be holding a message
 	 */
-	assert( ringp->r_client_cnt == 0 );
+	assert(ringp->r_client_cnt == 0);
 
 	/* get a message
 	 */
-	msgp = ring_get( ringp );
+	msgp = ring_get(ringp);
 
 	/* tell the slave to exit
 	 */
 	msgp->rm_op = RING_OP_DIE;
-	ring_put( ringp, msgp );
+	ring_put(ringp, msgp);
 
 	/* wait for the die to be acknowledged
 	 */
 	do {
 		/* pull a message from the ready queue
 		 */
-		qsemP( ringp->r_ready_qsemh );
-		msgp = &ringp->r_msgp[ ringp->r_ready_out_ix ];
-		assert( msgp->rm_loc == RING_LOC_READY );
-		ringp->r_ready_out_ix = ( ringp->r_ready_out_ix + 1 )
+		qsemP(ringp->r_ready_qsemh);
+		msgp = &ringp->r_msgp[ringp->r_ready_out_ix];
+		assert(msgp->rm_loc == RING_LOC_READY);
+		ringp->r_ready_out_ix = (ringp->r_ready_out_ix + 1)
 					%
 					ringp->r_len;
-	} while ( msgp->rm_stat != RING_STAT_DIEACK );
+	} while (msgp->rm_stat != RING_STAT_DIEACK);
 
 	/* the slave is dead.
 	 */
-	qsem_free( ringp->r_ready_qsemh );
-	qsem_free( ringp->r_active_qsemh );
-	free( ( void * )ringp );
+	qsem_free(ringp->r_ready_qsemh);
+	qsem_free(ringp->r_active_qsemh);
+	free((void *)ringp);
 }
 
 
 static ring_msg_t *
-ring_slave_get( ring_t *ringp )
+ring_slave_get(ring_t *ringp)
 {
 	ring_msg_t *msgp;
 
 	/* assert slave currently holds no messages
 	 */
-	assert( ringp->r_slave_cnt == 0 );
+	assert(ringp->r_slave_cnt == 0);
 
 	/* bump slave message count and note if slave needs to block
 	 */
 	ringp->r_slave_msgcnt++;
-	if ( qsemPwouldblock( ringp->r_active_qsemh )) {
+	if (qsemPwouldblock(ringp->r_active_qsemh)) {
 		ringp->r_slave_blkcnt++;
 	}
 
 	/* block until msg available on active queue ("P")
 	 */
-	qsemP( ringp->r_active_qsemh );
+	qsemP(ringp->r_active_qsemh);
 
 	/* get a pointer to the next msg on the queue
 	 */
-	msgp = &ringp->r_msgp[ ringp->r_active_out_ix ];
+	msgp = &ringp->r_msgp[ringp->r_active_out_ix];
 
 	/* assert the message is where it belongs
 	 */
-	assert( msgp->rm_loc == RING_LOC_ACTIVE );
+	assert(msgp->rm_loc == RING_LOC_ACTIVE);
 
 	/* verify the message index has not become corrupted
 	 */
-	assert( msgp->rm_mix == ringp->r_active_out_ix );
+	assert(msgp->rm_mix == ringp->r_active_out_ix);
 
 	/* bump the output index
 	 */
-	ringp->r_active_out_ix = ( ringp->r_active_out_ix + 1 )
+	ringp->r_active_out_ix = (ringp->r_active_out_ix + 1)
 				 %
 				 ringp->r_len;
 
@@ -368,19 +368,19 @@ ring_slave_get( ring_t *ringp )
 }
 
 static void
-ring_slave_put( ring_t *ringp, ring_msg_t *msgp )
+ring_slave_put(ring_t *ringp, ring_msg_t *msgp)
 {
 	/* assert the slave holds exactly one message
 	 */
-	assert( ringp->r_slave_cnt == 1 );
+	assert(ringp->r_slave_cnt == 1);
 
 	/* assert the slave is returning the right message
 	 */
-	assert( msgp->rm_mix == ringp->r_ready_in_ix );
+	assert(msgp->rm_mix == ringp->r_ready_in_ix);
 
 	/* assert the message is where it belongs
 	 */
-	assert( msgp->rm_loc == RING_LOC_SLAVE );
+	assert(msgp->rm_loc == RING_LOC_SLAVE);
 
 	/* decrement the count of messages held by the slave
 	 */
@@ -392,56 +392,56 @@ ring_slave_put( ring_t *ringp, ring_msg_t *msgp )
 
 	/* bump the ready queue input ix
 	 */
-	ringp->r_ready_in_ix = ( ringp->r_ready_in_ix + 1 )
+	ringp->r_ready_in_ix = (ringp->r_ready_in_ix + 1)
 			       %
 			       ringp->r_len;
 
 	/* bump the semaphore for the ready queue ("V")
 	 */
-	qsemV( ringp->r_ready_qsemh );
+	qsemV(ringp->r_ready_qsemh);
 }
 
 static int
-ring_slave_entry( void *ringctxp )
+ring_slave_entry(void *ringctxp)
 {
 	sigset_t blocked_set;
-	ring_t *ringp = ( ring_t * )ringctxp;
+	ring_t *ringp = (ring_t *)ringctxp;
 	enum { LOOPMODE_NORMAL, LOOPMODE_IGNORE, LOOPMODE_DIE } loopmode;
 
 	/* block signals, let the main thread handle them
 	 */
-	sigemptyset( &blocked_set );
-	sigaddset( &blocked_set, SIGINT );
-	sigaddset( &blocked_set, SIGHUP );
-	sigaddset( &blocked_set, SIGTERM );
-	sigaddset( &blocked_set, SIGQUIT );
-	sigaddset( &blocked_set, SIGALRM );
-	pthread_sigmask( SIG_SETMASK, &blocked_set, NULL );
+	sigemptyset(&blocked_set);
+	sigaddset(&blocked_set, SIGINT);
+	sigaddset(&blocked_set, SIGHUP);
+	sigaddset(&blocked_set, SIGTERM);
+	sigaddset(&blocked_set, SIGQUIT);
+	sigaddset(&blocked_set, SIGALRM);
+	pthread_sigmask(SIG_SETMASK, &blocked_set, NULL);
 
 	/* loop reading and precessing messages until told to die
 	 */
-	for ( loopmode = LOOPMODE_NORMAL ; loopmode != LOOPMODE_DIE ; ) {
+	for (loopmode = LOOPMODE_NORMAL ; loopmode != LOOPMODE_DIE ;) {
 		ring_msg_t *msgp;
 		int rval;
 
-		msgp = ring_slave_get( ringp );
+		msgp = ring_slave_get(ringp);
 		msgp->rm_rval = 0;
 
-		switch( msgp->rm_op ) {
+		switch(msgp->rm_op) {
 		case RING_OP_READ:
-			if ( loopmode == LOOPMODE_IGNORE ) {
+			if (loopmode == LOOPMODE_IGNORE) {
 				msgp->rm_stat = RING_STAT_IGNORE;
 				break;
 			}
-			if ( ! ringp->r_first_io_time ) {
-				ringp->r_first_io_time = time( 0 );
-				assert( ringp->r_first_io_time );
+			if (! ringp->r_first_io_time) {
+				ringp->r_first_io_time = time(0);
+				assert(ringp->r_first_io_time);
 			}
-			rval = ( ringp->r_readfunc )( ringp->r_clientctxp,
-						      msgp->rm_bufp );
+			rval = (ringp->r_readfunc)(ringp->r_clientctxp,
+						      msgp->rm_bufp);
 			msgp->rm_rval = rval;
 			ringp->r_all_io_cnt++;
-			if ( msgp->rm_rval == 0 ) {
+			if (msgp->rm_rval == 0) {
 				msgp->rm_stat = RING_STAT_OK;
 			} else {
 				msgp->rm_stat = RING_STAT_ERROR;
@@ -449,19 +449,19 @@ ring_slave_entry( void *ringctxp )
 			}
 			break;
 		case RING_OP_WRITE:
-			if ( loopmode == LOOPMODE_IGNORE ) {
+			if (loopmode == LOOPMODE_IGNORE) {
 				msgp->rm_stat = RING_STAT_IGNORE;
 				break;
 			}
-			if ( ! ringp->r_first_io_time ) {
-				ringp->r_first_io_time = time( 0 );
-				assert( ringp->r_first_io_time );
+			if (! ringp->r_first_io_time) {
+				ringp->r_first_io_time = time(0);
+				assert(ringp->r_first_io_time);
 			}
-			rval = ( ringp->r_writefunc )( ringp->r_clientctxp,
-						       msgp->rm_bufp );
+			rval = (ringp->r_writefunc)(ringp->r_clientctxp,
+						       msgp->rm_bufp);
 			msgp->rm_rval = rval;
 			ringp->r_all_io_cnt++;
-			if ( msgp->rm_rval == 0 ) {
+			if (msgp->rm_rval == 0) {
 				msgp->rm_stat = RING_STAT_OK;
 			} else {
 				msgp->rm_stat = RING_STAT_ERROR;
@@ -486,7 +486,7 @@ ring_slave_entry( void *ringctxp )
 			msgp->rm_stat = RING_STAT_IGNORE;
 			break;
 		}
-		ring_slave_put( ringp, msgp );
+		ring_slave_put(ringp, msgp);
 	}
 
 	return 0;
diff --git a/common/ring.h b/common/ring.h
index 6126b77..be4ae69 100644
--- a/common/ring.h
+++ b/common/ring.h
@@ -144,8 +144,8 @@ struct ring {
 	qsemh_t r_active_qsemh;
 	size_t r_client_cnt;
 	size_t r_slave_cnt;
-	int ( *r_readfunc )( void *contextp, char *bufp );
-	int ( *r_writefunc )( void *contextp, char *bufp );
+	int (*r_readfunc)(void *contextp, char *bufp);
+	int (*r_writefunc)(void *contextp, char *bufp);
 	void *r_clientctxp;
 };
 
@@ -164,34 +164,34 @@ typedef struct ring ring_t;
  * E2BIG - insufficient physical memory available for pinning;
  * EPERM - exceeds allowed amount of pinned down memory.
  */
-extern ring_t *ring_create( size_t ringlen,
+extern ring_t *ring_create(size_t ringlen,
 			    size_t bufsz,
 			    bool_t pinpr,
 			    ix_t drive_index,
-			    int ( * readfunc )( void *clientctxp, char *bufp ),
-			    int ( * writefunc )( void *clientctxp, char *bufp ),
+			    int (* readfunc)(void *clientctxp, char *bufp),
+			    int (* writefunc)(void *clientctxp, char *bufp),
 			    void *clientctxp,
-			    int *rvalp );
+			    int *rvalp);
 
 
 /* ring_get - get a message off the ready queue
  */
-extern ring_msg_t *ring_get( ring_t *ringp );
+extern ring_msg_t *ring_get(ring_t *ringp);
 
 
 /* ring_put - put a message on the active queue
  */
-extern void ring_put( ring_t *ringp, ring_msg_t *msgp );
+extern void ring_put(ring_t *ringp, ring_msg_t *msgp);
 
 
 /* ring_reset - re-initialize the ring, after the current I/O completes.
  * msgp must be NULL if the client is not currently holding a ring message.
  * otherwise it must point to that message.
  */
-extern void ring_reset( ring_t *ringp, ring_msg_t *msgp );
+extern void ring_reset(ring_t *ringp, ring_msg_t *msgp);
 
 /* ring_destroy - de-allocates ring
  */
-extern void ring_destroy( ring_t *ringp );
+extern void ring_destroy(ring_t *ringp);
 
 #endif /* RING_H */
diff --git a/common/stream.c b/common/stream.c
index eadaaea..64a112a 100644
--- a/common/stream.c
+++ b/common/stream.c
@@ -40,13 +40,13 @@ struct spm {
 };
 
 typedef struct spm spm_t;
-static spm_t spm[ STREAM_SIMMAX * 3 ];
+static spm_t spm[STREAM_SIMMAX * 3];
 static bool_t initialized = BOOL_FALSE;
 
 void
-stream_init( void )
+stream_init(void)
 {
-	( void )memset( ( void * )spm, 0, sizeof( spm ));
+	(void)memset((void *)spm, 0, sizeof(spm));
 	initialized = BOOL_TRUE;
 }
 
@@ -61,24 +61,24 @@ stream_init( void )
  */
 
 void
-stream_register( pthread_t tid, int streamix )
+stream_register(pthread_t tid, int streamix)
 {
 	spm_t *p = spm;
 	spm_t *ep = spm + N(spm);
 
-	assert( streamix < STREAM_SIMMAX );
+	assert(streamix < STREAM_SIMMAX);
 
 	lock();
-	for ( ; p < ep ; p++ ) {
-		if ( p->s_state == S_FREE ) {
+	for (; p < ep ; p++) {
+		if (p->s_state == S_FREE) {
 			p->s_state = S_RUNNING;
 			break;
 		}
 	}
 	unlock();
-	assert( p < ep );
+	assert(p < ep);
 
-	if ( p >= ep ) return;
+	if (p >= ep) return;
 
 	p->s_tid = tid;
 	p->s_ix = streamix;
@@ -89,40 +89,40 @@ stream_register( pthread_t tid, int streamix )
 
 /* NOTE: lock() must be held when calling stream_dead() */
 void
-stream_dead( pthread_t tid )
+stream_dead(pthread_t tid)
 {
 	spm_t *p = spm;
 	spm_t *ep = spm + N(spm);
 
-	for ( ; p < ep ; p++ )
-		if ( pthread_equal( p->s_tid, tid ) ) {
+	for (; p < ep ; p++)
+		if (pthread_equal(p->s_tid, tid)) {
 			p->s_state = S_ZOMBIE;
 			break;
 		}
-	assert( p < ep );
+	assert(p < ep);
 }
 
 void
-stream_free( pthread_t tid )
+stream_free(pthread_t tid)
 {
 	spm_t *p = spm;
 	spm_t *ep = spm + N(spm);
 
 	lock();
-	for ( ; p < ep ; p++ ) {
-		if ( pthread_equal( p->s_tid, tid ) ) {
-			(void) memset( (void *) p, 0, sizeof(spm_t) );
+	for (; p < ep ; p++) {
+		if (pthread_equal(p->s_tid, tid)) {
+			(void) memset((void *) p, 0, sizeof(spm_t));
 			p->s_state = S_FREE;
 			break;
 		}
 	}
 	unlock();
-	assert( p < ep );
+	assert(p < ep);
 }
 
 int
-stream_find_all( stream_state_t states[], int nstates,
-		 pthread_t tids[], int ntids )
+stream_find_all(stream_state_t states[], int nstates,
+		 pthread_t tids[], int ntids)
 {
 	int i, count = 0;
 	spm_t *p = spm;
@@ -134,7 +134,7 @@ stream_find_all( stream_state_t states[], int nstates,
 
 	/* lock - make sure we get a consistent snapshot of the stream status */
 	lock();
-	for ( ; p < ep && count < ntids; p++ )
+	for (; p < ep && count < ntids; p++)
 		for (i = 0; i < nstates; i++)
 			if (p->s_state == states[i]) {
 				tids[count++] = p->s_tid;
@@ -145,7 +145,7 @@ stream_find_all( stream_state_t states[], int nstates,
 }
 
 static spm_t *
-stream_find( pthread_t tid, stream_state_t s[], int nstates )
+stream_find(pthread_t tid, stream_state_t s[], int nstates)
 {
 	int i;
 	spm_t *p = spm;
@@ -154,8 +154,8 @@ stream_find( pthread_t tid, stream_state_t s[], int nstates )
 	assert(nstates > 0);
 
 	/* note we don't lock the stream array in this function */
-	for ( ; p < ep ; p++ )
-		if ( pthread_equal( p->s_tid, tid ) ) {
+	for (; p < ep ; p++)
+		if (pthread_equal(p->s_tid, tid)) {
 			/* check state */
 			for (i = 0; i < nstates; i++)
 				if (p->s_state == s[i])
@@ -165,13 +165,13 @@ stream_find( pthread_t tid, stream_state_t s[], int nstates )
 #ifdef STREAM_DEBUG
 	{
 		static const char *state_strings[] = { "S_FREE", "S_RUNNING", "S_ZOMBIE" };
-		mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE,
+		mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE,
 		      "stream_find(): no stream with tid: %lu and state%s:",
-		      tid, nstates == 1 ? "" : "s" );
+		      tid, nstates == 1 ? "" : "s");
 		for (i = 0; i < nstates; i++)
-			mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE,
+			mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE,
 			      " %s", state_strings[s[i]]);
-		mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE, "\n");
+		mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK | MLOG_BARE, "\n");
 	}
 #endif /* STREAM_DEBUG */
 
@@ -185,12 +185,12 @@ stream_find( pthread_t tid, stream_state_t s[], int nstates )
  */
 
 int
-stream_getix( pthread_t tid )
+stream_getix(pthread_t tid)
 {
 	stream_state_t states[] = { S_RUNNING };
 	spm_t *p;
 	int ix;
-	p = stream_find( tid, states, N(states) );
+	p = stream_find(tid, states, N(states));
 	ix = p ? p->s_ix : -1;
 	return ix;
 }
@@ -208,8 +208,8 @@ stream_getix( pthread_t tid )
 	spm_t *p;							\
 	pthread_t mytid = pthread_self();				\
 									\
-	if ( !pthread_equal(mytid, (tid))) {				\
-		mlog( MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,		\
+	if (!pthread_equal(mytid, (tid))) {				\
+		mlog(MLOG_DEBUG | MLOG_ERROR | MLOG_NOLOCK,		\
 		      "stream_set_" #field_name "(): "			\
 		      "foreign stream (tid %lu) "			\
 		      "not permitted to update this stream (tid %lu)\n",\
@@ -218,28 +218,28 @@ stream_getix( pthread_t tid )
 	}								\
 									\
 	lock();								\
-	p = stream_find( (tid), states, N(states) );			\
+	p = stream_find((tid), states, N(states));			\
 	if (p) p->s_exit_ ## field_name = (value);			\
 	unlock();
 
-void stream_set_code( pthread_t tid, int exit_code )
+void stream_set_code(pthread_t tid, int exit_code)
 {
-	stream_set( code, tid, exit_code );
+	stream_set(code, tid, exit_code);
 }
 
-void stream_set_return( pthread_t tid, rv_t rv )
+void stream_set_return(pthread_t tid, rv_t rv)
 {
-	stream_set( return, tid, rv );
+	stream_set(return, tid, rv);
 }
 
-void stream_set_hint( pthread_t tid, rv_t rv )
+void stream_set_hint(pthread_t tid, rv_t rv)
 {
-	stream_set( hint, tid, rv );
+	stream_set(hint, tid, rv);
 }
 
 
 bool_t
-stream_get_exit_status( pthread_t tid,
+stream_get_exit_status(pthread_t tid,
 			stream_state_t states[],
 			int nstates,
 			stream_state_t *state,
@@ -252,7 +252,7 @@ stream_get_exit_status( pthread_t tid,
 	spm_t *p;
 
 	lock();
-	p = stream_find( tid, states, nstates );
+	p = stream_find(tid, states, nstates);
 	if (! p) goto unlock;
 
 	if (state) *state = p->s_state;
@@ -268,7 +268,7 @@ stream_get_exit_status( pthread_t tid,
 }
 
 size_t
-stream_cnt( void )
+stream_cnt(void)
 {
 	spm_t *p = spm;
 	spm_t *ep = spm + N(spm);
@@ -276,19 +276,19 @@ stream_cnt( void )
 	size_t ixcnt;
 	size_t bitix;
 
-	assert( sizeof( ixmap ) * NBBY >= STREAM_SIMMAX );
+	assert(sizeof(ixmap) * NBBY >= STREAM_SIMMAX);
 
 	lock();
-	for ( ; p < ep ; p++ ) {
-		if ( p->s_state == S_RUNNING ) {
-			ixmap |= ( size_t )1 << p->s_ix;
+	for (; p < ep ; p++) {
+		if (p->s_state == S_RUNNING) {
+			ixmap |= (size_t)1 << p->s_ix;
 		}
 	}
 	unlock();
 
 	ixcnt = 0;
-	for ( bitix = 0 ; bitix < STREAM_SIMMAX ; bitix++ ) {
-		if ( ixmap & ( ( size_t )1 << bitix )) {
+	for (bitix = 0 ; bitix < STREAM_SIMMAX ; bitix++) {
+		if (ixmap & ((size_t)1 << bitix)) {
 			ixcnt++;
 		}
 	}
diff --git a/common/stream.h b/common/stream.h
index a83a5a5..b3417fa 100644
--- a/common/stream.h
+++ b/common/stream.h
@@ -41,21 +41,21 @@
 
 typedef enum { S_FREE, S_RUNNING, S_ZOMBIE } stream_state_t;
 
-extern void stream_init( void );
-extern void stream_register( pthread_t tid, int streamix );
+extern void stream_init(void);
+extern void stream_register(pthread_t tid, int streamix);
 /* NOTE: lock() must be held when calling stream_dead */
-extern void stream_dead( pthread_t tid );
-extern void stream_free( pthread_t tid );
-extern int stream_find_all( stream_state_t states[],
+extern void stream_dead(pthread_t tid);
+extern void stream_free(pthread_t tid);
+extern int stream_find_all(stream_state_t states[],
 			    int nstates,
 			    pthread_t tids[],
-			    int ntids );
-extern int stream_getix( pthread_t tid );
-extern void stream_set_code( pthread_t tid, int code );
-extern void stream_set_return( pthread_t tid, rv_t rv );
-extern void stream_set_hint( pthread_t tid, rv_t rv );
-extern bool_t stream_exists( pthread_t tid );
-extern bool_t stream_get_exit_status( pthread_t tid,
+			    int ntids);
+extern int stream_getix(pthread_t tid);
+extern void stream_set_code(pthread_t tid, int code);
+extern void stream_set_return(pthread_t tid, rv_t rv);
+extern void stream_set_hint(pthread_t tid, rv_t rv);
+extern bool_t stream_exists(pthread_t tid);
+extern bool_t stream_get_exit_status(pthread_t tid,
 				      stream_state_t states[],
 				      int nstates,
 				      stream_state_t *state,
@@ -63,7 +63,7 @@ extern bool_t stream_get_exit_status( pthread_t tid,
 				      int *exit_code,
 				      rv_t *exit_return,
 				      rv_t *exit_hint);
-extern size_t stream_cnt( void );
+extern size_t stream_cnt(void);
 
 
 #endif /* STREAM_H */
diff --git a/common/timeutil.c b/common/timeutil.c
index 0e52968..a25b0c4 100644
--- a/common/timeutil.c
+++ b/common/timeutil.c
@@ -38,12 +38,12 @@ ctime32_r(const time32_t *timep, char *buf)
 }
 
 char *
-ctimennl( const time32_t *clockp )
+ctimennl(const time32_t *clockp)
 {
-	char *p = ctime32( clockp );
+	char *p = ctime32(clockp);
 
-	if ( p && strlen( p ) > 0 ) {
-		p[ strlen( p ) - 1 ] = 0;
+	if (p && strlen(p) > 0) {
+		p[strlen(p) - 1] = 0;
 	}
 
 	return p;
diff --git a/common/timeutil.h b/common/timeutil.h
index b200855..5b9567d 100644
--- a/common/timeutil.h
+++ b/common/timeutil.h
@@ -24,14 +24,14 @@
 
 /* ctime32 - takes a time32_t instead of a time_t
  */
-extern char *ctime32( const time32_t *timep );
+extern char *ctime32(const time32_t *timep);
 
 /* ctime32_r - takes a time32_t instead of a time_t
  */
-extern char *ctime32_r( const time32_t *timep, char *buf );
+extern char *ctime32_r(const time32_t *timep, char *buf);
 
 /* ctimennl - ctime(3C) with newline removed
  */
-extern char *ctimennl( const time32_t *clockp );
+extern char *ctimennl(const time32_t *clockp);
 
 #endif /* TIMEUTIL_H */
diff --git a/common/ts_mtio.h b/common/ts_mtio.h
index 92fd889..9e4ae4c 100644
--- a/common/ts_mtio.h
+++ b/common/ts_mtio.h
@@ -42,7 +42,7 @@ typedef unsigned int    minor_t;
  * #define MTSEEK	22	 Seek to the given block number.  Not all
  *				 drives support this option.  For drives
  *				 that support audio, the block number
- *				 actually becomes the program number ( 0
+ *				 actually becomes the program number (0
  *				 meaning leadin area, 0xfffffffe meaning
  *				 leadout, and other values (currently 1-
  *				 799 decimal) the program #).  For seeking
diff --git a/common/types.h b/common/types.h
index b619667..080cc1a 100644
--- a/common/types.h
+++ b/common/types.h
@@ -43,8 +43,8 @@
  * for now we will
  */
 #define PGSZLOG2	12
-#define PGSZ		( 1 << PGSZLOG2 )
-#define PGMASK		( PGSZ - 1 )
+#define PGSZ		(1 << PGSZLOG2)
+#define PGMASK		(PGSZ - 1)
 
 /* integers
  */
@@ -68,37 +68,37 @@ typedef uint64_t xfs_ino_t;
 #define NBBY		8
 #endif
 
-#define	MKMAX( t, s )	( ( t )						\
-			  ( ( ( 1ull					\
+#define	MKMAX(t, s)	((t)						\
+			  (((1ull					\
 			        <<					\
-			        ( ( unsigned long long )sizeof( t )	\
+			        ((unsigned long long)sizeof(t)	\
 				  *					\
-				  ( unsigned long long )NBBY		\
+				  (unsigned long long)NBBY		\
 			          -					\
-			          ( s + 1ull )))			\
+			          (s + 1ull)))			\
 			      -						\
-			      1ull )					\
+			      1ull)					\
 			    *						\
 			    2ull					\
 			    +						\
-			    1ull ))
-#define MKSMAX( t )	MKMAX( t, 1ull )
-#define MKUMAX( t )	MKMAX( t, 0ull )
-#define INT32MAX	MKSMAX( int32_t )
-#define UINT32MAX	MKUMAX( uint32_t )
-#define SIZE32MAX	MKUMAX( size32_t )
-#define INT64MAX	MKSMAX( int64_t )
-#define UINT64MAX	MKUMAX( uint64_t )
-#define SIZE64MAX	MKUMAX( size64_t )
-#define INO64MAX	MKUMAX( xfs_ino_t )
-#define OFF64MAX	MKSMAX( off64_t )
-#define INTGENMAX	MKSMAX( int )
-#define UINTGENMAX	MKUMAX( uint )
-#define OFFMAX		MKSMAX( off_t )
-#define SIZEMAX		MKUMAX( size_t )
-#define IXMAX		MKUMAX( size_t )
-#define INOMAX		MKUMAX( ino_t )
-#define TIMEMAX		MKSMAX( time32_t )
+			    1ull))
+#define MKSMAX(t)	MKMAX(t, 1ull)
+#define MKUMAX(t)	MKMAX(t, 0ull)
+#define INT32MAX	MKSMAX(int32_t)
+#define UINT32MAX	MKUMAX(uint32_t)
+#define SIZE32MAX	MKUMAX(size32_t)
+#define INT64MAX	MKSMAX(int64_t)
+#define UINT64MAX	MKUMAX(uint64_t)
+#define SIZE64MAX	MKUMAX(size64_t)
+#define INO64MAX	MKUMAX(xfs_ino_t)
+#define OFF64MAX	MKSMAX(off64_t)
+#define INTGENMAX	MKSMAX(int)
+#define UINTGENMAX	MKUMAX(uint)
+#define OFFMAX		MKSMAX(off_t)
+#define SIZEMAX		MKUMAX(size_t)
+#define IXMAX		MKUMAX(size_t)
+#define INOMAX		MKUMAX(ino_t)
+#define TIMEMAX		MKSMAX(time32_t)
 #define INT16MAX	0x7fff
 #define UINT16MAX	0xffff
 
@@ -107,8 +107,8 @@ typedef uint64_t xfs_ino_t;
 typedef int bool_t;
 #define BOOL_TRUE	1
 #define BOOL_FALSE	0
-#define BOOL_UNKNOWN	( -1 )
-#define BOOL_ERROR	( -2 )
+#define BOOL_UNKNOWN	(-1)
+#define BOOL_ERROR	(-2)
 
 /* useful return code scheme
  * NOTE: that there are macros and error messages in common/types.h that should
@@ -122,7 +122,7 @@ typedef enum { RV_OK,		/* mission accomplished */
 	       RV_EOM,		/* hit end of media object */
 	       RV_ERROR,	/* operator error or resource exhaustion */
 	       RV_DONE,		/* return early because someone else did work */
-	       RV_INTR,		/* cldmgr_stop_requested( ) */
+	       RV_INTR,		/* cldmgr_stop_requested() */
 	       RV_CORRUPT,	/* stopped because corrupt data encountered */
 	       RV_QUIT,		/* stop using resource */
 	       RV_DRIVE,	/* drive quit working */
diff --git a/common/util.c b/common/util.c
index 70b17eb..081a40f 100644
--- a/common/util.c
+++ b/common/util.c
@@ -38,31 +38,31 @@
 extern size_t pgsz;
 
 int
-write_buf( char *bufp,
+write_buf(char *bufp,
 	   size_t bufsz,
 	   void *contextp,
 	   gwbfp_t get_write_buf_funcp,
-	   wfp_t write_funcp )
+	   wfp_t write_funcp)
 {
 	char *mbufp;	/* buffer obtained from manager */
 	size_t mbufsz;/* size of buffer obtained from manager */
 
-	while ( bufsz ) {
+	while (bufsz) {
 		int rval;
 
-		assert( bufsz > 0 );
-		mbufp = ( *get_write_buf_funcp )( contextp, bufsz, &mbufsz );
-		assert( mbufsz <= bufsz );
-		if ( bufp ) {
-			(void)memcpy( ( void * )mbufp, ( void * )bufp, mbufsz );
+		assert(bufsz > 0);
+		mbufp = (*get_write_buf_funcp)(contextp, bufsz, &mbufsz);
+		assert(mbufsz <= bufsz);
+		if (bufp) {
+			(void)memcpy((void *)mbufp, (void *)bufp, mbufsz);
 		} else {
-			(void)memset( ( void * )mbufp, 0, mbufsz );
+			(void)memset((void *)mbufp, 0, mbufsz);
 		}
-		rval = ( * write_funcp )( contextp, mbufp, mbufsz );
-		if ( rval ) {
+		rval = (* write_funcp)(contextp, mbufp, mbufsz);
+		if (rval) {
 			return rval;
 		}
-		if ( bufp ) {
+		if (bufp) {
 			bufp += mbufsz;
 		}
 		bufsz -= mbufsz;
@@ -72,12 +72,12 @@ write_buf( char *bufp,
 }
 
 int
-read_buf( char *bufp,
+read_buf(char *bufp,
 	  size_t bufsz,
 	  void *contextp,
 	  rfp_t read_funcp,
 	  rrbfp_t return_read_buf_funcp,
-	  int *statp )
+	  int *statp)
 {
 	char *mbufp;		/* manager's buffer pointer */
 	size_t mbufsz;	/* size of manager's buffer */
@@ -85,37 +85,37 @@ read_buf( char *bufp,
 
 	nread = 0;
 	*statp = 0;
-	while ( bufsz ) {
-		mbufp = ( * read_funcp )( contextp, bufsz, &mbufsz, statp );
-		if ( *statp ) {
+	while (bufsz) {
+		mbufp = (* read_funcp)(contextp, bufsz, &mbufsz, statp);
+		if (*statp) {
 			break;
 		}
-		assert( mbufsz <= bufsz );
-		if ( bufp ) {
-			( void )memcpy( (void *)bufp, (void *)mbufp, mbufsz );
+		assert(mbufsz <= bufsz);
+		if (bufp) {
+			(void)memcpy((void *)bufp, (void *)mbufp, mbufsz);
 			bufp += mbufsz;
 		}
 		bufsz -= mbufsz;
-		nread += ( int )mbufsz;
-		( * return_read_buf_funcp )( contextp, mbufp, mbufsz );
+		nread += (int)mbufsz;
+		(* return_read_buf_funcp)(contextp, mbufp, mbufsz);
 	}
 
 	return nread;
 }
 
 char
-*strncpyterm( char *s1, char *s2, size_t n )
+*strncpyterm(char *s1, char *s2, size_t n)
 {
 	char *rval;
 
-	if ( n < 1 ) return 0;
-	rval = strncpy( s1, s2, n );
-	s1[ n - 1 ] = 0;
+	if (n < 1) return 0;
+	rval = strncpy(s1, s2, n);
+	s1[n - 1] = 0;
 	return rval;
 }
 
 int
-bigstat_iter( jdm_fshandle_t *fshandlep,
+bigstat_iter(jdm_fshandle_t *fshandlep,
 	      int fsfd,
 	      int selector,
 	      xfs_ino_t start_ino,
@@ -124,9 +124,9 @@ bigstat_iter( jdm_fshandle_t *fshandlep,
 	      bstat_seekfp_t seekfp,
 	      void * seek_arg1,
 	      int *statp,
-	      bool_t ( pfp )( int ),
+	      bool_t (pfp)(int),
 	      xfs_bstat_t *buf,
-	      size_t buflenin )
+	      size_t buflenin)
 {
 	__s32 buflenout;
 	xfs_ino_t lastino;
@@ -141,20 +141,20 @@ bigstat_iter( jdm_fshandle_t *fshandlep,
 	/* NOT COOL: open will affect root dir's access time
 	 */
 
-	mlog( MLOG_NITTY,
+	mlog(MLOG_NITTY,
 	      "bulkstat iteration initiated: start_ino == %llu\n",
-	      start_ino );
+	      start_ino);
 
 	/* quirk of the interface: I want to play in terms of the
 	 * ino to begin with, and ino 0 is not used. so, ...
 	 */
-	if ( start_ino > 0 ) {
+	if (start_ino > 0) {
 		lastino = start_ino - 1;
 	} else {
 		lastino = 0;
 	}
-	mlog( MLOG_NITTY + 1,
-	      "calling bulkstat\n" );
+	mlog(MLOG_NITTY + 1,
+	      "calling bulkstat\n");
 
 	bulkstatcnt = 0;
 	bulkreq.lastip = (__u64 *)&lastino;
@@ -165,101 +165,101 @@ bigstat_iter( jdm_fshandle_t *fshandlep,
 		xfs_bstat_t *p;
 		xfs_bstat_t *endp;
 
-		if ( buflenout == 0 ) {
-			mlog( MLOG_NITTY + 1,
+		if (buflenout == 0) {
+			mlog(MLOG_NITTY + 1,
 			      "bulkstat returns buflen %d\n",
-			      buflenout );
+			      buflenout);
 			return 0;
 		}
-		mlog( MLOG_NITTY + 1,
+		mlog(MLOG_NITTY + 1,
 		      "bulkstat returns buflen %d ino %llu\n",
 		      buflenout,
-		      buf->bs_ino );
-		for ( p = buf, endp = buf + buflenout ; p < endp ; p++ ) {
+		      buf->bs_ino);
+		for (p = buf, endp = buf + buflenout ; p < endp ; p++) {
 			int rval;
 
-			if ( p->bs_ino == 0 )
+			if (p->bs_ino == 0)
 				continue;
 
-			if ( !p->bs_nlink || !p->bs_mode ) {
+			if (!p->bs_nlink || !p->bs_mode) {
 				/* inode being modified, get synced data */
-				mlog( MLOG_NITTY + 1,
+				mlog(MLOG_NITTY + 1,
 				      "ino %llu needed second bulkstat\n",
-				      p->bs_ino );
+				      p->bs_ino);
 
-				if( bigstat_one( fsfd, p->bs_ino, p ) < 0 ) {
-				    mlog( MLOG_WARNING,
+				if(bigstat_one(fsfd, p->bs_ino, p) < 0) {
+				    mlog(MLOG_WARNING,
 					  _("failed to get bulkstat information for inode %llu\n"),
-					  p->bs_ino );
+					  p->bs_ino);
 				    continue;
 				}
-				if ( !p->bs_nlink || !p->bs_mode || !p->bs_ino ) {
-					mlog( MLOG_TRACE,
+				if (!p->bs_nlink || !p->bs_mode || !p->bs_ino) {
+					mlog(MLOG_TRACE,
 					      _("failed to get valid bulkstat information for inode %llu\n"),
-					      p->bs_ino );
+					      p->bs_ino);
 					continue;
 				}
 			}
 
-			if ( ( p->bs_mode & S_IFMT ) == S_IFDIR ) {
-				if ( ! ( selector & BIGSTAT_ITER_DIR )){
+			if ((p->bs_mode & S_IFMT) == S_IFDIR) {
+				if (! (selector & BIGSTAT_ITER_DIR)){
 					continue;
 				}
 			} else {
-				if ( ! ( selector & BIGSTAT_ITER_NONDIR )){
+				if (! (selector & BIGSTAT_ITER_NONDIR)){
 					continue;
 				}
 			}
-			rval = ( * fp )( cb_arg1, fshandlep, fsfd, p );
-			if ( rval ) {
+			rval = (* fp)(cb_arg1, fshandlep, fsfd, p);
+			if (rval) {
 				*statp = rval;
 				return 0;
 			}
-			if ( pfp ) ( pfp )( PREEMPT_PROGRESSONLY );
+			if (pfp) (pfp)(PREEMPT_PROGRESSONLY);
 		}
 
-		if ( pfp && (++bulkstatcnt % 10) == 0 &&
-		     ( pfp )( PREEMPT_FULL )) {
+		if (pfp && (++bulkstatcnt % 10) == 0 &&
+		     (pfp)(PREEMPT_FULL)) {
 			return EINTR;
 		}
 
 		if (seekfp) {
 			lastino = seekfp(seek_arg1, lastino);
 			if (lastino == INO64MAX) {
-				mlog( MLOG_DEBUG,
+				mlog(MLOG_DEBUG,
 				      "bulkstat seeked to EOS\n");
 				return 0;
 			}
 
-			mlog( MLOG_DEBUG,
+			mlog(MLOG_DEBUG,
 			      "bulkstat seeked to %llu\n", lastino);
 
 			lastino = (lastino > 0) ? lastino - 1 : 0;
 		}
 
-		mlog( MLOG_NITTY + 1,
-		      "calling bulkstat\n" );
+		mlog(MLOG_NITTY + 1,
+		      "calling bulkstat\n");
 	}
 
 	saved_errno = errno;
 
-	mlog( MLOG_NORMAL,
+	mlog(MLOG_NORMAL,
 	      _("syssgi( SGI_FS_BULKSTAT ) on fsroot failed: %s\n"),
-	      strerror( saved_errno ));
+	      strerror(saved_errno));
 
 	return saved_errno;
 }
 
 /* ARGSUSED */
 int
-bigstat_one( int fsfd,
+bigstat_one(int fsfd,
 	     xfs_ino_t ino,
-	     xfs_bstat_t *statp )
+	     xfs_bstat_t *statp)
 {
         xfs_fsop_bulkreq_t bulkreq;
 	int count = 0;
 
-	assert( ino > 0 );
+	assert(ino > 0);
         bulkreq.lastip = (__u64 *)&ino;
         bulkreq.icount = 1;
         bulkreq.ubuffer = statp;
@@ -271,12 +271,12 @@ bigstat_one( int fsfd,
  */
 #define INOGRPLEN	256
 int
-inogrp_iter( int fsfd,
-	     int ( * fp )( void *arg1,
+inogrp_iter(int fsfd,
+	     int (* fp)(void *arg1,
 				int fsfd,
-				xfs_inogrp_t *inogrp ),
+				xfs_inogrp_t *inogrp),
 	     void * arg1,
-	     int *statp )
+	     int *statp)
 {
 	xfs_ino_t lastino;
 	int inogrpcnt;
@@ -304,15 +304,15 @@ inogrp_iter( int fsfd,
 	while (!ioctl(fsfd, XFS_IOC_FSINUMBERS, &bulkreq)) {
 		xfs_inogrp_t *p, *endp;
 
-		if ( inogrpcnt == 0 ) {
+		if (inogrpcnt == 0) {
 			free(igrp);
 			return 0;
 		}
-		for ( p = igrp, endp = igrp + inogrpcnt ; p < endp ; p++ ) {
+		for (p = igrp, endp = igrp + inogrpcnt ; p < endp ; p++) {
 			int rval;
 
-			rval = ( * fp )( arg1, fsfd, p );
-			if ( rval ) {
+			rval = (* fp)(arg1, fsfd, p);
+			if (rval) {
 				*statp = rval;
 				free(igrp);
 				return 0;
@@ -337,18 +337,18 @@ inogrp_iter( int fsfd,
  * caller may supply a dirent buffer. if not, will malloc one
  */
 int
-diriter( jdm_fshandle_t *fshandlep,
+diriter(jdm_fshandle_t *fshandlep,
 	 int fsfd,
 	 xfs_bstat_t *statp,
-	 int ( *cbfp )( void *arg1,
+	 int (*cbfp)(void *arg1,
 			     jdm_fshandle_t *fshandlep,
 			     int fsfd,
 			     xfs_bstat_t *statp,
-			     char *namep ),
+			     char *namep),
 	 void *arg1,
 	 int *cbrvalp,
 	 char *usrgdp,
-	 size_t usrgdsz )
+	 size_t usrgdsz)
 {
 	size_t gdsz;
 	struct dirent *gdp;
@@ -357,105 +357,105 @@ diriter( jdm_fshandle_t *fshandlep,
 	int scrval;
 	int cbrval;
 
-	if ( usrgdp ) {
-		assert( usrgdsz >= sizeof( struct dirent ) );
+	if (usrgdp) {
+		assert(usrgdsz >= sizeof(struct dirent));
 		gdsz = usrgdsz;
-		gdp = ( struct dirent * )usrgdp;
+		gdp = (struct dirent *)usrgdp;
 	} else {
 		gdsz = pgsz;
-		gdp = ( struct dirent * )malloc( gdsz );
-		assert( gdp );
+		gdp = (struct dirent *)malloc(gdsz);
+		assert(gdp);
 	}
 
 	/* open the directory
 	 */
-	fd = jdm_open( fshandlep, statp, O_RDONLY );
-	if ( fd < 0 ) {
-		mlog( MLOG_NORMAL,
+	fd = jdm_open(fshandlep, statp, O_RDONLY);
+	if (fd < 0) {
+		mlog(MLOG_NORMAL,
 		      _("WARNING: unable to open directory ino %llu: %s\n"),
 		      statp->bs_ino,
-		      strerror( errno ));
+		      strerror(errno));
 		*cbrvalp = 0;
-		if ( ! usrgdp ) {
-			free( ( void * )gdp );
+		if (! usrgdp) {
+			free((void *)gdp);
 		}
 		return -1;
 	}
-	assert( ( statp->bs_mode & S_IFMT ) == S_IFDIR );
+	assert((statp->bs_mode & S_IFMT) == S_IFDIR);
 
 	/* lots of buffering done here, to achieve OS-independence.
 	 * if proves to be to much overhead, can streamline.
 	 */
 	scrval = 0;
 	cbrval = 0;
-	for ( gdcnt = 1 ; ; gdcnt++ ) {
+	for (gdcnt = 1 ; ; gdcnt++) {
 		struct dirent *p;
 		int nread;
 		register size_t reclen;
 
-		assert( scrval == 0 );
-		assert( cbrval == 0 );
+		assert(scrval == 0);
+		assert(cbrval == 0);
 
-		nread = getdents_wrap( fd, (char *)gdp, gdsz );
+		nread = getdents_wrap(fd, (char *)gdp, gdsz);
 
 		/* negative count indicates something very bad happened;
 		 * try to gracefully end this dir.
 		 */
-		if ( nread < 0 ) {
-			mlog( MLOG_NORMAL,
+		if (nread < 0) {
+			mlog(MLOG_NORMAL,
 			      _("WARNING: unable to read dirents (%d) for "
 			      "directory ino %llu: %s\n"),
 			      gdcnt,
 			      statp->bs_ino,
-			      strerror( errno ));
+			      strerror(errno));
 			nread = 0; /* pretend we are done */
 		}
 
 		/* no more directory entries: break;
 		 */
-		if ( nread == 0 ) {
+		if (nread == 0) {
 			break;
 		}
 
 		/* translate and invoke cb each entry: skip "." and "..".
 		 */
-		for ( p = gdp,
-		      reclen = ( size_t )p->d_reclen
+		for (p = gdp,
+		      reclen = (size_t)p->d_reclen
 		      ;
 		      nread > 0
 		      ;
-		      nread -= ( int )reclen,
-		      assert( nread >= 0 ),
-		      p = ( struct dirent * )( ( char * )p + reclen ),
-		      reclen = ( size_t )p->d_reclen ) {
+		      nread -= (int)reclen,
+		      assert(nread >= 0),
+		      p = (struct dirent *)((char *)p + reclen),
+		      reclen = (size_t)p->d_reclen) {
 			xfs_bstat_t statbuf;
-			assert( scrval == 0 );
-			assert( cbrval == 0 );
+			assert(scrval == 0);
+			assert(cbrval == 0);
 
 			/* skip "." and ".."
 			 */
-			if ( *( p->d_name + 0 ) == '.'
+			if (*(p->d_name + 0) == '.'
 			     &&
-			     ( *( p->d_name + 1 ) == 0
+			     (*(p->d_name + 1) == 0
 			       ||
-			       ( *( p->d_name + 1 ) == '.'
+			       (*(p->d_name + 1) == '.'
 				 &&
-				 *( p->d_name + 2 ) == 0 ))) {
+				 *(p->d_name + 2) == 0))) {
 				continue;
 			}
 
 			/* use bigstat
 			 */
-			scrval = bigstat_one( fsfd,
+			scrval = bigstat_one(fsfd,
 					      p->d_ino,
-					      &statbuf );
-			if ( scrval ) {
-				mlog( MLOG_NORMAL,
+					      &statbuf);
+			if (scrval) {
+				mlog(MLOG_NORMAL,
 				      _("WARNING: could not stat "
 				      "dirent %s ino %llu: %s\n"),
 				      p->d_name,
-				      ( xfs_ino_t )p->d_ino,
-				      strerror( errno ));
+				      (xfs_ino_t)p->d_ino,
+				      strerror(errno));
 				scrval = 0;
 				continue;
 			}
@@ -464,45 +464,45 @@ diriter( jdm_fshandle_t *fshandlep,
 			 * occupied more than 32 bits, warn and skip.
 			 */
 #ifndef __USE_LARGEFILE64
-			if ( statbuf.bs_ino > ( xfs_ino_t )INOMAX ) {
-				mlog( MLOG_NORMAL,
+			if (statbuf.bs_ino > (xfs_ino_t)INOMAX) {
+				mlog(MLOG_NORMAL,
 				      _("WARNING: unable to process dirent %s: "
 				      "ino %llu too large\n"),
 				      p->d_name,
-				      ( xfs_ino_t )p->d_ino );
+				      (xfs_ino_t)p->d_ino);
 				continue;
 			}
 #endif
 
 			/* invoke the callback
 			 */
-			cbrval = ( * cbfp )( arg1,
+			cbrval = (* cbfp)(arg1,
 					     fshandlep,
 					     fsfd,
 					     &statbuf,
-					     p->d_name );
+					     p->d_name);
 
 			/* abort the iteration if the callback returns non-zero
 			 */
-			if ( cbrval ) {
+			if (cbrval) {
 				break;
 			}
 		}
 
-		if ( scrval || cbrval ) {
+		if (scrval || cbrval) {
 			break;
 		}
 	}
 
-	( void )close( fd );
-	if ( ! usrgdp ) {
-		free( ( void * )gdp );
+	(void)close(fd);
+	if (! usrgdp) {
+		free((void *)gdp);
 	}
 
-	if ( scrval ) {
+	if (scrval) {
 		*cbrvalp = 0;
 		return -1;
-	} else if ( cbrval ) {
+	} else if (cbrval) {
 		*cbrvalp = cbrval;
 		return 1;
 	} else {
@@ -512,7 +512,7 @@ diriter( jdm_fshandle_t *fshandlep,
 }
 
 int
-cvtnum( int blocksize, char *s )
+cvtnum(int blocksize, char *s)
 {
 	int i;
 	char *sp;
diff --git a/common/util.h b/common/util.h
index 07fdd36..ab43739 100644
--- a/common/util.h
+++ b/common/util.h
@@ -32,14 +32,14 @@
  *
  * if bufp is null, writes bufsz zeros.
  */
-typedef char * ( * gwbfp_t )( void *contextp, size_t wantedsz, size_t *szp);
-typedef int ( * wfp_t )( void *contextp, char *bufp, size_t bufsz );
+typedef char * (* gwbfp_t)(void *contextp, size_t wantedsz, size_t *szp);
+typedef int (* wfp_t)(void *contextp, char *bufp, size_t bufsz);
 
-extern int write_buf( char *bufp,
+extern int write_buf(char *bufp,
 			   size_t bufsz,
 			   void *contextp,
 			   gwbfp_t get_write_buf_funcp,
-			   wfp_t write_funcp );
+			   wfp_t write_funcp);
 
 
 /* read_buf - converts the normal manager read method into something simpler
@@ -56,21 +56,21 @@ extern int write_buf( char *bufp,
  * status of the first failure of the read funcp. if no read failures occur,
  * *statp will be zero.
  */
-typedef char * ( *rfp_t )( void *contextp, size_t wantedsz, size_t *szp, int *statp );
-typedef void ( * rrbfp_t )( void *contextp, char *bufp, size_t bufsz );
+typedef char * (*rfp_t)(void *contextp, size_t wantedsz, size_t *szp, int *statp);
+typedef void (* rrbfp_t)(void *contextp, char *bufp, size_t bufsz);
 
-extern int read_buf( char *bufp,
+extern int read_buf(char *bufp,
 			  size_t bufsz,
 			  void *contextp,
 			  rfp_t read_funcp,
 			  rrbfp_t return_read_buf_funcp,
-			  int *statp );
+			  int *statp);
 
 
 
 /* strncpyterm - like strncpy, but guarantees the destination is null-terminated
  */
-extern char *strncpyterm( char *s1, char *s2, size_t n );
+extern char *strncpyterm(char *s1, char *s2, size_t n);
 
 /* bigstat - efficient file status gatherer. presents an iterative
  * callback interface, invoking the caller's callback for each in-use
@@ -80,19 +80,19 @@ extern char *strncpyterm( char *s1, char *s2, size_t n );
  * stat is set to zero. return value set to errno if the system call fails,
  * or EINTR if optional pre-emption func returns TRUE.
  */
-#define BIGSTAT_ITER_DIR	( 1 << 0 )
-#define BIGSTAT_ITER_NONDIR	( 1 << 1 )
-#define BIGSTAT_ITER_ALL	( ~0 )
+#define BIGSTAT_ITER_DIR	(1 << 0)
+#define BIGSTAT_ITER_NONDIR	(1 << 1)
+#define BIGSTAT_ITER_ALL	(~0)
 
 typedef int (*bstat_cbfp_t)(void *arg1,
 				 jdm_fshandle_t *fshandlep,
 				 int fsfd,
-				 xfs_bstat_t *statp );
+				 xfs_bstat_t *statp);
 
 typedef xfs_ino_t (*bstat_seekfp_t)(void *arg1,
 				    xfs_ino_t lastino);
 
-extern int bigstat_iter( jdm_fshandle_t *fshandlep,
+extern int bigstat_iter(jdm_fshandle_t *fshandlep,
 			      int fsfd,
 			      int selector,
 			      xfs_ino_t start_ino,
@@ -101,20 +101,20 @@ extern int bigstat_iter( jdm_fshandle_t *fshandlep,
 			      bstat_seekfp_t seekfp,
 			      void * seek_arg1,
 			      int *statp,
-			      bool_t ( pfp )( int ), /* preemption chk func */
+			      bool_t (pfp)(int), /* preemption chk func */
 			      xfs_bstat_t *buf,
-			      size_t buflen );
+			      size_t buflen);
 
-extern int bigstat_one( int fsfd,
+extern int bigstat_one(int fsfd,
 			     xfs_ino_t ino,
-			     xfs_bstat_t *statp );
+			     xfs_bstat_t *statp);
 
-extern int inogrp_iter( int fsfd,
-			     int ( * fp )( void *arg1,
+extern int inogrp_iter(int fsfd,
+			     int (* fp)(void *arg1,
 				     		int fsfd,
-						xfs_inogrp_t *inogrp ),
+						xfs_inogrp_t *inogrp),
 			     void * arg1,
-			     int *statp );
+			     int *statp);
 
 /* calls the callback for every entry in the directory specified
  * by the stat buffer. supplies the callback with a file system
@@ -122,31 +122,31 @@ extern int inogrp_iter( int fsfd,
  *
  * NOTE: does NOT invoke callback for "." or ".."!
  *
- * caller may supply getdents buffer. size must be >= sizeof( dirent_t )
+ * caller may supply getdents buffer. size must be >= sizeof(dirent_t)
  * + MAXPATHLEN. if not supplied (usrgdp NULL), one will be malloc()ed.
  *
  * if the callback returns non-zero, returns 1 with cbrval set to the
  * callback's return value. if syscall fails, returns -1 with errno set.
  * otherwise returns 0.
  */
-extern int diriter( jdm_fshandle_t *fshandlep,
+extern int diriter(jdm_fshandle_t *fshandlep,
 			 int fsfd,
 			 xfs_bstat_t *statp,
-			 int ( *cbfp )( void *arg1,
+			 int (*cbfp)(void *arg1,
 					     jdm_fshandle_t *fshandlep,
 					     int fsfd,
 					     xfs_bstat_t *statp,
-					     char *namep ),
+					     char *namep),
 			 void *arg1,
 			 int *cbrvalp,
 			 char *usrgdp,
-			 size_t usrgdsz );
+			 size_t usrgdsz);
 
 
 
 /* macro to copy uuid structures
  */
-#define COPY_LABEL( lab1, lab2) ( bcopy( lab1, lab2, GLOBAL_HDR_STRING_SZ) )
+#define COPY_LABEL(lab1, lab2) (bcopy(lab1, lab2, GLOBAL_HDR_STRING_SZ))
 
 /*
  * Align pointer up to alignment
