/* 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; } }