diff --git a/dump/content.c b/dump/content.c
index 7890eb9..62a4f13 100644
--- a/dump/content.c
+++ b/dump/content.c
@@ -74,20 +74,20 @@
 /*
  * max "unsigned long long int"
  */
-#define ULONGLONG_MAX	18446744073709551615LLU
+#define ULONGLONG_MAX   18446744073709551615LLU
 
 /*
  * legal range of dump levels
  */
-#define LEVEL_DEFAULT	0
-#define LEVEL_MAX	9
+#define LEVEL_DEFAULT   0
+#define LEVEL_MAX       9
 
 /*
  * ordinary files as big or bigger than this many pages will be
  * preceeded in the dump by enough padding to align the first byte
  * of that file's data to a page boundary
  */
-#define PGALIGNTHRESH	8
+#define PGALIGNTHRESH   8
 
 
 /* structure definitions used locally ****************************************/
@@ -95,12 +95,12 @@
 /*
  * number of bstats bstat_iter fetches at a time
  */
-#define BSTATBUFLEN	4096
+#define BSTATBUFLEN     4096
 
 /*
  * if the source file system type can't be determined, assume it is this
  */
-#define FS_DEFAULT	"xfs"
+#define FS_DEFAULT      "xfs"
 
 /*
  * marks consist of a opaque drive layer cookie and a startpoint.
@@ -110,7 +110,7 @@
  */
 struct mark {
 	drive_markrec_t dm;
-	startpt_t startpt;
+	startpt_t	startpt;
 };
 
 typedef struct mark mark_t;
@@ -118,7 +118,7 @@ typedef struct mark mark_t;
 /*
  * Media_mfile_begin() entry state.
  */
-enum bes { BES_INIT,	/* in the beginning */
+enum bes { BES_INIT,    /* in the beginning */
 	   BES_ENDOK,   /* last media file successfully flushed to media */
 	   BES_ENDEOM,  /* hit EOM while writing last media file */
 	   BES_INVAL }; /* to assert protocol being followed */
@@ -129,90 +129,90 @@ typedef enum bes bes_t;
  * per-stream context
  */
 struct context {
-	filehdr_t *cc_filehdrp;
-			/*
-			 * pre-allocated buffer: heads each dumped file
-			 */
-	extenthdr_t *cc_extenthdrp;
-			/*
-			 * pre-allocated buffer: heads each dumped file extent
-			 */
-	void *cc_inomap_contextp;
-			/*
-			 * pre-allocated context to speed inomap iteration
-			 */
-	char *cc_getdentsbufp;
-	size_t cc_getdentsbufsz;
-			/*
-			 * pre-allocated buffer for getdents() syscall
-			 */
-	char *cc_mdirentbufp;
-	size_t cc_mdirentbufsz;
-			/*
-			 * pre-allocated buffer for on-media dirent
-			 */
-	char *cc_extattrlistbufp;
-	size_t cc_extattrlistbufsz;
-			/*
-			 * pre-allocated buffer for retrieving a
-			 * list of extended file attributes
-			 */
+	filehdr_t *	cc_filehdrp;
+	/*
+	 * pre-allocated buffer: heads each dumped file
+	 */
+	extenthdr_t *	cc_extenthdrp;
+	/*
+	 * pre-allocated buffer: heads each dumped file extent
+	 */
+	void *		cc_inomap_contextp;
+	/*
+	 * pre-allocated context to speed inomap iteration
+	 */
+	char *		cc_getdentsbufp;
+	size_t		cc_getdentsbufsz;
+	/*
+	 * pre-allocated buffer for getdents() syscall
+	 */
+	char *		cc_mdirentbufp;
+	size_t		cc_mdirentbufsz;
+	/*
+	 * pre-allocated buffer for on-media dirent
+	 */
+	char *		cc_extattrlistbufp;
+	size_t		cc_extattrlistbufsz;
+	/*
+	 * pre-allocated buffer for retrieving a
+	 * list of extended file attributes
+	 */
 	attr_multiop_t *cc_extattrrtrvarrayp;
-	size_t cc_extattrrtrvarraylen;
-			/*
-			 * pre-allocated array of ops for retrieving the
-			 * values for a list of extended file attributes
-			 */
-	char *cc_extattrdumpbufp;
-	size_t cc_extattrdumpbufsz;
-			/*
-			 * pre-allocated buffer for dumping the names and
-			 * values for a list of extended file attributes
-			 */
-	hsm_f_ctxt_t *cc_hsm_f_ctxtp;
-			/*
-			 * pre-allocated HSM context used for holding HSM
-			   state information about a file across subroutine
-			   calls.
-			*/
-	char *cc_readlinkbufp;
-	size_t cc_readlinkbufsz;
-			/*
-			 * pre-allocated buffer for readlink()
-			 */
-	off64_t cc_mfilesz;
-			/*
-			 * total bytes dumped to media file
-			 */
-	size_t cc_markscommitted;
-			/*
-			 * number of marks committed in mfile. only useful
-			 * info is if greater than zero.
-			 */
-	xfs_ino_t cc_stat_lastino;
-			/*
-			 * monotonic strm nondir ino dumped
-			 */
-	bool_t cc_completepr;
-			/*
-			 * set if stream completely dumped. useful for
-			 * determining if dump was interrupted
-			 */
-	bool_t cc_Media_useterminatorpr;
-			/*
-			 * true if stream terminators are expected and
-			 * will be used
-			 */
-	char *cc_Media_firstlabel;
-			/*
-			 * optional command line media label. only used
-			 * for first media object in stream, and only if
-			 * media object does not already have a label
-			 */
-	bes_t cc_Media_begin_entrystate;
-			/*
-			 * Media_mfile_begin context entry state
-			 */
+	size_t		cc_extattrrtrvarraylen;
+	/*
+	 * pre-allocated array of ops for retrieving the
+	 * values for a list of extended file attributes
+	 */
+	char *		cc_extattrdumpbufp;
+	size_t		cc_extattrdumpbufsz;
+	/*
+	 * pre-allocated buffer for dumping the names and
+	 * values for a list of extended file attributes
+	 */
+	hsm_f_ctxt_t *	cc_hsm_f_ctxtp;
+	/*
+	 * pre-allocated HSM context used for holding HSM
+	   state information about a file across subroutine
+	   calls.
+	 */
+	char *		cc_readlinkbufp;
+	size_t		cc_readlinkbufsz;
+	/*
+	 * pre-allocated buffer for readlink()
+	 */
+	off64_t		cc_mfilesz;
+	/*
+	 * total bytes dumped to media file
+	 */
+	size_t		cc_markscommitted;
+	/*
+	 * number of marks committed in mfile. only useful
+	 * info is if greater than zero.
+	 */
+	xfs_ino_t	cc_stat_lastino;
+	/*
+	 * monotonic strm nondir ino dumped
+	 */
+	bool_t		cc_completepr;
+	/*
+	 * set if stream completely dumped. useful for
+	 * determining if dump was interrupted
+	 */
+	bool_t		cc_Media_useterminatorpr;
+	/*
+	 * true if stream terminators are expected and
+	 * will be used
+	 */
+	char *		cc_Media_firstlabel;
+	/*
+	 * optional command line media label. only used
+	 * for first media object in stream, and only if
+	 * media object does not already have a label
+	 */
+	bes_t		cc_Media_begin_entrystate;
+	/*
+	 * Media_mfile_begin context entry state
+	 */
 };
 
 typedef struct context context_t;
@@ -220,15 +220,15 @@ typedef struct context context_t;
 /*
  * extent group context, used by dump_file()
  */
-#define BMAP_LEN	512
+#define BMAP_LEN        512
 
 struct extent_group_context {
-	getbmapx_t eg_bmap[BMAP_LEN];
-	getbmapx_t *eg_nextbmapp;	/* ptr to the next extent to dump */
-	getbmapx_t *eg_endbmapp;		/* to detect extent exhaustion */
-	int eg_fd;			/* file desc. */
-	int eg_bmapix;		/* debug info only, not used */
-	int eg_gbmcnt;		/* debug, counts getbmapx calls for ino*/
+	getbmapx_t	eg_bmap[BMAP_LEN];
+	getbmapx_t *	eg_nextbmapp;   /* ptr to the next extent to dump */
+	getbmapx_t *	eg_endbmapp;    /* to detect extent exhaustion */
+	int		eg_fd;          /* file desc. */
+	int		eg_bmapix;      /* debug info only, not used */
+	int		eg_gbmcnt;      /* debug, counts getbmapx calls for ino*/
 };
 
 typedef struct extent_group_context extent_group_context_t;
@@ -237,42 +237,42 @@ typedef struct extent_group_context extent_group_context_t;
 /*
  * minimum getdents() buffer size
  */
-#define GETDENTSBUF_SZ_MIN	(2 * pgsz)
+#define GETDENTSBUF_SZ_MIN      (2 * pgsz)
 
 
 /*
  * minimum sizes for extended attributes buffers
  */
-#define EXTATTR_LISTBUF_SZ	(XATTR_LIST_MAX)
-#define EXTATTR_RTRVARRAY_LEN	(1 * pgsz)
-#define EXTATTR_DUMPBUF_SZ	(4 * pgsz)
+#define EXTATTR_LISTBUF_SZ      (XATTR_LIST_MAX)
+#define EXTATTR_RTRVARRAY_LEN   (1 * pgsz)
+#define EXTATTR_DUMPBUF_SZ      (4 * pgsz)
 
 /*
  * for printing ext attr namespace
  */
-#define EXTATTR_NAMESPACE(flag)	(((flag) & ATTR_ROOT) ? _("root") : \
-				(((flag) & ATTR_SECURE) ? _("secure") : \
+#define EXTATTR_NAMESPACE(flag) (((flag) & ATTR_ROOT) ? _("root") : \
+				 (((flag) & ATTR_SECURE) ? _("secure") : \
 				  _("non-root")) )
 
 /*
  * for printing file type
  */
-#define FILETYPE(statp)		(((statp)->bs_mode & S_IFMT) == S_IFDIR \
-				  ? _("dir") : _("nondir"))
+#define FILETYPE(statp)         (((statp)->bs_mode & S_IFMT) == S_IFDIR \
+				 ? _("dir") : _("nondir"))
 
 /*
  * per-drive status descriptor
  */
 struct pds {
-	enum { PDS_NULL,		/* per-drive activity not begun */
-	       PDS_INOMAP,		/* dumping inomap */
-	       PDS_DIRDUMP,		/* dumping dirs */
-	       PDS_NONDIR,		/* dumping nondirs */
-	       PDS_INVSYNC,		/* waiting for inventory */
-	       PDS_INVDUMP,		/* dumping session inventory */
-	       PDS_TERMDUMP		/* writing stream terminator */
+	enum { PDS_NULL,                /* per-drive activity not begun */
+	       PDS_INOMAP,              /* dumping inomap */
+	       PDS_DIRDUMP,             /* dumping dirs */
+	       PDS_NONDIR,              /* dumping nondirs */
+	       PDS_INVSYNC,             /* waiting for inventory */
+	       PDS_INVDUMP,             /* dumping session inventory */
+	       PDS_TERMDUMP             /* writing stream terminator */
 	} pds_phase;
-	size64_t pds_dirdone;		/* number of directories done */
+	size64_t pds_dirdone;           /* number of directories done */
 };
 
 typedef struct pds pds_t;
@@ -294,141 +294,141 @@ extern size_t pgsz;
  * file dumpers
  */
 static rv_t
-dump_dirs(ix_t strmix,
-		       xfs_bstat_t *bstatbufp,
-		       size_t bstatbuflen,
-		       void *inomap_contextp);
+dump_dirs(ix_t		strmix,
+	  xfs_bstat_t * bstatbufp,
+	  size_t	bstatbuflen,
+	  void *	inomap_contextp);
 static rv_t
 dump_dir(ix_t strmix,
-		      jdm_fshandle_t *,
-		      int,
-		      xfs_bstat_t *);
+	 jdm_fshandle_t *,
+	 int,
+	 xfs_bstat_t *);
 static rv_t
 dump_file(void *,
-		       jdm_fshandle_t *,
-		       int,
-		       xfs_bstat_t *);
+	  jdm_fshandle_t *,
+	  int,
+	  xfs_bstat_t *);
 static rv_t
-dump_file_reg(drive_t *drivep,
-			   context_t *contextp,
-			   content_inode_hdr_t *scwhdrp,
-			   jdm_fshandle_t *,
-			   xfs_bstat_t *,
-			   bool_t *);
+dump_file_reg(drive_t *			drivep,
+	      context_t *		contextp,
+	      content_inode_hdr_t *	scwhdrp,
+	      jdm_fshandle_t *,
+	      xfs_bstat_t *,
+	      bool_t *);
 static rv_t
-dump_file_spec(drive_t *drivep,
-			    context_t *contextp,
-			    jdm_fshandle_t *,
-			    xfs_bstat_t *);
+dump_file_spec(drive_t *	drivep,
+	       context_t *	contextp,
+	       jdm_fshandle_t *,
+	       xfs_bstat_t *);
 static rv_t
-dump_filehdr(drive_t *drivep,
-			  context_t *contextp,
-			  xfs_bstat_t *,
-			  off64_t,
-			  int);
+dump_filehdr(drive_t *	drivep,
+	     context_t *contextp,
+	     xfs_bstat_t *,
+	     off64_t,
+	     int);
 static rv_t
-dump_extenthdr(drive_t *drivep,
-			    context_t *contextp,
-			    int32_t,
-			    int32_t,
-			    off64_t,
-			    off64_t);
+dump_extenthdr(drive_t *	drivep,
+	       context_t *	contextp,
+	       int32_t,
+	       int32_t,
+	       off64_t,
+	       off64_t);
 static rv_t
-dump_dirent(drive_t *drivep,
-			 context_t *contextp,
-			 xfs_bstat_t *,
-			 xfs_ino_t,
-			 gen_t,
-			 char *,
-			 size_t);
+dump_dirent(drive_t *	drivep,
+	    context_t * contextp,
+	    xfs_bstat_t *,
+	    xfs_ino_t,
+	    gen_t,
+	    char *,
+	    size_t);
 static rv_t
 init_extent_group_context(jdm_fshandle_t *,
-				       xfs_bstat_t *,
-				       extent_group_context_t *);
+			  xfs_bstat_t *,
+			  extent_group_context_t *);
 static void cleanup_extent_group_context(extent_group_context_t *);
 static rv_t
-dump_extent_group(drive_t *drivep,
-			       context_t *contextp,
-			       xfs_bstat_t *,
-			       extent_group_context_t *,
-			       off64_t,
-			       off64_t,
-			       bool_t,
-			       off64_t *,
-			       off64_t *,
-			       bool_t *);
+dump_extent_group(drive_t *	drivep,
+		  context_t *	contextp,
+		  xfs_bstat_t *,
+		  extent_group_context_t *,
+		  off64_t,
+		  off64_t,
+		  bool_t,
+		  off64_t *,
+		  off64_t *,
+		  bool_t *);
 static bool_t
-dump_session_inv(drive_t *drivep,
-			        context_t *contextp,
-			        media_hdr_t *mwhdrp,
-			        content_inode_hdr_t *scwhdrp);
+dump_session_inv(drive_t *		drivep,
+		 context_t *		contextp,
+		 media_hdr_t *		mwhdrp,
+		 content_inode_hdr_t *	scwhdrp);
 static rv_t write_pad(drive_t *drivep, size_t);
 
 static void mark_callback(void *, drive_markrec_t *, bool_t);
 
 static void inv_cleanup(void);
 static void
-dump_terminator(drive_t *drivep,
-			     context_t *contextp,
-			     media_hdr_t *mwhdrp);
+dump_terminator(drive_t *	drivep,
+		context_t *	contextp,
+		media_hdr_t *	mwhdrp);
 static rv_t
-Media_mfile_begin(drive_t *drivep,
-			       context_t *contextp,
-			       bool_t intr_allowed);
+Media_mfile_begin(drive_t *	drivep,
+		  context_t *	contextp,
+		  bool_t	intr_allowed);
 static rv_t
-Media_mfile_end(drive_t *drivep,
-			     context_t *contextp,
-			     media_hdr_t *mwhdrp,
-			     off64_t *ncommittedp,
-			     bool_t hit_eom);
+Media_mfile_end(drive_t *	drivep,
+		context_t *	contextp,
+		media_hdr_t *	mwhdrp,
+		off64_t *	ncommittedp,
+		bool_t		hit_eom);
 static bool_t Media_prompt_overwrite(drive_t *drivep);
 static rv_t
 Media_erasechk(drive_t *drivep,
-			    int dcaps,
-			    bool_t intr_allowed,
-			    bool_t prevmediapresentpr);
+	       int	dcaps,
+	       bool_t	intr_allowed,
+	       bool_t	prevmediapresentpr);
 static bool_t Media_prompt_erase(drive_t *drivep);
 static char *Media_prompt_label(drive_t *drivep, char *bufp, size_t bufsz);
 static void
-update_cc_Media_useterminatorpr(drive_t *drivep,
-					     context_t *contextp);
+update_cc_Media_useterminatorpr(drive_t *	drivep,
+				context_t *	contextp);
 static void set_mcflag(ix_t thrdix);
 static void clr_mcflag(ix_t thrdix);
 
 static bool_t check_complete_flags(void);
 
 static rv_t
-dump_extattrs(drive_t *drivep,
-			   context_t *contextp,
-	       		   jdm_fshandle_t *fshandlep,
-			   xfs_bstat_t *statp);
+dump_extattrs(drive_t *		drivep,
+	      context_t *	contextp,
+	      jdm_fshandle_t *	fshandlep,
+	      xfs_bstat_t *	statp);
 static rv_t
-dump_extattr_list(drive_t *drivep,
-			       context_t *contextp,
-	       		       jdm_fshandle_t *fshandlep,
-			       xfs_bstat_t *statp,
-			       attrlist_t *listp,
-			       int flag,
-			       bool_t *abortprp);
-static char *dump_extattr_buildrecord(xfs_bstat_t *statp,
-				       char *dumpbufp,
-				       char *dumpbufendp,
-				       char *namesrcp,
-				       uint32_t valuesz,
-				       int flag,
-				       char **valuepp);
+dump_extattr_list(drive_t *		drivep,
+		  context_t *		contextp,
+		  jdm_fshandle_t *	fshandlep,
+		  xfs_bstat_t *		statp,
+		  attrlist_t *		listp,
+		  int			flag,
+		  bool_t *		abortprp);
+static char *dump_extattr_buildrecord(xfs_bstat_t *	statp,
+				      char *		dumpbufp,
+				      char *		dumpbufendp,
+				      char *		namesrcp,
+				      uint32_t		valuesz,
+				      int		flag,
+				      char **		valuepp);
 static rv_t
-dump_extattrhdr(drive_t *drivep,
-			     context_t *contextp,
-			     xfs_bstat_t *statp,
-			     size_t recsz,
-			     size_t valoff,
-			     ix_t flags,
-			     uint32_t valsz);
+dump_extattrhdr(drive_t *	drivep,
+		context_t *	contextp,
+		xfs_bstat_t *	statp,
+		size_t		recsz,
+		size_t		valoff,
+		ix_t		flags,
+		uint32_t	valsz);
 
 static bool_t
-save_quotas(char *mntpnt,
-			   quota_info_t *quotainfo);
+save_quotas(char *		mntpnt,
+	    quota_info_t *	quotainfo);
 static int getxfsqstat(char *fsdev);
 
 
@@ -445,137 +445,137 @@ bool_t allowexcludefiles_pr = BOOL_FALSE;
 /* definition of locally defined static variables *****************************/
 
 static bool_t sc_preerasepr = BOOL_FALSE;
-	/*
-	 * pre-erase media
-	 */
+/*
+ * pre-erase media
+ */
 static inv_idbtoken_t sc_inv_idbtoken = INV_TOKEN_NULL;
-	/*
-	 * handle to inventory
-	 */
+/*
+ * handle to inventory
+ */
 static inv_sestoken_t sc_inv_sestoken = INV_TOKEN_NULL;
-	/*
-	 * handle to inventory session
-	 */
+/*
+ * handle to inventory session
+ */
 static inv_stmtoken_t *sc_inv_stmtokenp = 0;
-	/*
-	 * array of inventory session stream handles
-	 */
+/*
+ * array of inventory session stream handles
+ */
 static bool_t sc_inv_updatepr = BOOL_TRUE;
-	/*
-	 * set if ok to update online inventory with stats of this dump
-	 */
+/*
+ * set if ok to update online inventory with stats of this dump
+ */
 static ix_t sc_level = LEVEL_DEFAULT;
-	/*
-	 * dump level requested
-	 */
+/*
+ * dump level requested
+ */
 static bool_t sc_incrpr = BOOL_FALSE;
 static time32_t sc_incrbasetime;
 static ix_t sc_incrbaselevel;
 static uuid_t sc_incrbaseid;
-	/*
-	 * if an incremental dump, the base, level and time of the incremental
-	 * base dump. TRICKY: if resuming an incremental dump, this is the
-	 * base of the original incremental.
-	 */
+/*
+ * if an incremental dump, the base, level and time of the incremental
+ * base dump. TRICKY: if resuming an incremental dump, this is the
+ * base of the original incremental.
+ */
 static bool_t sc_resumepr = BOOL_FALSE;
 static time32_t sc_resumebasetime = 0;
 static uuid_t sc_resumebaseid;
 static size_t sc_resumerangecnt = 0;
 static drange_t *sc_resumerangep = 0;
-	/*
-	 * if a resumed dump, the id, time and undumped ino/offset ranges
-	 * of the interrupted dump being resumed.
-	 */
+/*
+ * if a resumed dump, the id, time and undumped ino/offset ranges
+ * of the interrupted dump being resumed.
+ */
 static jdm_fshandle_t *sc_fshandlep = 0;
-	/*
-	 * dmi file system handle
-	 */
+/*
+ * dmi file system handle
+ */
 static int sc_fsfd = -1;
-	/*
-	 * open file descriptor for root directory
-	 */
+/*
+ * open file descriptor for root directory
+ */
 static xfs_bstat_t *sc_rootxfsstatp = 0;
-	/*
-	 * pointer to loaded bulkstat for root directory
-	 */
+/*
+ * pointer to loaded bulkstat for root directory
+ */
 static startpt_t *sc_startptp = 0;
-	/*
-	 * an array of stream ino/offset start points
-	 */
+/*
+ * an array of stream ino/offset start points
+ */
 static time32_t sc_stat_starttime = 0;
-	/*
-	 * for cacluating elapsed time
-	 */
+/*
+ * for cacluating elapsed time
+ */
 static ix_t sc_stat_inomapphase = 0;
 static ix_t sc_stat_inomappass = 0;
 static size64_t sc_stat_inomapcnt;
 static size64_t sc_stat_inomapdone;
 static size64_t sc_stat_dircnt = 0;
-	/*
-	 * total number of directory inodes to be dumped (strm 0)
-	 */
+/*
+ * total number of directory inodes to be dumped (strm 0)
+ */
 static pds_t sc_stat_pds[STREAM_SIMMAX];
-	/*
-	 * per-drive stream status
-	 */
+/*
+ * per-drive stream status
+ */
 static size64_t sc_stat_nondircnt = 0;
-	/*
-	 * total number of non-directory inodes to be dumped (all strms)
-	 */
+/*
+ * total number of non-directory inodes to be dumped (all strms)
+ */
 static size64_t sc_stat_nondirdone = 0;
-	/*
-	 * total number of non-directory inodes dumped (all strms)
-	 */
+/*
+ * total number of non-directory inodes dumped (all strms)
+ */
 static size64_t sc_stat_datasz = 0;
-	/*
-	 * total size in bytes of non-dirs to be dumped (all strms)
-	 */
+/*
+ * total size in bytes of non-dirs to be dumped (all strms)
+ */
 static size64_t sc_stat_datadone = 0;
-	/*
-	 * total size in bytes of non-dirs dumped (all strms)
-	 */
+/*
+ * total size in bytes of non-dirs dumped (all strms)
+ */
 static size_t sc_thrdsarrivedcnt = 0;
-	/*
-	 * each thread checks in by bumping this count under lock.
-	 * used to decide when its ok to begin waiting for all threads
-	 * to arrive at sync pt for session inventory dump.
-	 */
+/*
+ * each thread checks in by bumping this count under lock.
+ * used to decide when its ok to begin waiting for all threads
+ * to arrive at sync pt for session inventory dump.
+ */
 static size_t sc_thrdsdonecnt = 0;
-	/*
-	 * number of threads which are ready to dump the session inventory.
-	 * when equal to the number of streams remaining (stream_cnt()),
-	 * can proceed with inventory dumps
-	 */
+/*
+ * number of threads which are ready to dump the session inventory.
+ * when equal to the number of streams remaining (stream_cnt()),
+ * can proceed with inventory dumps
+ */
 static context_t *sc_contextp;
-	/*
-	 * an array of per-stream context descriptors
-	 */
+/*
+ * an array of per-stream context descriptors
+ */
 static bool_t sc_mcflag[STREAM_SIMMAX];
-	/*
-	 * media change flag
-	 */
+/*
+ * media change flag
+ */
 static bool_t sc_dumpextattrpr = BOOL_TRUE;
-	/*
-	 * dump extended attributes
-	 */
+/*
+ * dump extended attributes
+ */
 static bool_t sc_dumpasoffline = BOOL_FALSE;
-	/*
-	 * dump dual-residency HSM files as offline
-	 */
+/*
+ * dump dual-residency HSM files as offline
+ */
 static bool_t sc_use_old_direntpr = BOOL_FALSE;
-	/*
-	 * dump dirents as dirent_v1_t instead of dirent_t
-	 * (for compat with dump format 2)
-	 */
+/*
+ * dump dirents as dirent_v1_t instead of dirent_t
+ * (for compat with dump format 2)
+ */
 
 static bool_t sc_savequotas = BOOL_TRUE;
 /*
  * save quota information in dump
  */
 static quota_info_t quotas[] = {
-	{ "user quota",		BOOL_TRUE,	CONTENT_QUOTAFILE,	"", "-uf", XFS_QUOTA_UDQ_ACCT, 0 },
-	{ "project quota",	BOOL_TRUE,	CONTENT_PQUOTAFILE,	"", "-pf", XFS_QUOTA_PDQ_ACCT, 0 },
-	{ "group quota",	BOOL_TRUE,	CONTENT_GQUOTAFILE,	"", "-gf", XFS_QUOTA_GDQ_ACCT, 0 }
+	{ "user quota",	   BOOL_TRUE, CONTENT_QUOTAFILE,  "", "-uf", XFS_QUOTA_UDQ_ACCT, 0 },
+	{ "project quota", BOOL_TRUE, CONTENT_PQUOTAFILE, "", "-pf", XFS_QUOTA_PDQ_ACCT, 0 },
+	{ "group quota",   BOOL_TRUE, CONTENT_GQUOTAFILE, "", "-gf", XFS_QUOTA_GDQ_ACCT, 0 }
 };
 
 /* definition of locally defined global functions ****************************/
@@ -583,17 +583,17 @@ static quota_info_t quotas[] = {
 
 /* definition of locally defined static functions ****************************/
 static bool_t create_inv_session(
-		global_hdr_t *gwhdrtemplatep,
-		uuid_t *fsidp,
-		const char *mntpnt,
-		const char *fsdevice,
-		ix_t subtreecnt,
-		size_t strmix);
+	global_hdr_t *	gwhdrtemplatep,
+	uuid_t *	fsidp,
+	const char *	mntpnt,
+	const char *	fsdevice,
+	ix_t		subtreecnt,
+	size_t		strmix);
 
 bool_t
-content_init(int argc,
-	      char *argv[],
-	      global_hdr_t *gwhdrtemplatep)
+content_init(int		argc,
+	     char *		argv[],
+	     global_hdr_t *	gwhdrtemplatep)
 {
 
 	inv_idbtoken_t inv_idbt;
@@ -655,8 +655,8 @@ content_init(int argc,
 	assert(sizeof(direnthdr_v1_t) == DIRENTHDR_SZ);
 	assert(DIRENTHDR_SZ % DIRENTHDR_ALIGN == 0);
 	assert(sizeofmember(content_hdr_t, ch_specific)
-		>=
-		sizeof(content_inode_hdr_t));
+	       >=
+	       sizeof(content_inode_hdr_t));
 	assert(sizeof(extattrhdr_t) == EXTATTRHDR_SZ);
 
 	/*
@@ -683,18 +683,18 @@ content_init(int argc,
 		case GETOPT_LEVEL:
 			if (! optarg || optarg[0] == '-') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument missing\n"),
-				      c);
+					     "-%c argument missing\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
 			sc_level = (ix_t)atoi(optarg);
 			if (sc_level > LEVEL_MAX) {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument must be "
-				      "between 0 and %d\n"),
-				      c,
-				      LEVEL_MAX);
+					     "-%c argument must be "
+					     "between 0 and %d\n"),
+				     c,
+				     LEVEL_MAX);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -702,16 +702,16 @@ content_init(int argc,
 		case GETOPT_SUBTREE:
 			if (! optarg || optarg[0] == '-') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument missing\n"),
-				      c);
+					     "-%c argument missing\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
 			if (optarg[0] == '/') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument (subtree) "
-				      "must be a relative pathname\n"),
-				      c);
+					     "-%c argument (subtree) "
+					     "must be a relative pathname\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -720,18 +720,18 @@ content_init(int argc,
 		case GETOPT_MAXDUMPFILESIZE:
 			if (! optarg || optarg [0] == '-') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument missing\n"),
-				      c);
+					     "-%c argument missing\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
 			maxdumpfilesize = strtoull(optarg, NULL, 0);
 			if (maxdumpfilesize == 0 ||
-			     maxdumpfilesize > ULONGLONG_MAX / 1024 ||
-			     (maxdumpfilesize == ULONGLONG_MAX && errno == ERANGE) ) {
+			    maxdumpfilesize > ULONGLONG_MAX / 1024 ||
+			    (maxdumpfilesize == ULONGLONG_MAX && errno == ERANGE) ) {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument is not a valid file size\n"),
-				      c);
+					     "-%c argument is not a valid file size\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -755,8 +755,8 @@ content_init(int argc,
 		case GETOPT_ALERTPROG:
 			if (! optarg || optarg[0] == '-') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-					"-%c argument missing\n"),
-				    c);
+					     "-%c argument missing\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -771,8 +771,8 @@ content_init(int argc,
 		case GETOPT_BASED:
 			if (! optarg || optarg[0] == '-') {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument missing\n"),
-				      c);
+					     "-%c argument missing\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -780,9 +780,9 @@ content_init(int argc,
 
 			if (uuid_parse(baseuuidstr, baseuuid) < 0) {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "-%c argument not a valid "
-				      "dump session id\n"),
-				      c);
+					     "-%c argument not a valid "
+					     "dump session id\n"),
+				     c);
 				usage();
 				return BOOL_FALSE;
 			}
@@ -792,9 +792,9 @@ content_init(int argc,
 
 	if (resumereqpr && baseuuidvalpr) {
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "may not specify both -%c and -%c\n"),
-		      GETOPT_BASED,
-		      GETOPT_RESUME);
+			     "may not specify both -%c and -%c\n"),
+		     GETOPT_BASED,
+		     GETOPT_RESUME);
 		return BOOL_FALSE;
 	}
 
@@ -813,8 +813,8 @@ content_init(int argc,
 	 */
 	if (optind >= argc) {
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "source file system "
-		      "not specified\n"));
+			     "source file system "
+			     "not specified\n"));
 		usage();
 		return BOOL_FALSE;
 	}
@@ -856,18 +856,18 @@ content_init(int argc,
 	 * argument doesn't look like a file system.
 	 */
 	if (! fs_info(fstype,
-			sizeof(fstype),
-			FS_DEFAULT,
-			fsdevice,
-			sizeof(fsdevice),
-			mntpnt,
-			sizeof(mntpnt),
-			&fsid,
-			srcname)) {
+		     sizeof(fstype),
+		     FS_DEFAULT,
+		     fsdevice,
+		     sizeof(fsdevice),
+		     mntpnt,
+		     sizeof(mntpnt),
+		     &fsid,
+		     srcname)) {
 
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "%s does not identify a file system\n"),
-		      srcname);
+			     "%s does not identify a file system\n"),
+		     srcname);
 		usage();
 		return BOOL_FALSE;
 	}
@@ -879,8 +879,8 @@ content_init(int argc,
 	 */
 	if (! fs_mounted(fstype, fsdevice, mntpnt, &fsid)) {
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "%s must be mounted to be dumped\n"),
-		      srcname);
+			     "%s must be mounted to be dumped\n"),
+		     srcname);
 		return BOOL_FALSE;
 	}
 
@@ -888,14 +888,14 @@ content_init(int argc,
 	 * place the fs info in the write hdr template
 	 */
 	(void)strncpyterm(cwhdrtemplatep->ch_mntpnt,
-			     mntpnt,
-			     sizeof(cwhdrtemplatep->ch_mntpnt));
+			  mntpnt,
+			  sizeof(cwhdrtemplatep->ch_mntpnt));
 	(void)strncpyterm(cwhdrtemplatep->ch_fsdevice,
-			     fsdevice,
-			     sizeof(cwhdrtemplatep->ch_fsdevice));
+			  fsdevice,
+			  sizeof(cwhdrtemplatep->ch_fsdevice));
 	(void)strncpyterm(cwhdrtemplatep->ch_fstype,
-			     fstype,
-			     sizeof(cwhdrtemplatep->ch_fstype));
+			  fstype,
+			  sizeof(cwhdrtemplatep->ch_fstype));
 	uuid_copy(cwhdrtemplatep->ch_fsid, fsid);
 
 	/* write quota information */
@@ -911,7 +911,7 @@ content_init(int argc,
 					if (subtreecnt) {
 						subtreecnt++;
 						subtreep = (char **) realloc(subtreep,
-								subtreecnt * sizeof(char *));
+									     subtreecnt * sizeof(char *));
 						assert(subtreep);
 						subtreep[subtreecnt - 1] = quotas[i].quotafile;
 					}
@@ -919,8 +919,8 @@ content_init(int argc,
 					quotas[i].savequotas = BOOL_TRUE;
 				} else {
 					mlog(MLOG_NORMAL | MLOG_ERROR, _(
-					      "failed to save %s information, continuing\n"),
-					      quotas[i].desc);
+						     "failed to save %s information, continuing\n"),
+					     quotas[i].desc);
 				}
 			}
 		}
@@ -950,8 +950,8 @@ content_init(int argc,
 	 * to calculate incremental and resumed dumps.
 	 */
 	inv_idbt = inv_open((inv_predicate_t)INV_BY_UUID,
-			     INV_SEARCH_ONLY,
-			     (void *)&fsid);
+			    INV_SEARCH_ONLY,
+			    (void *)&fsid);
 
 	/*
 	 * if a based request, look for the indicated session.
@@ -974,9 +974,9 @@ content_init(int argc,
 		ok = inv_get_session_byuuid(&fsid, &baseuuid, &sessp);
 		if (! ok) {
 			mlog(MLOG_NORMAL | MLOG_ERROR, _(
-			      "could not find specified base dump (%s) "
-			      "in inventory\n"),
-			      baseuuidstr);
+				     "could not find specified base dump (%s) "
+				     "in inventory\n"),
+			     baseuuidstr);
 			return BOOL_FALSE;
 		}
 		strcnt =  (ix_t)sessp->s_nstreams;
@@ -998,7 +998,7 @@ content_init(int argc,
 			sameinterruptedpr = BOOL_TRUE;
 			sc_resumerangecnt =  (size_t)sessp->s_nstreams;
 			sc_resumerangep = (drange_t *)calloc(sc_resumerangecnt,
-								sizeof(drange_t));
+							     sizeof(drange_t));
 			assert(sc_resumerangep);
 			for (strmix = 0; strmix < sc_resumerangecnt; strmix++) {
 				inv_stream_t *bsp;
@@ -1017,25 +1017,25 @@ content_init(int argc,
 					if (esp) {
 						p->dr_end.sp_ino = esp->st_startino;
 						p->dr_end.sp_offset =
-								esp->st_startino_off;
+							esp->st_startino_off;
 						mlog(MLOG_DEBUG,
-						      "resume range stream %u "
-						      "ino %llu:%lld to "
-						      "%llu:%lld\n",
-						      strmix,
-						      p->dr_begin.sp_ino,
-						      p->dr_begin.sp_offset,
-						      p->dr_end.sp_ino,
-						      p->dr_end.sp_offset);
+						     "resume range stream %u "
+						     "ino %llu:%lld to "
+						     "%llu:%lld\n",
+						     strmix,
+						     p->dr_begin.sp_ino,
+						     p->dr_begin.sp_offset,
+						     p->dr_end.sp_ino,
+						     p->dr_end.sp_offset);
 					} else {
 						p->dr_end.sp_flags = STARTPT_FLAGS_END;
 						mlog(MLOG_DEBUG,
-						      "resume range stream %u "
-						      "ino %llu:%lld to "
-						      "end\n",
-						      strmix,
-						      p->dr_begin.sp_ino,
-						      p->dr_begin.sp_offset);
+						     "resume range stream %u "
+						     "ino %llu:%lld to "
+						     "end\n",
+						     strmix,
+						     p->dr_begin.sp_ino,
+						     p->dr_begin.sp_offset);
 					}
 				} else {
 					/*
@@ -1048,11 +1048,11 @@ content_init(int argc,
 		} else {
 			if (sessp->s_level >= LEVEL_MAX) {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "cannot select dump session %d as base "
-				      "for incremental dump: "
-				      "level must be less than %d\n"),
-				      sessp->s_level,
-				      LEVEL_MAX);
+					     "cannot select dump session %d as base "
+					     "for incremental dump: "
+					     "level must be less than %d\n"),
+				     sessp->s_level,
+				     LEVEL_MAX);
 				return BOOL_FALSE;
 			}
 			sc_level = (ix_t)sessp->s_level + 1;
@@ -1080,8 +1080,8 @@ content_init(int argc,
 	if (sc_level > 0) {
 		if (inv_idbt == INV_TOKEN_NULL) {
 			mlog(MLOG_NORMAL | MLOG_ERROR, _(
-			      "cannot calculate incremental dump: "
-			      "online inventory not available\n"));
+				     "cannot calculate incremental dump: "
+				     "online inventory not available\n"));
 			return BOOL_FALSE;
 		}
 		ok = inv_lastsession_level_lessthan(&fsid,
@@ -1111,7 +1111,7 @@ content_init(int argc,
 				}
 			}
 			underfoundpr = BOOL_TRUE;
-			inv_free_session(& sessp);
+			inv_free_session(&sessp);
 			sessp = 0;
 		}
 	}
@@ -1147,7 +1147,7 @@ content_init(int argc,
 		sameinterruptedpr = BOOL_FALSE;
 		sc_resumerangecnt =  (size_t)sessp->s_nstreams;
 		sc_resumerangep = (drange_t *)calloc(sc_resumerangecnt,
-						        sizeof(drange_t));
+						     sizeof(drange_t));
 		assert(sc_resumerangep);
 		for (strmix = 0; strmix < sc_resumerangecnt; strmix++) {
 			inv_stream_t *bsp;
@@ -1166,25 +1166,25 @@ content_init(int argc,
 				if (esp) {
 					p->dr_end.sp_ino = esp->st_startino;
 					p->dr_end.sp_offset =
-							esp->st_startino_off;
+						esp->st_startino_off;
 					mlog(MLOG_DEBUG,
-					      "resume range stream %u "
-					      "ino %llu:%lld to "
-					      "%llu:%lld\n",
-					      strmix,
-					      p->dr_begin.sp_ino,
-					      p->dr_begin.sp_offset,
-					      p->dr_end.sp_ino,
-					      p->dr_end.sp_offset);
+					     "resume range stream %u "
+					     "ino %llu:%lld to "
+					     "%llu:%lld\n",
+					     strmix,
+					     p->dr_begin.sp_ino,
+					     p->dr_begin.sp_offset,
+					     p->dr_end.sp_ino,
+					     p->dr_end.sp_offset);
 				} else {
 					p->dr_end.sp_flags = STARTPT_FLAGS_END;
 					mlog(MLOG_DEBUG,
-					      "resume range stream %u "
-					      "ino %llu:%lld to "
-					      "end\n",
-					      strmix,
-					      p->dr_begin.sp_ino,
-					      p->dr_begin.sp_offset);
+					     "resume range stream %u "
+					     "ino %llu:%lld to "
+					     "end\n",
+					     strmix,
+					     p->dr_begin.sp_ino,
+					     p->dr_begin.sp_offset);
 				}
 			} else {
 				/*
@@ -1194,7 +1194,7 @@ content_init(int argc,
 				p->dr_begin.sp_flags = STARTPT_FLAGS_END;
 			}
 		}
-		inv_free_session(& sessp);
+		inv_free_session(&sessp);
 		sessp = 0;
 		samefoundpr = BOOL_TRUE;
 	}
@@ -1212,11 +1212,11 @@ baseuuidbypass:
 	if (samefoundpr && ! resumereqpr) {
 		if (! underfoundpr || undertime <= sametime) {
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "most recent level %d dump "
-			      "was interrupted, "
-			      "but not resuming that dump since "
-			      "resume (-R) option not specified\n"),
-			      sc_level);
+				     "most recent level %d dump "
+				     "was interrupted, "
+				     "but not resuming that dump since "
+				     "resume (-R) option not specified\n"),
+			     sc_level);
 		}
 		free((void *)sc_resumerangep);
 		sc_resumerangep = 0;
@@ -1229,32 +1229,32 @@ baseuuidbypass:
 			if (undertime >= sametime) {
 				if (underinterruptedpr) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "most recent base for "
-					      "incremental dump was "
-					      "interrupted (level %u): "
-					      "must resume or redump "
-					      "at or below level %d\n"),
-					      underlevel,
-					      sc_level);
+						     "most recent base for "
+						     "incremental dump was "
+						     "interrupted (level %u): "
+						     "must resume or redump "
+						     "at or below level %d\n"),
+					     underlevel,
+					     sc_level);
 					return BOOL_FALSE;
 				}
 				if (subtreecnt && ! underpartialpr) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "level %u incremental "
-					      "subtree dump "
-					      "will be based on non-subtree "
-					      "level %u dump\n"),
-					      sc_level,
-					      underlevel);
+						     "level %u incremental "
+						     "subtree dump "
+						     "will be based on non-subtree "
+						     "level %u dump\n"),
+					     sc_level,
+					     underlevel);
 				}
 				if (! subtreecnt && underpartialpr) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "level %u incremental "
-					      "non-subtree dump "
-					      "will be based on subtree "
-					      "level %u dump\n"),
-					      sc_level,
-					      underlevel);
+						     "level %u incremental "
+						     "non-subtree dump "
+						     "will be based on subtree "
+						     "level %u dump\n"),
+					     sc_level,
+					     underlevel);
 				}
 				sc_incrpr = BOOL_TRUE;
 				sc_incrbasetime = undertime;
@@ -1267,21 +1267,21 @@ baseuuidbypass:
 			} else {
 				if (subtreecnt && ! samepartialpr) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "level %u incremental "
-					      "subtree dump "
-					      "will be based on non-subtree "
-					      "level %u resumed dump\n"),
-					      sc_level,
-					      sc_level);
+						     "level %u incremental "
+						     "subtree dump "
+						     "will be based on non-subtree "
+						     "level %u resumed dump\n"),
+					     sc_level,
+					     sc_level);
 				}
 				if (! subtreecnt && samepartialpr) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "level %u incremental "
-					      "non-subtree dump "
-					      "will be based on subtree "
-					      "level %u resumed dump\n"),
-					      sc_level,
-					      sc_level);
+						     "level %u incremental "
+						     "non-subtree dump "
+						     "will be based on subtree "
+						     "level %u resumed dump\n"),
+					     sc_level,
+					     sc_level);
 				}
 				assert(sametime);
 				sc_incrpr = BOOL_TRUE;
@@ -1295,32 +1295,32 @@ baseuuidbypass:
 		} else {
 			if (underinterruptedpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "most recent base for "
-				      "incremental dump was "
-				      "interrupted (level %u): "
-				      "must resume or redump "
-				      "at or below level %d\n"),
-				      underlevel,
-				      sc_level);
+					     "most recent base for "
+					     "incremental dump was "
+					     "interrupted (level %u): "
+					     "must resume or redump "
+					     "at or below level %d\n"),
+				     underlevel,
+				     sc_level);
 				return BOOL_FALSE;
 			}
 			if (subtreecnt && ! underpartialpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "level %u incremental "
-				      "subtree dump "
-				      "will be based on non-subtree "
-				      "level %u dump\n"),
-				      sc_level,
-				      underlevel);
+					     "level %u incremental "
+					     "subtree dump "
+					     "will be based on non-subtree "
+					     "level %u dump\n"),
+				     sc_level,
+				     underlevel);
 			}
 			if (! subtreecnt && underpartialpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "level %u incremental "
-				      "non-subtree dump "
-				      "will be based on subtree "
-				      "level %u dump\n"),
-				      sc_level,
-				      underlevel);
+					     "level %u incremental "
+					     "non-subtree dump "
+					     "will be based on subtree "
+					     "level %u dump\n"),
+				     sc_level,
+				     underlevel);
 			}
 			sc_incrpr = BOOL_TRUE;
 			sc_incrbasetime = undertime;
@@ -1334,21 +1334,21 @@ baseuuidbypass:
 			assert(sametime);
 			if (subtreecnt && ! samepartialpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "level %u "
-				      "subtree dump "
-				      "will be based on non-subtree "
-				      "level %u resumed dump\n"),
-				      sc_level,
-				      sc_level);
+					     "level %u "
+					     "subtree dump "
+					     "will be based on non-subtree "
+					     "level %u resumed dump\n"),
+				     sc_level,
+				     sc_level);
 			}
 			if (! subtreecnt && samepartialpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "level %u "
-				      "non-subtree dump "
-				      "will be based on subtree "
-				      "level %u resumed dump\n"),
-				      sc_level,
-				      sc_level);
+					     "level %u "
+					     "non-subtree dump "
+					     "will be based on subtree "
+					     "level %u resumed dump\n"),
+				     sc_level,
+				     sc_level);
 			}
 			sc_incrpr = BOOL_FALSE;
 			sc_resumepr = BOOL_TRUE;
@@ -1361,9 +1361,9 @@ baseuuidbypass:
 			assert(! sc_resumerangep);
 			if (sc_level > 0) {
 				mlog(MLOG_NORMAL | MLOG_ERROR, _(
-				      "cannot find earlier dump "
-				      "to base level %d increment upon\n"),
-				      sc_level);
+					     "cannot find earlier dump "
+					     "to base level %d increment upon\n"),
+				     sc_level);
 				return BOOL_FALSE;
 			}
 		}
@@ -1374,10 +1374,10 @@ baseuuidbypass:
 	 */
 	if (sc_incrpr && underinterruptedpr) {
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "most recent base dump (level %d begun %s) "
-		      "was interrupted: aborting\n"),
-		      sc_incrbaselevel,
-		      ctimennl(&sc_incrbasetime));
+			     "most recent base dump (level %d begun %s) "
+			     "was interrupted: aborting\n"),
+		     sc_incrbaselevel,
+		     ctimennl(&sc_incrbasetime));
 		return BOOL_FALSE;
 	}
 
@@ -1386,9 +1386,9 @@ baseuuidbypass:
 	 */
 	if (! sc_resumepr && resumereqpr) {
 		mlog(MLOG_NORMAL | MLOG_ERROR, _(
-		      "resume (-R) option inappropriate: "
-		      "no interrupted level %d dump to resume\n"),
-		      sc_level);
+			     "resume (-R) option inappropriate: "
+			     "no interrupted level %d dump to resume\n"),
+		     sc_level);
 		return BOOL_FALSE;
 	}
 
@@ -1406,39 +1406,39 @@ baseuuidbypass:
 			assert(strlen(incrtimestr) < sizeof(incrtimestr));
 
 			mlog(MLOG_VERBOSE, _(
-			      "resuming level %d incremental dump of %s:%s "
-			      "begun %s "
-			      "(incremental base level %d begun %s)\n"),
-			      sc_level,
-			      gwhdrtemplatep->gh_hostname,
-			      mntpnt,
-			      restimestr,
-			      sc_incrbaselevel,
-			      incrtimestr);
+				     "resuming level %d incremental dump of %s:%s "
+				     "begun %s "
+				     "(incremental base level %d begun %s)\n"),
+			     sc_level,
+			     gwhdrtemplatep->gh_hostname,
+			     mntpnt,
+			     restimestr,
+			     sc_incrbaselevel,
+			     incrtimestr);
 		} else {
 			mlog(MLOG_VERBOSE, _(
-			      "level %d incremental dump of %s:%s "
-			      "based on level %d dump begun %s\n"),
-			      sc_level,
-			      gwhdrtemplatep->gh_hostname,
-			      mntpnt,
-			      sc_incrbaselevel,
-			      ctimennl(&sc_incrbasetime));
+				     "level %d incremental dump of %s:%s "
+				     "based on level %d dump begun %s\n"),
+			     sc_level,
+			     gwhdrtemplatep->gh_hostname,
+			     mntpnt,
+			     sc_incrbaselevel,
+			     ctimennl(&sc_incrbasetime));
 		}
 	} else {
 		if (sc_resumepr) {
 			mlog(MLOG_VERBOSE, _(
-			      "resuming level %d dump of %s:%s begun %s\n"),
-			      sc_level,
-			      gwhdrtemplatep->gh_hostname,
-			      mntpnt,
-			      ctimennl(&sc_resumebasetime));
+				     "resuming level %d dump of %s:%s begun %s\n"),
+			     sc_level,
+			     gwhdrtemplatep->gh_hostname,
+			     mntpnt,
+			     ctimennl(&sc_resumebasetime));
 		} else {
 			mlog(MLOG_VERBOSE, _(
-			      "level %d dump of %s:%s\n"),
-			      sc_level,
-			      gwhdrtemplatep->gh_hostname,
-			      mntpnt);
+				     "level %d dump of %s:%s\n"),
+			     sc_level,
+			     gwhdrtemplatep->gh_hostname,
+			     mntpnt);
 		}
 	}
 
@@ -1450,8 +1450,8 @@ baseuuidbypass:
 	 * announce the dump time
 	 */
 	mlog(MLOG_VERBOSE, _(
-	      "dump date: %s\n"),
-	      ctimennl(&gwhdrtemplatep->gh_timestamp));
+		     "dump date: %s\n"),
+	     ctimennl(&gwhdrtemplatep->gh_timestamp));
 
 	/*
 	 * display the session UUID
@@ -1460,16 +1460,16 @@ baseuuidbypass:
 		char string_uuid[UUID_STR_LEN + 1];
 		uuid_unparse(gwhdrtemplatep->gh_dumpid, string_uuid);
 		mlog(MLOG_VERBOSE, _(
-		      "session id: %s\n"),
-		      string_uuid);
+			     "session id: %s\n"),
+		     string_uuid);
 	}
 
 	/*
 	 * display the session label
 	 */
 	mlog(MLOG_VERBOSE, _(
-	      "session label: \"%s\"\n"),
-	      gwhdrtemplatep->gh_dumplabel);
+		     "session label: \"%s\"\n"),
+	     gwhdrtemplatep->gh_dumplabel);
 
 	/*
 	 * get a file descriptor for the file system. any file
@@ -1479,9 +1479,9 @@ baseuuidbypass:
 	sc_fsfd = open(mntpnt, O_RDONLY);
 	if (sc_fsfd < 0) {
 		mlog(MLOG_NORMAL, _(
-		      "unable to open %s: %s\n"),
-		      mntpnt,
-		      strerror(errno));
+			     "unable to open %s: %s\n"),
+		     mntpnt,
+		     strerror(errno));
 		return BOOL_FALSE;
 	}
 
@@ -1501,8 +1501,8 @@ baseuuidbypass:
 		rval = fstat64(sc_fsfd, &rootstat);
 		if (rval) {
 			mlog(MLOG_NORMAL, _(
-			      "could not stat %s\n"),
-			      mntpnt);
+				     "could not stat %s\n"),
+			     mntpnt);
 			return BOOL_FALSE;
 		}
 		sc_rootxfsstatp =
@@ -1516,14 +1516,14 @@ baseuuidbypass:
 		bulkreq.ocount = &ocount;
 		if (ioctl(sc_fsfd, XFS_IOC_FSBULKSTAT, &bulkreq) < 0) {
 			mlog(MLOG_ERROR,
-			      _("failed to get bulkstat information for root inode\n"));
+			     _("failed to get bulkstat information for root inode\n"));
 			return BOOL_FALSE;
 		}
 
 		if (sc_rootxfsstatp->bs_ino != rootstat.st_ino)
 			mlog (MLOG_NORMAL | MLOG_NOTE,
-			       _("root ino %lld differs from mount dir ino %lld, bind mount?\n"),
-			         sc_rootxfsstatp->bs_ino, rootstat.st_ino);
+			      _("root ino %lld differs from mount dir ino %lld, bind mount?\n"),
+			      sc_rootxfsstatp->bs_ino, rootstat.st_ino);
 	}
 
 	/*
@@ -1533,9 +1533,9 @@ baseuuidbypass:
 	sc_fshandlep = jdm_getfshandle(mntpnt);
 	if (! sc_fshandlep) {
 		mlog(MLOG_NORMAL, _(
-		      "unable to construct a file system handle for %s: %s\n"),
-		      mntpnt,
-		      strerror(errno));
+			     "unable to construct a file system handle for %s: %s\n"),
+		     mntpnt,
+		     strerror(errno));
 		return BOOL_FALSE;
 	}
 
@@ -1568,23 +1568,23 @@ baseuuidbypass:
 	sc_startptp = (startpt_t *)calloc(drivecnt, sizeof(startpt_t));
 	assert(sc_startptp);
 	ok = inomap_build(sc_fshandlep,
-			   sc_fsfd,
-			   sc_rootxfsstatp,
-			   sc_incrpr,
-			   sc_incrbasetime,
-			   sc_resumepr,
-			   sc_resumebasetime,
-			   sc_resumerangecnt,
-			   sc_resumerangep,
-			   subtreep,
-			   subtreecnt,
-			   skip_unchanged_dirs,
-			   sc_startptp,
-			   drivecnt,
-			   &sc_stat_inomapphase,
-			   &sc_stat_inomappass,
-			   sc_stat_inomapcnt,
-			   &sc_stat_inomapdone);
+			  sc_fsfd,
+			  sc_rootxfsstatp,
+			  sc_incrpr,
+			  sc_incrbasetime,
+			  sc_resumepr,
+			  sc_resumebasetime,
+			  sc_resumerangecnt,
+			  sc_resumerangep,
+			  subtreep,
+			  subtreecnt,
+			  skip_unchanged_dirs,
+			  sc_startptp,
+			  drivecnt,
+			  &sc_stat_inomapphase,
+			  &sc_stat_inomappass,
+			  sc_stat_inomapcnt,
+			  &sc_stat_inomapdone);
 	free((void *)subtreep);
 	subtreep = 0;
 	if (! ok) {
@@ -1633,7 +1633,7 @@ baseuuidbypass:
 	if (sc_dumpextattrpr) {
 		scwhdrtemplatep->cih_dumpattr |= CIH_DUMPATTR_EXTATTR;
 		scwhdrtemplatep->cih_dumpattr |=
-					CIH_DUMPATTR_EXTATTRHDR_CHECKSUM;
+			CIH_DUMPATTR_EXTATTRHDR_CHECKSUM;
 	}
 
 	scwhdrtemplatep->cih_rootino = sc_rootxfsstatp->bs_ino;
@@ -1650,34 +1650,34 @@ baseuuidbypass:
 	direntsz = inocnt * (uint64_t)(DIRENTHDR_SZ + 8);
 	filesz = inocnt * (uint64_t)(FILEHDR_SZ + EXTENTHDR_SZ);
 
-	hdr_mfilesz =	GLOBAL_HDR_SZ
-			+
-			inomapsz
-			+
-			direntsz;
+	hdr_mfilesz =   GLOBAL_HDR_SZ
+		      +
+		      inomapsz
+		      +
+		      direntsz;
 	size_estimate = hdr_mfilesz
 			+
 			filesz
 			+
 			datasz;
 	mlog(MLOG_VERBOSE, _(
-	      "estimated dump size: %llu bytes\n"),
-	      size_estimate);
+		     "estimated dump size: %llu bytes\n"),
+	     size_estimate);
 
 	if (drivecnt > 1) {
-	    mlog(MLOG_VERBOSE, _(
-		  "estimated dump size per stream: %llu bytes\n"),
-		    hdr_mfilesz + (filesz + datasz) / drivecnt);
+		mlog(MLOG_VERBOSE, _(
+			     "estimated dump size per stream: %llu bytes\n"),
+		     hdr_mfilesz + (filesz + datasz) / drivecnt);
 	}
 	mlog(MLOG_DEBUG,
-	      "estimated dump header size: %llu bytes\n",
-	      hdr_mfilesz);
+	     "estimated dump header size: %llu bytes\n",
+	     hdr_mfilesz);
 	mlog(MLOG_DEBUG,
-	      "estimated component sizes: global hdr: %llu bytes, "
-	      "inomap: %llu bytes,  dir entries: %llu bytes, "
-	      "file hdrs: %llu bytes, datasz: %llu bytes\n",
-	      GLOBAL_HDR_SZ, inomapsz, direntsz,
-	      filesz, datasz);
+	     "estimated component sizes: global hdr: %llu bytes, "
+	     "inomap: %llu bytes,  dir entries: %llu bytes, "
+	     "file hdrs: %llu bytes, datasz: %llu bytes\n",
+	     GLOBAL_HDR_SZ, inomapsz, direntsz,
+	     filesz, datasz);
 
 	/*
 	 * extract the progress stat denominators from the write hdr
@@ -1696,21 +1696,21 @@ baseuuidbypass:
 		context_t *contextp = &sc_contextp[strmix];
 
 		contextp->cc_filehdrp =
-				(filehdr_t *)calloc(1, sizeof(filehdr_t));
+			(filehdr_t *)calloc(1, sizeof(filehdr_t));
 		assert(contextp->cc_filehdrp);
 
 		contextp->cc_extenthdrp =
-			    (extenthdr_t *)calloc(1, sizeof(extenthdr_t));
+			(extenthdr_t *)calloc(1, sizeof(extenthdr_t));
 		assert(contextp->cc_extenthdrp);
 
 		contextp->cc_getdentsbufsz = sizeof(struct dirent)
-					       +
-					       NAME_MAX + 1;
+					     +
+					     NAME_MAX + 1;
 		if (contextp->cc_getdentsbufsz < GETDENTSBUF_SZ_MIN) {
 			contextp->cc_getdentsbufsz = GETDENTSBUF_SZ_MIN;
 		}
 		contextp->cc_getdentsbufp =
-			   (char *) calloc(1, contextp->cc_getdentsbufsz);
+			(char *) calloc(1, contextp->cc_getdentsbufsz);
 		assert(contextp->cc_getdentsbufp);
 
 		contextp->cc_mdirentbufsz = sizeof(direnthdr_t)
@@ -1719,7 +1719,7 @@ baseuuidbypass:
 					    +
 					    DIRENTHDR_ALIGN;
 		contextp->cc_mdirentbufp =
-			   (char *) calloc(1, contextp->cc_mdirentbufsz);
+			(char *) calloc(1, contextp->cc_mdirentbufsz);
 		assert(contextp->cc_mdirentbufp);
 
 		contextp->cc_extattrlistbufsz = EXTATTR_LISTBUF_SZ;
@@ -1729,15 +1729,15 @@ baseuuidbypass:
 			contextp->cc_extattrdumpbufsz = EXTATTR_DUMPBUF_SZ;
 		}
 		contextp->cc_extattrlistbufp =
-			   (char *)calloc(1, contextp->cc_extattrlistbufsz);
+			(char *)calloc(1, contextp->cc_extattrlistbufsz);
 		assert(contextp->cc_extattrlistbufp);
 		contextp->cc_extattrrtrvarrayp =
-		  (attr_multiop_t *)calloc(contextp->cc_extattrrtrvarraylen,
-				    sizeof(attr_multiop_t));
+			(attr_multiop_t *)calloc(contextp->cc_extattrrtrvarraylen,
+						 sizeof(attr_multiop_t));
 		assert(contextp->cc_extattrrtrvarrayp);
 		contextp->cc_extattrdumpbufp =
-			   (char *)memalign(sizeof(extattrhdr_t),
-					       contextp->cc_extattrdumpbufsz);
+			(char *)memalign(sizeof(extattrhdr_t),
+					 contextp->cc_extattrdumpbufsz);
 		assert(contextp->cc_extattrdumpbufp);
 		if (hsm_fs_ctxtp) {
 			contextp->cc_hsm_f_ctxtp = HsmAllocateFileContext(
@@ -1748,7 +1748,7 @@ baseuuidbypass:
 
 		contextp->cc_readlinkbufsz = MAXPATHLEN + SYMLINK_ALIGN;
 		contextp->cc_readlinkbufp =
-			   (char *) calloc(1, contextp->cc_readlinkbufsz);
+			(char *) calloc(1, contextp->cc_readlinkbufsz);
 		assert(contextp->cc_readlinkbufp);
 
 		contextp->cc_inomap_contextp = inomap_alloc_context();
@@ -1772,16 +1772,16 @@ baseuuidbypass:
 			case GETOPT_MEDIALABEL:
 				if (cp >= ep) {
 					mlog(MLOG_NORMAL, _(
-					      "more -%c arguments "
-					      "than number of drives\n"),
-					      c);
+						     "more -%c arguments "
+						     "than number of drives\n"),
+					     c);
 					usage();
 					return BOOL_FALSE;
 				}
 				if (! optarg || optarg[0] == '-') {
 					mlog(MLOG_NORMAL, _(
-					      "-%c argument missing\n"),
-					      c);
+						     "-%c argument missing\n"),
+					     c);
 					usage();
 					return BOOL_FALSE;
 				}
@@ -1793,10 +1793,10 @@ baseuuidbypass:
 
 		if (cp > sc_contextp && cp < ep) {
 			mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      "media labels given for only %d out of %d "
-			      "drives\n"),
-			      cp - sc_contextp,
-			      drivecnt);
+				     "media labels given for only %d out of %d "
+				     "drives\n"),
+			     cp - sc_contextp,
+			     drivecnt);
 		}
 	}
 
@@ -1820,11 +1820,11 @@ baseuuidbypass:
 		pthread_sigmask(SIG_BLOCK, &tty_set, &orig_set);
 
 		result = create_inv_session(gwhdrtemplatep, &fsid, mntpnt,
-					     fsdevice, subtreecnt, strmix);
+					    fsdevice, subtreecnt, strmix);
 
 		pthread_sigmask(SIG_SETMASK, &orig_set, NULL);
 
-		if (!result) {
+		if (! result) {
 			return BOOL_FALSE;
 		}
 	}
@@ -1856,7 +1856,7 @@ baseuuidbypass:
 	return BOOL_TRUE;
 }
 
-#define STATLINESZ	160
+#define STATLINESZ      160
 
 size_t
 content_statline(char **linespp[])
@@ -1905,32 +1905,32 @@ content_statline(char **linespp[])
 	if (sc_stat_inomapphase && sc_stat_inomapcnt) {
 		if (sc_stat_inomappass) {
 			sprintf(statline[0],
-				 "status at %02d:%02d:%02d: "
-				 "inomap phase %u pass %u "
-				 "%llu/%llu inos scanned, "
-				 "%ld seconds elapsed\n",
-				 tmp->tm_hour,
-				 tmp->tm_min,
-				 tmp->tm_sec,
-				 (unsigned int)sc_stat_inomapphase,
-				 (unsigned int)sc_stat_inomappass,
-				 (unsigned long long)sc_stat_inomapdone,
-				 (unsigned long long)sc_stat_inomapcnt,
-				 elapsed);
+				"status at %02d:%02d:%02d: "
+				"inomap phase %u pass %u "
+				"%llu/%llu inos scanned, "
+				"%ld seconds elapsed\n",
+				tmp->tm_hour,
+				tmp->tm_min,
+				tmp->tm_sec,
+				(unsigned int)sc_stat_inomapphase,
+				(unsigned int)sc_stat_inomappass,
+				(unsigned long long)sc_stat_inomapdone,
+				(unsigned long long)sc_stat_inomapcnt,
+				elapsed);
 			assert(strlen(statline[0]) < STATLINESZ);
 		} else {
 			sprintf(statline[0],
-				 "status at %02d:%02d:%02d: "
-				 "inomap phase %u "
-				 "%llu/%llu inos scanned, "
-				 "%ld seconds elapsed\n",
-				 tmp->tm_hour,
-				 tmp->tm_min,
-				 tmp->tm_sec,
-				 (unsigned int)sc_stat_inomapphase,
-				 (unsigned long long)sc_stat_inomapdone,
-				 (unsigned long long)sc_stat_inomapcnt,
-				 elapsed);
+				"status at %02d:%02d:%02d: "
+				"inomap phase %u "
+				"%llu/%llu inos scanned, "
+				"%ld seconds elapsed\n",
+				tmp->tm_hour,
+				tmp->tm_min,
+				tmp->tm_sec,
+				(unsigned int)sc_stat_inomapphase,
+				(unsigned long long)sc_stat_inomapdone,
+				(unsigned long long)sc_stat_inomapcnt,
+				elapsed);
 			assert(strlen(statline[0]) < STATLINESZ);
 		}
 		return 1;
@@ -1948,11 +1948,11 @@ content_statline(char **linespp[])
 	if (nondirdone || datadone) {
 		/*
 		 * calculate percentage of data dumped
-		*/
+		 */
 		if (sc_stat_datasz) {
 			percent = (double)datadone
-				/
-				(double)sc_stat_datasz;
+				  /
+				  (double)sc_stat_datasz;
 			percent *= 100.0;
 		} else {
 			percent = 100.0;
@@ -1963,26 +1963,26 @@ content_statline(char **linespp[])
 
 		/*
 		 * format the status line in a local static buffer (non-re-entrant!)
-		*/
+		 */
 		sprintf(statline[0],
-				"status at %02d:%02d:%02d: %llu/%llu files dumped, "
-				"%.1lf%%%% data dumped, "
-				"%ld seconds elapsed\n",
-				tmp->tm_hour,
-				tmp->tm_min,
-				tmp->tm_sec,
-				(unsigned long long) nondirdone,
-				(unsigned long long) sc_stat_nondircnt,
-				percent,
-				elapsed);
+			"status at %02d:%02d:%02d: %llu/%llu files dumped, "
+			"%.1lf%%%% data dumped, "
+			"%ld seconds elapsed\n",
+			tmp->tm_hour,
+			tmp->tm_min,
+			tmp->tm_sec,
+			(unsigned long long) nondirdone,
+			(unsigned long long) sc_stat_nondircnt,
+			percent,
+			elapsed);
 	} else {
 		sprintf(statline[0],
-				"status at %02d:%02d:%02d: "
-				"%ld seconds elapsed\n",
-				tmp->tm_hour,
-				tmp->tm_min,
-				tmp->tm_sec,
-				elapsed);
+			"status at %02d:%02d:%02d: "
+			"%ld seconds elapsed\n",
+			tmp->tm_hour,
+			tmp->tm_min,
+			tmp->tm_sec,
+			elapsed);
 	}
 
 	assert(strlen(statline[0]) < STATLINESZ);
@@ -1994,46 +1994,46 @@ content_statline(char **linespp[])
 	for (i = 0; i < drivecnt; i++) {
 		pds_t *pdsp = &sc_stat_pds[i];
 		if (pdsp->pds_phase == PDS_NULL
-		     ||
-		     pdsp->pds_phase == PDS_NONDIR) {
+		    ||
+		    pdsp->pds_phase == PDS_NONDIR) {
 			continue;
 		}
 		statline[statlinecnt][0] = 0;
 		if (drivecnt > 1) {
 			sprintf(statline[statlinecnt],
-				 "drive %u: ",
-				 (unsigned int)i);
+				"drive %u: ",
+				(unsigned int)i);
 		}
 		switch (pdsp->pds_phase) {
 		case PDS_INOMAP:
 			strcat(statline[statlinecnt],
-				"dumping inomap");
+			       "dumping inomap");
 			break;
 		case PDS_DIRDUMP:
 			sprintf(&statline[statlinecnt]
-					  [strlen(statline[statlinecnt])],
-				 "%llu/%llu directories dumped",
-				 (unsigned long long)pdsp->pds_dirdone,
-				 (unsigned long long)sc_stat_dircnt);
+				[strlen(statline[statlinecnt])],
+				"%llu/%llu directories dumped",
+				(unsigned long long)pdsp->pds_dirdone,
+				(unsigned long long)sc_stat_dircnt);
 			break;
 		case PDS_INVSYNC:
 			strcat(statline[statlinecnt],
-				"waiting to dump inventory");
+			       "waiting to dump inventory");
 			break;
 		case PDS_INVDUMP:
 			strcat(statline[statlinecnt],
-				"dumping inventory");
+			       "dumping inventory");
 			break;
 		case PDS_TERMDUMP:
 			strcat(statline[statlinecnt],
-				"dumping stream terminator");
+			       "dumping stream terminator");
 			break;
 		default:
 			break;
 		}
 		sprintf(&statline[statlinecnt]
-				  [strlen(statline[statlinecnt])],
-			 "\n");
+			[strlen(statline[statlinecnt])],
+			"\n");
 		assert(strlen(statline[statlinecnt]) < STATLINESZ);
 		statlinecnt++;
 	}
@@ -2043,12 +2043,12 @@ content_statline(char **linespp[])
 
 static bool_t
 create_inv_session(
-		global_hdr_t *gwhdrtemplatep,
-		uuid_t *fsidp,
-		const char *mntpnt,
-		const char *fsdevice,
-		ix_t subtreecnt,
-		size_t strmix)
+	global_hdr_t *	gwhdrtemplatep,
+	uuid_t *	fsidp,
+	const char *	mntpnt,
+	const char *	fsdevice,
+	ix_t		subtreecnt,
+	size_t		strmix)
 {
 	int rval;
 	char *qmntpnt;
@@ -2059,18 +2059,18 @@ create_inv_session(
 	assert(! rval);
 
 	sc_inv_idbtoken = inv_open((inv_predicate_t)INV_BY_UUID,
-					INV_SEARCH_N_MOD,
-					(void *)fsidp);
+				   INV_SEARCH_N_MOD,
+				   (void *)fsidp);
 	if (sc_inv_idbtoken == INV_TOKEN_NULL) {
 		return BOOL_FALSE;
 	}
 	qmntpnt = (char *)calloc(1, strlen(gwhdrtemplatep->gh_hostname)
-					+ 1 + strlen(mntpnt) + 1);
+				 + 1 + strlen(mntpnt) + 1);
 	assert(qmntpnt);
 	assert(strlen(gwhdrtemplatep->gh_hostname));
 	sprintf(qmntpnt, "%s:%s", gwhdrtemplatep->gh_hostname, mntpnt);
 	qfsdevice = (char *)calloc(1, strlen(gwhdrtemplatep->gh_hostname)
-					 + 1 + strlen(fsdevice) + 1);
+				   + 1 + strlen(fsdevice) + 1);
 	assert(qfsdevice);
 	sprintf(qfsdevice, "%s:%s", gwhdrtemplatep->gh_hostname, fsdevice);
 
@@ -2079,7 +2079,7 @@ create_inv_session(
 						&gwhdrtemplatep->gh_dumpid,
 						gwhdrtemplatep->gh_dumplabel,
 						subtreecnt ? BOOL_TRUE
-							   : BOOL_FALSE,
+						: BOOL_FALSE,
 						sc_resumepr,
 						(u_char_t)sc_level,
 						drivecnt,
@@ -2092,9 +2092,9 @@ create_inv_session(
 
 	/*
 	 * open an inventory stream for each stream
-	*/
+	 */
 	sc_inv_stmtokenp = (inv_stmtoken_t *)
-				calloc(drivecnt, sizeof(inv_stmtoken_t));
+			   calloc(drivecnt, sizeof(inv_stmtoken_t));
 	assert(sc_inv_stmtokenp);
 	for (strmix = 0; strmix < drivecnt; strmix++) {
 		drive_t *drivep = drivepp[strmix];
@@ -2106,7 +2106,7 @@ create_inv_session(
 			drvpath = drivep->d_pathname;
 		}
 		sc_inv_stmtokenp[strmix] = inv_stream_open(sc_inv_sestoken,
-								drvpath);
+							   drvpath);
 		if (strcmp(drivep->d_pathname, "stdio")) {
 			free((void *)drvpath);
 		}
@@ -2127,25 +2127,25 @@ mark_set(drive_t *drivep, xfs_ino_t ino, off64_t offset, int32_t flags)
 
 	if (flags & STARTPT_FLAGS_NULL) {
 		mlog(MLOG_DEBUG,
-		      "setting media NULL mark\n");
+		     "setting media NULL mark\n");
 	} else if (flags & STARTPT_FLAGS_END) {
 		mlog(MLOG_DEBUG,
-		      "setting media END mark\n");
+		     "setting media END mark\n");
 	} else {
 		mlog(MLOG_DEBUG,
-		      "setting media mark"
-		      " for ino %llu offset %lld\n",
-		      ino,
-		      offset);
+		     "setting media mark"
+		     " for ino %llu offset %lld\n",
+		     ino,
+		     offset);
 	}
 
 	markp->startpt.sp_ino = ino;
 	markp->startpt.sp_offset = offset;
 	markp->startpt.sp_flags = flags;
 	(*dop->do_set_mark)(drivep,
-				mark_callback,
-				(void *)drivep->d_index,
-				(drive_markrec_t *)markp);
+			    mark_callback,
+			    (void *)drivep->d_index,
+			    (drive_markrec_t *)markp);
 }
 
 static void
@@ -2186,15 +2186,15 @@ mark_callback(void *p, drive_markrec_t *dmp, bool_t committed)
 		 */
 		if (markp->startpt.sp_flags & STARTPT_FLAGS_NULL) {
 			mlog(MLOG_DEBUG,
-			      "media NULL mark committed"
-			      " in media file %d\n",
-			      mwhdrp->mh_dumpfileix);
+			     "media NULL mark committed"
+			     " in media file %d\n",
+			     mwhdrp->mh_dumpfileix);
 			scwhdrp->cih_startpt.sp_flags |= STARTPT_FLAGS_NULL;
 		} else if (markp->startpt.sp_flags & STARTPT_FLAGS_END) {
 			mlog(MLOG_DEBUG,
-			      "media END mark committed"
-			      " in media file %d\n",
-			      mwhdrp->mh_dumpfileix);
+			     "media END mark committed"
+			     " in media file %d\n",
+			     mwhdrp->mh_dumpfileix);
 			if (scwhdrp->cih_endpt.sp_flags & STARTPT_FLAGS_END) {
 				scwhdrp->cih_startpt.sp_ino++;
 				scwhdrp->cih_startpt.sp_offset = 0;
@@ -2204,12 +2204,12 @@ mark_callback(void *p, drive_markrec_t *dmp, bool_t committed)
 			scwhdrp->cih_startpt.sp_flags |= STARTPT_FLAGS_END;
 		} else {
 			mlog(MLOG_DEBUG,
-			      "media mark committed"
-			      " for ino %llu offset %lld"
-			      " in media file %d\n",
-			      markp->startpt.sp_ino,
-			      markp->startpt.sp_offset,
-			      mwhdrp->mh_dumpfileix);
+			     "media mark committed"
+			     " for ino %llu offset %lld"
+			     " in media file %d\n",
+			     markp->startpt.sp_ino,
+			     markp->startpt.sp_offset,
+			     mwhdrp->mh_dumpfileix);
 			scwhdrp->cih_startpt = markp->startpt;
 		}
 	} else {
@@ -2218,16 +2218,16 @@ mark_callback(void *p, drive_markrec_t *dmp, bool_t committed)
 		 */
 		if (markp->startpt.sp_flags & STARTPT_FLAGS_NULL) {
 			mlog(MLOG_DEBUG,
-			      "media NULL mark -NOT- committed\n");
+			     "media NULL mark -NOT- committed\n");
 		} else if (markp->startpt.sp_flags & STARTPT_FLAGS_END) {
 			mlog(MLOG_DEBUG,
-			      "media END mark -NOT- committed\n");
+			     "media END mark -NOT- committed\n");
 		} else {
 			mlog(MLOG_DEBUG,
-			      "media mark -NOT- committed"
-			      " for ino %llu offset %lld\n",
-			      markp->startpt.sp_ino,
-			      markp->startpt.sp_offset);
+			     "media mark -NOT- committed"
+			     " for ino %llu offset %lld\n",
+			     markp->startpt.sp_ino,
+			     markp->startpt.sp_offset);
 		}
 	}
 
@@ -2269,7 +2269,7 @@ content_stream_dump(ix_t strmix)
 	 * allocate a buffer for use by bstat_iter
 	 */
 	bstatbufp = (xfs_bstat_t *)calloc(bstatbuflen,
-					     sizeof(xfs_bstat_t));
+					  sizeof(xfs_bstat_t));
 	assert(bstatbufp);
 
 	/* allocate an inomap context */
@@ -2409,17 +2409,17 @@ content_stream_dump(ix_t strmix)
 		}
 		if (rv == RV_TIMEOUT) {
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change timeout will be treated as "
-			      "a request to stop using drive: "
-			      "can resume later\n"));
+				     "media change timeout will be treated as "
+				     "a request to stop using drive: "
+				     "can resume later\n"));
 			mlog_exit_hint(RV_QUIT);
 			return mlog_exit(EXIT_NORMAL, rv);
 		}
 		if (rv == RV_QUIT) {
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change decline will be treated as "
-			      "a request to stop using drive: "
-			      "can resume later\n"));
+				     "media change decline will be treated as "
+				     "a request to stop using drive: "
+				     "can resume later\n"));
 			mlog_exit_hint(RV_QUIT);
 			return mlog_exit(EXIT_NORMAL, rv);
 		}
@@ -2441,11 +2441,11 @@ content_stream_dump(ix_t strmix)
 		 * sync up here with other streams if reasonable
 		 */
 		mlog(MLOG_VERBOSE, _(
-		      "creating dump session media file %u "
-		      "(media %u, file %u)\n"),
-		      mwhdrp->mh_dumpfileix,
-		      mwhdrp->mh_mediaix,
-		      mwhdrp->mh_mediafileix);
+			     "creating dump session media file %u "
+			     "(media %u, file %u)\n"),
+		     mwhdrp->mh_dumpfileix,
+		     mwhdrp->mh_mediaix,
+		     mwhdrp->mh_mediafileix);
 
 		/*
 		 * initialize the count of marks committed in the media file.
@@ -2457,7 +2457,7 @@ content_stream_dump(ix_t strmix)
 		 * first dump the inomap
 		 */
 		mlog(MLOG_VERBOSE, _(
-		      "dumping ino map\n"));
+			     "dumping ino map\n"));
 		sc_stat_pds[strmix].pds_phase = PDS_INOMAP;
 		rv = inomap_dump(drivep);
 		if (rv == RV_INTR) {
@@ -2494,9 +2494,9 @@ content_stream_dump(ix_t strmix)
 		if (scwhdrp->cih_dumpattr & CIH_DUMPATTR_DIRDUMP) {
 			sc_stat_pds[strmix].pds_dirdone = 0;
 			rv = dump_dirs(strmix,
-					bstatbufp,
-					bstatbuflen,
-					inomap_contextp);
+				       bstatbufp,
+				       bstatbuflen,
+				       inomap_contextp);
 			if (rv == RV_INTR) {
 				stop_requested = BOOL_TRUE;
 				goto decision_more;
@@ -2534,23 +2534,23 @@ content_stream_dump(ix_t strmix)
 		 */
 		if (! all_nondirs_committed) {
 			mlog(MLOG_VERBOSE, _(
-			      "dumping non-directory files\n"));
+				     "dumping non-directory files\n"));
 			sc_stat_pds[strmix].pds_phase = PDS_NONDIR;
 			rv = RV_OK;
 			inomap_reset_context(inomap_contextp);
 			rval = bigstat_iter(sc_fshandlep,
-					     sc_fsfd,
-					     BIGSTAT_ITER_NONDIR,
-					     scwhdrp->cih_startpt.sp_ino,
-					     (bstat_cbfp_t)dump_file,
-					     (void *)strmix,
-					     inomap_next_nondir,
-					     inomap_contextp,
-					     (int *)&rv,
-					     pipeline ?
-					       (bool_t (*)(int))preemptchk : 0,
-					     bstatbufp,
-					     bstatbuflen);
+					    sc_fsfd,
+					    BIGSTAT_ITER_NONDIR,
+					    scwhdrp->cih_startpt.sp_ino,
+					    (bstat_cbfp_t)dump_file,
+					    (void *)strmix,
+					    inomap_next_nondir,
+					    inomap_contextp,
+					    (int *)&rv,
+					    pipeline ?
+					    (bool_t (*)(int))preemptchk : 0,
+					    bstatbufp,
+					    bstatbuflen);
 			if (rval) {
 				free((void *)bstatbufp);
 				return mlog_exit(EXIT_FAULT, RV_CORE);
@@ -2597,9 +2597,9 @@ content_stream_dump(ix_t strmix)
 		 */
 		all_nondirs_sent = BOOL_TRUE;
 		mark_set(drivep,
-			  INO64MAX,
-			  OFF64MAX,
-			  STARTPT_FLAGS_END);
+			 INO64MAX,
+			 OFF64MAX,
+			 STARTPT_FLAGS_END);
 
 decision_more:
 		/*
@@ -2611,16 +2611,16 @@ decision_more:
 		 */
 		if (! hit_eom) {
 			rv = dump_filehdr(drivep,
-					   contextp,
-					   0,
-					   0,
-					   all_nondirs_sent
-					   ?
-					   (FILEHDR_FLAGS_NULL
-					     |
-					     FILEHDR_FLAGS_END)
-					   :
-					   FILEHDR_FLAGS_NULL);
+					  contextp,
+					  0,
+					  0,
+					  all_nondirs_sent
+					  ?
+					  (FILEHDR_FLAGS_NULL
+					   |
+					   FILEHDR_FLAGS_END)
+					  :
+					  FILEHDR_FLAGS_NULL);
 			if (rv == RV_DRIVE) {
 				free((void *)bstatbufp);
 				return mlog_exit(EXIT_NORMAL, rv);
@@ -2640,13 +2640,13 @@ decision_more:
 			 * call returns if the null file header made it.
 			 */
 			mark_set(drivep,
-				  INO64MAX,
-				  OFF64MAX,
-				  all_nondirs_sent
-				  ?
-				  STARTPT_FLAGS_NULL | STARTPT_FLAGS_END
-				  :
-				  STARTPT_FLAGS_NULL);
+				 INO64MAX,
+				 OFF64MAX,
+				 all_nondirs_sent
+				 ?
+				 STARTPT_FLAGS_NULL | STARTPT_FLAGS_END
+				 :
+				 STARTPT_FLAGS_NULL);
 		}
 
 		/*
@@ -2657,13 +2657,13 @@ decision_more:
 		 * all pending marks.
 		 */
 		mlog(MLOG_VERBOSE, _(
-		      "ending media file\n"));
+			     "ending media file\n"));
 		ncommitted = 0;
 		rv = Media_mfile_end(drivep,
-				      contextp,
-				      mwhdrp,
-				      &ncommitted,
-				      hit_eom);
+				     contextp,
+				     mwhdrp,
+				     &ncommitted,
+				     hit_eom);
 		if (rv == RV_DRIVE) {
 			free((void *)bstatbufp);
 			return mlog_exit(EXIT_NORMAL, rv);
@@ -2673,8 +2673,8 @@ decision_more:
 			return mlog_exit(EXIT_FAULT, rv);
 		}
 		mlog(MLOG_VERBOSE, _(
-		      "media file size %lld bytes\n"),
-		      ncommitted);
+			     "media file size %lld bytes\n"),
+		     ncommitted);
 
 		/*
 		 * if at least one mark committed, we know all of
@@ -2710,66 +2710,66 @@ decision_more:
 
 			if (! all_dirs_committed) {
 				mlog(MLOG_DEBUG,
-				      "giving inventory "
-				      "partial dirdump media file\n");
+				     "giving inventory "
+				     "partial dirdump media file\n");
 			} else if (done && empty_mediafile) {
 				mlog(MLOG_DEBUG,
-				      "giving inventory "
-				      "empty last media file: "
-				      "%llu:%lld\n",
-				       startino,
-				       startoffset);
+				     "giving inventory "
+				     "empty last media file: "
+				     "%llu:%lld\n",
+				     startino,
+				     startoffset);
 			} else if (empty_mediafile) {
 				mlog(MLOG_DEBUG,
-				      "giving inventory "
-				      "empty media file: "
-				      "%llu:%lld\n",
-				       startino,
-				       startoffset);
+				     "giving inventory "
+				     "empty media file: "
+				     "%llu:%lld\n",
+				     startino,
+				     startoffset);
 			} else if (done) {
 				mlog(MLOG_DEBUG,
-				      "giving inventory "
-				      "last media file: "
-				      "%llu:%lld\n",
-				       startino,
-				       startoffset);
+				     "giving inventory "
+				     "last media file: "
+				     "%llu:%lld\n",
+				     startino,
+				     startoffset);
 			} else {
 				mlog(MLOG_DEBUG,
-				      "giving inventory "
-				      "media file: "
-				      "%llu:%lld - %llu:%lld\n",
-				       startino,
-				       startoffset,
-				       scwhdrp->cih_startpt.sp_ino,
-				       scwhdrp->cih_startpt.sp_offset);
+				     "giving inventory "
+				     "media file: "
+				     "%llu:%lld - %llu:%lld\n",
+				     startino,
+				     startoffset,
+				     scwhdrp->cih_startpt.sp_ino,
+				     scwhdrp->cih_startpt.sp_offset);
 			}
 
 			/*
 			 * already thread-safe, don't need to lock
 			 */
 			ok = inv_put_mediafile(inv_stmt,
-						&mwhdrp->mh_mediaid,
-						mwhdrp->mh_medialabel,
-					(uint)mwhdrp->mh_mediafileix,
-						startino,
-						startoffset,
-						scwhdrp->cih_startpt.sp_ino,
-						scwhdrp->cih_startpt.sp_offset,
-						ncommitted,
-					        all_dirs_committed
-						&&
-						! empty_mediafile,
-						BOOL_FALSE);
+					       &mwhdrp->mh_mediaid,
+					       mwhdrp->mh_medialabel,
+					       (uint)mwhdrp->mh_mediafileix,
+					       startino,
+					       startoffset,
+					       scwhdrp->cih_startpt.sp_ino,
+					       scwhdrp->cih_startpt.sp_offset,
+					       ncommitted,
+					       all_dirs_committed
+					       &&
+					       ! empty_mediafile,
+					       BOOL_FALSE);
 			if (! ok) {
 				mlog(MLOG_NORMAL, _(
-				      "inventory media file put failed\n"));
+					     "inventory media file put failed\n"));
 			}
 		}
 		if (done) {
 			contextp->cc_completepr = BOOL_TRUE;
-			    /*
-			     * so inv_end_stream and main will know
-			     */
+			/*
+			 * so inv_end_stream and main will know
+			 */
 		}
 
 		/*
@@ -2796,20 +2796,20 @@ decision_more:
 	if (drivep->d_capabilities & DRIVE_CAP_FILES) {
 		if (stream_cnt() > 1) {
 			mlog(MLOG_VERBOSE, _(
-			      "waiting for synchronized "
-			      "session inventory dump\n"));
+				     "waiting for synchronized "
+				     "session inventory dump\n"));
 			sc_stat_pds[strmix].pds_phase = PDS_INVSYNC;
 		}
 
 		/*
 		 * first be sure all threads have begun
-		*/
+		 */
 		while (sc_thrdsarrivedcnt < drivecnt) {
 			sleep(1);
 		}
 		/*
 		 * now wait for survivors to checkin
-		*/
+		 */
 		while (sc_thrdsdonecnt < stream_cnt()) {
 			sleep(1);
 		}
@@ -2830,8 +2830,8 @@ decision_more:
 	elapsed = time(0) - sc_stat_starttime;
 
 	mlog(MLOG_TRACE, _(
-	      "ending stream: %ld seconds elapsed\n"),
-	      elapsed);
+		     "ending stream: %ld seconds elapsed\n"),
+	     elapsed);
 
 	return mlog_exit(EXIT_NORMAL, rv);
 }
@@ -2854,57 +2854,57 @@ content_complete(void)
 	elapsed = time(0) - sc_stat_starttime;
 
 	mlog(MLOG_VERBOSE, _(
-	      "dump size (non-dir files) : %llu bytes\n"),
-	      sc_stat_datadone);
+		     "dump size (non-dir files) : %llu bytes\n"),
+	     sc_stat_datadone);
 
 	if (completepr) {
 		if (sc_savequotas) {
 			for (i = 0; i < (sizeof(quotas) / sizeof(quotas[0])); i++) {
 				if (quotas[i].savequotas && unlink(quotas[i].quotapath) < 0) {
 					mlog(MLOG_ERROR, _(
-					"unable to remove %s: %s\n"),
-					quotas[i].quotapath,
-					strerror (errno));
+						     "unable to remove %s: %s\n"),
+					     quotas[i].quotapath,
+					     strerror (errno));
 				}
 			}
 		}
 
 		mlog(MLOG_VERBOSE, _(
-		      "dump complete"
-		      ": %ld seconds elapsed"
-		      "\n"),
-		      elapsed);
+			     "dump complete"
+			     ": %ld seconds elapsed"
+			     "\n"),
+		     elapsed);
 	} else {
 		if (sc_inv_updatepr) {
 			mlog(MLOG_VERBOSE | MLOG_NOTE, _(
-			      "dump interrupted"
-			      ": %ld seconds elapsed"
-			      ": may resume later using -%c option"
-			      "\n"),
-			      elapsed,
-			      GETOPT_RESUME);
+				     "dump interrupted"
+				     ": %ld seconds elapsed"
+				     ": may resume later using -%c option"
+				     "\n"),
+			     elapsed,
+			     GETOPT_RESUME);
 			mlog_exit_hint(RV_INTR);
 		} else {
 			mlog(MLOG_VERBOSE | MLOG_NOTE, _(
-			      "dump interrupted"
-			      ": %ld seconds elapsed"
-			      "\n"),
-			      elapsed);
+				     "dump interrupted"
+				     ": %ld seconds elapsed"
+				     "\n"),
+			     elapsed);
 			mlog_exit_hint(RV_INTR);
 		}
 	}
 	return completepr;
 }
 
-#define PREAMBLEMAX	3
-#define QUERYMAX	1
-#define CHOICEMAX	30
-#define ACKMAX		3
-#define POSTAMBLEMAX	3
-#define DLOG_TIMEOUT	300
-#define DLOG_TIMEOUT_MEDIA	3600
+#define PREAMBLEMAX     3
+#define QUERYMAX        1
+#define CHOICEMAX       30
+#define ACKMAX          3
+#define POSTAMBLEMAX    3
+#define DLOG_TIMEOUT    300
+#define DLOG_TIMEOUT_MEDIA      3600
 
-#define CHOICESTRSZ	10
+#define CHOICESTRSZ     10
 typedef struct { ix_t thrdix; char choicestr[CHOICESTRSZ]; } cttm_t;
 
 char *
@@ -2928,10 +2928,10 @@ content_mediachange_query(void)
 		if (sc_mcflag[thrdix]) {
 			choicetothrdmap[choicecnt].thrdix = thrdix;
 			sprintf(choicetothrdmap[choicecnt].choicestr,
-				 "drive %u",
-				 (unsigned int)thrdix);
+				"drive %u",
+				(unsigned int)thrdix);
 			choicestr[choicecnt] =
-					choicetothrdmap[choicecnt].choicestr;
+				choicetothrdmap[choicecnt].choicestr;
 			maxdrvchoiceix = choicecnt;
 			choicecnt++;
 		}
@@ -2940,18 +2940,18 @@ content_mediachange_query(void)
 	choicestr[choicecnt++] = "continue";
 	assert(choicecnt <= CHOICEMAX);
 	responseix = dlog_multi_query(querystr,
-				       querycnt,
-				       choicestr,
-				       choicecnt,
-				       0,           /* hilitestr */
-				       IXMAX,       /* hiliteix */
-				       0,           /* defaultstr */
-				       nochangeix,  /* defaultix */
-				       DLOG_TIMEOUT_MEDIA,
-				       nochangeix, /* timeout ix */
-				       nochangeix, /* sigint ix */
-				       nochangeix, /* sighup ix */
-				       nochangeix);/* sigquit ix */
+				      querycnt,
+				      choicestr,
+				      choicecnt,
+				      0,                /* hilitestr */
+				      IXMAX,            /* hiliteix */
+				      0,                /* defaultstr */
+				      nochangeix,       /* defaultix */
+				      DLOG_TIMEOUT_MEDIA,
+				      nochangeix,       /* timeout ix */
+				      nochangeix,       /* sigint ix */
+				      nochangeix,       /* sighup ix */
+				      nochangeix);      /* sigquit ix */
 	if (responseix <= maxdrvchoiceix) {
 		clr_mcflag(choicetothrdmap[responseix].thrdix);
 		return "media change acknowledged\n";
@@ -2967,29 +2967,29 @@ update_cc_Media_useterminatorpr(drive_t *drivep, context_t *contextp)
 	int dcaps = drivep->d_capabilities;
 
 	contextp->cc_Media_useterminatorpr = BOOL_TRUE;
-	if (! (dcaps & DRIVE_CAP_FILES)) {
+	if (!(dcaps & DRIVE_CAP_FILES)) {
 		contextp->cc_Media_useterminatorpr = BOOL_FALSE;
 	}
-	if (! (dcaps & DRIVE_CAP_OVERWRITE)) {
+	if (!(dcaps & DRIVE_CAP_OVERWRITE)) {
 		contextp->cc_Media_useterminatorpr = BOOL_FALSE;
 	}
-	if (! (dcaps & DRIVE_CAP_BSF)) {
+	if (!(dcaps & DRIVE_CAP_BSF)) {
 		contextp->cc_Media_useterminatorpr = BOOL_FALSE;
 	}
-	if (! (dcaps & DRIVE_CAP_APPEND)) {
+	if (!(dcaps & DRIVE_CAP_APPEND)) {
 		contextp->cc_Media_useterminatorpr = BOOL_FALSE;
 	}
 }
 
 static rv_t
-dump_dirs(ix_t strmix,
-	   xfs_bstat_t *bstatbufp,
-	   size_t bstatbuflen,
-	   void *inomap_contextp)
+dump_dirs(ix_t		strmix,
+	  xfs_bstat_t * bstatbufp,
+	  size_t	bstatbuflen,
+	  void *	inomap_contextp)
 {
 	xfs_ino_t lastino;
 	size_t bulkstatcallcnt;
-        xfs_fsop_bulkreq_t bulkreq;
+	xfs_fsop_bulkreq_t bulkreq;
 
 	inomap_reset_context(inomap_contextp);
 
@@ -3005,7 +3005,7 @@ dump_dirs(ix_t strmix,
 
 		if (bulkstatcallcnt == 0) {
 			mlog(MLOG_VERBOSE, _(
-			      "dumping directories\n"));
+				     "dumping directories\n"));
 		}
 		sc_stat_pds[strmix].pds_phase = PDS_DIRDUMP;
 
@@ -3020,9 +3020,9 @@ dump_dirs(ix_t strmix,
 		 * get a bunch of bulkstats
 		 */
 		mlog(MLOG_NITTY,
-		      "dump_dirs SGI_FS_BULKSTAT %u buf len %u\n",
-		      bulkstatcallcnt,
-		      bstatbuflen);
+		     "dump_dirs SGI_FS_BULKSTAT %u buf len %u\n",
+		     bulkstatcallcnt,
+		     bstatbuflen);
 
 		bulkreq.lastip = (__u64 *)&lastino;
 		bulkreq.icount = bstatbuflen;
@@ -3033,15 +3033,15 @@ dump_dirs(ix_t strmix,
 
 		if (rval) {
 			mlog(MLOG_NORMAL, _(
-			      "SGI_FS_BULKSTAT failed: "
-			      "%s (%d)\n"),
-			      strerror(errno),
-			      errno);
+				     "SGI_FS_BULKSTAT failed: "
+				     "%s (%d)\n"),
+			     strerror(errno),
+			     errno);
 			return RV_ERROR;
 		}
 		mlog(MLOG_NITTY,
-		      "dump_dirs SGI_FS_BULKSTAT returns %d entries\n",
-		      buflenout);
+		     "dump_dirs SGI_FS_BULKSTAT returns %d entries\n",
+		     buflenout);
 
 		/*
 		 * check if done
@@ -3056,30 +3056,30 @@ dump_dirs(ix_t strmix,
 		 */
 		for (p = bstatbufp, endp = bstatbufp + buflenout
 		     ;
-		      p < endp
+		     p < endp
 		     ;
-		      p++) {
+		     p++) {
 			rv_t rv;
 
 			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,
-				      "ino %llu needs second bulkstat\n",
-				      p->bs_ino);
+				     "ino %llu needs second bulkstat\n",
+				     p->bs_ino);
 
 				if (bigstat_one(sc_fsfd, p->bs_ino, p) < 0) {
-					mlog(MLOG_WARNING,  _(
-					      "failed to get bulkstat information for inode %llu\n"),
-					      p->bs_ino);
+					mlog(MLOG_WARNING, _(
+						     "failed to get bulkstat information for inode %llu\n"),
+					     p->bs_ino);
 					continue;
 				}
-				if (!p->bs_nlink || !p->bs_mode || !p->bs_ino) {
+				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);
+					     "failed to get valid bulkstat information for inode %llu\n",
+					     p->bs_ino);
 					continue;
 				}
 			}
@@ -3107,10 +3107,10 @@ dump_dirs(ix_t strmix,
 }
 
 static rv_t
-dump_dir(ix_t strmix,
-	  jdm_fshandle_t *fshandlep,
-	  int fsfd,
-	  xfs_bstat_t *statp)
+dump_dir(ix_t			strmix,
+	 jdm_fshandle_t *	fshandlep,
+	 int			fsfd,
+	 xfs_bstat_t *		statp)
 {
 	context_t *contextp = &sc_contextp[strmix];
 	drive_t *drivep = drivepp[strmix];
@@ -3147,15 +3147,15 @@ dump_dir(ix_t strmix,
 	 * skip if not in inomap
 	 */
 	if (state == MAP_INO_UNUSED
-	     ||
-	     state == MAP_DIR_NOCHNG
-	     ||
-	     state == MAP_NDR_NOCHNG) {
+	    ||
+	    state == MAP_DIR_NOCHNG
+	    ||
+	    state == MAP_NDR_NOCHNG) {
 		if (state == MAP_NDR_NOCHNG) {
 			mlog(MLOG_DEBUG,
-			      "inomap inconsistency ino %llu: "
-			      "map says is non-dir but is dir: skipping\n",
-			      statp->bs_ino);
+			     "inomap inconsistency ino %llu: "
+			     "map says is non-dir but is dir: skipping\n",
+			     statp->bs_ino);
 		}
 		return RV_OK;
 	}
@@ -3165,9 +3165,9 @@ dump_dir(ix_t strmix,
 	 */
 	if (state == MAP_NDR_CHANGE) {
 		mlog(MLOG_DEBUG,
-		      "inomap inconsistency ino %llu: "
-		      "map says non-dir but is dir: skipping\n",
-		      statp->bs_ino);
+		     "inomap inconsistency ino %llu: "
+		     "map says non-dir but is dir: skipping\n",
+		     statp->bs_ino);
 		return RV_OK;
 	}
 
@@ -3176,21 +3176,21 @@ dump_dir(ix_t strmix,
 	 */
 	sc_stat_pds[strmix].pds_dirdone++;
 
-        /*
-         * if bulkstat ino# occupied more than 32 bits and
-         * linux ino# for getdents is 32 bits then
-         * warn and skip.
-         */
+	/*
+	 * if bulkstat ino# occupied more than 32 bits and
+	 * linux ino# for getdents is 32 bits then
+	 * warn and skip.
+	 */
 	if (statp->bs_ino > (xfs_ino_t)INOMAX) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "unable to dump directory: ino %llu too large\n"),
-		      statp->bs_ino);
+			     "unable to dump directory: ino %llu too large\n"),
+		     statp->bs_ino);
 		return RV_OK; /* continue anyway */
 	}
 
 	mlog(MLOG_TRACE,
-	      "dumping directory ino %llu\n",
-	      statp->bs_ino);
+	     "dumping directory ino %llu\n",
+	     statp->bs_ino);
 
 	/*
 	 * open the directory named by statp
@@ -3198,8 +3198,8 @@ dump_dir(ix_t strmix,
 	fd = jdm_open(fshandlep, statp, O_RDONLY);
 	if (fd < 0) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "unable to open directory: ino %llu: %s\n"),
-		      statp->bs_ino, strerror(errno) );
+			     "unable to open directory: ino %llu: %s\n"),
+		     statp->bs_ino, strerror(errno) );
 		return RV_OK; /* continue anyway */
 	}
 
@@ -3229,11 +3229,11 @@ dump_dir(ix_t strmix,
 		 */
 		if (nread < 0) {
 			mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      "unable to read dirents (%d) for "
-			      "directory ino %llu: %s\n"),
-			      gdcnt,
-			      statp->bs_ino,
-			      strerror(errno));
+				     "unable to read dirents (%d) for "
+				     "directory ino %llu: %s\n"),
+			     gdcnt,
+			     statp->bs_ino,
+			     strerror(errno));
 			/*
 			 * !!! curtis looked at this, and pointed out that
 			 * we could take some recovery action here. if the
@@ -3256,21 +3256,21 @@ dump_dir(ix_t strmix,
 		 * and null entries.
 		 */
 		for (p = gdp,
-		      reclen = (size_t)p->d_reclen
+		     reclen = (size_t)p->d_reclen
 		     ;
-		      nread > 0
+		     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_ino_t ino;
 			register size_t namelen = strlen(p->d_name);
 #ifdef DEBUG
 			register size_t nameszmax = (size_t)reclen
 						    -
 						    offsetofmember(struct dirent,
-								    d_name);
+								   d_name);
 
 			/*
 			 * getdents(2) guarantees that the string will
@@ -3284,12 +3284,12 @@ dump_dir(ix_t strmix,
 			 * skip "." and ".."
 			 */
 			if (*(p->d_name + 0) == '.'
-			     &&
-			     (*(p->d_name + 1) == 0
-			       ||
-			       (*(p->d_name + 1) == '.'
-				 &&
-				 *(p->d_name + 2) == 0))) {
+			    &&
+			    (*(p->d_name + 1) == 0
+			     ||
+			     (*(p->d_name + 1) == '.'
+			      &&
+			      *(p->d_name + 2) == 0))) {
 				continue;
 			}
 
@@ -3297,10 +3297,10 @@ dump_dir(ix_t strmix,
 
 			if (ino == 0) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "encountered 0 ino (%s) in "
-				      "directory ino %llu: NOT dumping\n"),
-				      p->d_name,
-				      statp->bs_ino);
+					     "encountered 0 ino (%s) in "
+					     "directory ino %llu: NOT dumping\n"),
+				     p->d_name,
+				     statp->bs_ino);
 				continue;
 			}
 
@@ -3313,17 +3313,17 @@ dump_dir(ix_t strmix,
 				int scrval;
 
 				scrval = bigstat_one(fsfd,
-						      p->d_ino,
-						      &statbuf);
+						     p->d_ino,
+						     &statbuf);
 				if (scrval) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					      "could not stat "
-					      "dirent %s ino %llu: %s: "
-					      "using null generation count "
-					      "in directory entry\n"),
-					      p->d_name,
-					      (xfs_ino_t)p->d_ino,
-					      strerror(errno));
+						     "could not stat "
+						     "dirent %s ino %llu: %s: "
+						     "using null generation count "
+						     "in directory entry\n"),
+					     p->d_name,
+					     (xfs_ino_t)p->d_ino,
+					     strerror(errno));
 					gen = 0;
 				} else {
 					gen = statbuf.bs_gen;
@@ -3331,12 +3331,12 @@ dump_dir(ix_t strmix,
 			}
 
 			rv = dump_dirent(drivep,
-					  contextp,
-					  statp,
-					  ino,
-					  gen,
-					  p->d_name,
-					  namelen);
+					 contextp,
+					 statp,
+					 ino,
+					 gen,
+					 p->d_name,
+					 namelen);
 			if (rv != RV_OK) {
 				break;
 			}
@@ -3351,10 +3351,10 @@ dump_dir(ix_t strmix,
 	}
 
 	if (rv == RV_OK
-	     &&
-	     sc_dumpextattrpr
-	     &&
-	     (statp->bs_xflags & XFS_XFLAG_HASATTR)) {
+	    &&
+	    sc_dumpextattrpr
+	    &&
+	    (statp->bs_xflags & XFS_XFLAG_HASATTR)) {
 		rv = dump_extattrs(drivep, contextp, fshandlep, statp);
 	}
 
@@ -3367,10 +3367,10 @@ dump_dir(ix_t strmix,
 }
 
 static rv_t
-dump_extattrs(drive_t *drivep,
-	       context_t *contextp,
-	       jdm_fshandle_t *fshandlep,
-	       xfs_bstat_t *statp)
+dump_extattrs(drive_t *		drivep,
+	      context_t *	contextp,
+	      jdm_fshandle_t *	fshandlep,
+	      xfs_bstat_t *	statp)
 {
 	ix_t pass;
 	int flag;
@@ -3382,9 +3382,9 @@ dump_extattrs(drive_t *drivep,
 	 * dump a file header specially marked as heading extended attributes
 	 */
 	mlog(MLOG_NITTY,
-	      "dumping %s ino %llu extended attributes filehdr\n",
-	      FILETYPE(statp),
-	      statp->bs_ino);
+	     "dumping %s ino %llu extended attributes filehdr\n",
+	     FILETYPE(statp),
+	     statp->bs_ino);
 
 	rv = dump_filehdr(drivep, contextp, statp, 0, FILEHDR_FLAGS_EXTATTR);
 	if (rv != RV_OK) {
@@ -3406,10 +3406,10 @@ dump_extattrs(drive_t *drivep,
 			flag = ATTR_SECURE;
 
 		mlog(MLOG_NITTY,
-		      "dumping %s extended attributes for %s ino %llu\n",
-		      EXTATTR_NAMESPACE(flag),
-		      FILETYPE(statp),
-		      statp->bs_ino);
+		     "dumping %s extended attributes for %s ino %llu\n",
+		     EXTATTR_NAMESPACE(flag),
+		     FILETYPE(statp),
+		     statp->bs_ino);
 
 		/*
 		 * loop dumping the extended attributes from the namespace
@@ -3422,18 +3422,18 @@ dump_extattrs(drive_t *drivep,
 			int rval = 0;
 
 			rval = jdm_attr_list(fshandlep, statp,
-				contextp->cc_extattrlistbufp,
-				(int)contextp->cc_extattrlistbufsz,
-				flag, &cursor);
+					     contextp->cc_extattrlistbufp,
+					     (int)contextp->cc_extattrlistbufsz,
+					     flag, &cursor);
 			if (rval) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "could not get list of %s attributes for "
-				      "%s ino %llu: %s (%d)\n"),
-				      EXTATTR_NAMESPACE(flag),
-				      FILETYPE(statp),
-				      statp->bs_ino,
-				      strerror(errno),
-				      errno);
+					     "could not get list of %s attributes for "
+					     "%s ino %llu: %s (%d)\n"),
+				     EXTATTR_NAMESPACE(flag),
+				     FILETYPE(statp),
+				     statp->bs_ino,
+				     strerror(errno),
+				     errno);
 				break;
 			}
 
@@ -3442,42 +3442,42 @@ dump_extattrs(drive_t *drivep,
 
 			abort = BOOL_FALSE;
 			rv = dump_extattr_list(drivep,
-						contextp,
-						fshandlep,
-						statp,
-						listp,
-						flag,
-						&abort);
+					       contextp,
+					       fshandlep,
+					       statp,
+					       listp,
+					       flag,
+					       &abort);
 			if (rv != RV_OK) {
 				return rv;
 			}
-		} while (more && !abort);
+		} while (more && ! abort);
 	}
 
 	/*
 	 * finally, dump a dummy extattr hdr so restore will know
 	 * we're done.
 	 */
-	/*DBG*/mlog(MLOG_NITTY,
+	/*DBG*/ mlog(MLOG_NITTY,
 		     "dumping NULL extattrhdr\n");
 	rv = dump_extattrhdr(drivep,
-			      contextp,
-			      statp,
-			      EXTATTRHDR_SZ,
-			      0,
-			      EXTATTRHDR_FLAGS_NULL,
-			      0);
+			     contextp,
+			     statp,
+			     EXTATTRHDR_SZ,
+			     0,
+			     EXTATTRHDR_FLAGS_NULL,
+			     0);
 	return rv;
 }
 
 static rv_t
-dump_extattr_list(drive_t *drivep,
-		   context_t *contextp,
-		   jdm_fshandle_t *fshandlep,
-		   xfs_bstat_t *statp,
-		   attrlist_t *listp,
-		   int flag,
-		   bool_t *abortprp)
+dump_extattr_list(drive_t *		drivep,
+		  context_t *		contextp,
+		  jdm_fshandle_t *	fshandlep,
+		  xfs_bstat_t *		statp,
+		  attrlist_t *		listp,
+		  int			flag,
+		  bool_t *		abortprp)
 {
 	size_t listlen = (size_t)listp->al_count;
 	ix_t nameix;
@@ -3521,19 +3521,19 @@ dump_extattr_list(drive_t *drivep,
 			 */
 
 			if (hsm_fs_ctxtp) {
-				int	skip_entry;
+				int skip_entry;
 
-				if (!HsmFilterExistingAttribute(
-				    contextp->cc_hsm_f_ctxtp, entp->a_name,
-				    entp->a_valuelen, flag,
-				    &skip_entry)) {
+				if (! HsmFilterExistingAttribute(
+					    contextp->cc_hsm_f_ctxtp, entp->a_name,
+					    entp->a_valuelen, flag,
+					    &skip_entry)) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      		    "HSM could not filter %s "
-					    "attribute %s for %s ino %llu\n"),
-					    EXTATTR_NAMESPACE(flag),
-					    entp->a_name,
-					    FILETYPE(statp),
-			      		    statp->bs_ino);
+						     "HSM could not filter %s "
+						     "attribute %s for %s ino %llu\n"),
+					     EXTATTR_NAMESPACE(flag),
+					     entp->a_name,
+					     FILETYPE(statp),
+					     statp->bs_ino);
 					*abortprp = BOOL_TRUE;
 					return RV_OK;
 				}
@@ -3544,16 +3544,16 @@ dump_extattr_list(drive_t *drivep,
 			}
 
 			dumpbufp = dump_extattr_buildrecord(statp,
-							     dumpbufp,
-							     dumpbufendp,
-							     entp->a_name,
-							     entp->a_valuelen,
-							     flag,
-							     &valuep);
+							    dumpbufp,
+							    dumpbufendp,
+							    entp->a_name,
+							    entp->a_valuelen,
+							    flag,
+							    &valuep);
 			if (dumpbufp > dumpbufendp) {
-				break;		/* won't fit in buffer */
+				break;          /* won't fit in buffer */
 			}
-			if (valuep != NULL) { /* if added to dump buffer */
+			if (valuep != NULL) {   /* if added to dump buffer */
 				endp = dumpbufp;
 				opp->am_attrname = entp->a_name;
 				opp->am_attrvalue = valuep;
@@ -3575,18 +3575,18 @@ dump_extattr_list(drive_t *drivep,
 		rtrvcnt = rtrvix;
 		if (rtrvcnt > 0) {
 			rval = jdm_attr_multi(fshandlep, statp,
-					(void *)contextp->cc_extattrrtrvarrayp,
-					(int)rtrvcnt,
-					0);
+					      (void *)contextp->cc_extattrrtrvarrayp,
+					      (int)rtrvcnt,
+					      0);
 			if (rval) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "could not retrieve %s attributes for "
-				      "%s ino %llu: %s (%d)\n"),
-				      EXTATTR_NAMESPACE(flag),
-				      FILETYPE(statp),
-				      statp->bs_ino,
-				      strerror(errno),
-				      errno);
+					     "could not retrieve %s attributes for "
+					     "%s ino %llu: %s (%d)\n"),
+				     EXTATTR_NAMESPACE(flag),
+				     FILETYPE(statp),
+				     statp->bs_ino,
+				     strerror(errno),
+				     errno);
 				*abortprp = BOOL_TRUE;
 				return RV_OK;
 			}
@@ -3596,23 +3596,23 @@ dump_extattr_list(drive_t *drivep,
 				opp = &contextp->cc_extattrrtrvarrayp[rtrvix];
 				if (opp->am_error) {
 					if (opp->am_error == ENOATTR &&
-					     flag & ATTR_SECURE) {
-				/*
-				 * Security attributes are supported by
-				 * the kernel but jdm_attr_multi() returns
-				 * ENOATTR for every 'user' space attribute
-				 * during the 'security' pass of the extended
-				 * attribute loop (pass==3).  Suppress the
-				 * following error message with a no-op. The
-				 * jdm_attr_multi() problem is fixed in mod
-				 * xfs-linux:xfs-kern:167038a (PV 907903).
-				 */
+					    flag & ATTR_SECURE) {
+						/*
+						 * Security attributes are supported by
+						 * the kernel but jdm_attr_multi() returns
+						 * ENOATTR for every 'user' space attribute
+						 * during the 'security' pass of the extended
+						 * attribute loop (pass==3).  Suppress the
+						 * following error message with a no-op. The
+						 * jdm_attr_multi() problem is fixed in mod
+						 * xfs-linux:xfs-kern:167038a (PV 907903).
+						 */
 						continue;
 					}
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-					     "attr_multi indicates error while "
-					     "retrieving %s attribute [%s] for "
-					     "%s ino %llu: %s (%d)\n"),
+						     "attr_multi indicates error while "
+						     "retrieving %s attribute [%s] for "
+						     "%s ino %llu: %s (%d)\n"),
 					     EXTATTR_NAMESPACE(flag),
 					     opp->am_attrname,
 					     FILETYPE(statp),
@@ -3630,16 +3630,16 @@ dump_extattr_list(drive_t *drivep,
 		 */
 
 		if (dumpbufp <= dumpbufendp)
-			continue;	/* no buffer overflow yet */
+			continue;       /* no buffer overflow yet */
 
 		assert(endp > contextp->cc_extattrdumpbufp);
 		bufsz = (size_t)(endp - contextp->cc_extattrdumpbufp);
 
 		rval = write_buf(contextp->cc_extattrdumpbufp,
-				  bufsz,
-				  (void *)drivep,
-				  (gwbfp_t)drivep->d_opsp->do_get_write_buf,
-				  (wfp_t)drivep->d_opsp->do_write);
+				 bufsz,
+				 (void *)drivep,
+				 (gwbfp_t)drivep->d_opsp->do_get_write_buf,
+				 (wfp_t)drivep->d_opsp->do_write);
 		switch (rval) {
 		case 0:
 			rv = RV_OK;
@@ -3669,41 +3669,41 @@ dump_extattr_list(drive_t *drivep,
 	 * needs to add any addtional attributes.
 	 */
 
-	if (!listp->al_more && hsm_fs_ctxtp) {
+	if (! listp->al_more && hsm_fs_ctxtp) {
 		int hsmcursor = 0;
 		for (;;) {
-			char	*hsmnamep;
-			char	*hsmvaluep;
-			char	*valuep;
-			uint32_t	hsmvaluesz;
+			char *hsmnamep;
+			char *hsmvaluep;
+			char *valuep;
+			uint32_t hsmvaluesz;
 
-			if (!HsmAddNewAttribute(contextp->cc_hsm_f_ctxtp,
+			if (! HsmAddNewAttribute(contextp->cc_hsm_f_ctxtp,
 						hsmcursor,
 						flag,
 						&hsmnamep,
 						&hsmvaluep,
 						&hsmvaluesz)) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      		"HSM could not add new %s attribute "
-					"#%d for %s ino %llu\n"),
-					EXTATTR_NAMESPACE(flag),
-					hsmcursor,
-					FILETYPE(statp),
-			      		statp->bs_ino);
+					     "HSM could not add new %s attribute "
+					     "#%d for %s ino %llu\n"),
+				     EXTATTR_NAMESPACE(flag),
+				     hsmcursor,
+				     FILETYPE(statp),
+				     statp->bs_ino);
 				*abortprp = BOOL_TRUE;
 				return RV_OK;
 			}
 			if (hsmnamep == NULL) {
-				break;		/* No more attributes to add */
+				break;          /* No more attributes to add */
 			}
 
 			dumpbufp = dump_extattr_buildrecord(statp,
-							     dumpbufp,
-							     dumpbufendp,
-							     hsmnamep,
-							     hsmvaluesz,
-							     flag,
-							     &valuep);
+							    dumpbufp,
+							    dumpbufendp,
+							    hsmnamep,
+							    hsmvaluesz,
+							    flag,
+							    &valuep);
 
 			if (dumpbufp < dumpbufendp) { /* if fits in buffer */
 				endp = dumpbufp;
@@ -3716,10 +3716,10 @@ dump_extattr_list(drive_t *drivep,
 			bufsz = (size_t)(endp - contextp->cc_extattrdumpbufp);
 
 			rval = write_buf(contextp->cc_extattrdumpbufp,
-				  bufsz,
-				  (void *)drivep,
-				  (gwbfp_t)drivep->d_opsp->do_get_write_buf,
-				  (wfp_t)drivep->d_opsp->do_write);
+					 bufsz,
+					 (void *)drivep,
+					 (gwbfp_t)drivep->d_opsp->do_get_write_buf,
+					 (wfp_t)drivep->d_opsp->do_write);
 			switch (rval) {
 			case 0:
 				rv = RV_OK;
@@ -3754,10 +3754,10 @@ dump_extattr_list(drive_t *drivep,
 		bufsz = (size_t)(endp - contextp->cc_extattrdumpbufp);
 
 		rval = write_buf(contextp->cc_extattrdumpbufp,
-				  bufsz,
-				  (void *)drivep,
-				  (gwbfp_t)drivep->d_opsp->do_get_write_buf,
-				  (wfp_t)drivep->d_opsp->do_write);
+				 bufsz,
+				 (void *)drivep,
+				 (gwbfp_t)drivep->d_opsp->do_get_write_buf,
+				 (wfp_t)drivep->d_opsp->do_write);
 		switch (rval) {
 		case 0:
 			rv = RV_OK;
@@ -3785,13 +3785,13 @@ dump_extattr_list(drive_t *drivep,
 }
 
 static char *
-dump_extattr_buildrecord(xfs_bstat_t *statp,
-			  char *dumpbufp,
-			  char *dumpbufendp,
-			  char *namesrcp,
-			  uint32_t valuesz,
-			  int flag,
-			  char **valuepp)
+dump_extattr_buildrecord(xfs_bstat_t *	statp,
+			 char *		dumpbufp,
+			 char *		dumpbufendp,
+			 char *		namesrcp,
+			 uint32_t	valuesz,
+			 int		flag,
+			 char **	valuepp)
 {
 	extattrhdr_t *ahdrp = (extattrhdr_t *)dumpbufp;
 	char *namep = dumpbufp + EXTATTRHDR_SZ;
@@ -3812,31 +3812,31 @@ dump_extattr_buildrecord(xfs_bstat_t *statp,
 
 	if (namelen > NAME_MAX) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "%s extended attribute name for %s ino %llu too long: "
-		      "%u, max is %u: skipping\n"),
-		      EXTATTR_NAMESPACE(flag),
-		      FILETYPE(statp),
-		      statp->bs_ino,
-		      namelen,
-		      NAME_MAX);
+			     "%s extended attribute name for %s ino %llu too long: "
+			     "%u, max is %u: skipping\n"),
+		     EXTATTR_NAMESPACE(flag),
+		     FILETYPE(statp),
+		     statp->bs_ino,
+		     namelen,
+		     NAME_MAX);
 		*valuepp = 0;
 		return dumpbufp;
 	}
 
 	if (valuesz > ATTR_MAX_VALUELEN) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "%s extended attribute value for %s ino %llu too long: "
-		      "%u, max is %u: skipping\n"),
-		      EXTATTR_NAMESPACE(flag),
-		      FILETYPE(statp),
-		      statp->bs_ino,
-		      valuesz,
-		      ATTR_MAX_VALUELEN);
+			     "%s extended attribute value for %s ino %llu too long: "
+			     "%u, max is %u: skipping\n"),
+		     EXTATTR_NAMESPACE(flag),
+		     FILETYPE(statp),
+		     statp->bs_ino,
+		     valuesz,
+		     ATTR_MAX_VALUELEN);
 		*valuepp = 0;
 		return dumpbufp;
 	}
 
-	/*DBG*/mlog(MLOG_NITTY,
+	/*DBG*/ mlog(MLOG_NITTY,
 		     "building extattr "
 		     "record sz %u "
 		     "hdrsz %u "
@@ -3853,8 +3853,8 @@ dump_extattr_buildrecord(xfs_bstat_t *statp,
 	assert(EXTATTRHDR_SZ + namesz < UINT16MAX);
 	tmpah.ah_valoff = (uint16_t)(EXTATTRHDR_SZ + namesz);
 	tmpah.ah_flags = (uint16_t)
-		((flag & ATTR_ROOT) ? EXTATTRHDR_FLAGS_ROOT :
-		((flag & ATTR_SECURE) ? EXTATTRHDR_FLAGS_SECURE : 0));
+			 ((flag & ATTR_ROOT) ? EXTATTRHDR_FLAGS_ROOT :
+			  ((flag & ATTR_SECURE) ? EXTATTRHDR_FLAGS_SECURE : 0));
 	tmpah.ah_valsz = valuesz;
 	tmpah.ah_flags |= EXTATTRHDR_FLAGS_CHECKSUM;
 	tmpah.ah_checksum = calc_checksum(&tmpah, EXTATTRHDR_SZ);
@@ -3866,13 +3866,13 @@ dump_extattr_buildrecord(xfs_bstat_t *statp,
 
 /* ARGSUSED */
 static rv_t
-dump_extattrhdr(drive_t *drivep,
-		 context_t *contextp,
-		 xfs_bstat_t *statp,
-		 size_t recsz,
-		 size_t valoff,
-		 ix_t flags,
-		 uint32_t valsz)
+dump_extattrhdr(drive_t *	drivep,
+		context_t *	contextp,
+		xfs_bstat_t *	statp,
+		size_t		recsz,
+		size_t		valoff,
+		ix_t		flags,
+		uint32_t	valsz)
 {
 	extattrhdr_t ahdr;
 	extattrhdr_t tmpahdr;
@@ -3889,10 +3889,10 @@ dump_extattrhdr(drive_t *drivep,
 
 	xlate_extattrhdr(&ahdr, &tmpahdr, 1);
 	rval = write_buf((char *)&tmpahdr,
-			  EXTATTRHDR_SZ,
-			  (void *)drivep,
-			  (gwbfp_t)drivep->d_opsp->do_get_write_buf,
-			  (wfp_t)drivep->d_opsp->do_write);
+			 EXTATTRHDR_SZ,
+			 (void *)drivep,
+			 (gwbfp_t)drivep->d_opsp->do_get_write_buf,
+			 (wfp_t)drivep->d_opsp->do_write);
 	switch (rval) {
 	case 0:
 		rv = RV_OK;
@@ -3923,10 +3923,10 @@ dump_extattrhdr(drive_t *drivep,
  */
 /* ARGSUSED */
 static rv_t
-dump_file(void *arg1,
-	   jdm_fshandle_t *fshandlep,
-	   int fsfd,
-	   xfs_bstat_t *statp)
+dump_file(void *		arg1,
+	  jdm_fshandle_t *	fshandlep,
+	  int			fsfd,
+	  xfs_bstat_t *		statp)
 {
 	ix_t strmix = (ix_t)arg1;
 	context_t *contextp = &sc_contextp[strmix];
@@ -3951,7 +3951,7 @@ dump_file(void *arg1,
 			contextp->cc_stat_lastino = statp->bs_ino;
 		}
 		mlog(MLOG_DEBUG, "skip as no links for ino %llu\n",
-			statp->bs_ino);
+		     statp->bs_ino);
 		return RV_OK;
 	}
 
@@ -3963,7 +3963,7 @@ dump_file(void *arg1,
 			contextp->cc_stat_lastino = statp->bs_ino;
 		}
 		mlog(MLOG_DEBUG, "skip as ino %llu is prior to starpoint\n",
-			statp->bs_ino);
+		     statp->bs_ino);
 		return RV_OK;
 	}
 
@@ -3971,14 +3971,14 @@ dump_file(void *arg1,
 	 * skip if at or beyond next startpoint. return non-zero to
 	 * abort iteration.
 	 */
-	if (! (endptp->sp_flags & STARTPT_FLAGS_END)) {
+	if (!(endptp->sp_flags & STARTPT_FLAGS_END)) {
 		if (endptp->sp_offset == 0) {
 			if (statp->bs_ino >= endptp->sp_ino) {
 				if (statp->bs_ino > contextp->cc_stat_lastino) {
 					contextp->cc_stat_lastino = statp->bs_ino;
 				}
 				mlog(MLOG_DEBUG, "skip as ino %llu is at/beyond starpoint\n",
-					statp->bs_ino);
+				     statp->bs_ino);
 				return RV_NOMORE;
 			}
 		} else {
@@ -3987,7 +3987,7 @@ dump_file(void *arg1,
 					contextp->cc_stat_lastino = statp->bs_ino;
 				}
 				mlog(MLOG_DEBUG, "skip as ino %llu is at/beyond starpoint\n",
-					statp->bs_ino);
+				     statp->bs_ino);
 				return RV_NOMORE;
 			}
 		}
@@ -4002,23 +4002,23 @@ dump_file(void *arg1,
 	 * skip if not in inomap
 	 */
 	if (state == MAP_INO_UNUSED
-	     ||
-	     state == MAP_DIR_NOCHNG
-	     ||
-	     state == MAP_NDR_NOCHNG) {
+	    ||
+	    state == MAP_DIR_NOCHNG
+	    ||
+	    state == MAP_NDR_NOCHNG) {
 		if (state == MAP_DIR_NOCHNG) {
 			mlog(MLOG_DEBUG,
-			      "inomap inconsistency ino %llu: "
-			      "MAP_DIR_NOCHNG but is non-dir: skipping\n",
-			      statp->bs_ino);
+			     "inomap inconsistency ino %llu: "
+			     "MAP_DIR_NOCHNG but is non-dir: skipping\n",
+			     statp->bs_ino);
 		}
 		if (statp->bs_ino > contextp->cc_stat_lastino) {
 			contextp->cc_stat_lastino = statp->bs_ino;
 		}
 		mlog(MLOG_DEBUG, "skip as ino %llu is not marked as changed in inomap\n",
-			statp->bs_ino);
+		     statp->bs_ino);
 		mlog(MLOG_DEBUG, "ino %llu is in state %d\n",
-			statp->bs_ino, state);
+		     statp->bs_ino, state);
 		return RV_OK;
 	}
 
@@ -4027,14 +4027,14 @@ dump_file(void *arg1,
 	 */
 	if (state == MAP_DIR_CHANGE || state == MAP_DIR_SUPPRT) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "inomap inconsistency ino %llu: "
-		      "%s but is now non-dir: NOT dumping\n"),
-		      statp->bs_ino,
-		      state == MAP_DIR_CHANGE
-		      ?
-		      "map says changed dir"
-		      :
-		      "map says unchanged dir");
+			     "inomap inconsistency ino %llu: "
+			     "%s but is now non-dir: NOT dumping\n"),
+		     statp->bs_ino,
+		     state == MAP_DIR_CHANGE
+		     ?
+		     "map says changed dir"
+		     :
+		     "map says unchanged dir");
 	}
 
 	/*
@@ -4046,9 +4046,9 @@ dump_file(void *arg1,
 	if (hsm_fs_ctxtp) {
 		if (HsmInitFileContext(contextp->cc_hsm_f_ctxtp, statp)) {
 			mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      "inomap inconsistency ino %llu: "
-			      "hsm detected error: NOT dumping\n"),
-			      statp->bs_ino);
+				     "inomap inconsistency ino %llu: "
+				     "hsm detected error: NOT dumping\n"),
+			     statp->bs_ino);
 			if (statp->bs_ino > contextp->cc_stat_lastino) {
 				contextp->cc_stat_lastino = statp->bs_ino;
 			}
@@ -4083,20 +4083,20 @@ dump_file(void *arg1,
 
 			/* quota files are exempt from max size check */
 			if (estimated_size > maxdumpfilesize &&
-			    !is_quota_file(statp->bs_ino)) {
+			    ! is_quota_file(statp->bs_ino)) {
 				mlog(MLOG_DEBUG | MLOG_NOTE,
-				      "ino %llu increased beyond maximum size: "
-				      "NOT dumping\n",
-				      statp->bs_ino);
+				     "ino %llu increased beyond maximum size: "
+				     "NOT dumping\n",
+				     statp->bs_ino);
 				return RV_OK;
 			}
 		}
 		rv = dump_file_reg(drivep,
-				    contextp,
-				    scwhdrp,
-				    fshandlep,
-				    statp,
-				    &file_skipped);
+				   contextp,
+				   scwhdrp,
+				   fshandlep,
+				   statp,
+				   &file_skipped);
 		if (statp->bs_ino > contextp->cc_stat_lastino) {
 			lock();
 			sc_stat_nondirdone++;
@@ -4129,9 +4129,9 @@ dump_file(void *arg1,
 		 * don't know how to dump these
 		 */
 		mlog(MLOG_VERBOSE, _(
-		      "don't know how to dump ino %llu: mode %08x\n"),
-		      statp->bs_ino,
-		      statp->bs_mode);
+			     "don't know how to dump ino %llu: mode %08x\n"),
+		     statp->bs_ino,
+		     statp->bs_mode);
 		if (statp->bs_ino > contextp->cc_stat_lastino) {
 			lock();
 			sc_stat_nondirdone++;
@@ -4139,19 +4139,19 @@ dump_file(void *arg1,
 			contextp->cc_stat_lastino = statp->bs_ino;
 		}
 		return RV_OK;
-	/*
-	 * not yet implemented
-	case S_IFMNT:
-	 */
+		/*
+		 * not yet implemented
+		   case S_IFMNT:
+		 */
 	}
 
 	if (rv == RV_OK
-	     &&
-	     file_skipped == BOOL_FALSE
-	     &&
-	     sc_dumpextattrpr
-	     &&
-	     (statp->bs_xflags & XFS_XFLAG_HASATTR)) {
+	    &&
+	    file_skipped == BOOL_FALSE
+	    &&
+	    sc_dumpextattrpr
+	    &&
+	    (statp->bs_xflags & XFS_XFLAG_HASATTR)) {
 		rv = dump_extattrs(drivep, contextp, fshandlep, statp);
 	}
 
@@ -4166,12 +4166,12 @@ dump_file(void *arg1,
  * operator requested stop.
  */
 static rv_t
-dump_file_reg(drive_t *drivep,
-	       context_t *contextp,
-	       content_inode_hdr_t *scwhdrp,
-	       jdm_fshandle_t *fshandlep,
-	       xfs_bstat_t *statp,
-	       bool_t *file_skippedp)
+dump_file_reg(drive_t *			drivep,
+	      context_t *		contextp,
+	      content_inode_hdr_t *	scwhdrp,
+	      jdm_fshandle_t *		fshandlep,
+	      xfs_bstat_t *		statp,
+	      bool_t *			file_skippedp)
 {
 	startpt_t *startptp = &scwhdrp->cih_startpt;
 	startpt_t *endptp = &scwhdrp->cih_endpt;
@@ -4179,7 +4179,7 @@ dump_file_reg(drive_t *drivep,
 	bool_t cmpltflg;
 	off64_t offset;
 	off64_t stopoffset;
-	bool_t sosig;	/* stop offset is significant */
+	bool_t sosig;   /* stop offset is significant */
 	off64_t maxextentcnt;
 	rv_t rv;
 
@@ -4213,7 +4213,7 @@ dump_file_reg(drive_t *drivep,
 				register time32_t ctime = statp->bs_ctime.tv_sec;
 				register time32_t ltime = max(mtime, ctime);
 				if (ltime < sc_resumebasetime) {
-					if (rp->dr_begin.sp_offset > offset){
+					if (rp->dr_begin.sp_offset > offset) {
 						offset =rp->dr_begin.sp_offset;
 					}
 				}
@@ -4239,14 +4239,14 @@ dump_file_reg(drive_t *drivep,
 	}
 
 	mlog(MLOG_TRACE,
-	      "dumping regular file ino %llu "
-	      "offset %lld "
-	      "to offset %lld "
-	      "(size %lld)\n",
-	      statp->bs_ino,
-	      offset,
-	      sosig ? stopoffset : statp->bs_size,
-	      statp->bs_size);
+	     "dumping regular file ino %llu "
+	     "offset %lld "
+	     "to offset %lld "
+	     "(size %lld)\n",
+	     statp->bs_ino,
+	     offset,
+	     sosig ? stopoffset : statp->bs_size,
+	     statp->bs_size);
 
 	/*
 	 * calculate the maximum extent group size. files larger than this
@@ -4260,15 +4260,15 @@ dump_file_reg(drive_t *drivep,
 	 * pretending the dump succeeded.
 	 */
 	rv = init_extent_group_context(fshandlep,
-					statp,
-					&extent_group_context);
+				       statp,
+				       &extent_group_context);
 	if (rv != RV_OK) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "could not open regular file ino %llu mode 0x%08x: "
-		      "%s: not dumped\n"),
-		      statp->bs_ino,
-		      statp->bs_mode,
-		      strerror(errno));
+			     "could not open regular file ino %llu mode 0x%08x: "
+			     "%s: not dumped\n"),
+		     statp->bs_ino,
+		     statp->bs_mode,
+		     strerror(errno));
 		*file_skippedp = BOOL_TRUE;
 		return RV_OK;
 	}
@@ -4309,7 +4309,7 @@ dump_file_reg(drive_t *drivep,
 		 * spoof EOF if the media file size is getting too big.
 		 * note that the most we can go over is d_recmarksep.
 		 */
-		if (contextp->cc_mfilesz >= drivep->d_recmfilesz){
+		if (contextp->cc_mfilesz >= drivep->d_recmfilesz) {
 			rv = RV_EOF;
 			break;
 		}
@@ -4319,9 +4319,9 @@ dump_file_reg(drive_t *drivep,
 		 */
 		if (cldmgr_stop_requested()) {
 			mlog(MLOG_NORMAL, _(
-			      "dump interrupted prior to ino %llu offset %lld\n"),
-			      statp->bs_ino,
-			      offset);
+				     "dump interrupted prior to ino %llu offset %lld\n"),
+			     statp->bs_ino,
+			     offset);
 			mlog_exit_hint(RV_INTR);
 			rv = RV_INTR;
 			break;
@@ -4331,9 +4331,9 @@ dump_file_reg(drive_t *drivep,
 		 * dump the file header
 		 */
 		mlog(MLOG_DEBUG,
-		      "dumping extent group ino %llu offset %lld\n",
-		      statp->bs_ino,
-		      offset);
+		     "dumping extent group ino %llu offset %lld\n",
+		     statp->bs_ino,
+		     offset);
 		rv = dump_filehdr(drivep, contextp, statp, offset, 0);
 		if (rv != RV_OK) {
 			break;
@@ -4349,15 +4349,15 @@ dump_file_reg(drive_t *drivep,
 		 */
 		bc = 0; /* for lint */
 		rv = dump_extent_group(drivep,
-					contextp,
-					statp,
-					&extent_group_context,
-					maxextentcnt,
-					stopoffset,
-					sosig,
-					&offset,
-					&bc,
-					&cmpltflg);
+				       contextp,
+				       statp,
+				       &extent_group_context,
+				       maxextentcnt,
+				       stopoffset,
+				       sosig,
+				       &offset,
+				       &bc,
+				       &cmpltflg);
 		assert(bc >= 0);
 		bytecnt += bc;
 		if (rv != RV_OK) {
@@ -4377,11 +4377,11 @@ dump_file_reg(drive_t *drivep,
 		 * end of the file.
 		 */
 		rv = dump_extenthdr(drivep,
-				     contextp,
-				     EXTENTHDR_TYPE_LAST,
-				     0,
-				     0,
-				     0);
+				    contextp,
+				    EXTENTHDR_TYPE_LAST,
+				    0,
+				    0,
+				    0);
 		if (rv != RV_OK) {
 			break;
 		}
@@ -4404,18 +4404,18 @@ dump_file_reg(drive_t *drivep,
  * appends a variable-length string after the filehdr_t.
  */
 static rv_t
-dump_file_spec(drive_t *drivep,
-		context_t *contextp,
-		jdm_fshandle_t *fshandlep,
-		xfs_bstat_t *statp)
+dump_file_spec(drive_t *	drivep,
+	       context_t *	contextp,
+	       jdm_fshandle_t * fshandlep,
+	       xfs_bstat_t *	statp)
 {
 	int rval;
 	rv_t rv;
 
 	mlog(MLOG_TRACE,
-	      "dumping special file ino %llu mode 0x%04x\n",
-	      statp->bs_ino,
-	      statp->bs_mode);
+	     "dumping special file ino %llu mode 0x%04x\n",
+	     statp->bs_ino,
+	     statp->bs_mode);
 
 	/*
 	 * set a mark - important to do this now, before deciding
@@ -4454,13 +4454,13 @@ dump_file_spec(drive_t *drivep,
 		 * the bytes.
 		 */
 		nread = jdm_readlink(fshandlep,
-				      statp,
-				      contextp->cc_readlinkbufp,
-				      contextp->cc_readlinkbufsz);
+				     statp,
+				     contextp->cc_readlinkbufp,
+				     contextp->cc_readlinkbufsz);
 		if (nread < 0) {
 			mlog(MLOG_DEBUG,
-			      "could not read symlink ino %llu\n",
-			      statp->bs_ino);
+			     "could not read symlink ino %llu\n",
+			     statp->bs_ino);
 			nread = 0;
 		}
 
@@ -4476,18 +4476,18 @@ dump_file_spec(drive_t *drivep,
 		 */
 		extentsz = ((size_t)nread + 1 + (SYMLINK_ALIGN - 1))
 			   &
-			   ~ (SYMLINK_ALIGN - 1);
+			   ~(SYMLINK_ALIGN - 1);
 		assert(extentsz <= contextp->cc_readlinkbufsz);
 
 		/*
 		 * dump an extent header
 		 */
 		rv = dump_extenthdr(drivep,
-				     contextp,
-				     EXTENTHDR_TYPE_DATA,
-				     0,
-				     0,
-				     (off64_t)extentsz);
+				    contextp,
+				    EXTENTHDR_TYPE_DATA,
+				    0,
+				    0,
+				    (off64_t)extentsz);
 		if (rv != RV_OK) {
 			return rv;
 		}
@@ -4496,10 +4496,10 @@ dump_file_spec(drive_t *drivep,
 		 * dump the link path extent
 		 */
 		rval = write_buf(contextp->cc_readlinkbufp,
-				  extentsz,
-				  (void *)drivep,
-				  (gwbfp_t)drivep->d_opsp->do_get_write_buf,
-				  (wfp_t)drivep->d_opsp->do_write);
+				 extentsz,
+				 (void *)drivep,
+				 (gwbfp_t)drivep->d_opsp->do_get_write_buf,
+				 (wfp_t)drivep->d_opsp->do_write);
 		switch (rval) {
 		case 0:
 			rv = RV_OK;
@@ -4530,9 +4530,9 @@ dump_file_spec(drive_t *drivep,
  * does anything else.
  */
 static rv_t
-init_extent_group_context(jdm_fshandle_t *fshandlep,
-			   xfs_bstat_t *statp,
-			   extent_group_context_t *gcp)
+init_extent_group_context(jdm_fshandle_t *		fshandlep,
+			  xfs_bstat_t *			statp,
+			  extent_group_context_t *	gcp)
 {
 	bool_t isrealtime;
 	int oflags;
@@ -4564,15 +4564,15 @@ init_extent_group_context(jdm_fshandle_t *fshandlep,
 	 * after this check but before all reads have completed.
 	 * This change just closes the window a bit.
 	 */
-	if ((statp->bs_mode & S_ISGID) && (! (statp->bs_mode&S_IXOTH)) ) {
+	if ((statp->bs_mode & S_ISGID) && (!(statp->bs_mode&S_IXOTH)) ) {
 		fl.l_type = F_RDLCK;
 		fl.l_whence = SEEK_SET;
 		fl.l_start = (off_t)0;
 		fl.l_len = 0;
 		if ((fcntl(gcp->eg_fd, F_GETLK, &fl)) < 0) {
 			mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      "locking check failed ino %llu\n"),
-			      statp->bs_ino);
+				     "locking check failed ino %llu\n"),
+			     statp->bs_ino);
 			close(gcp->eg_fd);
 			return RV_ERROR;
 		}
@@ -4593,24 +4593,24 @@ cleanup_extent_group_context(extent_group_context_t *gcp)
 }
 
 static rv_t
-dump_extent_group(drive_t *drivep,
-		   context_t *contextp,
-		   xfs_bstat_t *statp,
-		   extent_group_context_t *gcp,
-		   off64_t maxcnt,
-		   off64_t stopoffset,
-		   bool_t sosig,
-		   off64_t *nextoffsetp,
-		   off64_t *bytecntp,
-		   bool_t *cmpltflgp)
+dump_extent_group(drive_t *			drivep,
+		  context_t *			contextp,
+		  xfs_bstat_t *			statp,
+		  extent_group_context_t *	gcp,
+		  off64_t			maxcnt,
+		  off64_t			stopoffset,
+		  bool_t			sosig,
+		  off64_t *			nextoffsetp,
+		  off64_t *			bytecntp,
+		  bool_t *			cmpltflgp)
 {
 	struct dioattr da;
 	drive_ops_t *dop = drivep->d_opsp;
 	bool_t isrealtime = (bool_t)(statp->bs_xflags
-					&
-					XFS_XFLAG_REALTIME);
+				     &
+				     XFS_XFLAG_REALTIME);
 	off64_t nextoffset;
-	off64_t bytecnt;	/* accumulates total bytes sent to media */
+	off64_t bytecnt;        /* accumulates total bytes sent to media */
 	int rval;
 	rv_t rv;
 
@@ -4620,8 +4620,8 @@ dump_extent_group(drive_t *drivep,
 	if (isrealtime) {
 		if ((ioctl(gcp->eg_fd, XFS_IOC_DIOINFO, &da) < 0)) {
 			mlog(MLOG_NORMAL | MLOG_WARNING, _(
-			      "dioinfo failed ino %llu\n"),
-			      statp->bs_ino);
+				     "dioinfo failed ino %llu\n"),
+			     statp->bs_ino);
 			da.d_miniosz = PGSZ;
 		}
 	}
@@ -4642,7 +4642,7 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (sosig && nextoffset >= stopoffset) {
 			mlog(MLOG_NITTY,
-			      "dumped to stop offset\n");
+			     "dumped to stop offset\n");
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			*cmpltflgp = BOOL_TRUE;
@@ -4654,7 +4654,7 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (nextoffset >= statp->bs_size) {
 			mlog(MLOG_NITTY,
-			      "dumped to end of file\n");
+			     "dumped to end of file\n");
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			*cmpltflgp = BOOL_TRUE;
@@ -4668,7 +4668,7 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (bytecnt >= maxcnt) {
 			mlog(MLOG_NITTY,
-			      "reached per-extent group byte count\n");
+			     "reached per-extent group byte count\n");
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			*cmpltflgp = BOOL_FALSE;
@@ -4688,21 +4688,21 @@ dump_extent_group(drive_t *drivep,
 			 * get a new extent block
 			 */
 			mlog(MLOG_NITTY,
-			      "calling getbmapx for ino %llu\n",
-			      statp->bs_ino);
+			     "calling getbmapx for ino %llu\n",
+			     statp->bs_ino);
 			rval = ioctl(gcp->eg_fd, XFS_IOC_GETBMAPX, gcp->eg_bmap);
 			gcp->eg_gbmcnt++;
 			entrycnt = gcp->eg_bmap[0].bmv_entries;
 			if (entrycnt < 0) { /* workaround for getbmap bug */
 				mlog(MLOG_DEBUG | MLOG_WARNING, _(
-				      "getbmapx %d ino %lld mode 0x%08x "
-				      "offset %lld ix %d "
-				      "returns negative entry count\n"),
-				      gcp->eg_gbmcnt,
-				      statp->bs_ino,
-				      statp->bs_mode,
-				      nextoffset,
-				      gcp->eg_bmapix);
+					     "getbmapx %d ino %lld mode 0x%08x "
+					     "offset %lld ix %d "
+					     "returns negative entry count\n"),
+				     gcp->eg_gbmcnt,
+				     statp->bs_ino,
+				     statp->bs_mode,
+				     nextoffset,
+				     gcp->eg_bmapix);
 				*nextoffsetp = nextoffset;
 				*bytecntp = bytecnt;
 				*cmpltflgp = BOOL_TRUE;
@@ -4710,13 +4710,13 @@ dump_extent_group(drive_t *drivep,
 			}
 			if (rval) {
 				mlog(MLOG_NORMAL | MLOG_WARNING, _(
-				      "getbmapx %d ino %lld mode 0x%08x "
-				      "offset %lld failed: %s\n"),
-				      gcp->eg_gbmcnt,
-				      statp->bs_ino,
-				      statp->bs_mode,
-				      nextoffset,
-				      strerror(errno));
+					     "getbmapx %d ino %lld mode 0x%08x "
+					     "offset %lld failed: %s\n"),
+				     gcp->eg_gbmcnt,
+				     statp->bs_ino,
+				     statp->bs_mode,
+				     nextoffset,
+				     strerror(errno));
 				*nextoffsetp = nextoffset;
 				*bytecntp = bytecnt;
 				*cmpltflgp = BOOL_TRUE;
@@ -4730,12 +4730,12 @@ dump_extent_group(drive_t *drivep,
 			 */
 
 			if (hsm_fs_ctxtp) {
-				if (!HsmModifyExtentMap(contextp->cc_hsm_f_ctxtp,
-					&gcp->eg_bmap[0])) {
+				if (! HsmModifyExtentMap(contextp->cc_hsm_f_ctxtp,
+							&gcp->eg_bmap[0])) {
 					mlog(MLOG_NORMAL | MLOG_WARNING, _(
-						"hsm detected an extent map "
-						"error in ino %lld, skipping\n"),
-						statp->bs_ino);
+						     "hsm detected an extent map "
+						     "error in ino %lld, skipping\n"),
+					     statp->bs_ino);
 					*nextoffsetp = nextoffset;
 					*bytecntp = bytecnt;
 					*cmpltflgp = BOOL_TRUE;
@@ -4746,7 +4746,7 @@ dump_extent_group(drive_t *drivep,
 
 			if (entrycnt <= 0) {
 				mlog(MLOG_NITTY,
-				      "all extent groups dumped\n");
+				     "all extent groups dumped\n");
 				*nextoffsetp = nextoffset;
 				*bytecntp = bytecnt;
 				*cmpltflgp = BOOL_TRUE;
@@ -4755,17 +4755,17 @@ dump_extent_group(drive_t *drivep,
 			gcp->eg_nextbmapp = &gcp->eg_bmap[1];
 			gcp->eg_endbmapp = &gcp->eg_bmap[entrycnt + 1];
 			mlog(MLOG_NITTY,
-			      "getbmapx supplied %d extent entries\n",
-			      entrycnt);
+			     "getbmapx supplied %d extent entries\n",
+			     entrycnt);
 		}
 
 		mlog(MLOG_NITTY,
-		      "bmap entry %d ix %d block %lld offset %lld length %lld\n",
-		      gcp->eg_nextbmapp - &gcp->eg_bmap[0],
-		      gcp->eg_bmapix,
-		      gcp->eg_nextbmapp->bmv_block,
-		      gcp->eg_nextbmapp->bmv_offset,
-		      gcp->eg_nextbmapp->bmv_length);
+		     "bmap entry %d ix %d block %lld offset %lld length %lld\n",
+		     gcp->eg_nextbmapp - &gcp->eg_bmap[0],
+		     gcp->eg_bmapix,
+		     gcp->eg_nextbmapp->bmv_block,
+		     gcp->eg_nextbmapp->bmv_offset,
+		     gcp->eg_nextbmapp->bmv_length);
 
 		/*
 		 * if the next bmap entry represents a hole, go to the next
@@ -4780,24 +4780,24 @@ dump_extent_group(drive_t *drivep,
 			 * entry
 			 */
 			offset = gcp->eg_nextbmapp->bmv_offset
-					* (off64_t)BBSIZE;
-			extsz  = gcp->eg_nextbmapp->bmv_length
-					* (off64_t)BBSIZE;
+				 * (off64_t)BBSIZE;
+			extsz = gcp->eg_nextbmapp->bmv_length
+				* (off64_t)BBSIZE;
 
 			mlog(MLOG_NITTY,
-			      "hole extent offset = %lld size = %lld\n",
-			      offset, extsz);
+			     "hole extent offset = %lld size = %lld\n",
+			     offset, extsz);
 
 			/*
 			 * Encode the hole - dump the extent header
 			 * with the right extent type.
 			 */
 			rv = dump_extenthdr(drivep,
-					     contextp,
-					     EXTENTHDR_TYPE_HOLE,
-					     0,
-					     offset,
-					     extsz);
+					    contextp,
+					    EXTENTHDR_TYPE_HOLE,
+					    0,
+					    offset,
+					    extsz);
 			if (rv != RV_OK) {
 				*nextoffsetp = nextoffset;
 				*bytecntp = bytecnt;
@@ -4807,8 +4807,8 @@ dump_extent_group(drive_t *drivep,
 			bytecnt += sizeof(extenthdr_t);
 
 			tmpoffset = (gcp->eg_nextbmapp->bmv_offset
-				      +
-				      gcp->eg_nextbmapp->bmv_length)
+				     +
+				     gcp->eg_nextbmapp->bmv_length)
 				    *
 				    (off64_t)BBSIZE;
 			if (tmpoffset > nextoffset) {
@@ -4827,7 +4827,7 @@ dump_extent_group(drive_t *drivep,
 			off64_t tmpoffset;
 
 			mlog(MLOG_NITTY,
-			      "non-positive extent\n");
+			     "non-positive extent\n");
 			tmpoffset = gcp->eg_nextbmapp->bmv_offset
 				    *
 				    (off64_t)BBSIZE;
@@ -4846,10 +4846,10 @@ dump_extent_group(drive_t *drivep,
 		offset = gcp->eg_nextbmapp->bmv_offset * (off64_t)BBSIZE;
 		extsz = gcp->eg_nextbmapp->bmv_length * (off64_t)BBSIZE;
 		mlog(MLOG_NITTY,
-		      "extent offset %lld sz %lld; nextoffset %lld\n",
-		      offset,
-		      extsz,
-		      nextoffset);
+		     "extent offset %lld sz %lld; nextoffset %lld\n",
+		     offset,
+		     extsz,
+		     nextoffset);
 
 		/*
 		 * if the new bmap entry begins below the stop offset
@@ -4859,7 +4859,7 @@ dump_extent_group(drive_t *drivep,
 		if (! sosig || offset < stopoffset) {
 			if (offset + extsz <= nextoffset) {
 				mlog(MLOG_NITTY,
-				      "extent ends before nextoffset\n");
+				     "extent ends before nextoffset\n");
 				gcp->eg_nextbmapp++;
 				gcp->eg_bmapix++;
 				continue;
@@ -4872,7 +4872,7 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (offset >= statp->bs_size) {
 			mlog(MLOG_NITTY,
-			      "extent beyond end of file\n");
+			     "extent beyond end of file\n");
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			*cmpltflgp = BOOL_TRUE;
@@ -4885,7 +4885,7 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (sosig && offset >= stopoffset) {
 			mlog(MLOG_NITTY,
-			      "extent beyond stop offset\n");
+			     "extent beyond stop offset\n");
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			*cmpltflgp = BOOL_TRUE;
@@ -4902,11 +4902,11 @@ dump_extent_group(drive_t *drivep,
 			extsz -= nextoffset - offset;
 			offset = nextoffset;
 			mlog(MLOG_NITTY,
-			      "adjusted bottom of extent to nextoffset: "
-			      "offset %lld, sz %lld; nextoffset %lld\n",
-			      offset,
-			      extsz,
-			      nextoffset);
+			     "adjusted bottom of extent to nextoffset: "
+			     "offset %lld, sz %lld; nextoffset %lld\n",
+			     offset,
+			     extsz,
+			     nextoffset);
 		}
 		assert(extsz > 0);
 
@@ -4927,13 +4927,13 @@ dump_extent_group(drive_t *drivep,
 				&
 				~(off64_t)(iosz - 1);
 			mlog(MLOG_NITTY,
-			      "adjusted top of extent to honor maxcnt "
-			      "(rounded up %d): "
-			      "offset %lld, sz %lld; maxcnt %lld\n",
-			      iosz,
-			      offset,
-			      extsz,
-			      maxcnt);
+			     "adjusted top of extent to honor maxcnt "
+			     "(rounded up %d): "
+			     "offset %lld, sz %lld; maxcnt %lld\n",
+			     iosz,
+			     offset,
+			     extsz,
+			     maxcnt);
 		}
 
 		/*
@@ -4944,16 +4944,16 @@ dump_extent_group(drive_t *drivep,
 		 */
 		if (extsz <= 0) {
 			mlog(MLOG_NITTY,
-			      "adjusted extent size is non-positive: "
-			      "%lld (bs_size %lld)\n",
-			      extsz,
-			      statp->bs_size);
+			     "adjusted extent size is non-positive: "
+			     "%lld (bs_size %lld)\n",
+			     extsz,
+			     statp->bs_size);
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
 			if (statp->bs_size == 0) {
-			    *cmpltflgp = BOOL_TRUE;
+				*cmpltflgp = BOOL_TRUE;
 			} else {
-			    *cmpltflgp = BOOL_FALSE;
+				*cmpltflgp = BOOL_FALSE;
 			}
 			return RV_OK;
 		}
@@ -4976,13 +4976,13 @@ dump_extent_group(drive_t *drivep,
 				&
 				~(off64_t)(iosz - 1);
 			mlog(MLOG_NITTY,
-			      "adjusted top of extent to match file size "
-			      "(rounded up %d): "
-			      "offset %lld, sz %lld; bs_size %lld\n",
-			      iosz,
-			      offset,
-			      extsz,
-			      statp->bs_size);
+			     "adjusted top of extent to match file size "
+			     "(rounded up %d): "
+			     "offset %lld, sz %lld; bs_size %lld\n",
+			     iosz,
+			     offset,
+			     extsz,
+			     statp->bs_size);
 		}
 
 		/*
@@ -4992,14 +4992,14 @@ dump_extent_group(drive_t *drivep,
 		if (sosig && (extsz > stopoffset - offset)) {
 			extsz = stopoffset - offset;
 			assert(extsz >= 0);
-			assert(! (extsz & (off64_t)(BBSIZE - 1)));
+			assert(!(extsz & (off64_t)(BBSIZE - 1)));
 			mlog(MLOG_NITTY,
-			      "adjusted top of extent "
-			      "to adhere to stop offset: "
-			      "offset %lld, sz %lld; bs_size %lld\n",
-			      offset,
-			      extsz,
-			      statp->bs_size);
+			     "adjusted top of extent "
+			     "to adhere to stop offset: "
+			     "offset %lld, sz %lld; bs_size %lld\n",
+			     offset,
+			     extsz,
+			     statp->bs_size);
 		}
 
 		/*
@@ -5021,14 +5021,14 @@ dump_extent_group(drive_t *drivep,
 			cnt_to_align -= sizeof(extenthdr_t);
 
 			rv = dump_extenthdr(drivep,
-					     contextp,
-					     EXTENTHDR_TYPE_ALIGN,
-					     0,
-					     0,
-					     (off64_t)
-					     ((size_t)cnt_to_align
-					       -
-					       sizeof(extenthdr_t)));
+					    contextp,
+					    EXTENTHDR_TYPE_ALIGN,
+					    0,
+					    0,
+					    (off64_t)
+					    ((size_t)cnt_to_align
+					     -
+					     sizeof(extenthdr_t)));
 			if (rv != RV_OK) {
 				*nextoffsetp = nextoffset;
 				*bytecntp = bytecnt;
@@ -5057,11 +5057,11 @@ dump_extent_group(drive_t *drivep,
 		 * dump the extent header
 		 */
 		rv = dump_extenthdr(drivep,
-				     contextp,
-				     EXTENTHDR_TYPE_DATA,
-				     0,
-				     offset,
-				     extsz);
+				    contextp,
+				    EXTENTHDR_TYPE_DATA,
+				    0,
+				    offset,
+				    extsz);
 		if (rv != RV_OK) {
 			*nextoffsetp = nextoffset;
 			*bytecntp = bytecnt;
@@ -5088,14 +5088,14 @@ dump_extent_group(drive_t *drivep,
 				:
 				(size_t)extsz;
 			bufp = (*dop->do_get_write_buf)(drivep,
-							    reqsz,
-							    &actualsz);
+							reqsz,
+							&actualsz);
 			assert(actualsz <= reqsz);
 			new_off = lseek64(gcp->eg_fd, offset, SEEK_SET);
 			if (new_off == (off64_t)(-1)) {
 				mlog(MLOG_NORMAL, _(
-				      "can't lseek ino %llu\n"),
-				      statp->bs_ino);
+					     "can't lseek ino %llu\n"),
+				     statp->bs_ino);
 				nread = 0;
 			} else {
 				nread = read(gcp->eg_fd, bufp, actualsz);
@@ -5104,23 +5104,23 @@ dump_extent_group(drive_t *drivep,
 #ifdef HIDDEN
 				struct statvfs64 s;
 
- 				/* Be quiet if this is a swap file - #510197 */
+				/* Be quiet if this is a swap file - #510197 */
 				if ((fstatvfs64(gcp->eg_fd, &s) < 0) ||
-				     ((s.f_flag & ST_LOCAL) != 0))
-				   mlog(MLOG_NORMAL, _(
-		"can't read ino %llu at offset %d (act=%d req=%d) rt=%d\n"),
-		statp->bs_ino, new_off, actualsz, reqsz, isrealtime);
+				    ((s.f_flag & ST_LOCAL) != 0))
+					mlog(MLOG_NORMAL, _(
+						     "can't read ino %llu at offset %d (act=%d req=%d) rt=%d\n"),
+					     statp->bs_ino, new_off, actualsz, reqsz, isrealtime);
 #endif /* HIDDEN */
 
 				nread = 0;
 			}
 			assert((size_t)nread <= actualsz);
 			mlog(MLOG_NITTY,
-			      "read ino %llu offset %lld sz %d actual %d\n",
-			      statp->bs_ino,
-			      offset,
-			      actualsz,
-			      nread);
+			     "read ino %llu offset %lld sz %d actual %d\n",
+			     statp->bs_ino,
+			     offset,
+			     actualsz,
+			     nread);
 
 			/*
 			 * must return entire buffer supplied by call to
@@ -5130,13 +5130,13 @@ dump_extent_group(drive_t *drivep,
 			 */
 			if ((size_t)nread < actualsz) {
 				memset((void *)(bufp + nread),
-					0,
-					actualsz - (size_t)nread);
+				       0,
+				       actualsz - (size_t)nread);
 			}
 
 			rval = (*dop->do_write)(drivep,
-						    bufp,
-						    actualsz);
+						bufp,
+						actualsz);
 			switch (rval) {
 			case 0:
 				rv = RV_OK;
@@ -5170,8 +5170,8 @@ dump_extent_group(drive_t *drivep,
 			 */
 			if ((size_t)nread < actualsz) {
 				mlog(MLOG_NITTY,
-				      "padding remaind %lld bytes of extent\n",
-				      extsz);
+				     "padding remaind %lld bytes of extent\n",
+				     extsz);
 				while (extsz) {
 					reqsz = extsz > (off64_t)INTGENMAX
 						?
@@ -5179,7 +5179,7 @@ dump_extent_group(drive_t *drivep,
 						:
 						(size_t)extsz;
 					rv = write_pad(drivep,
-							(size_t)reqsz);
+						       (size_t)reqsz);
 					if (rv != RV_OK) {
 						*nextoffsetp = nextoffset;
 						*bytecntp = bytecnt;
@@ -5200,12 +5200,12 @@ dump_extent_group(drive_t *drivep,
 		 * !!! top of the loop.
 		 */
 		if (nextoffset
-		     >=
-		     gcp->eg_nextbmapp->bmv_offset * (off64_t)BBSIZE
-		     +
-		     gcp->eg_nextbmapp->bmv_length * (off64_t)BBSIZE) {
+		    >=
+		    gcp->eg_nextbmapp->bmv_offset * (off64_t)BBSIZE
+		    +
+		    gcp->eg_nextbmapp->bmv_length * (off64_t)BBSIZE) {
 			mlog(MLOG_NITTY,
-			      "advancing to next extent in bmap\n");
+			     "advancing to next extent in bmap\n");
 			gcp->eg_nextbmapp++;
 			gcp->eg_bmapix++;
 		}
@@ -5244,11 +5244,11 @@ copy_xfs_bstat(bstat_t *dst, xfs_bstat_t *src)
 }
 
 static rv_t
-dump_filehdr(drive_t *drivep,
-	      context_t *contextp,
-	      xfs_bstat_t *statp,
-	      off64_t offset,
-	      int flags)
+dump_filehdr(drive_t *		drivep,
+	     context_t *	contextp,
+	     xfs_bstat_t *	statp,
+	     off64_t		offset,
+	     int		flags)
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	register filehdr_t *fhdrp = contextp->cc_filehdrp;
@@ -5269,10 +5269,10 @@ dump_filehdr(drive_t *drivep,
 
 	xlate_filehdr(fhdrp, &tmpfhdrp, 1);
 	rval = write_buf((char *)&tmpfhdrp,
-			  sizeof(tmpfhdrp),
-			  (void *)drivep,
-			  (gwbfp_t)dop->do_get_write_buf,
-			  (wfp_t)dop->do_write);
+			 sizeof(tmpfhdrp),
+			 (void *)drivep,
+			 (gwbfp_t)dop->do_get_write_buf,
+			 (wfp_t)dop->do_write);
 
 	switch (rval) {
 	case 0:
@@ -5295,12 +5295,12 @@ dump_filehdr(drive_t *drivep,
 }
 
 static rv_t
-dump_extenthdr(drive_t *drivep,
-		context_t *contextp,
-		int32_t type,
-		int32_t flags,
-		off64_t offset,
-		off64_t sz)
+dump_extenthdr(drive_t *	drivep,
+	       context_t *	contextp,
+	       int32_t		type,
+	       int32_t		flags,
+	       off64_t		offset,
+	       off64_t		sz)
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	register extenthdr_t *ehdrp = contextp->cc_extenthdrp;
@@ -5310,27 +5310,27 @@ dump_extenthdr(drive_t *drivep,
 	char typestr[20];
 
 	switch (type)  {
-		case EXTENTHDR_TYPE_LAST:
-			strcpy(typestr, "LAST");
-			break;
-		case EXTENTHDR_TYPE_ALIGN:
-			strcpy(typestr, "ALIGN");
-			break;
-		case EXTENTHDR_TYPE_DATA:
-			strcpy(typestr, "DATA");
-			break;
-		case EXTENTHDR_TYPE_HOLE:
-			strcpy(typestr, "HOLE");
-			break;
-		default:
-			strcpy(typestr, "UNKNOWN");
+	case EXTENTHDR_TYPE_LAST:
+		strcpy(typestr, "LAST");
+		break;
+	case EXTENTHDR_TYPE_ALIGN:
+		strcpy(typestr, "ALIGN");
+		break;
+	case EXTENTHDR_TYPE_DATA:
+		strcpy(typestr, "DATA");
+		break;
+	case EXTENTHDR_TYPE_HOLE:
+		strcpy(typestr, "HOLE");
+		break;
+	default:
+		strcpy(typestr, "UNKNOWN");
 	}
 
 	mlog(MLOG_DEBUG,
-	      "dumping extent type = %s offset = %lld size = %lld\n",
-	      typestr,
-	      offset,
-	       sz);
+	     "dumping extent type = %s offset = %lld size = %lld\n",
+	     typestr,
+	     offset,
+	     sz);
 
 	(void)memset((void *)ehdrp, 0, sizeof(*ehdrp));
 	ehdrp->eh_type = type;
@@ -5341,10 +5341,10 @@ dump_extenthdr(drive_t *drivep,
 
 	xlate_extenthdr(ehdrp, &tmpehdrp, 1);
 	rval = write_buf((char *)&tmpehdrp,
-			  sizeof(tmpehdrp),
-			  (void *)drivep,
-			  (gwbfp_t)dop->do_get_write_buf,
-			  (wfp_t)dop->do_write);
+			 sizeof(tmpehdrp),
+			 (void *)drivep,
+			 (gwbfp_t)dop->do_get_write_buf,
+			 (wfp_t)dop->do_write);
 
 	switch (rval) {
 	case 0:
@@ -5367,13 +5367,13 @@ dump_extenthdr(drive_t *drivep,
 }
 
 static rv_t
-dump_dirent(drive_t *drivep,
-	     context_t *contextp,
-	     xfs_bstat_t *statp,
-	     xfs_ino_t ino,
-	     gen_t gen,
-	     char *name,
-	     size_t namelen)
+dump_dirent(drive_t *		drivep,
+	    context_t *		contextp,
+	    xfs_bstat_t *	statp,
+	    xfs_ino_t		ino,
+	    gen_t		gen,
+	    char *		name,
+	    size_t		namelen)
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	char *outbufp;
@@ -5400,12 +5400,12 @@ dump_dirent(drive_t *drivep,
 
 	if (sz > direntbufsz) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "unable to dump "
-		      "directory %llu entry %s (%llu): "
-		      "name too long\n"),
-		      statp->bs_ino,
-		      name,
-		      ino);
+			     "unable to dump "
+			     "directory %llu entry %s (%llu): "
+			     "name too long\n"),
+		     statp->bs_ino,
+		     name,
+		     ino);
 		mlog_exit_hint(RV_INCOMPLETE);
 		return RV_OK;
 	}
@@ -5454,10 +5454,10 @@ dump_dirent(drive_t *drivep,
 	}
 
 	rval = write_buf(outbufp,
-			  sz,
-			  (void *)drivep,
-			  (gwbfp_t)dop->do_get_write_buf,
-			  (wfp_t)dop->do_write);
+			 sz,
+			 (void *)drivep,
+			 (gwbfp_t)dop->do_get_write_buf,
+			 (wfp_t)dop->do_write);
 	free(outbufp);
 	switch (rval) {
 	case 0:
@@ -5480,10 +5480,10 @@ dump_dirent(drive_t *drivep,
 }
 
 static bool_t
-dump_session_inv(drive_t *drivep,
-		  context_t *contextp,
-		  media_hdr_t *mwhdrp,
-		  content_inode_hdr_t *scwhdrp)
+dump_session_inv(drive_t *		drivep,
+		 context_t *		contextp,
+		 media_hdr_t *		mwhdrp,
+		 content_inode_hdr_t *	scwhdrp)
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	ix_t strmix = drivep->d_index;
@@ -5502,7 +5502,7 @@ dump_session_inv(drive_t *drivep,
 	}
 
 	mlog(MLOG_VERBOSE, _(
-	      "dumping session inventory\n"));
+		     "dumping session inventory\n"));
 
 	/*
 	 * get a buffer from the inventory manager
@@ -5512,7 +5512,7 @@ dump_session_inv(drive_t *drivep,
 	ok = inv_get_sessioninfo(sc_inv_sestoken, (void *)&inv_sbufp, &inv_sbufsz);
 	if (! ok) {
 		mlog(MLOG_NORMAL | MLOG_WARNING, _(
-		      "unable to get session inventory to dump\n"));
+			     "unable to get session inventory to dump\n"));
 		return BOOL_TRUE;
 	}
 	assert(inv_sbufp);
@@ -5536,7 +5536,7 @@ dump_session_inv(drive_t *drivep,
 		rv_t rv;
 
 		mlog(MLOG_VERBOSE, _(
-		      "beginning inventory media file\n"));
+			     "beginning inventory media file\n"));
 
 		partial = BOOL_FALSE;
 		rv = Media_mfile_begin(drivep, contextp, BOOL_FALSE);
@@ -5545,14 +5545,14 @@ dump_session_inv(drive_t *drivep,
 			break;
 		case RV_TIMEOUT:
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change timeout: "
-			      "session inventory not dumped\n"));
+				     "media change timeout: "
+				     "session inventory not dumped\n"));
 			mlog_exit_hint(RV_INV);
 			return BOOL_FALSE;
 		case RV_QUIT:
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change declined: "
-			      "session inventory not dumped\n"));
+				     "media change declined: "
+				     "session inventory not dumped\n"));
 			mlog_exit_hint(RV_INV);
 			return BOOL_FALSE;
 		case RV_DRIVE:
@@ -5563,20 +5563,20 @@ dump_session_inv(drive_t *drivep,
 		}
 
 		mlog(MLOG_VERBOSE, _(
-		      "media file %u (media %u, file %u)\n"),
-		      mwhdrp->mh_dumpfileix,
-		      mwhdrp->mh_mediaix,
-		      mwhdrp->mh_mediafileix);
+			     "media file %u (media %u, file %u)\n"),
+		     mwhdrp->mh_dumpfileix,
+		     mwhdrp->mh_mediaix,
+		     mwhdrp->mh_mediafileix);
 
 		uuid_copy(mediaid, mwhdrp->mh_mediaid);
 		strcpy(medialabel, mwhdrp->mh_medialabel);
 		mediafileix = (int)mwhdrp->mh_mediafileix;
 
 		rval = write_buf(inv_sbufp,
-				  inv_sbufsz,
-				  (void *)drivep,
-				  (gwbfp_t)dop->do_get_write_buf,
-				  (wfp_t)dop->do_write);
+				 inv_sbufsz,
+				 (void *)drivep,
+				 (gwbfp_t)dop->do_get_write_buf,
+				 (wfp_t)dop->do_write);
 		switch (rval) {
 		case 0:
 			break;
@@ -5591,13 +5591,13 @@ dump_session_inv(drive_t *drivep,
 		}
 
 		mlog(MLOG_VERBOSE, _(
-		      "ending inventory media file\n"));
+			     "ending inventory media file\n"));
 		ncommitted = 0;
 		rv = Media_mfile_end(drivep,
-				      contextp,
-				      mwhdrp,
-				      &ncommitted,
-				      partial);
+				     contextp,
+				     mwhdrp,
+				     &ncommitted,
+				     partial);
 		switch (rv) {
 		case RV_OK:
 			break;
@@ -5610,14 +5610,14 @@ dump_session_inv(drive_t *drivep,
 
 		if (partial) {
 			mlog(MLOG_VERBOSE, _(
-			      "encountered EOM while writing "
-			      "inventory media file size %lld bytes\n"),
-			      ncommitted);
+				     "encountered EOM while writing "
+				     "inventory media file size %lld bytes\n"),
+			     ncommitted);
 			mlog_exit_hint(RV_INV);
 		} else {
 			mlog(MLOG_VERBOSE, _(
-			      "inventory media file size %lld bytes\n"),
-			      ncommitted);
+				     "inventory media file size %lld bytes\n"),
+			     ncommitted);
 		}
 		if (sc_inv_stmtokenp) {
 			inv_stmt = sc_inv_stmtokenp[strmix];
@@ -5627,23 +5627,23 @@ dump_session_inv(drive_t *drivep,
 
 		if (inv_stmt != INV_TOKEN_NULL) {
 			mlog(MLOG_DEBUG,
-			      "giving inventory "
-			      "session dump media file\n");
+			     "giving inventory "
+			     "session dump media file\n");
 			ok = inv_put_mediafile(inv_stmt,
-						&mediaid,
-						medialabel,
-						(uint)mediafileix,
-						(xfs_ino_t)0,
-						(off64_t)0,
-						(xfs_ino_t)0,
-						(off64_t)0,
-						ncommitted,
-						! partial,
-						BOOL_TRUE);
+					       &mediaid,
+					       medialabel,
+					       (uint)mediafileix,
+					       (xfs_ino_t)0,
+					       (off64_t)0,
+					       (xfs_ino_t)0,
+					       (off64_t)0,
+					       ncommitted,
+					       ! partial,
+					       BOOL_TRUE);
 			if (! ok) {
 				mlog(MLOG_NORMAL, _(
-				      "inventory session media file "
-				      "put failed\n"));
+					     "inventory session media file "
+					     "put failed\n"));
 				return BOOL_FALSE;
 			}
 		}
@@ -5668,7 +5668,7 @@ dump_terminator(drive_t *drivep, context_t *contextp, media_hdr_t *mwhdrp)
 	}
 
 	mlog(MLOG_VERBOSE, _(
-	      "writing stream terminator\n"));
+		     "writing stream terminator\n"));
 
 	/*
 	 * modify the write header to indicate a terminator
@@ -5685,7 +5685,7 @@ dump_terminator(drive_t *drivep, context_t *contextp, media_hdr_t *mwhdrp)
 		rv_t rv;
 
 		mlog(MLOG_VERBOSE, _(
-		      "beginning media stream terminator\n"));
+			     "beginning media stream terminator\n"));
 
 		partial = BOOL_FALSE;
 		rv = Media_mfile_begin(drivep, contextp, BOOL_FALSE);
@@ -5694,13 +5694,13 @@ dump_terminator(drive_t *drivep, context_t *contextp, media_hdr_t *mwhdrp)
 			break;
 		case RV_TIMEOUT:
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change timeout: "
-			      "media stream terminator not written\n"));
+				     "media change timeout: "
+				     "media stream terminator not written\n"));
 			return;
 		case RV_QUIT:
 			mlog(MLOG_VERBOSE | MLOG_WARNING, _(
-			      "media change declined: "
-			      "media stream terminator not written\n"));
+				     "media change declined: "
+				     "media stream terminator not written\n"));
 			return;
 		case RV_DRIVE:
 		case RV_ERROR:
@@ -5710,19 +5710,19 @@ dump_terminator(drive_t *drivep, context_t *contextp, media_hdr_t *mwhdrp)
 		}
 
 		mlog(MLOG_VERBOSE, _(
-		      "media file %u (media %u, file %u)\n"),
-		      mwhdrp->mh_dumpfileix,
-		      mwhdrp->mh_mediaix,
-		      mwhdrp->mh_mediafileix);
+			     "media file %u (media %u, file %u)\n"),
+		     mwhdrp->mh_dumpfileix,
+		     mwhdrp->mh_mediaix,
+		     mwhdrp->mh_mediafileix);
 
 		mlog(MLOG_VERBOSE, _(
-		      "ending media stream terminator\n"));
+			     "ending media stream terminator\n"));
 		ncommitted = 0;
 		rv = Media_mfile_end(drivep,
-				      contextp,
-				      mwhdrp,
-				      &ncommitted,
-				      BOOL_FALSE);
+				     contextp,
+				     mwhdrp,
+				     &ncommitted,
+				     BOOL_FALSE);
 		switch (rv) {
 		case RV_OK:
 			break;
@@ -5735,13 +5735,13 @@ dump_terminator(drive_t *drivep, context_t *contextp, media_hdr_t *mwhdrp)
 
 		if (partial) {
 			mlog(MLOG_VERBOSE, _(
-			      "encountered EOM while writing "
-			      "media stream terminator size %lld bytes\n"),
-			      ncommitted);
+				     "encountered EOM while writing "
+				     "media stream terminator size %lld bytes\n"),
+			     ncommitted);
 		} else {
 			mlog(MLOG_VERBOSE, _(
-			      "media stream terminator size %lld bytes\n"),
-			      ncommitted);
+				     "media stream terminator size %lld bytes\n"),
+			     ncommitted);
 		}
 
 		done = ! partial;
@@ -5756,10 +5756,10 @@ write_pad(drive_t *drivep, size_t sz)
 	rv_t rv;
 
 	rval = write_buf(0,
-			  sz,
-			  (void *)drivep,
-			  (gwbfp_t)dop->do_get_write_buf,
-			  (wfp_t)dop->do_write);
+			 sz,
+			 (void *)drivep,
+			 (gwbfp_t)dop->do_get_write_buf,
+			 (wfp_t)dop->do_write);
 
 	switch (rval) {
 	case 0:
@@ -5792,23 +5792,23 @@ inv_cleanup(void)
 		inv_stmtoken_t *inv_stmtp;
 		context_t *contextp;
 		for (strmix = 0,
-		      inv_stmtp = sc_inv_stmtokenp,
-		      contextp = sc_contextp
+		     inv_stmtp = sc_inv_stmtokenp,
+		     contextp = sc_contextp
 		     ;
-		      strmix < drivecnt
+		     strmix < drivecnt
 		     ;
-		      strmix++,
-		      inv_stmtp++,
-		      contextp++) {
+		     strmix++,
+		     inv_stmtp++,
+		     contextp++) {
 			bool_t interrupted;
 			interrupted = ! contextp->cc_completepr;
 			if (*inv_stmtp == INV_TOKEN_NULL) {
 				continue;
 			}
 			mlog(MLOG_DEBUG,
-			      "closing inventory stream %d%s\n",
-			      strmix,
-			      interrupted ? ": interrupted" : "");
+			     "closing inventory stream %d%s\n",
+			     strmix,
+			     interrupted ? ": interrupted" : "");
 			if (interrupted) mlog_exit_hint(RV_INTR);
 			ok = inv_stream_close(*inv_stmtp, interrupted);
 			assert(ok);
@@ -5861,7 +5861,7 @@ Media_mfile_begin(drive_t *drivep, context_t *contextp, bool_t intr_allowed)
 	assert(BES_INIT == 0);
 
 	mlog(MLOG_DEBUG | MLOG_MEDIA,
-	      "Media op: begin media file\n");
+	     "Media op: begin media file\n");
 
 	/*
 	 * the command line-specified media label is good only for the
@@ -5945,18 +5945,18 @@ position:
 		case 0:
 			mlog_lock();
 			mlog(MLOG_VERBOSE | MLOG_NOLOCK | MLOG_MEDIA, _(
-			      "positioned at media file %u: "
-			      "dump %u, "
-			      "stream %u\n"),
-			      mrhdrp->mh_mediafileix,
-			      mrhdrp->mh_dumpmediaix,
-			      drhdrp->dh_driveix);
+				     "positioned at media file %u: "
+				     "dump %u, "
+				     "stream %u\n"),
+			     mrhdrp->mh_mediafileix,
+			     mrhdrp->mh_dumpmediaix,
+			     drhdrp->dh_driveix);
 			mlog(MLOG_TRACE | MLOG_NOLOCK | MLOG_MEDIA,
-			      "stream media file %u (%u in object), "
-			      "stream media object %d\n",
-			      mrhdrp->mh_dumpfileix,
-			      mrhdrp->mh_dumpmediafileix,
-			      mrhdrp->mh_mediaix);
+			     "stream media file %u (%u in object), "
+			     "stream media object %d\n",
+			     mrhdrp->mh_dumpfileix,
+			     mrhdrp->mh_dumpmediafileix,
+			     mrhdrp->mh_mediaix);
 			mlog_unlock();
 
 			/*
@@ -5982,9 +5982,9 @@ position:
 			(*dop->do_end_read)(drivep);
 
 			switch (Media_erasechk(drivep,
-						dcaps,
-						intr_allowed,
-						prevmediapresentpr)) {
+					       dcaps,
+					       intr_allowed,
+					       prevmediapresentpr)) {
 			case RV_OK:
 				goto erasemedia;
 			case RV_INTR:
@@ -5995,20 +5995,20 @@ position:
 
 			if ((int32_t)mwhdrp->mh_mediaix >= 0) {
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "cannot interleave dump streams: "
-				      "must supply a blank media object\n"));
+					     "cannot interleave dump streams: "
+					     "must supply a blank media object\n"));
 				goto changemedia;
 			}
-			if (! (dcaps & DRIVE_CAP_APPEND)) {
+			if (!(dcaps & DRIVE_CAP_APPEND)) {
 				mlog(MLOG_NORMAL | MLOG_ERROR | MLOG_MEDIA, _(
-				      "media contains valid xfsdump "
-				      "but does not support append\n"));
+					     "media contains valid xfsdump "
+					     "but does not support append\n"));
 				goto changemedia;
 			}
 			if (MEDIA_TERMINATOR_CHK(mrhdrp)) {
 				int status;
 				mlog(MLOG_VERBOSE | MLOG_MEDIA, _(
-				      "stream terminator found\n"));
+					     "stream terminator found\n"));
 				assert(contextp->cc_Media_useterminatorpr);
 				assert(dcaps & DRIVE_CAP_BSF); /* redundant */
 				status = 0;
@@ -6016,8 +6016,8 @@ position:
 				assert(rval == 0);
 				if (status == DRIVE_ERROR_DEVICE) {
 					mlog(MLOG_NORMAL | MLOG_ERROR | MLOG_MEDIA, _(
-					      "encountered media error "
-					      "attempting BSF\n"));
+						     "encountered media error "
+						     "attempting BSF\n"));
 					goto changemedia;
 				}
 				if (mrhdrp->mh_mediafileix == 0) {
@@ -6030,15 +6030,15 @@ position:
 			prevmediapresentpr = mediapresentpr;
 			mediapresentpr = BOOL_TRUE;
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-			      "media contains non-xfsdump data "
-			      "or a corrupt xfsdump media file header "
-			      "at beginning of media\n"));
+				     "media contains non-xfsdump data "
+				     "or a corrupt xfsdump media file header "
+				     "at beginning of media\n"));
 			mlog_exit_hint(RV_CORRUPT);
 
 			switch (Media_erasechk(drivep,
-						dcaps,
-						intr_allowed,
-						prevmediapresentpr)) {
+					       dcaps,
+					       intr_allowed,
+					       prevmediapresentpr)) {
 			case RV_OK:
 				goto erasemedia;
 			case RV_INTR:
@@ -6058,14 +6058,14 @@ position:
 				}
 			}
 
-			if (! (dcaps & DRIVE_CAP_OVERWRITE)) {
+			if (!(dcaps & DRIVE_CAP_OVERWRITE)) {
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "unable to overwrite\n"));
+					     "unable to overwrite\n"));
 				goto changemedia;
 			} else {
 				int status;
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "repositioning to overwrite\n"));
+					     "repositioning to overwrite\n"));
 				assert(dcaps & DRIVE_CAP_BSF);
 				status = 0;
 				rval = (*dop->do_bsf)(drivep, 0, &status);
@@ -6083,8 +6083,8 @@ position:
 			prevmediapresentpr = mediapresentpr;
 			mediapresentpr = BOOL_TRUE;
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				"media may contain data. "
-				"Overwrite option specified\n"));
+				     "media may contain data. "
+				     "Overwrite option specified\n"));
 
 			if (dlog_allowed()) {
 				bool_t ok;
@@ -6111,15 +6111,15 @@ position:
 			return RV_DRIVE;
 		case DRIVE_ERROR_EOD:
 			mlog(MLOG_VERBOSE | MLOG_MEDIA, _(
-			      "at end of data\n"));
+				     "at end of data\n"));
 			prevmediapresentpr = mediapresentpr;
 			mediapresentpr = BOOL_TRUE;
 			virginmediapr = BOOL_FALSE;
 
 			switch (Media_erasechk(drivep,
-						dcaps,
-						intr_allowed,
-						prevmediapresentpr)) {
+					       dcaps,
+					       intr_allowed,
+					       prevmediapresentpr)) {
 			case RV_OK:
 				goto erasemedia;
 			case RV_INTR:
@@ -6130,9 +6130,9 @@ position:
 
 			if (contextp->cc_Media_useterminatorpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "encountered EOD but expecting a media "
-				      "stream terminator: "
-				      "assuming full media\n"));
+					     "encountered EOD but expecting a media "
+					     "stream terminator: "
+					     "assuming full media\n"));
 				goto changemedia;
 			} else {
 				goto write;
@@ -6142,12 +6142,12 @@ position:
 			mediapresentpr = BOOL_TRUE;
 			virginmediapr = BOOL_FALSE;
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-			      "encountered EOM: media is full\n"));
+				     "encountered EOM: media is full\n"));
 
 			switch (Media_erasechk(drivep,
-						dcaps,
-						intr_allowed,
-						prevmediapresentpr)) {
+					       dcaps,
+					       intr_allowed,
+					       prevmediapresentpr)) {
 			case RV_OK:
 				goto erasemedia;
 			case RV_INTR:
@@ -6165,14 +6165,14 @@ position:
 			virginmediapr = BOOL_FALSE;
 
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-			      "encountered corrupt or foreign data: "
-			      "assuming corrupted media\n"));
+				     "encountered corrupt or foreign data: "
+				     "assuming corrupted media\n"));
 			mlog_exit_hint(RV_CORRUPT);
 
 			switch (Media_erasechk(drivep,
-						dcaps,
-						intr_allowed,
-						prevmediapresentpr)) {
+					       dcaps,
+					       intr_allowed,
+					       prevmediapresentpr)) {
 			case RV_OK:
 				goto erasemedia;
 			case RV_INTR:
@@ -6183,24 +6183,24 @@ position:
 
 			if (contextp->cc_Media_useterminatorpr) {
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "encountered corrupt or foreign data "
-				      "but expecting a media "
-				      "stream terminator: "
-				      "assuming corrupted media\n"));
+					     "encountered corrupt or foreign data "
+					     "but expecting a media "
+					     "stream terminator: "
+					     "assuming corrupted media\n"));
 				mlog_exit_hint(RV_CORRUPT);
 				goto changemedia;
-			} else if (! (dcaps & DRIVE_CAP_OVERWRITE)) {
+			} else if (!(dcaps & DRIVE_CAP_OVERWRITE)) {
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "encountered corrupt or foreign data: "
-				      "unable to overwrite: "
-				      "assuming corrupted media\n"));
+					     "encountered corrupt or foreign data: "
+					     "unable to overwrite: "
+					     "assuming corrupted media\n"));
 				mlog_exit_hint(RV_CORRUPT);
 				goto changemedia;
 			} else {
 				int status;
 				mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-				      "encountered corrupt or foreign data: "
-				      "repositioning to overwrite\n"));
+					     "encountered corrupt or foreign data: "
+					     "repositioning to overwrite\n"));
 				mlog_exit_hint(RV_CORRUPT);
 				assert(dcaps & DRIVE_CAP_BSF);
 				status = 0;
@@ -6218,8 +6218,8 @@ position:
 		case DRIVE_ERROR_EOF:
 		default:
 			mlog(MLOG_NORMAL | MLOG_ERROR | MLOG_MEDIA, _(
-			      "unexpected error from do_begin_read: %d\n"),
-			      rval);
+				     "unexpected error from do_begin_read: %d\n"),
+			     rval);
 			return RV_CORE;
 		}
 	}
@@ -6227,7 +6227,7 @@ position:
 
 erasemedia:
 	mlog(MLOG_VERBOSE | MLOG_WARNING | MLOG_MEDIA, _(
-	      "erasing media\n"));
+		     "erasing media\n"));
 	rval = (*dop->do_erase)(drivep);
 	if (rval) {
 		return RV_DRIVE;
@@ -6242,7 +6242,7 @@ changemedia:
 	/*
 	 * if the drive does not support media change, quit.
 	 */
-	if (! (dcaps & DRIVE_CAP_REMOVABLE)) {
+	if (!(dcaps & DRIVE_CAP_REMOVABLE)) {
 		return RV_ERROR;
 	}
 
@@ -6270,7 +6270,7 @@ changemedia:
 	 * If an alert program has been specified, run it
 	 */
 	if (media_change_alert_program != NULL)
-	   system(media_change_alert_program);
+		system(media_change_alert_program);
 
 	/*
 	 * if media change prompt declined or times out,
@@ -6280,9 +6280,9 @@ changemedia:
 		ix_t thrdix = drivep->d_index;
 		assert(sistr);
 		mlog(MLOG_NORMAL | MLOG_NOTE | MLOG_MEDIA, _(
-		      "please change media: "
-		      "type %s to confirm media change\n"),
-		      sistr);
+			     "please change media: "
+			     "type %s to confirm media change\n"),
+		     sistr);
 		set_mcflag(thrdix);
 		while (sc_mcflag[thrdix]) {
 			sleep(2);
@@ -6362,13 +6362,13 @@ write:
 	 * do not allow interleaving of media files from different xfsdumps.
 	 */
 	if (mwhdrp->mh_mediaix != 0
-	     &&
-	     mwhdrp->mh_dumpmediafileix == 0
-	     &&
-	     ! virginmediapr) {
+	    &&
+	    mwhdrp->mh_dumpmediafileix == 0
+	    &&
+	    ! virginmediapr) {
 		mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-		      "cannot interleave dump streams: must supply a blank "
-		      "media object\n"));
+			     "cannot interleave dump streams: must supply a blank "
+			     "media object\n"));
 		*gwhdrp = saved_gwhdr;
 		goto changemedia;
 	}
@@ -6379,8 +6379,8 @@ write:
 	if (! mediawrittentopr && mwhdrp->mh_dumpfileix != 0) {
 		uuid_copy(mwhdrp->mh_prevmediaid, mwhdrp->mh_mediaid);
 		(void)strncpyterm(mwhdrp->mh_prevmedialabel,
-				     mwhdrp->mh_medialabel,
-				     sizeof(mwhdrp->mh_medialabel));
+				  mwhdrp->mh_medialabel,
+				  sizeof(mwhdrp->mh_medialabel));
 	}
 
 	/*
@@ -6393,42 +6393,42 @@ write:
 			uuid_generate(mwhdrp->mh_mediaid);
 
 			if (! cmdlinemedialabel
-			     &&
-			     ! drivep->d_isnamedpipepr
-			     &&
-			     ! drivep->d_isunnamedpipepr
-			     &&
-			     dlog_allowed()) {
+			    &&
+			    ! drivep->d_isnamedpipepr
+			    &&
+			    ! drivep->d_isunnamedpipepr
+			    &&
+			    dlog_allowed()) {
 				cmdlinemedialabel = Media_prompt_label(drivep,
-							labelbuf,
-							sizeof(labelbuf));
+								       labelbuf,
+								       sizeof(labelbuf));
 				if (intr_allowed && cldmgr_stop_requested()) {
 					return RV_INTR;
 				}
 			}
 			if (cmdlinemedialabel && strlen(cmdlinemedialabel)) {
 				(void)strncpyterm(mwhdrp->mh_medialabel,
-						     cmdlinemedialabel,
-					       sizeof(mwhdrp->mh_medialabel));
+						  cmdlinemedialabel,
+						  sizeof(mwhdrp->mh_medialabel));
 			} else {
 				(void)memset((void *)mwhdrp->mh_medialabel,
-						     0,
-					       sizeof(mwhdrp->mh_medialabel));
+					     0,
+					     sizeof(mwhdrp->mh_medialabel));
 				if (! pipeline) {
 					mlog(MLOG_VERBOSE
-					      |
-					      MLOG_WARNING
-					      |
-					      MLOG_MEDIA, _(
-					      "no media label specified\n"));
+					     |
+					     MLOG_WARNING
+					     |
+					     MLOG_MEDIA, _(
+						     "no media label specified\n"));
 				}
 			}
 		} else {
 			assert(! virginmediapr);
 			uuid_copy(mwhdrp->mh_mediaid, mrhdrp->mh_mediaid);
 			(void)strncpyterm(mwhdrp->mh_medialabel,
-					     mrhdrp->mh_medialabel,
-					     sizeof(mwhdrp->mh_medialabel));
+					  mrhdrp->mh_medialabel,
+					  sizeof(mwhdrp->mh_medialabel));
 		}
 	}
 
@@ -6446,8 +6446,8 @@ write:
 		return RV_OK;
 	case DRIVE_ERROR_EOM:
 		mlog(MLOG_VERBOSE | MLOG_MEDIA, _(
-		      "encountered end of media "
-		      "while attempting to begin new media file\n"));
+			     "encountered end of media "
+			     "while attempting to begin new media file\n"));
 		*gwhdrp = saved_gwhdr;
 		goto changemedia;
 	case DRIVE_ERROR_MEDIA:
@@ -6462,17 +6462,17 @@ write:
 
 /* ARGSUSED */
 static rv_t
-Media_mfile_end(drive_t *drivep,
-		 context_t *contextp,
-		 media_hdr_t *mwhdrp,
-		 off64_t *ncommittedp,
-		 bool_t hit_eom)
+Media_mfile_end(drive_t *	drivep,
+		context_t *	contextp,
+		media_hdr_t *	mwhdrp,
+		off64_t *	ncommittedp,
+		bool_t		hit_eom)
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	int rval;
 
 	mlog(MLOG_DEBUG | MLOG_MEDIA,
-	      "Media op: end media file\n");
+	     "Media op: end media file\n");
 
 	assert(contextp->cc_Media_begin_entrystate == BES_INVAL);
 
@@ -6493,8 +6493,8 @@ Media_mfile_end(drive_t *drivep,
 	case DRIVE_ERROR_MEDIA:
 	case DRIVE_ERROR_EOM:
 		mlog(MLOG_VERBOSE | MLOG_MEDIA, _(
-		      "encountered end of media "
-		      "while ending media file\n"));
+			     "encountered end of media "
+			     "while ending media file\n"));
 		mlog_exit_hint(RV_EOM);
 		contextp->cc_Media_begin_entrystate = BES_ENDEOM;
 		return RV_EOM;
@@ -6541,9 +6541,9 @@ retry:
 	 * query: ask if overwrite ok
 	 */
 	sprintf(question,
-		 "overwrite data on media in "
-		 "drive %u?\n",
-		 (unsigned int)drivep->d_index);
+		"overwrite data on media in "
+		"drive %u?\n",
+		(unsigned int)drivep->d_index);
 	querycnt = 0;
 	querystr[querycnt++] = question;
 	assert(querycnt <= QUERYMAX);
@@ -6556,18 +6556,18 @@ retry:
 	sigintix = IXMAX - 1;
 
 	responseix = dlog_multi_query(querystr,
-				       querycnt,
-				       choicestr,
-				       choicecnt,
-				       0,           /* hilitestr */
-				       IXMAX,       /* hiliteix */
-				       0,           /* defaultstr */
-				       doix,        /* defaultix */
-				       DLOG_TIMEOUT_MEDIA,
-				       dontix,		/* timeout ix */
-				       sigintix,	/* sigint ix */
-				       dontix,		/* sighup ix */
-				       dontix);	/* sigquit ix */
+				      querycnt,
+				      choicestr,
+				      choicecnt,
+				      0,        /* hilitestr */
+				      IXMAX,    /* hiliteix */
+				      0,        /* defaultstr */
+				      doix,     /* defaultix */
+				      DLOG_TIMEOUT_MEDIA,
+				      dontix,   /* timeout ix */
+				      sigintix, /* sigint ix */
+				      dontix,   /* sighup ix */
+				      dontix);  /* sigquit ix */
 	ackcnt = 0;
 	if (responseix == doix) {
 		ackstr[ackcnt++] = "media will be overwritten\n";
@@ -6578,7 +6578,7 @@ retry:
 	}
 	assert(ackcnt <= ACKMAX);
 	dlog_multi_ack(ackstr,
-			ackcnt);
+		       ackcnt);
 
 	postamblecnt = 0;
 	fold_init(fold, "end dialog", '-');
@@ -6587,21 +6587,21 @@ retry:
 	postamblestr[postamblecnt++] = "\n\n";
 	assert(postamblecnt <= POSTAMBLEMAX);
 	dlog_end(postamblestr,
-		  postamblecnt);
+		 postamblecnt);
 
 	if (responseix == sigintix) {
 		if (cldmgr_stop_requested()) {
 			return BOOL_FALSE;
 		}
-		sleep(1); /* to allow main thread to begin dialog */
+		sleep(1);       /* to allow main thread to begin dialog */
 		mlog(MLOG_NORMAL | MLOG_BARE,
-		      ""); /* to block until main thread dialog complete */
-		sleep(1); /* to allow main thread to request children die */
+		     "");       /* to block until main thread dialog complete */
+		sleep(1);       /* to allow main thread to request children die */
 		if (cldmgr_stop_requested()) {
 			return BOOL_FALSE;
 		}
 		mlog(MLOG_DEBUG,
-		      "retrying media overwrite dialog\n");
+		     "retrying media overwrite dialog\n");
 		goto retry;
 	}
 
@@ -6611,9 +6611,9 @@ retry:
 
 static rv_t
 Media_erasechk(drive_t *drivep,
-		int dcaps,
-		bool_t intr_allowed,
-		bool_t prevmediapresentpr)
+	       int	dcaps,
+	       bool_t	intr_allowed,
+	       bool_t	prevmediapresentpr)
 {
 	if (prevmediapresentpr == BOOL_TRUE) {
 		return RV_NOTOK;
@@ -6637,9 +6637,9 @@ Media_erasechk(drive_t *drivep,
 			}
 		} else {
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_MEDIA, _(
-			      "drive does not support media erase: "
-			      "ignoring -%c option\n"),
-			      GETOPT_ERASE);
+				     "drive does not support media erase: "
+				     "ignoring -%c option\n"),
+			     GETOPT_ERASE);
 			return RV_NOTOK;
 		}
 	} else {
@@ -6680,12 +6680,12 @@ retry:
 	 * query: ask if overwrite ok
 	 */
 	sprintf(question,
-		 "pre-erase (-%c) option specified "
-		 "and non-blank media encountered:\n"
-		 "please confirm media erase "
-		 "drive %u\n",
-		 GETOPT_ERASE,
-		 (unsigned int)drivep->d_index);
+		"pre-erase (-%c) option specified "
+		"and non-blank media encountered:\n"
+		"please confirm media erase "
+		"drive %u\n",
+		GETOPT_ERASE,
+		(unsigned int)drivep->d_index);
 	querycnt = 0;
 	querystr[querycnt++] = question;
 	assert(querycnt <= QUERYMAX);
@@ -6698,18 +6698,18 @@ retry:
 	sigintix = IXMAX - 1;
 
 	responseix = dlog_multi_query(querystr,
-				       querycnt,
-				       choicestr,
-				       choicecnt,
-				       0,           /* hilitestr */
-				       IXMAX,       /* hiliteix */
-				       0,           /* defaultstr */
-				       doix,        /* defaultix */
-				       DLOG_TIMEOUT_MEDIA,
-				       dontix,		/* timeout ix */
-				       sigintix,	/* sigint ix */
-				       dontix,		/* sighup ix */
-				       dontix);	/* sigquit ix */
+				      querycnt,
+				      choicestr,
+				      choicecnt,
+				      0,        /* hilitestr */
+				      IXMAX,    /* hiliteix */
+				      0,        /* defaultstr */
+				      doix,     /* defaultix */
+				      DLOG_TIMEOUT_MEDIA,
+				      dontix,   /* timeout ix */
+				      sigintix, /* sigint ix */
+				      dontix,   /* sighup ix */
+				      dontix);  /* sigquit ix */
 	ackcnt = 0;
 	if (responseix == doix) {
 		ackstr[ackcnt++] = "media will be erased\n";
@@ -6720,7 +6720,7 @@ retry:
 	}
 	assert(ackcnt <= ACKMAX);
 	dlog_multi_ack(ackstr,
-			ackcnt);
+		       ackcnt);
 
 	postamblecnt = 0;
 	fold_init(fold, "end dialog", '-');
@@ -6729,21 +6729,21 @@ retry:
 	postamblestr[postamblecnt++] = "\n\n";
 	assert(postamblecnt <= POSTAMBLEMAX);
 	dlog_end(postamblestr,
-		  postamblecnt);
+		 postamblecnt);
 
 	if (responseix == sigintix) {
 		if (cldmgr_stop_requested()) {
 			return BOOL_FALSE;
 		}
-		sleep(1); /* to allow main thread to begin dialog */
+		sleep(1);       /* to allow main thread to begin dialog */
 		mlog(MLOG_NORMAL | MLOG_BARE,
-		      ""); /* to block until main thread dialog complete */
-		sleep(1); /* to allow main thread to request children die */
+		     "");       /* to block until main thread dialog complete */
+		sleep(1);       /* to allow main thread to request children die */
 		if (cldmgr_stop_requested()) {
 			return BOOL_FALSE;
 		}
 		mlog(MLOG_DEBUG,
-		      "retrying media erase dialog\n");
+		     "retrying media erase dialog\n");
 		goto retry;
 	}
 
@@ -6760,9 +6760,9 @@ Media_prompt_label_cb(void *uctxp, dlog_pcbp_t pcb, void *pctxp)
 	 * query: ask for a label
 	 */
 	(*pcb)(pctxp,
-		   "please enter label for media in "
-		   "drive %u",
-		   drivep->d_index);
+	       "please enter label for media in "
+	       "drive %u",
+	       drivep->d_index);
 }
 
 static char *
@@ -6791,15 +6791,15 @@ retry:
 	dlog_begin(preamblestr, preamblecnt);
 
 	responseix = dlog_string_query(Media_prompt_label_cb,
-					(void *)drivep,
-					bufp,
-					bufsz,
-					DLOG_TIMEOUT,
-					timeoutix,/* timeout ix */
-					sigintix, /* sigint ix */
-					abortix,  /* sighup ix */
-					abortix,  /* sigquit ix */
-					okix);   /* ok ix */
+				       (void *)drivep,
+				       bufp,
+				       bufsz,
+				       DLOG_TIMEOUT,
+				       timeoutix,       /* timeout ix */
+				       sigintix,        /* sigint ix */
+				       abortix,         /* sighup ix */
+				       abortix,         /* sigquit ix */
+				       okix);           /* ok ix */
 	ackcnt = 0;
 	if (responseix == okix) {
 		ackstr[ackcnt++] = "media label entered: \"";
@@ -6815,7 +6815,7 @@ retry:
 
 	assert(ackcnt <= ACKMAX);
 	dlog_string_ack(ackstr,
-			 ackcnt);
+			ackcnt);
 
 	postamblecnt = 0;
 	fold_init(fold, "end dialog", '-');
@@ -6824,21 +6824,21 @@ retry:
 	postamblestr[postamblecnt++] = "\n\n";
 	assert(postamblecnt <= POSTAMBLEMAX);
 	dlog_end(postamblestr,
-		  postamblecnt);
+		 postamblecnt);
 
 	if (responseix == sigintix) {
 		if (cldmgr_stop_requested()) {
 			return 0;
 		}
-		sleep(1); /* to allow main thread to begin dialog */
+		sleep(1);       /* to allow main thread to begin dialog */
 		mlog(MLOG_NORMAL | MLOG_BARE,
-		      ""); /* to block until main thread dialog complete */
-		sleep(1); /* to allow main thread to request children die */
+		     "");       /* to block until main thread dialog complete */
+		sleep(1);       /* to allow main thread to request children die */
 		if (cldmgr_stop_requested()) {
 			return 0;
 		}
 		mlog(MLOG_DEBUG,
-		      "retrying media label dialog\n");
+		     "retrying media label dialog\n");
 		goto retry;
 	}
 
@@ -6908,65 +6908,65 @@ is_quota_file(ino_t ino)
 static bool_t
 save_quotas(char *mntpnt, quota_info_t *quotainfo)
 {
-        int             sts = 0;
-        char            buf[1024] = "";
-        int             fd;
-        char            tmp;
-        struct stat     statb;
-
-        mlog(MLOG_VERBOSE, _(
-		"saving %s information for: %s\n"), quotainfo->desc, mntpnt);
-
-        if (unlink(quotainfo->quotapath) == 0) {
-            mlog(MLOG_WARNING, _("overwriting: %s\n"), quotainfo->quotapath);
-        }
-        else {
-            if (errno != ENOENT) {
-                mlog(MLOG_ERROR, _(
-                      "unable to remove %s: %s\n"),
-                      quotainfo->quotapath,
-                      strerror(errno));
-                return BOOL_FALSE;
-            }
-        }
-
-        sprintf(buf,
-		 "%s -x -c 'dump %s %s' %s 2> /dev/null",
-		 REPQUOTA,
-                 quotainfo->repquotaargs,
-                 quotainfo->quotapath,
-                 mntpnt);
-
-        mlog(MLOG_NITTY, "saving quotas: %s\n", buf);
-
-        sts = system(buf);
-        if (sts != 0) {
-            mlog(MLOG_ERROR, _(
-                  "%s failed with exit status: %d\n"), REPQUOTA,
-		  sts == -1 ? -1 : WEXITSTATUS(sts));
-            return BOOL_FALSE;
-        }
-        if ((fd = open(quotainfo->quotapath, O_RDONLY|O_DSYNC)) < 0) {
-            mlog(MLOG_ERROR, _(
-                  "open failed %s: %s\n"),
-                  quotainfo->quotapath,
-                  strerror(errno));
-            return BOOL_FALSE;
-        }
-        if (fstat(fd, &statb) < 0) {
-            mlog(MLOG_ERROR, _(
-                  "stat failed %s: %s\n"),
-                  quotainfo->quotapath,
-                  strerror(errno));
-            close(fd);
-            return BOOL_FALSE;
-        }
-        quotainfo->quotaino = statb.st_ino;
-
-        /* open and read dump file to ensure it is in the dump */
-        read(fd, &tmp, 1);
-        close(fd);
-        return BOOL_TRUE;
+	int sts = 0;
+	char buf[1024] = "";
+	int fd;
+	char tmp;
+	struct stat statb;
+
+	mlog(MLOG_VERBOSE, _(
+		     "saving %s information for: %s\n"), quotainfo->desc, mntpnt);
+
+	if (unlink(quotainfo->quotapath) == 0) {
+		mlog(MLOG_WARNING, _("overwriting: %s\n"), quotainfo->quotapath);
+	}
+	else {
+		if (errno != ENOENT) {
+			mlog(MLOG_ERROR, _(
+				     "unable to remove %s: %s\n"),
+			     quotainfo->quotapath,
+			     strerror(errno));
+			return BOOL_FALSE;
+		}
+	}
+
+	sprintf(buf,
+		"%s -x -c 'dump %s %s' %s 2> /dev/null",
+		REPQUOTA,
+		quotainfo->repquotaargs,
+		quotainfo->quotapath,
+		mntpnt);
+
+	mlog(MLOG_NITTY, "saving quotas: %s\n", buf);
+
+	sts = system(buf);
+	if (sts != 0) {
+		mlog(MLOG_ERROR, _(
+			     "%s failed with exit status: %d\n"), REPQUOTA,
+		     sts == -1 ? -1 : WEXITSTATUS(sts));
+		return BOOL_FALSE;
+	}
+	if ((fd = open(quotainfo->quotapath, O_RDONLY|O_DSYNC)) < 0) {
+		mlog(MLOG_ERROR, _(
+			     "open failed %s: %s\n"),
+		     quotainfo->quotapath,
+		     strerror(errno));
+		return BOOL_FALSE;
+	}
+	if (fstat(fd, &statb) < 0) {
+		mlog(MLOG_ERROR, _(
+			     "stat failed %s: %s\n"),
+		     quotainfo->quotapath,
+		     strerror(errno));
+		close(fd);
+		return BOOL_FALSE;
+	}
+	quotainfo->quotaino = statb.st_ino;
+
+	/* open and read dump file to ensure it is in the dump */
+	read(fd, &tmp, 1);
+	close(fd);
+	return BOOL_TRUE;
 }
 
 static int
diff --git a/dump/getopt.h b/dump/getopt.h
index 06c9ab0..c2ee88f 100644
--- a/dump/getopt.h
+++ b/dump/getopt.h
@@ -28,59 +28,59 @@
  * facilitating easy changes.
  */
 
-#define GETOPT_CMDSTRING	"ab:c:d:ef:hl:mop:qs:t:v:z:AB:CDEFG:H:I:JKL:M:NO:PRSTUVWY:"
+#define GETOPT_CMDSTRING        "ab:c:d:ef:hl:mop:qs:t:v:z:AB:CDEFG:H:I:JKL:M:NO:PRSTUVWY:"
 
-#define GETOPT_DUMPASOFFLINE	'a'	/* dump DMF dualstate files as offline */
-#define	GETOPT_BLOCKSIZE	'b'	/* blocksize for rmt */
-#define	GETOPT_ALERTPROG	'c'	/* Media Change Alert prog(content.c) */
-#define	GETOPT_FILESZ		'd'	/* Media file size to use in Mb */
-#define GETOPT_EXCLUDEFILES	'e'	/* allow files to be excluded */
-#define	GETOPT_DUMPDEST		'f'	/* dump dest. file (drive.c) */
+#define GETOPT_DUMPASOFFLINE    'a'     /* dump DMF dualstate files as offline */
+#define GETOPT_BLOCKSIZE        'b'     /* blocksize for rmt */
+#define GETOPT_ALERTPROG        'c'     /* Media Change Alert prog(content.c) */
+#define GETOPT_FILESZ           'd'     /* Media file size to use in Mb */
+#define GETOPT_EXCLUDEFILES     'e'     /* allow files to be excluded */
+#define GETOPT_DUMPDEST         'f'     /* dump dest. file (drive.c) */
 /*				'g'	*/
-#define	GETOPT_HELP		'h'	/* display version and usage */
+#define GETOPT_HELP             'h'     /* display version and usage */
 /*				'i'	*/
 /*				'j'	*/
 /*				'k'	*/
-#define	GETOPT_LEVEL		'l'	/* dump level (content_inode.c) */
-#define GETOPT_MINRMT		'm'	/* use minimal rmt protocol */
+#define GETOPT_LEVEL            'l'     /* dump level (content_inode.c) */
+#define GETOPT_MINRMT           'm'     /* use minimal rmt protocol */
 /*				'n'	*/
-#define GETOPT_OVERWRITE	'o'	/* overwrite data on tape */
-#define GETOPT_PROGRESS		'p'	/* interval between progress reports */
-#define	GETOPT_QIC		'q'	/* option to tell dump it's a QIC tape */
+#define GETOPT_OVERWRITE        'o'     /* overwrite data on tape */
+#define GETOPT_PROGRESS         'p'     /* interval between progress reports */
+#define GETOPT_QIC              'q'     /* option to tell dump it's a QIC tape */
 /*				'r'	*/
-#define	GETOPT_SUBTREE		's'	/* subtree dump (content_inode.c) */
-#define GETOPT_DUMPTIME		't'	/* use mtime of file as dump time */
+#define GETOPT_SUBTREE          's'     /* subtree dump (content_inode.c) */
+#define GETOPT_DUMPTIME         't'     /* use mtime of file as dump time */
 /*				'u' */
-#define	GETOPT_VERBOSITY	'v'	/* verbosity level (0 to 4) */
+#define GETOPT_VERBOSITY        'v'     /* verbosity level (0 to 4) */
 /*				'w' */
 /*				'x'	   used in irix for xvm snapshot */
 /*				'y' */
-#define GETOPT_MAXDUMPFILESIZE	'z'	/* prune files over specified size */
-#define	GETOPT_NOEXTATTR	'A'	/* do not dump ext. file attributes */
-#define	GETOPT_BASED		'B'	/* specify session to base increment */
-#define GETOPT_RECCHKSUM	'C'	/* use record checksums */
-#define GETOPT_NOUNCHANGEDDIRS	'D'	/* skip unchanged directories */
-#define	GETOPT_ERASE		'E'	/* pre-erase media */
-#define GETOPT_FORCE		'F'	/* don't prompt (getopt.c) */
-#define GETOPT_MINSTACKSZ	'G'	/* minimum stack size (bytes) */
-#define GETOPT_MAXSTACKSZ	'H'	/* maximum stack size (bytes) */
+#define GETOPT_MAXDUMPFILESIZE  'z'     /* prune files over specified size */
+#define GETOPT_NOEXTATTR        'A'     /* do not dump ext. file attributes */
+#define GETOPT_BASED            'B'     /* specify session to base increment */
+#define GETOPT_RECCHKSUM        'C'     /* use record checksums */
+#define GETOPT_NOUNCHANGEDDIRS  'D'     /* skip unchanged directories */
+#define GETOPT_ERASE            'E'     /* pre-erase media */
+#define GETOPT_FORCE            'F'     /* don't prompt (getopt.c) */
+#define GETOPT_MINSTACKSZ       'G'     /* minimum stack size (bytes) */
+#define GETOPT_MAXSTACKSZ       'H'     /* maximum stack size (bytes) */
 #define GETOPT_INVPRINT         'I'     /* just display the inventory */
-#define	GETOPT_NOINVUPDATE	'J'	/* do not update the dump inventory */
-#define GETOPT_FMT2COMPAT	'K'	/* use dump format 2 for compat with old restore */
-#define	GETOPT_DUMPLABEL	'L'	/* dump session label (global.c) */
-#define	GETOPT_MEDIALABEL	'M'	/* media object label (media.c) */
-#define	GETOPT_TIMESTAMP	'N'	/* show timestamps in log msgs */
-#define	GETOPT_OPTFILE		'O'	/* specifycmd line options file */
-#define	GETOPT_RINGPIN		'P'	/* pin down I/O buffer ring */
+#define GETOPT_NOINVUPDATE      'J'     /* do not update the dump inventory */
+#define GETOPT_FMT2COMPAT       'K'     /* use dump format 2 for compat with old restore */
+#define GETOPT_DUMPLABEL        'L'     /* dump session label (global.c) */
+#define GETOPT_MEDIALABEL       'M'     /* media object label (media.c) */
+#define GETOPT_TIMESTAMP        'N'     /* show timestamps in log msgs */
+#define GETOPT_OPTFILE          'O'     /* specifycmd line options file */
+#define GETOPT_RINGPIN          'P'     /* pin down I/O buffer ring */
 /*				'Q'	*/
-#define	GETOPT_RESUME		'R'	/* resume intr dump (content_inode.c) */
-#define	GETOPT_SINGLEMFILE	'S'	/* obsolete - now the default */
-#define	GETOPT_NOTIMEOUTS	'T'	/* don't timeout dialogs */
-#define	GETOPT_UNLOAD		'U'	/* unload media when change needed */
-#define	GETOPT_SHOWLOGSS	'V'	/* show subsystem of log messages */
-#define	GETOPT_SHOWLOGLEVEL	'W'	/* show level of log messages */
+#define GETOPT_RESUME           'R'     /* resume intr dump (content_inode.c) */
+#define GETOPT_SINGLEMFILE      'S'     /* obsolete - now the default */
+#define GETOPT_NOTIMEOUTS       'T'     /* don't timeout dialogs */
+#define GETOPT_UNLOAD           'U'     /* unload media when change needed */
+#define GETOPT_SHOWLOGSS        'V'     /* show subsystem of log messages */
+#define GETOPT_SHOWLOGLEVEL     'W'     /* show level of log messages */
 /*				'X'	*/
-#define	GETOPT_RINGLEN		'Y'	/* specify I/O buffer ring length */
+#define GETOPT_RINGLEN          'Y'     /* specify I/O buffer ring length */
 /*				'Z'	   used on irix for miniroot */
 
 #endif /* GETOPT_H */
diff --git a/dump/inomap.c b/dump/inomap.c
index 240a767..be505ea 100644
--- a/dump/inomap.c
+++ b/dump/inomap.c
@@ -47,15 +47,15 @@
 
 /* structure definitions used locally ****************************************/
 
-#define BSTATBUFLEN	pgsz
-	/*
-	 * length (in bstat_t's) of buf passed to bigstat_iter
-	 */
+#define BSTATBUFLEN     pgsz
+/*
+ * length (in bstat_t's) of buf passed to bigstat_iter
+ */
 
-#define GETDENTBUFSZ	pgsz
-	/*
-	 * size (in bytes) of buf passed to diriter (when not recursive)
-	 */
+#define GETDENTBUFSZ    pgsz
+/*
+ * size (in bytes) of buf passed to diriter (when not recursive)
+ */
 
 /* declarations of externally defined global symbols *************************/
 
@@ -72,16 +72,16 @@ extern bool_t allowexcludefiles_pr;
  */
 static int
 cb_context(bool_t last,
-			    time32_t,
-			    bool_t,
-			    time32_t,
-			    size_t,
-			    drange_t *,
-			    startpt_t *,
-			    size_t,
-			    int,
-			    bool_t,
-			    bool_t *);
+	   time32_t,
+	   bool_t,
+	   time32_t,
+	   size_t,
+	   drange_t *,
+	   startpt_t *,
+	   size_t,
+	   int,
+	   bool_t,
+	   bool_t *);
 static void cb_context_free(void);
 static int cb_count_inogrp(void *, int, xfs_inogrp_t *);
 static int cb_add_inogrp(void *, int, xfs_inogrp_t *);
@@ -92,15 +92,15 @@ static void cb_accuminit_sz(void);
 static void cb_spinit(void);
 static int
 cb_startpt(void *,
-			    jdm_fshandle_t *,
-			    int,
-			    xfs_bstat_t *);
+	   jdm_fshandle_t *,
+	   int,
+	   xfs_bstat_t *);
 static int
 supprt_prune(void *,
-			      jdm_fshandle_t *,
-			      int,
-			      xfs_bstat_t *,
-			      char *);
+	     jdm_fshandle_t *,
+	     int,
+	     xfs_bstat_t *,
+	     char *);
 static off64_t quantity2offset(jdm_fshandle_t *, xfs_bstat_t *, off64_t);
 static off64_t estimate_dump_space(xfs_bstat_t *);
 
@@ -117,22 +117,22 @@ static void inomap_set_gen(void *, xfs_ino_t, gen_t);
  */
 static int
 subtree_descend_cb(void *,
-				    jdm_fshandle_t *,
-				    int fsfd,
-				    xfs_bstat_t *,
-				    char *);
+		   jdm_fshandle_t *,
+		   int fsfd,
+		   xfs_bstat_t *,
+		   char *);
 static int
 subtreelist_parse_cb(void *,
-				      jdm_fshandle_t *,
-				      int fsfd,
-				      xfs_bstat_t *,
-				      char *);
+		     jdm_fshandle_t *,
+		     int fsfd,
+		     xfs_bstat_t *,
+		     char *);
 static int
 subtreelist_parse(jdm_fshandle_t *,
-				   int,
-				   xfs_bstat_t *,
-				   char *[],
-				   ix_t);
+		  int,
+		  xfs_bstat_t *,
+		  char *[],
+		  ix_t);
 
 /* definition of locally defined global variables ****************************/
 
@@ -154,24 +154,24 @@ static uint64_t inomap_exclude_skipattr = 0;
  */
 /* ARGSUSED */
 bool_t
-inomap_build(jdm_fshandle_t *fshandlep,
-	      int fsfd,
-	      xfs_bstat_t *rootstatp,
-	      bool_t last,
-	      time32_t lasttime,
-	      bool_t resume,
-	      time32_t resumetime,
-	      size_t resumerangecnt,
-	      drange_t *resumerangep,
-	      char *subtreebuf[],
-	      ix_t subtreecnt,
-	      bool_t skip_unchanged_dirs,
-	      startpt_t *startptp,
-	      size_t startptcnt,
-	      ix_t *statphasep,
-	      ix_t *statpassp,
-	      size64_t statcnt,
-	      size64_t *statdonep)
+inomap_build(jdm_fshandle_t *	fshandlep,
+	     int		fsfd,
+	     xfs_bstat_t *	rootstatp,
+	     bool_t		last,
+	     time32_t		lasttime,
+	     bool_t		resume,
+	     time32_t		resumetime,
+	     size_t		resumerangecnt,
+	     drange_t *		resumerangep,
+	     char *		subtreebuf[],
+	     ix_t		subtreecnt,
+	     bool_t		skip_unchanged_dirs,
+	     startpt_t *	startptp,
+	     size_t		startptcnt,
+	     ix_t *		statphasep,
+	     ix_t *		statpassp,
+	     size64_t		statcnt,
+	     size64_t *		statdonep)
 {
 	xfs_bstat_t *bstatbufp;
 	size_t bstatbuflen;
@@ -180,13 +180,13 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	int stat;
 	int rval;
 
-        /*
-         * do a sync so that bulkstat will pick up inode changes
-         * that are currently in the inode cache. this is necessary
-         * for incremental dumps in order to have the dump time
-         * accurately reflect what inodes were included in this dump.
-         * (PV 881455)
-         */
+	/*
+	 * do a sync so that bulkstat will pick up inode changes
+	 * that are currently in the inode cache. this is necessary
+	 * for incremental dumps in order to have the dump time
+	 * accurately reflect what inodes were included in this dump.
+	 * (PV 881455)
+	 */
 	sync();
 
 	/*
@@ -201,9 +201,9 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 */
 	bstatbuflen = BSTATBUFLEN;
 	bstatbufp = (xfs_bstat_t *)memalign(pgsz,
-					       bstatbuflen
-					       *
-					       sizeof(xfs_bstat_t));
+					    bstatbuflen
+					    *
+					    sizeof(xfs_bstat_t));
 	assert(bstatbufp);
 
 	/*
@@ -220,20 +220,20 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 * initialize the callback context
 	 */
 	rval = cb_context(last,
-			   lasttime,
-			   resume,
-			   resumetime,
-			   resumerangecnt,
-			   resumerangep,
-			   startptp,
-			   startptcnt,
-			   igrpcnt,
-			   skip_unchanged_dirs,
-			   &pruneneeded);
- 	if (rval) {
- 		free((void *)bstatbufp);
- 		return BOOL_FALSE;
- 	}
+			  lasttime,
+			  resume,
+			  resumetime,
+			  resumerangecnt,
+			  resumerangep,
+			  startptp,
+			  startptcnt,
+			  igrpcnt,
+			  skip_unchanged_dirs,
+			  &pruneneeded);
+	if (rval) {
+		free((void *)bstatbufp);
+		return BOOL_FALSE;
+	}
 
 	/*
 	 * the inode map requires that inodes are added in increasing
@@ -244,11 +244,11 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 * correct state is set in cb_add.
 	 */
 	rval = inogrp_iter(fsfd, cb_add_inogrp, NULL, &stat);
- 	if (rval || stat) {
+	if (rval || stat) {
 		cb_context_free();
- 		free((void *)bstatbufp);
- 		return BOOL_FALSE;
- 	}
+		free((void *)bstatbufp);
+		return BOOL_FALSE;
+	}
 
 	/*
 	 * construct the ino map, based on the last dump time, resumed
@@ -264,8 +264,8 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 * to decide if any pruning can be done.
 	 */
 	mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-	      "ino map phase 1: "
-	      "constructing initial dump list\n"));
+		     "ino map phase 1: "
+		     "constructing initial dump list\n"));
 
 	*inomap_statdonep = 0;
 	*inomap_statphasep = 1;
@@ -274,23 +274,23 @@ inomap_build(jdm_fshandle_t *fshandlep,
 
 	if (subtreecnt) {
 		rval = subtreelist_parse(fshandlep,
-					  fsfd,
-					  rootstatp,
-					  subtreebuf,
-					  subtreecnt);
+					 fsfd,
+					 rootstatp,
+					 subtreebuf,
+					 subtreecnt);
 	} else {
 		rval = bigstat_iter(fshandlep,
-				     fsfd,
-				     BIGSTAT_ITER_ALL,
-				     (xfs_ino_t)0,
-				     cb_add,
-				     NULL,
-				     NULL,
-				     NULL,
-				     &stat,
-				     preemptchk,
-				     bstatbufp,
-				     bstatbuflen);
+				    fsfd,
+				    BIGSTAT_ITER_ALL,
+				    (xfs_ino_t)0,
+				    cb_add,
+				    NULL,
+				    NULL,
+				    NULL,
+				    &stat,
+				    preemptchk,
+				    bstatbufp,
+				    bstatbuflen);
 	}
 	*inomap_statphasep = 0;
 	if (rval || preemptchk(PREEMPT_FULL)) {
@@ -301,13 +301,13 @@ inomap_build(jdm_fshandle_t *fshandlep,
 
 	if (inomap_exclude_filesize > 0) {
 		mlog(MLOG_NOTE | MLOG_VERBOSE, _(
-		      "pruned %llu files: maximum size exceeded\n"),
-		      inomap_exclude_filesize);
+			     "pruned %llu files: maximum size exceeded\n"),
+		     inomap_exclude_filesize);
 	}
 	if (inomap_exclude_skipattr > 0) {
 		mlog(MLOG_NOTE | MLOG_VERBOSE, _(
-		      "pruned %llu files: skip attribute set\n"),
-		      inomap_exclude_skipattr);
+			     "pruned %llu files: skip attribute set\n"),
+		     inomap_exclude_skipattr);
 	}
 
 	/*
@@ -315,20 +315,20 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 * no children needing dumping.
 	 */
 	if (pruneneeded) {
-		bool_t	rootdump = BOOL_FALSE;
+		bool_t rootdump = BOOL_FALSE;
 
 		mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-		      "ino map phase 2: "
-		      "pruning unneeded subtrees\n"));
+			     "ino map phase 2: "
+			     "pruning unneeded subtrees\n"));
 		*inomap_statdonep = 0;
 		*inomap_statpassp = 0;
 		*inomap_statphasep = 2;
 
 		(void) supprt_prune(&rootdump,
-				     fshandlep,
-				     fsfd,
-				     rootstatp,
-				     NULL);
+				    fshandlep,
+				    fsfd,
+				    rootstatp,
+				    NULL);
 		*inomap_statphasep = 0;
 
 		if (preemptchk(PREEMPT_FULL)) {
@@ -339,8 +339,8 @@ inomap_build(jdm_fshandle_t *fshandlep,
 
 	} else {
 		mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-		      "ino map phase 2: "
-		      "skipping (no pruning necessary)\n"));
+			     "ino map phase 2: "
+			     "skipping (no pruning necessary)\n"));
 	}
 
 	/*
@@ -353,28 +353,28 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	 */
 	if (startptcnt > 1) {
 		mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-		      "ino map phase 3: "
-		      "identifying stream starting points\n"));
+			     "ino map phase 3: "
+			     "identifying stream starting points\n"));
 	} else {
 		mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-		      "ino map phase 3: "
-		      "skipping (only one dump stream)\n"));
+			     "ino map phase 3: "
+			     "skipping (only one dump stream)\n"));
 	}
 	stat = 0;
 	*inomap_statdonep = 0;
 	*inomap_statphasep = 3;
 	rval = bigstat_iter(fshandlep,
-			     fsfd,
-			     BIGSTAT_ITER_NONDIR,
-			     (xfs_ino_t)0,
-			     cb_startpt,
-			     NULL,
-			     inomap_next_nondir,
-			     inomap_alloc_context(),
-			     &stat,
-			     preemptchk,
-			     bstatbufp,
-			     bstatbuflen);
+			    fsfd,
+			    BIGSTAT_ITER_NONDIR,
+			    (xfs_ino_t)0,
+			    cb_startpt,
+			    NULL,
+			    inomap_next_nondir,
+			    inomap_alloc_context(),
+			    &stat,
+			    preemptchk,
+			    bstatbufp,
+			    bstatbuflen);
 	*inomap_statphasep = 0;
 
 	if (rval) {
@@ -397,18 +397,18 @@ inomap_build(jdm_fshandle_t *fshandlep,
 			}
 			assert(! p->sp_flags);
 			mlog(MLOG_VERBOSE | MLOG_INOMAP,
-			      _("stream %u: ino %llu offset %lld to "),
-			      startptix,
-			      p->sp_ino,
-			      p->sp_offset);
+			     _("stream %u: ino %llu offset %lld to "),
+			     startptix,
+			     p->sp_ino,
+			     p->sp_offset);
 			if (! ep) {
 				mlog(MLOG_VERBOSE | MLOG_BARE | MLOG_INOMAP,
-				      _("end\n"));
+				     _("end\n"));
 			} else {
 				mlog(MLOG_VERBOSE |  MLOG_BARE | MLOG_INOMAP,
-				      _("ino %llu offset %lld\n"),
-				      ep->sp_ino,
-				      ep->sp_offset);
+				     _("ino %llu offset %lld\n"),
+				     ep->sp_ino,
+				     ep->sp_offset);
 			}
 		}
 	}
@@ -416,7 +416,7 @@ inomap_build(jdm_fshandle_t *fshandlep,
 	cb_context_free();
 	free((void *)bstatbufp);
 	mlog(MLOG_VERBOSE | MLOG_INOMAP, _(
-	      "ino map construction complete\n"));
+		     "ino map construction complete\n"));
 	return BOOL_TRUE;
 }
 
@@ -431,8 +431,8 @@ inomap_skip(xfs_ino_t ino)
 	}
 
 	if (oldstate == MAP_DIR_CHANGE
-	     ||
-	     oldstate == MAP_DIR_SUPPRT) {
+	    ||
+	    oldstate == MAP_DIR_SUPPRT) {
 		inomap_set_state(NULL, ino, MAP_DIR_NOCHNG);
 	}
 }
@@ -444,42 +444,42 @@ inomap_skip(xfs_ino_t ino)
  * callback context and operators - inomap_build makes extensive use
  * of iterators. below are the callbacks given to these iterators.
  */
-static bool_t cb_last;		/* set by cb_context() */
-static time32_t cb_lasttime;	/* set by cb_context() */
-static bool_t cb_resume;	/* set by cb_context() */
-static time32_t cb_resumetime;	/* set by cb_context() */
-static size_t cb_resumerangecnt;/* set by cb_context() */
-static drange_t *cb_resumerangep;/* set by cb_context() */
-static void *cb_inomap_contextp;/* set by cb_context() */
-static startpt_t *cb_startptp;	/* set by cb_context() */
-static size_t cb_startptcnt;	/* set by cb_context() */
-static size_t cb_startptix;	/* set by cb_spinit(), incr. by cb_startpt */
-static off64_t cb_datasz;	/* set by cb_context() */
-static off64_t cb_hdrsz;	/* set by cb_context() */
-static off64_t cb_accum;	/* set by cb_context(), cb_spinit() */
-static off64_t cb_incr;		/* set by cb_spinit(), used by cb_startpt() */
-static off64_t cb_target;	/* set by cb_spinit(), used by cb_startpt() */
-static off64_t cb_dircnt;	/* number of dirs CHANGED or PRUNE */
-static off64_t cb_nondircnt;	/* number of non-dirs CHANGED */
-static bool_t *cb_pruneneededp; /* set by cb_context() */
-static bool_t cb_skip_unchanged_dirs;	/* set by cb_context() */
+static bool_t cb_last;                  /* set by cb_context() */
+static time32_t cb_lasttime;            /* set by cb_context() */
+static bool_t cb_resume;                /* set by cb_context() */
+static time32_t cb_resumetime;          /* set by cb_context() */
+static size_t cb_resumerangecnt;        /* set by cb_context() */
+static drange_t *cb_resumerangep;       /* set by cb_context() */
+static void *cb_inomap_contextp;        /* set by cb_context() */
+static startpt_t *cb_startptp;          /* set by cb_context() */
+static size_t cb_startptcnt;            /* set by cb_context() */
+static size_t cb_startptix;             /* set by cb_spinit(), incr. by cb_startpt */
+static off64_t cb_datasz;               /* set by cb_context() */
+static off64_t cb_hdrsz;                /* set by cb_context() */
+static off64_t cb_accum;                /* set by cb_context(), cb_spinit() */
+static off64_t cb_incr;                 /* set by cb_spinit(), used by cb_startpt() */
+static off64_t cb_target;               /* set by cb_spinit(), used by cb_startpt() */
+static off64_t cb_dircnt;               /* number of dirs CHANGED or PRUNE */
+static off64_t cb_nondircnt;            /* number of non-dirs CHANGED */
+static bool_t *cb_pruneneededp;         /* set by cb_context() */
+static bool_t cb_skip_unchanged_dirs;   /* set by cb_context() */
 
 /*
  * cb_context - initializes the call back context for the add and prune
  * phases of inomap_build().
  */
 static int
-cb_context(bool_t last,
-	    time32_t lasttime,
-	    bool_t resume,
-	    time32_t resumetime,
-	    size_t resumerangecnt,
-	    drange_t *resumerangep,
-	    startpt_t *startptp,
-	    size_t startptcnt,
-	    int igrpcnt,
-	    bool_t skip_unchanged_dirs,
-	    bool_t *pruneneededp)
+cb_context(bool_t	last,
+	   time32_t	lasttime,
+	   bool_t	resume,
+	   time32_t	resumetime,
+	   size_t	resumerangecnt,
+	   drange_t *	resumerangep,
+	   startpt_t *	startptp,
+	   size_t	startptcnt,
+	   int		igrpcnt,
+	   bool_t	skip_unchanged_dirs,
+	   bool_t *	pruneneededp)
 {
 	cb_last = last;
 	cb_lasttime = lasttime;
@@ -499,7 +499,7 @@ cb_context(bool_t last,
 		return -1;
 
 	cb_inomap_contextp = inomap_alloc_context();
-	if (!cb_inomap_contextp)
+	if (! cb_inomap_contextp)
 		return -1;
 
 	return 0;
@@ -527,10 +527,10 @@ cb_count_inogrp(void *arg1, int fsfd, xfs_inogrp_t *inogrp)
  */
 /* ARGSUSED */
 static int
-cb_add(void *arg1,
-	jdm_fshandle_t *fshandlep,
-	int fsfd,
-	xfs_bstat_t *statp)
+cb_add(void *		arg1,
+       jdm_fshandle_t * fshandlep,
+       int		fsfd,
+       xfs_bstat_t *	statp)
 {
 	register time32_t mtime = statp->bs_mtime.tv_sec;
 	register time32_t ctime = statp->bs_ctime.tv_sec;
@@ -589,9 +589,9 @@ cb_add(void *arg1,
 	if (changed) {
 		if (mode == S_IFDIR) {
 			inomap_add(cb_inomap_contextp,
-				    ino,
-				    (gen_t)statp->bs_gen,
-				    MAP_DIR_CHANGE);
+				   ino,
+				   (gen_t)statp->bs_gen,
+				   MAP_DIR_CHANGE);
 			cb_dircnt++;
 		} else {
 			estimated_size = estimate_dump_space(statp);
@@ -601,39 +601,39 @@ cb_add(void *arg1,
 			 * files are exempt from the check.
 			 */
 			if (maxdumpfilesize > 0 &&
-			     estimated_size > maxdumpfilesize &&
-			     !is_quota_file(statp->bs_ino)) {
+			    estimated_size > maxdumpfilesize &&
+			    ! is_quota_file(statp->bs_ino)) {
 				mlog(MLOG_DEBUG | MLOG_EXCLFILES,
-				      "pruned ino %llu, owner %u, estimated size %llu: maximum size exceeded\n",
-				      statp->bs_ino,
-				      statp->bs_uid,
-				      estimated_size);
+				     "pruned ino %llu, owner %u, estimated size %llu: maximum size exceeded\n",
+				     statp->bs_ino,
+				     statp->bs_uid,
+				     estimated_size);
 				inomap_add(cb_inomap_contextp,
-					    ino,
-					    (gen_t)statp->bs_gen,
-					    MAP_NDR_NOCHNG);
+					   ino,
+					   (gen_t)statp->bs_gen,
+					   MAP_NDR_NOCHNG);
 				inomap_exclude_filesize++;
 				return 0;
 			}
 
 			if (allowexcludefiles_pr && statp->bs_xflags & XFS_XFLAG_NODUMP) {
 				mlog(MLOG_DEBUG | MLOG_EXCLFILES,
-				      "pruned ino %llu, owner %u, estimated size %llu: skip flag set\n",
-				      statp->bs_ino,
-				      statp->bs_uid,
-				      estimated_size);
+				     "pruned ino %llu, owner %u, estimated size %llu: skip flag set\n",
+				     statp->bs_ino,
+				     statp->bs_uid,
+				     estimated_size);
 				inomap_add(cb_inomap_contextp,
-					    ino,
-					    (gen_t)statp->bs_gen,
-					    MAP_NDR_NOCHNG);
+					   ino,
+					   (gen_t)statp->bs_gen,
+					   MAP_NDR_NOCHNG);
 				inomap_exclude_skipattr++;
 				return 0;
 			}
 
 			inomap_add(cb_inomap_contextp,
-				    ino,
-				    (gen_t)statp->bs_gen,
-				    MAP_NDR_CHANGE);
+				   ino,
+				   (gen_t)statp->bs_gen,
+				   MAP_NDR_CHANGE);
 			cb_nondircnt++;
 			cb_datasz += estimated_size;
 			cb_hdrsz += (EXTENTHDR_SZ * (statp->bs_extents + 1));
@@ -645,22 +645,22 @@ cb_add(void *arg1,
 		if (mode == S_IFDIR) {
 			if (cb_skip_unchanged_dirs) {
 				inomap_add(cb_inomap_contextp,
-					    ino,
-					    (gen_t)statp->bs_gen,
-					    MAP_DIR_NOCHNG);
+					   ino,
+					   (gen_t)statp->bs_gen,
+					   MAP_DIR_NOCHNG);
 			} else {
 				*cb_pruneneededp = BOOL_TRUE;
 				inomap_add(cb_inomap_contextp,
-					    ino,
-					    (gen_t)statp->bs_gen,
-					    MAP_DIR_SUPPRT);
+					   ino,
+					   (gen_t)statp->bs_gen,
+					   MAP_DIR_SUPPRT);
 				cb_dircnt++;
 			}
 		} else {
 			inomap_add(cb_inomap_contextp,
-				    ino,
-				    (gen_t)statp->bs_gen,
-				    MAP_NDR_NOCHNG);
+				   ino,
+				   (gen_t)statp->bs_gen,
+				   MAP_NDR_NOCHNG);
 		}
 	}
 
@@ -674,17 +674,17 @@ cb_inoinresumerange(xfs_ino_t ino)
 
 	for (streamix = 0; streamix < cb_resumerangecnt; streamix++) {
 		register drange_t *rp = &cb_resumerangep[streamix];
-		if (! (rp->dr_begin.sp_flags & STARTPT_FLAGS_END)
-		     &&
-		     ino >= rp->dr_begin.sp_ino
-		     &&
-		     ((rp->dr_end.sp_flags & STARTPT_FLAGS_END)
-		       ||
-		       ino < rp->dr_end.sp_ino
-		       ||
-		       (ino == rp->dr_end.sp_ino
-			 &&
-			 rp->dr_end.sp_offset != 0))) {
+		if (!(rp->dr_begin.sp_flags & STARTPT_FLAGS_END)
+		    &&
+		    ino >= rp->dr_begin.sp_ino
+		    &&
+		    ((rp->dr_end.sp_flags & STARTPT_FLAGS_END)
+		     ||
+		     ino < rp->dr_end.sp_ino
+		     ||
+		     (ino == rp->dr_end.sp_ino
+		      &&
+		      rp->dr_end.sp_offset != 0))) {
 			return BOOL_TRUE;
 		}
 	}
@@ -699,11 +699,11 @@ cb_inoresumed(xfs_ino_t ino)
 
 	for (streamix = 0; streamix < cb_resumerangecnt; streamix++) {
 		drange_t *rp = &cb_resumerangep[streamix];
-		if (! (rp->dr_begin.sp_flags & STARTPT_FLAGS_END)
-		     &&
-		     ino == rp->dr_begin.sp_ino
-		     &&
-		     rp->dr_begin.sp_offset != 0) {
+		if (!(rp->dr_begin.sp_flags & STARTPT_FLAGS_END)
+		    &&
+		    ino == rp->dr_begin.sp_ino
+		    &&
+		    rp->dr_begin.sp_offset != 0) {
 			return BOOL_TRUE;
 		}
 	}
@@ -717,12 +717,12 @@ cb_inoresumed(xfs_ino_t ino)
  * (-> nochng) on the way back up after examining all descendents.
  */
 /* ARGSUSED */
-static bool_t			/* false, used as diriter callback */
-supprt_prune(void *arg1,	/* ancestors marked as changed? */
-	      jdm_fshandle_t *fshandlep,
-	      int fsfd,
-	      xfs_bstat_t *statp,
-	      char *name)
+static bool_t                           /* false, used as diriter callback */
+supprt_prune(void *		arg1,   /* ancestors marked as changed? */
+	     jdm_fshandle_t *	fshandlep,
+	     int		fsfd,
+	     xfs_bstat_t *	statp,
+	     char *		name)
 {
 	static bool_t cbrval = BOOL_FALSE;
 	int state;
@@ -732,33 +732,33 @@ supprt_prune(void *arg1,	/* ancestors marked as changed? */
 
 		state = inomap_get_state(cb_inomap_contextp, statp->bs_ino);
 		if (state != MAP_DIR_CHANGE &&
-                     state != MAP_DIR_NOCHNG &&
-		     state != MAP_DIR_SUPPRT) {
+		    state != MAP_DIR_NOCHNG &&
+		    state != MAP_DIR_SUPPRT) {
 			/*
 			 * if file is now a dir then it has
 			 * certainly changed.
 			 */
 			state = MAP_DIR_CHANGE;
 			inomap_set_state(cb_inomap_contextp,
-					  statp->bs_ino,
-					  state);
+					 statp->bs_ino,
+					 state);
 		}
 
 		(void)diriter(fshandlep,
-				 fsfd,
-				 statp,
-				 supprt_prune,
-				 (void *)&changed_below,
-				 &cbrval,
-				 NULL,
-				 0);
+			      fsfd,
+			      statp,
+			      supprt_prune,
+			      (void *)&changed_below,
+			      &cbrval,
+			      NULL,
+			      0);
 
 		if (state == MAP_DIR_SUPPRT) {
 			if (changed_below == BOOL_FALSE) {
 				inomap_set_state(cb_inomap_contextp,
-						  statp->bs_ino,
-						  MAP_DIR_NOCHNG);
-				cb_dircnt--;	/* dump size just changed! */
+						 statp->bs_ino,
+						 MAP_DIR_NOCHNG);
+				cb_dircnt--;    /* dump size just changed! */
 			}
 			else {
 				/* Directory entries back up the hierarchy */
@@ -781,7 +781,7 @@ supprt_prune(void *arg1,	/* ancestors marked as changed? */
 
 	state = inomap_get_state(cb_inomap_contextp, statp->bs_ino);
 	if (state != MAP_NDR_CHANGE &&
-	     state != MAP_NDR_NOCHNG) {
+	    state != MAP_NDR_NOCHNG) {
 		/*
 		 * if dir is now a file then it has
 		 * certainly changed.
@@ -829,28 +829,28 @@ cb_spinit(void)
  * or split the file between the old and new streams. in the case of
  * a split decision, always split at a BBSIZE boundary.
  */
-#define TOO_SHY		1000000	/* max accept. accum short of target */
-#define TOO_BOLD	1000000	/* max accept. accum beyond target */
+#define TOO_SHY         1000000 /* max accept. accum short of target */
+#define TOO_BOLD        1000000 /* max accept. accum beyond target */
 
 typedef enum {
-	HOLD,	/* don't change */
-	BUMP,	/* set a new start point and put this file after it */
-	SPLIT,	/* set a new start point and split this file across it */
-	YELL	/* impossible condition; complain */
+	HOLD,   /* don't change */
+	BUMP,   /* set a new start point and put this file after it */
+	SPLIT,  /* set a new start point and split this file across it */
+	YELL    /* impossible condition; complain */
 } action_t;
 
 /* ARGSUSED */
 static int
-cb_startpt(void *arg1,
-	    jdm_fshandle_t *fshandlep,
-	    int fsfd,
-	    xfs_bstat_t *statp)
+cb_startpt(void *		arg1,
+	   jdm_fshandle_t *	fshandlep,
+	   int			fsfd,
+	   xfs_bstat_t *	statp)
 {
 	register int state;
 
 	off64_t estimate;
 	off64_t old_accum = cb_accum;
-	off64_t qty;	/* amount of a SPLIT file to skip */
+	off64_t qty;    /* amount of a SPLIT file to skip */
 	action_t action;
 
 	(*inomap_statdonep)++;
@@ -927,7 +927,7 @@ cb_startpt(void *arg1,
 				action = (action_t)HOLD;
 			} else if (cb_accum - cb_target < TOO_BOLD) {
 				if (cb_accum - cb_target >=
-						      cb_target - old_accum) {
+				    cb_target - old_accum) {
 					action = (action_t)BUMP;
 				} else {
 					action = (action_t)HOLD;
@@ -959,9 +959,9 @@ cb_startpt(void *arg1,
 			      &
 			      ~(off64_t)(BBSIZE - 1);
 			cb_startptp->sp_offset =
-					quantity2offset(fshandlep,
-							 statp,
-							 qty);
+				quantity2offset(fshandlep,
+						statp,
+						qty);
 			cb_startptix++;
 			cb_startptp++;
 			cb_target += cb_incr;
@@ -986,22 +986,22 @@ cb_startpt(void *arg1,
  * define structure for ino to gen mapping.
  */
 struct i2gseg {
-	uint64_t s_valid;
-	gen_t s_gen[INOPERSEG];
+	uint64_t	s_valid;
+	gen_t		s_gen[INOPERSEG];
 };
 typedef struct i2gseg i2gseg_t;
 
 typedef struct seg_addr {
-	int hnkoff;
-	int segoff;
-	int inooff;
+	int	hnkoff;
+	int	segoff;
+	int	inooff;
 } seg_addr_t;
 
 static struct inomap {
-	hnk_t *hnkmap;
-	int hnkmaplen;
-	i2gseg_t *i2gmap;
-	seg_addr_t lastseg;
+	hnk_t *		hnkmap;
+	int		hnkmaplen;
+	i2gseg_t *	i2gmap;
+	seg_addr_t	lastseg;
 } inomap;
 
 static inline void
@@ -1096,8 +1096,8 @@ inomap_init(int igrpcnt)
 	inomap.hnkmaplen = (igrpcnt + SEGPERHNK - 1) / SEGPERHNK;
 	inomap.hnkmap = (hnk_t *)malloc(inomap.hnkmaplen * HNKSZ);
 	inomap.i2gmap = (i2gseg_t *)
-		calloc(inomap.hnkmaplen * SEGPERHNK, sizeof(i2gseg_t));
-	if (!inomap.hnkmap || !inomap.i2gmap)
+			calloc(inomap.hnkmaplen * SEGPERHNK, sizeof(i2gseg_t));
+	if (! inomap.hnkmap || ! inomap.i2gmap)
 		return -1;
 	return 0;
 }
@@ -1117,7 +1117,7 @@ inomap_validaddr(seg_addr_t *addrp)
 		return BOOL_FALSE;
 
 	maxseg = (addrp->hnkoff == inomap.lastseg.hnkoff) ?
-			inomap.lastseg.segoff : SEGPERHNK - 1;
+		 inomap.lastseg.segoff : SEGPERHNK - 1;
 
 	if (addrp->segoff < 0 || addrp->segoff > maxseg)
 		return BOOL_FALSE;
@@ -1175,15 +1175,15 @@ cb_add_inogrp(void *arg1, int fsfd, xfs_inogrp_t *inogrp)
 
 			inomap.hnkmaplen++;
 			inomap.hnkmap = (hnk_t *)
-				realloc(inomap.hnkmap, inomap.hnkmaplen * HNKSZ);
+					realloc(inomap.hnkmap, inomap.hnkmaplen * HNKSZ);
 
 			numsegs = inomap.hnkmaplen * SEGPERHNK;
 			if (numsegs < 0)
 				return -1;
 			inomap.i2gmap = (i2gseg_t *)
-				realloc(inomap.i2gmap, numsegs * sizeof(i2gseg_t));
+					realloc(inomap.i2gmap, numsegs * sizeof(i2gseg_t));
 
-			if (!inomap.hnkmap || !inomap.i2gmap)
+			if (! inomap.hnkmap || ! inomap.i2gmap)
 				return -1;
 
 			/* zero the new portion of the i2gmap */
@@ -1217,10 +1217,10 @@ void *
 inomap_alloc_context(void)
 {
 	void *addr = calloc(1, sizeof(seg_addr_t));
-	if (!addr) {
+	if (! addr) {
 		mlog(MLOG_NORMAL | MLOG_ERROR,
-		      _("failed to allocate inomap context: %s\n"),
-		      strerror(errno));
+		     _("failed to allocate inomap context: %s\n"),
+		     strerror(errno));
 	}
 	return addr;
 }
@@ -1281,11 +1281,11 @@ inomap_find_seg(seg_addr_t *addrp, xfs_ino_t ino)
 	int lower;
 	int upper;
 
-	if (!inomap_validaddr(addrp) ) {
+	if (! inomap_validaddr(addrp) ) {
 		inomap_reset_context(addrp);
 	}
 
-	if (!inomap_find_hnk(addrp, ino) )
+	if (! inomap_find_hnk(addrp, ino) )
 		return BOOL_FALSE;
 
 	/* find the correct segment */
@@ -1317,12 +1317,12 @@ inomap_iter(void *contextp, int statemask)
 	seg_addr_t *addrp = (seg_addr_t *)contextp;
 
 	for (;
-	      addrp->hnkoff <= inomap.lastseg.hnkoff;
-	      addrp->hnkoff++, addrp->segoff = 0, addrp->inooff = 0) {
+	     addrp->hnkoff <= inomap.lastseg.hnkoff;
+	     addrp->hnkoff++, addrp->segoff = 0, addrp->inooff = 0) {
 
 		for (;
-		      addrp->segoff <= inomap_lastseg(addrp->hnkoff);
-		      addrp->segoff++, addrp->inooff = 0) {
+		     addrp->segoff <= inomap_lastseg(addrp->hnkoff);
+		     addrp->segoff++, addrp->inooff = 0) {
 
 			segp = inomap_addr2seg(addrp);
 
@@ -1377,7 +1377,7 @@ inomap_set_state(void *contextp, xfs_ino_t ino, int state)
 	seg_t *segp;
 
 	addrp = contextp ? (seg_addr_t *)contextp : &addr;
-	if (!inomap_find_seg(addrp, ino) )
+	if (! inomap_find_seg(addrp, ino) )
 		return MAP_INO_UNUSED;
 
 	segp = inomap_addr2seg(addrp);
@@ -1396,7 +1396,7 @@ inomap_get_state(void *contextp, xfs_ino_t ino)
 	seg_t *segp;
 
 	addrp = contextp ? (seg_addr_t *)contextp : &addr;
-	if (!inomap_find_seg(addrp, ino) )
+	if (! inomap_find_seg(addrp, ino) )
 		return MAP_INO_UNUSED;
 
 	segp = inomap_addr2seg(addrp);
@@ -1414,7 +1414,7 @@ inomap_set_gen(void *contextp, xfs_ino_t ino, gen_t gen)
 	xfs_ino_t relino;
 
 	addrp = contextp ? (seg_addr_t *)contextp : &addr;
-	if (!inomap_find_seg(addrp, ino) )
+	if (! inomap_find_seg(addrp, ino) )
 		return;
 
 	segp = inomap_addr2seg(addrp);
@@ -1435,14 +1435,14 @@ inomap_get_gen(void *contextp, xfs_ino_t ino, gen_t *gen)
 	xfs_ino_t relino;
 
 	addrp = contextp ? (seg_addr_t *)contextp : &addr;
-	if (!inomap_find_seg(addrp, ino) )
+	if (! inomap_find_seg(addrp, ino) )
 		return 1;
 
 	segp = inomap_addr2seg(addrp);
 	i2gsegp = &inomap.i2gmap[inomap_addr2segix(addrp)];
 
 	relino = ino - segp->base;
-	if (! (i2gsegp->s_valid & ((uint64_t)1 << relino)))
+	if (!(i2gsegp->s_valid & ((uint64_t)1 << relino)))
 		return 1;
 
 	*gen = i2gsegp->s_gen[relino];
@@ -1475,8 +1475,8 @@ inomap_dump(drive_t *drivep)
 	 * use write_buf to dump the hunks
 	 */
 	for (addr.hnkoff = 0;
-	      addr.hnkoff <= inomap.lastseg.hnkoff;
-	      addr.hnkoff++) {
+	     addr.hnkoff <= inomap.lastseg.hnkoff;
+	     addr.hnkoff++) {
 		int rval;
 		rv_t rv;
 		drive_ops_t *dop = drivep->d_opsp;
@@ -1485,10 +1485,10 @@ inomap_dump(drive_t *drivep)
 
 		xlate_hnk(hnkp, &tmphnkp, 1);
 		rval = write_buf((char *)&tmphnkp,
-				  sizeof(tmphnkp),
-				  (void *)drivep,
-				  (gwbfp_t)dop->do_get_write_buf,
-				  (wfp_t)dop->do_write);
+				 sizeof(tmphnkp),
+				 (void *)drivep,
+				 (gwbfp_t)dop->do_get_write_buf,
+				 (wfp_t)dop->do_write);
 		switch (rval) {
 		case 0:
 			rv = RV_OK;
@@ -1517,11 +1517,11 @@ inomap_dump(drive_t *drivep)
 }
 
 static int
-subtreelist_parse(jdm_fshandle_t *fshandlep,
-		   int fsfd,
-		   xfs_bstat_t *rootstatp,
-		   char *subtreebuf[],
-		   ix_t subtreecnt)
+subtreelist_parse(jdm_fshandle_t *	fshandlep,
+		  int			fsfd,
+		  xfs_bstat_t *		rootstatp,
+		  char *		subtreebuf[],
+		  ix_t			subtreecnt)
 {
 	ix_t subtreeix;
 
@@ -1538,19 +1538,19 @@ subtreelist_parse(jdm_fshandle_t *fshandlep,
 		char *currentpath = subtreebuf[subtreeix];
 		assert(*currentpath != '/');
 		(void)diriter(fshandlep,
-				 fsfd,
-				 rootstatp,
-				 subtreelist_parse_cb,
-				 (void *)currentpath,
-				 &cbrval,
-				 NULL,
-				 0);
+			      fsfd,
+			      rootstatp,
+			      subtreelist_parse_cb,
+			      (void *)currentpath,
+			      &cbrval,
+			      NULL,
+			      0);
 		if (cbrval != 1) {
 			mlog(MLOG_NORMAL | MLOG_ERROR | MLOG_INOMAP,
-			      "%s: %s\n",
-			      cbrval == 0 ? _("subtree not present")
-					  : _("invalid subtree specified"),
-			      currentpath);
+			     "%s: %s\n",
+			     cbrval == 0 ? _("subtree not present")
+			     : _("invalid subtree specified"),
+			     currentpath);
 			return -1;
 		}
 	}
@@ -1559,11 +1559,11 @@ subtreelist_parse(jdm_fshandle_t *fshandlep,
 }
 
 static int
-subtreelist_parse_cb(void *arg1,
-		      jdm_fshandle_t *fshandlep,
-		      int fsfd,
-		      xfs_bstat_t *statp,
-		      char *name)
+subtreelist_parse_cb(void *		arg1,
+		     jdm_fshandle_t *	fshandlep,
+		     int		fsfd,
+		     xfs_bstat_t *	statp,
+		     char *		name)
 {
 	int cbrval = 0;
 
@@ -1610,20 +1610,20 @@ subtreelist_parse_cb(void *arg1,
 
 		/*
 		 * repair the subpath
-		*/
+		 */
 		*nextslash = '/';
 
 		/*
 		 * peel the first element of the subpath and recurse
-		*/
+		 */
 		(void)diriter(fshandlep,
-				 fsfd,
-				 statp,
-				 subtreelist_parse_cb,
-				 (void *)(nextslash + 1),
-				 &cbrval,
-				 NULL,
-				 0);
+			      fsfd,
+			      statp,
+			      subtreelist_parse_cb,
+			      (void *)(nextslash + 1),
+			      &cbrval,
+			      NULL,
+			      0);
 		return cbrval;
 
 	} else {
@@ -1638,23 +1638,23 @@ subtreelist_parse_cb(void *arg1,
 		}
 
 		(void)diriter(fshandlep,
-				 fsfd,
-				 statp,
-				 subtree_descend_cb,
-				 NULL,
-				 &cbrval,
-				 0,
-				 0);
+			      fsfd,
+			      statp,
+			      subtree_descend_cb,
+			      NULL,
+			      &cbrval,
+			      0,
+			      0);
 		return 1;
 	}
 }
 
 static int
-subtree_descend_cb(void *arg1,
-		    jdm_fshandle_t *fshandlep,
-		    int fsfd,
-		    xfs_bstat_t *statp,
-		    char *name)
+subtree_descend_cb(void *		arg1,
+		   jdm_fshandle_t *	fshandlep,
+		   int			fsfd,
+		   xfs_bstat_t *	statp,
+		   char *		name)
 {
 	int cbrval = 0;
 
@@ -1663,13 +1663,13 @@ subtree_descend_cb(void *arg1,
 	if ((statp->bs_mode & S_IFMT) == S_IFDIR) {
 
 		(void)diriter(fshandlep,
-				 fsfd,
-				 statp,
-				 subtree_descend_cb,
-				 NULL,
-				 &cbrval,
-				 NULL,
-				 0);
+			      fsfd,
+			      statp,
+			      subtree_descend_cb,
+			      NULL,
+			      &cbrval,
+			      NULL,
+			      0);
 	}
 
 	return cbrval;
@@ -1679,7 +1679,7 @@ subtree_descend_cb(void *arg1,
  * uses the extent map to figure the first offset in the file
  * with qty real (non-hole) bytes behind it
  */
-#define BMAP_LEN	512
+#define BMAP_LEN        512
 
 static off64_t
 quantity2offset(jdm_fshandle_t *fshandlep, xfs_bstat_t *statp, off64_t qty)
@@ -1711,9 +1711,9 @@ quantity2offset(jdm_fshandle_t *fshandlep, xfs_bstat_t *statp, off64_t qty)
 	fd = jdm_open(fshandlep, statp, O_RDONLY);
 	if (fd < 0) {
 		mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_INOMAP, _(
-		      "could not open ino %llu to read extent map: %s\n"),
-		      statp->bs_ino,
-		      strerror(errno));
+			     "could not open ino %llu to read extent map: %s\n"),
+		     statp->bs_ino,
+		     strerror(errno));
 		return 0;
 	}
 
@@ -1724,9 +1724,9 @@ quantity2offset(jdm_fshandle_t *fshandlep, xfs_bstat_t *statp, off64_t qty)
 		rval = ioctl(fd, XFS_IOC_GETBMAPX, bmap);
 		if (rval) {
 			mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_INOMAP, _(
-			      "could not read extent map for ino %llu: %s\n"),
-			      statp->bs_ino,
-			      strerror(errno));
+				     "could not read extent map for ino %llu: %s\n"),
+			     statp->bs_ino,
+			     strerror(errno));
 			(void)close(fd);
 			return 0;
 		}
@@ -1767,7 +1767,7 @@ estimate_dump_space(xfs_bstat_t *statp)
 		 * specified and the HSM provided an estimate, then use it.
 		 */
 		if (hsm_fs_ctxtp) {
-			off64_t	bytes;
+			off64_t bytes;
 			int accurate;
 
 			/*
@@ -1790,17 +1790,17 @@ estimate_dump_space(xfs_bstat_t *statp)
 	case S_IFBLK:
 	case S_IFSOCK:
 	case S_IFLNK:
-	/*
-	 * not yet
-	case S_IFUUID:
-	*/
+		/*
+		 * not yet
+		   case S_IFUUID:
+		 */
 		return 0;
 	default:
 		mlog(MLOG_NORMAL | MLOG_WARNING | MLOG_INOMAP, _(
-		      "unknown inode type: ino=%llu, mode=0x%04x 0%06o\n"),
-		      statp->bs_ino,
-		      statp->bs_mode,
-		      statp->bs_mode);
+			     "unknown inode type: ino=%llu, mode=0x%04x 0%06o\n"),
+		     statp->bs_ino,
+		     statp->bs_mode,
+		     statp->bs_mode);
 		return 0;
 	}
 }
diff --git a/dump/inomap.h b/dump/inomap.h
index b9619f6..2ae6b71 100644
--- a/dump/inomap.h
+++ b/dump/inomap.h
@@ -49,24 +49,24 @@ struct xfs_bstat;
  * fall at file boundaries. returns BOOL_FALSE if error encountered (should
  * abort the dump; else returns BOOL_TRUE.
  */
-extern bool_t inomap_build(void *fshandlep,
-			    int fsfd,
-			    struct xfs_bstat *rootstatp,
-			    bool_t last,
-	      		    time32_t lasttime,
-			    bool_t resume,
-	      		    time32_t resumetime,
-			    size_t resumerangecnt,
-			    drange_t *resumerangep,
-			    char *subtreebuf[],
-			    ix_t subtreecnt,
-			    bool_t skip_unchanged_dirs,
-			    startpt_t startptp[],
-	      		    size_t startptcnt,
-			    ix_t *statphasep,
-			    ix_t *statpassp,
-			    size64_t statcnt,
-			    size64_t *statdonep);
+extern bool_t inomap_build(void *		fshandlep,
+			   int			fsfd,
+			   struct xfs_bstat *	rootstatp,
+			   bool_t		last,
+			   time32_t		lasttime,
+			   bool_t		resume,
+			   time32_t		resumetime,
+			   size_t		resumerangecnt,
+			   drange_t *		resumerangep,
+			   char *		subtreebuf[],
+			   ix_t			subtreecnt,
+			   bool_t		skip_unchanged_dirs,
+			   startpt_t		startptp[],
+			   size_t		startptcnt,
+			   ix_t *		statphasep,
+			   ix_t *		statpassp,
+			   size64_t		statcnt,
+			   size64_t *		statdonep);
 
 extern uint64_t inomap_getsz(void);
 
@@ -94,14 +94,14 @@ extern rv_t inomap_dump(drive_t *drivep);
 /*
  * map state values
  */
-#define MAP_INO_UNUSED	0       /* ino not in use by fs */
-#define MAP_DIR_NOCHNG	1       /* dir, ino in use by fs, but not dumped */
-#define MAP_NDR_NOCHNG	2       /* non-dir, ino in use by fs, but not dumped */
-#define MAP_DIR_CHANGE	3       /* dir, changed since last dump */
-#define MAP_NDR_CHANGE	4       /* non-dir, changed since last dump */
-#define MAP_DIR_SUPPRT	5       /* dir, unchanged but needed for hierarchy */
-#define MAP_RESERVED1	6       /* this state currently not used */
-#define MAP_RESERVED2	7       /* this state currently not used */
+#define MAP_INO_UNUSED  0       /* ino not in use by fs */
+#define MAP_DIR_NOCHNG  1       /* dir, ino in use by fs, but not dumped */
+#define MAP_NDR_NOCHNG  2       /* non-dir, ino in use by fs, but not dumped */
+#define MAP_DIR_CHANGE  3       /* dir, changed since last dump */
+#define MAP_NDR_CHANGE  4       /* non-dir, changed since last dump */
+#define MAP_DIR_SUPPRT  5       /* dir, unchanged but needed for hierarchy */
+#define MAP_RESERVED1   6       /* this state currently not used */
+#define MAP_RESERVED2   7       /* this state currently not used */
 
 /*
  * the inomap is implemented as a linked list of chunks. each chunk contains
@@ -110,24 +110,24 @@ extern rv_t inomap_dump(drive_t *drivep);
  * index and manipulate the 3-bit state values.
  */
 struct seg {
-	xfs_ino_t base;
-	uint64_t lobits;
-	uint64_t mebits;
-	uint64_t hibits;
+	xfs_ino_t	base;
+	uint64_t	lobits;
+	uint64_t	mebits;
+	uint64_t	hibits;
 };
 
 typedef struct seg seg_t;
 
-#define INOPERSEG	(sizeof(((seg_t *)0)->lobits) * NBBY)
+#define INOPERSEG       (sizeof(((seg_t *)0)->lobits) * NBBY)
 
-#define HNKSZ		(4 * PGSZ)
-#define SEGPERHNK	((HNKSZ / sizeof(seg_t)) - 1)
+#define HNKSZ           (4 * PGSZ)
+#define SEGPERHNK       ((HNKSZ / sizeof(seg_t)) - 1)
 
 struct hnk {
-	seg_t seg[SEGPERHNK];
-	xfs_ino_t maxino;
-	struct hnk *nextp;		/* no longer used, kept for binary compat */
-	char pad[sizeof(seg_t) - sizeof(xfs_ino_t) - sizeof(struct hnk *)];
+	seg_t		seg[SEGPERHNK];
+	xfs_ino_t	maxino;
+	struct hnk *	nextp;          /* no longer used, kept for binary compat */
+	char		pad[sizeof(seg_t) - sizeof(xfs_ino_t) - sizeof(struct hnk *)];
 };
 
 typedef struct hnk hnk_t;
diff --git a/dump/var.c b/dump/var.c
index a195693..47ec9fa 100644
--- a/dump/var.c
+++ b/dump/var.c
@@ -66,14 +66,14 @@ var_create_component(char *path)
 
 	if (rval && errno != EEXIST) {
 		mlog(MLOG_NORMAL, _("unable to create %s: %s\n"),
-		      path, strerror(errno));
+		     path, strerror(errno));
 		return 0;
 	}
 	if (rval == 0) {
 		rval = chown(path, 0, 0);
 		if (rval) {
 			mlog(MLOG_NORMAL, _("unable to chown %s: %s\n"),
-			      path, strerror(errno));
+			     path, strerror(errno));
 		}
 	}
 	return 1;
@@ -91,13 +91,13 @@ var_skip(uuid_t *dumped_fsidp, void (*cb)(xfs_ino_t ino))
 	rval = fs_getid(XFSDUMP_DIRPATH, &fsid);
 	if (rval) {
 #ifdef HIDDEN
-                /* NOTE: this will happen for non-XFS file systems */
-                /*       and is expected, so no msg */
+		/* NOTE: this will happen for non-XFS file systems */
+		/*       and is expected, so no msg */
 		mlog(MLOG_NORMAL, _(
-		      "unable to determine uuid of fs containing %s: "
-		      "%s\n"),
-		      XFSDUMP_DIRPATH,
-		      strerror(errno));
+			     "unable to determine uuid of fs containing %s: "
+			     "%s\n"),
+		     XFSDUMP_DIRPATH,
+		     strerror(errno));
 #endif
 		return;
 	}
@@ -124,15 +124,15 @@ var_skip_recurse(char *base, void (*cb)(xfs_ino_t ino))
 	rval = lstat64(base, &statbuf);
 	if (rval) {
 		mlog(MLOG_NORMAL, _(
-		      "unable to get status of %s: %s\n"),
-		      base,
-		      strerror(errno));
+			     "unable to get status of %s: %s\n"),
+		     base,
+		     strerror(errno));
 		return;
 	}
 
 	mlog(MLOG_DEBUG,
-	      "excluding %s from dump\n",
-	      base);
+	     "excluding %s from dump\n",
+	     base);
 
 	(*cb)(statbuf.st_ino);
 
@@ -143,8 +143,8 @@ var_skip_recurse(char *base, void (*cb)(xfs_ino_t ino))
 	dirp = opendir(base);
 	if (! dirp) {
 		mlog(MLOG_NORMAL, _(
-		      "unable to open directory %s\n"),
-		      base);
+			     "unable to open directory %s\n"),
+		     base);
 		return;
 	}
 
@@ -155,12 +155,12 @@ var_skip_recurse(char *base, void (*cb)(xfs_ino_t ino))
 		 * skip "." and ".."
 		 */
 		if (*(direntp->d_name + 0) == '.'
-		     &&
-		     (*(direntp->d_name + 1) == 0
-		       ||
-		       (*(direntp->d_name + 1) == '.'
-			 &&
-			 *(direntp->d_name + 2) == 0))) {
+		    &&
+		    (*(direntp->d_name + 1) == 0
+		     ||
+		     (*(direntp->d_name + 1) == '.'
+		      &&
+		      *(direntp->d_name + 2) == 0))) {
 			continue;
 		}
 
