restore/inomap.c - pub/scm/fs/xfs/xfsdump-dev - Git at Google

 /*
  * Copyright (c) 2000-2001 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */

 #include <xfs/xfs.h>
 #include <xfs/jdm.h>

 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <time.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <time.h>
 #include <assert.h>
 #include <string.h>

 #include "config.h"

 #include "types.h"
 #include "util.h"
 #include "openutil.h"
 #include "mlog.h"
 #include "global.h"
 #include "drive.h"
 #include "media.h"
 #include "content.h"
 #include "content_inode.h"
 #include "inomap.h"
 #include "mmap.h"
 #include "arch_xlate.h"

 /* structure definitions used locally ****************************************/

 /* restores the inomap into a file
  */
 #define PERS_NAME	"inomap"

 /* reserve the first page for persistent state
  */
 struct pers {
 	size64_t hnkcnt;
 		/* number of hunks in map
 		 */
 	size64_t segcnt;
 		/* number of segments
 		 */
 	xfs_ino_t last_ino_added;
 };

 typedef struct pers pers_t;

 #define PERSSZ	perssz

 /* declarations of externally defined global symbols *************************/

 extern size_t pgsz;


 /* forward declarations of locally defined static functions ******************/

 /* inomap primitives
  */
 static int map_getset( xfs_ino_t, int, bool_t );
 static int map_set( xfs_ino_t ino, int );
 static seg_t * map_getsegment( xfs_ino_t ino );

 /* definition of locally defined global variables ****************************/


 /* definition of locally defined static variables *****************************/

 static int pers_fd = -1;
 	/* file descriptor for persistent inomap backing store
 	 */

 /* context for inomap construction - initialized by inomap_restore_pers
  */
 static uint64_t hnkcnt;
 static uint64_t segcnt;
 static hnk_t *roothnkp = 0;
 static hnk_t *tailhnkp;
 static seg_t *lastsegp;
 static xfs_ino_t last_ino_added;

 /* map context and operators
  */

 static inline void
 SEG_SET_BITS( seg_t *segp, xfs_ino_t ino, int state )
 {
 	register xfs_ino_t relino;
 	register uint64_t mask;
 	register uint64_t clrmask;
 	relino = ino - segp->base;
 	mask = ( uint64_t )1 << relino;
 	clrmask = ~mask;
 	switch( state ) {
 	case 0:
 		segp->lobits &= clrmask;
 		segp->mebits &= clrmask;
 		segp->hibits &= clrmask;
 		break;
 	case 1:
 		segp->lobits |= mask;
 		segp->mebits &= clrmask;
 		segp->hibits &= clrmask;
 		break;
 	case 2:
 		segp->lobits &= clrmask;
 		segp->mebits |= mask;
 		segp->hibits &= clrmask;
 		break;
 	case 3:
 		segp->lobits |= mask;
 		segp->mebits |= mask;
 		segp->hibits &= clrmask;
 		break;
 	case 4:
 		segp->lobits &= clrmask;
 		segp->mebits &= clrmask;
 		segp->hibits |= mask;
 		break;
 	case 5:
 		segp->lobits |= mask;
 		segp->mebits &= clrmask;
 		segp->hibits |= mask;
 		break;
 	case 6:
 		segp->lobits &= clrmask;
 		segp->mebits |= mask;
 		segp->hibits |= mask;
 		break;
 	case 7:
 		segp->lobits |= mask;
 		segp->mebits |= mask;
 		segp->hibits |= mask;
 		break;
 	}
 }

 static inline int
 SEG_GET_BITS( seg_t *segp, xfs_ino_t ino )
 {
 	int state;
 	register xfs_ino_t relino;
 	register uint64_t mask;
 	relino = ino - segp->base;
 	mask = ( uint64_t )1 << relino;
 	if ( segp->lobits & mask ) {
 		state = 1;
 	} else {
 		state = 0;
 	}
 	if ( segp->mebits & mask ) {
 		state |= 2;
 	}
 	if ( segp->hibits & mask ) {
 		state |= 4;
 	}

 	return state;
 }

 /* definition of locally defined global functions ****************************/

 rv_t
 inomap_restore_pers( drive_t *drivep,
 		     content_inode_hdr_t *scrhdrp,
 		     char *hkdir )
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	char *perspath;
 	pers_t *persp;
 	hnk_t *pershnkp;
 	hnk_t *tmphnkp;
 	int fd;
 	/* REFERENCED */
 	int nread;
 	int rval;
 	/* REFERENCED */
 	int rval1;
 	int i;
 	bool_t ok;

 	/* sanity checks
 	 */
 	assert( INOPERSEG == ( sizeof( (( seg_t * )0 )->lobits ) * NBBY ));
 	assert( sizeof( hnk_t ) == HNKSZ );
 	assert( sizeof( pers_t ) <= PERSSZ );

 	/* get inomap info from media hdr
 	 */
 	hnkcnt = scrhdrp->cih_inomap_hnkcnt;
 	segcnt = scrhdrp->cih_inomap_segcnt;
 	last_ino_added = scrhdrp->cih_inomap_lastino;

 	/* truncate and open the backing store
 	 */
 	perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
 	( void )unlink( perspath );
 	fd = open( perspath,
 		   O_RDWR | O_CREAT,
 		   S_IRUSR | S_IWUSR );
 	if ( fd < 0 ) {
 		mlog( MLOG_NORMAL | MLOG_ERROR, _(
 		      "could not open %s: %s\n"),
 		      perspath,
 		      strerror( errno ));
 		return RV_ERROR;
 	}

 	/* mmap the persistent hdr and space for the map
 	 */
 	persp = ( pers_t * ) mmap_autogrow(
 				     PERSSZ
 				     +
 				     sizeof( hnk_t ) * ( size_t )hnkcnt,
 				     fd,
 				     ( off64_t )0 );
 	if ( persp == ( pers_t * )-1 ) {
 		mlog( MLOG_NORMAL | MLOG_ERROR, _(
 		      "unable to map %s: %s\n"),
 		      perspath,
 		      strerror( errno ));
 		return RV_ERROR;
 	}

 	/* load the pers hdr
 	 */
 	persp->hnkcnt = hnkcnt;
 	persp->segcnt = segcnt;
 	persp->last_ino_added = last_ino_added;

 	tmphnkp = ( hnk_t * )calloc( ( size_t )hnkcnt, sizeof( hnk_t ));
 	assert( tmphnkp );

 	/* read the map in from media
 	 */
 	nread = read_buf( ( char * )tmphnkp,
 			  sizeof( hnk_t ) * ( size_t )hnkcnt,
 			  ( void * )drivep,
 			  ( rfp_t )dop->do_read,
 			  ( rrbfp_t )dop->do_return_read_buf,
 			  &rval );

 	pershnkp = (hnk_t *)((char *)persp + PERSSZ);
 	for(i = 0; i < hnkcnt; i++) {
 		xlate_hnk(&tmphnkp[i], &pershnkp[i], 1);
 	}
 	free(tmphnkp);

 	mlog(MLOG_NITTY, "inomap_restore_pers: pre-munmap\n");

 	/* close up
 	 */
 	rval1 = munmap( ( void * )persp,
 		        PERSSZ
 		        +
 		        sizeof( hnk_t ) * ( size_t )hnkcnt );
 	assert( ! rval1 );
 	( void )close( fd );
 	free( ( void * )perspath );

 	mlog(MLOG_NITTY, "inomap_restore_pers: post-munmap\n");

 	/* check the return code from read
 	 */
 	switch( rval ) {
 	case 0:
 		assert( ( size_t )nread == sizeof( hnk_t ) * ( size_t )hnkcnt );
 		ok = inomap_sync_pers( hkdir );
 		if ( ! ok ) {
 			return RV_ERROR;
 		}
 		return RV_OK;
 	case DRIVE_ERROR_EOD:
 	case DRIVE_ERROR_EOF:
 	case DRIVE_ERROR_EOM:
 	case DRIVE_ERROR_MEDIA:
 	case DRIVE_ERROR_CORRUPTION:
 		return RV_CORRUPT;
 	case DRIVE_ERROR_DEVICE:
 		return RV_DRIVE;
 	case DRIVE_ERROR_CORE:
 	default:
 		return RV_CORE;
 	}
 }

 /* peels inomap from media
  */
 rv_t
 inomap_discard( drive_t *drivep, content_inode_hdr_t *scrhdrp )
 {
 	drive_ops_t *dop = drivep->d_opsp;
 	uint64_t tmphnkcnt;
 	/* REFERENCED */
 	int nread;
 	int rval;

 	/* get inomap info from media hdr
 	 */
 	tmphnkcnt = scrhdrp->cih_inomap_hnkcnt;

 	/* read the map in from media
 	 */
 	nread = read_buf( 0,
 			  sizeof( hnk_t ) * ( size_t )tmphnkcnt,
 			  ( void * )drivep,
 			  ( rfp_t )dop->do_read,
 			  ( rrbfp_t )dop->do_return_read_buf,
 			  &rval );
 	/* check the return code from read
 	 */
 	switch( rval ) {
 	case 0:
 		assert( ( size_t )nread == sizeof( hnk_t ) * ( size_t )hnkcnt );
 		return RV_OK;
 	case DRIVE_ERROR_EOD:
 	case DRIVE_ERROR_EOF:
 	case DRIVE_ERROR_EOM:
 	case DRIVE_ERROR_MEDIA:
 	case DRIVE_ERROR_CORRUPTION:
 		return RV_CORRUPT;
 	case DRIVE_ERROR_DEVICE:
 		return RV_DRIVE;
 	case DRIVE_ERROR_CORE:
 	default:
 		return RV_CORE;
 	}
 }

 bool_t
 inomap_sync_pers( char *hkdir )
 {
 	char *perspath;
 	pers_t *persp;
 	hnk_t *hnkp;

 	/* sanity checks
 	 */
 	assert( sizeof( hnk_t ) == HNKSZ );

 	/* only needed once per session
 	 */
 	if ( pers_fd >= 0 ) {
 		return BOOL_TRUE;
 	}

 	/* open the backing store. if not present, ok, hasn't been created yet
 	 */
 	perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
 	pers_fd = open( perspath, O_RDWR );
 	if ( pers_fd < 0 ) {
 		return BOOL_TRUE;
 	}

 	/* mmap the persistent hdr
 	 */
 	persp = ( pers_t * ) mmap_autogrow(
 				     PERSSZ,
 				     pers_fd,
 				     ( off64_t )0 );
 	if ( persp == ( pers_t * )-1 ) {
 		mlog( MLOG_NORMAL | MLOG_ERROR, _(
 		      "unable to map %s hdr: %s\n"),
 		      perspath,
 		      strerror( errno ));
 		return BOOL_FALSE;
 	}

 	/* read the pers hdr
 	 */
 	hnkcnt = persp->hnkcnt;
 	segcnt = persp->segcnt;
 	last_ino_added = persp->last_ino_added;

 	/* mmap the pers inomap
 	 */
 	assert( hnkcnt * sizeof( hnk_t ) <= ( size64_t )INT32MAX );
 	roothnkp = ( hnk_t * ) mmap_autogrow(
 				       sizeof( hnk_t ) * ( size_t )hnkcnt,
 				       pers_fd,
 				       ( off64_t )PERSSZ );
 	if ( roothnkp == ( hnk_t * )-1 ) {
 		mlog( MLOG_NORMAL | MLOG_ERROR, _(
 		      "unable to map %s: %s\n"),
 		      perspath,
 		      strerror( errno ));
 		return BOOL_FALSE;
 	}

 	/* correct the next pointers
 	 */
 	for ( hnkp = roothnkp
 	      ;
 	      hnkp < roothnkp + ( int )hnkcnt - 1
 	      ;
 	      hnkp++ ) {
 		hnkp->nextp = hnkp + 1;
 	}
 	hnkp->nextp = 0;

 	/* calculate the tail pointers
 	 */
 	tailhnkp = hnkp;
 	assert( hnkcnt > 0 );
 	lastsegp = &tailhnkp->seg[ ( int )( segcnt
 						 -
 						 SEGPERHNK * ( hnkcnt - 1 )
 						 -
 						 1 ) ];

 	/* now all inomap operators will work
 	 */
 	return BOOL_TRUE;
 }

 /* de-allocate the persistent inomap
  */
 void
 inomap_del_pers( char *hkdir )
 {
 	char *perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
 	( void )unlink( perspath );
 	free( ( void * )perspath );
 }

 /* mark all included non-dirs as MAP_NDR_NOREST
  */
 void
 inomap_sanitize( void )
 {
 	hnk_t *hnkp;
 	seg_t *segp;

 	/* step through all hunks, segs, and inos
 	 */
 	for ( hnkp = roothnkp
 	      ;
 	      hnkp != 0
 	      ;
 	      hnkp = hnkp->nextp ) {
 		for ( segp = hnkp->seg
 		      ;
 		      segp < hnkp->seg + SEGPERHNK
 		      ;
 		      segp++ ) {
 			xfs_ino_t ino;
 			if ( hnkp == tailhnkp && segp > lastsegp ) {
 				return;
 			}
 			for ( ino = segp->base
 			      ;
 			      ino < segp->base + INOPERSEG
 			      ;
 			      ino++ ) {
 				int state;
 				if ( ino > last_ino_added ) {
 					return;
 				}
 				state = SEG_GET_BITS( segp, ino );
 				if ( state == MAP_NDR_CHANGE ) {
 					state = MAP_NDR_NOREST;
 					SEG_SET_BITS( segp, ino, state );
 				}
 			}
 		}
 	}
 }

 /* called to mark a non-dir ino as TO be restored
  */
 void
 inomap_rst_add( xfs_ino_t ino )
 {
 		assert( pers_fd >= 0 );
 		( void )map_set( ino, MAP_NDR_CHANGE );
 }

 /* called to mark a non-dir ino as NOT to be restored
  */
 void
 inomap_rst_del( xfs_ino_t ino )
 {
 		assert( pers_fd >= 0 );
 		( void )map_set( ino, MAP_NDR_NOREST );
 }

 /* called to ask if any inos in the given range need to be restored.
  * range is inclusive
  */
 bool_t
 inomap_rst_needed( xfs_ino_t firstino, xfs_ino_t lastino )
 {
 	hnk_t *hnkp;
 	seg_t *segp;

 	/* if inomap not restored/resynced, just say yes
 	 */
 	if ( ! roothnkp ) {
 		return BOOL_TRUE;
 	}

 	/* may be completely out of range
 	 */
 	if ( firstino > last_ino_added ) {
 		return BOOL_FALSE;
 	}

 	/* find the hunk/seg containing first ino or any ino beyond
 	 */
 	for ( hnkp = roothnkp ; hnkp != 0 ; hnkp = hnkp->nextp ) {
 		if ( firstino > hnkp->maxino ) {
 			continue;
 		}
 		for ( segp = hnkp->seg; segp < hnkp->seg + SEGPERHNK ; segp++ ){
 			if ( hnkp == tailhnkp && segp > lastsegp ) {
 				return BOOL_FALSE;
 			}
 			if ( firstino < segp->base + INOPERSEG ) {
 				goto begin;
 			}
 		}
 	}
 	return BOOL_FALSE;

 begin:
 	/* search until at least one ino is needed or until beyond last ino
 	 */
 	for ( ; ; ) {
 		xfs_ino_t ino;

 		if ( segp->base > lastino ) {
 			return BOOL_FALSE;
 		}
 		for ( ino = segp->base ; ino < segp->base + INOPERSEG ; ino++ ){
 			int state;
 			if ( ino < firstino ) {
 				continue;
 			}
 			if ( ino > lastino ) {
 				return BOOL_FALSE;
 			}
 			state = SEG_GET_BITS( segp, ino );
 			if ( state == MAP_NDR_CHANGE ) {
 				return BOOL_TRUE;
 			}
 		}
 		segp++;
 		if ( hnkp == tailhnkp && segp > lastsegp ) {
 			return BOOL_FALSE;
 		}
 		if ( segp >= hnkp->seg + SEGPERHNK ) {
 			hnkp = hnkp->nextp;
 			if ( ! hnkp ) {
 				return BOOL_FALSE;
 			}
 			segp = hnkp->seg;
 		}
 	}
 	/* NOTREACHED */
 }

 /* calls the callback for all inos with an inomap state included
  * in the state mask. stops iteration when inos exhaused or cb
  * returns FALSE.
  */
 void
 inomap_cbiter( int statemask,
 	       bool_t ( * cbfunc )( void *ctxp, xfs_ino_t ino ),
 	       void *ctxp )
 {
 	hnk_t *hnkp;
 	seg_t *segp;

 	/* step through all hunks, segs, and inos
 	 */
 	for ( hnkp = roothnkp
 	      ;
 	      hnkp != 0
 	      ;
 	      hnkp = hnkp->nextp ) {
 		for ( segp = hnkp->seg
 		      ;
 		      segp < hnkp->seg + SEGPERHNK
 		      ;
 		      segp++ ) {
 			xfs_ino_t ino;
 			if ( hnkp == tailhnkp && segp > lastsegp ) {
 				return;
 			}
 			for ( ino = segp->base
 			      ;
 			      ino < segp->base + INOPERSEG
 			      ;
 			      ino++ ) {
 				int state;
 				if ( ino > last_ino_added ) {
 					return;
 				}
 				state = SEG_GET_BITS( segp, ino );
 				if ( statemask & ( 1 << state )) {
 					bool_t ok;
 					ok = ( cbfunc )( ctxp, ino );
 					if ( ! ok ) {
 						return;
 					}
 				}
 			}
 		}
 	}
 }

 /* definition of locally defined static functions ****************************/

 /* map_getset - locates and gets the state of the specified ino,
  * and optionally sets the state to a new value.
  */
 static int
 map_getset( xfs_ino_t ino, int newstate, bool_t setflag )
 {
 	int state;
 	seg_t *segp;

 	if ((segp = map_getsegment( ino )) == NULL) {
 		return MAP_INO_UNUSED;
 	}

 	state = SEG_GET_BITS( segp, ino );
 	if ( setflag ) {
 		SEG_SET_BITS( segp, ino, newstate );
 	}
 	return state;
 }

 static seg_t *
 map_getsegment( xfs_ino_t ino )
 {
 	uint64_t min;
 	uint64_t max;
 	uint64_t hnk;
 	uint64_t seg;

 	/* Use binary search to find the hunk that contains the inode number,
 	 * if any.  This counts on the fact that all the hunks are contiguous
 	 * in memory and therefore can be treated as an array instead of a
 	 * list.
 	 */

 	min = 0;
 	max = hnkcnt - 1;

 	while (max >= min) {
 		hnk = min + ((max - min) / 2);

 		if (roothnkp[hnk].seg[0].base > ino) {
 			max = hnk - 1;	/* in a lower hunk */
 		} else if (roothnkp[hnk].maxino < ino) {
 			min = hnk + 1;	/* in a higher hunk */
 		} else {
 			break;	/* we have a winner! */
 		}
 	}

 	if (max < min) {
 		return NULL;	/* inode number fell between hunks */
 	}

 	/* Use binary search to find the segment within the hunk that contains
 	 * the inode number, if any.
 	 */

 	min = 0;
 	if (hnk == hnkcnt - 1) {
 		max = segcnt - SEGPERHNK * ( hnkcnt - 1 ) - 1;
 	} else {
 		max = SEGPERHNK - 1;
 	}

 	while (max >= min) {
 		seg = min + ((max - min) / 2);

 		if (roothnkp[hnk].seg[seg].base > ino) {
 			max = seg - 1;	/* in a lower segment */
 		} else if (roothnkp[hnk].seg[seg].base + INOPERSEG <= ino) {
 			min = seg + 1;	/* in a higher segment */
 		} else {
 			return &roothnkp[hnk].seg[seg];	/* we have a winner! */
 		}
 	}
 	return NULL;
 }

 static int
 map_set( xfs_ino_t ino, int state )
 {
 	int oldstate;

  	oldstate = map_getset( ino, state, BOOL_TRUE );
 	return oldstate;
 }
	/*
	* Copyright (c) 2000-2001 Silicon Graphics, Inc.
	* All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it would be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <xfs/xfs.h>
	#include <xfs/jdm.h>

	#include <unistd.h>
	#include <stdlib.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <errno.h>
	#include <time.h>
	#include <fcntl.h>
	#include <dirent.h>
	#include <time.h>
	#include <assert.h>
	#include <string.h>

	#include "config.h"

	#include "types.h"
	#include "util.h"
	#include "openutil.h"
	#include "mlog.h"
	#include "global.h"
	#include "drive.h"
	#include "media.h"
	#include "content.h"
	#include "content_inode.h"
	#include "inomap.h"
	#include "mmap.h"
	#include "arch_xlate.h"

	/* structure definitions used locally ****************************************/

	/* restores the inomap into a file
	*/
	#define PERS_NAME "inomap"

	/* reserve the first page for persistent state
	*/
	struct pers {
	size64_t hnkcnt;
	/* number of hunks in map
	*/
	size64_t segcnt;
	/* number of segments
	*/
	xfs_ino_t last_ino_added;
	};

	typedef struct pers pers_t;

	#define PERSSZ perssz

	/* declarations of externally defined global symbols *************************/

	extern size_t pgsz;


	/* forward declarations of locally defined static functions ******************/

	/* inomap primitives
	*/
	static int map_getset( xfs_ino_t, int, bool_t );
	static int map_set( xfs_ino_t ino, int );
	static seg_t * map_getsegment( xfs_ino_t ino );

	/* definition of locally defined global variables ****************************/


	/* definition of locally defined static variables *****************************/

	static int pers_fd = -1;
	/* file descriptor for persistent inomap backing store
	*/

	/* context for inomap construction - initialized by inomap_restore_pers
	*/
	static uint64_t hnkcnt;
	static uint64_t segcnt;
	static hnk_t *roothnkp = 0;
	static hnk_t *tailhnkp;
	static seg_t *lastsegp;
	static xfs_ino_t last_ino_added;

	/* map context and operators
	*/

	static inline void
	SEG_SET_BITS( seg_t *segp, xfs_ino_t ino, int state )
	{
	register xfs_ino_t relino;
	register uint64_t mask;
	register uint64_t clrmask;
	relino = ino - segp->base;
	mask = ( uint64_t )1 << relino;
	clrmask = ~mask;
	switch( state ) {
	case 0:
	segp->lobits &= clrmask;
	segp->mebits &= clrmask;
	segp->hibits &= clrmask;
	break;
	case 1:
	segp->lobits \|= mask;
	segp->mebits &= clrmask;
	segp->hibits &= clrmask;
	break;
	case 2:
	segp->lobits &= clrmask;
	segp->mebits \|= mask;
	segp->hibits &= clrmask;
	break;
	case 3:
	segp->lobits \|= mask;
	segp->mebits \|= mask;
	segp->hibits &= clrmask;
	break;
	case 4:
	segp->lobits &= clrmask;
	segp->mebits &= clrmask;
	segp->hibits \|= mask;
	break;
	case 5:
	segp->lobits \|= mask;
	segp->mebits &= clrmask;
	segp->hibits \|= mask;
	break;
	case 6:
	segp->lobits &= clrmask;
	segp->mebits \|= mask;
	segp->hibits \|= mask;
	break;
	case 7:
	segp->lobits \|= mask;
	segp->mebits \|= mask;
	segp->hibits \|= mask;
	break;
	}
	}

	static inline int
	SEG_GET_BITS( seg_t *segp, xfs_ino_t ino )
	{
	int state;
	register xfs_ino_t relino;
	register uint64_t mask;
	relino = ino - segp->base;
	mask = ( uint64_t )1 << relino;
	if ( segp->lobits & mask ) {
	state = 1;
	} else {
	state = 0;
	}
	if ( segp->mebits & mask ) {
	state \|= 2;
	}
	if ( segp->hibits & mask ) {
	state \|= 4;
	}

	return state;
	}

	/* definition of locally defined global functions ****************************/

	rv_t
	inomap_restore_pers( drive_t *drivep,
	content_inode_hdr_t *scrhdrp,
	char *hkdir )
	{
	drive_ops_t *dop = drivep->d_opsp;
	char *perspath;
	pers_t *persp;
	hnk_t *pershnkp;
	hnk_t *tmphnkp;
	int fd;
	/* REFERENCED */
	int nread;
	int rval;
	/* REFERENCED */
	int rval1;
	int i;
	bool_t ok;

	/* sanity checks
	*/
	assert( INOPERSEG == ( sizeof( (( seg_t * )0 )->lobits ) * NBBY ));
	assert( sizeof( hnk_t ) == HNKSZ );
	assert( sizeof( pers_t ) <= PERSSZ );

	/* get inomap info from media hdr
	*/
	hnkcnt = scrhdrp->cih_inomap_hnkcnt;
	segcnt = scrhdrp->cih_inomap_segcnt;
	last_ino_added = scrhdrp->cih_inomap_lastino;

	/* truncate and open the backing store
	*/
	perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
	( void )unlink( perspath );
	fd = open( perspath,
	O_RDWR \| O_CREAT,
	S_IRUSR \| S_IWUSR );
	if ( fd < 0 ) {
	mlog( MLOG_NORMAL \| MLOG_ERROR, _(
	"could not open %s: %s\n"),
	perspath,
	strerror( errno ));
	return RV_ERROR;
	}

	/* mmap the persistent hdr and space for the map
	*/
	persp = ( pers_t * ) mmap_autogrow(
	PERSSZ
	+
	sizeof( hnk_t ) * ( size_t )hnkcnt,
	fd,
	( off64_t )0 );
	if ( persp == ( pers_t * )-1 ) {
	mlog( MLOG_NORMAL \| MLOG_ERROR, _(
	"unable to map %s: %s\n"),
	perspath,
	strerror( errno ));
	return RV_ERROR;
	}

	/* load the pers hdr
	*/
	persp->hnkcnt = hnkcnt;
	persp->segcnt = segcnt;
	persp->last_ino_added = last_ino_added;

	tmphnkp = ( hnk_t * )calloc( ( size_t )hnkcnt, sizeof( hnk_t ));
	assert( tmphnkp );

	/* read the map in from media
	*/
	nread = read_buf( ( char * )tmphnkp,
	sizeof( hnk_t ) * ( size_t )hnkcnt,
	( void * )drivep,
	( rfp_t )dop->do_read,
	( rrbfp_t )dop->do_return_read_buf,
	&rval );

	pershnkp = (hnk_t )((char )persp + PERSSZ);
	for(i = 0; i < hnkcnt; i++) {
	xlate_hnk(&tmphnkp[i], &pershnkp[i], 1);
	}
	free(tmphnkp);

	mlog(MLOG_NITTY, "inomap_restore_pers: pre-munmap\n");

	/* close up
	*/
	rval1 = munmap( ( void * )persp,
	PERSSZ
	+
	sizeof( hnk_t ) * ( size_t )hnkcnt );
	assert( ! rval1 );
	( void )close( fd );
	free( ( void * )perspath );

	mlog(MLOG_NITTY, "inomap_restore_pers: post-munmap\n");

	/* check the return code from read
	*/
	switch( rval ) {
	case 0:
	assert( ( size_t )nread == sizeof( hnk_t ) * ( size_t )hnkcnt );
	ok = inomap_sync_pers( hkdir );
	if ( ! ok ) {
	return RV_ERROR;
	}
	return RV_OK;
	case DRIVE_ERROR_EOD:
	case DRIVE_ERROR_EOF:
	case DRIVE_ERROR_EOM:
	case DRIVE_ERROR_MEDIA:
	case DRIVE_ERROR_CORRUPTION:
	return RV_CORRUPT;
	case DRIVE_ERROR_DEVICE:
	return RV_DRIVE;
	case DRIVE_ERROR_CORE:
	default:
	return RV_CORE;
	}
	}

	/* peels inomap from media
	*/
	rv_t
	inomap_discard( drive_t drivep, content_inode_hdr_t scrhdrp )
	{
	drive_ops_t *dop = drivep->d_opsp;
	uint64_t tmphnkcnt;
	/* REFERENCED */
	int nread;
	int rval;

	/* get inomap info from media hdr
	*/
	tmphnkcnt = scrhdrp->cih_inomap_hnkcnt;

	/* read the map in from media
	*/
	nread = read_buf( 0,
	sizeof( hnk_t ) * ( size_t )tmphnkcnt,
	( void * )drivep,
	( rfp_t )dop->do_read,
	( rrbfp_t )dop->do_return_read_buf,
	&rval );
	/* check the return code from read
	*/
	switch( rval ) {
	case 0:
	assert( ( size_t )nread == sizeof( hnk_t ) * ( size_t )hnkcnt );
	return RV_OK;
	case DRIVE_ERROR_EOD:
	case DRIVE_ERROR_EOF:
	case DRIVE_ERROR_EOM:
	case DRIVE_ERROR_MEDIA:
	case DRIVE_ERROR_CORRUPTION:
	return RV_CORRUPT;
	case DRIVE_ERROR_DEVICE:
	return RV_DRIVE;
	case DRIVE_ERROR_CORE:
	default:
	return RV_CORE;
	}
	}

	bool_t
	inomap_sync_pers( char *hkdir )
	{
	char *perspath;
	pers_t *persp;
	hnk_t *hnkp;

	/* sanity checks
	*/
	assert( sizeof( hnk_t ) == HNKSZ );

	/* only needed once per session
	*/
	if ( pers_fd >= 0 ) {
	return BOOL_TRUE;
	}

	/* open the backing store. if not present, ok, hasn't been created yet
	*/
	perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
	pers_fd = open( perspath, O_RDWR );
	if ( pers_fd < 0 ) {
	return BOOL_TRUE;
	}

	/* mmap the persistent hdr
	*/
	persp = ( pers_t * ) mmap_autogrow(
	PERSSZ,
	pers_fd,
	( off64_t )0 );
	if ( persp == ( pers_t * )-1 ) {
	mlog( MLOG_NORMAL \| MLOG_ERROR, _(
	"unable to map %s hdr: %s\n"),
	perspath,
	strerror( errno ));
	return BOOL_FALSE;
	}

	/* read the pers hdr
	*/
	hnkcnt = persp->hnkcnt;
	segcnt = persp->segcnt;
	last_ino_added = persp->last_ino_added;

	/* mmap the pers inomap
	*/
	assert( hnkcnt * sizeof( hnk_t ) <= ( size64_t )INT32MAX );
	roothnkp = ( hnk_t * ) mmap_autogrow(
	sizeof( hnk_t ) * ( size_t )hnkcnt,
	pers_fd,
	( off64_t )PERSSZ );
	if ( roothnkp == ( hnk_t * )-1 ) {
	mlog( MLOG_NORMAL \| MLOG_ERROR, _(
	"unable to map %s: %s\n"),
	perspath,
	strerror( errno ));
	return BOOL_FALSE;
	}

	/* correct the next pointers
	*/
	for ( hnkp = roothnkp
	;
	hnkp < roothnkp + ( int )hnkcnt - 1
	;
	hnkp++ ) {
	hnkp->nextp = hnkp + 1;
	}
	hnkp->nextp = 0;

	/* calculate the tail pointers
	*/
	tailhnkp = hnkp;
	assert( hnkcnt > 0 );
	lastsegp = &tailhnkp->seg[ ( int )( segcnt
	-
	SEGPERHNK * ( hnkcnt - 1 )
	-
	1 ) ];

	/* now all inomap operators will work
	*/
	return BOOL_TRUE;
	}

	/* de-allocate the persistent inomap
	*/
	void
	inomap_del_pers( char *hkdir )
	{
	char *perspath = open_pathalloc( hkdir, PERS_NAME, 0 );
	( void )unlink( perspath );
	free( ( void * )perspath );
	}

	/* mark all included non-dirs as MAP_NDR_NOREST
	*/
	void
	inomap_sanitize( void )
	{
	hnk_t *hnkp;
	seg_t *segp;

	/* step through all hunks, segs, and inos
	*/
	for ( hnkp = roothnkp
	;
	hnkp != 0
	;
	hnkp = hnkp->nextp ) {
	for ( segp = hnkp->seg
	;
	segp < hnkp->seg + SEGPERHNK
	;
	segp++ ) {
	xfs_ino_t ino;
	if ( hnkp == tailhnkp && segp > lastsegp ) {
	return;
	}
	for ( ino = segp->base
	;
	ino < segp->base + INOPERSEG
	;
	ino++ ) {
	int state;
	if ( ino > last_ino_added ) {
	return;
	}
	state = SEG_GET_BITS( segp, ino );
	if ( state == MAP_NDR_CHANGE ) {
	state = MAP_NDR_NOREST;
	SEG_SET_BITS( segp, ino, state );
	}
	}
	}
	}
	}

	/* called to mark a non-dir ino as TO be restored
	*/
	void
	inomap_rst_add( xfs_ino_t ino )
	{
	assert( pers_fd >= 0 );
	( void )map_set( ino, MAP_NDR_CHANGE );
	}

	/* called to mark a non-dir ino as NOT to be restored
	*/
	void
	inomap_rst_del( xfs_ino_t ino )
	{
	assert( pers_fd >= 0 );
	( void )map_set( ino, MAP_NDR_NOREST );
	}

	/* called to ask if any inos in the given range need to be restored.
	* range is inclusive
	*/
	bool_t
	inomap_rst_needed( xfs_ino_t firstino, xfs_ino_t lastino )
	{
	hnk_t *hnkp;
	seg_t *segp;

	/* if inomap not restored/resynced, just say yes
	*/
	if ( ! roothnkp ) {
	return BOOL_TRUE;
	}

	/* may be completely out of range
	*/
	if ( firstino > last_ino_added ) {
	return BOOL_FALSE;
	}

	/* find the hunk/seg containing first ino or any ino beyond
	*/
	for ( hnkp = roothnkp ; hnkp != 0 ; hnkp = hnkp->nextp ) {
	if ( firstino > hnkp->maxino ) {
	continue;
	}
	for ( segp = hnkp->seg; segp < hnkp->seg + SEGPERHNK ; segp++ ){
	if ( hnkp == tailhnkp && segp > lastsegp ) {
	return BOOL_FALSE;
	}
	if ( firstino < segp->base + INOPERSEG ) {
	goto begin;
	}
	}
	}
	return BOOL_FALSE;

	begin:
	/* search until at least one ino is needed or until beyond last ino
	*/
	for ( ; ; ) {
	xfs_ino_t ino;

	if ( segp->base > lastino ) {
	return BOOL_FALSE;
	}
	for ( ino = segp->base ; ino < segp->base + INOPERSEG ; ino++ ){
	int state;
	if ( ino < firstino ) {
	continue;
	}
	if ( ino > lastino ) {
	return BOOL_FALSE;
	}
	state = SEG_GET_BITS( segp, ino );
	if ( state == MAP_NDR_CHANGE ) {
	return BOOL_TRUE;
	}
	}
	segp++;
	if ( hnkp == tailhnkp && segp > lastsegp ) {
	return BOOL_FALSE;
	}
	if ( segp >= hnkp->seg + SEGPERHNK ) {
	hnkp = hnkp->nextp;
	if ( ! hnkp ) {
	return BOOL_FALSE;
	}
	segp = hnkp->seg;
	}
	}
	/* NOTREACHED */
	}

	/* calls the callback for all inos with an inomap state included
	* in the state mask. stops iteration when inos exhaused or cb
	* returns FALSE.
	*/
	void
	inomap_cbiter( int statemask,
	bool_t ( * cbfunc )( void *ctxp, xfs_ino_t ino ),
	void *ctxp )
	{
	hnk_t *hnkp;
	seg_t *segp;

	/* step through all hunks, segs, and inos
	*/
	for ( hnkp = roothnkp
	;
	hnkp != 0
	;
	hnkp = hnkp->nextp ) {
	for ( segp = hnkp->seg
	;
	segp < hnkp->seg + SEGPERHNK
	;
	segp++ ) {
	xfs_ino_t ino;
	if ( hnkp == tailhnkp && segp > lastsegp ) {
	return;
	}
	for ( ino = segp->base
	;
	ino < segp->base + INOPERSEG
	;
	ino++ ) {
	int state;
	if ( ino > last_ino_added ) {
	return;
	}
	state = SEG_GET_BITS( segp, ino );
	if ( statemask & ( 1 << state )) {
	bool_t ok;
	ok = ( cbfunc )( ctxp, ino );
	if ( ! ok ) {
	return;
	}
	}
	}
	}
	}
	}

	/* definition of locally defined static functions ****************************/

	/* map_getset - locates and gets the state of the specified ino,
	* and optionally sets the state to a new value.
	*/
	static int
	map_getset( xfs_ino_t ino, int newstate, bool_t setflag )
	{
	int state;
	seg_t *segp;

	if ((segp = map_getsegment( ino )) == NULL) {
	return MAP_INO_UNUSED;
	}

	state = SEG_GET_BITS( segp, ino );
	if ( setflag ) {
	SEG_SET_BITS( segp, ino, newstate );
	}
	return state;
	}

	static seg_t *
	map_getsegment( xfs_ino_t ino )
	{
	uint64_t min;
	uint64_t max;
	uint64_t hnk;
	uint64_t seg;

	/* Use binary search to find the hunk that contains the inode number,
	* if any. This counts on the fact that all the hunks are contiguous
	* in memory and therefore can be treated as an array instead of a
	* list.
	*/

	min = 0;
	max = hnkcnt - 1;

	while (max >= min) {
	hnk = min + ((max - min) / 2);

	if (roothnkp[hnk].seg[0].base > ino) {
	max = hnk - 1; /* in a lower hunk */
	} else if (roothnkp[hnk].maxino < ino) {
	min = hnk + 1; /* in a higher hunk */
	} else {
	break; /* we have a winner! */
	}
	}

	if (max < min) {
	return NULL; /* inode number fell between hunks */
	}

	/* Use binary search to find the segment within the hunk that contains
	* the inode number, if any.
	*/

	min = 0;
	if (hnk == hnkcnt - 1) {
	max = segcnt - SEGPERHNK * ( hnkcnt - 1 ) - 1;
	} else {
	max = SEGPERHNK - 1;
	}

	while (max >= min) {
	seg = min + ((max - min) / 2);

	if (roothnkp[hnk].seg[seg].base > ino) {
	max = seg - 1; /* in a lower segment */
	} else if (roothnkp[hnk].seg[seg].base + INOPERSEG <= ino) {
	min = seg + 1; /* in a higher segment */
	} else {
	return &roothnkp[hnk].seg[seg]; /* we have a winner! */
	}
	}
	return NULL;
	}

	static int
	map_set( xfs_ino_t ino, int state )
	{
	int oldstate;

	oldstate = map_getset( ino, state, BOOL_TRUE );
	return oldstate;
	}