?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move everything from /var/adm to /var/log
[unleashed/lotheac.git] / usr / src / cmd / fs.d / ufs / volcopy / volcopy.c
blob51ea3af31f6b4c96a40cfabbfc57d111630bd15d
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 * The Regents of the University of California
32 * All Rights Reserved
33 *
34 * University Acknowledgment- Portions of this document are derived from
35 * software developed by the University of California, Berkeley, and its
36 * contributors.
37 */
38
39 #include <sys/param.h>
40 #include <signal.h>
41 #include <sys/types.h>
42 #include <sys/sysmacros.h>
43 #include <sys/vnode.h>
44 #include <sys/fs/ufs_fsdir.h>
45 #include <sys/fs/ufs_inode.h>
46 #include <sys/fs/ufs_fs.h>
47 #include <sys/stat.h>
48 #include <sys/statvfs.h>
49 #include <fcntl.h>
50 #include <stdio.h>
51 #include <unistd.h>
52 #include <stdlib.h>
53 #include <errno.h>
54 #include <signal.h>
55 #include <stdarg.h>
56 #include <sys/errno.h>
57 #include <sys/utsname.h>
58 #include <sys/ipc.h>
59 #include <sys/sem.h>
60 #include <sys/shm.h>
61 #include <archives.h>
62 #include "volcopy.h"
63
64 #include <locale.h>
65
66 /*
67 * main I/O information structure, contains information for the
68 * source and destination files.
69 */
70
71 struct file_info {
72 char *f_dev_p, /* name of device */
73 *f_vol_p; /* volume name */
74 int f_bsize, /* size to buffer I/O to */
75 f_des, /* file descriptor */
76 f_dev; /* device type (generic I/O library) */
77 } In, Out;
78
79
80 int Sem_id[BUFCNT], /* semaphore ids for controlling shared memory */
81 Shm_id[BUFCNT], /* shared memory identifier */
82 *Cnts[BUFCNT]; /* an array of byte counts for shared memory */
83
84 char Empty[BLKSIZ], /* empty memory used to clear sections of memory */
85 *Buf[BUFCNT]; /* buffer pointers (possibly to shared memory) */
86
87 struct sembuf Sem_buf, /* semaphore operation buffer */
88 Rstsem_buf; /* semaphore reset operation buffer */
89
90 typedef union {
91 char dummy[SBSIZE];
92 struct fs sblk;
93
94 } sb_un;
95
96 sb_un isup, osup, tsup;
97
98 #define Isup isup.sblk
99 #define Osup osup.sblk
100
101 struct fs *Sptr = (struct fs *)&tsup.sblk; /* super-block pointer */
102
103 char *Ifname, *Ifpack, *Ofname, *Ofpack;
104 struct volcopy_label V_labl;
105
106 char From_vol[VVOLLEN + 1],
107 To_vol[VVOLLEN + 1],
108 *Fsys_p;
109
110 static char *nolabel = ""; /* used when there is no room for label */
111
112 int Blk_cnt = 1, /* Do I/O in (Blk_cnt * BLKSIZ) byte blocks */
113 Blocks = 0, /* Number of blocks transferred */
114 Bpi = 0,
115 Bufcnt,
116 Bufflg = 0,
117 Bufsz = BLKSIZ,
118 Disk_cnt = 1, /* Disk I/O (Disk_cnt * Blk_cnt * BLKSIZ) byte blocks */
119 Drive_typ = 0, /* Flag for special tape drive types */
120 Eomflg = 0,
121 Ipc = 0,
122 Itape,
123 M3b15 = 0, /* Machine types, set to 1 for the machine */
124 M3b2 = 0, /* the command is executing on */
125 Otape,
126 Pid = -1,
127 R_blks = 0, /* Number of blocks per tape reel */
128 R_cur = 1, /* Current tape reel being processed */
129 R_len = 0, /* Length in feet of tape reels */
130 R_num = 0, /* Number of tape reels to be processed */
131 Shell_esc = 1, /* Allow shell after delete -nosh (3b15) can disable */
132 Yesflg = 0;
133
134 void (*singal())();
135 long Fs,
136 Fstype;
137
138 time_t Tvec;
139
140 FILE *Devtty;
141
142 static void getinfs(),
143 getoutfs();
144
145 static char *getfslabel(struct fs *);
146 static char *getvolabel(struct fs *);
147 static void prompt(int, const char *, ...);
148 static void perr(int, const char *, ...);
149 static void mklabel(void);
150 static void get_mach_type(void);
151 static void mem_setup(void);
152 static void rprt(void);
153 static void chgreel(struct file_info *, int);
154 static void parent_copy(void);
155 static void copy(void);
156 static void flush_bufs(int);
157 static void cleanup(void);
158
159 #ifdef LOG
160 static int fslog(void);
161 #endif /* LOG */
162
163 /*
164 * g_init(), g_read(), g_write() originally came from libgenIO,
165 * a totally obsolete device interface library, now deleted.
166 * volcopy should be deleted too, since it doesn't work.
167 */
168
169 #define G_TM_TAPE 1 /* Tapemaster controller */
170 #define G_XY_DISK 3 /* xy disks */
171 #define G_SD_DISK 7 /* scsi sd disk */
172 #define G_XT_TAPE 8 /* xt tapes */
173 #define G_SF_FLOPPY 9 /* sf floppy */
174 #define G_XD_DISK 10 /* xd disks */
175 #define G_ST_TAPE 11 /* scsi tape */
176 #define G_NS 12 /* noswap pseudo-dev */
177 #define G_RAM 13 /* ram pseudo-dev */
178 #define G_FT 14 /* tftp */
179 #define G_HD 15 /* 386 network disk */
180 #define G_FD 16 /* 386 AT disk */
181 #define G_FILE 28 /* file, not a device */
182 #define G_NO_DEV 29 /* device does not require special treatment */
183 #define G_DEV_MAX 30 /* last valid device type */
184
185 /*
186 * g_init: Determine the device being accessed, set the buffer size,
187 * and perform any device specific initialization. Since at this point
188 * Sun has no system call to read the configuration, the major numbers
189 * are assumed to be static and types are figured out as such. However,
190 * as a rough estimate, the buffer size for all types is set to 512
191 * as a default.
192 */
193 static int
194 g_init(int *devtype, int *fdes)
195 {
196 major_t maj;
197 int bufsize;
198 struct stat st_buf;
199 struct statvfs64 stfs_buf;
200
201 *devtype = G_NO_DEV;
202 if (fstat(*fdes, &st_buf) == -1)
203 return (-1);
204 if (!S_ISCHR(st_buf.st_mode) && !S_ISBLK(st_buf.st_mode)) {
205 if (S_ISFIFO(st_buf.st_mode))
206 bufsize = 512;
207 else {
208 /* find block size for this file system */
209 *devtype = G_FILE;
210 if (fstatvfs(*fdes, &stfs_buf) < 0) {
211 bufsize = -1;
212 errno = ENODEV;
213 } else {
214 bufsize = stfs_buf.f_bsize;
215 }
216 }
217 return (bufsize);
218 }
219
220 return (512);
221 }
222
223 /*
224 * g_read: Read nbytes of data from fdes (of type devtype) and place
225 * data in location pointed to by buf. In case of end of medium,
226 * translate (where necessary) device specific EOM indications into
227 * the generic EOM indication of rv = -1, errno = ENOSPC.
228 */
229 /* ARGSUSED */
230 static ssize_t
231 g_read(int devtype, int fdes, void *buf, size_t nbytes)
232 {
233 ssize_t rv;
234
235 rv = read(fdes, buf, nbytes);
236
237 /* st devices return 0 when no space left */
238 if ((rv == 0 && errno == 0) || (rv == -1 && errno == EIO)) {
239 errno = ENOSPC;
240 rv = -1;
241 }
242
243 return (rv);
244 }
245
246 /*
247 * g_write: Write nbytes of data to fdes (of type devtype) from
248 * the location pointed to by buf. In case of end of medium,
249 * translate (where necessary) device specific EOM indications into
250 * the generic EOM indication of rv = -1, errno = ENOSPC.
251 */
252 /* ARGSUSED */
253 static ssize_t
254 g_write(int devtype, int fdes, void *buf, size_t nbytes)
255 {
256 ssize_t rv;
257
258 rv = write(fdes, buf, nbytes);
259
260 /* st devices return 0 when no more space left */
261 if ((rv == 0 && errno == 0) || (rv == -1 && errno == EIO)) {
262 errno = ENOSPC;
263 rv = -1;
264 }
265
266 return (rv);
267 }
268
269 /*
270 * filesystem copy with propagation of volume ID and filesystem name:
271 *
272 * volcopy [-options] filesystem /dev/from From_vol /dev/to To_vol
273 *
274 * options are:
275 * -feet - length of tape
276 * -bpi - recording density
277 * -reel - reel number (if not starting from beginning)
278 * -buf - use double buffered i/o (if dens >= 1600 bpi)
279 * -block - Set the transfer block size to NUM physical blocks (512
280 * bytes on 3B2 and 3B15). Note that an arbitrary block size might
281 * or might not work on a given system. Also, the block size
282 * read from the header of an input tape silently overrides this.
283 * -nosh - Don't offer the user a shell after hitting break or delete.
284 * -r - Read NUM transfer blocks from the disk at once and write it
285 * to the output device one block at a time. Intended only to
286 * boost the 3B15 EDFC disk to tape performance. Disabled on 3B2.
287 * -a - ask "y or n" instead of "DEL if wrong"
288 * -s - inverse of -a, from/to devices are printed followed by `?'.
289 * User has 10 seconds to DEL if mistaken!
290 * -y - assume "yes" response to all questions
291 *
292 * Examples:
293 *
294 * volcopy root /dev/rdsk/0s2 pk5 /dev/rdsk/1s2 pk12
295 *
296 * volcopy u3 /dev/rdsk/1s5 pk1 /dev/rmt/0m tp123
297 *
298 * volcopy u5 /dev/rmt/0m - /dev/rdsk/1s5 -
299 */
300
301 int
302 main(int argc, char *argv[])
303 {
304 char c;
305 int lfdes, altflg = 0, result, verify;
306 long dist;
307 char *align();
308 void sigalrm(), sigint();
309 struct stat stbuf;
310 int cnt;
311
312 (void) setlocale(LC_ALL, "");
313 #if !defined(TEXT_DOMAIN)
314 #define TEXT_DOMAIN "SYS_TEST"
315 #endif
316 (void) textdomain(TEXT_DOMAIN);
317
318 (void) get_mach_type();
319 (void) signal(SIGINT, sigint);
320 (void) signal(SIGALRM, sigalrm);
321 In.f_bsize = Out.f_bsize = BLKSIZ;
322 while (argc > 1 && argv[1][0] == '-') {
323 if (EQ(argv[1], "-a", 2)) {
324 altflg |= MINUSA;
325 } else if (EQ(argv[1], "-e", 2)) {
326 Eomflg = 1;
327 } else if (EQ(argv[1], "-s", 2)) {
328 altflg |= MINUSS;
329 } else if (EQ(argv[1], "-y", 2)) {
330 Yesflg++;
331 } else if (EQ(argv[1], "-buf", 4)) {
332 Bufflg++;
333 } else if (EQ(argv[1], "-bpi", 4)) {
334 if ((c = argv[1][4]) >= '0' && c <= '9')
335 Bpi = getbpi(&argv[1][4]);
336 else {
337 ++argv;
338 --argc;
339 Bpi = getbpi(&argv[1][0]);
340 }
341 } else if (EQ(argv[1], "-feet", 5)) {
342 if ((c = argv[1][5]) >= '0' && c <= '9')
343 R_len = atoi(&argv[1][5]);
344 else {
345 ++argv;
346 --argc;
347 R_len = atoi(&argv[1][0]);
348 }
349 } else if (EQ(argv[1], "-reel", 5)) {
350 if ((c = argv[1][5]) >= '0' && c <= '9')
351 R_cur = atoi(&argv[1][5]);
352 else {
353 ++argv;
354 --argc;
355 R_cur = atoi(&argv[1][0]);
356 }
357 } else if (EQ(argv[1], "-r", 2)) { /* 3b15 only */
358 if ((c = argv[1][2]) >= '0' && c <= '9')
359 Disk_cnt = atoi(&argv[1][2]);
360 else {
361 ++argv;
362 --argc;
363 Disk_cnt = atoi(&argv[1][0]);
364 }
365 if (Disk_cnt == 0)
366 perr(1, "volcopy: Need a non-zero value for the -r option\n");
367 } else if (EQ(argv[1], "-block", 6)) { /* 3b15 only */
368 if ((c = argv[1][6]) >= '0' && c <= '9')
369 Blk_cnt = atoi(&argv[1][6]);
370 else {
371 ++argv;
372 --argc;
373 Blk_cnt = atoi(&argv[1][0]);
374 }
375 if (Blk_cnt == 0)
376 perr(1, "volcopy: Need a non-zero value for the -block option\n");
377 } else if (EQ(argv[1], "-nosh", 5)) { /* 3b15 only */
378 Shell_esc = 0;
379 } else
380 perr(1, "<%s> invalid option\n", argv[1]);
381 ++argv;
382 --argc;
383 } /* argv[1][0] == '-' */
384
385 Devtty = fopen("/dev/tty", "r");
386 if ((Devtty == NULL) && !isatty(0))
387 Devtty = stdin;
388 time(&Tvec);
389
390 if (Eomflg && R_len)
391 perr(9, "volcopy: -e and -feet are mutually exclusive\n");
392 if ((altflg & MINUSA) && (altflg & MINUSS))
393 perr(9, "volcopy: -a and -s are mutually exclusive\n");
394 if (argc != 6) /* if mandatory fields not present */
395 perr(9, "ufs usage: volcopy [-F ufs] [generic options] \
396 fsname /devfrom volfrom /devto volto\n");
397 if (!(altflg & MINUSA)) /* -a was not specified, use default (-s) */
398 altflg |= MINUSS;
399
400 In.f_dev_p = argv[DEV_IN];
401 Out.f_dev_p = argv[DEV_OUT];
402 strncpy(To_vol, argv[VOL_OUT], VVOLLEN);
403 To_vol[VVOLLEN] = '\0';
404 Out.f_vol_p = &To_vol[0];
405 strncpy(From_vol, argv[VOL_IN], VVOLLEN);
406 From_vol[VVOLLEN] = '\0';
407 In.f_vol_p = &From_vol[0];
408 Fsys_p = argv[FIL_SYS];
409
410 if ((In.f_des = open(In.f_dev_p, O_RDONLY)) < 1)
411 perr(10, "%s: cannot open\n", In.f_dev_p);
412 if ((Out.f_des = open(Out.f_dev_p, O_RDONLY)) < 1)
413 perr(10, "%s: cannot open\n", Out.f_dev_p);
414
415 if (fstat(In.f_des, &stbuf) < 0 || (stbuf.st_mode & S_IFMT) != S_IFCHR)
416 perr(10, "From device not character-special\n");
417 if (fstat(Out.f_des, &stbuf) < 0 || (stbuf.st_mode & S_IFMT) != S_IFCHR)
418 perr(10, "To device not character-special\n");
419
420 if ((Itape = tapeck(&In, INPUT)) == 1)
421 R_blks = V_labl.v_reelblks;
422 Otape = tapeck(&Out, OUTPUT);
423 if (Otape && Itape)
424 perr(10, "Use dd(1) command to copy tapes\n");
425 (void) mem_setup();
426 if (Bufflg && !Ipc)
427 perr(1, "The -buf option requires ipc\n");
428 if (!Itape && !Otape)
429 R_cur = 1;
430 if (R_cur == 1 || !Itape) {
431 /* read in superblock */
432 verify = 0;
433 (void) getinfs(In.f_dev, In.f_des, Sptr);
434
435 if ((Sptr->fs_magic != FS_MAGIC) &&
436 (Sptr->fs_magic != MTB_UFS_MAGIC))
437 perr(10, "File System type unknown--get help\n");
438
439 if (Sptr->fs_magic == FS_MAGIC &&
440 (Sptr->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
441 Sptr->fs_version != UFS_VERSION_MIN))
442 perr(10, "Unrecognized version of UFS--get help\n");
443
444 if (Sptr->fs_magic == MTB_UFS_MAGIC &&
445 (Sptr->fs_version > MTB_UFS_VERSION_1 ||
446 Sptr->fs_version < MTB_UFS_VERSION_MIN))
447 perr(10, "Unrecognized version of UFS--get help\n");
448
449 (void) memcpy(&Isup, Sptr, Sptr->fs_sbsize);
450 Ifname = getfslabel(&Isup);
451 Ifpack = getvolabel(&Isup);
452 Fs = Sptr->fs_size * Sptr->fs_nspf;
453 } /* R_cur == 1 || !Itape */
454
455 /* read in superblock */
456 verify = !Otape || (altflg & MINUSS);
457 (void) getoutfs(Out.f_dev, Out.f_des, Sptr, verify);
458
459 if ((Sptr->fs_magic == FS_MAGIC) || (Sptr->fs_magic == MTB_UFS_MAGIC)) {
460 (void) memcpy(&Osup, Sptr, Sptr->fs_sbsize);
461 Ofname = getfslabel(&Osup);
462 Ofpack = getvolabel(&Osup);
463 } else {
464 int i;
465
466 /* out vol does not contain a ufs file system */
467 /* stuff let over from Isup */
468 (void) memcpy(&Osup, &Isup, Isup.fs_sbsize);
469 Ofname = getfslabel(&Osup);
470 Ofpack = getvolabel(&Osup);
471 /* wipe out the fs name and pack name for warning purposes */
472 for (i = 0; i < 6; i++) Ofname[i] = ' ';
473 for (i = 0; i < 6; i++) Ofpack[i] = ' ';
474 }
475
476 if (Itape) {
477 if (R_cur != 1) {
478 (void) printf(gettext(
479 "\nvolcopy: IF REEL 1 HAS NOT BEEN RESTORED,"));
480 (void) printf(gettext(
481 " STOP NOW AND START OVER ***\07\n"));
482 if (!ask(" Continue? ")) {
483 cleanup();
484 exit(31+9);
485 }
486 strncpy(Ifname, Fsys_p, 6);
487 strncpy(Ifpack, In.f_vol_p, 6);
488 }
489 if (V_labl.v_reel != R_cur || V_labl.v_reels != R_num)
490 prompt(1, "Tape disagrees: Reel %d of %d : looking for %d of %d\n",
491 V_labl.v_reel, V_labl.v_reels, R_cur, R_num);
492 } else if (Otape) {
493 strncpy(V_labl.v_volume, Out.f_vol_p, 6);
494 strncpy(Ofpack, Out.f_vol_p, 6);
495 strncpy(Ofname, Fsys_p, 6);
496 if (!Eomflg) {
497 R_num = Fs / R_blks + ((Fs % R_blks) ? 1 : 0);
498 (void) printf(gettext(
499 "You will need %d reels.\n"), R_num);
500 (void) printf(gettext(
501 "(\tThe same size and density is expected for all reels)\n"));
502 }
503 }
504 if (NOT_EQ(Fsys_p, Ifname, 6)) {
505 verify = !Otape || (altflg & MINUSS);
506 prompt(verify,
507 "arg. (%.6s) doesn't agree with from fs. (%.6s)\n",
508 Fsys_p, Ifname);
509 }
510 if (NOT_EQ(In.f_vol_p, "-", 6) && NOT_EQ(In.f_vol_p, Ifpack, 6)) {
511 verify = !Otape || (altflg & MINUSS);
512 prompt(verify, "arg. (%.6s) doesn't agree with from vol.(%.6s)\n",
513 In.f_vol_p, Ifpack);
514 }
515
516 if (*In.f_vol_p == '-')
517 In.f_vol_p = Ifpack;
518 if (*Out.f_vol_p == '-')
519 Out.f_vol_p = Ofpack;
520
521 if (R_cur == 1 && (Osup.fs_time + _2_DAYS) > Isup.fs_time) {
522 time_t t;
523
524 verify = altflg & MINUSS;
525 t = (time_t)Osup.fs_time;
526 prompt(verify, "%s less than 48 hours older than %s\n"
527 "To filesystem dated: %s",
528 Out.f_dev_p, In.f_dev_p, ctime(&t));
529 }
530 if (NOT_EQ(Out.f_vol_p, Ofpack, 6)) {
531 prompt(1, "arg.(%.6s) doesn't agree with to vol.(%.6s)\n",
532 Out.f_vol_p, Ofpack);
533 strncpy(Ofpack, Out.f_vol_p, 6);
534 }
535 if (Isup.fs_size > Osup.fs_size && !Otape)
536 prompt(1, "from fs larger than to fs\n");
537 if (!Otape && NOT_EQ(Ifname, Ofname, 6)) {
538 verify = altflg & MINUSS;
539 prompt(verify, "warning! from fs(%.6s) differs from to fs(%.6s)\n",
540 Ifname, Ofname);
541 }
542
543 (void) printf(gettext("From: %s, to: %s? "), In.f_dev_p, Out.f_dev_p);
544 if (!(altflg & MINUSA)) {
545 (void) printf(gettext("(DEL if wrong)\n"));
546 sleep(10);
547 } else if (!ask("(y or n) "))
548 perr(10, "\nvolcopy: STOP\n");
549 close(In.f_des);
550 close(Out.f_des);
551 sync();
552 In.f_des = open(In.f_dev_p, O_RDONLY);
553 Out.f_des = open(Out.f_dev_p, O_WRONLY);
554 errno = 0;
555 if (g_init(&In.f_dev, &In.f_des) < 0 ||
556 g_init(&Out.f_dev, &Out.f_des) < 0)
557 perr(1, "volcopy: Error %d during initialization\n", errno);
558 if (Itape) {
559 errno = 0;
560 if (g_read(In.f_dev, In.f_des, &V_labl, sizeof (V_labl)) <
561 sizeof (V_labl))
562 perr(10, "Error while reading label\n");
563 } else if (Otape) {
564 V_labl.v_reels = R_num;
565 V_labl.v_reel = R_cur;
566 V_labl.v_time = Tvec;
567 V_labl.v_reelblks = R_blks;
568 V_labl.v_blksize = BLKSIZ * Blk_cnt;
569 V_labl.v_nblocks = Blk_cnt;
570 V_labl.v_offset = 0L;
571 V_labl.v_type = T_TYPE;
572 errno = 0;
573 if (g_write(Out.f_dev, Out.f_des, &V_labl, sizeof (V_labl)) <
574 sizeof (V_labl))
575 perr(10, "Error while writing label\n");
576 }
577 if (R_cur > 1) {
578 if (!Eomflg) {
579 Fs = (R_cur - 1) * actual_blocks();
580 lfdes = Otape ? In.f_des : Out.f_des;
581 dist = (long)(Fs * BLKSIZ);
582 } else { /* Eomflg */
583 if (Otape)
584 perr(1, "Cannot use -reel with -e when copying to tape\n");
585 lfdes = Out.f_des;
586 dist = (long)(V_labl.v_offset * BLKSIZ);
587 Fs = V_labl.v_offset;
588 }
589 if (lseek(lfdes, dist, 0) < 0)
590 perr(1, "Cannot lseek()\n");
591 Sptr = Otape ? &Isup : &Osup;
592 if ((Sptr -> fs_magic != FS_MAGIC) &&
593 (Sptr -> fs_magic != MTB_UFS_MAGIC))
594 perr(10, "File System type unknown--get help!\n");
595
596 if (Sptr->fs_magic == FS_MAGIC &&
597 (Sptr->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
598 Sptr->fs_version != UFS_VERSION_MIN))
599 perr(10, "Unrecognized version of UFS--get help\n");
600
601 if (Sptr->fs_magic == MTB_UFS_MAGIC &&
602 (Sptr->fs_version > MTB_UFS_VERSION_1 ||
603 Sptr->fs_version < MTB_UFS_VERSION_MIN))
604 perr(10, "Unrecognized version of UFS--get help\n");
605
606 Fs = (Sptr->fs_size * Sptr->fs_nspf) - Fs;
607 }
608 if (Itape || Otape)
609 rprt();
610
611 if (Ipc) {
612 parent_copy();
613 (void) cleanup();
614 } else
615 copy();
616 (void) printf(gettext(" END: %ld blocks.\n"), Blocks);
617
618 #ifdef LOG
619 fslog();
620 #endif
621 if (Blocks)
622 return (0);
623 return (31+1); /* failed.. 0 blocks */
624 }
625
626 /*
627 * sigalrm: catch alarm signals.
628 */
629
630 void
631 sigalrm()
632 {
633 void (*signal())();
634
635 (void) signal(SIGALRM, sigalrm);
636 }
637
638 /*
639 * sigsys: catch illegal system calls to determine if IPC is available.
640 */
641
642 void
643 sigsys()
644 {
645
646 Ipc = 0;
647 }
648
649 /*
650 * sigint: catch interrupts and prompt user for shell or to quit.
651 */
652
653 void
654 sigint()
655 {
656 void (*signal())();
657 extern char **environ;
658 int tmpflg, i = 0, ps1 = -1, ps2 = -1;
659
660 tmpflg = Yesflg; /* override yesflag for duration of interrupt */
661 Yesflg = 0;
662 if (Shell_esc && ask("Want Shell? ")) {
663 if (!fork()) {
664 /* both PS1 and PS2 must be exported */
665 while (environ[i]) {
666 if (EQ(environ[i], "PS1", 3))
667 ps1 = i;
668 if (EQ(environ[i], "PS2", 3))
669 ps2 = i;
670 i++;
671 }
672 if (ps1 >= 0 && ps2 >= 0)
673 environ[ps1] = environ[ps2];
674 (void) signal(SIGINT, SIG_DFL);
675 execl("/usr/bin/sh", "/usr/bin/sh", 0);
676 } else { /* parent */
677 (void) signal(SIGINT, SIG_IGN);
678 wait((int *)0);
679 }
680 } else if (ask("Want to quit? ")) {
681 if (Pid > 0)
682 kill(Pid, 9);
683 (void) cleanup(); /* ipc */
684 exit(31+2);
685 }
686 (void) signal(SIGINT, sigint);
687 Yesflg = tmpflg; /* reset Yesflg */
688 }
689
690 /*
691 * actual_blocks: Calculate the actual number of blocks written to
692 * the tape (will differ from V_labl.v_reelblks if v_reelblks is not
693 * an even multiple of the blocking factor Blk_cnt).
694 */
695
696 int
697 actual_blocks()
698 {
699
700 if (R_blks % Blk_cnt)
701 return (((R_blks / Blk_cnt) + 1) * Blk_cnt);
702 else
703 return (R_blks);
704 }
705
706 /*
707 * get_mach_type: Determine what machine this is executing on.
708 */
709
710 static void
711 get_mach_type(void)
712 {
713 struct utsname utsinfo;
714
715 errno = 0;
716 if (uname(&utsinfo) < 0)
717 perr(1, "Unable to determine machine type\n");
718 if (strcmp(utsinfo.machine, "3B2") == 0)
719 M3b2 = 1;
720 else if (strcmp(utsinfo.machine, "3B15") == 0)
721 M3b15 = 1;
722 }
723
724 /*
725 * mem_setup: Determine memory needs and check for IPC. If IPC is available,
726 * used shared memory and semaphores to increase performance. If no IPC,
727 * get normal memory and only use one process.
728 */
729
730 static void
731 mem_setup(void)
732 {
733 void (*signal())();
734 int cnt, num, size;
735 char *align();
736
737 union semun {
738 int val;
739 struct semid_ds *buf;
740 ushort_t *array;
741 } sem_arg;
742
743 if (Blk_cnt == 1) {
744 switch (Drive_typ) {
745 case A_DRIVE:
746 Blk_cnt = 32;
747 break;
748 case C_DRIVE:
749 Blk_cnt = 10;
750 break;
751 case K_DRIVE:
752 Blk_cnt = 4;
753 break;
754 case T_DRIVE:
755 if (Bpi == 6250)
756 Blk_cnt = 50;
757 else
758 Blk_cnt = 10;
759 break;
760 default:
761 if (M3b15) {
762 if (Itape || Otape)
763 Blk_cnt = 16;
764 } else {
765 if (Otape || Itape) {
766 if (Bpi == 6250)
767 Blk_cnt = 50;
768 else
769 Blk_cnt = 10;
770 }
771 }
772 break;
773 } /* Drive_typ */
774 } /* Blk_cnt == 1 */
775 if (Blk_cnt > 1) /* user overrode g_init */
776 In.f_bsize = Out.f_bsize = Blk_cnt * BLKSIZ;
777 In.f_bsize = (!Itape) ? Disk_cnt * In.f_bsize : In.f_bsize;
778 Out.f_bsize = (!Otape) ? Disk_cnt * Out.f_bsize : Out.f_bsize;
779 Bufsz = find_lcm(In.f_bsize, Out.f_bsize);
780 num = _128K / (Bufsz + sizeof (int));
781 Bufsz *= num;
782 size = Bufsz + sizeof (int);
783 /* test to see if ipc is available, the shmat should fail with EINVAL */
784 (void) signal(SIGSYS, sigsys);
785 errno = 0;
786 if (Ipc) {
787 if ((int)shmat(0, NULL, 0) < 0 && errno != EINVAL)
788 Ipc = 0; /* something went wrong */
789 }
790 if (Ipc) { /* ipc is available */
791 Bufcnt = 2;
792 sem_arg.val = 0;
793 for (cnt = 0; cnt < BUFCNT; cnt++) {
794 errno = 0;
795 if ((Sem_id[cnt] = semget(IPC_PRIVATE, 1, 0)) < 0)
796 perr(1, "Error allocating semaphores: %d",
797 errno);
798 if (semctl(Sem_id[cnt], 0, SETVAL, sem_arg) < 0)
799 perr(1, "Error setting semaphores: %d", errno);
800 if ((Shm_id[cnt] = shmget(IPC_PRIVATE, size, 0)) < 0)
801 perr(1, "Error allocating shared memory: %d",
802 errno);
803 if ((Buf[cnt] = shmat(Shm_id[cnt], 0, 0)) == (void *)-1)
804 perr(1, "Error attaching shared memory: %d",
805 errno);
806 if (shmctl(Shm_id[cnt], SHM_LOCK, 0) < 0)
807 perr(0, "Error locking in shared memory: %d",
808 errno);
809 Cnts[cnt] = (int *)(Buf[cnt] + Bufsz);
810 }
811 } else { /* ipc is not available */
812 Bufcnt = 1;
813 if ((Buf[0] = align(size)) == NULL)
814 perr(1, "Out of memory\n");
815 Cnts[0] = (int *)(Buf[0] + Bufsz);
816 *Cnts[0] = 0;
817 }
818 }
819
820 /*
821 * prompt: Prompt the user for verification.
822 */
823
824 static void
825 prompt(int verify, const char *fmt, ...)
826 {
827 va_list ap;
828
829 va_start(ap, fmt);
830 if (fmt != NULL)
831 (void) vfprintf(stdout, gettext(fmt), ap);
832 va_end(ap);
833 if (verify) {
834 (void) fprintf(stdout, gettext("Type 'y' to override: "));
835 if (!ask("")) {
836 cleanup();
837 exit(31+9);
838 }
839 }
840 }
841
842 /*
843 * ask: Ask the user a question and get the answer.
844 */
845
846 int
847 ask(char *s)
848 {
849 char ans[12];
850
851 (void) printf(gettext(s));
852 if (Yesflg) {
853 (void) printf(gettext("YES\n"));
854 return (1);
855 }
856 ans[0] = '\0';
857 fgets(ans, 10, Devtty);
858 for (;;) {
859 switch (ans[0]) {
860 case 'a':
861 case 'A':
862 if (Pid > 0) /* parent with a child */
863 kill(Pid, 9);
864 cleanup();
865 exit(31+1);
866 case 'y':
867 case 'Y':
868 return (1);
869 case 'n':
870 case 'N':
871 return (0);
872 default:
873 (void) printf(gettext("\n(y or n)?"));
874 fgets(ans, 10, Devtty);
875 }
876 }
877 }
878
879 /*
880 * align: Align a malloc'd memory section on a page boundry.
881 */
882
883 char *
884 align(int size)
885 {
886 int pad;
887
888 if ((pad = ((int)malloc(0) & (PAGESIZE-1))) > 0) {
889 pad = PAGESIZE - pad;
890 if (malloc(pad) == NULL)
891 return (NULL);
892 }
893 return (malloc((unsigned)size));
894 }
895
896 /*
897 * child_copy: Using IPC, this child process reads from shared memory
898 * and writes to the destination file system.
899 */
900
901 int
902 child_copy()
903 {
904 int rv, cur_buf, left, have, tpcnt;
905 char *c_p;
906
907 (void) signal(SIGINT, SIG_IGN);
908 Sem_buf.sem_op = -1;
909 (void) close(In.f_des);
910 if (Otape && !Eomflg)
911 tpcnt = actual_blocks() * BLKSIZ;
912 cur_buf = 0;
913 for (;;) {
914 if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
915 perr(1, "semaphore operation error %d\n", errno);
916 left = *Cnts[cur_buf];
917 if (!left)
918 break;
919 c_p = Buf[cur_buf];
920 rv = 0;
921 while (left) {
922 have = (left < Out.f_bsize) ? left : Out.f_bsize;
923 if (!Eomflg && Otape) {
924 if (!tpcnt) {
925 (void) chgreel(&Out, OUTPUT);
926 tpcnt = actual_blocks() * BLKSIZ;
927 }
928 have = (tpcnt < have) ? tpcnt : have;
929 }
930 errno = 0;
931 if ((rv = g_write(Out.f_dev, Out.f_des, c_p, have)) <
932 0) {
933 if (Eomflg && errno == ENOSPC) {
934 (void) chgreel(&Out, OUTPUT);
935 continue;
936 } else
937 perr(1, "I/O error %d on write\n",
938 errno);
939 }
940 left -= rv;
941 c_p += rv;
942 V_labl.v_offset += rv;
943 if (!Eomflg && Otape)
944 tpcnt -= rv;
945 }
946 if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
947 perr(2, "semaphore operation error %d\n", errno);
948 cur_buf = (cur_buf + 1) % BUFCNT;
949 }
950 exit(0);
951 }
952
953 /*
954 * parent_copy: Using shared memory, the parent process reads fromt the
955 * source file system and writes to shared memory.
956 */
957
958 static void
959 parent_copy(void)
960 {
961 int rv, left, have, tpcnt, cur_buf;
962 char *c_p;
963 int eom = 0, xfer_cnt = Fs * BLKSIZ;
964
965 Sem_buf.sem_num = 0;
966 Sem_buf.sem_flg = 0;
967 if ((Pid = fork()) == 0)
968 child_copy(); /* child does not return */
969 (void) close(Out.f_des);
970 Rstsem_buf.sem_num = 0;
971 Rstsem_buf.sem_flg = 0;
972 Rstsem_buf.sem_op = 2;
973 Sem_buf.sem_op = 0;
974 cur_buf = 0;
975 if (Itape && !Eomflg)
976 tpcnt = actual_blocks() * BLKSIZ;
977 while (xfer_cnt) {
978 if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
979 perr(1, "Semaphore operation error %d\n", errno);
980 c_p = Buf[cur_buf];
981 left = Bufsz;
982 rv = 0;
983 while (left >= In.f_bsize && xfer_cnt) {
984 have = (xfer_cnt < In.f_bsize) ? xfer_cnt : In.f_bsize;
985 if (!Eomflg && Itape) {
986 if (!tpcnt) {
987 *Cnts[cur_buf] = Bufsz - left;
988 (void) flush_bufs(cur_buf);
989 (void) chgreel(&In, INPUT);
990 tpcnt = actual_blocks() * BLKSIZ;
991 cur_buf = (cur_buf == 0) ? 1 : 0;
992 eom = 1;
993 break;
994 }
995 have = (tpcnt < have) ? tpcnt : have;
996 }
997 errno = 0;
998 if ((rv = g_read(In.f_dev, In.f_des, c_p, have)) < 0) {
999 if (Eomflg && errno == ENOSPC) {
1000 *Cnts[cur_buf] = Bufsz - left;
1001 (void) flush_bufs(cur_buf);
1002 (void) chgreel(&In, INPUT);
1003 cur_buf = (cur_buf == 0) ? 1 : 0;
1004 eom = 1;
1005 break;
1006 } else
1007 perr(1, "I/O error %d on read\n",
1008 errno);
1009 }
1010 left -= rv;
1011 c_p += rv;
1012 xfer_cnt -= rv;
1013 if (!Eomflg && Itape)
1014 tpcnt -= rv;
1015 }
1016 if (eom > 0) {
1017 eom = 0;
1018 if (Eomflg)
1019 xfer_cnt -= rv;
1020 else if (Itape)
1021 tpcnt -= rv;
1022 continue;
1023 }
1024 *Cnts[cur_buf] = Bufsz - left;
1025 Blocks += *Cnts[cur_buf];
1026 if (semop(Sem_id[cur_buf], &Rstsem_buf, 1) < 0)
1027 perr(2, "Semaphore operation error %d\n", errno);
1028 cur_buf = (cur_buf == 0) ? 1 : 0;
1029 }
1030 if (semop(Sem_id[cur_buf], &Sem_buf, 1) < 0)
1031 perr(3, "Semaphore operation error %d\n", errno);
1032 *Cnts[cur_buf] = 0;
1033 if (semop(Sem_id[cur_buf], &Rstsem_buf, 1) < 0)
1034 perr(4, "Semaphore operation error %d\n", errno);
1035 wait(NULL);
1036 Blocks /= BLKSIZ;
1037 }
1038
1039 /*
1040 * copy: Copy without shared memory. The process reads from the source
1041 * filesystem and writes to the destination filesystem.
1042 */
1043
1044 static void
1045 copy(void)
1046 {
1047 int rv, left, have, tpcnt = 1, xfer_cnt = Fs * BLKSIZ;
1048 char *c_p;
1049
1050 if ((Itape || Otape) && !Eomflg)
1051 tpcnt = actual_blocks() * BLKSIZ;
1052 while (xfer_cnt) {
1053 c_p = (char *)(Buf[0] + *Cnts[0]);
1054 left = Bufsz - *Cnts[0];
1055 rv = 0;
1056 while (left >= In.f_bsize && xfer_cnt) {
1057 have = (xfer_cnt < In.f_bsize) ? xfer_cnt : In.f_bsize;
1058 if (!Eomflg && Itape) {
1059 if (!tpcnt) {
1060 *Cnts[0] = Bufsz - left;
1061 (void) chgreel(&In, INPUT);
1062 tpcnt = actual_blocks() * BLKSIZ;
1063 break;
1064 }
1065 have = (tpcnt < have) ? tpcnt : have;
1066 }
1067 errno = 0;
1068 if ((rv = g_read(In.f_dev, In.f_des, c_p, have)) < 0) {
1069 if (Eomflg && errno == ENOSPC) {
1070 (void) chgreel(&In, INPUT);
1071 break;
1072 } else
1073 perr(1, "I/O error %d on read\n",
1074 errno);
1075 }
1076 left -= rv;
1077 c_p += rv;
1078 xfer_cnt -= rv;
1079 if (!Eomflg && Itape)
1080 tpcnt -= rv;
1081 } /* left >= In.f_bsize && xfer_cnt */
1082 *Cnts[0] = Bufsz - left;
1083 Blocks += *Cnts[0];
1084 c_p = Buf[0];
1085 left = *Cnts[0];
1086 rv = 0;
1087 while (left >= Out.f_bsize || (left > 0 && !xfer_cnt)) {
1088 have = (left < Out.f_bsize) ? left : Out.f_bsize;
1089 if (!Eomflg && Otape) {
1090 if (!tpcnt) {
1091 (void) chgreel(&Out, OUTPUT);
1092 tpcnt = actual_blocks() * BLKSIZ;
1093 }
1094 have = (tpcnt < have) ? tpcnt : have;
1095 }
1096 errno = 0;
1097 if ((rv = g_write(Out.f_dev, Out.f_des, c_p, have)) <
1098 0) {
1099 if (Eomflg && errno == ENOSPC) {
1100 (void) chgreel(&Out, OUTPUT);
1101 continue;
1102 } else
1103 perr(1, "I/O error %d on write\n",
1104 errno);
1105 }
1106 left -= rv;
1107 c_p += rv;
1108 V_labl.v_offset += rv;
1109 if (!Eomflg && Otape)
1110 tpcnt -= rv;
1111 } /* left >= Out.f_bsize */
1112 if (left) {
1113 (void) memcpy(Buf[0], c_p, left);
1114 Blocks -= left;
1115 }
1116 *Cnts[0] = left;
1117 } /* xfer_cnt */
1118 Blocks /= BLKSIZ;
1119 }
1120
1121 /*
1122 * flush_bufs: Permit child to read the remaining data from the
1123 * buffer before prompting user for end-of-media.
1124 */
1125
1126 static void
1127 flush_bufs(int buffer)
1128 {
1129
1130 Blocks += *Cnts[buffer];
1131 if (semop(Sem_id[buffer], &Rstsem_buf, 1) < 0)
1132 perr(5, "Semaphore operation error %d\n", errno);
1133 if (semop(Sem_id[buffer], &Sem_buf, 1) < 0)
1134 perr(6, "Semaphore operation error %d\n", errno);
1135 }
1136
1137 /*
1138 * cleanup: Clean up shared memory and semaphore resources.
1139 */
1140
1141 static void
1142 cleanup(void)
1143 {
1144 int cnt;
1145
1146 if (Ipc) {
1147 for (cnt = 0; cnt < BUFCNT; cnt++) {
1148 (void) semctl(Sem_id[cnt], IPC_RMID, 0);
1149 (void) shmctl(Shm_id[cnt], IPC_RMID, 0);
1150 }
1151 }
1152 }
1153
1154 /*
1155 * find_lcm: Find the lowest common multiple of two numbers. This is used
1156 * to determine the buffer size that should be malloc(3)'d such that the
1157 * input and output data blocks can both fit evenly into the buffer.
1158 */
1159
1160 int
1161 find_lcm(int sz1, int sz2)
1162 {
1163 int inc, lcm, small;
1164
1165 if (sz1 < sz2) {
1166 lcm = inc = sz2;
1167 small = sz1;
1168 } else { /* sz1 >= sz2 */
1169 lcm = inc = sz1;
1170 small = sz2;
1171 }
1172 while (lcm % small != 0)
1173 lcm += inc;
1174 return (lcm);
1175 }
1176
1177 /*
1178 * Determine bpi information from drive names.
1179 */
1180
1181 int
1182 getbpi(char *inp)
1183 {
1184
1185 /*
1186 * Kludge to recognize Accellerated Tape Controller usage from
1187 * letter 'a' or 'A' following density given by user.
1188 *
1189 * Kludge to recognize 3B15 Compatibility Mode from
1190 * letter 'c' or 'C' following density given by user.
1191 */
1192 if (M3b15) {
1193 if (inp[4] == 'a' || inp[4] == 'A') {
1194 Drive_typ = A_DRIVE;
1195 inp[4] = '\0';
1196 }
1197 if (inp[4] == 'c' || inp[4] == 'C') {
1198 Drive_typ = C_DRIVE;
1199 inp[4] = '\0';
1200 }
1201 }
1202 return (atoi(inp));
1203 }
1204
1205 /*
1206 * blks_per_ft: Determine the number of blocks per foot of tape.
1207 * Inter-block gap (dgap) is 0.3 in.
1208 */
1209
1210 int
1211 blks_per_ft(double disc)
1212 {
1213 double dcnt = Blk_cnt, dBpi = Bpi, dsiz = BLKSIZ, dgap = 0.3;
1214
1215 return ((int)(dcnt / (((dcnt * dsiz / dBpi) + dgap) / 12.0) * disc));
1216 }
1217
1218 /*
1219 * tapeck: Arbitrary block size. Determine the number of physical blocks per
1220 * foot of tape, including the inter-block gap, and the possibility of a short
1221 * tape. Assume the usable portion of a tape is 85% of its length for small
1222 * block sizes and 88% for large block sizes.
1223 */
1224
1225 int
1226 tapeck(struct file_info *f_p, int dir)
1227 {
1228 int again = 1, verify, old_style, new_style;
1229 char resp[16];
1230
1231 errno = 0;
1232 if ((f_p->f_bsize = g_init(&f_p->f_dev, &f_p->f_des)) < 0)
1233 perr(1, "volcopy: Error %d during initialization\n", errno);
1234 if ((f_p->f_dev != G_TM_TAPE) && (f_p->f_dev != G_XT_TAPE) &&
1235 (f_p->f_dev != G_ST_TAPE))
1236 return (0);
1237 V_labl.v_magic[0] = '\0'; /* scribble on old data */
1238 alarm(5);
1239 if (g_read(f_p->f_dev, f_p->f_des, &V_labl, sizeof (V_labl)) <= 0) {
1240 if (dir == INPUT)
1241 perror("input tape");
1242 else
1243 perror("output tape");
1244 }
1245 alarm(0);
1246 if (V_labl.v_reel == '\0' && dir == INPUT)
1247 perr(9, "Input tape is empty\n");
1248 else {
1249 old_style = strncmp(V_labl.v_magic, "Volcopy", 7) == 0;
1250 new_style = strncmp(V_labl.v_magic, "VOLCOPY", 7) == 0;
1251 if (!old_style && !new_style) {
1252 verify = (dir == INPUT) ? 0 : 1;
1253 prompt(verify, "Not a labeled tape\n");
1254 if (dir == INPUT)
1255 perr(10, "Input tape not made by volcopy\n");
1256 mklabel();
1257 strncpy(V_labl.v_volume, f_p->f_vol_p, 6);
1258 Osup.fs_time = 0;
1259 } else if (new_style) {
1260 Eomflg = (dir == INPUT) ? 1 : Eomflg;
1261 if (!Eomflg)
1262 strncpy(V_labl.v_magic, "Volcopy", 7);
1263 }
1264 }
1265 if (*f_p->f_vol_p == '-')
1266 strncpy(f_p->f_vol_p, V_labl.v_volume, 6);
1267 else if (NOT_EQ(V_labl.v_volume, f_p->f_vol_p, 6)) {
1268 prompt(1, "Header volume(%.6s) does not match (%s)\n",
1269 V_labl.v_volume, f_p->f_vol_p);
1270 strncpy(V_labl.v_volume, f_p->f_vol_p, 6);
1271 }
1272 if (dir == INPUT) {
1273 Bpi = V_labl.v_dens;
1274 if (!Eomflg) {
1275 R_len = V_labl.v_length;
1276 R_num = V_labl.v_reels;
1277 }
1278 if (M3b15) {
1279 if (V_labl.v_type == T_TYPE) {
1280 if (V_labl.v_nblocks == 0) {
1281 Blk_cnt = 10;
1282 Drive_typ = C_DRIVE;
1283 } else
1284 Blk_cnt = V_labl.v_nblocks;
1285 if (V_labl.v_nblocks == 32)
1286 Drive_typ = A_DRIVE;
1287 else
1288 Drive_typ = 0;
1289 } else {
1290 Drive_typ = 0;
1291 Blk_cnt = 10;
1292 Drive_typ = C_DRIVE;
1293 }
1294 }
1295 }
1296 while (!Eomflg && (R_len <= 0 || R_len > 3600)) {
1297 (void) printf(gettext(
1298 "Enter size of reel in feet for <%s>: "),
1299 f_p->f_vol_p);
1300 fgets(resp, 10, Devtty);
1301 R_len = atoi(resp);
1302 if (R_len > 0 && R_len <= 3600)
1303 break;
1304 perr(0, "Size of reel must be > 0, <= 3600\n");
1305 }
1306 while (!Eomflg && again) {
1307 again = 0;
1308 if (!Bpi) {
1309 (void) printf(gettext(
1310 "Tape density? (i.e., 800 | 1600 | 6250)? "));
1311 fgets(resp, 10, Devtty);
1312 Bpi = getbpi(resp);
1313 }
1314 switch (Bpi) {
1315 case 800:
1316 R_blks = Ft800x10 * R_len;
1317 break;
1318 case 1600:
1319 if (M3b15) {
1320 switch (Blk_cnt) {
1321 case 1: /* Writing a new tape */
1322 if (Drive_typ == A_DRIVE)
1323 R_blks = Ft1600x32 * R_len;
1324 else if (Drive_typ == C_DRIVE)
1325 R_blks = Ft1600x10 * R_len;
1326 else
1327 R_blks = Ft1600x16 * R_len;
1328 break;
1329 case 10:
1330 R_blks = Ft1600x10 * R_len;
1331 break;
1332 case 16:
1333 R_blks = Ft1600x16 * R_len;
1334 break;
1335 case 32:
1336 R_blks = Ft1600x32 * R_len;
1337 break;
1338 default:
1339 if (Blk_cnt < 32)
1340 R_blks = blks_per_ft(0.85);
1341 else
1342 R_blks = blks_per_ft(0.88);
1343 R_blks *= R_len;
1344 } /* Blk_cnt */
1345 } else
1346 R_blks = Ft1600x10 * R_len;
1347 break;
1348 case 6250:
1349 if (M3b15) {
1350 switch (Blk_cnt) {
1351 case 1: /* Writing a new tape */
1352 if (Drive_typ == A_DRIVE)
1353 R_blks = Ft6250x32 * R_len;
1354 else if (Drive_typ == C_DRIVE)
1355 R_blks = Ft6250x10 * R_len;
1356 else
1357 R_blks = Ft6250x16 * R_len;
1358 break;
1359 case 10:
1360 R_blks = Ft6250x10 * R_len;
1361 break;
1362 case 16:
1363 R_blks = Ft6250x16 * R_len;
1364 break;
1365 case 32:
1366 R_blks = Ft6250x32 * R_len;
1367 break;
1368 default:
1369 if (Blk_cnt < 32)
1370 R_blks = blks_per_ft(0.85);
1371 else
1372 R_blks = blks_per_ft(0.88);
1373 R_blks *= R_len;
1374 }
1375 } else
1376 R_blks = Ft6250x50 * R_len;
1377 break;
1378 default:
1379 perr(0, "Bpi must be 800, 1600, or 6250\n");
1380 Bpi = 0;
1381 again = 1;
1382 } /* Bpi */
1383 } /* again */
1384 (void) printf(gettext("\nReel %.6s"), V_labl.v_volume);
1385 if (!Eomflg) {
1386 V_labl.v_length = R_len;
1387 V_labl.v_dens = Bpi;
1388 (void) printf(gettext(", %d feet, %d BPI\n"), R_len, Bpi);
1389 } else
1390 (void) printf(gettext(", ? feet\n"));
1391 return (1);
1392 }
1393
1394 /*
1395 * hdrck: Look for and validate a volcopy style tape label.
1396 */
1397
1398 int
1399 hdrck(int dev, int fd, char *tvol)
1400 {
1401 int verify;
1402 struct volcopy_label tlabl;
1403
1404 alarm(15); /* don't scan whole tape for label */
1405 errno = 0;
1406 if (g_read(dev, fd, &tlabl, sizeof (tlabl)) != sizeof (tlabl)) {
1407 alarm(0);
1408 verify = Otape;
1409 prompt(verify, "Cannot read header\n");
1410 if (Itape)
1411 close(fd);
1412 else
1413 strncpy(V_labl.v_volume, tvol, 6);
1414 return (verify);
1415 }
1416 alarm(0);
1417 V_labl.v_reel = tlabl.v_reel;
1418 if (NOT_EQ(tlabl.v_volume, tvol, 6)) {
1419 perr(0, "Volume is <%.6s>, not <%s>.\n", tlabl.v_volume, tvol);
1420 if (ask("Want to override? ")) {
1421 if (Otape)
1422 strncpy(V_labl.v_volume, tvol, 6);
1423 else
1424 strncpy(tvol, tlabl.v_volume, 6);
1425 return (1);
1426 }
1427 return (0);
1428 }
1429 return (1);
1430 }
1431
1432 /*
1433 * mklabel: Zero out and initialize a volcopy label.
1434 */
1435
1436 static void
1437 mklabel(void)
1438 {
1439
1440 (void) memcpy(&V_labl, Empty, sizeof (V_labl));
1441 if (!Eomflg)
1442 (void) strcpy(V_labl.v_magic, "Volcopy");
1443 else
1444 (void) strcpy(V_labl.v_magic, "VOLCOPY");
1445 }
1446
1447 /*
1448 * rprt: Report activity to user.
1449 */
1450
1451 static void
1452 rprt(void)
1453 {
1454
1455 if (Itape)
1456 (void) printf(gettext("\nReading "));
1457 else /* Otape */
1458 (void) printf(gettext("\nWriting "));
1459 if (!Eomflg)
1460 (void) printf(gettext(
1461 "REEL %d of %d VOL = %.6s\n"),
1462 R_cur, R_num, In.f_vol_p);
1463 else
1464 (void) printf(gettext(
1465 "REEL %d of ? VOL = %.6s\n"), R_cur, In.f_vol_p);
1466 }
1467
1468 #ifdef LOG
1469 /*
1470 * fslog: Log current activity.
1471 */
1472
1473 static int
1474 fslog(void)
1475 {
1476 FILE *fp = NULL;
1477
1478 fp = fopen("/var/log/filesave.log", "a");
1479 if (fp == NULL) {
1480 perr(1, "volcopy: cannot open /var/log/filesave.log\n");
1481 }
1482
1483 fprintf(fp, "%s%c%.6s%c%.6s -> %s%c%.6s%c%.6s on %.24s\n",
1484 In.f_dev_p, ';', Ifname, ';', Ifpack, Out.f_dev_p,
1485 ';', Ofname, ';', Ofpack, ctime(&Tvec));
1486 fclose(fp);
1487 return (0);
1488 }
1489 #endif /* LOG */
1490
1491 /*
1492 * getname: Get device name.
1493 */
1494
1495 void
1496 getname(char *nam_p)
1497 {
1498 int lastchar;
1499 char nam_buf[21];
1500
1501 nam_buf[0] = '\0';
1502 (void) printf(gettext("Changing drives? (type RETURN for no,\n"));
1503 (void) printf(gettext("\t`/dev/rmt/??\' or `/dev/rtp/??\' for yes: "));
1504 fgets(nam_buf, 20, Devtty);
1505 nam_buf[20] = '\0';
1506 lastchar = strlen(nam_buf) - 1;
1507 if (nam_buf[lastchar] == '\n')
1508 nam_buf[lastchar] = '\0'; /* remove it */
1509 if (nam_buf[0] != '\0')
1510 (void) strcpy(nam_p, nam_buf);
1511 }
1512
1513 /*
1514 * chgreel: Change reel on end-of-media.
1515 */
1516
1517 static void
1518 chgreel(struct file_info *f_p, int dir)
1519 {
1520 int again = 1, lastchar, temp;
1521 char vol_tmp[11];
1522
1523 R_cur++;
1524 while (again) {
1525 again = 0;
1526 errno = 0;
1527 (void) close(f_p->f_des);
1528 (void) getname(f_p->f_dev_p);
1529 (void) printf(gettext(
1530 "Mount tape %d\nType volume-ID when ready: "), R_cur);
1531 vol_tmp[0] = '\0';
1532 fgets(vol_tmp, 10, Devtty);
1533 vol_tmp[10] = '\0';
1534 lastchar = strlen(vol_tmp) - 1;
1535 if (vol_tmp[lastchar] == '\n')
1536 vol_tmp[lastchar] = '\0'; /* remove it */
1537 if (vol_tmp[0] != '\0') { /* if null string, use old vol-id */
1538 strncpy(f_p->f_vol_p, vol_tmp, 6);
1539 strncpy(V_labl.v_volume, vol_tmp, 6);
1540 }
1541 errno = 0;
1542 f_p->f_des = open(f_p->f_dev_p, O_RDONLY);
1543 if (f_p->f_des <= 0 || f_p->f_des > 10) {
1544 if (dir == INPUT)
1545 perror("input ERR");
1546 else
1547 perror("output ERR");
1548 }
1549 errno = 0;
1550 if (g_init(&(f_p->f_dev), &(f_p->f_des)) < 0)
1551 perr(0, "Initialization error %d\n", errno);
1552 if ((f_p->f_dev != G_TM_TAPE) && (f_p->f_dev != G_XT_TAPE) &&
1553 (f_p->f_dev != G_ST_TAPE)) {
1554 (void) printf(gettext(
1555 "\n'%s' is not a valid device"), f_p->f_dev_p);
1556 (void) printf(gettext(
1557 "\n\tenter device name `/dev/rmt/??\' or `/dev/rtp/??\' :"));
1558 again = 1;
1559 continue;
1560 }
1561 if (!hdrck(f_p->f_dev, f_p->f_des, f_p->f_vol_p)) {
1562 again = 1;
1563 continue;
1564 }
1565 switch (dir) {
1566 case INPUT:
1567 if (V_labl.v_reel != R_cur) {
1568 perr(0, "Need reel %d, label says reel %d\n",
1569 R_cur, V_labl.v_reel);
1570 again = 1;
1571 continue;
1572 }
1573 break;
1574 case OUTPUT:
1575 V_labl.v_reel = R_cur;
1576 temp = V_labl.v_offset;
1577 V_labl.v_offset /= BUFSIZ;
1578 close(f_p->f_des);
1579 sleep(2);
1580 errno = 0;
1581 f_p->f_des = open(f_p->f_dev_p, O_WRONLY);
1582 if (f_p->f_des <= 0 || f_p->f_des > 10)
1583 perror("output ERR");
1584 errno = 0;
1585 if (g_init(&(f_p->f_dev), &(f_p->f_des)) < 0)
1586 perr(1, "Initialization error %d\n", errno);
1587 errno = 0;
1588 if (g_write(f_p->f_dev, f_p->f_des, &V_labl,
1589 sizeof (V_labl)) < 0) {
1590 perr(0, "Cannot re-write header -Try again!\n");
1591 again = 1;
1592 V_labl.v_offset = temp;
1593 continue;
1594 }
1595 V_labl.v_offset = temp;
1596 break;
1597 default:
1598 perr(1, "Impossible case\n");
1599 } /* dir */
1600 } /* again */
1601 rprt();
1602 }
1603
1604 /*
1605 * perr: Print error messages.
1606 */
1607
1608 static void
1609 perr(int severity, const char *fmt, ...)
1610 {
1611 va_list ap;
1612
1613 va_start(ap, fmt);
1614 (void) fflush(stdout);
1615 (void) fflush(stderr);
1616 if (severity == 10) {
1617 (void) vfprintf(stdout, gettext(fmt), ap);
1618 (void) fprintf(stdout, gettext(
1619 "\t%d reel(s) completed\n"), --R_cur);
1620 (void) fflush(stdout);
1621 (void) fflush(stderr);
1622 cleanup();
1623 exit(31+9);
1624 }
1625 (void) vfprintf(stderr, gettext(fmt), ap);
1626 (void) fflush(stderr);
1627 va_end(ap);
1628 if (severity > 0) {
1629 (void) cleanup();
1630 exit(31+severity);
1631 }
1632 }
1633
1634
1635 static void
1636 getinfs(int dev, int fd, char *buf)
1637 {
1638 int cnt;
1639 int i;
1640
1641 if (lseek(fd, SBLOCK * DEV_BSIZE, 0) != SBLOCK * DEV_BSIZE) {
1642 perr(10, "Unable to lseek on input\n");
1643 }
1644 cnt = SBSIZE/DEV_BSIZE;
1645 for (i = 0; i < cnt; i++) {
1646 if (g_read(dev, fd, (char *)buf + i*DEV_BSIZE, DEV_BSIZE)
1647 != DEV_BSIZE) {
1648 perr(10, "Unable to read on input\n");
1649 }
1650 }
1651 }
1652
1653 static void
1654 getoutfs(int dev, int fd, char *buf, int verify)
1655 {
1656 int cnt;
1657 int i;
1658
1659 errno = 0;
1660 if (lseek(fd, SBLOCK * DEV_BSIZE, 0) != SBLOCK * DEV_BSIZE) {
1661 prompt(verify, "Unable to lseek on output\n", errno);
1662 }
1663 cnt = SBSIZE/DEV_BSIZE;
1664 for (i = 0; i < cnt; i++) {
1665 if (g_read(dev, fd, (char *)buf + i*DEV_BSIZE, DEV_BSIZE)
1666 != DEV_BSIZE) {
1667 prompt(verify, "Unable to read on output\n", errno);
1668 }
1669 }
1670 }
1671
1672 static char *
1673 getfslabel(struct fs *sb)
1674 {
1675 int i;
1676 int blk;
1677
1678 /*
1679 * is there room for label?
1680 */
1681
1682 if (sb->fs_cpc <= 0)
1683 return (nolabel);
1684
1685 /*
1686 * calculate the available blocks for each rotational position
1687 */
1688 blk = sb->fs_spc * sb->fs_cpc / sb->fs_nspf;
1689 for (i = 0; i < blk; i += sb->fs_frag)
1690 /* void */;
1691 i -= sb->fs_frag;
1692 blk = i / sb->fs_frag;
1693
1694 return ((char *)&(fs_rotbl(sb)[blk]));
1695 }
1696
1697 static char *
1698 getvolabel(struct fs *sb)
1699 {
1700 char *p;
1701 int i;
1702
1703 p = getfslabel(sb);
1704
1705 if (p == nolabel || p == NULL)
1706 return (nolabel);
1707
1708 for (i = 0; *p && i < 6; p++, i++)
1709 ;
1710 p++;
1711 return (p);
1712 }