/* 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 );
}
static void
var_skip_recurse( char *base, void ( *cb )( xfs_ino_t ino ))
{
struct stat64 statbuf;
DIR *dirp;
struct dirent *direntp;
intgen_t rval;
rval = lstat64( base, &statbuf );
if ( rval ) {
mlog( MLOG_NORMAL, _(
"unable to get status of %s: %s\n"),
base,
strerror( errno ));
return;
}
mlog( MLOG_DEBUG,
"excluding %s from dump\n",
base );
( * cb )( statbuf.st_ino );
if ( ( statbuf.st_mode & S_IFMT ) != S_IFDIR ) {
return;
}
dirp = opendir( base );
if ( ! dirp ) {
mlog( MLOG_NORMAL, _(
"unable to open directory %s\n"),
base );
return;
}
while ( ( direntp = readdir( dirp )) != NULL ) {
char *path;
/* skip "." and ".."
*/
if ( *( direntp->d_name + 0 ) == '.'
&&
( *( direntp->d_name + 1 ) == 0
||
( *( direntp->d_name + 1 ) == '.'
&&
*( direntp->d_name + 2 ) == 0 ))) {
continue;
}
path = open_pathalloc( base, direntp->d_name, 0 );
var_skip_recurse( path, cb );
free( ( void * )path );
}
closedir( dirp );
}
namreg_t *
namreg_init( bool_t cumulative,
bool_t delta,
char *housekeepingdir )
{
namreg_context_t *ncp;
/* allocate and initialize context
*/
ncp = ( namreg_context_t * )calloc( 1, sizeof( namreg_context_t ));
ASSERT( ncp );
/* generate a string containing the pathname of the namreg file
*/
ncp->nc_pathname = open_pathalloc( housekeepingdir, NAMETEMPLATE, 0 );
/* if not a cumulative restore, be sure the name registry gets removed
* on exit.
*/
if ( ! cumulative ) {
( void )cleanup_register( namreg_abort_cleanup,
( void * )ncp,
0 );
}
/* if this is a delta during a cumulative restore, the namreg file must
* already exist. if not, create/truncate.
*/
if ( cumulative && delta ) {
ncp->nc_fd = open_rwp( ncp->nc_pathname );
if ( ncp->nc_fd < 0 ) {
mlog( MLOG_NORMAL,
"could not open %s: %s\n",
ncp->nc_pathname,
strerror( errno ));
return 0;
}
} else {
ncp->nc_fd = open_trwp( ncp->nc_pathname );
if ( ncp->nc_fd < 0 ) {
return 0;
}
}
return ( namreg_t * )ncp;
}
bool_t
inomap_sync_pers( char *hkdir )
{
char *perspath;
pers_t *persp;
hnk_t *hnkp;
/* sanity checks
*/
ASSERT( sizeof( hnk_t ) == HNKSZ );
ASSERT( HNKSZ >= pgsz );
ASSERT( ! ( HNKSZ % pgsz ));
/* 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 + ( intgen_t )hnkcnt - 1
;
hnkp++ ) {
hnkp->nextp = hnkp + 1;
}
hnkp->nextp = 0;
/* calculate the tail pointers
*/
tailhnkp = hnkp;
ASSERT( hnkcnt > 0 );
lastsegp = &tailhnkp->seg[ ( intgen_t )( segcnt
-
SEGPERHNK * ( hnkcnt - 1 )
-
1 ) ];
/* now all inomap operators will work
*/
return BOOL_TRUE;
}
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;
intgen_t fd;
/* REFERENCED */
intgen_t nread;
intgen_t rval;
/* REFERENCED */
intgen_t rval1;
int i;
bool_t ok;
/* sanity checks
*/
ASSERT( INOPERSEG == ( sizeof( (( seg_t * )0 )->lobits ) * NBBY ));
ASSERT( sizeof( hnk_t ) == HNKSZ );
ASSERT( HNKSZ >= pgsz );
ASSERT( ! ( HNKSZ % pgsz ));
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
*/
ASSERT( sizeof( hnk_t ) * ( size_t )hnkcnt >= pgsz );
ASSERT( ! ( sizeof( hnk_t ) * ( size_t )hnkcnt % pgsz ));
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;
}
}
