| /* |
| * 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 <unistd.h> |
| #include <sys/stat.h> |
| #include <time.h> |
| #include <errno.h> |
| #include <assert.h> |
| #include <string.h> |
| #include <uuid/uuid.h> |
| #include <xfs/xfs.h> |
| #include <xfs/jdm.h> /* only for util.h include */ |
| |
| #include "config.h" |
| |
| #include "types.h" |
| #include "util.h" /* only for strncpyterm */ |
| #include "mlog.h" |
| #include "dlog.h" |
| #include "global.h" |
| #include "getopt.h" |
| #include "swap.h" |
| |
| |
| /* declarations of externally defined global symbols *************************/ |
| |
| extern void usage( void ); |
| extern bool_t pipeline; |
| |
| |
| /* forward declarations of locally defined static functions ******************/ |
| |
| #ifdef DUMP |
| static char * prompt_label( char *bufp, size_t bufsz ); |
| #endif /* DUMP */ |
| |
| /* definition of locally defined global variables ****************************/ |
| |
| |
| /* definition of locally defined static variables *****************************/ |
| |
| |
| /* definition of locally defined global functions ****************************/ |
| |
| global_hdr_t * |
| global_hdr_alloc( int argc, char *argv[ ] ) |
| { |
| global_hdr_t *ghdrp; |
| int c; |
| char *dumplabel; |
| #ifdef DUMP |
| char labelbuf[ GLOBAL_HDR_STRING_SZ ]; |
| struct stat64 statb; |
| #endif /* DUMP */ |
| |
| int rval; |
| |
| /* sanity checks |
| */ |
| assert( sizeof( time32_t ) == GLOBAL_HDR_TIME_SZ ); |
| assert( sizeof( uuid_t ) == GLOBAL_HDR_UUID_SZ ); |
| |
| /* allocate a global hdr |
| */ |
| ghdrp = ( global_hdr_t * )calloc( 1, sizeof( global_hdr_t )); |
| assert( ghdrp ); |
| |
| /* fill in the magic number |
| */ |
| strncpy( ghdrp->gh_magic, GLOBAL_HDR_MAGIC, GLOBAL_HDR_MAGIC_SZ ); |
| |
| /* fill in the hdr version |
| */ |
| ghdrp->gh_version = GLOBAL_HDR_VERSION; |
| |
| /* fill in the timestamp: all changes made at or after this moment |
| * will be included in increments on this base. This may be |
| * overridden with the GETOPT_DUMPTIME option. |
| */ |
| ghdrp->gh_timestamp = (time32_t) time( 0 ); |
| |
| /* fill in the host id: typecast to fit into a 64 bit field |
| */ |
| ghdrp->gh_ipaddr = ( uint64_t )( unsigned long )gethostid( ); |
| |
| #ifdef DUMP |
| uuid_generate( ghdrp->gh_dumpid ); |
| #endif /* DUMP */ |
| #ifdef RESTORE |
| uuid_clear( ghdrp->gh_dumpid ); |
| #endif /* RESTORE */ |
| |
| /* fill in the hostname |
| */ |
| rval = gethostname( ghdrp->gh_hostname, GLOBAL_HDR_STRING_SZ ); |
| if ( rval ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("unable to determine hostname: %s\n"), |
| strerror( errno )); |
| return 0; |
| } |
| if ( ! strlen( ghdrp->gh_hostname )) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("hostname length is zero\n") ); |
| return 0; |
| } |
| |
| /* scan the command line for the dump session label |
| */ |
| dumplabel = 0; |
| optind = 1; |
| opterr = 0; |
| while ( ( c = getopt( argc, argv, GETOPT_CMDSTRING )) != EOF ) { |
| switch ( c ) { |
| case GETOPT_DUMPLABEL: |
| if ( dumplabel ) { |
| mlog( MLOG_NORMAL, |
| _("too many -%c arguments: " |
| "\"-%c %s\" already given\n"), |
| c, |
| c, |
| dumplabel ); |
| usage( ); |
| return 0; |
| } |
| if ( ! optarg || optarg[ 0 ] == '-' ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("-%c argument missing\n"), |
| c ); |
| usage( ); |
| return 0; |
| } |
| dumplabel = optarg; |
| break; |
| #ifdef RESTORE |
| case GETOPT_SESSIONID: |
| if ( ! uuid_is_null( ghdrp->gh_dumpid )) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("too many -%c arguments\n"), |
| c ); |
| usage( ); |
| return 0; |
| } |
| if ( ! optarg || optarg[ 0 ] == '-' ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("-%c argument missing\n"), |
| c ); |
| usage( ); |
| return 0; |
| } |
| |
| if ( ! uuid_parse( optarg, ghdrp->gh_dumpid ) ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("-%c argument not a valid uuid\n"), |
| c ); |
| usage( ); |
| return 0; |
| } |
| break; |
| #endif /* RESTORE */ |
| #ifdef DUMP |
| case GETOPT_DUMPTIME: |
| /* Use the timestamp of the specified file for the |
| * dump time, rather than using the current time. |
| */ |
| if ( ! optarg || optarg[ 0 ] == '-' ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("-%c argument missing\n"), |
| c ); |
| usage( ); |
| return 0; |
| } |
| rval = stat64( optarg, &statb ); |
| if ( rval ) { |
| mlog( MLOG_NORMAL | MLOG_ERROR, |
| _("unable to stat %s: %s\n"), |
| optarg, |
| strerror( errno )); |
| usage( ); |
| return 0; |
| } |
| ghdrp->gh_timestamp = statb.st_mtime; |
| break; |
| |
| case GETOPT_FMT2COMPAT: |
| ghdrp->gh_version = GLOBAL_HDR_VERSION_2; |
| break; |
| #endif /* DUMP */ |
| } |
| } |
| |
| #ifdef DUMP |
| /* if no dump label specified, no pipes in use, and dialogs |
| * are allowed, prompt for one |
| */ |
| if ( ! dumplabel && dlog_allowed( )) { |
| dumplabel = prompt_label( labelbuf, sizeof( labelbuf )); |
| } |
| #endif /* DUMP */ |
| |
| if ( ! dumplabel || ! strlen( dumplabel )) { |
| #ifdef DUMP |
| if ( ! pipeline ) { |
| mlog( MLOG_VERBOSE | MLOG_WARNING, |
| _("no session label specified\n") ); |
| } |
| #endif /* DUMP */ |
| dumplabel = ""; |
| } |
| |
| strncpyterm( ghdrp->gh_dumplabel, |
| dumplabel, |
| sizeof( ghdrp->gh_dumplabel )); |
| |
| return ghdrp; |
| } |
| |
| |
| void |
| global_hdr_free( global_hdr_t *ghdrp ) |
| { |
| free( ( void * )ghdrp ); |
| } |
| |
| /* global_hdr_checksum_set - fill in the global media file header checksum. |
| * utility function for use by drive-specific strategies. |
| */ |
| void |
| global_hdr_checksum_set( global_hdr_t *hdrp ) |
| { |
| uint32_t *beginp = ( uint32_t * )&hdrp[ 0 ]; |
| uint32_t *endp = ( uint32_t * )&hdrp[ 1 ]; |
| uint32_t *p; |
| uint32_t accum; |
| |
| hdrp->gh_checksum = 0; |
| accum = 0; |
| for ( p = beginp ; p < endp ; p++ ) { |
| accum += INT_GET(*p, ARCH_CONVERT); |
| } |
| INT_SET(hdrp->gh_checksum, ARCH_CONVERT, (int32_t)(~accum + 1)); |
| } |
| |
| /* global_hdr_checksum_check - check the global media file header checksum. |
| * utility function for use by drive-specific strategies. |
| * returns BOOL_TRUE if ok, BOOL_FALSE if bad |
| */ |
| bool_t |
| global_hdr_checksum_check( global_hdr_t *hdrp ) |
| { |
| uint32_t *beginp = ( uint32_t * )&hdrp[ 0 ]; |
| uint32_t *endp = ( uint32_t * )&hdrp[ 1 ]; |
| uint32_t *p; |
| uint32_t accum; |
| |
| accum = 0; |
| for ( p = beginp ; p < endp ; p++ ) { |
| accum += INT_GET(*p, ARCH_CONVERT); |
| } |
| return accum == 0 ? BOOL_TRUE : BOOL_FALSE; |
| } |
| |
| /* global_version_check - if we know this version number, return BOOL_TRUE |
| * else return BOOL_FALSE |
| */ |
| bool_t |
| global_version_check( uint32_t version ) |
| { |
| switch (version) { |
| case GLOBAL_HDR_VERSION_0: |
| case GLOBAL_HDR_VERSION_1: |
| case GLOBAL_HDR_VERSION_2: |
| case GLOBAL_HDR_VERSION_3: |
| return BOOL_TRUE; |
| default: |
| return BOOL_FALSE; |
| } |
| } |
| |
| /* definition of locally defined static functions ****************************/ |
| |
| #ifdef DUMP |
| #define PREAMBLEMAX 3 |
| #define QUERYMAX 1 |
| #define CHOICEMAX 1 |
| #define ACKMAX 3 |
| #define POSTAMBLEMAX 3 |
| #define DLOG_TIMEOUT 300 |
| |
| /* ARGSUSED */ |
| static void |
| prompt_label_cb( void *uctxp, dlog_pcbp_t pcb, void *pctxp ) |
| { |
| /* query: ask for a dump label |
| */ |
| ( * pcb )( pctxp, |
| _("please enter label for this dump session") ); |
| } |
| |
| static char * |
| prompt_label( char *bufp, size_t bufsz ) |
| { |
| fold_t fold; |
| char *preamblestr[ PREAMBLEMAX ]; |
| size_t preamblecnt; |
| char *ackstr[ ACKMAX ]; |
| size_t ackcnt; |
| char *postamblestr[ POSTAMBLEMAX ]; |
| size_t postamblecnt; |
| const ix_t abortix = 1; |
| const ix_t okix = 2; |
| ix_t responseix; |
| |
| preamblecnt = 0; |
| fold_init( fold, _("dump label dialog"), '=' ); |
| preamblestr[ preamblecnt++ ] = "\n"; |
| preamblestr[ preamblecnt++ ] = fold; |
| preamblestr[ preamblecnt++ ] = "\n\n"; |
| assert( preamblecnt <= PREAMBLEMAX ); |
| dlog_begin( preamblestr, preamblecnt ); |
| |
| responseix = dlog_string_query( prompt_label_cb, |
| 0, |
| bufp, |
| bufsz, |
| DLOG_TIMEOUT, |
| abortix,/* timeout ix */ |
| IXMAX, /* sigint ix */ |
| IXMAX, /* sighup ix */ |
| IXMAX, /* sigquit ix */ |
| okix ); /* ok ix */ |
| ackcnt = 0; |
| if ( responseix == okix ) { |
| ackstr[ ackcnt++ ] = _("session label entered: \""); |
| ackstr[ ackcnt++ ] = bufp; |
| ackstr[ ackcnt++ ] = "\"\n"; |
| } else { |
| ackstr[ ackcnt++ ] = _("session label left blank\n"); |
| } |
| |
| assert( ackcnt <= ACKMAX ); |
| dlog_string_ack( ackstr, |
| ackcnt ); |
| |
| postamblecnt = 0; |
| fold_init( fold, _("end dialog"), '-' ); |
| postamblestr[ postamblecnt++ ] = "\n"; |
| postamblestr[ postamblecnt++ ] = fold; |
| postamblestr[ postamblecnt++ ] = "\n\n"; |
| assert( postamblecnt <= POSTAMBLEMAX ); |
| dlog_end( postamblestr, |
| postamblecnt ); |
| |
| if ( responseix == okix ) { |
| return bufp; |
| } else { |
| return 0; |
| } |
| } |
| #endif /* DUMP */ |
