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