ticket-2618-patches-20031207
[openafs.git] / src / butc / dump.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <sys/types.h>
17 #ifdef AFS_NT40_ENV
18 #include <winsock2.h>
19 #else
20 #include <sys/time.h>
21 #include <sys/file.h>
22 #include <netinet/in.h>
23 #include <sys/socket.h>
24 #include <netdb.h>
25 #endif
26 #include <stdlib.h>
27 #include <rx/xdr.h>
28 #include <rx/rx.h>
29 #include <lwp.h>
30 #include <lock.h>
31 #include <errno.h>
32 #include <afs/tcdata.h>
33 #include <afs/bubasics.h>
34 #include <afs/budb_client.h>
35 #include <afs/vldbint.h>
36 #include <afs/ktime.h>
37 #include <afs/vlserver.h>
38 #include <afs/volser.h>
39 #include <afs/volint.h>
40 #include <afs/cellconfig.h>
41
42 #include "error_macros.h"
43 #include "butc_xbsa.h"
44 #include "afs/butx.h"
45
46
47 /* GLOBAL CONFIGURATION PARAMETERS */
48 extern int dump_namecheck;
49 extern int queryoperator;
50 extern int isafile;
51 extern int forcemultiple;
52
53 extern struct ubik_client *cstruct;
54 dlqlinkT savedEntries;
55 dlqlinkT entries_to_flush;
56
57 afs_int32 flushSavedEntries(), finishDump(), finishTape(), useTape(),
58 addVolume();
59
60 extern struct rx_connection *UV_Bind();
61
62 extern afs_int32 groupId;
63 extern afs_int32 BufferSize;
64 extern afs_int32 statusSize;
65 extern FILE *centralLogIO;
66 afs_int32 lastPass = 0;
67 #ifdef xbsa
68 extern afs_int32 xbsaType;
69 char *butcdumpIdStr = "/backup_afs_volume_dumps";
70 extern struct butx_transactionInfo butxInfo;
71 extern char *xbsaObjectOwner;
72 extern char *appObjectOwner;
73 extern char *xbsaSecToken;
74 extern char *xbsalGName;
75 extern char *globalButcLog;
76 #endif /*xbsa */
77
78 afs_int32 dataSize;             /* Size of data to read on each rx_Read() call */
79 afs_int32 tapeblocks;           /* Number of 16K tape datablocks in buffer (!CONF_XBSA) */
80
81 /* TBD
82  *
83  * Done 1) dump id generation
84  * Done xx) volume fragment number accounting !!  I think.
85  * 2) check abort - check after subroutine calls
86  * Done 3) trailer anomaly
87  * 4) trailer damage indicator after partial dumps ( affects scandump )
88  * Done 5) Ensure mount failure logged
89  * 6) Ensure bucoord status calls work
90  *
91  * notes
92  * pass 3: 
93  *      keep token timeout. If no user reponse (idle time > some period)
94  *      and tokens about to time out, terminate dump. This provides at
95  *      least something usable.
96  */
97
98 #define DUMPNAME(dumpname, name, dbDumpId) \
99    if (dbDumpId == 0) \
100      sprintf(dumpname, "%s", name); \
101    else \
102      sprintf(dumpname, "%s (DumpId %u)", name, dbDumpId);
103
104 #if defined(AFS_NT40_ENV) || (defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN60_ENV)) || defined(AFS_SUN4_ENV)
105 int
106 localtime_r(time_t * t, struct tm *tm)
107 {
108     memcpy(tm, localtime(t), sizeof(struct tm));
109 }
110 #endif
111
112 struct dumpRock {
113     /* status only */
114     int tapeSeq;
115     int curVolume;              /* index in dumpNode of volume */
116     int curVolumeStatus;        /* more explicit dump state */
117     afs_uint32 curVolStartPos;  /* Starting position of the current volume */
118     afs_uint32 databaseDumpId;  /* real dump id, for db */
119     afs_uint32 initialDumpId;   /* the initial dump, for appended dumps */
120     afs_int32 volumesDumped;    /* # volumes successfully dumped */
121     afs_int32 volumesFailed;    /* # volumes that failed to dump */
122     afs_int32 volumesNotDumped; /* # volumes that were not dumped (didn't fail) */
123
124     /* tape management */
125     char tapeName[TC_MAXTAPENAMELEN];
126     struct butm_tapeInfo *tapeInfoPtr;
127     struct butm_tapeLabel tapeLabel;
128     int wroteLabel;             /* If the tape label is written */
129
130     /* database information */
131     struct budb_dumpEntry lastDump;     /* the last dump of this volset */
132     struct budb_dumpEntry dump; /* current dump */
133     struct budb_tapeEntry tape; /* current tape, not used -VA */
134
135     /* links to existing info */
136     struct dumpNode *node;
137 };
138
139 /* configuration variables */
140 #define HITEOT(code) ((code == BUTM_IO) || (code == BUTM_EOT) || (code == BUTM_IOCTL))
141 extern int autoQuery;
142 extern int maxpass;
143
144 afs_int32 tc_EndMargin;
145 afs_int32 tc_KEndMargin;
146 static char *bufferBlock;
147
148 /* compute the absolute expiration date */
149 afs_int32
150 calcExpirationDate(afs_int32 expType, afs_int32 expDate, afs_int32 createTime)
151 {
152     struct ktime_date kd;
153     afs_int32 Add_RelDate_to_Time();
154
155     switch (expType) {
156     case BC_REL_EXPDATE:
157         /* expiration date is relative to the creation time of the dump.
158          * This is the only case that requires any work
159          */
160         Int32To_ktimeRelDate(expDate, &kd);
161         return (Add_RelDate_to_Time(&kd, createTime));
162         break;
163
164     case BC_ABS_EXPDATE:
165         return (expDate);
166         break;
167
168     case BC_NO_EXPDATE:
169     default:
170         return (0);
171     }
172 }
173
174 afs_int32 curr_bserver = 0;
175 struct rx_connection *curr_fromconn = (struct rx_connection *)0;
176
177 struct rx_connection *
178 Bind(afs_int32 server)
179 {
180     if (curr_fromconn) {
181         if (curr_bserver == server)     /* Keep connection if have it */
182             return (curr_fromconn);
183
184         rx_DestroyConnection(curr_fromconn);    /* Otherwise get rid of it */
185         curr_fromconn = (struct rx_connection *)0;
186         curr_bserver = 0;
187     }
188
189     if (server) {
190         curr_fromconn = UV_Bind(server, AFSCONF_VOLUMEPORT);    /* Establish new connection */
191         if (curr_fromconn)
192             curr_bserver = server;
193     }
194
195     return (curr_fromconn);
196 }
197
198 /* notes
199  * 1) save the chunksize or otherwise ensure tape space remaining is
200  *      check frequently enough
201  * 2) This is called once. For partial dumps, need to 
202  *      ensure that the tape device is left in the correct state for
203  *      further dumps.
204  * 
205  */
206 #define BIGCHUNK 102400
207
208 afs_int32
209 dumpVolume(struct tc_dumpDesc * curDump, struct dumpRock * dparamsPtr)
210 {
211     struct butm_tapeInfo *tapeInfoPtr = dparamsPtr->tapeInfoPtr;
212     struct dumpNode *nodePtr = dparamsPtr->node;
213     afs_int32 taskId = nodePtr->taskID;
214     char *buffer;
215     int fragmentNumber;
216     afs_int32 volumeFlags;
217     afs_int32 kRemaining;
218     afs_int32 rc, code = 0;
219     afs_int32 toread;
220     afs_uint32 volBytesRead;
221     afs_uint32 chunkSize;
222     afs_int32 bytesread;        /* rx reads */
223     int endofvolume = 0;        /* Have we read all volume data */
224     int indump = 0;
225     int fragmentvolume;
226     struct volumeHeader hostVolumeHeader;
227
228     struct rx_call *fromcall = (struct rx_call *)0;
229     struct rx_connection *fromconn;
230     afs_int32 updatedate, fromtid = 0;
231     volEntries volumeInfo;
232     afs_int32 bytesWritten;
233     afs_uint32 statuscount = statusSize, tsize = 0;
234
235     dparamsPtr->curVolumeStatus = DUMP_NOTHING;
236
237     fromconn = Bind(htonl(curDump->hostAddr));  /* get connection to the server */
238
239     /* Determine when the volume was last cloned and updated */
240     volumeInfo.volEntries_val = (volintInfo *) 0;
241     volumeInfo.volEntries_len = 0;
242     rc = AFSVolListOneVolume(fromconn, curDump->partition, curDump->vid,
243                              &volumeInfo);
244     if (rc)
245         ERROR_EXIT(rc);
246     updatedate = volumeInfo.volEntries_val[0].updateDate;
247     curDump->cloneDate =
248         ((curDump->vtype ==
249           RWVOL) ? time(0) : volumeInfo.volEntries_val[0].creationDate);
250
251     if (curDump->date >= curDump->cloneDate)
252         ERROR_EXIT(0);          /* not recloned since last dump */
253     if (curDump->date > updatedate) {
254         dparamsPtr->curVolumeStatus = DUMP_NODUMP;      /* not modified since last dump */
255         ERROR_EXIT(0);
256     }
257
258     /* Start the volserver transaction and dump */
259     rc = AFSVolTransCreate(fromconn, curDump->vid, curDump->partition, ITBusy,
260                            &fromtid);
261     if (rc)
262         ERROR_EXIT(rc);
263     fromcall = rx_NewCall(fromconn);
264
265     rc = StartAFSVolDump(fromcall, fromtid, curDump->date);
266     if (rc)
267         ERROR_EXIT(rc);
268
269     dparamsPtr->curVolumeStatus = DUMP_PARTIAL;
270     dparamsPtr->curVolStartPos = tapeInfoPtr->position;
271
272     /* buffer is place in bufferBlock to write volume data.
273      * butm_writeFileData() assumes the previous BUTM_HDRSIZE bytes
274      * is available to write the tape block header.
275      */
276     buffer = bufferBlock + BUTM_HDRSIZE;
277
278     /* Dump one volume fragment at a time until we dump the full volume.
279      * A volume with more than 1 fragment means the volume will 'span' 
280      * 2 or more tapes.
281      */
282     for (fragmentNumber = 1; !endofvolume; fragmentNumber++) {  /*frag */
283         rc = butm_WriteFileBegin(tapeInfoPtr);
284         if (rc) {
285             ErrorLog(1, taskId, rc, tapeInfoPtr->error,
286                      "Can't write FileBegin on tape\n");
287             ERROR_EXIT(rc);
288         }
289         indump = 1;             /* first write to tape */
290
291         /* Create and Write the volume header */
292         makeVolumeHeader(&hostVolumeHeader, dparamsPtr, fragmentNumber);
293         hostVolumeHeader.contd = ((fragmentNumber == 1) ? 0 : TC_VOLCONTD);
294         volumeHeader_hton(&hostVolumeHeader, buffer);
295
296         rc = butm_WriteFileData(tapeInfoPtr, buffer, 1,
297                                 sizeof(hostVolumeHeader));
298         if (rc) {
299             ErrorLog(1, taskId, rc, tapeInfoPtr->error,
300                      "Can't write VolumeHeader on tape\n");
301             ERROR_EXIT(rc);
302         }
303
304         bytesWritten = BUTM_BLOCKSIZE;  /* Wrote one tapeblock */
305         tsize += bytesWritten;
306
307         /* Start reading volume data, rx_Read(), and dumping to the tape
308          * until we've dumped the entire volume (endofvolume == 1). We can
309          * exit this loop early if we find we are close to the end of the
310          * tape; in which case we dump the next fragment on the next tape.
311          */
312         volBytesRead = 0;
313         chunkSize = 0;
314         fragmentvolume = 0;
315         while (!endofvolume && !fragmentvolume) {       /*w */
316             bytesread = 0;
317
318             /* Check for abort in the middle of writing data */
319             if (volBytesRead >= chunkSize) {
320                 chunkSize += BIGCHUNK;
321                 if (checkAbortByTaskId(taskId))
322                     ABORT_EXIT(TC_ABORTEDBYREQUEST);
323
324                 /* set bytes dumped for backup */
325                 lock_Status();
326                 nodePtr->statusNodePtr->nKBytes = tapeInfoPtr->kBytes;
327                 unlock_Status();
328             }
329
330             /* Determine how much data to read in upcoming RX_Read() call */
331             toread = dataSize;
332             /* Check if we are close to the EOT. There should at least be some
333              * data on the tape before it is switched. HACK: we have to split a 
334              * volume across tapes because the volume trailer says the dump 
335              * continues on the next tape (and not the filemark). This could 
336              * result in a volume starting on one tape (no volume data dumped) and 
337              * continued on the next tape. It'll work, just requires restore to 
338              * switch tapes. This allows many small volumes (<16K) to be dumped.
339              */
340             kRemaining = butm_remainingKSpace(tapeInfoPtr);
341             if ((kRemaining < tc_KEndMargin)
342                 && (volBytesRead
343                     || (tapeInfoPtr->position > (isafile ? 3 : 2)))) {
344                 fragmentvolume = 1;
345             }
346
347
348             /* Guess at how much data to read. So we don't write off end of tape */
349             if (kRemaining < (tapeblocks * 16)) {
350                 if (kRemaining < 0) {
351                     toread = BUTM_BLKSIZE;
352                 } else {
353                     toread = ((kRemaining / 16) + 1) * BUTM_BLKSIZE;
354                     if (toread > dataSize)
355                         toread = dataSize;
356                 }
357             }
358
359             /* Read some volume data. */
360             if (fragmentvolume) {
361                 bytesread = 0;
362             } else {
363                 bytesread = rx_Read(fromcall, buffer, toread);
364                 volBytesRead += bytesread;
365                 if (bytesread != toread) {
366                     /* Make sure were at end of volume and not a communication error */
367                     rc = rx_Error(fromcall);
368                     if (rc)
369                         ERROR_EXIT(rc);
370                     endofvolume = 1;
371                 }
372             }
373
374             if (fragmentvolume || endofvolume) {
375                 /* Create a volume trailer appending it to this data block */
376                 makeVolumeHeader(&hostVolumeHeader, dparamsPtr,
377                                  fragmentNumber);
378                 hostVolumeHeader.contd = (endofvolume ? 0 : TC_VOLCONTD);
379                 hostVolumeHeader.magic = TC_VOLENDMAGIC;
380                 hostVolumeHeader.endTime = (endofvolume ? time(0) : 0);
381                 volumeHeader_hton(&hostVolumeHeader, &buffer[bytesread]);
382                 bytesread += sizeof(hostVolumeHeader);
383             }
384
385             /* Write the datablock out */
386             /* full data buffer - write it to tape */
387             rc = butm_WriteFileData(tapeInfoPtr, buffer, tapeblocks,
388                                     bytesread);
389             if (rc) {
390                 ErrorLog(1, taskId, rc, tapeInfoPtr->error,
391                          "Can't write VolumeData on tape\n");
392                 ERROR_EXIT(rc);
393             }
394             bytesWritten = tapeblocks * BUTM_BLOCKSIZE;
395             tsize += bytesWritten;
396
397             /* Display a status line every statusSize or at end of volume */
398             if (statusSize
399                 && ((tsize >= statuscount) || endofvolume
400                     || fragmentvolume)) {
401                 time_t t = time(0);
402                 struct tm tm;
403                 localtime_r(&t, &tm);
404                 printf("%02d:%02d:%02d: Task %u: %u KB: %s: %u B\n",
405                        tm.tm_hour, tm.tm_min, tm.tm_sec, taskId,
406                        tapeInfoPtr->kBytes, hostVolumeHeader.volumeName,
407                        tsize);
408                 statuscount = tsize + statusSize;
409             }
410         }                       /*w */
411
412         /* End the dump before recording it in BUDB as successfully dumped */
413         rc = butm_WriteFileEnd(tapeInfoPtr);
414         indump = 0;
415         if (rc) {
416             ErrorLog(1, taskId, rc, tapeInfoPtr->error,
417                      "Can't write FileEnd on tape\n");
418             ERROR_EXIT(rc);
419         }
420
421         /* Record in BUDB the volume fragment as succcessfully dumped */
422         volumeFlags = ((fragmentNumber == 1) ? BUDB_VOL_FIRSTFRAG : 0);
423         if (endofvolume)
424             volumeFlags |= BUDB_VOL_LASTFRAG;
425         rc = addVolume(0, dparamsPtr->databaseDumpId, dparamsPtr->tapeName,
426                        nodePtr->dumps[dparamsPtr->curVolume].name,
427                        nodePtr->dumps[dparamsPtr->curVolume].vid,
428                        nodePtr->dumps[dparamsPtr->curVolume].cloneDate,
429                        dparamsPtr->curVolStartPos, volBytesRead,
430                        (fragmentNumber - 1), volumeFlags);
431         if (rc)
432             ABORT_EXIT(rc);
433
434         /* If haven't finished dumping the volume, end this
435          * tape and get the next tape.
436          */
437         if (!endofvolume) {
438             /* Write an EOT marker.
439              * Log the error but ignore it since the dump is effectively done.
440              * Scantape will detect continued volume and not read the EOT.
441              */
442             rc = butm_WriteEOT(tapeInfoPtr);
443             if (rc)
444                 TapeLog(1, taskId, rc, tapeInfoPtr->error,
445                         "Warning: Can't write End-Of-Dump on tape\n");
446
447             /* Unmount the tape */
448             unmountTape(taskId, tapeInfoPtr);
449
450             /* Tell the database the tape is complete (and ok) */
451             rc = finishTape(&dparamsPtr->tape,
452                             dparamsPtr->tapeInfoPtr->kBytes +
453                             (dparamsPtr->tapeInfoPtr->nBytes ? 1 : 0));
454             if (rc)
455                 ABORT_EXIT(rc);
456
457             /* get the next tape. Prompt, mount, and add it into the database */
458             dparamsPtr->tapeSeq++;
459             rc = getDumpTape(dparamsPtr, 1, 0); /* interactive - no append */
460             if (rc)
461                 ABORT_EXIT(rc);
462
463             dparamsPtr->curVolStartPos = tapeInfoPtr->position;
464         }
465     }                           /*frag */
466
467     dparamsPtr->curVolumeStatus = DUMP_SUCCESS;
468
469   error_exit:
470     /* 
471      * If we hit the end, see if this is the first volume on the tape or not.
472      * Also, mark the tape as finished if the tape contains other dumps.
473      */
474     if (!code)
475         code = rc;
476     if (HITEOT(code)) {
477         ErrorLog(2, taskId, code, tapeInfoPtr->error,
478                  "Warning: Dump (%s) hit end-of-tape inferred\n",
479                  nodePtr->dumpSetName);
480
481         if (tapeInfoPtr->position == 2) {
482             dparamsPtr->curVolumeStatus = DUMP_NORETRYEOT;
483         } else {
484             dparamsPtr->curVolumeStatus = DUMP_RETRY;
485             rc = finishTape(&dparamsPtr->tape,
486                             dparamsPtr->tapeInfoPtr->kBytes +
487                             (dparamsPtr->tapeInfoPtr->nBytes ? 1 : 0));
488             if (rc)
489                 ABORT_EXIT(rc);
490         }
491     }
492
493     /* 
494      * This is used when an error occurs part way into a volume dump. Clean
495      * the tape state by writing an FileEnd mark. Forgo this action if we hit
496      * the end of tape.
497      */
498     else if (indump) {
499         rc = butm_WriteFileEnd(tapeInfoPtr);
500         indump = 0;
501         if (rc) {
502             ErrorLog(1, taskId, rc, tapeInfoPtr->error,
503                      "Can't write FileEnd on tape\n");
504         }
505     }
506
507     if (fromcall) {
508         rc = rx_EndCall(fromcall, 0);
509         if (!code)
510             code = rc;
511     }
512
513     if (fromtid) {
514         afs_int32 rcode;
515         rc = AFSVolEndTrans(fromconn, fromtid, &rcode);
516         if (!code)
517             code = (rc ? rc : rcode);
518     }
519
520     return (code);
521
522   abort_exit:
523     dparamsPtr->curVolumeStatus = DUMP_FAILED;
524     ERROR_EXIT(code);
525 }
526
527 afs_int32
528 xbsaDumpVolume(struct tc_dumpDesc * curDump, struct dumpRock * dparamsPtr)
529 {
530 #ifdef xbsa
531     struct butm_tapeInfo *tapeInfoPtr = dparamsPtr->tapeInfoPtr;
532     struct dumpNode *nodePtr = dparamsPtr->node;
533     char *buffer = bufferBlock;
534     afs_int32 taskId = nodePtr->taskID;
535     afs_int32 rc, code = 0;
536     afs_int32 toread;
537     afs_uint32 volBytesRead;
538     afs_uint32 chunkSize;
539     afs_int32 bytesread;        /* rx reads */
540     int endofvolume = 0;        /* Have we read all volume data */
541     int begindump = 0, indump = 0;      /* if dump transaction started; if dumping data */
542     struct volumeHeader hostVolumeHeader;
543
544     struct rx_call *fromcall = (struct rx_call *)0;
545     struct rx_connection *fromconn;
546     afs_int32 updatedate, fromtid = 0;
547     volEntries volumeInfo;
548     afs_int32 bytesWritten;
549     afs_uint32 statuscount = statusSize, tsize = 0, esize;
550     afs_hyper_t estSize;
551
552     char dumpIdStr[XBSA_MAX_OSNAME];
553     char volumeNameStr[XBSA_MAX_PATHNAME];
554     static char *dumpDescription = "AFS volume dump";
555     static char *objectDescription = "XBSA - butc";
556
557     dparamsPtr->curVolumeStatus = DUMP_NOTHING;
558
559     fromconn = Bind(htonl(curDump->hostAddr));  /* get connection to the server */
560
561     /* Determine when the volume was last cloned and updated */
562     volumeInfo.volEntries_val = (volintInfo *) 0;
563     volumeInfo.volEntries_len = 0;
564     rc = AFSVolListOneVolume(fromconn, curDump->partition, curDump->vid,
565                              &volumeInfo);
566     if (rc)
567         ERROR_EXIT(rc);
568     updatedate = volumeInfo.volEntries_val[0].updateDate;
569     curDump->cloneDate =
570         ((curDump->vtype ==
571           RWVOL) ? time(0) : volumeInfo.volEntries_val[0].creationDate);
572
573     /* Get the volume size (in KB) and increase by 25%. Then set as a hyper */
574     esize = volumeInfo.volEntries_val[0].size;
575     esize += (esize / 4) + 1;
576
577     if (curDump->date >= curDump->cloneDate)
578         ERROR_EXIT(0);          /* not recloned since last dump */
579     if (curDump->date > updatedate) {
580         dparamsPtr->curVolumeStatus = DUMP_NODUMP;      /* not modified since last dump */
581         ERROR_EXIT(0);
582     }
583
584     /* Start a new XBSA Transaction */
585     rc = xbsa_BeginTrans(&butxInfo);
586     if (rc != XBSA_SUCCESS) {
587         ErrorLog(1, taskId, rc, 0, "Unable to create a new transaction\n");
588         ERROR_EXIT(rc);
589     }
590     begindump = 1;              /* Will need to do an xbsa_EndTrans */
591
592     /* Start the volserver transaction and dump. Once started, the
593      * volume status is "partial dump". Also, the transaction with
594      * the volserver is idle until the first read. An idle transaction
595      * will time out in 600 seconds. After the first rx_Read,
596      * the transaction is not idle. See GCTrans().
597      */
598     rc = AFSVolTransCreate(fromconn, curDump->vid, curDump->partition, ITBusy,
599                            &fromtid);
600     if (rc)
601         ERROR_EXIT(rc);
602     fromcall = rx_NewCall(fromconn);
603
604     rc = StartAFSVolDump(fromcall, fromtid, curDump->date);
605     if (rc)
606         ERROR_EXIT(rc);
607
608     dparamsPtr->curVolumeStatus = DUMP_PARTIAL;
609     dparamsPtr->curVolStartPos = tapeInfoPtr->position;
610
611     /* Tell XBSA what the name and size of volume to write */
612     strcpy(dumpIdStr, butcdumpIdStr);   /* "backup_afs_volume_dumps" */
613     sprintf(volumeNameStr, "/%d", dparamsPtr->databaseDumpId);
614     strcat(volumeNameStr, "/");
615     strcat(volumeNameStr, curDump->name);       /* <dumpid>/<volname> */
616     hset32(estSize, esize);
617     hshlft(estSize, 10);        /* Multiply by 1024 so its in KB */
618
619     rc = xbsa_WriteObjectBegin(&butxInfo, dumpIdStr, volumeNameStr,
620                                xbsalGName, estSize, dumpDescription,
621                                objectDescription);
622     if (rc != XBSA_SUCCESS) {
623         ErrorLog(1, taskId, rc, 0,
624                  "Unable to begin writing of the fileset data to the server\n");
625         ERROR_EXIT(rc);
626     }
627     indump = 1;                 /* Will need to do an xbsa_WriteObjectEnd */
628
629     /* Create and Write the volume header */
630     makeVolumeHeader(&hostVolumeHeader, dparamsPtr, 1);
631     hostVolumeHeader.contd = 0;
632     volumeHeader_hton(&hostVolumeHeader, buffer);
633
634     rc = xbsa_WriteObjectData(&butxInfo, buffer, sizeof(struct volumeHeader),
635                               &bytesWritten);
636     if (rc != XBSA_SUCCESS) {
637         ErrorLog(1, taskId, rc, 0,
638                  "Unable to write VolumeHeader data to the server\n");
639         ERROR_EXIT(rc);
640     }
641     /* There is a bug in the ADSM library where the bytesWritten is
642      * not filled in, so we set it as correct anyway.
643      */
644     bytesWritten = sizeof(struct volumeHeader);
645     if (bytesWritten != sizeof(struct volumeHeader)) {
646         ErrorLog(1, taskId, rc, 0,
647                  "The size of VolumeHeader written (%d) does not equal its actual size (%d)\n",
648                  bytesWritten, sizeof(struct volumeHeader));
649         ERROR_EXIT(TC_INTERNALERROR);
650     }
651
652     incSize(tapeInfoPtr, sizeof(struct volumeHeader));  /* Increment amount we've written */
653     tsize += bytesWritten;
654
655     /* Start reading volume data, rx_Read(), and dumping to the tape
656      * until we've dumped the entire volume (endofvolume == 1).
657      */
658     volBytesRead = 0;
659     chunkSize = 0;
660     while (!endofvolume) {      /*w */
661         bytesread = 0;
662
663         /* Check for abort in the middle of writing data */
664         if (volBytesRead >= chunkSize) {
665             chunkSize += BIGCHUNK;
666             if (checkAbortByTaskId(taskId))
667                 ABORT_EXIT(TC_ABORTEDBYREQUEST);
668
669             /* set bytes dumped for backup */
670             lock_Status();
671             nodePtr->statusNodePtr->nKBytes = tapeInfoPtr->kBytes;
672             unlock_Status();
673         }
674
675         /* Determine how much data to read in upcoming RX_Read() call */
676         toread = dataSize;
677
678         /* Read some volume data. */
679         bytesread = rx_Read(fromcall, buffer, toread);
680         volBytesRead += bytesread;
681         if (bytesread != toread) {
682             afs_int32 rcode;
683
684             /* Make sure were at end of volume and not a communication error */
685             rc = rx_Error(fromcall);
686             if (rc)
687                 ERROR_EXIT(rc);
688
689             endofvolume = 1;
690
691             /* Create a volume trailer appending it to this data block (if not XBSA) */
692             makeVolumeHeader(&hostVolumeHeader, dparamsPtr, 1);
693             hostVolumeHeader.contd = 0;
694             hostVolumeHeader.magic = TC_VOLENDMAGIC;
695             hostVolumeHeader.endTime = time(0);
696             volumeHeader_hton(&hostVolumeHeader, &buffer[bytesread]);
697             bytesread += sizeof(hostVolumeHeader);
698
699             /* End the dump and transaction with the volserver. We end it now, before
700              * we make the XBSA call because if XBSA blocks, we could time out on the 
701              * volserver (After last read, the transaction with the volserver is idle).
702              */
703             rc = rx_EndCall(fromcall, 0);
704             fromcall = 0;
705             if (rc)
706                 ERROR_EXIT(rc);
707
708             rc = AFSVolEndTrans(fromconn, fromtid, &rcode);
709             fromtid = 0;
710             if (rc)
711                 ERROR_EXIT(rc);
712         }
713
714         /* Write the datablock out */
715         rc = xbsa_WriteObjectData(&butxInfo, buffer, bytesread,
716                                   &bytesWritten);
717         if (rc != XBSA_SUCCESS) {
718             ErrorLog(1, taskId, rc, 0,
719                      "Unable to write data to the server\n");
720             ERROR_EXIT(rc);
721         }
722         /* There is a bug in the ADSM library where the bytesWritten is
723          * not filled in, so we set it as correct anyway.
724          */
725         bytesWritten = bytesread;
726         if (bytesWritten != bytesread) {
727             ErrorLog(1, taskId, rc, 0,
728                      "The size of data written (%d) does not equal size read (%d)\n",
729                      bytesWritten, bytesread);
730             ERROR_EXIT(TC_INTERNALERROR);
731         }
732
733         incSize(tapeInfoPtr, bytesread);        /* Increment amount we've written */
734         tsize += bytesWritten;
735
736         /* Display a status line every statusSize or at end of volume */
737         if (statusSize && ((tsize >= statuscount) || endofvolume)) {
738             time_t t = time(0);
739             struct tm tm;
740             localtime_r(&t, &tm);
741             printf("%02d:%02d:%02d: Task %u: %u KB: %s: %u B\n", tm.tm_hour,
742                    tm.tm_min, tm.tm_sec, taskId, tapeInfoPtr->kBytes,
743                    hostVolumeHeader.volumeName, tsize);
744             statuscount = tsize + statusSize;
745         }
746     }                           /*w */
747
748     /* End the XBSA transaction before recording it in BUDB as successfully dumped */
749     rc = xbsa_WriteObjectEnd(&butxInfo);
750     indump = 0;
751     if (rc != XBSA_SUCCESS) {
752         ErrorLog(1, taskId, rc, 0,
753                  "Unable to terminate writing of the volume data to the server");
754         ERROR_EXIT(rc);
755     }
756     rc = xbsa_EndTrans(&butxInfo);
757     begindump = 0;
758     tapeInfoPtr->position++;
759     if (rc != XBSA_SUCCESS) {
760         ErrorLog(1, taskId, rc, 0,
761                  "Unable to terminate the current transaction");
762         ERROR_EXIT(rc);
763     }
764
765     /* Record in BUDB the volume fragment as succcessfully dumped */
766     rc = addVolume(0, dparamsPtr->databaseDumpId, dparamsPtr->tapeName,
767                    nodePtr->dumps[dparamsPtr->curVolume].name,
768                    nodePtr->dumps[dparamsPtr->curVolume].vid,
769                    nodePtr->dumps[dparamsPtr->curVolume].cloneDate,
770                    dparamsPtr->curVolStartPos, volBytesRead, 0 /*frag0 */ ,
771                    (BUDB_VOL_FIRSTFRAG | BUDB_VOL_LASTFRAG));
772     if (rc)
773         ABORT_EXIT(rc);
774
775     dparamsPtr->curVolumeStatus = DUMP_SUCCESS;
776
777   error_exit:
778     /* Cleanup after an error occurs part way into a volume dump */
779     if (fromcall) {
780         rc = rx_EndCall(fromcall, 0);
781         if (!code)
782             code = rc;
783     }
784
785     if (fromtid) {
786         afs_int32 rcode;
787         rc = AFSVolEndTrans(fromconn, fromtid, &rcode);
788         if (!code)
789             code = (rc ? rc : rcode);
790     }
791
792     /* If this dump failed, what happens to successive retries
793      * of the volume? How do they get recorded in the XBSA database
794      * (overwritten)? If not, we don't record this in the BUDB database
795      * so it will not be removed when we delete the dump. What to do?
796      * Also if the volume was never recorded in the DB (partial dump).
797      */
798     if (indump) {
799         /* End the Write */
800         rc = xbsa_WriteObjectEnd(&butxInfo);
801         indump = 0;
802         if (rc != XBSA_SUCCESS) {
803             ErrorLog(1, taskId, rc, 0,
804                      "Unable to terminate writing of the volume data to the server");
805         }
806         tapeInfoPtr->position++;
807     }
808
809     if (begindump) {
810         /* End the XBSA Transaction */
811         rc = xbsa_EndTrans(&butxInfo);
812         begindump = 0;
813         if (rc != XBSA_SUCCESS) {
814             ErrorLog(1, taskId, rc, 0,
815                      "Unable to terminate the current transaction");
816         }
817     }
818
819     return (code);
820
821   abort_exit:
822     dparamsPtr->curVolumeStatus = DUMP_FAILED;
823     ERROR_EXIT(code);
824 #endif
825 }
826
827 #ifdef AFS_DEC_ENV
828 #define HOSTADDR(sockaddr) (sockaddr)->sin_addr.S_un.S_addr
829 #else
830 #define HOSTADDR(sockaddr) (sockaddr)->sin_addr.s_addr
831 #endif
832
833 /* dumpPass
834  *      Go through the list of volumes to dump, dumping each one. The action
835  *      taken when a volume dump fails, depends on the passNumber. At minimum,
836  *      the failed volume is remembered.
837  * notes:
838  *      flushSavedEntries - inconsistent treatment for errors. What should
839  *              be done for user aborts?
840  */
841
842 afs_int32
843 dumpPass(struct dumpRock * dparamsPtr, int passNumber)
844 {
845     struct dumpNode *nodePtr = dparamsPtr->node;
846     struct butm_tapeInfo *tapeInfoPtr = dparamsPtr->tapeInfoPtr;
847     afs_int32 taskId = nodePtr->taskID;
848     struct tc_dumpDesc *curDump;
849     int action, e;
850     afs_int32 code = 0, tcode, dvcode;
851     char ch;
852     char retryPrompt();
853     struct vldbentry vldbEntry;
854     struct sockaddr_in server;
855     afs_int32 tapepos;
856
857     TapeLog(2, taskId, 0, 0, "Starting pass %d\n", passNumber);
858
859     /* while there are more volumes to dump */
860     for (dparamsPtr->curVolume = 0; dparamsPtr->curVolume < nodePtr->arraySize; dparamsPtr->curVolume++) {      /*w */
861         curDump = &nodePtr->dumps[dparamsPtr->curVolume];
862         if (curDump->hostAddr == 0)
863             continue;
864
865         /* set name of current volume being dumped */
866         lock_Status();
867         strcpy(nodePtr->statusNodePtr->volumeName, curDump->name);
868         unlock_Status();
869
870         /* Determine location of the volume.
871          * In case the volume moved has moved.
872          */
873         if (passNumber > 1) {   /*pass */
874             tcode =
875                 bc_GetEntryByID(cstruct, curDump->vid, curDump->vtype,
876                                 &vldbEntry);
877             if (tcode) {
878                 ErrorLog(0, taskId, tcode, 0,
879                          "Volume %s (%u) failed - Can't find volume in VLDB\n",
880                          curDump->name, curDump->vid);
881                 curDump->hostAddr = 0;
882                 dparamsPtr->volumesFailed++;
883                 continue;
884             }
885
886             switch (curDump->vtype) {
887             case BACKVOL:
888                 if (!(vldbEntry.flags & BACK_EXISTS)) {
889                     ErrorLog(0, taskId, 0, 0,
890                              "Volume %s (%u) failed - Backup volume no longer exists\n",
891                              curDump->name, curDump->vid);
892                     curDump->hostAddr = 0;
893                     dparamsPtr->volumesFailed++;
894                     continue;
895                 }
896                 /* Fall into RWVOL case */
897
898             case RWVOL:
899                 for (e = 0; e < vldbEntry.nServers; e++) {      /* Find the RW volume */
900                     if (vldbEntry.serverFlags[e] & ITSRWVOL)
901                         break;
902                 }
903                 break;
904
905             case ROVOL:
906                 /* Try to use the server and partition we found the volume on
907                  * Otherwise, use the first RO volume.
908                  */
909                 for (e = 0; e < vldbEntry.nServers; e++) {      /* Find the RO volume */
910                     if ((curDump->hostAddr == vldbEntry.serverNumber[e])
911                         && (curDump->partition ==
912                             vldbEntry.serverPartition[e]))
913                         break;
914                 }
915
916                 if (e >= vldbEntry.nServers) {  /* Didn't find RO volume */
917                     for (e = 0; e < vldbEntry.nServers; e++) {  /* Find the first RO volume */
918                         if (vldbEntry.serverFlags[e] & ITSROVOL)
919                             break;
920                     }
921                 }
922                 break;
923
924             default:
925                 ErrorLog(0, taskId, 0, 0,
926                          "Volume %s (%u) failed - Unknown volume type\n",
927                          curDump->name, curDump->vid);
928                 curDump->hostAddr = 0;
929                 continue;
930                 break;
931             }
932
933             if (e >= vldbEntry.nServers) {
934                 ErrorLog(0, taskId, 0, 0,
935                          "Volume %s (%u) failed - Can't find volume entry in VLDB\n",
936                          curDump->name, curDump->vid);
937                 curDump->hostAddr = 0;
938                 dparamsPtr->volumesFailed++;
939                 continue;
940             }
941
942             /* Remember the server and partition the volume exists on */
943             memset(&server, 0, sizeof(server));
944             server.sin_addr.s_addr = vldbEntry.serverNumber[e];
945             server.sin_port = 0;
946             server.sin_family = AF_INET;
947 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
948             server.sin_len = sizeof(struct sockaddr_in);
949 #endif
950             curDump->hostAddr = HOSTADDR(&server);
951             curDump->partition = vldbEntry.serverPartition[e];
952
953             /* Determine date from which to do an incremental dump
954              */
955             if (nodePtr->parent) {
956                 tcode =
957                     bcdb_FindClone(nodePtr->parent, curDump->name,
958                                    &curDump->date);
959                 if (tcode)
960                     curDump->date = 0;
961             } else {
962                 curDump->date = 0;      /* do a full dump */
963             }
964         }
965         /*pass */
966         if (checkAbortByTaskId(taskId))
967             ERROR_EXIT(TC_ABORTEDBYREQUEST);
968
969         /* Establish connection to volume - UV_ routine expects 
970          * host address in network order 
971          */
972         if (CONF_XBSA) {
973             dvcode = xbsaDumpVolume(curDump, dparamsPtr);
974         } else {
975             dvcode = dumpVolume(curDump, dparamsPtr);
976         }
977         action = dparamsPtr->curVolumeStatus;
978
979         /* Flush volume and tape entries to the database */
980         tcode = flushSavedEntries(action);
981         if (tcode)
982             ERROR_EXIT(tcode);
983
984         switch (action) {
985         case DUMP_SUCCESS:
986             TapeLog(1, taskId, 0, 0, "Volume %s (%u) successfully dumped\n",
987                     curDump->name, curDump->vid);
988             if (dvcode)
989                 ErrorLog(1, taskId, dvcode, 0,
990                          "Warning: Termination processing error on volume %s (%u)\n",
991                          curDump->name, curDump->vid);
992
993             curDump->hostAddr = 0;
994             dparamsPtr->volumesDumped++;
995             break;
996
997         case DUMP_PARTIAL:
998         case DUMP_NOTHING:
999             if (action == DUMP_PARTIAL) {
1000                 ErrorLog(1, taskId, dvcode, 0,
1001                          "Volume %s (%u) failed - partially dumped\n",
1002                          curDump->name, curDump->vid);
1003             } else if (dvcode) {
1004                 ErrorLog(0, taskId, dvcode, 0, "Volume %s (%u) failed\n",
1005                          curDump->name, curDump->vid);
1006             } else {
1007                 ErrorLog(0, taskId, dvcode, 0,
1008                          "Volume %s (%u) not dumped - has not been re-cloned since last dump\n",
1009                          curDump->name, curDump->vid);
1010             }
1011
1012             if (passNumber == maxpass) {
1013                 if (!queryoperator)
1014                     ch = 'o';
1015                 else
1016                     ch = retryPrompt(curDump->name, curDump->vid, taskId);
1017
1018                 switch (ch) {
1019                 case 'r':       /* retry */
1020                     dparamsPtr->curVolume--;    /* redump this volume */
1021                     continue;
1022                     break;
1023                 case 'o':       /* omit */
1024                     ErrorLog(1, taskId, 0, 0, "Volume %s (%u) omitted\n",
1025                              curDump->name, curDump->vid);
1026                     dparamsPtr->volumesFailed++;
1027                     break;
1028                 case 'a':       /* abort */
1029                     TapeLog(1, taskId, 0, 0, "Dump aborted\n");
1030                     ERROR_EXIT(TC_ABORTEDBYREQUEST);
1031                     break;
1032                 default:
1033                     ERROR_EXIT(TC_INTERNALERROR);
1034                     break;
1035                 }
1036             }
1037             break;
1038
1039         case DUMP_RETRY:
1040             TapeLog(1, taskId, dvcode, 0,
1041                     "Volume %s (%u) hit end-of-tape inferred - will retry on next tape\n",
1042                     curDump->name, curDump->vid);
1043
1044             /* Get the next tape */
1045             unmountTape(taskId, tapeInfoPtr);
1046
1047             dparamsPtr->tapeSeq++;
1048             tcode = getDumpTape(dparamsPtr, 1, 0);      /* interactive - no appends */
1049             if (tcode)
1050                 ERROR_EXIT(tcode);
1051
1052             dparamsPtr->curVolume--;    /* redump this volume */
1053             continue;
1054             break;
1055
1056         case DUMP_NORETRYEOT:
1057             ErrorLog(1, taskId, 0, 0,
1058                      "Volume %s (%u) failed - volume larger than tape\n",
1059                      curDump->name, curDump->vid);
1060
1061             /* rewrite the label on the tape - rewind - no need to switch tapes */
1062             tcode = butm_Create(tapeInfoPtr, &dparamsPtr->tapeLabel, 1);
1063             if (tcode) {
1064                 ErrorLog(0, taskId, tcode, tapeInfoPtr->error,
1065                          "Can't relabel tape\n");
1066
1067                 unmountTape(taskId, tapeInfoPtr);
1068                 tcode = getDumpTape(dparamsPtr, 1, 0);  /* interactive - no appends */
1069                 if (tcode)
1070                     ERROR_EXIT(tcode);
1071             } else {            /* Record the tape in database */
1072                 tapepos = tapeInfoPtr->position;
1073                 tcode =
1074                     useTape(&dparamsPtr->tape, dparamsPtr->databaseDumpId,
1075                             dparamsPtr->tapeName,
1076                             (dparamsPtr->tapeSeq + dparamsPtr->dump.tapes.b),
1077                             dparamsPtr->tapeLabel.useCount,
1078                             dparamsPtr->tapeLabel.creationTime,
1079                             dparamsPtr->tapeLabel.expirationDate, tapepos);
1080             }
1081
1082             curDump->hostAddr = 0;
1083             dparamsPtr->volumesFailed++;
1084             break;
1085
1086         case DUMP_NODUMP:
1087             TapeLog(1, taskId, dvcode, 0,
1088                     "Volume %s (%u) not dumped - has not been modified since last dump\n",
1089                     curDump->name, curDump->vid);
1090
1091             curDump->hostAddr = 0;
1092             dparamsPtr->volumesNotDumped++;
1093             break;
1094
1095         default:
1096             ErrorLog(1, taskId, dvcode, 0, "Volume %s (%u) failed\n",
1097                      curDump->name, curDump->vid);
1098             ERROR_EXIT(dvcode);
1099             break;
1100         }
1101     }                           /*w */
1102
1103   error_exit:
1104     /* check if we terminated while processing a volume */
1105     if (dparamsPtr->curVolume < nodePtr->arraySize) {
1106         TapeLog(2, taskId, 0, 0,
1107                 "Terminated while processing Volume %s (%u)\n", curDump->name,
1108                 curDump->vid);
1109     }
1110
1111     /* print a summary of this pass */
1112     TapeLog(2, taskId, 0, 0, "End of pass %d: Volumes remaining = %d\n",
1113             passNumber,
1114             nodePtr->arraySize - (dparamsPtr->volumesDumped +
1115                                   dparamsPtr->volumesFailed +
1116                                   dparamsPtr->volumesNotDumped));
1117     return (code);
1118 }
1119
1120 int
1121 Dumper(struct dumpNode *nodePtr)
1122 {
1123     struct dumpRock dparams;
1124     struct butm_tapeInfo tapeInfo;
1125     int pass;
1126     int action;
1127     afs_int32 taskId;
1128     afs_int32 code = 0;
1129
1130     /* for volume setup */
1131     int i;
1132     int failedvolumes = 0;
1133     int dumpedvolumes = 0;
1134     int nodumpvolumes = 0;
1135     char strlevel[5];
1136     char msg[20];
1137     char finishedMsg1[50];
1138     char finishedMsg2[50];
1139     time_t startTime = 0;
1140     time_t endTime = 0;
1141     afs_int32 allocbufferSize;
1142
1143     extern struct deviceSyncNode *deviceLatch;
1144     extern struct tapeConfig globalTapeConfig;
1145     extern afs_int32 createDump();
1146
1147     taskId = nodePtr->taskID;   /* Get task Id */
1148     setStatus(taskId, DRIVE_WAIT);
1149     EnterDeviceQueue(deviceLatch);
1150     clearStatus(taskId, DRIVE_WAIT);
1151
1152     printf("\n\n");
1153     TapeLog(2, taskId, 0, 0, "Dump %s\n", nodePtr->dumpSetName);
1154
1155     /* setup the dump parameters */
1156     memset(&dparams, 0, sizeof(dparams));
1157     dparams.node = nodePtr;
1158     dparams.tapeInfoPtr = &tapeInfo;
1159     dlqInit(&savedEntries);
1160
1161     if (!CONF_XBSA) {
1162         /* Instantiate the tape module */
1163         tapeInfo.structVersion = BUTM_MAJORVERSION;
1164         code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
1165         if (code) {
1166             ErrorLog(0, taskId, code, tapeInfo.error,
1167                      "Can't initialize the tape module\n");
1168             ERROR_EXIT(code);
1169         }
1170     }
1171
1172     /* check if abort requested while waiting on device latch */
1173     if (checkAbortByTaskId(taskId))
1174         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1175
1176     /* Are there volumes to dump */
1177     if (nodePtr->arraySize == 0) {
1178         TLog(taskId, "Dump (%s), no volumes to dump\n", nodePtr->dumpSetName);
1179         ERROR_EXIT(0);
1180     }
1181
1182     /* Allocate a buffer for the dumps. Leave room for header and vol-trailer.
1183      * dataSize is amount of data to read in each rx_Read() call.
1184      */
1185     if (CONF_XBSA) {
1186         /* XBSA dumps have not header */
1187         dataSize = BufferSize;
1188         allocbufferSize = dataSize + sizeof(struct volumeHeader);
1189     } else {
1190         tapeblocks = BufferSize / BUTM_BLOCKSIZE;       /* # of 16K tapeblocks */
1191         dataSize = (tapeblocks * BUTM_BLKSIZE);
1192         allocbufferSize =
1193             BUTM_HDRSIZE + dataSize + sizeof(struct volumeHeader);
1194     }
1195     bufferBlock = NULL;
1196     bufferBlock = malloc(allocbufferSize);
1197     if (!bufferBlock) {
1198         ErrorLog(0, taskId, TC_NOMEMORY, 0,
1199                  "Can't allocate BUFFERSIZE for dumps\n");
1200         ERROR_EXIT(TC_NOMEMORY);
1201     }
1202
1203     /* Determine the dumpid of the most recent dump of this volumeset and dumplevel
1204      * Used when requesting a tape. Done now because once we create the dump, the
1205      * routine will then find the newly created dump.
1206      */
1207     sprintf(strlevel, "%d", nodePtr->level);
1208     code =
1209         bcdb_FindLatestDump(nodePtr->volumeSetName, strlevel,
1210                             &dparams.lastDump);
1211     if (code) {
1212         if (code != BUDB_NODUMPNAME) {
1213             ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
1214             ERROR_EXIT(code);
1215         }
1216         memset(&dparams.lastDump, 0, sizeof(dparams.lastDump));
1217     }
1218
1219     code = createDump(&dparams);        /* enter dump into database */
1220     if (code) {
1221         ErrorLog(0, taskId, code, 0, "Can't create dump in database\n");
1222         ERROR_EXIT(code);
1223     }
1224
1225     TLog(taskId, "Dump %s (DumpID %u)\n", nodePtr->dumpSetName,
1226          dparams.databaseDumpId);
1227
1228     if (!CONF_XBSA) {
1229         /* mount the tape and write its label */
1230         code = getDumpTape(&dparams, autoQuery, nodePtr->doAppend);
1231     } else {
1232         /* Create a dummy tape to satisfy backup databae */
1233         code = getXBSATape(&dparams);
1234         tapeInfo.position = 1;
1235     }
1236     if (code) {
1237         /* If didn't write the label, remove dump from the database */
1238         if (!dparams.wroteLabel) {
1239             i = bcdb_deleteDump(dparams.databaseDumpId, 0, 0, 0);
1240             if (i && (i != BUDB_NOENT))
1241                 ErrorLog(1, taskId, i, 0,
1242                          "Warning: Can't delete dump %u from database\n",
1243                          dparams.databaseDumpId);
1244             else
1245                 dparams.databaseDumpId = 0;
1246         }
1247         ERROR_EXIT(code);       /* exit with code from getTape */
1248     }
1249
1250     startTime = time(0);
1251     for (pass = 1; pass <= maxpass; pass++) {
1252         lastPass = (pass == maxpass);
1253         code = dumpPass(&dparams, pass);
1254         if (code)
1255             ERROR_EXIT(code);
1256
1257         /* if no failed volumes, we're done */
1258         if ((dparams.volumesDumped + dparams.volumesFailed +
1259              dparams.volumesNotDumped) == nodePtr->arraySize)
1260             break;
1261     }
1262
1263     /* 
1264      * Log the error but ignore it since the dump is effectively done.
1265      * Scantape may assume another volume and ask for next tape.
1266      */
1267     if (!CONF_XBSA) {
1268         code = butm_WriteEOT(&tapeInfo);
1269         if (code)
1270             TapeLog(taskId, code, tapeInfo.error,
1271                     "Warning: Can't write end-of-dump on tape\n");
1272     }
1273
1274     code =
1275         finishTape(&dparams.tape,
1276                    dparams.tapeInfoPtr->kBytes +
1277                    (dparams.tapeInfoPtr->nBytes ? 1 : 0));
1278     if (code)
1279         ERROR_EXIT(code);
1280
1281     code = finishDump(&dparams.dump);
1282     if (code)
1283         ERROR_EXIT(code);
1284
1285     action = dparams.curVolumeStatus;
1286     code = flushSavedEntries(action);
1287     if (code)
1288         ERROR_EXIT(code);
1289
1290   error_exit:
1291     endTime = time(0);
1292     Bind(0);
1293     if (bufferBlock)
1294         free(bufferBlock);
1295
1296     if (!CONF_XBSA) {
1297         unmountTape(taskId, &tapeInfo);
1298     }
1299     waitDbWatcher();
1300
1301     dumpedvolumes = dparams.volumesDumped;
1302     nodumpvolumes = dparams.volumesNotDumped;
1303     failedvolumes = nodePtr->arraySize - (dumpedvolumes + nodumpvolumes);
1304
1305     /* pass back the number of volumes we failed to dump */
1306     lock_Status();
1307     nodePtr->statusNodePtr->volsFailed = failedvolumes;
1308     unlock_Status();
1309
1310     lastPass = 1;               /* In case we aborted */
1311
1312     DUMPNAME(finishedMsg1, nodePtr->dumpSetName, dparams.databaseDumpId);
1313     sprintf(finishedMsg2, "%d volumes dumped", dumpedvolumes);
1314     if (failedvolumes) {
1315         sprintf(msg, ", %d failed", failedvolumes);
1316         strcat(finishedMsg2, msg);
1317     }
1318     if (nodumpvolumes) {
1319         sprintf(msg, ", %d unchanged", nodumpvolumes);
1320         strcat(finishedMsg2, msg);
1321     }
1322
1323     if (code == TC_ABORTEDBYREQUEST) {
1324         ErrorLog(0, taskId, 0, 0, "%s: Aborted by request. %s\n",
1325                  finishedMsg1, finishedMsg2);
1326         clearStatus(taskId, ABORT_REQUEST);
1327         setStatus(taskId, ABORT_DONE);
1328     } else if (code) {
1329         ErrorLog(0, taskId, code, 0, "%s: Finished with errors. %s\n",
1330                  finishedMsg1, finishedMsg2);
1331         setStatus(taskId, TASK_ERROR);
1332     } else {
1333         TLog(taskId, "%s: Finished. %s\n", finishedMsg1, finishedMsg2);
1334     }
1335     lastPass = 0;
1336
1337     /* Record how long the dump took */
1338     if (centralLogIO && startTime) {
1339         long timediff;
1340         afs_int32 hrs, min, sec, tmp;
1341         char line[1024];
1342         struct tm tmstart, tmend;
1343
1344         localtime_r(&startTime, &tmstart);
1345         localtime_r(&endTime, &tmend);
1346         timediff = (int)endTime - (int)startTime;
1347         hrs = timediff / 3600;
1348         tmp = timediff % 3600;
1349         min = tmp / 60;
1350         sec = tmp % 60;
1351
1352         sprintf(line,
1353                 "%-5d  %02d/%02d/%04d %02d:%02d:%02d  "
1354                 "%02d/%02d/%04d %02d:%02d:%02d  " "%02d:%02d:%02d  "
1355                 "%s %d of %d volumes dumped (%ld KB)\n", taskId,
1356                 tmstart.tm_mon + 1, tmstart.tm_mday, tmstart.tm_year + 1900,
1357                 tmstart.tm_hour, tmstart.tm_min, tmstart.tm_sec,
1358                 tmend.tm_mon + 1, tmend.tm_mday, tmend.tm_year + 1900,
1359                 tmend.tm_hour, tmend.tm_min, tmend.tm_sec, hrs, min, sec,
1360                 nodePtr->volumeSetName, dumpedvolumes,
1361                 dumpedvolumes + failedvolumes,
1362                 dparams.tapeInfoPtr->kBytes + 1);
1363
1364         fwrite(line, strlen(line), 1, centralLogIO);
1365         fflush(centralLogIO);
1366     }
1367
1368     setStatus(taskId, TASK_DONE);
1369
1370     FreeNode(taskId);           /* free the dump node */
1371     LeaveDeviceQueue(deviceLatch);
1372     return (code);
1373 }
1374
1375 #define BELLTIME 60             /* 60 seconds before a bell rings */
1376 #define BELLCHAR 7              /* ascii for bell */
1377
1378 /* retryPrompt
1379  *      prompt the user to decide how to handle a failed volume dump. The
1380  *      volume parameters describe the volume that failed
1381  * entry:
1382  *      volumeName - name of volume
1383  *      volumeId - volume id 
1384  *      taskId - for job contrl
1385  * fn return:
1386  *      character typed by user, one of r, o or a
1387  */
1388
1389 char
1390 retryPrompt(char *volumeName, afs_int32 volumeId, afs_uint32 taskId)
1391 {
1392     afs_int32 start;
1393     char ch;
1394     afs_int32 code = 0;
1395
1396     setStatus(taskId, OPR_WAIT);
1397     printf("\nDump of volume %s (%u) failed\n\n", volumeName, volumeId);
1398
1399     printf("Please select action to be taken for this volume\n");
1400
1401   again:
1402     printf("r - retry, try dumping this volume again\n");
1403     printf("o - omit,  this volume from this dump\n");
1404     printf("a - abort, the entire dump\n");
1405
1406     while (1) {
1407         FFlushInput(stdin);
1408         putchar(BELLCHAR);
1409         fflush(stdout);
1410
1411         start = time(0);
1412         while (1) {
1413 #ifdef AFS_PTHREAD_ENV
1414             code = GetResponseKey(5, &ch);      /* ch stores key pressed */
1415 #else
1416             code = LWP_GetResponseKey(5, &ch);  /* ch stores key pressed */
1417 #endif
1418             if (code == 1)
1419                 break;          /* input is available */
1420
1421             if (checkAbortByTaskId(taskId)) {
1422                 clearStatus(taskId, OPR_WAIT);
1423                 printf
1424                     ("This tape operation has been aborted by the coordinator\n");
1425                 return 'a';
1426             }
1427
1428             if (time(0) > start + BELLTIME)
1429                 break;
1430         }
1431         /* otherwise, we should beep again, check for abort and go back,
1432          * since the GetResponseKey() timed out.
1433          */
1434         if (code == 1)
1435             break;              /* input is available */
1436     }
1437     clearStatus(taskId, OPR_WAIT);
1438     if (ch != 'r' && ch != 'o' && ch != 'a') {
1439         printf("Please select one of the 3 options, r, o or a\n");
1440         goto again;
1441     }
1442
1443     return ch;
1444 }
1445
1446 /* For testing: it prints the tape label */
1447 int
1448 printTapeLabel(struct butm_tapeLabel *tl)
1449 {
1450     printf("Tape Label\n");
1451     printf("   structVersion  = %d\n", tl->structVersion);
1452     printf("   creationTime   = %u\n", tl->creationTime);
1453     printf("   expirationDate = %u\n", tl->expirationDate);
1454     printf("   AFSName        = %s\n", tl->AFSName);
1455     printf("   cell           = %s\n", tl->cell);
1456     printf("   dumpid         = %d\n", tl->dumpid);
1457     printf("   useCount       = %d\n", tl->useCount);
1458     printf("   comment        = %s\n", tl->comment);
1459     printf("   pName          = %s\n", tl->pName);
1460     printf("   size           = %u\n", tl->size);
1461     printf("   dumpPath       = %s\n", tl->dumpPath);
1462 }
1463
1464 /* getXBSATape
1465  *      Create a tape structure to be satisfy the backup database
1466  *      even though we don't really use a tape with XBSA.
1467  */
1468 int
1469 getXBSATape(struct dumpRock *dparamsPtr)
1470 {
1471     struct dumpNode *nodePtr = dparamsPtr->node;
1472     struct butm_tapeInfo *tapeInfoPtr = dparamsPtr->tapeInfoPtr;
1473     struct butm_tapeLabel *tapeLabelPtr = &dparamsPtr->tapeLabel;
1474     afs_int32 code = 0;
1475
1476     tc_MakeTapeName(dparamsPtr->tapeName, &nodePtr->tapeSetDesc,
1477                     dparamsPtr->tapeSeq);
1478
1479     GetNewLabel(tapeInfoPtr, "" /*pName */ , dparamsPtr->tapeName,
1480                 tapeLabelPtr);
1481     strcpy(tapeLabelPtr->dumpPath, nodePtr->dumpName);
1482     tapeLabelPtr->dumpid = dparamsPtr->databaseDumpId;
1483     tapeLabelPtr->expirationDate =
1484         calcExpirationDate(nodePtr->tapeSetDesc.expType,
1485                            nodePtr->tapeSetDesc.expDate, time(0));
1486
1487     /* printTapeLabel(tapeLabelPtr); For testing */
1488
1489     code =
1490         useTape(&dparamsPtr->tape, dparamsPtr->databaseDumpId,
1491                 dparamsPtr->tapeName,
1492                 (dparamsPtr->tapeSeq + dparamsPtr->dump.tapes.b),
1493                 tapeLabelPtr->useCount, tapeLabelPtr->creationTime,
1494                 tapeLabelPtr->expirationDate, 0 /*tape position */ );
1495     return (code);
1496 }
1497
1498 /* getDumpTape
1499  *      iterate until the desired tape (as specified by the dump structures)
1500  *      is mounted.
1501  * entry:
1502  *      interactiveFlag
1503  *              0 - assume the tape is there. Prompt if assumption false
1504  *              1 - prompt regardless
1505  */
1506
1507 int
1508 getDumpTape(struct dumpRock *dparamsPtr, int interactiveFlag,
1509             afs_int32 append)
1510 {
1511     struct dumpNode *nodePtr = dparamsPtr->node;
1512     struct butm_tapeInfo *tapeInfoPtr = dparamsPtr->tapeInfoPtr;
1513     struct butm_tapeLabel *newTapeLabelPtr = &dparamsPtr->tapeLabel;
1514     char AFSTapeName[TC_MAXTAPENAMELEN];
1515     afs_int32 taskId = nodePtr->taskID;
1516     struct butm_tapeLabel oldTapeLabel;
1517     struct budb_dumpEntry dumpEntry;
1518     struct budb_tapeEntry tapeEntry;
1519     struct budb_volumeEntry volEntry;
1520     Date expir;
1521     afs_int32 doAppend;
1522     afs_int32 code = 0;
1523     int askForTape;
1524     int tapecount = 1;
1525     char strlevel[5];
1526     afs_int32 tapepos, lastpos;
1527
1528     extern struct tapeConfig globalTapeConfig;
1529     extern struct udbHandleS udbHandle;
1530
1531     askForTape = interactiveFlag;
1532     dparamsPtr->wroteLabel = 0;
1533
1534     /* Keep prompting for a tape until we get it right */
1535     while (1) {
1536         /* What the name of the tape would be if not appending to it */
1537         tc_MakeTapeName(AFSTapeName, &nodePtr->tapeSetDesc,
1538                         dparamsPtr->tapeSeq);
1539
1540         doAppend = append;
1541
1542         if (askForTape) {
1543             code =
1544                 PromptForTape((doAppend ? APPENDOPCODE : WRITEOPCODE),
1545                               AFSTapeName, dparamsPtr->databaseDumpId, taskId,
1546                               tapecount);
1547             if (code)
1548                 ERROR_EXIT(code);
1549         }
1550         askForTape = 1;
1551         tapecount++;
1552
1553         /* open the tape device */
1554         code = butm_Mount(tapeInfoPtr, AFSTapeName);
1555         if (code) {
1556             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
1557             goto getNewTape;
1558         }
1559
1560         /* Read the tape label */
1561         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* rewind */
1562         if (code) {
1563             if (tapeInfoPtr->error) {
1564                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
1565                          "Warning: Tape error while reading label (will proceed with dump)\n");
1566             }
1567             memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
1568         }
1569
1570         /* Check if null tape. Prior 3.3, backup tapes have no dump id */
1571         if ((strcmp(oldTapeLabel.AFSName, "") == 0)
1572             && (oldTapeLabel.dumpid == 0)) {
1573             if (doAppend) {
1574                 TLog(taskId,
1575                      "Dump not found on tape. Proceeding with initial dump\n");
1576                 doAppend = 0;
1577             }
1578         } else if (doAppend) {  /* appending */
1579             /* Check that we don't have a database dump tape */
1580             if (databaseTape(oldTapeLabel.AFSName)) {
1581                 char gotName[BU_MAXTAPELEN + 32];
1582
1583                 /* label does not match */
1584                 LABELNAME(gotName, &oldTapeLabel);
1585                 TLog(taskId, "Can't append to database tape %s\n", gotName);
1586                 goto getNewTape;
1587             }
1588
1589             /* Verify that the tape is of version 4 (AFS 3.3) or greater */
1590             if (oldTapeLabel.structVersion < TAPE_VERSION_4) {
1591                 TLog(taskId,
1592                      "Can't append: requires tape version %d or greater\n",
1593                      TAPE_VERSION_4);
1594                 goto getNewTape;
1595             }
1596
1597             /* Verify that the last tape of the dump set is in the drive.
1598              * volEntry will be zeroed if last dump has no volume entries.
1599              */
1600             code =
1601                 bcdb_FindLastTape(oldTapeLabel.dumpid, &dumpEntry, &tapeEntry,
1602                                   &volEntry);
1603             if (code) {
1604                 ErrorLog(0, taskId, code, 0,
1605                          "Can't append: Can't find last volume of dumpId %u in database\n",
1606                          oldTapeLabel.dumpid);
1607                 printf("Please scan the dump in or choose another tape\n");
1608                 goto getNewTape;
1609             }
1610             lastpos =
1611                 (volEntry.position ? volEntry.position : tapeEntry.labelpos);
1612
1613             if (strcmp(TNAME(&oldTapeLabel), tapeEntry.name)) {
1614                 char expName[BU_MAXTAPELEN + 32], gotName[BU_MAXTAPELEN + 32];
1615
1616                 TAPENAME(expName, tapeEntry.name, oldTapeLabel.dumpid);
1617                 LABELNAME(gotName, &oldTapeLabel);
1618
1619                 TLog(taskId,
1620                      "Can't append: Last tape in dump-set is %s, label seen %s\n",
1621                      expName, gotName);
1622                 goto getNewTape;
1623             }
1624
1625             /* After reading the tape label, we now know what it is */
1626             strcpy(AFSTapeName, oldTapeLabel.AFSName);  /* the real name */
1627             strcpy(tapeInfoPtr->name, oldTapeLabel.AFSName);    /* the real name */
1628
1629             /* Position after last volume on the tape */
1630             code = butm_SeekEODump(tapeInfoPtr, lastpos);
1631             if (code) {
1632                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
1633                          "Can't append: Can't position to end of dump on tape %s\n",
1634                          tapeEntry.name);
1635                 goto getNewTape;
1636             }
1637
1638             /* Track size of tape - set after seek since seek changes the value */
1639             tapeInfoPtr->kBytes = tapeEntry.useKBytes;
1640         } else {                /* not appending */
1641
1642             afs_uint32 tapeid;
1643             afs_uint32 dmp;
1644             struct budb_dumpEntry de, de2;
1645
1646             /* Check if tape name is not what expected - null tapes are acceptable
1647              * Don't do check if the tape has a user defined label.
1648              */
1649             if (dump_namecheck && (strcmp(oldTapeLabel.pName, "") == 0)) {
1650                 if (strcmp(oldTapeLabel.AFSName, "") && /* not null tape */
1651                     strcmp(oldTapeLabel.AFSName, AFSTapeName)) {        /* not expected name */
1652                     TLog(taskId, "Tape label expected %s, label seen %s\n",
1653                          AFSTapeName, oldTapeLabel.AFSName);
1654                     goto getNewTape;
1655                 }
1656
1657                 /* Check that we don't have a database dump tape */
1658                 if (databaseTape(oldTapeLabel.AFSName)) {
1659                     /* label does not match */
1660                     TLog(taskId,
1661                          "Tape label expected %s, can't dump to database tape %s\n",
1662                          AFSTapeName, oldTapeLabel.AFSName);
1663                     goto getNewTape;
1664                 }
1665             }
1666
1667             /* Verify the tape has not expired - only check if not appending */
1668             if (!tapeExpired(&oldTapeLabel)) {
1669                 TLog(taskId, "This tape has not expired\n");
1670                 goto getNewTape;
1671             }
1672
1673             /* Given a tape dump with good data, verify we don't overwrite recent dumps
1674              * and also verify that the volume will be restorable - if not print warnings
1675              */
1676             if (oldTapeLabel.dumpid) {
1677                 /* Do not overwrite a tape that belongs to the dump's dumpset */
1678                 tapeid =
1679                     (dparamsPtr->initialDumpId ? dparamsPtr->
1680                      initialDumpId : dparamsPtr->databaseDumpId);
1681                 if (oldTapeLabel.dumpid == tapeid) {
1682                     ErrorLog(0, taskId, 0, 0,
1683                              "Can't overwrite tape containing the dump in progress\n");
1684                     goto getNewTape;
1685                 }
1686
1687                 /* Since the dumpset on this tape will be deleted from database, check if
1688                  * any of the dump's parent-dumps are on this tape.
1689                  */
1690                 for (dmp = nodePtr->parent; dmp; dmp = de.parent) {
1691                     code = bcdb_FindDumpByID(dmp, &de);
1692                     if (code) {
1693                         ErrorLog(0, taskId, 0, 0,
1694                                  "Warning: Can't find parent dump %u in backup database\n",
1695                                  dmp);
1696                         break;
1697                     }
1698
1699                     tapeid = (de.initialDumpID ? de.initialDumpID : de.id);
1700                     if (oldTapeLabel.dumpid == tapeid) {
1701                         ErrorLog(0, taskId, 0, 0,
1702                                  "Can't overwrite the parent dump %s (DumpID %u)\n",
1703                                  de.name, de.id);
1704                         goto getNewTape;
1705                     }
1706                 }
1707
1708                 /* Since the dumpset on this tape will be deleted from database, check if
1709                  * any of the dumps in this dumpset are most-recent-dumps.
1710                  */
1711                 for (dmp = oldTapeLabel.dumpid; dmp; dmp = de.appendedDumpID) {
1712                     if (dmp == dparamsPtr->lastDump.id) {
1713                         memcpy(&de, &dparamsPtr->lastDump, sizeof(de));
1714                         memcpy(&de2, &dparamsPtr->lastDump, sizeof(de2));
1715                     } else {
1716                         code = bcdb_FindDumpByID(dmp, &de);
1717                         if (code)
1718                             break;
1719                         sprintf(strlevel, "%d", de.level);
1720                         code =
1721                             bcdb_FindLatestDump(de.volumeSetName, strlevel,
1722                                                 &de2);
1723                         if (code)
1724                             continue;
1725                     }
1726
1727                     /* If dump on the tape is the latest dump at this level */
1728                     if (de.id == de2.id) {
1729                         if (strcmp(DUMP_TAPE_NAME, de2.name) == 0) {
1730                             ErrorLog(0, taskId, 0, 0,
1731                                      "Warning: Overwriting most recent dump %s (DumpID %u)\n",
1732                                      de.name, de.id);
1733                         } else {
1734                             ErrorLog(0, taskId, 0, 0,
1735                                      "Warning: Overwriting most recent dump of the '%s' volumeset: %s (DumpID %u)\n",
1736                                      de.volumeSetName, de.name, de.id);
1737                         }
1738                     }
1739                 }
1740             }                   /* if (oldTapeLabel.dumpid) */
1741         }                       /* else not appending */
1742
1743         /*
1744          * Now have the right tape. Create a new label for the tape
1745          * Appended labels have the dump's dumpId - labels at beginnings of 
1746          *     tape have the initial dump's dumpId.
1747          * Appended labels do not increment the useCount.
1748          * Labels at beginnings of tape use the most future expiration of the dump set.
1749          */
1750         GetNewLabel(tapeInfoPtr, oldTapeLabel.pName, AFSTapeName,
1751                     newTapeLabelPtr);
1752         strcpy(newTapeLabelPtr->dumpPath, nodePtr->dumpName);
1753         newTapeLabelPtr->expirationDate =
1754             calcExpirationDate(nodePtr->tapeSetDesc.expType,
1755                                nodePtr->tapeSetDesc.expDate, time(0));
1756         newTapeLabelPtr->dumpid = dparamsPtr->databaseDumpId;
1757         newTapeLabelPtr->useCount = oldTapeLabel.useCount;
1758
1759         if (!doAppend) {
1760             newTapeLabelPtr->useCount++;
1761             if (dparamsPtr->initialDumpId) {
1762                 newTapeLabelPtr->dumpid = dparamsPtr->initialDumpId;
1763                 expir = ExpirationDate(dparamsPtr->initialDumpId);
1764                 if (expir > newTapeLabelPtr->expirationDate)
1765                     newTapeLabelPtr->expirationDate = expir;
1766             }
1767         }
1768
1769         /* write the label on the tape - rewind if not appending and vice-versa */
1770         code = butm_Create(tapeInfoPtr, newTapeLabelPtr, !doAppend);
1771         if (code) {
1772             char gotName[BU_MAXTAPELEN + 32];
1773
1774             LABELNAME(gotName, newTapeLabelPtr);
1775             TapeLog(0, taskId, code, tapeInfoPtr->error,
1776                     "Can't label tape as %s\n", gotName);
1777             goto getNewTape;
1778         }
1779         dparamsPtr->wroteLabel = 1;     /* Remember we wrote the label */
1780         tapepos = tapeInfoPtr->position - 1;
1781
1782         strcpy(dparamsPtr->tapeName, TNAME(newTapeLabelPtr));
1783
1784         /* If appending, set dumpentry in the database as appended. */
1785         if (doAppend) {
1786             char gotName[BU_MAXTAPELEN + 32];
1787
1788             nodePtr->tapeSetDesc.b = extractTapeSeq(AFSTapeName);
1789             dparamsPtr->dump.tapes.b = nodePtr->tapeSetDesc.b;
1790             dparamsPtr->initialDumpId = oldTapeLabel.dumpid;
1791             strcpy(nodePtr->tapeSetDesc.format, dumpEntry.tapes.format);
1792
1793             code =
1794                 bcdb_MakeDumpAppended(dparamsPtr->databaseDumpId,
1795                                       dparamsPtr->initialDumpId,
1796                                       nodePtr->tapeSetDesc.b);
1797             if (code)
1798                 ErrorLog(2, taskId, code, 0,
1799                          "Warning: Can't append dump %u to dump %u in database\n",
1800                          dparamsPtr->databaseDumpId,
1801                          dparamsPtr->initialDumpId);
1802
1803             LABELNAME(gotName, &oldTapeLabel);
1804             TLog(taskId, "Appending dump %s (DumpID %u) to tape %s\n",
1805                  nodePtr->dumpSetName, dparamsPtr->databaseDumpId, gotName);
1806         }
1807
1808         /* If not appending, delete overwritten dump from the database */
1809         else {
1810             if ((oldTapeLabel.structVersion >= TAPE_VERSION_3)
1811                 && oldTapeLabel.dumpid) {
1812                 code = bcdb_deleteDump(oldTapeLabel.dumpid, 0, 0, 0);
1813                 if (code && (code != BUDB_NOENT))
1814                     ErrorLog(0, taskId, code, 0,
1815                              "Warning: Can't delete old dump %u from database\n",
1816                              oldTapeLabel.dumpid);
1817             }
1818         }
1819
1820         code =
1821             useTape(&dparamsPtr->tape, dparamsPtr->databaseDumpId,
1822                     dparamsPtr->tapeName,
1823                     (dparamsPtr->tapeSeq + dparamsPtr->dump.tapes.b),
1824                     newTapeLabelPtr->useCount, newTapeLabelPtr->creationTime,
1825                     newTapeLabelPtr->expirationDate, tapepos);
1826
1827         /*
1828          * The margin of space to check for end of tape is set to the
1829          * amount of space used to write an end-of-tape multiplied by 2.
1830          * The amount of space is size of a 16K volume trailer, a 16K File
1831          * End mark, its EOF marker, a 16K EODump marker, its EOF marker,
1832          * and up to two EOF markers done on close (3 16K blocks + 4 EOF
1833          * markers).
1834          */
1835         tc_EndMargin = (3 * 16384 + 4 * globalTapeConfig.fileMarkSize) * 2;
1836         tc_KEndMargin = tc_EndMargin / 1024;
1837         break;
1838
1839       getNewTape:
1840         unmountTape(taskId, tapeInfoPtr);
1841     }
1842
1843   error_exit:
1844     return (code);
1845 }
1846
1847 int
1848 makeVolumeHeader(struct volumeHeader *vhptr, struct dumpRock *dparamsPtr,
1849                  int fragmentNumber)
1850 {
1851     struct dumpNode *nodePtr = dparamsPtr->node;
1852     struct tc_dumpDesc *curDump;
1853     afs_int32 code = 0;
1854
1855     curDump = &nodePtr->dumps[dparamsPtr->curVolume];
1856
1857     memset(vhptr, 0, sizeof(*vhptr));
1858     strcpy(vhptr->volumeName, curDump->name);
1859     vhptr->volumeID = curDump->vid;
1860     vhptr->cloneDate = curDump->cloneDate;
1861     vhptr->server = curDump->hostAddr;
1862     vhptr->part = curDump->partition;
1863     vhptr->from = curDump->date;
1864     vhptr->frag = fragmentNumber;
1865     vhptr->contd = 0;
1866     vhptr->magic = TC_VOLBEGINMAGIC;
1867     vhptr->dumpID = dparamsPtr->databaseDumpId; /* real dump id */
1868     vhptr->level = nodePtr->level;
1869     vhptr->parentID = nodePtr->parent;
1870     vhptr->endTime = 0;
1871     vhptr->versionflags = CUR_TAPE_VERSION;
1872     strcpy(vhptr->dumpSetName, nodePtr->dumpSetName);
1873     strcpy(vhptr->preamble, "H++NAME#");
1874     strcpy(vhptr->postamble, "T--NAME#");
1875   
1876     return (code);
1877 }
1878
1879 int
1880 volumeHeader_hton(struct volumeHeader *hostPtr, struct volumeHeader *netPtr)
1881 {
1882     struct volumeHeader volHdr;
1883
1884     strcpy(volHdr.preamble, hostPtr->preamble);
1885     strcpy(volHdr.postamble, hostPtr->postamble);
1886     strcpy(volHdr.volumeName, hostPtr->volumeName);
1887     strcpy(volHdr.dumpSetName, hostPtr->dumpSetName);
1888     volHdr.volumeID = htonl(hostPtr->volumeID);
1889     volHdr.server = htonl(hostPtr->server);
1890     volHdr.part = htonl(hostPtr->part);
1891     volHdr.from = htonl(hostPtr->from);
1892     volHdr.frag = htonl(hostPtr->frag);
1893     volHdr.magic = htonl(hostPtr->magic);
1894     volHdr.contd = htonl(hostPtr->contd);
1895     volHdr.dumpID = htonl(hostPtr->dumpID);
1896     volHdr.level = htonl(hostPtr->level);
1897     volHdr.parentID = htonl(hostPtr->parentID);
1898     volHdr.endTime = htonl(hostPtr->endTime);
1899     volHdr.versionflags = htonl(hostPtr->versionflags);
1900     volHdr.cloneDate = htonl(hostPtr->cloneDate);
1901
1902     memcpy(netPtr, &volHdr, sizeof(struct volumeHeader));
1903 }
1904
1905 /* database related routines */
1906
1907 afs_int32
1908 createDump(struct dumpRock *dparamsPtr)
1909 {
1910     struct dumpNode *nodePtr = dparamsPtr->node;
1911     struct budb_dumpEntry *dumpPtr;
1912     afs_int32 code = 0;
1913
1914     dumpPtr = &dparamsPtr->dump;
1915     memset(dumpPtr, 0, sizeof(*dumpPtr));
1916
1917     /* id filled in by database */
1918     dumpPtr->parent = nodePtr->parent;
1919     dumpPtr->level = nodePtr->level;
1920     dumpPtr->flags = 0;
1921 #ifdef xbsa
1922     if (CONF_XBSA) {
1923         if (xbsaType == XBSA_SERVER_TYPE_ADSM) {
1924             strcpy(dumpPtr->tapes.tapeServer, butxInfo.serverName);
1925             dumpPtr->flags = BUDB_DUMP_ADSM;
1926         }
1927         if (!(butxInfo.serverType & XBSA_SERVER_FLAG_MULTIPLE)) {
1928             /* The current server (API) doesn't provide the function required
1929              * to specify a server at startup time.  For that reason, we can't
1930              * be sure that the server name supplied by the user in the user-
1931              * defined configuration file is correct.  We set a flag here so
1932              * we know at restore time that the servername info in the backup
1933              * database may be incorrect.  We will not allow a server switch
1934              * at that time, even if the server at restore time supports
1935              * multiple servers.
1936              */
1937             dumpPtr->flags |= BUDB_DUMP_XBSA_NSS;
1938         }
1939     }
1940 #endif
1941     strcpy(dumpPtr->volumeSetName, nodePtr->volumeSetName);
1942     strcpy(dumpPtr->dumpPath, nodePtr->dumpName);
1943     strcpy(dumpPtr->name, nodePtr->dumpSetName);
1944     dumpPtr->created = 0;       /* let database assign it */
1945     dumpPtr->incTime = 0;       /* not really used */
1946     dumpPtr->nVolumes = 0;
1947     dumpPtr->initialDumpID = 0;
1948
1949     dumpPtr->tapes.id = groupId;
1950     dumpPtr->tapes.b = 1;
1951     dumpPtr->tapes.maxTapes = 0;
1952     strcpy(dumpPtr->tapes.format, nodePtr->tapeSetDesc.format);
1953
1954     /* principal filled in by database */
1955
1956     /* now call the database to create the entry */
1957     code = bcdb_CreateDump(dumpPtr);
1958     if (code == 0)
1959         dparamsPtr->databaseDumpId = dumpPtr->id;
1960
1961     return (code);
1962 }
1963
1964 #ifdef xbsa
1965 /* InitToServer:
1966  * Initialize to a specific server. The first time, we remember the
1967  * server as the original server and go back to it each time we pass 0
1968  * as the server.
1969  */
1970 afs_int32
1971 InitToServer(afs_int32 taskId, struct butx_transactionInfo * butxInfoP,
1972              char *server)
1973 {
1974     static char origserver[BSA_MAX_DESC];
1975     static int init = 0;
1976     afs_int32 rc, code = 0;
1977
1978     if (!init) {
1979         strcpy(origserver, "");
1980         init = 1;
1981     }
1982
1983     if (!server)
1984         server = origserver;    /* return to original server */
1985     if (strcmp(server, "") == 0)
1986         return 0;               /* No server, do nothing */
1987     if (strcmp(butxInfoP->serverName, server) == 0)
1988         return 0;               /* same server, do nothing */
1989     if (strcmp(origserver, "") == 0)
1990         strcpy(origserver, server);     /* remember original server */
1991
1992     if (strcmp(butxInfoP->serverName, "") != 0) {
1993         /* If already connected to a server, disconnect from it.
1994          * Check to see if our server does not support switching.
1995          */
1996         if (!(butxInfo.serverType & XBSA_SERVER_FLAG_MULTIPLE)) {
1997             ErrorLog(0, taskId, TC_BADTASK, 0,
1998                      "This version of XBSA libraries does not support switching "
1999                      "from server %s to server %s\n", butxInfoP->serverName,
2000                      server);
2001             return (TC_BADTASK);
2002         }
2003
2004         rc = xbsa_Finalize(&butxInfo);
2005         if (rc != XBSA_SUCCESS) {
2006             ErrorLog(0, taskId, rc, 0,
2007                      "InitToServer: Unable to terminate the connection to server %s\n",
2008                      butxInfoP->serverName);
2009             ERROR_EXIT(rc);
2010         }
2011     }
2012
2013     /* initialize to the new server */
2014     rc = xbsa_Initialize(&butxInfo, xbsaObjectOwner, appObjectOwner,
2015                          xbsaSecToken, server);
2016     if (rc != XBSA_SUCCESS) {
2017         ErrorLog(0, taskId, rc, 0,
2018                  "InitToServer: Unable to initialize the XBSA library to server %s\n",
2019                  server);
2020         ERROR_EXIT(rc);
2021     }
2022
2023   error_exit:
2024     return (code);
2025 }
2026
2027
2028 /* DeleteDump
2029  *
2030  */
2031 int
2032 DeleteDump(struct deleteDumpIf *ptr)
2033 {
2034     afs_int32 taskId;
2035     afs_int32 rc, code = 0;
2036     afs_uint32 dumpid;
2037     afs_int32 index, next, dbTime;
2038     budb_volumeList vl;
2039     struct budb_dumpEntry dumpEntry;
2040     char tapeName[BU_MAXTAPELEN];
2041     char dumpIdStr[XBSA_MAX_OSNAME];
2042     char volumeNameStr[XBSA_MAX_PATHNAME];
2043     afs_int32 i;
2044     int intrans = 0;
2045     int allnotfound = 1, onenotfound = 0;
2046     extern struct udbHandleS udbHandle;
2047     extern struct deviceSyncNode *deviceLatch;
2048
2049     setStatus(taskId, DRIVE_WAIT);
2050     EnterDeviceQueue(deviceLatch);
2051     clearStatus(taskId, DRIVE_WAIT);
2052
2053     dumpid = ptr->dumpID;
2054     taskId = ptr->taskId;       /* Get task Id */
2055
2056     printf("\n\n");
2057     TapeLog(2, taskId, 0, 0, "Delete Dump %u\n", dumpid);
2058
2059     vl.budb_volumeList_len = 0;
2060     vl.budb_volumeList_val = 0;
2061     tapeName[0] = '\0';
2062
2063     /* Get the dump info for the dump we are deleting */
2064     rc = bcdb_FindDumpByID(dumpid, &dumpEntry);
2065     if (rc) {
2066         ErrorLog(0, taskId, rc, 0,
2067                  "Unable to locate dump ID %u in database\n", dumpid);
2068         setStatus(taskId, TASK_ERROR);
2069         ERROR_EXIT(rc);
2070     }
2071
2072     /* we must make sure that we are configured with the correct type of
2073      * XBSA server for this dump delete! Only those dumped to an ADSM server.
2074      */
2075     if ((xbsaType == XBSA_SERVER_TYPE_ADSM)
2076         && !((dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA)))) {
2077         ErrorLog(0, taskId, TC_BADTASK, 0,
2078                  "The dump %u requested for deletion is incompatible with this instance of butc\n",
2079                  dumpid);
2080         setStatus(taskId, TASK_ERROR);
2081         ERROR_EXIT(TC_BADTASK);
2082     }
2083
2084     /* Make sure we are connected to the correct server. If not, switch to it if appropriate */
2085     if ((strlen((char *)dumpEntry.tapes.tapeServer) != 0)
2086         && (strcmp((char *)dumpEntry.tapes.tapeServer, butxInfo.serverName) !=
2087             0)) {
2088
2089         /* Check to see if the tapeServer name is trustworthy */
2090         if ((dumpEntry.flags & (BUDB_DUMP_XBSA_NSS | BUDB_DUMP_BUTA))
2091             && !forcemultiple) {
2092             /* The dump was made with a version of the XBSA interface
2093              * that didn't allow switching of servers, we can't be sure
2094              * that the servername in the backup database is correct.  So,
2095              * we will check the servername and log it if they don't match;
2096              * but we will try to do the delete without switching servers.
2097              */
2098             TLog(taskId,
2099                  "The dump %d requested for deletion is on server %s "
2100                  "but butc is connected to server %s "
2101                  "(Attempting to delete the dump anyway)\n", dumpid,
2102                  (char *)dumpEntry.tapes.tapeServer, butxInfo.serverName);
2103         } else {
2104             TLog(taskId,
2105                  "The dump %u requested for deletion is on server %s "
2106                  "but butc is connected to server %s "
2107                  "(switching servers)\n", dumpid,
2108                  (char *)dumpEntry.tapes.tapeServer, butxInfo.serverName);
2109
2110             rc = InitToServer(taskId, &butxInfo,
2111                               (char *)dumpEntry.tapes.tapeServer);
2112             if (rc != XBSA_SUCCESS) {
2113                 setStatus(taskId, TASK_ERROR);
2114                 ERROR_EXIT(rc);
2115             }
2116         }
2117     }
2118
2119     /* Start a new Transaction */
2120     rc = xbsa_BeginTrans(&butxInfo);
2121     if (rc != XBSA_SUCCESS) {
2122         ErrorLog(0, taskId, rc, 0, "Unable to create a new transaction\n");
2123         setStatus(taskId, TASK_ERROR);
2124         ERROR_EXIT(rc);
2125     }
2126     intrans = 1;
2127
2128     /* Query the backup database for list of volumes to delete */
2129     for (index = next = 0; index != -1; index = next) {
2130         rc = ubik_Call_SingleServer(BUDB_GetVolumes, udbHandle.uh_client,
2131                                     UF_SINGLESERVER, BUDB_MAJORVERSION,
2132                                     BUDB_OP_DUMPID, tapeName, dumpid, 0,
2133                                     index, &next, &dbTime, &vl);
2134         if (rc) {
2135             if (rc == BUDB_ENDOFLIST)
2136                 break;
2137             ErrorLog(0, taskId, rc, 0, "Can't find volume info for dump %d\n",
2138                      dumpid);
2139             setStatus(taskId, TASK_ERROR);
2140             ERROR_EXIT(rc);
2141         }
2142
2143         /* Delete all volumes on the list */
2144         for (i = 0; i < vl.budb_volumeList_len; i++) {
2145             if (dumpEntry.flags & BUDB_DUMP_BUTA) {
2146                 /* dump was from buta, use old buta style names */
2147                 sprintf(dumpIdStr, "/%d", dumpid);
2148                 strcpy(volumeNameStr, "/");
2149                 strcat(volumeNameStr, (char *)vl.budb_volumeList_val[i].name);
2150             } else {            /* BUDB_DUMP_ADSM */
2151                 /* dump was from butc to ADSM, use butc names */
2152                 strcpy(dumpIdStr, butcdumpIdStr);
2153                 sprintf(volumeNameStr, "/%d", dumpid);
2154                 strcat(volumeNameStr, "/");
2155                 strcat(volumeNameStr, (char *)vl.budb_volumeList_val[i].name);
2156             }
2157
2158             rc = xbsa_DeleteObject(&butxInfo, dumpIdStr, volumeNameStr);
2159             if (rc != XBSA_SUCCESS) {
2160                 ErrorLog(0, taskId, rc, 0,
2161                          "Unable to delete the object %s of dump %s from the server\n",
2162                          volumeNameStr, dumpIdStr);
2163                 /* Don't exit if volume was not found */
2164                 if (rc != BUTX_DELETENOVOL) {
2165                     allnotfound = 0;
2166                     ERROR_EXIT(rc);
2167                 }
2168                 onenotfound = 1;
2169             } else {
2170                 allnotfound = 0;
2171                 TLog(0,
2172                      "Deleted volume %s (%u) in dumpID %u from the backup server\n",
2173                      vl.budb_volumeList_val[i].name,
2174                      vl.budb_volumeList_val[i].id, dumpid);
2175             }
2176         }
2177
2178         /* free the memory allocated by RPC for this list */
2179         if (vl.budb_volumeList_val)
2180             free(vl.budb_volumeList_val);
2181         vl.budb_volumeList_len = 0;
2182         vl.budb_volumeList_val = 0;
2183     }
2184
2185   error_exit:
2186     if (intrans) {
2187         rc = xbsa_EndTrans(&butxInfo);
2188         if (rc != XBSA_SUCCESS) {
2189             ErrorLog(0, taskId, rc, 0,
2190                      "Unable to terminate the current transaction\n");
2191             setStatus(taskId, TASK_ERROR);
2192             ERROR_EXIT(rc);
2193         }
2194     }
2195
2196     /* Switch back to the original server */
2197     rc = InitToServer(taskId, &butxInfo, NULL);
2198
2199     if (vl.budb_volumeList_val)
2200         free(vl.budb_volumeList_val);
2201
2202     setStatus(taskId, TASK_DONE);
2203     FreeNode(taskId);           /* free the dump node */
2204     LeaveDeviceQueue(deviceLatch);
2205
2206     /* If we don't find any dumps on the server, rather than returning
2207      * a success, return a failure.
2208      */
2209     if (!code && onenotfound && allnotfound) {
2210         code = BUTX_DELETENOVOL;
2211         setStatus(taskId, TASK_ERROR);
2212     }
2213     return (code);
2214 }
2215 #endif