]> git.wh0rd.org Git - dump.git/blob - dump/main.c
Andreas Dilger fixes (CPP, ext2 features, const char etc).
[dump.git] / dump / main.c
1 /*
2  *      Ported to Linux's Second Extended File System as part of the
3  *      dump and restore backup suit
4  *      Remy Card <card@Linux.EU.Org>, 1994-1997
5  *      Stelian Pop <pop@noos.fr>, 1999-2000
6  *      Stelian Pop <pop@noos.fr> - AlcĂ´ve <www.alcove.fr>, 2000
7  */
8
9 /*-
10  * Copyright (c) 1980, 1991, 1993, 1994
11  *      The Regents of the University of California.  All rights reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgement:
23  *      This product includes software developed by the University of
24  *      California, Berkeley and its contributors.
25  * 4. Neither the name of the University nor the names of its contributors
26  *    may be used to endorse or promote products derived from this software
27  *    without specific prior written permission.
28  *
29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39  * SUCH DAMAGE.
40  */
41
42 #ifndef lint
43 static const char rcsid[] =
44         "$Id: main.c,v 1.35 2001/03/19 13:22:48 stelian Exp $";
45 #endif /* not lint */
46
47 #include <config.h>
48 #include <ctype.h>
49 #include <compaterr.h>
50 #include <fcntl.h>
51 #include <fstab.h>
52 #include <signal.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <unistd.h>
57
58 #include <sys/param.h>
59 #include <sys/time.h>
60 #ifdef __linux__
61 #include <linux/ext2_fs.h>
62 #include <ext2fs/ext2fs.h>
63 #include <time.h>
64 #include <sys/stat.h>
65 #include <bsdcompat.h>
66 #elif defined sunos
67 #include <sys/vnode.h>
68
69 #include <ufs/inode.h>
70 #include <ufs/fs.h>
71 #else
72 #include <ufs/ufs/dinode.h>
73 #include <ufs/ffs/fs.h>
74 #endif
75
76 #include <protocols/dumprestore.h>
77
78 #include "dump.h"
79 #include "pathnames.h"
80 #include "bylabel.h"
81
82 #ifndef SBOFF
83 #define SBOFF (SBLOCK * DEV_BSIZE)
84 #endif
85
86 int     notify = 0;     /* notify operator flag */
87 int     blockswritten = 0;      /* number of blocks written on current tape */
88 int     tapeno = 0;     /* current tape number */
89 int     density = 0;    /* density in bytes/0.1" " <- this is for hilit19 */
90 int     ntrec = NTREC;  /* # tape blocks in each tape record */
91 int     cartridge = 0;  /* Assume non-cartridge tape */
92 int     dokerberos = 0; /* Use Kerberos authentication */
93 long    dev_bsize = 1;  /* recalculated below */
94 long    blocksperfile;  /* output blocks per file */
95 char    *host = NULL;   /* remote host (if any) */
96 int     sizest = 0;     /* return size estimate only */
97 int     compressed = 0; /* use zlib to compress the output */
98 long long bytes_written = 0; /* total bytes written */
99 long    uncomprblks = 0;/* uncompressed blocks written */
100
101 #ifdef  __linux__
102 char    *__progname;
103 #endif
104
105 int     maxbsize = 64*1024;     /* XXX MAXBSIZE from sys/param.h */
106 static long numarg __P((const char *, long, long));
107 static void obsolete __P((int *, char **[]));
108 static void usage __P((void));
109
110 ino_t iexclude_list[IEXCLUDE_MAXNUM];   /* the inode exclude list */
111 int iexclude_num = 0;                   /* number of elements in the list */
112
113 int
114 main(int argc, char *argv[])
115 {
116         register ino_t ino;
117         register int dirty;
118         register struct dinode *dp;
119         register struct fstab *dt;
120         register char *map;
121         register int ch;
122         int i, anydirskipped, bflag = 0, Tflag = 0, honorlevel = 1;
123         ino_t maxino;
124 #ifdef  __linux__
125         errcode_t retval;
126         char directory[MAXPATHLEN];
127         char pathname[MAXPATHLEN];
128 #endif
129         time_t tnow;
130         char *diskparam;
131
132         spcl.c_label[0] = '\0';
133         spcl.c_date = 0;
134 #ifdef  __linux__
135         (void)time4(&spcl.c_date);
136 #else
137         (void)time((time_t *)&spcl.c_date);
138 #endif
139
140 #ifdef __linux__
141         __progname = argv[0];
142         directory[0] = 0;
143         initialize_ext2_error_table();
144 #endif
145
146         tsize = 0;      /* Default later, based on 'c' option for cart tapes */
147         unlimited = 1;
148         eot_script = NULL;
149         if ((tapeprefix = getenv("TAPE")) == NULL)
150                 tapeprefix = _PATH_DEFTAPE;
151         dumpdates = _PATH_DUMPDATES;
152         if (TP_BSIZE / DEV_BSIZE == 0 || TP_BSIZE % DEV_BSIZE != 0)
153                 quit("TP_BSIZE must be a multiple of DEV_BSIZE\n");
154         level = '0';
155
156         if (argc < 2)
157                 usage();
158
159         obsolete(&argc, &argv);
160
161         while ((ch = getopt(argc, argv,
162                             "0123456789aB:b:cd:e:f:F:h:L:"
163 #ifdef KERBEROS
164                             "k"
165 #endif
166                             "Mns:ST:uWw"
167 #ifdef HAVE_ZLIB
168                             "z"
169 #endif
170                             )) != -1)
171 #undef optstring
172                 switch (ch) {
173                 /* dump level */
174                 case '0': case '1': case '2': case '3': case '4':
175                 case '5': case '6': case '7': case '8': case '9':
176                         level = ch;
177                         break;
178
179                 case 'a':               /* `auto-size', Write to EOM. */
180                         unlimited = 1;
181                         break;
182
183                 case 'B':               /* blocks per output file */
184                         unlimited = 0;
185                         blocksperfile = numarg("number of blocks per file",
186                             1L, 0L);
187                         break;
188
189                 case 'b':               /* blocks per tape write */
190                         ntrec = numarg("number of blocks per write",
191                             1L, 1000L);
192                         if (ntrec > maxbsize/1024) {
193                                 msg("Please choose a blocksize <= %dKB\n",
194                                         maxbsize/1024);
195                                 exit(X_STARTUP);
196                         }
197                         bflag = 1;
198                         break;
199
200                 case 'c':               /* Tape is cart. not 9-track */
201                         unlimited = 0;
202                         cartridge = 1;
203                         break;
204
205                 case 'd':               /* density, in bits per inch */
206                         unlimited = 0;
207                         density = numarg("density", 10L, 327670L) / 10;
208                         if (density >= 625 && !bflag)
209                                 ntrec = HIGHDENSITYTREC;
210                         break;
211                         
212                                         /* 04-Feb-00 ILC */
213                 case 'e':               /* exclude an inode */
214                         if (iexclude_num == IEXCLUDE_MAXNUM) {
215                                 (void)fprintf(stderr, "Too many -e options\n");
216                                 exit(X_STARTUP);
217                         }
218                         iexclude_list[iexclude_num++] = numarg("inode to exclude",0L,0L);
219                         if (iexclude_list[iexclude_num-1] <= ROOTINO) {
220                                 (void)fprintf(stderr, "Cannot exclude inode %ld\n", (long)iexclude_list[iexclude_num-1]);
221                                 exit(X_STARTUP);
222                         }
223                         msg("Added %d to exclude list\n",
224                             iexclude_list[iexclude_num-1]);
225                         break;
226
227                 case 'f':               /* output file */
228                         tapeprefix = optarg;
229                         break;
230
231                 case 'F':               /* end of tape script */
232                         eot_script = optarg;
233                         break;
234
235                 case 'h':
236                         honorlevel = numarg("honor level", 0L, 10L);
237                         break;
238
239 #ifdef KERBEROS
240                 case 'k':
241                         dokerberos = 1;
242                         break;
243 #endif
244
245                 case 'L':
246                         /*
247                          * Note that although there are LBLSIZE characters,
248                          * the last must be '\0', so the limit on strlen()
249                          * is really LBLSIZE-1.
250                          */
251                         strncpy(spcl.c_label, optarg, LBLSIZE);
252                         spcl.c_label[LBLSIZE-1] = '\0';
253                         if (strlen(optarg) > LBLSIZE-1) {
254                                 msg(
255                 "WARNING Label `%s' is larger than limit of %d characters.\n",
256                                     optarg, LBLSIZE-1);
257                                 msg("WARNING: Using truncated label `%s'.\n",
258                                     spcl.c_label);
259                         }
260                         break;
261
262                 case 'M':               /* multi-volume flag */
263                         Mflag = 1;
264                         break;
265
266                 case 'n':               /* notify operators */
267                         notify = 1;
268                         break;
269
270                 case 's':               /* tape size, feet */
271                         unlimited = 0;
272                         tsize = numarg("tape size", 1L, 0L) * 12 * 10;
273                         break;
274
275                 case 'S':
276                         sizest = 1;     /* return size estimate only */
277                         break;
278
279                 case 'T':               /* time of last dump */
280                         spcl.c_ddate = unctime(optarg);
281                         if (spcl.c_ddate < 0) {
282                                 (void)fprintf(stderr, "bad time \"%s\"\n",
283                                     optarg);
284                                 exit(X_STARTUP);
285                         }
286                         Tflag = 1;
287                         lastlevel = '?';
288                         break;
289
290                 case 'u':               /* update dumpdates */
291                         uflag = 1;
292                         break;
293
294                 case 'W':               /* what to do */
295                 case 'w':
296                         lastdump(ch);
297                         exit(X_FINOK);  /* do nothing else */
298 #ifdef HAVE_ZLIB
299                 case 'z':
300                         compressed = 1;
301                         break;
302 #endif /* HAVE_ZLIB */
303
304                 default:
305                         usage();
306                 }
307         argc -= optind;
308         argv += optind;
309
310         if (argc < 1) {
311                 (void)fprintf(stderr, "Must specify disk or filesystem\n");
312                 exit(X_STARTUP);
313         }
314         diskparam = *argv++;
315         if (strlen(diskparam) >= MAXPATHLEN) {
316                 (void)fprintf(stderr, "Disk or filesystem name too long: %s\n", 
317                               diskparam);
318                 exit(X_STARTUP);
319         }
320         argc--;
321         if (argc >= 1) {
322                 (void)fprintf(stderr, "Unknown arguments to dump:");
323                 while (argc--)
324                         (void)fprintf(stderr, " %s", *argv++);
325                 (void)fprintf(stderr, "\n");
326                 exit(X_STARTUP);
327         }
328         if (Tflag && uflag) {
329                 (void)fprintf(stderr,
330                     "You cannot use the T and u flags together.\n");
331                 exit(X_STARTUP);
332         }
333         if (strcmp(tapeprefix, "-") == 0) {
334                 pipeout++;
335                 tapeprefix = "standard output";
336         }
337
338         if (blocksperfile)
339                 blocksperfile = blocksperfile / ntrec * ntrec; /* round down */
340         else if (!unlimited) {
341                 /*
342                  * Determine how to default tape size and density
343                  *
344                  *              density                         tape size
345                  * 9-track      1600 bpi (160 bytes/.1")        2300 ft.
346                  * 9-track      6250 bpi (625 bytes/.1")        2300 ft.
347                  * cartridge    8000 bpi (100 bytes/.1")        1700 ft.
348                  *                                              (450*4 - slop)
349                  * hilit19 hits again: "
350                  */
351                 if (density == 0)
352                         density = cartridge ? 100 : 160;
353                 if (tsize == 0)
354                         tsize = cartridge ? 1700L*120L : 2300L*120L;
355         }
356
357         if (strchr(tapeprefix, ':')) {
358                 host = tapeprefix;
359                 tapeprefix = strchr(host, ':');
360                 *tapeprefix++ = '\0';
361 #ifdef RDUMP
362                 if (index(tapeprefix, '\n')) {
363                     (void)fprintf(stderr, "invalid characters in tape\n");
364                     exit(X_STARTUP);
365                 }
366                 if (rmthost(host) == 0)
367                         exit(X_STARTUP);
368 #else
369                 (void)fprintf(stderr, "remote dump not enabled\n");
370                 exit(X_STARTUP);
371 #endif
372         }
373         (void)setuid(getuid()); /* rmthost() is the only reason to be setuid */
374
375         if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
376                 signal(SIGHUP, sig);
377         if (signal(SIGTRAP, SIG_IGN) != SIG_IGN)
378                 signal(SIGTRAP, sig);
379         if (signal(SIGFPE, SIG_IGN) != SIG_IGN)
380                 signal(SIGFPE, sig);
381         if (signal(SIGBUS, SIG_IGN) != SIG_IGN)
382                 signal(SIGBUS, sig);
383         if (signal(SIGSEGV, SIG_IGN) != SIG_IGN)
384                 signal(SIGSEGV, sig);
385         if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
386                 signal(SIGTERM, sig);
387         if (signal(SIGINT, interrupt) == SIG_IGN)
388                 signal(SIGINT, SIG_IGN);
389         set_operators();        /* /etc/group snarfed */
390         getfstab();             /* /etc/fstab snarfed */
391
392         /*
393          *      disk may end in / and this can confuse
394          *      fstabsearch.
395          */
396         i = strlen(diskparam) - 1;
397         if (i > 1 && diskparam[i] == '/')
398                 diskparam[i] = '\0';
399
400         disk = get_device_name(diskparam);
401         if (!disk) {            /* null means the disk is some form
402                                    of LABEL= or UID= but it was not
403                                    found */
404                 msg("Cannot find a disk having %s\n", diskparam);
405                 exit(X_STARTUP);
406         }
407         /*
408          *      disk can be either the full special file name,
409          *      the suffix of the special file name,
410          *      the special name missing the leading '/',
411          *      the file system name with or without the leading '/'.
412          */
413         if ((dt = fstabsearch(disk)) != NULL) {
414                 disk = rawname(dt->fs_spec);
415                 (void)strncpy(spcl.c_dev, dt->fs_spec, NAMELEN);
416                 (void)strncpy(spcl.c_filesys, dt->fs_file, NAMELEN);
417         } else {
418 #ifdef  __linux__
419 #ifdef  HAVE_REALPATH
420                 if (realpath(disk, pathname) == NULL)
421 #endif
422                         strcpy(pathname, disk);
423                 /*
424                  * The argument could be now a mountpoint of
425                  * a filesystem specified in fstab. Search for it.
426                  */
427                 if ((dt = fstabsearch(pathname)) != NULL) {
428                         disk = rawname(dt->fs_spec);
429                         (void)strncpy(spcl.c_dev, dt->fs_spec, NAMELEN);
430                         (void)strncpy(spcl.c_filesys, dt->fs_file, NAMELEN);
431                 } else {
432                         /*
433                          * The argument was not found in the fstab
434                          * assume that this is a subtree and search for it
435                          */
436                         dt = fstabsearchdir(pathname, directory);
437                         if (dt != NULL) {
438                                 char name[MAXPATHLEN];
439                                 (void)strncpy(spcl.c_dev, dt->fs_spec, NAMELEN);
440                                 (void)snprintf(name, sizeof(name), "%s (dir %s)",
441                                               dt->fs_file, directory);
442                                 (void)strncpy(spcl.c_filesys, name, NAMELEN);
443                                 disk = rawname(dt->fs_spec);
444                         } else {
445                                 (void)strncpy(spcl.c_dev, disk, NAMELEN);
446                                 (void)strncpy(spcl.c_filesys, "an unlisted file system",
447                                     NAMELEN);
448                         }
449                 }
450 #else
451                 (void)strncpy(spcl.c_dev, disk, NAMELEN);
452                 (void)strncpy(spcl.c_filesys, "an unlisted file system",
453                     NAMELEN);
454 #endif
455         }
456
457         if (directory[0] != 0) {
458                 if (level != '0') {
459                         (void)fprintf(stderr, "Only level 0 dumps are allowed on a subdirectory\n");
460                         exit(X_STARTUP);
461                 }
462                 if (uflag) {
463                         (void)fprintf(stderr, "You can't update the dumpdates file when dumping a subdirectory\n");
464                         exit(X_STARTUP);
465                 }
466         }
467         spcl.c_dev[NAMELEN-1] = '\0';
468         spcl.c_filesys[NAMELEN-1] = '\0';
469         (void)gethostname(spcl.c_host, NAMELEN);
470         spcl.c_host[NAMELEN-1] = '\0';
471         spcl.c_level = level - '0';
472         spcl.c_type = TS_TAPE;
473         if (!Tflag)
474                 getdumptime(uflag);             /* dumpdates snarfed */
475
476         if (spcl.c_ddate == 0 && spcl.c_level) {
477                 msg("WARNING: There is no inferior level dump on this filesystem\n"); 
478                 msg("WARNING: Assuming a level 0 dump by default\n");
479                 level = '0';
480                 spcl.c_level = 0;
481         }
482
483         if (Mflag)
484                 snprintf(tape, MAXPATHLEN, "%s%03d", tapeprefix, tapeno + 1);
485         else
486                 strncpy(tape, tapeprefix, MAXPATHLEN);
487         tape[MAXPATHLEN - 1] = '\0';
488
489         if (!sizest) {
490
491                 msg("Date of this level %c dump: %s", level,
492 #ifdef  __linux__
493                         spcl.c_date == 0 ? "the epoch\n" : ctime4(&spcl.c_date));
494 #else
495                         spcl.c_date == 0 ? "the epoch\n" : ctime(&spcl.c_date));
496 #endif
497                 msg("Date of last level %c dump: %s", lastlevel,
498 #ifdef  __linux__
499                         spcl.c_ddate == 0 ? "the epoch\n" : ctime4(&spcl.c_ddate));
500 #else
501                         spcl.c_ddate == 0 ? "the epoch\n" : ctime(&spcl.c_ddate));
502 #endif
503                 msg("Dumping %s (%s) ", disk, spcl.c_filesys);
504                 if (host)
505                         msgtail("to %s on host %s\n", tape, host);
506                 else
507                         msgtail("to %s\n", tape);
508         } /* end of size estimate */
509
510 #ifdef  __linux__
511         retval = dump_fs_open(disk, &fs);
512         if (retval) {
513                 com_err(disk, retval, "while opening filesystem");
514                 if (retval == EXT2_ET_REV_TOO_HIGH)
515                         printf ("Get a newer version of dump!\n");
516                 exit(X_STARTUP);
517         }
518         if (fs->super->s_rev_level > DUMP_CURRENT_REV) {
519                 com_err(disk, retval, "while opening filesystem");
520                 printf ("Get a newer version of dump!\n");
521                 exit(X_STARTUP);
522         }
523         if ((diskfd = open(disk, O_RDONLY)) < 0) {
524                 msg("Cannot open %s\n", disk);
525                 exit(X_STARTUP);
526         }
527         /* if no user label specified, use ext2 filesystem label if available */
528         if (spcl.c_label[0] == '\0') {
529                 const char *lbl;
530                 if ( (lbl = get_device_label(disk)) != NULL) {
531                         strncpy(spcl.c_label, lbl, LBLSIZE);
532                         spcl.c_label[LBLSIZE-1] = '\0';
533                 }
534                 else
535                         strcpy(spcl.c_label, "none");   /* safe strcpy. */
536         }
537         sync();
538         dev_bsize = DEV_BSIZE;
539         dev_bshift = ffs(dev_bsize) - 1;
540         if (dev_bsize != (1 << dev_bshift))
541                 quit("dev_bsize (%d) is not a power of 2", dev_bsize);
542         tp_bshift = ffs(TP_BSIZE) - 1;
543         if (TP_BSIZE != (1 << tp_bshift))
544                 quit("TP_BSIZE (%d) is not a power of 2", TP_BSIZE);
545         maxino = fs->super->s_inodes_count;
546 #if     0
547         spcl.c_flags |= DR_NEWINODEFMT;
548 #endif
549 #else   /* __linux __*/
550         if ((diskfd = open(disk, O_RDONLY)) < 0) {
551                 msg("Cannot open %s\n", disk);
552                 exit(X_STARTUP);
553         }
554         sync();
555         sblock = (struct fs *)sblock_buf;
556         bread(SBOFF, (char *) sblock, SBSIZE);
557         if (sblock->fs_magic != FS_MAGIC)
558                 quit("bad sblock magic number\n");
559         dev_bsize = sblock->fs_fsize / fsbtodb(sblock, 1);
560         dev_bshift = ffs(dev_bsize) - 1;
561         if (dev_bsize != (1 << dev_bshift))
562                 quit("dev_bsize (%d) is not a power of 2", dev_bsize);
563         tp_bshift = ffs(TP_BSIZE) - 1;
564         if (TP_BSIZE != (1 << tp_bshift))
565                 quit("TP_BSIZE (%d) is not a power of 2", TP_BSIZE);
566 #ifdef FS_44INODEFMT
567         if (sblock->fs_inodefmt >= FS_44INODEFMT)
568                 spcl.c_flags |= DR_NEWINODEFMT;
569 #endif
570         maxino = sblock->fs_ipg * sblock->fs_ncg;
571 #endif  /* __linux__ */
572         mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);
573         usedinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
574         dumpdirmap = (char *)calloc((unsigned) mapsize, sizeof(char));
575         dumpinomap = (char *)calloc((unsigned) mapsize, sizeof(char));
576         if (usedinomap == NULL || dumpdirmap == NULL || dumpinomap == NULL)
577                 quit("out of memory allocating inode maps\n");
578         tapesize = 2 * (howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
579
580         nonodump = spcl.c_level < honorlevel;
581
582         msg("Label: %s\n", spcl.c_label);
583
584 #if defined(SIGINFO)
585         (void)signal(SIGINFO, statussig);
586 #endif
587
588         if (!sizest)
589                 msg("mapping (Pass I) [regular files]\n");
590 #ifdef  __linux__
591         if (directory[0] == 0)
592                 anydirskipped = mapfiles(maxino, &tapesize);
593         else
594                 anydirskipped = mapfilesfromdir(maxino, &tapesize, directory);
595 #else
596         anydirskipped = mapfiles(maxino, &tapesize);
597 #endif
598
599         if (!sizest)
600                 msg("mapping (Pass II) [directories]\n");
601         while (anydirskipped) {
602                 anydirskipped = mapdirs(maxino, &tapesize);
603         }
604
605         if (sizest) {
606                 printf("%.0f\n", ((double)tapesize + 11) * TP_BSIZE);
607                 exit(X_FINOK);
608         } /* stop here for size estimate */
609
610         if (pipeout || unlimited) {
611                 tapesize += 11; /* 10 trailer blocks + 1 map header */
612                 msg("estimated %ld tape blocks.\n", tapesize);
613         } else {
614                 double fetapes;
615
616                 if (blocksperfile)
617                         fetapes = (double) tapesize / blocksperfile;
618                 else if (cartridge) {
619                         /* Estimate number of tapes, assuming streaming stops at
620                            the end of each block written, and not in mid-block.
621                            Assume no erroneous blocks; this can be compensated
622                            for with an artificially low tape size. */
623                         fetapes =
624                         (         (double) tapesize     /* blocks */
625                                 * TP_BSIZE      /* bytes/block */
626                                 * (1.0/density) /* 0.1" / byte " */
627                           +
628                                   (double) tapesize     /* blocks */
629                                 * (1.0/ntrec)   /* streaming-stops per block */
630                                 * 15.48         /* 0.1" / streaming-stop " */
631                         ) * (1.0 / tsize );     /* tape / 0.1" " */
632                 } else {
633                         /* Estimate number of tapes, for old fashioned 9-track
634                            tape */
635                         int tenthsperirg = (density == 625) ? 3 : 7;
636                         fetapes =
637                         (         (double) tapesize     /* blocks */
638                                 * TP_BSIZE      /* bytes / block */
639                                 * (1.0/density) /* 0.1" / byte " */
640                           +
641                                   (double) tapesize     /* blocks */
642                                 * (1.0/ntrec)   /* IRG's / block */
643                                 * tenthsperirg  /* 0.1" / IRG " */
644                         ) * (1.0 / tsize );     /* tape / 0.1" " */
645                 }
646                 etapes = fetapes;               /* truncating assignment */
647                 etapes++;
648                 /* count the dumped inodes map on each additional tape */
649                 tapesize += (etapes - 1) *
650                         (howmany(mapsize * sizeof(char), TP_BSIZE) + 1);
651                 tapesize += etapes + 10;        /* headers + 10 trailer blks */
652                 msg("estimated %ld tape blocks on %3.2f tape(s).\n",
653                     tapesize, fetapes);
654         }
655
656         /*
657          * Allocate tape buffer.
658          */
659         if (!alloctape())
660                 quit(
661         "can't allocate tape buffers - try a smaller blocking factor.\n");
662
663         startnewtape(1);
664 #ifdef __linux__
665         (void)time4(&(tstart_writing));
666 #else
667         (void)time((time_t *)&(tstart_writing));
668 #endif
669         dumpmap(usedinomap, TS_CLRI, maxino - 1);
670
671         msg("dumping (Pass III) [directories]\n");
672         dirty = 0;              /* XXX just to get gcc to shut up */
673         for (map = dumpdirmap, ino = 1; ino < maxino; ino++) {
674                 if (((ino - 1) % NBBY) == 0)    /* map is offset by 1 */
675                         dirty = *map++;
676                 else
677                         dirty >>= 1;
678                 if ((dirty & 1) == 0)
679                         continue;
680                 /*
681                  * Skip directory inodes deleted and maybe reallocated
682                  */
683                 dp = getino(ino);
684                 if ((dp->di_mode & IFMT) != IFDIR)
685                         continue;
686 #ifdef  __linux__
687                 /*
688                  * Skip directory inodes deleted and not yes reallocated...
689                  */
690                 if (dp->di_nlink == 0 || dp->di_dtime != 0)
691                         continue;
692                 (void)dumpdirino(dp, ino);
693 #else
694                 (void)dumpino(dp, ino);
695 #endif
696         }
697
698         msg("dumping (Pass IV) [regular files]\n");
699         for (map = dumpinomap, ino = 1; ino < maxino; ino++) {
700                 if (((ino - 1) % NBBY) == 0)    /* map is offset by 1 */
701                         dirty = *map++;
702                 else
703                         dirty >>= 1;
704                 if ((dirty & 1) == 0)
705                         continue;
706                 /*
707                  * Skip inodes deleted and reallocated as directories.
708                  */
709                 dp = getino(ino);
710                 if ((dp->di_mode & IFMT) == IFDIR)
711                         continue;
712 #ifdef __linux__
713                 /*
714                  * No need to check here for deleted and not yes reallocated inodes
715                  * since this is done in dumpino().
716                  */
717 #endif
718                 (void)dumpino(dp, ino);
719         }
720
721 #ifdef __linux__
722         (void)time4(&(tend_writing));
723 #else
724         (void)time((time_t *)&(tend_writing));
725 #endif
726         spcl.c_type = TS_END;
727         for (i = 0; i < ntrec; i++)
728                 writeheader(maxino - 1);
729
730         tnow = trewind();
731
732         if (pipeout)
733                 msg("%ld tape blocks (%.2fMB)\n", spcl.c_tapea,
734                         ((double)spcl.c_tapea * TP_BSIZE / 1048576));
735         else
736                 msg("%ld tape blocks (%.2fMB) on %d volume(s)\n",
737                     spcl.c_tapea, 
738                     ((double)spcl.c_tapea * TP_BSIZE / 1048576),
739                     spcl.c_volume);
740
741         /* report dump performance, avoid division through zero */
742         if (tend_writing - tstart_writing == 0)
743                 msg("finished in less than a second\n");
744         else
745                 msg("finished in %d seconds, throughput %d KBytes/sec\n",
746                     tend_writing - tstart_writing,
747                     spcl.c_tapea / (tend_writing - tstart_writing));
748
749         putdumptime();
750 #ifdef __linux__
751         msg("Date of this level %c dump: %s", level,
752                 spcl.c_date == 0 ? "the epoch\n" : ctime4(&spcl.c_date));
753 #else
754         msg("Date of this level %c dump: %s", level,
755                 spcl.c_date == 0 ? "the epoch\n" : ctime(&spcl.c_date));
756 #endif
757         msg("Date this dump completed:  %s", ctime(&tnow));
758
759         msg("Average transfer rate: %ld KB/s\n", xferrate / tapeno);
760         if (compressed) {
761                 long tapekb = bytes_written / 1024;
762                 double rate = .0005 + (double) spcl.c_tapea / tapekb;
763                 msg("Wrote %ldKB uncompressed, %ldKB compressed,"
764                         " compression ratio %1.3f\n",
765                         spcl.c_tapea, tapekb, rate);
766         }
767
768         broadcast("DUMP IS DONE!\7\7\n");
769         msg("DUMP IS DONE\n");
770         Exit(X_FINOK);
771         /* NOTREACHED */
772         return 0;       /* gcc - shut up */
773 }
774
775 static void
776 usage(void)
777 {
778         char white[MAXPATHLEN];
779         int i;
780         
781         strncpy(white, __progname, MAXPATHLEN-1);
782         white[MAXPATHLEN-1] = '\0';
783         for (i=0; i<MAXPATHLEN; ++i)
784                 if (white[i] != '\0') white[i] = ' ';
785
786         fprintf(stderr,
787                 "%s %s\n", __progname, _DUMP_VERSION);
788         fprintf(stderr,
789                 "usage:\t%s [-0123456789ac"
790 #ifdef KERBEROS
791                 "k"
792 #endif
793                 "MnSu"
794 #ifdef HAVE_ZLIB
795                 "z"
796 #endif
797                 "] [-B records] [-b blocksize] [-d density]\n"
798                 "\t%s [-e inode#] [-f file] [-h level] [-s feet] [-T date] filesystem\n"
799                 "\t%s [-W | -w]\n", __progname, white, __progname);
800         exit(X_STARTUP);
801 }
802
803 /*
804  * Pick up a numeric argument.  It must be nonnegative and in the given
805  * range (except that a vmax of 0 means unlimited).
806  */
807 static long
808 numarg(const char *meaning, long vmin, long vmax)
809 {
810         char *p;
811         long val;
812
813         val = strtol(optarg, &p, 10);
814         if (*p)
815                 errx(X_STARTUP, "illegal %s -- %s", meaning, optarg);
816         if (val < vmin || (vmax && val > vmax))
817                 errx(X_STARTUP, "%s must be between %ld and %ld", meaning, vmin, vmax);
818         return (val);
819 }
820
821 void
822 sig(int signo)
823 {
824         switch(signo) {
825         case SIGALRM:
826         case SIGBUS:
827         case SIGFPE:
828         case SIGHUP:
829         case SIGTERM:
830         case SIGTRAP:
831                 if (pipeout)
832                         quit("Signal on pipe: cannot recover\n");
833                 msg("Rewriting attempted as response to unknown signal.\n");
834                 (void)fflush(stderr);
835                 (void)fflush(stdout);
836                 close_rewind();
837                 exit(X_REWRITE);
838                 /* NOTREACHED */
839         case SIGSEGV:
840                 msg("SIGSEGV: ABORTING!\n");
841                 (void)signal(SIGSEGV, SIG_DFL);
842                 (void)kill(0, SIGSEGV);
843                 /* NOTREACHED */
844         }
845 }
846
847 const char *
848 rawname(const char *cp)
849 {
850 #ifdef  __linux__
851         return cp;
852 #else   /* __linux__ */
853         static char rawbuf[MAXPATHLEN];
854         char *dp = strrchr(cp, '/');
855
856         if (dp == NULL)
857                 return (NULL);
858         (void)strncpy(rawbuf, cp, min(dp-cp, MAXPATHLEN - 1));
859         rawbuf[min(dp-cp, MAXPATHLEN-1)] = '\0';
860         (void)strncat(rawbuf, "/r", MAXPATHLEN - 1 - strlen(rawbuf));
861         (void)strncat(rawbuf, dp + 1, MAXPATHLEN - 1 - strlen(rawbuf));
862         return (rawbuf);
863 #endif  /* __linux__ */
864 }
865
866 /*
867  * obsolete --
868  *      Change set of key letters and ordered arguments into something
869  *      getopt(3) will like.
870  */
871 static void
872 obsolete(int *argcp, char **argvp[])
873 {
874         int argc, flags;
875         char *ap, **argv, *flagsp=NULL, **nargv, *p=NULL;
876
877         /* Setup. */
878         argv = *argvp;
879         argc = *argcp;
880
881         /* Return if no arguments or first argument has leading dash. */
882         ap = argv[1];
883         if (argc == 1 || *ap == '-')
884                 return;
885
886         /* Allocate space for new arguments. */
887         if ((*argvp = nargv = malloc((argc + 1) * sizeof(char *))) == NULL ||
888             (p = flagsp = malloc(strlen(ap) + 2)) == NULL)
889                 err(X_STARTUP, "malloc new args");
890
891         *nargv++ = *argv;
892         argv += 2;
893
894         for (flags = 0; *ap; ++ap) {
895                 switch (*ap) {
896                 case 'B':
897                 case 'b':
898                 case 'd':
899                 case 'e':
900                 case 'f':
901                 case 'F':
902                 case 'h':
903                 case 'L':
904                 case 's':
905                 case 'T':
906                         if (*argv == NULL) {
907                                 warnx("option requires an argument -- %c", *ap);
908                                 usage();
909                         }
910                         if ((nargv[0] = malloc(strlen(*argv) + 2 + 1)) == NULL)
911                                 err(X_STARTUP, "malloc arg");
912                         nargv[0][0] = '-';
913                         nargv[0][1] = *ap;
914                         (void)strcpy(&nargv[0][2], *argv);
915                         ++argv;
916                         ++nargv;
917                         break;
918                 default:
919                         if (!flags) {
920                                 *p++ = '-';
921                                 flags = 1;
922                         }
923                         *p++ = *ap;
924                         break;
925                 }
926         }
927
928         /* Terminate flags. */
929         if (flags) {
930                 *p = '\0';
931                 *nargv++ = flagsp;
932         }
933
934         /* Copy remaining arguments. */
935         while ((*nargv++ = *argv++));
936
937         /* Update argument count. */
938         *argcp = nargv - *argvp - 1;
939 }