1994-05-26 06:35:07 +00:00
|
|
|
/*-
|
2017-11-20 19:49:47 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-26 06:35:07 +00:00
|
|
|
* Copyright (c) 1980, 1991, 1993, 1994
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-26 06:35:07 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef lint
|
1998-06-15 06:58:13 +00:00
|
|
|
static const char copyright[] =
|
1994-05-26 06:35:07 +00:00
|
|
|
"@(#) Copyright (c) 1980, 1991, 1993, 1994\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#ifndef lint
|
1998-06-15 06:58:13 +00:00
|
|
|
#if 0
|
1997-03-11 12:09:50 +00:00
|
|
|
static char sccsid[] = "@(#)main.c 8.6 (Berkeley) 5/1/95";
|
1998-06-15 06:58:13 +00:00
|
|
|
#endif
|
|
|
|
static const char rcsid[] =
|
1999-08-28 00:22:10 +00:00
|
|
|
"$FreeBSD$";
|
1994-05-26 06:35:07 +00:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
2000-04-02 10:16:40 +00:00
|
|
|
#include <sys/stat.h>
|
2002-12-03 18:21:09 +00:00
|
|
|
#include <sys/mount.h>
|
2002-05-12 21:37:08 +00:00
|
|
|
#include <sys/disklabel.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2021-02-18 13:43:58 +00:00
|
|
|
#include <ufs/ufs/extattr.h>
|
|
|
|
#include <ufs/ufs/quota.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <ufs/ufs/dinode.h>
|
2002-12-03 18:21:09 +00:00
|
|
|
#include <ufs/ufs/ufsmount.h>
|
1997-03-11 12:09:50 +00:00
|
|
|
#include <ufs/ffs/fs.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
#include <protocols/dumprestore.h>
|
|
|
|
|
|
|
|
#include <ctype.h>
|
1997-03-11 12:09:50 +00:00
|
|
|
#include <err.h>
|
2002-12-03 18:21:09 +00:00
|
|
|
#include <errno.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <fstab.h>
|
2018-01-26 00:58:32 +00:00
|
|
|
#include <libufs.h>
|
2002-09-25 04:06:37 +00:00
|
|
|
#include <limits.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <signal.h>
|
2003-11-14 13:07:38 +00:00
|
|
|
#include <stdint.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2011-01-24 06:17:05 +00:00
|
|
|
#include <time.h>
|
2002-07-08 00:29:23 +00:00
|
|
|
#include <timeconv.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "dump.h"
|
|
|
|
#include "pathnames.h"
|
|
|
|
|
2020-04-04 00:56:56 +00:00
|
|
|
int mapsize; /* size of the state maps */
|
|
|
|
char *usedinomap; /* map of allocated inodes */
|
|
|
|
char *dumpdirmap; /* map of directories to be dumped */
|
|
|
|
char *dumpinomap; /* map of files to be dumped */
|
|
|
|
char *disk; /* name of the disk file */
|
|
|
|
char *tape; /* name of the tape file */
|
|
|
|
char *popenout; /* popen(3) per-"tape" command */
|
|
|
|
int level; /* dump level of this dump */
|
|
|
|
int uflag; /* update flag */
|
|
|
|
int diskfd; /* disk file descriptor */
|
|
|
|
int pipeout; /* true => output to standard output */
|
|
|
|
int density = 0; /* density in bytes/0.1" " <- this is for hilit19 */
|
|
|
|
long tapesize; /* estimated tape size, blocks */
|
|
|
|
long tsize; /* tape size in 0.1" units */
|
|
|
|
int etapes; /* estimated number of tapes */
|
|
|
|
int nonodump; /* if set, do not honor UF_NODUMP user flags */
|
|
|
|
int unlimited; /* if set, write to end of medium */
|
|
|
|
int cachesize = 0; /* block cache size (in bytes), defaults to 0 */
|
|
|
|
int rsync_friendly; /* be friendly with rsync */
|
1994-05-26 06:35:07 +00:00
|
|
|
int notify = 0; /* notify operator flag */
|
2020-04-04 00:56:56 +00:00
|
|
|
int blockswritten = 0; /* number of blocks written on current tape */
|
1994-05-26 06:35:07 +00:00
|
|
|
int tapeno = 0; /* current tape number */
|
|
|
|
int ntrec = NTREC; /* # tape blocks in each tape record */
|
2020-04-04 00:56:56 +00:00
|
|
|
long blocksperfile; /* number of blocks per output file */
|
1994-05-26 06:35:07 +00:00
|
|
|
int cartridge = 0; /* Assume non-cartridge tape */
|
|
|
|
char *host = NULL; /* remote host (if any) */
|
2020-04-04 00:56:56 +00:00
|
|
|
time_t tstart_writing; /* when started writing the first tape block */
|
|
|
|
time_t tend_writing; /* after writing the last tape block */
|
|
|
|
int passno; /* current dump pass number */
|
|
|
|
struct fs *sblock; /* the file system super block */
|
|
|
|
long dev_bsize = 1; /* recalculated below */
|
|
|
|
int dev_bshift; /* log2(dev_bsize) */
|
|
|
|
int tp_bshift; /* log2(TP_BSIZE) */
|
|
|
|
int snapdump = 0; /* dumping live filesystem, so use snapshot */
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2002-12-03 18:21:09 +00:00
|
|
|
static char *getmntpt(char *, int *);
|
2002-03-20 22:49:40 +00:00
|
|
|
static long numarg(const char *, long, long);
|
|
|
|
static void obsolete(int *, char **[]);
|
|
|
|
static void usage(void) __dead2;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
int
|
2002-03-20 22:49:40 +00:00
|
|
|
main(int argc, char *argv[])
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2001-11-16 22:13:44 +00:00
|
|
|
struct stat sb;
|
2001-11-17 00:06:55 +00:00
|
|
|
ino_t ino;
|
|
|
|
int dirty;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
2002-12-03 18:21:09 +00:00
|
|
|
struct fstab *dt;
|
|
|
|
char *map, *mntpt;
|
|
|
|
int ch, mode, mntflags;
|
2018-06-11 20:38:30 +00:00
|
|
|
int i, ret, anydirskipped, bflag = 0, Tflag = 0, honorlevel = 1;
|
2018-06-11 19:35:41 +00:00
|
|
|
int just_estimate = 0;
|
1994-05-26 06:35:07 +00:00
|
|
|
ino_t maxino;
|
2001-10-28 20:01:38 +00:00
|
|
|
char *tmsg;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2002-06-21 06:18:05 +00:00
|
|
|
spcl.c_date = _time_to_time64(time(NULL));
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
tsize = 0; /* Default later, based on 'c' option for cart tapes */
|
|
|
|
dumpdates = _PATH_DUMPDATES;
|
2004-04-13 02:58:06 +00:00
|
|
|
popenout = NULL;
|
|
|
|
tape = NULL;
|
1994-05-26 06:35:07 +00:00
|
|
|
if (TP_BSIZE / DEV_BSIZE == 0 || TP_BSIZE % DEV_BSIZE != 0)
|
|
|
|
quit("TP_BSIZE must be a multiple of DEV_BSIZE\n");
|
2008-05-24 05:20:46 +00:00
|
|
|
level = 0;
|
2008-05-23 23:13:14 +00:00
|
|
|
rsync_friendly = 0;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
if (argc < 2)
|
|
|
|
usage();
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
obsolete(&argc, &argv);
|
2003-05-01 21:18:36 +00:00
|
|
|
while ((ch = getopt(argc, argv,
|
2008-05-23 23:13:14 +00:00
|
|
|
"0123456789aB:b:C:cD:d:f:h:LnP:RrSs:T:uWw")) != -1)
|
1997-03-11 12:09:50 +00:00
|
|
|
switch (ch) {
|
|
|
|
/* dump level */
|
|
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
|
|
case '5': case '6': case '7': case '8': case '9':
|
2008-05-24 05:20:46 +00:00
|
|
|
level = 10 * level + ch - '0';
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'a': /* `auto-size', Write to EOM. */
|
|
|
|
unlimited = 1;
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'B': /* blocks per output file */
|
|
|
|
blocksperfile = numarg("number of blocks per file",
|
|
|
|
1L, 0L);
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'b': /* blocks per tape write */
|
1997-03-11 12:09:50 +00:00
|
|
|
ntrec = numarg("number of blocks per write",
|
|
|
|
1L, 1000L);
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
2003-02-23 01:50:07 +00:00
|
|
|
case 'C':
|
|
|
|
cachesize = numarg("cachesize", 0, 0) * 1024 * 1024;
|
|
|
|
break;
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
case 'c': /* Tape is cart. not 9-track */
|
|
|
|
cartridge = 1;
|
|
|
|
break;
|
|
|
|
|
2003-02-23 01:50:07 +00:00
|
|
|
case 'D':
|
|
|
|
dumpdates = optarg;
|
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'd': /* density, in bits per inch */
|
|
|
|
density = numarg("density", 10L, 327670L) / 10;
|
|
|
|
if (density >= 625 && !bflag)
|
|
|
|
ntrec = HIGHDENSITYTREC;
|
1997-02-01 23:44:19 +00:00
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'f': /* output file */
|
2004-04-13 02:58:06 +00:00
|
|
|
if (popenout != NULL)
|
|
|
|
errx(X_STARTUP, "You cannot use the P and f "
|
|
|
|
"flags together.\n");
|
1997-03-11 12:09:50 +00:00
|
|
|
tape = optarg;
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'h':
|
|
|
|
honorlevel = numarg("honor level", 0L, 10L);
|
1994-05-26 06:35:07 +00:00
|
|
|
break;
|
|
|
|
|
2002-12-03 18:21:09 +00:00
|
|
|
case 'L':
|
|
|
|
snapdump = 1;
|
|
|
|
break;
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
case 'n': /* notify operators */
|
|
|
|
notify = 1;
|
|
|
|
break;
|
|
|
|
|
2004-04-13 02:58:06 +00:00
|
|
|
case 'P':
|
|
|
|
if (tape != NULL)
|
|
|
|
errx(X_STARTUP, "You cannot use the P and f "
|
|
|
|
"flags together.\n");
|
|
|
|
popenout = optarg;
|
|
|
|
break;
|
|
|
|
|
2008-05-23 23:13:14 +00:00
|
|
|
case 'r': /* store slightly less data to be friendly to rsync */
|
|
|
|
if (rsync_friendly < 1)
|
|
|
|
rsync_friendly = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'R': /* store even less data to be friendlier to rsync */
|
|
|
|
if (rsync_friendly < 2)
|
|
|
|
rsync_friendly = 2;
|
|
|
|
break;
|
|
|
|
|
2002-03-01 20:54:23 +00:00
|
|
|
case 'S': /* exit after estimating # of tapes */
|
|
|
|
just_estimate = 1;
|
|
|
|
break;
|
|
|
|
|
2003-02-23 01:50:07 +00:00
|
|
|
case 's': /* tape size, feet */
|
|
|
|
tsize = numarg("tape size", 1L, 0L) * 12 * 10;
|
|
|
|
break;
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'T': /* time of last dump */
|
|
|
|
spcl.c_ddate = unctime(optarg);
|
|
|
|
if (spcl.c_ddate < 0) {
|
|
|
|
(void)fprintf(stderr, "bad time \"%s\"\n",
|
|
|
|
optarg);
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1997-03-11 12:09:50 +00:00
|
|
|
}
|
|
|
|
Tflag = 1;
|
2008-05-24 05:20:46 +00:00
|
|
|
lastlevel = -1;
|
1997-03-11 12:09:50 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'u': /* update /etc/dumpdates */
|
|
|
|
uflag = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'W': /* what to do */
|
|
|
|
case 'w':
|
|
|
|
lastdump(ch);
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_FINOK); /* do nothing else */
|
1997-03-11 12:09:50 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
default:
|
1997-03-11 12:09:50 +00:00
|
|
|
usage();
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
1997-03-11 12:09:50 +00:00
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
if (argc < 1) {
|
2002-08-21 18:11:48 +00:00
|
|
|
(void)fprintf(stderr, "Must specify disk or file system\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
disk = *argv++;
|
|
|
|
argc--;
|
|
|
|
if (argc >= 1) {
|
|
|
|
(void)fprintf(stderr, "Unknown arguments to dump:");
|
|
|
|
while (argc--)
|
|
|
|
(void)fprintf(stderr, " %s", *argv++);
|
|
|
|
(void)fprintf(stderr, "\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2008-05-24 05:20:46 +00:00
|
|
|
if (rsync_friendly && (level > 0)) {
|
2008-05-23 23:13:14 +00:00
|
|
|
(void)fprintf(stderr, "%s %s\n", "rsync friendly options",
|
|
|
|
"can be used only with level 0 dumps.");
|
|
|
|
exit(X_STARTUP);
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (Tflag && uflag) {
|
|
|
|
(void)fprintf(stderr,
|
|
|
|
"You cannot use the T and u flags together.\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2004-04-13 02:58:06 +00:00
|
|
|
if (popenout) {
|
|
|
|
tape = "child pipeline process";
|
|
|
|
} else if (tape == NULL && (tape = getenv("TAPE")) == NULL)
|
|
|
|
tape = _PATH_DEFTAPE;
|
1994-05-26 06:35:07 +00:00
|
|
|
if (strcmp(tape, "-") == 0) {
|
|
|
|
pipeout++;
|
|
|
|
tape = "standard output";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (blocksperfile)
|
2016-05-01 02:24:05 +00:00
|
|
|
blocksperfile = rounddown(blocksperfile, ntrec);
|
1997-02-01 23:44:19 +00:00
|
|
|
else if (!unlimited) {
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Determine how to default tape size and density
|
|
|
|
*
|
|
|
|
* density tape size
|
|
|
|
* 9-track 1600 bpi (160 bytes/.1") 2300 ft.
|
|
|
|
* 9-track 6250 bpi (625 bytes/.1") 2300 ft.
|
|
|
|
* cartridge 8000 bpi (100 bytes/.1") 1700 ft.
|
|
|
|
* (450*4 - slop)
|
1995-11-18 18:00:43 +00:00
|
|
|
* hilit19 hits again: "
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
|
|
|
if (density == 0)
|
|
|
|
density = cartridge ? 100 : 160;
|
|
|
|
if (tsize == 0)
|
|
|
|
tsize = cartridge ? 1700L*120L : 2300L*120L;
|
|
|
|
}
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
if (strchr(tape, ':')) {
|
1994-05-26 06:35:07 +00:00
|
|
|
host = tape;
|
1997-03-11 12:09:50 +00:00
|
|
|
tape = strchr(host, ':');
|
1994-05-26 06:35:07 +00:00
|
|
|
*tape++ = '\0';
|
|
|
|
#ifdef RDUMP
|
2012-01-03 18:51:58 +00:00
|
|
|
if (strchr(tape, '\n')) {
|
1997-01-07 20:48:24 +00:00
|
|
|
(void)fprintf(stderr, "invalid characters in tape\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1997-01-07 20:48:24 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (rmthost(host) == 0)
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1994-05-26 06:35:07 +00:00
|
|
|
#else
|
|
|
|
(void)fprintf(stderr, "remote dump not enabled\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1994-05-26 06:35:07 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
(void)setuid(getuid()); /* rmthost() is the only reason to be setuid */
|
|
|
|
|
|
|
|
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGHUP, sig);
|
|
|
|
if (signal(SIGTRAP, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGTRAP, sig);
|
|
|
|
if (signal(SIGFPE, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGFPE, sig);
|
|
|
|
if (signal(SIGBUS, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGBUS, sig);
|
|
|
|
if (signal(SIGSEGV, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGSEGV, sig);
|
|
|
|
if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
|
|
|
|
signal(SIGTERM, sig);
|
|
|
|
if (signal(SIGINT, interrupt) == SIG_IGN)
|
|
|
|
signal(SIGINT, SIG_IGN);
|
|
|
|
|
2003-04-07 11:34:12 +00:00
|
|
|
dump_getfstab(); /* /etc/fstab snarfed */
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* disk can be either the full special file name,
|
|
|
|
* the suffix of the special file name,
|
|
|
|
* the special name missing the leading '/',
|
2002-08-21 18:11:48 +00:00
|
|
|
* the file system name with or without the leading '/'.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
|
|
|
dt = fstabsearch(disk);
|
|
|
|
if (dt != NULL) {
|
|
|
|
disk = rawname(dt->fs_spec);
|
2006-08-15 17:53:37 +00:00
|
|
|
if (disk == NULL)
|
|
|
|
errx(X_STARTUP, "%s: unknown file system", dt->fs_spec);
|
1994-05-26 06:35:07 +00:00
|
|
|
(void)strncpy(spcl.c_dev, dt->fs_spec, NAMELEN);
|
|
|
|
(void)strncpy(spcl.c_filesys, dt->fs_file, NAMELEN);
|
|
|
|
} else {
|
|
|
|
(void)strncpy(spcl.c_dev, disk, NAMELEN);
|
2002-08-21 18:11:48 +00:00
|
|
|
(void)strncpy(spcl.c_filesys, "an unlisted file system",
|
1994-05-26 06:35:07 +00:00
|
|
|
NAMELEN);
|
|
|
|
}
|
1997-01-07 20:48:24 +00:00
|
|
|
spcl.c_dev[NAMELEN-1]='\0';
|
|
|
|
spcl.c_filesys[NAMELEN-1]='\0';
|
2002-12-03 18:21:09 +00:00
|
|
|
|
2016-04-19 19:13:33 +00:00
|
|
|
if ((mntpt = getmntpt(disk, &mntflags)) != NULL) {
|
2004-04-12 20:19:32 +00:00
|
|
|
if (mntflags & MNT_RDONLY) {
|
|
|
|
if (snapdump != 0) {
|
|
|
|
msg("WARNING: %s\n",
|
|
|
|
"-L ignored for read-only filesystem.");
|
|
|
|
snapdump = 0;
|
|
|
|
}
|
|
|
|
} else if (snapdump == 0) {
|
2004-04-13 02:58:06 +00:00
|
|
|
msg("WARNING: %s\n",
|
|
|
|
"should use -L when dumping live read-write "
|
2004-04-12 20:19:32 +00:00
|
|
|
"filesystems!");
|
2002-12-03 18:21:09 +00:00
|
|
|
} else {
|
2003-11-16 08:01:58 +00:00
|
|
|
char snapname[BUFSIZ], snapcmd[BUFSIZ];
|
|
|
|
|
2005-01-21 22:13:25 +00:00
|
|
|
snprintf(snapname, sizeof snapname, "%s/.snap", mntpt);
|
|
|
|
if ((stat(snapname, &sb) < 0) || !S_ISDIR(sb.st_mode)) {
|
|
|
|
msg("WARNING: %s %s\n",
|
|
|
|
"-L requested but snapshot location",
|
|
|
|
snapname);
|
|
|
|
msg(" %s: %s\n",
|
|
|
|
"is not a directory",
|
|
|
|
"dump downgraded, -L ignored");
|
|
|
|
snapdump = 0;
|
|
|
|
} else {
|
|
|
|
snprintf(snapname, sizeof snapname,
|
|
|
|
"%s/.snap/dump_snapshot", mntpt);
|
|
|
|
snprintf(snapcmd, sizeof snapcmd, "%s %s %s",
|
|
|
|
_PATH_MKSNAP_FFS, mntpt, snapname);
|
|
|
|
unlink(snapname);
|
|
|
|
if (system(snapcmd) != 0)
|
|
|
|
errx(X_STARTUP, "Cannot create %s: %s\n",
|
|
|
|
snapname, strerror(errno));
|
|
|
|
if ((diskfd = open(snapname, O_RDONLY)) < 0) {
|
|
|
|
unlink(snapname);
|
|
|
|
errx(X_STARTUP, "Cannot open %s: %s\n",
|
|
|
|
snapname, strerror(errno));
|
|
|
|
}
|
2002-12-03 18:21:09 +00:00
|
|
|
unlink(snapname);
|
2005-01-21 22:13:25 +00:00
|
|
|
if (fstat(diskfd, &sb) != 0)
|
|
|
|
err(X_STARTUP, "%s: stat", snapname);
|
|
|
|
spcl.c_date = _time_to_time64(sb.st_mtime);
|
2002-12-03 18:21:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (snapdump != 0) {
|
|
|
|
msg("WARNING: Cannot use -L on an unmounted filesystem.\n");
|
|
|
|
snapdump = 0;
|
|
|
|
}
|
|
|
|
if (snapdump == 0) {
|
|
|
|
if ((diskfd = open(disk, O_RDONLY)) < 0)
|
|
|
|
err(X_STARTUP, "Cannot open %s", disk);
|
|
|
|
if (fstat(diskfd, &sb) != 0)
|
|
|
|
err(X_STARTUP, "%s: stat", disk);
|
|
|
|
if (S_ISDIR(sb.st_mode))
|
|
|
|
errx(X_STARTUP, "%s: unknown file system", disk);
|
|
|
|
}
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
(void)strcpy(spcl.c_label, "none");
|
|
|
|
(void)gethostname(spcl.c_host, NAMELEN);
|
2008-05-24 05:20:46 +00:00
|
|
|
spcl.c_level = level;
|
1994-05-26 06:35:07 +00:00
|
|
|
spcl.c_type = TS_TAPE;
|
2008-05-23 23:13:14 +00:00
|
|
|
if (rsync_friendly) {
|
|
|
|
/* don't store real dump times */
|
|
|
|
spcl.c_date = 0;
|
|
|
|
spcl.c_ddate = 0;
|
|
|
|
}
|
2001-10-28 20:01:38 +00:00
|
|
|
if (spcl.c_date == 0) {
|
|
|
|
tmsg = "the epoch\n";
|
|
|
|
} else {
|
2002-06-21 06:18:05 +00:00
|
|
|
time_t t = _time64_to_time(spcl.c_date);
|
2001-10-28 20:01:38 +00:00
|
|
|
tmsg = ctime(&t);
|
|
|
|
}
|
2008-05-24 05:20:46 +00:00
|
|
|
msg("Date of this level %d dump: %s", level, tmsg);
|
2002-12-03 18:21:09 +00:00
|
|
|
|
2008-05-23 23:13:14 +00:00
|
|
|
if (!Tflag && (!rsync_friendly))
|
2002-12-03 18:21:09 +00:00
|
|
|
getdumptime(); /* /etc/dumpdates snarfed */
|
2001-10-28 20:01:38 +00:00
|
|
|
if (spcl.c_ddate == 0) {
|
|
|
|
tmsg = "the epoch\n";
|
|
|
|
} else {
|
2002-06-21 06:18:05 +00:00
|
|
|
time_t t = _time64_to_time(spcl.c_ddate);
|
2001-10-28 20:01:38 +00:00
|
|
|
tmsg = ctime(&t);
|
|
|
|
}
|
2008-05-24 05:20:46 +00:00
|
|
|
if (lastlevel < 0)
|
|
|
|
msg("Date of last (level unknown) dump: %s", tmsg);
|
|
|
|
else
|
|
|
|
msg("Date of last level %d dump: %s", lastlevel, tmsg);
|
2002-12-03 18:21:09 +00:00
|
|
|
|
|
|
|
msg("Dumping %s%s ", snapdump ? "snapshot of ": "", disk);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (dt != NULL)
|
|
|
|
msgtail("(%s) ", dt->fs_file);
|
|
|
|
if (host)
|
|
|
|
msgtail("to %s on host %s\n", tape, host);
|
|
|
|
else
|
|
|
|
msgtail("to %s\n", tape);
|
|
|
|
|
|
|
|
sync();
|
Normally when an attempt is made to mount a UFS/FFS filesystem whose
superblock has a check-hash error, an error message noting the
superblock check-hash failure is printed and the mount fails. The
administrator then runs fsck to repair the filesystem and when
successful, the filesystem can once again be mounted.
This approach fails if the filesystem in question is a root filesystem
from which you are trying to boot. Here, the loader fails when trying
to access the filesystem to get the kernel to boot. So it is necessary
to allow the loader to ignore the superblock check-hash error and make
a best effort to read the kernel. The filesystem may be suffiently
corrupted that the read attempt fails, but there is no harm in trying
since the loader makes no attempt to write to the filesystem.
Once the kernel is loaded and starts to run, it attempts to mount its
root filesystem. Once again, failure means that it breaks to its prompt
to ask where to get its root filesystem. Unless you have an alternate
root filesystem, you are stuck.
Since the root filesystem is initially mounted read-only, it is
safe to make an attempt to mount the root filesystem with the failed
superblock check-hash. Thus, when asked to mount a root filesystem
with a failed superblock check-hash, the kernel prints a warning
message that the root filesystem superblock check-hash needs repair,
but notes that it is ignoring the error and proceeding. It does
mark the filesystem as needing an fsck which prevents it from being
enabled for writing until fsck has been run on it. The net effect
is that the reboot fails to single user, but at least at that point
the administrator has the tools at hand to fix the problem.
Reported by: Rick Macklem (rmacklem@)
Discussed with: Warner Losh (imp@)
Sponsored by: Netflix
2018-12-06 00:09:39 +00:00
|
|
|
if ((ret = sbget(diskfd, &sblock, STDSB)) != 0) {
|
2018-01-26 00:58:32 +00:00
|
|
|
switch (ret) {
|
|
|
|
case ENOENT:
|
|
|
|
warn("Cannot find file system superblock");
|
|
|
|
return (1);
|
|
|
|
default:
|
|
|
|
warn("Unable to read file system superblock");
|
|
|
|
return (1);
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
dev_bsize = sblock->fs_fsize / fsbtodb(sblock, 1);
|
|
|
|
dev_bshift = ffs(dev_bsize) - 1;
|
|
|
|
if (dev_bsize != (1 << dev_bshift))
|
2002-07-08 00:29:23 +00:00
|
|
|
quit("dev_bsize (%ld) is not a power of 2", dev_bsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
tp_bshift = ffs(TP_BSIZE) - 1;
|
|
|
|
if (TP_BSIZE != (1 << tp_bshift))
|
|
|
|
quit("TP_BSIZE (%d) is not a power of 2", TP_BSIZE);
|
|
|
|
maxino = sblock->fs_ipg * sblock->fs_ncg;
|
2002-09-25 04:06:37 +00:00
|
|
|
mapsize = roundup(howmany(maxino, CHAR_BIT), TP_BSIZE);
|
1994-05-26 06:35:07 +00:00
|
|
|
usedinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
|
|
|
|
dumpdirmap = (char *)calloc((unsigned) mapsize, sizeof(char));
|
|
|
|
dumpinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
|
|
|
|
tapesize = 3 * (howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
|
|
|
|
|
|
|
|
nonodump = spcl.c_level < honorlevel;
|
|
|
|
|
2002-02-16 21:05:16 +00:00
|
|
|
passno = 1;
|
|
|
|
setproctitle("%s: pass 1: regular files", disk);
|
1994-05-26 06:35:07 +00:00
|
|
|
msg("mapping (Pass I) [regular files]\n");
|
|
|
|
anydirskipped = mapfiles(maxino, &tapesize);
|
|
|
|
|
2002-02-16 21:05:16 +00:00
|
|
|
passno = 2;
|
|
|
|
setproctitle("%s: pass 2: directories", disk);
|
1994-05-26 06:35:07 +00:00
|
|
|
msg("mapping (Pass II) [directories]\n");
|
|
|
|
while (anydirskipped) {
|
|
|
|
anydirskipped = mapdirs(maxino, &tapesize);
|
|
|
|
}
|
|
|
|
|
1997-02-01 23:44:19 +00:00
|
|
|
if (pipeout || unlimited) {
|
1994-05-26 06:35:07 +00:00
|
|
|
tapesize += 10; /* 10 trailer blocks */
|
|
|
|
msg("estimated %ld tape blocks.\n", tapesize);
|
|
|
|
} else {
|
|
|
|
double fetapes;
|
|
|
|
|
|
|
|
if (blocksperfile)
|
|
|
|
fetapes = (double) tapesize / blocksperfile;
|
|
|
|
else if (cartridge) {
|
|
|
|
/* Estimate number of tapes, assuming streaming stops at
|
|
|
|
the end of each block written, and not in mid-block.
|
|
|
|
Assume no erroneous blocks; this can be compensated
|
|
|
|
for with an artificially low tape size. */
|
1995-05-30 06:12:45 +00:00
|
|
|
fetapes =
|
1997-01-07 20:15:04 +00:00
|
|
|
( (double) tapesize /* blocks */
|
1994-05-26 06:35:07 +00:00
|
|
|
* TP_BSIZE /* bytes/block */
|
1995-11-18 18:00:43 +00:00
|
|
|
* (1.0/density) /* 0.1" / byte " */
|
1994-05-26 06:35:07 +00:00
|
|
|
+
|
1997-01-07 20:15:04 +00:00
|
|
|
(double) tapesize /* blocks */
|
1994-05-26 06:35:07 +00:00
|
|
|
* (1.0/ntrec) /* streaming-stops per block */
|
1995-11-18 18:00:43 +00:00
|
|
|
* 15.48 /* 0.1" / streaming-stop " */
|
|
|
|
) * (1.0 / tsize ); /* tape / 0.1" " */
|
1994-05-26 06:35:07 +00:00
|
|
|
} else {
|
|
|
|
/* Estimate number of tapes, for old fashioned 9-track
|
|
|
|
tape */
|
|
|
|
int tenthsperirg = (density == 625) ? 3 : 7;
|
|
|
|
fetapes =
|
1997-01-07 20:15:04 +00:00
|
|
|
( (double) tapesize /* blocks */
|
1994-05-26 06:35:07 +00:00
|
|
|
* TP_BSIZE /* bytes / block */
|
1995-11-18 18:00:43 +00:00
|
|
|
* (1.0/density) /* 0.1" / byte " */
|
1994-05-26 06:35:07 +00:00
|
|
|
+
|
1997-01-07 20:15:04 +00:00
|
|
|
(double) tapesize /* blocks */
|
1994-05-26 06:35:07 +00:00
|
|
|
* (1.0/ntrec) /* IRG's / block */
|
1995-11-18 18:00:43 +00:00
|
|
|
* tenthsperirg /* 0.1" / IRG " */
|
|
|
|
) * (1.0 / tsize ); /* tape / 0.1" " */
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
etapes = fetapes; /* truncating assignment */
|
|
|
|
etapes++;
|
|
|
|
/* count the dumped inodes map on each additional tape */
|
|
|
|
tapesize += (etapes - 1) *
|
|
|
|
(howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
|
|
|
|
tapesize += etapes + 10; /* headers + 10 trailer blks */
|
|
|
|
msg("estimated %ld tape blocks on %3.2f tape(s).\n",
|
|
|
|
tapesize, fetapes);
|
|
|
|
}
|
|
|
|
|
2002-03-01 20:54:23 +00:00
|
|
|
/*
|
|
|
|
* If the user only wants an estimate of the number of
|
|
|
|
* tapes, exit now.
|
|
|
|
*/
|
|
|
|
if (just_estimate)
|
|
|
|
exit(0);
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Allocate tape buffer.
|
|
|
|
*/
|
|
|
|
if (!alloctape())
|
1998-06-15 06:58:13 +00:00
|
|
|
quit(
|
|
|
|
"can't allocate tape buffers - try a smaller blocking factor.\n");
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
startnewtape(1);
|
|
|
|
(void)time((time_t *)&(tstart_writing));
|
|
|
|
dumpmap(usedinomap, TS_CLRI, maxino - 1);
|
|
|
|
|
2002-02-16 21:05:16 +00:00
|
|
|
passno = 3;
|
|
|
|
setproctitle("%s: pass 3: directories", disk);
|
1994-05-26 06:35:07 +00:00
|
|
|
msg("dumping (Pass III) [directories]\n");
|
|
|
|
dirty = 0; /* XXX just to get gcc to shut up */
|
|
|
|
for (map = dumpdirmap, ino = 1; ino < maxino; ino++) {
|
2002-09-25 04:06:37 +00:00
|
|
|
if (((ino - 1) % CHAR_BIT) == 0) /* map is offset by 1 */
|
1994-05-26 06:35:07 +00:00
|
|
|
dirty = *map++;
|
|
|
|
else
|
|
|
|
dirty >>= 1;
|
|
|
|
if ((dirty & 1) == 0)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Skip directory inodes deleted and maybe reallocated
|
|
|
|
*/
|
2018-11-14 00:21:52 +00:00
|
|
|
dp = getino(ino, &mode);
|
2018-03-17 12:59:55 +00:00
|
|
|
if (mode != IFDIR)
|
1994-05-26 06:35:07 +00:00
|
|
|
continue;
|
|
|
|
(void)dumpino(dp, ino);
|
|
|
|
}
|
|
|
|
|
2002-02-16 21:05:16 +00:00
|
|
|
passno = 4;
|
|
|
|
setproctitle("%s: pass 4: regular files", disk);
|
1994-05-26 06:35:07 +00:00
|
|
|
msg("dumping (Pass IV) [regular files]\n");
|
|
|
|
for (map = dumpinomap, ino = 1; ino < maxino; ino++) {
|
2002-09-25 04:06:37 +00:00
|
|
|
if (((ino - 1) % CHAR_BIT) == 0) /* map is offset by 1 */
|
1994-05-26 06:35:07 +00:00
|
|
|
dirty = *map++;
|
|
|
|
else
|
|
|
|
dirty >>= 1;
|
|
|
|
if ((dirty & 1) == 0)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Skip inodes deleted and reallocated as directories.
|
|
|
|
*/
|
2018-11-14 00:21:52 +00:00
|
|
|
dp = getino(ino, &mode);
|
2018-03-17 12:59:55 +00:00
|
|
|
if (mode == IFDIR)
|
1994-05-26 06:35:07 +00:00
|
|
|
continue;
|
|
|
|
(void)dumpino(dp, ino);
|
|
|
|
}
|
|
|
|
|
1995-11-18 18:00:43 +00:00
|
|
|
(void)time((time_t *)&(tend_writing));
|
1994-05-26 06:35:07 +00:00
|
|
|
spcl.c_type = TS_END;
|
|
|
|
for (i = 0; i < ntrec; i++)
|
|
|
|
writeheader(maxino - 1);
|
|
|
|
if (pipeout)
|
2002-07-08 00:29:23 +00:00
|
|
|
msg("DUMP: %jd tape blocks\n", (intmax_t)spcl.c_tapea);
|
1994-05-26 06:35:07 +00:00
|
|
|
else
|
2002-07-08 00:29:23 +00:00
|
|
|
msg("DUMP: %jd tape blocks on %d volume%s\n",
|
|
|
|
(intmax_t)spcl.c_tapea, spcl.c_volume,
|
1999-05-24 00:35:47 +00:00
|
|
|
(spcl.c_volume == 1) ? "" : "s");
|
1995-11-18 18:00:43 +00:00
|
|
|
|
|
|
|
/* report dump performance, avoid division through zero */
|
|
|
|
if (tend_writing - tstart_writing == 0)
|
|
|
|
msg("finished in less than a second\n");
|
|
|
|
else
|
2003-11-14 13:07:38 +00:00
|
|
|
msg("finished in %jd seconds, throughput %jd KBytes/sec\n",
|
|
|
|
(intmax_t)tend_writing - tstart_writing,
|
|
|
|
(intmax_t)(spcl.c_tapea /
|
2002-07-08 00:29:23 +00:00
|
|
|
(tend_writing - tstart_writing)));
|
1995-11-18 18:00:43 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
putdumptime();
|
|
|
|
trewind();
|
2001-01-28 21:21:37 +00:00
|
|
|
broadcast("DUMP IS DONE!\a\a\n");
|
1994-05-26 06:35:07 +00:00
|
|
|
msg("DUMP IS DONE\n");
|
|
|
|
Exit(X_FINOK);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
static void
|
2002-03-20 22:49:40 +00:00
|
|
|
usage(void)
|
1997-03-11 12:09:50 +00:00
|
|
|
{
|
1997-06-10 11:14:04 +00:00
|
|
|
fprintf(stderr,
|
2003-05-01 21:18:36 +00:00
|
|
|
"usage: dump [-0123456789acLnSu] [-B records] [-b blocksize] [-C cachesize]\n"
|
2005-02-10 09:19:34 +00:00
|
|
|
" [-D dumpdates] [-d density] [-f file | -P pipecommand] [-h level]\n"
|
|
|
|
" [-s feet] [-T date] filesystem\n"
|
2002-10-01 13:44:15 +00:00
|
|
|
" dump -W | -w\n");
|
1998-07-14 09:19:47 +00:00
|
|
|
exit(X_STARTUP);
|
1997-03-11 12:09:50 +00:00
|
|
|
}
|
|
|
|
|
2002-12-03 18:21:09 +00:00
|
|
|
/*
|
|
|
|
* Check to see if a disk is currently mounted.
|
|
|
|
*/
|
|
|
|
static char *
|
|
|
|
getmntpt(char *name, int *mntflagsp)
|
|
|
|
{
|
|
|
|
long mntsize, i;
|
|
|
|
struct statfs *mntbuf;
|
|
|
|
|
|
|
|
mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
|
|
|
|
for (i = 0; i < mntsize; i++) {
|
|
|
|
if (!strcmp(mntbuf[i].f_mntfromname, name)) {
|
|
|
|
*mntflagsp = mntbuf[i].f_flags;
|
|
|
|
return (mntbuf[i].f_mntonname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Pick up a numeric argument. It must be nonnegative and in the given
|
|
|
|
* range (except that a vmax of 0 means unlimited).
|
|
|
|
*/
|
|
|
|
static long
|
2002-03-20 22:49:40 +00:00
|
|
|
numarg(const char *meaning, long vmin, long vmax)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
1997-03-11 12:09:50 +00:00
|
|
|
char *p;
|
1994-05-26 06:35:07 +00:00
|
|
|
long val;
|
1997-03-11 12:09:50 +00:00
|
|
|
|
|
|
|
val = strtol(optarg, &p, 10);
|
|
|
|
if (*p)
|
|
|
|
errx(1, "illegal %s -- %s", meaning, optarg);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (val < vmin || (vmax && val > vmax))
|
1997-03-11 12:09:50 +00:00
|
|
|
errx(1, "%s must be between %ld and %ld", meaning, vmin, vmax);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (val);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2002-03-20 22:49:40 +00:00
|
|
|
sig(int signo)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
switch(signo) {
|
|
|
|
case SIGALRM:
|
|
|
|
case SIGBUS:
|
|
|
|
case SIGFPE:
|
|
|
|
case SIGHUP:
|
|
|
|
case SIGTERM:
|
|
|
|
case SIGTRAP:
|
|
|
|
if (pipeout)
|
|
|
|
quit("Signal on pipe: cannot recover\n");
|
|
|
|
msg("Rewriting attempted as response to unknown signal.\n");
|
|
|
|
(void)fflush(stderr);
|
|
|
|
(void)fflush(stdout);
|
|
|
|
close_rewind();
|
|
|
|
exit(X_REWRITE);
|
|
|
|
/* NOTREACHED */
|
|
|
|
case SIGSEGV:
|
|
|
|
msg("SIGSEGV: ABORTING!\n");
|
|
|
|
(void)signal(SIGSEGV, SIG_DFL);
|
|
|
|
(void)kill(0, SIGSEGV);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
2002-03-20 22:49:40 +00:00
|
|
|
rawname(char *cp)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2000-04-02 10:16:40 +00:00
|
|
|
struct stat sb;
|
|
|
|
|
2005-04-18 15:08:29 +00:00
|
|
|
/*
|
|
|
|
* Ensure that the device passed in is a raw device.
|
|
|
|
*/
|
|
|
|
if (stat(cp, &sb) == 0 && (sb.st_mode & S_IFMT) == S_IFCHR)
|
|
|
|
return (cp);
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2005-04-18 15:08:29 +00:00
|
|
|
/*
|
|
|
|
* Since there's only one device type now, we can't construct any
|
|
|
|
* better name, so we have to return NULL.
|
|
|
|
*/
|
|
|
|
return (NULL);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
/*
|
|
|
|
* obsolete --
|
|
|
|
* Change set of key letters and ordered arguments into something
|
|
|
|
* getopt(3) will like.
|
|
|
|
*/
|
|
|
|
static void
|
2002-03-20 22:49:40 +00:00
|
|
|
obsolete(int *argcp, char **argvp[])
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
1997-03-11 12:09:50 +00:00
|
|
|
int argc, flags;
|
|
|
|
char *ap, **argv, *flagsp, **nargv, *p;
|
|
|
|
|
|
|
|
/* Setup. */
|
|
|
|
argv = *argvp;
|
|
|
|
argc = *argcp;
|
|
|
|
|
2006-10-12 20:22:31 +00:00
|
|
|
/*
|
|
|
|
* Return if no arguments or first argument has leading
|
|
|
|
* dash or slash.
|
|
|
|
*/
|
1997-03-11 12:09:50 +00:00
|
|
|
ap = argv[1];
|
2006-10-12 20:22:31 +00:00
|
|
|
if (argc == 1 || *ap == '-' || *ap == '/')
|
1997-03-11 12:09:50 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Allocate space for new arguments. */
|
|
|
|
if ((*argvp = nargv = malloc((argc + 1) * sizeof(char *))) == NULL ||
|
|
|
|
(p = flagsp = malloc(strlen(ap) + 2)) == NULL)
|
|
|
|
err(1, NULL);
|
|
|
|
|
|
|
|
*nargv++ = *argv;
|
|
|
|
argv += 2;
|
|
|
|
|
|
|
|
for (flags = 0; *ap; ++ap) {
|
|
|
|
switch (*ap) {
|
|
|
|
case 'B':
|
|
|
|
case 'b':
|
|
|
|
case 'd':
|
|
|
|
case 'f':
|
2001-07-08 19:48:37 +00:00
|
|
|
case 'D':
|
2003-01-13 19:50:46 +00:00
|
|
|
case 'C':
|
1997-03-11 12:09:50 +00:00
|
|
|
case 'h':
|
|
|
|
case 's':
|
|
|
|
case 'T':
|
|
|
|
if (*argv == NULL) {
|
|
|
|
warnx("option requires an argument -- %c", *ap);
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
if ((nargv[0] = malloc(strlen(*argv) + 2 + 1)) == NULL)
|
|
|
|
err(1, NULL);
|
|
|
|
nargv[0][0] = '-';
|
|
|
|
nargv[0][1] = *ap;
|
|
|
|
(void)strcpy(&nargv[0][2], *argv);
|
|
|
|
++argv;
|
|
|
|
++nargv;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!flags) {
|
|
|
|
*p++ = '-';
|
|
|
|
flags = 1;
|
|
|
|
}
|
|
|
|
*p++ = *ap;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1997-03-11 12:09:50 +00:00
|
|
|
/* Terminate flags. */
|
|
|
|
if (flags) {
|
|
|
|
*p = '\0';
|
|
|
|
*nargv++ = flagsp;
|
2010-02-03 23:56:12 +00:00
|
|
|
} else
|
|
|
|
free(flagsp);
|
1997-03-11 12:09:50 +00:00
|
|
|
|
|
|
|
/* Copy remaining arguments. */
|
1998-06-15 06:58:13 +00:00
|
|
|
while ((*nargv++ = *argv++));
|
1997-03-11 12:09:50 +00:00
|
|
|
|
|
|
|
/* Update argument count. */
|
|
|
|
*argcp = nargv - *argvp - 1;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|