tape.c revision 1.13 1 1.13 lukem /* $NetBSD: tape.c,v 1.13 1997/09/15 12:42:55 lukem Exp $ */
2 1.6 cgd
3 1.1 cgd /*-
4 1.3 mycroft * Copyright (c) 1980, 1991, 1993
5 1.3 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.1 cgd * This product includes software developed by the University of
18 1.1 cgd * California, Berkeley and its contributors.
19 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
20 1.1 cgd * may be used to endorse or promote products derived from this software
21 1.1 cgd * without specific prior written permission.
22 1.1 cgd *
23 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 1.1 cgd * SUCH DAMAGE.
34 1.1 cgd */
35 1.1 cgd
36 1.12 lukem #include <sys/cdefs.h>
37 1.1 cgd #ifndef lint
38 1.6 cgd #if 0
39 1.6 cgd static char sccsid[] = "@(#)tape.c 8.2 (Berkeley) 3/17/94";
40 1.6 cgd #else
41 1.13 lukem __RCSID("$NetBSD: tape.c,v 1.13 1997/09/15 12:42:55 lukem Exp $");
42 1.6 cgd #endif
43 1.1 cgd #endif /* not lint */
44 1.1 cgd
45 1.3 mycroft #include <sys/param.h>
46 1.3 mycroft #include <sys/socket.h>
47 1.3 mycroft #include <sys/time.h>
48 1.3 mycroft #include <sys/wait.h>
49 1.1 cgd #ifdef sunos
50 1.3 mycroft #include <sys/vnode.h>
51 1.3 mycroft
52 1.1 cgd #include <ufs/fs.h>
53 1.3 mycroft #include <ufs/inode.h>
54 1.1 cgd #else
55 1.3 mycroft #include <ufs/ffs/fs.h>
56 1.3 mycroft #include <ufs/ufs/dinode.h>
57 1.1 cgd #endif
58 1.3 mycroft
59 1.1 cgd #include <protocols/dumprestore.h>
60 1.3 mycroft
61 1.1 cgd #include <errno.h>
62 1.3 mycroft #include <fcntl.h>
63 1.1 cgd #include <setjmp.h>
64 1.3 mycroft #include <signal.h>
65 1.3 mycroft #include <stdio.h>
66 1.1 cgd #ifdef __STDC__
67 1.1 cgd #include <stdlib.h>
68 1.1 cgd #include <string.h>
69 1.8 lukem #include <time.h>
70 1.3 mycroft #include <unistd.h>
71 1.3 mycroft #else
72 1.3 mycroft int write(), read();
73 1.1 cgd #endif
74 1.3 mycroft
75 1.1 cgd #include "dump.h"
76 1.1 cgd #include "pathnames.h"
77 1.1 cgd
78 1.1 cgd int writesize; /* size of malloc()ed buffer for tape */
79 1.1 cgd long lastspclrec = -1; /* tape block number of last written header */
80 1.1 cgd int trecno = 0; /* next record to write in current block */
81 1.1 cgd extern long blocksperfile; /* number of blocks per output file */
82 1.1 cgd long blocksthisvol; /* number of blocks on current output file */
83 1.1 cgd extern int ntrec; /* blocking factor on tape */
84 1.1 cgd extern int cartridge;
85 1.1 cgd extern char *host;
86 1.1 cgd char *nexttape;
87 1.3 mycroft
88 1.12 lukem static ssize_t atomic_read __P((int, char *, int));
89 1.12 lukem static ssize_t atomic_write __P((int, char *, int));
90 1.3 mycroft static void doslave __P((int, int));
91 1.3 mycroft static void enslave __P((void));
92 1.3 mycroft static void flushtape __P((void));
93 1.3 mycroft static void killall __P((void));
94 1.12 lukem static void proceed __P((int));
95 1.3 mycroft static void rollforward __P((void));
96 1.12 lukem static void sigpipe __P((int));
97 1.12 lukem static void tperror __P((int));
98 1.1 cgd
99 1.1 cgd /*
100 1.1 cgd * Concurrent dump mods (Caltech) - disk block reading and tape writing
101 1.1 cgd * are exported to several slave processes. While one slave writes the
102 1.1 cgd * tape, the others read disk blocks; they pass control of the tape in
103 1.1 cgd * a ring via signals. The parent process traverses the filesystem and
104 1.1 cgd * sends writeheader()'s and lists of daddr's to the slaves via pipes.
105 1.1 cgd * The following structure defines the instruction packets sent to slaves.
106 1.1 cgd */
107 1.1 cgd struct req {
108 1.1 cgd daddr_t dblk;
109 1.1 cgd int count;
110 1.1 cgd };
111 1.1 cgd int reqsiz;
112 1.1 cgd
113 1.1 cgd #define SLAVES 3 /* 1 slave writing, 1 reading, 1 for slack */
114 1.1 cgd struct slave {
115 1.1 cgd int tapea; /* header number at start of this chunk */
116 1.1 cgd int count; /* count to next header (used for TS_TAPE */
117 1.1 cgd /* after EOT) */
118 1.1 cgd int inode; /* inode that we are currently dealing with */
119 1.1 cgd int fd; /* FD for this slave */
120 1.1 cgd int pid; /* PID for this slave */
121 1.1 cgd int sent; /* 1 == we've sent this slave requests */
122 1.1 cgd int firstrec; /* record number of this block */
123 1.1 cgd char (*tblock)[TP_BSIZE]; /* buffer for data blocks */
124 1.1 cgd struct req *req; /* buffer for requests */
125 1.1 cgd } slaves[SLAVES+1];
126 1.1 cgd struct slave *slp;
127 1.1 cgd
128 1.1 cgd char (*nextblock)[TP_BSIZE];
129 1.1 cgd
130 1.8 lukem static time_t tstart_volume; /* time of volume start */
131 1.8 lukem static int tapea_volume; /* value of spcl.c_tapea at volume start */
132 1.8 lukem
133 1.1 cgd int master; /* pid of master, for sending error signals */
134 1.1 cgd int tenths; /* length of tape used per block written */
135 1.1 cgd static int caught; /* have we caught the signal to proceed? */
136 1.1 cgd static int ready; /* have we reached the lock point without having */
137 1.1 cgd /* received the SIGUSR2 signal from the prev slave? */
138 1.1 cgd static jmp_buf jmpbuf; /* where to jump to if we are ready when the */
139 1.1 cgd /* SIGUSR2 arrives from the previous slave */
140 1.1 cgd
141 1.1 cgd int
142 1.1 cgd alloctape()
143 1.1 cgd {
144 1.1 cgd int pgoff = getpagesize() - 1;
145 1.1 cgd char *buf;
146 1.1 cgd int i;
147 1.1 cgd
148 1.1 cgd writesize = ntrec * TP_BSIZE;
149 1.1 cgd reqsiz = (ntrec + 1) * sizeof(struct req);
150 1.1 cgd /*
151 1.1 cgd * CDC 92181's and 92185's make 0.8" gaps in 1600-bpi start/stop mode
152 1.1 cgd * (see DEC TU80 User's Guide). The shorter gaps of 6250-bpi require
153 1.1 cgd * repositioning after stopping, i.e, streaming mode, where the gap is
154 1.1 cgd * variable, 0.30" to 0.45". The gap is maximal when the tape stops.
155 1.1 cgd */
156 1.1 cgd if (blocksperfile == 0)
157 1.1 cgd tenths = writesize / density +
158 1.1 cgd (cartridge ? 16 : density == 625 ? 5 : 8);
159 1.1 cgd /*
160 1.1 cgd * Allocate tape buffer contiguous with the array of instruction
161 1.1 cgd * packets, so flushtape() can write them together with one write().
162 1.1 cgd * Align tape buffer on page boundary to speed up tape write().
163 1.1 cgd */
164 1.1 cgd for (i = 0; i <= SLAVES; i++) {
165 1.1 cgd buf = (char *)
166 1.1 cgd malloc((unsigned)(reqsiz + writesize + pgoff + TP_BSIZE));
167 1.1 cgd if (buf == NULL)
168 1.1 cgd return(0);
169 1.1 cgd slaves[i].tblock = (char (*)[TP_BSIZE])
170 1.1 cgd (((long)&buf[ntrec + 1] + pgoff) &~ pgoff);
171 1.1 cgd slaves[i].req = (struct req *)slaves[i].tblock - ntrec - 1;
172 1.1 cgd }
173 1.1 cgd slp = &slaves[0];
174 1.1 cgd slp->count = 1;
175 1.1 cgd slp->tapea = 0;
176 1.1 cgd slp->firstrec = 0;
177 1.1 cgd nextblock = slp->tblock;
178 1.1 cgd return(1);
179 1.1 cgd }
180 1.1 cgd
181 1.1 cgd void
182 1.1 cgd writerec(dp, isspcl)
183 1.1 cgd char *dp;
184 1.1 cgd int isspcl;
185 1.1 cgd {
186 1.1 cgd
187 1.1 cgd slp->req[trecno].dblk = (daddr_t)0;
188 1.1 cgd slp->req[trecno].count = 1;
189 1.1 cgd *(union u_spcl *)(*(nextblock)++) = *(union u_spcl *)dp;
190 1.1 cgd if (isspcl)
191 1.1 cgd lastspclrec = spcl.c_tapea;
192 1.1 cgd trecno++;
193 1.1 cgd spcl.c_tapea++;
194 1.1 cgd if (trecno >= ntrec)
195 1.1 cgd flushtape();
196 1.1 cgd }
197 1.1 cgd
198 1.1 cgd void
199 1.1 cgd dumpblock(blkno, size)
200 1.1 cgd daddr_t blkno;
201 1.1 cgd int size;
202 1.1 cgd {
203 1.1 cgd int avail, tpblks, dblkno;
204 1.1 cgd
205 1.1 cgd dblkno = fsbtodb(sblock, blkno);
206 1.1 cgd tpblks = size >> tp_bshift;
207 1.1 cgd while ((avail = MIN(tpblks, ntrec - trecno)) > 0) {
208 1.1 cgd slp->req[trecno].dblk = dblkno;
209 1.1 cgd slp->req[trecno].count = avail;
210 1.1 cgd trecno += avail;
211 1.1 cgd spcl.c_tapea += avail;
212 1.1 cgd if (trecno >= ntrec)
213 1.1 cgd flushtape();
214 1.1 cgd dblkno += avail << (tp_bshift - dev_bshift);
215 1.1 cgd tpblks -= avail;
216 1.1 cgd }
217 1.1 cgd }
218 1.1 cgd
219 1.1 cgd int nogripe = 0;
220 1.1 cgd
221 1.12 lukem static void
222 1.1 cgd tperror(signo)
223 1.1 cgd int signo;
224 1.1 cgd {
225 1.1 cgd
226 1.1 cgd if (pipeout) {
227 1.1 cgd msg("write error on %s\n", tape);
228 1.1 cgd quit("Cannot recover\n");
229 1.1 cgd /* NOTREACHED */
230 1.1 cgd }
231 1.1 cgd msg("write error %d blocks into volume %d\n", blocksthisvol, tapeno);
232 1.1 cgd broadcast("DUMP WRITE ERROR!\n");
233 1.1 cgd if (!query("Do you want to restart?"))
234 1.1 cgd dumpabort(0);
235 1.1 cgd msg("Closing this volume. Prepare to restart with new media;\n");
236 1.1 cgd msg("this dump volume will be rewritten.\n");
237 1.1 cgd killall();
238 1.1 cgd nogripe = 1;
239 1.1 cgd close_rewind();
240 1.1 cgd Exit(X_REWRITE);
241 1.1 cgd }
242 1.1 cgd
243 1.12 lukem static void
244 1.1 cgd sigpipe(signo)
245 1.1 cgd int signo;
246 1.1 cgd {
247 1.1 cgd
248 1.1 cgd quit("Broken pipe\n");
249 1.1 cgd }
250 1.1 cgd
251 1.8 lukem /*
252 1.8 lukem * do_stats --
253 1.8 lukem * Update xferrate stats
254 1.8 lukem */
255 1.8 lukem time_t
256 1.8 lukem do_stats()
257 1.8 lukem {
258 1.8 lukem time_t tnow, ttaken;
259 1.8 lukem int blocks;
260 1.8 lukem
261 1.8 lukem (void)time(&tnow);
262 1.8 lukem ttaken = tnow - tstart_volume;
263 1.8 lukem blocks = spcl.c_tapea - tapea_volume;
264 1.8 lukem msg("Volume %d completed at: %s", tapeno, ctime(&tnow));
265 1.8 lukem if (ttaken > 0) {
266 1.8 lukem msg("Volume %d took %d:%02d:%02d\n", tapeno,
267 1.8 lukem ttaken / 3600, (ttaken % 3600) / 60, ttaken % 60);
268 1.11 lukem msg("Volume %d transfer rate: %ld KB/s\n", tapeno,
269 1.8 lukem blocks / ttaken);
270 1.8 lukem xferrate += blocks / ttaken;
271 1.8 lukem }
272 1.8 lukem return(tnow);
273 1.8 lukem }
274 1.8 lukem
275 1.11 lukem /*
276 1.11 lukem * statussig --
277 1.11 lukem * information message upon receipt of SIGINFO
278 1.11 lukem * (derived from optr.c::timeest())
279 1.11 lukem */
280 1.11 lukem void
281 1.11 lukem statussig(notused)
282 1.11 lukem int notused;
283 1.11 lukem {
284 1.11 lukem time_t tnow, deltat;
285 1.11 lukem char msgbuf[128];
286 1.11 lukem
287 1.11 lukem if (blockswritten < 500)
288 1.11 lukem return;
289 1.11 lukem (void) time((time_t *) &tnow);
290 1.11 lukem deltat = tstart_writing - tnow + (1.0 * (tnow - tstart_writing))
291 1.11 lukem / blockswritten * tapesize;
292 1.11 lukem (void)snprintf(msgbuf, sizeof(msgbuf),
293 1.11 lukem "%3.2f%% done at %ld KB/s, finished in %d:%02d\n",
294 1.11 lukem (blockswritten * 100.0) / tapesize,
295 1.11 lukem (spcl.c_tapea - tapea_volume) / (tnow - tstart_volume),
296 1.11 lukem (int)(deltat / 3600), (int)((deltat % 3600) / 60));
297 1.11 lukem write(STDERR_FILENO, msgbuf, strlen(msgbuf));
298 1.11 lukem }
299 1.11 lukem
300 1.3 mycroft static void
301 1.1 cgd flushtape()
302 1.1 cgd {
303 1.1 cgd int i, blks, got;
304 1.1 cgd long lastfirstrec;
305 1.1 cgd
306 1.1 cgd int siz = (char *)nextblock - (char *)slp->req;
307 1.1 cgd
308 1.1 cgd slp->req[trecno].count = 0; /* Sentinel */
309 1.1 cgd
310 1.12 lukem if (atomic_write(slp->fd, (char *)slp->req, siz) != siz)
311 1.1 cgd quit("error writing command pipe: %s\n", strerror(errno));
312 1.1 cgd slp->sent = 1; /* we sent a request, read the response later */
313 1.1 cgd
314 1.1 cgd lastfirstrec = slp->firstrec;
315 1.1 cgd
316 1.1 cgd if (++slp >= &slaves[SLAVES])
317 1.1 cgd slp = &slaves[0];
318 1.1 cgd
319 1.1 cgd /* Read results back from next slave */
320 1.1 cgd if (slp->sent) {
321 1.12 lukem if (atomic_read(slp->fd, (char *)&got, sizeof got)
322 1.1 cgd != sizeof got) {
323 1.1 cgd perror(" DUMP: error reading command pipe in master");
324 1.1 cgd dumpabort(0);
325 1.1 cgd }
326 1.1 cgd slp->sent = 0;
327 1.1 cgd
328 1.1 cgd /* Check for end of tape */
329 1.1 cgd if (got < writesize) {
330 1.1 cgd msg("End of tape detected\n");
331 1.1 cgd
332 1.1 cgd /*
333 1.1 cgd * Drain the results, don't care what the values were.
334 1.1 cgd * If we read them here then trewind won't...
335 1.1 cgd */
336 1.1 cgd for (i = 0; i < SLAVES; i++) {
337 1.1 cgd if (slaves[i].sent) {
338 1.12 lukem if (atomic_read(slaves[i].fd,
339 1.1 cgd (char *)&got, sizeof got)
340 1.1 cgd != sizeof got) {
341 1.1 cgd perror(" DUMP: error reading command pipe in master");
342 1.1 cgd dumpabort(0);
343 1.1 cgd }
344 1.1 cgd slaves[i].sent = 0;
345 1.1 cgd }
346 1.1 cgd }
347 1.1 cgd
348 1.1 cgd close_rewind();
349 1.1 cgd rollforward();
350 1.1 cgd return;
351 1.1 cgd }
352 1.1 cgd }
353 1.1 cgd
354 1.1 cgd blks = 0;
355 1.1 cgd if (spcl.c_type != TS_END) {
356 1.1 cgd for (i = 0; i < spcl.c_count; i++)
357 1.1 cgd if (spcl.c_addr[i] != 0)
358 1.1 cgd blks++;
359 1.1 cgd }
360 1.1 cgd slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
361 1.1 cgd slp->tapea = spcl.c_tapea;
362 1.1 cgd slp->firstrec = lastfirstrec + ntrec;
363 1.1 cgd slp->inode = curino;
364 1.1 cgd nextblock = slp->tblock;
365 1.1 cgd trecno = 0;
366 1.1 cgd asize += tenths;
367 1.1 cgd blockswritten += ntrec;
368 1.1 cgd blocksthisvol += ntrec;
369 1.1 cgd if (!pipeout && (blocksperfile ?
370 1.1 cgd (blocksthisvol >= blocksperfile) : (asize > tsize))) {
371 1.1 cgd close_rewind();
372 1.1 cgd startnewtape(0);
373 1.1 cgd }
374 1.1 cgd timeest();
375 1.1 cgd }
376 1.1 cgd
377 1.1 cgd void
378 1.1 cgd trewind()
379 1.1 cgd {
380 1.1 cgd int f;
381 1.1 cgd int got;
382 1.1 cgd
383 1.1 cgd for (f = 0; f < SLAVES; f++) {
384 1.1 cgd /*
385 1.1 cgd * Drain the results, but unlike EOT we DO (or should) care
386 1.1 cgd * what the return values were, since if we detect EOT after
387 1.1 cgd * we think we've written the last blocks to the tape anyway,
388 1.1 cgd * we have to replay those blocks with rollforward.
389 1.1 cgd *
390 1.1 cgd * fixme: punt for now.
391 1.1 cgd */
392 1.1 cgd if (slaves[f].sent) {
393 1.12 lukem if (atomic_read(slaves[f].fd, (char *)&got, sizeof got)
394 1.1 cgd != sizeof got) {
395 1.1 cgd perror(" DUMP: error reading command pipe in master");
396 1.1 cgd dumpabort(0);
397 1.1 cgd }
398 1.1 cgd slaves[f].sent = 0;
399 1.1 cgd if (got != writesize) {
400 1.1 cgd msg("EOT detected in last 2 tape records!\n");
401 1.1 cgd msg("Use a longer tape, decrease the size estimate\n");
402 1.1 cgd quit("or use no size estimate at all.\n");
403 1.1 cgd }
404 1.1 cgd }
405 1.1 cgd (void) close(slaves[f].fd);
406 1.1 cgd }
407 1.1 cgd while (wait((int *)NULL) >= 0) /* wait for any signals from slaves */
408 1.1 cgd /* void */;
409 1.1 cgd
410 1.1 cgd if (pipeout)
411 1.1 cgd return;
412 1.1 cgd
413 1.1 cgd msg("Closing %s\n", tape);
414 1.1 cgd
415 1.1 cgd #ifdef RDUMP
416 1.1 cgd if (host) {
417 1.1 cgd rmtclose();
418 1.1 cgd while (rmtopen(tape, 0) < 0)
419 1.1 cgd sleep(10);
420 1.1 cgd rmtclose();
421 1.1 cgd return;
422 1.1 cgd }
423 1.1 cgd #endif
424 1.1 cgd (void) close(tapefd);
425 1.1 cgd while ((f = open(tape, 0)) < 0)
426 1.1 cgd sleep (10);
427 1.1 cgd (void) close(f);
428 1.1 cgd }
429 1.1 cgd
430 1.1 cgd void
431 1.1 cgd close_rewind()
432 1.1 cgd {
433 1.1 cgd trewind();
434 1.8 lukem (void)do_stats();
435 1.1 cgd if (nexttape)
436 1.1 cgd return;
437 1.1 cgd if (!nogripe) {
438 1.1 cgd msg("Change Volumes: Mount volume #%d\n", tapeno+1);
439 1.1 cgd broadcast("CHANGE DUMP VOLUMES!\7\7\n");
440 1.1 cgd }
441 1.1 cgd while (!query("Is the new volume mounted and ready to go?"))
442 1.1 cgd if (query("Do you want to abort?")) {
443 1.1 cgd dumpabort(0);
444 1.1 cgd /*NOTREACHED*/
445 1.1 cgd }
446 1.1 cgd }
447 1.1 cgd
448 1.1 cgd void
449 1.1 cgd rollforward()
450 1.1 cgd {
451 1.9 lukem struct req *p, *q, *prev;
452 1.9 lukem struct slave *tslp;
453 1.1 cgd int i, size, savedtapea, got;
454 1.1 cgd union u_spcl *ntb, *otb;
455 1.1 cgd tslp = &slaves[SLAVES];
456 1.1 cgd ntb = (union u_spcl *)tslp->tblock[1];
457 1.1 cgd
458 1.1 cgd /*
459 1.1 cgd * Each of the N slaves should have requests that need to
460 1.1 cgd * be replayed on the next tape. Use the extra slave buffers
461 1.1 cgd * (slaves[SLAVES]) to construct request lists to be sent to
462 1.1 cgd * each slave in turn.
463 1.1 cgd */
464 1.1 cgd for (i = 0; i < SLAVES; i++) {
465 1.1 cgd q = &tslp->req[1];
466 1.1 cgd otb = (union u_spcl *)slp->tblock;
467 1.1 cgd
468 1.1 cgd /*
469 1.1 cgd * For each request in the current slave, copy it to tslp.
470 1.1 cgd */
471 1.1 cgd
472 1.3 mycroft prev = NULL;
473 1.1 cgd for (p = slp->req; p->count > 0; p += p->count) {
474 1.1 cgd *q = *p;
475 1.1 cgd if (p->dblk == 0)
476 1.1 cgd *ntb++ = *otb++; /* copy the datablock also */
477 1.1 cgd prev = q;
478 1.1 cgd q += q->count;
479 1.1 cgd }
480 1.3 mycroft if (prev == NULL)
481 1.3 mycroft quit("rollforward: protocol botch");
482 1.1 cgd if (prev->dblk != 0)
483 1.1 cgd prev->count -= 1;
484 1.1 cgd else
485 1.1 cgd ntb--;
486 1.1 cgd q -= 1;
487 1.1 cgd q->count = 0;
488 1.1 cgd q = &tslp->req[0];
489 1.1 cgd if (i == 0) {
490 1.1 cgd q->dblk = 0;
491 1.1 cgd q->count = 1;
492 1.1 cgd trecno = 0;
493 1.1 cgd nextblock = tslp->tblock;
494 1.1 cgd savedtapea = spcl.c_tapea;
495 1.1 cgd spcl.c_tapea = slp->tapea;
496 1.1 cgd startnewtape(0);
497 1.1 cgd spcl.c_tapea = savedtapea;
498 1.1 cgd lastspclrec = savedtapea - 1;
499 1.1 cgd }
500 1.1 cgd size = (char *)ntb - (char *)q;
501 1.12 lukem if (atomic_write(slp->fd, (char *)q, size) != size) {
502 1.1 cgd perror(" DUMP: error writing command pipe");
503 1.1 cgd dumpabort(0);
504 1.1 cgd }
505 1.1 cgd slp->sent = 1;
506 1.1 cgd if (++slp >= &slaves[SLAVES])
507 1.1 cgd slp = &slaves[0];
508 1.1 cgd
509 1.1 cgd q->count = 1;
510 1.1 cgd
511 1.1 cgd if (prev->dblk != 0) {
512 1.1 cgd /*
513 1.1 cgd * If the last one was a disk block, make the
514 1.1 cgd * first of this one be the last bit of that disk
515 1.1 cgd * block...
516 1.1 cgd */
517 1.1 cgd q->dblk = prev->dblk +
518 1.1 cgd prev->count * (TP_BSIZE / DEV_BSIZE);
519 1.1 cgd ntb = (union u_spcl *)tslp->tblock;
520 1.1 cgd } else {
521 1.1 cgd /*
522 1.1 cgd * It wasn't a disk block. Copy the data to its
523 1.1 cgd * new location in the buffer.
524 1.1 cgd */
525 1.1 cgd q->dblk = 0;
526 1.1 cgd *((union u_spcl *)tslp->tblock) = *ntb;
527 1.1 cgd ntb = (union u_spcl *)tslp->tblock[1];
528 1.1 cgd }
529 1.1 cgd }
530 1.1 cgd slp->req[0] = *q;
531 1.1 cgd nextblock = slp->tblock;
532 1.1 cgd if (q->dblk == 0)
533 1.1 cgd nextblock++;
534 1.1 cgd trecno = 1;
535 1.1 cgd
536 1.1 cgd /*
537 1.1 cgd * Clear the first slaves' response. One hopes that it
538 1.1 cgd * worked ok, otherwise the tape is much too short!
539 1.1 cgd */
540 1.1 cgd if (slp->sent) {
541 1.12 lukem if (atomic_read(slp->fd, (char *)&got, sizeof got)
542 1.1 cgd != sizeof got) {
543 1.1 cgd perror(" DUMP: error reading command pipe in master");
544 1.1 cgd dumpabort(0);
545 1.1 cgd }
546 1.1 cgd slp->sent = 0;
547 1.1 cgd
548 1.1 cgd if (got != writesize) {
549 1.1 cgd quit("EOT detected at start of the tape!\n");
550 1.1 cgd }
551 1.1 cgd }
552 1.1 cgd }
553 1.1 cgd
554 1.1 cgd /*
555 1.1 cgd * We implement taking and restoring checkpoints on the tape level.
556 1.1 cgd * When each tape is opened, a new process is created by forking; this
557 1.1 cgd * saves all of the necessary context in the parent. The child
558 1.1 cgd * continues the dump; the parent waits around, saving the context.
559 1.1 cgd * If the child returns X_REWRITE, then it had problems writing that tape;
560 1.1 cgd * this causes the parent to fork again, duplicating the context, and
561 1.1 cgd * everything continues as if nothing had happened.
562 1.1 cgd */
563 1.1 cgd void
564 1.1 cgd startnewtape(top)
565 1.1 cgd int top;
566 1.1 cgd {
567 1.1 cgd int parentpid;
568 1.1 cgd int childpid;
569 1.1 cgd int status;
570 1.1 cgd int waitpid;
571 1.1 cgd char *p;
572 1.1 cgd #ifdef sunos
573 1.1 cgd void (*interrupt_save)();
574 1.1 cgd #else
575 1.1 cgd sig_t interrupt_save;
576 1.1 cgd #endif
577 1.1 cgd
578 1.1 cgd interrupt_save = signal(SIGINT, SIG_IGN);
579 1.1 cgd parentpid = getpid();
580 1.8 lukem tapea_volume = spcl.c_tapea;
581 1.8 lukem (void)time(&tstart_volume);
582 1.1 cgd
583 1.3 mycroft restore_check_point:
584 1.1 cgd (void)signal(SIGINT, interrupt_save);
585 1.1 cgd /*
586 1.1 cgd * All signals are inherited...
587 1.1 cgd */
588 1.1 cgd childpid = fork();
589 1.1 cgd if (childpid < 0) {
590 1.1 cgd msg("Context save fork fails in parent %d\n", parentpid);
591 1.1 cgd Exit(X_ABORT);
592 1.1 cgd }
593 1.1 cgd if (childpid != 0) {
594 1.1 cgd /*
595 1.1 cgd * PARENT:
596 1.1 cgd * save the context by waiting
597 1.1 cgd * until the child doing all of the work returns.
598 1.1 cgd * don't catch the interrupt
599 1.1 cgd */
600 1.1 cgd signal(SIGINT, SIG_IGN);
601 1.1 cgd #ifdef TDEBUG
602 1.1 cgd msg("Tape: %d; parent process: %d child process %d\n",
603 1.1 cgd tapeno+1, parentpid, childpid);
604 1.3 mycroft #endif /* TDEBUG */
605 1.1 cgd while ((waitpid = wait(&status)) != childpid)
606 1.1 cgd msg("Parent %d waiting for child %d has another child %d return\n",
607 1.1 cgd parentpid, childpid, waitpid);
608 1.1 cgd if (status & 0xFF) {
609 1.1 cgd msg("Child %d returns LOB status %o\n",
610 1.1 cgd childpid, status&0xFF);
611 1.1 cgd }
612 1.1 cgd status = (status >> 8) & 0xFF;
613 1.1 cgd #ifdef TDEBUG
614 1.1 cgd switch(status) {
615 1.1 cgd case X_FINOK:
616 1.1 cgd msg("Child %d finishes X_FINOK\n", childpid);
617 1.1 cgd break;
618 1.1 cgd case X_ABORT:
619 1.1 cgd msg("Child %d finishes X_ABORT\n", childpid);
620 1.1 cgd break;
621 1.1 cgd case X_REWRITE:
622 1.1 cgd msg("Child %d finishes X_REWRITE\n", childpid);
623 1.1 cgd break;
624 1.1 cgd default:
625 1.1 cgd msg("Child %d finishes unknown %d\n",
626 1.1 cgd childpid, status);
627 1.1 cgd break;
628 1.1 cgd }
629 1.3 mycroft #endif /* TDEBUG */
630 1.1 cgd switch(status) {
631 1.1 cgd case X_FINOK:
632 1.1 cgd Exit(X_FINOK);
633 1.1 cgd case X_ABORT:
634 1.1 cgd Exit(X_ABORT);
635 1.1 cgd case X_REWRITE:
636 1.1 cgd goto restore_check_point;
637 1.1 cgd default:
638 1.1 cgd msg("Bad return code from dump: %d\n", status);
639 1.1 cgd Exit(X_ABORT);
640 1.1 cgd }
641 1.1 cgd /*NOTREACHED*/
642 1.1 cgd } else { /* we are the child; just continue */
643 1.1 cgd #ifdef TDEBUG
644 1.1 cgd sleep(4); /* allow time for parent's message to get out */
645 1.1 cgd msg("Child on Tape %d has parent %d, my pid = %d\n",
646 1.1 cgd tapeno+1, parentpid, getpid());
647 1.3 mycroft #endif /* TDEBUG */
648 1.1 cgd /*
649 1.10 lukem * If we have a name like "/dev/rst0,/dev/rst1",
650 1.1 cgd * use the name before the comma first, and save
651 1.1 cgd * the remaining names for subsequent volumes.
652 1.1 cgd */
653 1.1 cgd tapeno++; /* current tape sequence */
654 1.4 mycroft if (nexttape || strchr(tape, ',')) {
655 1.1 cgd if (nexttape && *nexttape)
656 1.1 cgd tape = nexttape;
657 1.4 mycroft if ((p = strchr(tape, ',')) != NULL) {
658 1.1 cgd *p = '\0';
659 1.1 cgd nexttape = p + 1;
660 1.1 cgd } else
661 1.1 cgd nexttape = NULL;
662 1.1 cgd msg("Dumping volume %d on %s\n", tapeno, tape);
663 1.1 cgd }
664 1.1 cgd #ifdef RDUMP
665 1.1 cgd while ((tapefd = (host ? rmtopen(tape, 2) :
666 1.1 cgd pipeout ? 1 : open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
667 1.1 cgd #else
668 1.1 cgd while ((tapefd = (pipeout ? 1 :
669 1.1 cgd open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
670 1.1 cgd #endif
671 1.1 cgd {
672 1.1 cgd msg("Cannot open output \"%s\".\n", tape);
673 1.1 cgd if (!query("Do you want to retry the open?"))
674 1.1 cgd dumpabort(0);
675 1.1 cgd }
676 1.1 cgd
677 1.1 cgd enslave(); /* Share open tape file descriptor with slaves */
678 1.1 cgd
679 1.1 cgd asize = 0;
680 1.1 cgd blocksthisvol = 0;
681 1.1 cgd if (top)
682 1.1 cgd newtape++; /* new tape signal */
683 1.1 cgd spcl.c_count = slp->count;
684 1.1 cgd /*
685 1.1 cgd * measure firstrec in TP_BSIZE units since restore doesn't
686 1.1 cgd * know the correct ntrec value...
687 1.1 cgd */
688 1.1 cgd spcl.c_firstrec = slp->firstrec;
689 1.1 cgd spcl.c_volume++;
690 1.1 cgd spcl.c_type = TS_TAPE;
691 1.1 cgd spcl.c_flags |= DR_NEWHEADER;
692 1.1 cgd writeheader((ino_t)slp->inode);
693 1.1 cgd spcl.c_flags &=~ DR_NEWHEADER;
694 1.8 lukem msg("Volume %d started at: %s", tapeno, ctime(&tstart_volume));
695 1.1 cgd if (tapeno > 1)
696 1.1 cgd msg("Volume %d begins with blocks from inode %d\n",
697 1.1 cgd tapeno, slp->inode);
698 1.1 cgd }
699 1.1 cgd }
700 1.1 cgd
701 1.1 cgd void
702 1.1 cgd dumpabort(signo)
703 1.1 cgd int signo;
704 1.1 cgd {
705 1.1 cgd
706 1.1 cgd if (master != 0 && master != getpid())
707 1.1 cgd /* Signals master to call dumpabort */
708 1.1 cgd (void) kill(master, SIGTERM);
709 1.1 cgd else {
710 1.1 cgd killall();
711 1.1 cgd msg("The ENTIRE dump is aborted.\n");
712 1.1 cgd }
713 1.2 cgd #ifdef RDUMP
714 1.2 cgd rmtclose();
715 1.2 cgd #endif
716 1.1 cgd Exit(X_ABORT);
717 1.1 cgd }
718 1.1 cgd
719 1.13 lukem void
720 1.1 cgd Exit(status)
721 1.1 cgd int status;
722 1.1 cgd {
723 1.1 cgd
724 1.1 cgd #ifdef TDEBUG
725 1.1 cgd msg("pid = %d exits with status %d\n", getpid(), status);
726 1.3 mycroft #endif /* TDEBUG */
727 1.3 mycroft exit(status);
728 1.1 cgd }
729 1.1 cgd
730 1.1 cgd /*
731 1.1 cgd * proceed - handler for SIGUSR2, used to synchronize IO between the slaves.
732 1.1 cgd */
733 1.12 lukem static void
734 1.1 cgd proceed(signo)
735 1.1 cgd int signo;
736 1.1 cgd {
737 1.1 cgd
738 1.1 cgd if (ready)
739 1.1 cgd longjmp(jmpbuf, 1);
740 1.1 cgd caught++;
741 1.1 cgd }
742 1.1 cgd
743 1.1 cgd void
744 1.1 cgd enslave()
745 1.1 cgd {
746 1.1 cgd int cmd[2];
747 1.9 lukem int i, j;
748 1.1 cgd
749 1.1 cgd master = getpid();
750 1.1 cgd
751 1.1 cgd signal(SIGTERM, dumpabort); /* Slave sends SIGTERM on dumpabort() */
752 1.1 cgd signal(SIGPIPE, sigpipe);
753 1.1 cgd signal(SIGUSR1, tperror); /* Slave sends SIGUSR1 on tape errors */
754 1.1 cgd signal(SIGUSR2, proceed); /* Slave sends SIGUSR2 to next slave */
755 1.1 cgd
756 1.1 cgd for (i = 0; i < SLAVES; i++) {
757 1.1 cgd if (i == slp - &slaves[0]) {
758 1.1 cgd caught = 1;
759 1.1 cgd } else {
760 1.1 cgd caught = 0;
761 1.1 cgd }
762 1.1 cgd
763 1.1 cgd if (socketpair(AF_UNIX, SOCK_STREAM, 0, cmd) < 0 ||
764 1.1 cgd (slaves[i].pid = fork()) < 0)
765 1.1 cgd quit("too many slaves, %d (recompile smaller): %s\n",
766 1.1 cgd i, strerror(errno));
767 1.1 cgd
768 1.1 cgd slaves[i].fd = cmd[1];
769 1.1 cgd slaves[i].sent = 0;
770 1.1 cgd if (slaves[i].pid == 0) { /* Slave starts up here */
771 1.1 cgd for (j = 0; j <= i; j++)
772 1.1 cgd (void) close(slaves[j].fd);
773 1.1 cgd signal(SIGINT, SIG_IGN); /* Master handles this */
774 1.11 lukem signal(SIGINFO, SIG_IGN);
775 1.1 cgd doslave(cmd[0], i);
776 1.1 cgd Exit(X_FINOK);
777 1.1 cgd }
778 1.1 cgd }
779 1.1 cgd
780 1.1 cgd for (i = 0; i < SLAVES; i++)
781 1.12 lukem (void) atomic_write(slaves[i].fd,
782 1.1 cgd (char *) &slaves[(i + 1) % SLAVES].pid,
783 1.1 cgd sizeof slaves[0].pid);
784 1.1 cgd
785 1.1 cgd master = 0;
786 1.1 cgd }
787 1.1 cgd
788 1.1 cgd void
789 1.1 cgd killall()
790 1.1 cgd {
791 1.9 lukem int i;
792 1.1 cgd
793 1.1 cgd for (i = 0; i < SLAVES; i++)
794 1.1 cgd if (slaves[i].pid > 0)
795 1.1 cgd (void) kill(slaves[i].pid, SIGKILL);
796 1.1 cgd }
797 1.1 cgd
798 1.1 cgd /*
799 1.1 cgd * Synchronization - each process has a lockfile, and shares file
800 1.1 cgd * descriptors to the following process's lockfile. When our write
801 1.1 cgd * completes, we release our lock on the following process's lock-
802 1.1 cgd * file, allowing the following process to lock it and proceed. We
803 1.1 cgd * get the lock back for the next cycle by swapping descriptors.
804 1.1 cgd */
805 1.3 mycroft static void
806 1.1 cgd doslave(cmd, slave_number)
807 1.9 lukem int cmd;
808 1.1 cgd int slave_number;
809 1.1 cgd {
810 1.9 lukem int nread;
811 1.1 cgd int nextslave, size, wrote, eot_count;
812 1.7 mycroft sigset_t sigset;
813 1.1 cgd
814 1.1 cgd /*
815 1.1 cgd * Need our own seek pointer.
816 1.1 cgd */
817 1.1 cgd (void) close(diskfd);
818 1.1 cgd if ((diskfd = open(disk, O_RDONLY)) < 0)
819 1.1 cgd quit("slave couldn't reopen disk: %s\n", strerror(errno));
820 1.1 cgd
821 1.1 cgd /*
822 1.1 cgd * Need the pid of the next slave in the loop...
823 1.1 cgd */
824 1.12 lukem if ((nread = atomic_read(cmd, (char *)&nextslave, sizeof nextslave))
825 1.1 cgd != sizeof nextslave) {
826 1.1 cgd quit("master/slave protocol botched - didn't get pid of next slave.\n");
827 1.1 cgd }
828 1.1 cgd
829 1.1 cgd /*
830 1.1 cgd * Get list of blocks to dump, read the blocks into tape buffer
831 1.1 cgd */
832 1.12 lukem while ((nread = atomic_read(cmd, (char *)slp->req, reqsiz)) == reqsiz) {
833 1.9 lukem struct req *p = slp->req;
834 1.1 cgd
835 1.1 cgd for (trecno = 0; trecno < ntrec;
836 1.1 cgd trecno += p->count, p += p->count) {
837 1.1 cgd if (p->dblk) {
838 1.1 cgd bread(p->dblk, slp->tblock[trecno],
839 1.1 cgd p->count * TP_BSIZE);
840 1.1 cgd } else {
841 1.12 lukem if (p->count != 1 || atomic_read(cmd,
842 1.1 cgd (char *)slp->tblock[trecno],
843 1.1 cgd TP_BSIZE) != TP_BSIZE)
844 1.1 cgd quit("master/slave protocol botched.\n");
845 1.1 cgd }
846 1.1 cgd }
847 1.1 cgd if (setjmp(jmpbuf) == 0) {
848 1.1 cgd ready = 1;
849 1.1 cgd if (!caught)
850 1.1 cgd (void) pause();
851 1.1 cgd }
852 1.1 cgd ready = 0;
853 1.1 cgd caught = 0;
854 1.1 cgd
855 1.1 cgd /* Try to write the data... */
856 1.1 cgd eot_count = 0;
857 1.1 cgd size = 0;
858 1.1 cgd
859 1.1 cgd while (eot_count < 10 && size < writesize) {
860 1.1 cgd #ifdef RDUMP
861 1.1 cgd if (host)
862 1.1 cgd wrote = rmtwrite(slp->tblock[0]+size,
863 1.1 cgd writesize-size);
864 1.1 cgd else
865 1.1 cgd #endif
866 1.1 cgd wrote = write(tapefd, slp->tblock[0]+size,
867 1.1 cgd writesize-size);
868 1.1 cgd #ifdef WRITEDEBUG
869 1.1 cgd printf("slave %d wrote %d\n", slave_number, wrote);
870 1.1 cgd #endif
871 1.1 cgd if (wrote < 0)
872 1.1 cgd break;
873 1.1 cgd if (wrote == 0)
874 1.1 cgd eot_count++;
875 1.1 cgd size += wrote;
876 1.1 cgd }
877 1.1 cgd
878 1.1 cgd #ifdef WRITEDEBUG
879 1.1 cgd if (size != writesize)
880 1.1 cgd printf("slave %d only wrote %d out of %d bytes and gave up.\n",
881 1.1 cgd slave_number, size, writesize);
882 1.1 cgd #endif
883 1.1 cgd
884 1.1 cgd if (eot_count > 0)
885 1.1 cgd size = 0;
886 1.1 cgd
887 1.1 cgd /*
888 1.1 cgd * fixme: Pyramids running OSx return ENOSPC
889 1.1 cgd * at EOT on 1/2 inch drives.
890 1.1 cgd */
891 1.1 cgd if (size < 0) {
892 1.1 cgd (void) kill(master, SIGUSR1);
893 1.7 mycroft sigemptyset(&sigset);
894 1.1 cgd for (;;)
895 1.7 mycroft sigsuspend(&sigset);
896 1.1 cgd } else {
897 1.1 cgd /*
898 1.1 cgd * pass size of write back to master
899 1.1 cgd * (for EOT handling)
900 1.1 cgd */
901 1.12 lukem (void) atomic_write(cmd, (char *)&size, sizeof size);
902 1.1 cgd }
903 1.1 cgd
904 1.1 cgd /*
905 1.1 cgd * If partial write, don't want next slave to go.
906 1.1 cgd * Also jolts him awake.
907 1.1 cgd */
908 1.1 cgd (void) kill(nextslave, SIGUSR2);
909 1.1 cgd }
910 1.1 cgd if (nread != 0)
911 1.1 cgd quit("error reading command pipe: %s\n", strerror(errno));
912 1.1 cgd }
913 1.1 cgd
914 1.1 cgd /*
915 1.1 cgd * Since a read from a pipe may not return all we asked for,
916 1.1 cgd * loop until the count is satisfied (or error).
917 1.1 cgd */
918 1.5 cgd static ssize_t
919 1.12 lukem atomic_read(fd, buf, count)
920 1.12 lukem int fd;
921 1.12 lukem char *buf;
922 1.12 lukem int count;
923 1.12 lukem {
924 1.12 lukem ssize_t got, need = count;
925 1.12 lukem
926 1.12 lukem while ((got = read(fd, buf, need)) > 0 && (need -= got) > 0)
927 1.12 lukem buf += got;
928 1.12 lukem return (got < 0 ? got : count - need);
929 1.12 lukem }
930 1.12 lukem
931 1.12 lukem /*
932 1.12 lukem * Since a write may not write all we ask if we get a signal,
933 1.12 lukem * loop until the count is satisfied (or error).
934 1.12 lukem */
935 1.12 lukem static ssize_t
936 1.12 lukem atomic_write(fd, buf, count)
937 1.5 cgd int fd;
938 1.1 cgd char *buf;
939 1.3 mycroft int count;
940 1.1 cgd {
941 1.5 cgd ssize_t got, need = count;
942 1.1 cgd
943 1.12 lukem while ((got = write(fd, buf, need)) > 0 && (need -= got) > 0)
944 1.1 cgd buf += got;
945 1.1 cgd return (got < 0 ? got : count - need);
946 1.1 cgd }
947