butc: Catch failures to start keep alive thread
[openafs.git] / src / butc / tcudbprocs.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 #include <afs/procmgmt.h>
14 #include <roken.h>
15
16 #ifdef IGNORE_SOME_GCC_WARNINGS
17 # pragma GCC diagnostic warning "-Wimplicit-function-declaration"
18 #endif
19
20 #include <afs/opr.h>
21 #include <rx/rx.h>
22 #include <afs/afsint.h>
23 #include <afs/prs_fs.h>
24 #include <afs/nfs.h>
25 #include <lwp.h>
26 #include <lock.h>
27 #include <afs/cellconfig.h>
28 #include <afs/keys.h>
29 #include <ubik.h>
30 #include <afs/acl.h>
31 #include <afs/volser.h>
32 #include <afs/vlserver.h>
33 #include <afs/tcdata.h>
34 #include <afs/budb.h>
35 #include <afs/budb_client.h>
36 #include <afs/bubasics.h>
37 #include <afs/bucoord_prototypes.h>
38 #include <afs/butm_prototypes.h>
39 #include <afs/budb_prototypes.h>
40 #include <afs/afsutil.h>
41
42 #include "butc_internal.h"
43 #include "error_macros.h"
44
45 /* GLOBAL CONFIGURATION PARAMETERS */
46 #define BIGCHUNK 102400
47
48 extern int dump_namecheck;
49 extern int autoQuery;
50
51 struct rstTapeInfo {
52     afs_int32 taskId;
53     afs_int32 tapeSeq;
54     afs_uint32 dumpid;
55 };
56
57 static void initTapeBuffering(void);
58 static int writeDbDump(struct butm_tapeInfo *, afs_uint32, Date, afs_uint32);
59 static int restoreDbEntries(struct butm_tapeInfo *, struct rstTapeInfo *);
60
61 int getTapeData(struct butm_tapeInfo *, struct rstTapeInfo *, void *,
62                 afs_int32);
63 int restoreDbHeader(struct butm_tapeInfo *, struct rstTapeInfo *,
64                     struct structDumpHeader *);
65 int restoreDbDump(struct butm_tapeInfo *, struct rstTapeInfo *,
66                   struct structDumpHeader *);
67 int restoreText(struct butm_tapeInfo *, struct rstTapeInfo *,
68                 struct structDumpHeader *);
69
70
71
72 void * KeepAlive(void *);
73 /* CreateDBDump
74  *      create a dump entry for a saved database
75  */
76
77 afs_int32
78 CreateDBDump(struct budb_dumpEntry *dumpEntryPtr)
79 {
80     afs_int32 code = 0;
81
82     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
83
84     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
85     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
86     strcat(dumpEntryPtr->tapes.format, ".%d");
87     strcpy(dumpEntryPtr->volumeSetName, "");
88     strcpy(dumpEntryPtr->dumpPath, "");
89     dumpEntryPtr->created = 0;  /* let database assign it */
90     dumpEntryPtr->incTime = 0;
91     dumpEntryPtr->nVolumes = 0;
92     dumpEntryPtr->initialDumpID = 0;
93     dumpEntryPtr->parent = 0;
94     dumpEntryPtr->level = 0;
95     dumpEntryPtr->tapes.maxTapes = 0;
96     dumpEntryPtr->tapes.b = 1;
97
98     /* now call the database to create the entry */
99     code = bcdb_CreateDump(dumpEntryPtr);
100     return (code);
101 }
102
103 struct tapeEntryList {
104     struct tapeEntryList *next;
105     afs_uint32 oldDumpId;
106     struct budb_tapeEntry tapeEnt;
107 };
108 struct tapeEntryList *listEntryHead;
109 struct tapeEntryList *listEntryPtr;
110 #define tapeEntryPtr (&listEntryPtr->tapeEnt)
111 struct budb_dumpEntry lastDump; /* the last dump of this volset */
112
113 /* GetDBTape
114  *      Load a DB tape, read and over write its label.
115  *      Leave the tape mounted.
116  */
117 afs_int32
118 GetDBTape(afs_int32 taskId, Date expires, struct butm_tapeInfo *tapeInfoPtr,
119           afs_uint32 dumpid, afs_int32 sequence, int queryFlag,
120           int *wroteLabel)
121 {
122     afs_int32 code = 0;
123     int interactiveFlag;
124     char tapeName[BU_MAXTAPELEN];
125     char strlevel[5];
126     struct timeval tp;
127     afs_int32 curTime;
128     int tapecount = 1;
129
130     struct butm_tapeLabel oldTapeLabel, newLabel;
131     struct tapeEntryList *endList;
132
133     /* construct the name of the tape */
134     sprintf(tapeName, "%s.%-d", DUMP_TAPE_NAME, sequence);
135
136     interactiveFlag = queryFlag;
137     *wroteLabel = 0;
138
139     while (!*wroteLabel) {      /*w */
140         if (interactiveFlag) {  /* need a tape to write */
141             code =
142                 PromptForTape(SAVEDBOPCODE, tapeName, dumpid, taskId,
143                               tapecount);
144             if (code)
145                 ERROR_EXIT(code);
146         }
147         interactiveFlag = 1;
148         tapecount++;
149
150         code = butm_Mount(tapeInfoPtr, tapeName);
151         if (code) {
152             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
153             goto getNewTape;
154         }
155
156         memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
157         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* rewind tape */
158         if (code) {
159             oldTapeLabel.useCount = 0;  /* no label exists */
160             oldTapeLabel.structVersion = 0;
161             strcpy(oldTapeLabel.pName, "");
162         } else {
163             /* If tape has a name, it must be null or database tape name */
164             if (dump_namecheck && strcmp(oldTapeLabel.AFSName, "")
165                 && !databaseTape(oldTapeLabel.AFSName)) {
166                 char gotName[BU_MAXTAPELEN + 32];
167
168                 LABELNAME(gotName, &oldTapeLabel);
169                 TLog(taskId,
170                      "This tape %s must be a database tape or NULL tape\n",
171                      gotName);
172
173               getNewTape:
174                 unmountTape(taskId, tapeInfoPtr);
175                 continue;
176             }
177
178             /* Do not overwrite a tape that belongs to this dump */
179             if (oldTapeLabel.dumpid && (oldTapeLabel.dumpid == dumpid)) {
180                 ErrorLog(0, taskId, 0, 0,
181                          "Can't overwrite tape containing the dump in progress\n");
182                 goto getNewTape;
183             }
184
185             /* On first tape, the savedb has not started yet, so the database is not locked
186              * and we can therefore, access information from it. This is easier to do because
187              * database dumps don't have appended dumps (nor appended).
188              */
189             if (sequence == 1) {
190                 afs_uint32 dmp;
191                 struct budb_dumpEntry de, de2;
192
193                 /* Verify the tape has not expired
194                  * Early database dumps don't have a dumpid
195                  */
196                 if (!tapeExpired(&oldTapeLabel)) {
197                     TLog(taskId, "This tape has not expired\n");
198                     goto getNewTape;
199                 }
200
201                 /* Since the dumpset on this tape will be deleted from database, check if
202                  * any of the dumps in this dumpset are most-recent-dumps.
203                  */
204                 for (dmp = oldTapeLabel.dumpid; dmp; dmp = de.appendedDumpID) {
205                     if (dmp == lastDump.id) {
206                         memcpy(&de, &lastDump, sizeof(de));
207                         memcpy(&de2, &lastDump, sizeof(de2));
208                     } else {
209                         code = bcdb_FindDumpByID(dmp, &de);
210                         if (code)
211                             break;
212                         sprintf(strlevel, "%d", de.level);
213                         code =
214                             bcdb_FindLatestDump(de.volumeSetName, strlevel,
215                                                 &de2);
216                         if (code)
217                             continue;
218                     }
219
220                     if (de.id == de2.id) {
221                         if (strcmp(DUMP_TAPE_NAME, de2.name) == 0) {
222                             ErrorLog(0, taskId, 0, 0,
223                                      "Warning: Overwriting most recent dump %s (DumpID %u)\n",
224                                      de.name, de.id);
225                         } else {
226                             ErrorLog(0, taskId, 0, 0,
227                                      "Warning: Overwriting most recent dump of the '%s' volumeset: %s (DumpID %u)\n",
228                                      de.volumeSetName, de.name, de.id);
229                         }
230                     }
231                 }
232             }
233
234             /* Otherwise, the savedb is in progress and we can't
235              * access the database (it's locked). So we rely on the
236              * information available (and not the backup database).
237              */
238             else {
239                 /* Check the tape's expiration date. Use the expiration on the label */
240                 gettimeofday(&tp, NULL);
241                 curTime = tp.tv_sec;
242                 if (curTime < oldTapeLabel.expirationDate) {
243                     TLog(taskId, "This tape has not expired\n");
244                     goto getNewTape;
245                 }
246
247                 /* Check if this previous-dump of the dump-in-progress is on this tape */
248                 if (oldTapeLabel.dumpid
249                     && (oldTapeLabel.dumpid == lastDump.id)) {
250                     ErrorLog(0, taskId, 0, 0,
251                              "Warning: Overwriting most recent dump %s (DumpID %u)\n",
252                              lastDump.name, lastDump.id);
253                 }
254
255             }
256         }
257
258         GetNewLabel(tapeInfoPtr, oldTapeLabel.pName, tapeName, &newLabel);
259         newLabel.expirationDate = expires;
260         newLabel.useCount = oldTapeLabel.useCount + 1;
261         newLabel.dumpid = dumpid;
262         newLabel.size = tapeInfoPtr->tapeSize;
263
264         code = butm_Create(tapeInfoPtr, &newLabel, 1);  /* rewind tape */
265         if (code) {
266             TapeLog(0, taskId, code, tapeInfoPtr->error,
267                     "Can't label tape\n");
268             goto getNewTape;
269         }
270
271         *wroteLabel = 1;
272
273         /* Initialize a tapeEntry for later inclusion into the database */
274         listEntryPtr = calloc(1, sizeof(struct tapeEntryList));
275         if (!listEntryPtr)
276             ERROR_EXIT(TC_NOMEMORY);
277
278         /* Remember dumpid so we can delete it later */
279         if ((oldTapeLabel.structVersion >= TAPE_VERSION_3)
280             && oldTapeLabel.dumpid)
281             listEntryPtr->oldDumpId = oldTapeLabel.dumpid;
282
283         /* Fill in tape entry so we can save it later */
284         strcpy(tapeEntryPtr->name, TNAME(&newLabel));
285         tapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
286         tapeEntryPtr->written = newLabel.creationTime;
287         tapeEntryPtr->expires = expires;
288         tapeEntryPtr->seq = sequence;
289         tapeEntryPtr->useCount = oldTapeLabel.useCount + 1;
290         tapeEntryPtr->dump = dumpid;
291         tapeEntryPtr->useKBytes = 0;
292         tapeEntryPtr->labelpos = 0;
293
294         /* Thread onto end of single-linked list */
295         if (listEntryHead) {
296             endList = listEntryHead;
297             while (endList->next)
298                 endList = endList->next;
299             endList->next = listEntryPtr;
300         } else
301             listEntryHead = listEntryPtr;
302     }                           /*w */
303
304   error_exit:
305     return (code);
306 }
307
308 /* freeTapeList
309  *       With the list of tapes, free the structures.
310  */
311
312 afs_int32
313 freeTapeList(void)
314 {
315     struct tapeEntryList *next;
316
317     listEntryPtr = listEntryHead;
318     while (listEntryPtr) {
319         next = listEntryPtr->next;
320         free(listEntryPtr);
321         listEntryPtr = next;
322     }
323
324     listEntryHead = NULL;
325     return (0);
326 }
327
328 /* addTapesToDb
329  *       With the list of tapes, add them to the database.
330  *       Also delete any olddumpids that are around.
331  */
332
333 afs_int32
334 addTapesToDb(afs_int32 taskId)
335 {
336     afs_int32 code = 0;
337     afs_int32 i, new;
338     struct tapeEntryList *next;
339
340     listEntryPtr = listEntryHead;
341     while (listEntryPtr) {
342         next = listEntryPtr->next;
343
344         /* Remove the old database entry */
345         if (listEntryPtr->oldDumpId) {
346             i = bcdb_deleteDump(listEntryPtr->oldDumpId, 0, 0, 0);
347             if (i && (i != BUDB_NOENT)) {
348                 ErrorLog(0, taskId, i, 0,
349                          "Unable to delete old DB entry %u.\n",
350                          listEntryPtr->oldDumpId);
351             }
352         }
353
354         /* Add the tape to the database */
355         code = bcdb_UseTape(tapeEntryPtr, &new);
356         if (code) {
357             ErrorLog(0, taskId, code, 0, "Can't add tape to database: %s\n",
358                      tapeEntryPtr->name);
359             ERROR_EXIT(code);
360         }
361
362         code = bcdb_FinishTape(tapeEntryPtr);
363         if (code) {
364             ErrorLog(0, taskId, code, 0, "Can't finish tape: %s\n",
365                      tapeEntryPtr->name);
366             ERROR_EXIT(code);
367         }
368
369         listEntryPtr = next;
370     }
371
372   error_exit:
373     return (code);
374 }
375
376 /* writeDbDump
377  * notes:
378  *      this code assumes that the blocksize on reads is smaller than
379  *      the blocksize on writes
380  */
381
382 static int
383 writeDbDump(struct butm_tapeInfo *tapeInfoPtr, afs_uint32 taskId,
384             Date expires, afs_uint32 dumpid)
385 {
386     afs_int32 blockSize;
387     afs_int32 writeBufNbytes = 0;
388     char *writeBlock = 0;
389     char *writeBuffer = 0;
390     char *writeBufPtr;
391     afs_int32 transferSize;
392
393     char *readBufPtr = NULL;
394     afs_int32 maxReadSize;
395
396     charListT charList;
397     afs_int32 done;
398     afs_int32 code;
399     afs_int32 chunksize = 0;
400     afs_int32 tc_EndMargin, tc_KEndMargin, kRemaining;
401     int sequence;
402     int wroteLabel;
403     int firstcall;
404 #ifdef AFS_PTHREAD_ENV
405     pthread_t alivePid;
406     pthread_attr_t tattr;
407     AFS_SIGSET_DECL;
408 #else
409     PROCESS alivePid;
410 #endif
411
412     extern struct tapeConfig globalTapeConfig;
413     extern struct udbHandleS udbHandle;
414
415     charList.charListT_val = 0;
416     charList.charListT_len = 0;
417     blockSize = BUTM_BLKSIZE;
418     writeBlock = malloc(BUTM_BLOCKSIZE);
419     if (!writeBlock)
420         ERROR_EXIT(TC_NOMEMORY);
421
422     writeBuffer = writeBlock + sizeof(struct blockMark);
423     memset(writeBuffer, 0, BUTM_BLKSIZE);
424     maxReadSize = 1024;
425
426     /*
427      * The margin of space to check for end of tape is set to the
428      * amount of space used to write an end-of-tape multiplied by 2.
429      * The amount of space is size of a 16K EODump marker, its EOF
430      * marker, and up to two EOF markers done on close (1 16K blocks +
431      * 3 EOF * markers).
432      */
433     tc_EndMargin = (16384 + 3 * globalTapeConfig.fileMarkSize) * 2;
434     tc_KEndMargin = tc_EndMargin / 1024;
435
436     /* have to write enclose the dump in file marks */
437     code = butm_WriteFileBegin(tapeInfoPtr);
438     if (code) {
439         ErrorLog(0, taskId, code, tapeInfoPtr->error,
440                  "Can't write FileBegin on tape\n");
441         ERROR_EXIT(code);
442     }
443
444     writeBufPtr = &writeBuffer[0];
445     firstcall = 1;
446     sequence = 1;
447
448     while (1) {                 /*w */
449         /* When no data in buffer, read data from the budb_server */
450         if (charList.charListT_len == 0) {
451             /* get more data. let rx allocate space */
452             if (charList.charListT_val) {
453                 free(charList.charListT_val);
454                 charList.charListT_val = 0;
455             }
456
457             /* get the data */
458             code =
459                 ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
460                                        UF_SINGLESERVER, firstcall,
461                                        maxReadSize, &charList, &done);
462             if (code) {
463                 ErrorLog(0, taskId, code, 0, "Can't read database\n");
464                 ERROR_EXIT(code);
465             }
466
467             /* If this if the first call to the budb server, create a thread
468              * that will keep the connection alive (during tape changes).
469              */
470             if (firstcall) {
471 #ifdef AFS_PTHREAD_ENV
472                 code = pthread_attr_init(&tattr);
473                 if (code) {
474                     ErrorLog(0, taskId, code, 0,
475                              "Can't pthread_attr_init Keep-alive process\n");
476                     ERROR_EXIT(code);
477                 }
478
479                 code =
480                     pthread_attr_setdetachstate(&tattr,
481                                                 PTHREAD_CREATE_DETACHED);
482                 if (code) {
483                     ErrorLog(0, taskId, code, 0,
484                              "Can't pthread_attr_setdetachstate Keep-alive process\n");
485                     ERROR_EXIT(code);
486                 }
487
488                 AFS_SIGSET_CLEAR();
489                 code = pthread_create(&alivePid, &tattr, KeepAlive, 0);
490                 AFS_SIGSET_RESTORE();
491 #else
492                 code =
493                     LWP_CreateProcess(KeepAlive, 16384, 1, NULL,
494                                       "Keep-alive process", &alivePid);
495 #endif
496                 if (code) {
497                     ErrorLog(0, taskId, code, 0,
498                              "Failed to create keep alive process\n");
499                     ERROR_EXIT(code);
500                 }
501             }
502             firstcall = 0;
503
504             readBufPtr = charList.charListT_val;
505         }
506
507         if ((charList.charListT_len == 0) && done)
508             break;
509
510         /* compute how many bytes and transfer to the write Buffer */
511         transferSize =
512             (charList.charListT_len <
513              (blockSize -
514               writeBufNbytes)) ? charList.charListT_len : (blockSize -
515                                                            writeBufNbytes);
516
517         memcpy(writeBufPtr, readBufPtr, transferSize);
518         charList.charListT_len -= transferSize;
519         writeBufPtr += transferSize;
520         readBufPtr += transferSize;
521         writeBufNbytes += transferSize;
522
523         /* If filled the write buffer, then write it to tape */
524         if (writeBufNbytes == blockSize) {
525             code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
526             if (code) {
527                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
528                          "Can't write data on tape\n");
529                 ERROR_EXIT(code);
530             }
531
532             memset(writeBuffer, 0, blockSize);
533             writeBufPtr = &writeBuffer[0];
534             writeBufNbytes = 0;
535
536             /* Every BIGCHUNK bytes check if aborted */
537             chunksize += blockSize;
538             if (chunksize > BIGCHUNK) {
539                 chunksize = 0;
540                 if (checkAbortByTaskId(taskId))
541                     ERROR_EXIT(TC_ABORTEDBYREQUEST);
542             }
543
544             /*
545              * check if tape is full - since we filled a blockSize worth of data
546              * assume that there is more data.
547              */
548             kRemaining = butm_remainingKSpace(tapeInfoPtr);
549             if (kRemaining < tc_KEndMargin) {
550                 code = butm_WriteFileEnd(tapeInfoPtr);
551                 if (code) {
552                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
553                              "Can't write FileEnd on tape\n");
554                     ERROR_EXIT(code);
555                 }
556
557                 code = butm_WriteEOT(tapeInfoPtr);
558                 if (code) {
559                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
560                              "Can't write end-of-dump on tape\n");
561                     ERROR_EXIT(code);
562                 }
563
564                 /* Mark tape as having been written */
565                 tapeEntryPtr->useKBytes =
566                     tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
567                 tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
568
569                 unmountTape(taskId, tapeInfoPtr);
570
571                 /* Get next tape and writes its label */
572                 sequence++;
573                 code =
574                     GetDBTape(taskId, expires, tapeInfoPtr, dumpid, sequence,
575                               1, &wroteLabel);
576                 if (code)
577                     ERROR_EXIT(code);
578
579                 code = butm_WriteFileBegin(tapeInfoPtr);
580                 if (code) {
581                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
582                              "Can't write FileBegin on tape\n");
583                     ERROR_EXIT(code);
584                 }
585             }
586         }
587     }                           /*w */
588
589     /* no more data to be read - if necessary, flush out the last buffer */
590     if (writeBufNbytes > 0) {
591         code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
592         if (code) {
593             ErrorLog(1, taskId, code, tapeInfoPtr->error,
594                      "Can't write data on tape\n");
595             ERROR_EXIT(code);
596         }
597     }
598
599     code = butm_WriteFileEnd(tapeInfoPtr);
600     if (code) {
601         ErrorLog(0, taskId, code, tapeInfoPtr->error,
602                  "Can't write FileEnd on tape\n");
603         ERROR_EXIT(code);
604     }
605
606     /* Mark tape as having been written */
607     tapeEntryPtr->useKBytes =
608         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
609     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
610
611   error_exit:
612     /* Let the KeepAlive process stop on its own */
613     code =
614         ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
615                                UF_END_SINGLESERVER, 0);
616
617     if (writeBlock)
618         free(writeBlock);
619     if (charList.charListT_val)
620         free(charList.charListT_val);
621     return (code);
622 }
623
624 /* saveDbToTape
625  *      dump backup database to tape
626  */
627
628 void *
629 saveDbToTape(void *param)
630 {
631     struct saveDbIf *saveDbIfPtr = (struct saveDbIf *)param;
632     afs_int32 code;
633     afs_int32 i;
634     int wroteLabel;
635     afs_uint32 taskId;
636     Date expires;
637
638     struct butm_tapeInfo tapeInfo;
639     struct budb_dumpEntry dumpEntry;
640
641     extern struct deviceSyncNode *deviceLatch;
642     extern struct tapeConfig globalTapeConfig;
643
644     afs_pthread_setname_self("Db save");
645     expires = (saveDbIfPtr->archiveTime ? NEVERDATE : 0);
646     taskId = saveDbIfPtr->taskId;
647     dumpEntry.id = 0;
648
649     setStatus(taskId, DRIVE_WAIT);
650     EnterDeviceQueue(deviceLatch);      /* lock tape device */
651     clearStatus(taskId, DRIVE_WAIT);
652
653     printf("\n\n");
654     TLog(taskId, "SaveDb\n");
655
656     tapeInfo.structVersion = BUTM_MAJORVERSION;
657     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
658     if (code) {
659         ErrorLog(0, taskId, code, tapeInfo.error,
660                  "Can't initialize tape module\n");
661         ERROR_EXIT(code);
662     }
663
664     /* Determine what the last database dump was */
665     memset(&lastDump, 0, sizeof(lastDump));
666     code = bcdb_FindLatestDump("", "", &lastDump);
667     if (code) {
668         if (code != BUDB_NODUMPNAME) {
669             ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
670             ERROR_EXIT(code);
671         }
672         memset(&lastDump, 0, sizeof(lastDump));
673     }
674
675     code = CreateDBDump(&dumpEntry);    /* Create a dump for this tape */
676     if (code) {
677         ErrorLog(0, taskId, code, 0, "Can't create dump in database\n");
678         ERROR_EXIT(code);
679     }
680
681
682     listEntryHead = NULL;
683
684     /* Get the tape and write a new label to it */
685     code =
686         GetDBTape(taskId, expires, &tapeInfo, dumpEntry.id, 1, autoQuery,
687                   &wroteLabel);
688
689     /*
690      * If did not write the label, remove created dump
691      * Else if wrote the label, remove old dump from db so it's not saved.
692      */
693     if (!wroteLabel) {
694         i = bcdb_deleteDump(dumpEntry.id, 0, 0, 0);
695         dumpEntry.id = 0;
696         if (i && (i != BUDB_NOENT))
697             ErrorLog(0, taskId, i, 0, "Unable to delete DB entry %u.\n",
698                      dumpEntry.id);
699     } else if (listEntryHead->oldDumpId) {
700         i = bcdb_deleteDump(listEntryHead->oldDumpId, 0, 0, 0);
701         listEntryHead->oldDumpId = 0;
702         if (i && (i != BUDB_NOENT)) {
703             ErrorLog(0, taskId, i, 0, "Unable to delete old DB entry %u.\n",
704                      listEntryHead->oldDumpId);
705             ERROR_EXIT(i);
706         }
707     }
708     if (code)
709         ERROR_EXIT(code);
710
711     TapeLog(1, taskId, 0, 0, "Tape accepted - now dumping database\n");
712
713     /* we have a writable tape */
714     code = writeDbDump(&tapeInfo, taskId, expires, dumpEntry.id);
715     if (code)
716         ERROR_EXIT(code);
717
718     /* Now delete the entries between time 0 and archive-time */
719     if (saveDbIfPtr->archiveTime)
720         code = bcdb_deleteDump(0, 0, saveDbIfPtr->archiveTime, 0);
721
722   error_exit:
723     unmountTape(taskId, &tapeInfo);
724
725     /* Add this dump's tapes to the database and mark it finished */
726     if (dumpEntry.id) {
727         i = addTapesToDb(taskId);
728         if (!code)
729             code = i;
730
731         i = bcdb_FinishDump(&dumpEntry);
732         if (!code)
733             code = i;
734     }
735     freeTapeList();
736
737     if (code == TC_ABORTEDBYREQUEST) {
738         TLog(taskId, "SaveDb: Aborted by request\n");
739         clearStatus(taskId, ABORT_REQUEST);
740         setStatus(taskId, ABORT_DONE);
741     } else if (code) {
742         TapeLog(0, taskId, code, 0, "SaveDb: Finished with errors\n");
743         setStatus(taskId, TASK_ERROR);
744     } else {
745         TLog(taskId, "SaveDb: Finished\n");
746     }
747     setStatus(taskId, TASK_DONE);
748
749     free(saveDbIfPtr);
750     LeaveDeviceQueue(deviceLatch);
751     return (void *)(intptr_t)(code);
752 }
753
754
755 /* makeDbDumpEntry()
756  *      Make a database dump entry given a tape label.
757  */
758
759 afs_int32
760 makeDbDumpEntry(struct budb_tapeEntry *tapeEntPtr,
761                 struct budb_dumpEntry *dumpEntryPtr)
762 {
763     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
764
765     dumpEntryPtr->id = tapeEntPtr->dump;
766     dumpEntryPtr->initialDumpID = 0;
767     dumpEntryPtr->parent = 0;
768     dumpEntryPtr->level = 0;
769     dumpEntryPtr->flags = 0;
770
771     strcpy(dumpEntryPtr->volumeSetName, "");
772     strcpy(dumpEntryPtr->dumpPath, "");
773     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
774
775     dumpEntryPtr->created = tapeEntPtr->dump;
776     dumpEntryPtr->incTime = 0;
777     dumpEntryPtr->nVolumes = 0;
778
779     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
780     strcat(dumpEntryPtr->tapes.format, ".%d");
781     dumpEntryPtr->tapes.b = tapeEntPtr->seq;
782     dumpEntryPtr->tapes.maxTapes = 0;
783     return 0;
784 }
785
786 /* readDbTape
787  *      prompt for a specific database tape
788  */
789
790 afs_int32
791 readDbTape(struct butm_tapeInfo *tapeInfoPtr,
792            struct rstTapeInfo *rstTapeInfoPtr, int query)
793 {
794     afs_int32 code = 0;
795     int interactiveFlag;
796     afs_int32 taskId;
797     struct butm_tapeLabel oldTapeLabel;
798     char AFStapeName[BU_MAXTAPELEN], tapeName[BU_MAXTAPELEN];
799     struct tapeEntryList *endList;
800     int tapecount = 1;
801     struct budb_dumpEntry de;
802     struct budb_tapeEntry te;
803
804     taskId = rstTapeInfoPtr->taskId;
805     interactiveFlag = query;
806
807     /* construct the name of the tape */
808     sprintf(AFStapeName, "%s.%-d", DUMP_TAPE_NAME, rstTapeInfoPtr->tapeSeq);
809     strcpy(tapeName, AFStapeName);
810
811     /* Will prompt for the latest saved database tape, but will accept any one */
812     if (rstTapeInfoPtr->tapeSeq == 1) {
813         code = bcdb_FindLatestDump("", "", &de);
814         if (!code)
815             rstTapeInfoPtr->dumpid = de.id;
816     }
817     if (rstTapeInfoPtr->dumpid) {
818         code =
819             bcdb_FindTapeSeq(rstTapeInfoPtr->dumpid, rstTapeInfoPtr->tapeSeq,
820                              &te);
821         if (!code)
822             strcpy(tapeName, te.name);
823     }
824     code = 0;
825
826     while (1) {                 /*w */
827         if (interactiveFlag) {  /* need a tape to read */
828             code =
829                 PromptForTape(RESTOREDBOPCODE, tapeName,
830                               rstTapeInfoPtr->dumpid, taskId, tapecount);
831             if (code)
832                 ERROR_EXIT(code);
833         }
834         interactiveFlag = 1;
835         tapecount++;
836
837         code = butm_Mount(tapeInfoPtr, tapeName);
838         if (code) {
839             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
840             goto getNewTape;
841         }
842
843         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* will rewind the tape */
844         if (code) {
845             TapeLog(0, taskId, code, tapeInfoPtr->error,
846                     "Can't read tape label\n");
847             goto getNewTape;
848         }
849
850         /* Check for name of tape and matching dump id (if applicable). */
851         if ((strcmp(oldTapeLabel.AFSName, AFStapeName) != 0)
852             || ((rstTapeInfoPtr->tapeSeq != 1)
853                 && (oldTapeLabel.dumpid != rstTapeInfoPtr->dumpid))) {
854             char expTape[BU_MAXTAPELEN + 32];
855             char gotTape[BU_MAXTAPELEN + 32];
856
857             TAPENAME(expTape, tapeName, rstTapeInfoPtr->dumpid);
858             TAPENAME(gotTape, oldTapeLabel.AFSName, oldTapeLabel.dumpid);
859
860             TLog(taskId, "Tape label expected %s, label seen %s\n", expTape,
861                  gotTape);
862             goto getNewTape;
863         }
864
865         if (rstTapeInfoPtr->tapeSeq == 1)       /* Remember this dumpId */
866             rstTapeInfoPtr->dumpid = oldTapeLabel.dumpid;
867
868         break;
869
870       getNewTape:
871         unmountTape(taskId, tapeInfoPtr);
872     }                           /*w */
873
874
875     /* Initialize a tapeEntry for later inclusion into the database */
876     listEntryPtr = calloc(1, sizeof(struct tapeEntryList));
877     if (!listEntryPtr)
878         ERROR_EXIT(TC_NOMEMORY);
879
880     /* Fill in tape entry so we can save it later */
881     strcpy(tapeEntryPtr->name, TNAME(&oldTapeLabel));
882     tapeEntryPtr->dump = oldTapeLabel.dumpid;
883     tapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
884     tapeEntryPtr->written = oldTapeLabel.creationTime;
885     tapeEntryPtr->expires = oldTapeLabel.expirationDate;
886     tapeEntryPtr->seq = extractTapeSeq(oldTapeLabel.AFSName);
887     tapeEntryPtr->useCount = oldTapeLabel.useCount;
888     tapeEntryPtr->useKBytes = 0;
889     tapeEntryPtr->labelpos = 0;
890
891     /* Thread onto end of single-linked list */
892     if (listEntryHead) {
893         endList = listEntryHead;
894         while (endList->next)
895             endList = endList->next;
896         endList->next = listEntryPtr;
897     } else
898         listEntryHead = listEntryPtr;
899
900   error_exit:
901     return (code);
902 }
903
904 static afs_int32 nbytes = 0;    /* # bytes left in buffer */
905 static void
906 initTapeBuffering(void)
907 {
908     nbytes = 0;
909 }
910
911
912 /* restoreDbEntries
913  *      restore all the items on the tape
914  * entry:
915  *      tape positioned after tape label
916  */
917
918 static int
919 restoreDbEntries(struct butm_tapeInfo *tapeInfoPtr,
920                  struct rstTapeInfo *rstTapeInfoPtr)
921 {
922     struct structDumpHeader netItemHeader, hostItemHeader;
923     afs_int32 more = 1;
924     afs_int32 taskId, code = 0;
925     int count = 0;
926
927     taskId = rstTapeInfoPtr->taskId;
928
929     /* clear state for the buffer routine(s) */
930     initTapeBuffering();
931
932     code = butm_ReadFileBegin(tapeInfoPtr);
933     if (code) {
934         ErrorLog(0, taskId, code, tapeInfoPtr->error,
935                  "Can't read FileBegin on tape\n");
936         ERROR_EXIT(code);
937     }
938
939     /* get the first item-header */
940     memset(&netItemHeader, 0, sizeof(netItemHeader));
941     code =
942         getTapeData(tapeInfoPtr, rstTapeInfoPtr, &netItemHeader,
943                     sizeof(netItemHeader));
944     if (code)
945         ERROR_EXIT(code);
946     structDumpHeader_ntoh(&netItemHeader, &hostItemHeader);
947
948     while (more) {
949         switch (hostItemHeader.type) {
950         case SD_DBHEADER:
951             code =
952                 restoreDbHeader(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
953             if (code)
954                 ERROR_EXIT(code);
955             break;
956
957         case SD_DUMP:
958             if (++count > 25) { /*every 25 dumps, wait */
959                 waitDbWatcher();
960                 count = 0;
961             }
962             code =
963                 restoreDbDump(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
964             if (code)
965                 ERROR_EXIT(code);
966             break;
967
968         case SD_TAPE:
969         case SD_VOLUME:
970             ERROR_EXIT(-1);
971             break;
972
973         case SD_TEXT_DUMPSCHEDULE:
974         case SD_TEXT_VOLUMESET:
975         case SD_TEXT_TAPEHOSTS:
976             code = restoreText(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
977             if (code)
978                 ERROR_EXIT(code);
979             break;
980
981         case SD_END:
982             more = 0;
983             break;
984
985         default:
986             TLog(taskId, "Unknown database header type %d\n",
987                  hostItemHeader.type);
988             ERROR_EXIT(-1);
989             break;
990         }
991     }
992
993     code = butm_ReadFileEnd(tapeInfoPtr);
994     if (code) {
995         ErrorLog(0, taskId, code, tapeInfoPtr->error,
996                  "Can't read EOF on tape\n");
997         ERROR_EXIT(code);
998     }
999
1000     /* Mark tape as having been written */
1001     tapeEntryPtr->useKBytes =
1002         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
1003     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
1004
1005   error_exit:
1006     return (code);
1007 }
1008
1009 /* restoreDbFromTape
1010  *      restore the backup database from tape.
1011  */
1012
1013 void *
1014 restoreDbFromTape(void *param)
1015 {
1016     afs_uint32 taskId = (intptr_t) param;
1017     afs_int32 code = 0;
1018     afs_int32 i;
1019     struct butm_tapeInfo tapeInfo;
1020     struct rstTapeInfo rstTapeInfo;
1021     struct budb_dumpEntry dumpEntry;
1022
1023     extern struct tapeConfig globalTapeConfig;
1024     extern struct deviceSyncNode *deviceLatch;
1025
1026     afs_pthread_setname_self("Db restore");
1027     setStatus(taskId, DRIVE_WAIT);
1028     EnterDeviceQueue(deviceLatch);      /* lock tape device */
1029     clearStatus(taskId, DRIVE_WAIT);
1030
1031     printf("\n\n");
1032     TLog(taskId, "RestoreDb\n");
1033
1034     tapeInfo.structVersion = BUTM_MAJORVERSION;
1035     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
1036     if (code) {
1037         ErrorLog(0, taskId, code, tapeInfo.error,
1038                  "Can't initialize tape module\n");
1039         ERROR_EXIT(code);
1040     }
1041
1042     listEntryHead = NULL;
1043
1044     rstTapeInfo.taskId = taskId;
1045     rstTapeInfo.tapeSeq = 1;
1046     rstTapeInfo.dumpid = 0;
1047
1048     code = readDbTape(&tapeInfo, &rstTapeInfo, autoQuery);
1049     if (code)
1050         ERROR_EXIT(code);
1051
1052     code = restoreDbEntries(&tapeInfo, &rstTapeInfo);
1053     if (code)
1054         ERROR_EXIT(code);
1055
1056   error_exit:
1057     /* Now put this dump into the database */
1058     /* Make a dump entry from first tape   */
1059     listEntryPtr = listEntryHead;
1060     if (listEntryPtr) {
1061         makeDbDumpEntry(tapeEntryPtr, &dumpEntry);
1062         if (dumpEntry.id != 0) {
1063             i = bcdb_CreateDump(&dumpEntry);
1064             if (i) {
1065                 if (i == BUDB_DUMPIDEXISTS)
1066                     fprintf(stderr,
1067                             "Dump id %d not added to database - already exists\n",
1068                             dumpEntry.id);
1069                 else
1070                     TapeLog(0, taskId, i, 0,
1071                             "Dump id %d not added to database\n",
1072                             dumpEntry.id);
1073             } else {
1074                 i = addTapesToDb(taskId);
1075                 if (!code)
1076                     code = i;
1077
1078                 i = bcdb_FinishDump(&dumpEntry);
1079                 if (!code)
1080                     code = i;
1081             }
1082         }
1083         freeTapeList();
1084     }
1085
1086     unmountTape(taskId, &tapeInfo);
1087     waitDbWatcher();
1088
1089     if (code == TC_ABORTEDBYREQUEST) {
1090         TLog(taskId, "RestoreDb: Aborted by request\n");
1091         clearStatus(taskId, ABORT_REQUEST);
1092         setStatus(taskId, ABORT_DONE);
1093     } else if (code) {
1094         TapeLog(0, taskId, code, 0, "RestoreDb: Finished with errors\n");
1095         setStatus(taskId, TASK_ERROR);
1096     } else {
1097         TLog(taskId, "RestoreDb: Finished\n");
1098     }
1099
1100     LeaveDeviceQueue(deviceLatch);
1101     setStatus(taskId, TASK_DONE);
1102
1103     return (void *)(intptr_t)(code);
1104 }
1105
1106 /* KeepAlive
1107  *
1108  *      While dumping the database, keeps the connection alive.
1109  *      Every 10 seconds, wake up and ask to read 0 bytes of the database.
1110  *      This resets the database's internal timer so that it does not
1111  *      prematuraly quit (on asking for new tapes and such).
1112  *
1113  *      Use the same udbHandle as writeDbDump so we go to the same server.
1114  */
1115 void *
1116 KeepAlive(void *unused)
1117 {
1118     charListT charList;
1119     afs_int32 code;
1120     afs_int32 done;
1121
1122     extern struct udbHandleS udbHandle;
1123
1124     afs_pthread_setname_self("Keep-alive");
1125     while (1) {
1126 #ifdef AFS_PTHREAD_ENV
1127         sleep(5);
1128 #else
1129         IOMGR_Sleep(5);
1130 #endif
1131         charList.charListT_val = 0;
1132         charList.charListT_len = 0;
1133         code =
1134             ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
1135                                    UF_SINGLESERVER, 0, 0, &charList, &done);
1136         if (code || done)
1137             break;
1138     }
1139     return 0;
1140 }
1141
1142
1143 /* restoreDbHeader
1144  *      restore special items in the header
1145  */
1146
1147 int
1148 restoreDbHeader(struct butm_tapeInfo *tapeInfo,
1149                 struct rstTapeInfo *rstTapeInfoPtr,
1150                 struct structDumpHeader *nextHeader)
1151 {
1152     struct structDumpHeader netItemHeader;
1153     struct DbHeader netDbHeader, hostDbHeader;
1154     afs_int32 code = 0;
1155
1156     extern struct udbHandleS udbHandle;
1157
1158     /* Read the database header */
1159     memset(&netDbHeader, 0, sizeof(netDbHeader));
1160     code =
1161         getTapeData(tapeInfo, rstTapeInfoPtr, &netDbHeader,
1162                     sizeof(netDbHeader));
1163     if (code)
1164         ERROR_EXIT(code);
1165     DbHeader_ntoh(&netDbHeader, &hostDbHeader);
1166
1167     /* Add the database header to the database */
1168     code =
1169         ubik_BUDB_RestoreDbHeader(udbHandle.uh_client, 0,
1170                   &hostDbHeader);
1171     if (code) {
1172         ErrorLog(0, rstTapeInfoPtr->taskId, code, 0,
1173                  "Can't restore DB Header\n");
1174         ERROR_EXIT(code);
1175     }
1176
1177     /* get the next item-header */
1178     memset(nextHeader, 0, sizeof(*nextHeader));
1179     code =
1180         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1181                     sizeof(netItemHeader));
1182     if (code)
1183         ERROR_EXIT(code);
1184     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1185
1186   error_exit:
1187     return (code);
1188 }
1189
1190
1191 /* restoreDbDump
1192  *      restore a single dump, including all its tapes and volumes, from
1193  *      the tape.
1194  * entry:
1195  *      nextHeader - ptr to structure for return value
1196  * exit:
1197  *      nextHeader - next structure header from tape
1198  * notes:
1199  *      upon entry, the dump structure header has been read confirming that
1200  *      a database dump tree exists on the tape
1201  */
1202
1203 int
1204 restoreDbDump(struct butm_tapeInfo *tapeInfo,
1205               struct rstTapeInfo *rstTapeInfoPtr,
1206               struct structDumpHeader *nextHeader)
1207 {
1208     struct budb_dumpEntry netDumpEntry, hostDumpEntry;
1209     struct budb_tapeEntry netTapeEntry, hostTapeEntry;
1210     struct budb_volumeEntry netVolumeEntry, hostVolumeEntry;
1211     struct structDumpHeader netItemHeader;
1212     int restoreThisDump = 1;
1213     afs_int32 code = 0;
1214
1215     extern struct udbHandleS udbHandle;
1216
1217     /* read dump entry */
1218     memset(&netDumpEntry, 0, sizeof(netDumpEntry));
1219     code =
1220         getTapeData(tapeInfo, rstTapeInfoPtr, &netDumpEntry,
1221                     sizeof(netDumpEntry));
1222     if (code)
1223         ERROR_EXIT(code);
1224
1225     /* If database tape does not have a dumpid (AFS 3.3) then no initial/appended dumps */
1226     if (rstTapeInfoPtr->dumpid == 0) {
1227         netDumpEntry.initialDumpID = 0;
1228         netDumpEntry.appendedDumpID = 0;
1229     }
1230
1231     dumpEntry_ntoh(&netDumpEntry, &hostDumpEntry);
1232
1233     /* The dump entry for this database tape is incomplete, so don't include it */
1234     if (hostDumpEntry.id == rstTapeInfoPtr->dumpid)
1235         restoreThisDump = 0;
1236
1237     /* add the dump to the database */
1238     if (restoreThisDump) {
1239         code =
1240             threadEntryDir(&hostDumpEntry, sizeof(hostDumpEntry),
1241                            DLQ_USEDUMP);
1242         if (code)
1243             ERROR_EXIT(code);
1244     }
1245
1246     /* get the next item-header */
1247     memset(nextHeader, 0, sizeof(*nextHeader));
1248     code =
1249         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1250                     sizeof(netItemHeader));
1251     if (code)
1252         ERROR_EXIT(code);
1253     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1254
1255     /* Add every tape to the db */
1256     while (nextHeader->type == SD_TAPE) {       /*t */
1257
1258         /* read the tape entry */
1259         memset(&netTapeEntry, 0, sizeof(netTapeEntry));
1260         code =
1261             getTapeData(tapeInfo, rstTapeInfoPtr, &netTapeEntry,
1262                         sizeof(netTapeEntry));
1263         if (code)
1264             ERROR_EXIT(code);
1265         tapeEntry_ntoh(&netTapeEntry, &hostTapeEntry);
1266
1267         /* Add the tape to the database */
1268         if (restoreThisDump) {
1269             code =
1270                 threadEntryDir(&hostTapeEntry, sizeof(hostTapeEntry),
1271                                DLQ_USETAPE);
1272             if (code)
1273                 ERROR_EXIT(code);
1274         }
1275
1276         /* get the next item-header */
1277         memset(nextHeader, 0, sizeof(*nextHeader));
1278         code =
1279             getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1280                         sizeof(netItemHeader));
1281         if (code)
1282             ERROR_EXIT(code);
1283         structDumpHeader_ntoh(&netItemHeader, nextHeader);
1284
1285         /* Add every volume to the db */
1286         while (nextHeader->type == SD_VOLUME) { /*v */
1287
1288             /* read the volume entry */
1289             memset(&netVolumeEntry, 0, sizeof(netVolumeEntry));
1290             code =
1291                 getTapeData(tapeInfo, rstTapeInfoPtr, &netVolumeEntry,
1292                             sizeof(netVolumeEntry));
1293             if (code)
1294                 ERROR_EXIT(code);
1295             volumeEntry_ntoh(&netVolumeEntry, &hostVolumeEntry);
1296
1297             if (restoreThisDump) {
1298                 code =
1299                     threadEntryDir(&hostVolumeEntry, sizeof(hostVolumeEntry),
1300                                    DLQ_VOLENTRY);
1301                 if (code)
1302                     ERROR_EXIT(code);
1303             }
1304
1305             /* get the next item-header */
1306             memset(nextHeader, 0, sizeof(*nextHeader));
1307             code =
1308                 getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1309                             sizeof(netItemHeader));
1310             if (code)
1311                 ERROR_EXIT(code);
1312             structDumpHeader_ntoh(&netItemHeader, nextHeader);
1313         }                       /*v */
1314
1315         /* Finish the tape */
1316         if (restoreThisDump) {
1317             code =
1318                 threadEntryDir(&hostTapeEntry, sizeof(hostTapeEntry),
1319                                DLQ_FINISHTAPE);
1320             if (code)
1321                 ERROR_EXIT(code);
1322         }
1323     }                           /*t */
1324
1325     /* Finish the dump */
1326     if (restoreThisDump) {
1327         code =
1328             threadEntryDir(&hostDumpEntry, sizeof(hostDumpEntry),
1329                            DLQ_FINISHDUMP);
1330         if (code)
1331             ERROR_EXIT(code);
1332     }
1333
1334   error_exit:
1335     return (code);
1336 }
1337
1338 /* saveTextFile
1339  *      Save the specified file as configuration text in the ubik database.
1340  *      Have to setup the client text structure so that we can call
1341  *      the routine to transmit the text to the db.
1342  */
1343
1344 afs_int32
1345 saveTextFile(afs_int32 taskId, afs_int32 textType, char *fileName)
1346 {
1347     udbClientTextP ctPtr = 0;
1348     afs_int32 code = 0;
1349     int tlock = 0;
1350
1351     ctPtr = calloc(1, sizeof(*ctPtr));
1352     if (!ctPtr)
1353         ERROR_EXIT(TC_NOMEMORY);
1354
1355     ctPtr->textType = textType;
1356
1357     /* lock the text in the database */
1358     code = bc_LockText(ctPtr);
1359     if (code) {
1360         ErrorLog(0, taskId, code, 0, "Can't lock text file\n");
1361         ERROR_EXIT(code);
1362     }
1363     tlock = 1;
1364
1365     ctPtr->textStream = fopen(fileName, "r");
1366     if (!ctPtr->textStream) {
1367         ErrorLog(0, taskId, errno, 0, "Can't open text file\n");
1368         ERROR_EXIT(errno);
1369     }
1370
1371     /* now send the text to the database */
1372     code = bcdb_SaveTextFile(ctPtr);
1373     if (code) {
1374         ErrorLog(0, taskId, code, 0, "Can't save text file\n");
1375         ERROR_EXIT(code);
1376     }
1377
1378   error_exit:
1379     if (ctPtr) {
1380         if (ctPtr->textStream)
1381             fclose(ctPtr->textStream);
1382         if (tlock)
1383             bc_UnlockText(ctPtr);
1384         free(ctPtr);
1385     }
1386     return (code);
1387 }
1388
1389 /* restoreText
1390  *      read the text off the tape, and store it in the appropriate
1391  *      text type in the database.
1392  * entry:
1393  *      nextHeader - ptr to struct for return information
1394  * exit:
1395  *      nextHeader - struct header for next item on the tape
1396  */
1397
1398 int
1399 restoreText(struct butm_tapeInfo *tapeInfo,
1400             struct rstTapeInfo *rstTapeInfoPtr,
1401             struct structDumpHeader *nextHeader)
1402 {
1403     char filename[64];
1404     afs_int32 nbytes;
1405     char *readBuffer = 0;
1406     afs_int32 readBlockSize;
1407     afs_int32 transferSize;
1408     struct structDumpHeader netItemHeader;
1409     int fid = -1;
1410     afs_int32 code = 0;
1411
1412     udbClientTextP ctPtr = 0;
1413     afs_int32 textType;
1414
1415     ctPtr = malloc(sizeof(*ctPtr));
1416     if (!ctPtr)
1417         ERROR_EXIT(TC_NOMEMORY);
1418
1419     /* determine the type of text block */
1420     switch (nextHeader->type) {
1421     case SD_TEXT_DUMPSCHEDULE:
1422         textType = TB_DUMPSCHEDULE;
1423         break;
1424
1425     case SD_TEXT_VOLUMESET:
1426         textType = TB_VOLUMESET;
1427         break;
1428
1429     case SD_TEXT_TAPEHOSTS:
1430         textType = TB_TAPEHOSTS;
1431         break;
1432
1433     default:
1434         ErrorLog(0, rstTapeInfoPtr->taskId, TC_INTERNALERROR, 0,
1435                  "Unknown text block\n");
1436         ERROR_EXIT(TC_INTERNALERROR);
1437         break;
1438     }
1439
1440     /* open the text file */
1441     sprintf(filename, "%s/bu_XXXXXX", gettmpdir());
1442     fid = mkstemp(filename);
1443     if (fid < 0) {
1444         ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1445                  "Can't open temporary text file: %s\n", filename);
1446         ERROR_EXIT(errno);
1447     }
1448
1449     /* allocate buffer for text */
1450     readBlockSize = BUTM_BLKSIZE;
1451     readBuffer = malloc(readBlockSize);
1452     if (!readBuffer)
1453         ERROR_EXIT(TC_NOMEMORY);
1454
1455     /* read the text into the temporary file */
1456     nbytes = nextHeader->size;
1457     while (nbytes > 0) {
1458         transferSize = (readBlockSize < nbytes) ? readBlockSize : nbytes;
1459
1460         /* read it from the tape */
1461         code =
1462             getTapeData(tapeInfo, rstTapeInfoPtr, readBuffer, transferSize);
1463         if (code)
1464             ERROR_EXIT(code);
1465
1466         /* write to the file */
1467         if (write(fid, readBuffer, transferSize) != transferSize) {
1468             ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1469                      "Can't write temporary text file: %s\n", filename);
1470             ERROR_EXIT(errno);
1471         }
1472
1473         nbytes -= transferSize;
1474     }
1475
1476     close(fid);
1477     fid = -1;
1478     code = saveTextFile(rstTapeInfoPtr->taskId, textType, filename);
1479     if (code)
1480         ERROR_EXIT(code);
1481     unlink(filename);
1482
1483     /* get the next item-header */
1484     memset(nextHeader, 0, sizeof(*nextHeader));
1485     code =
1486         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1487                     sizeof(netItemHeader));
1488     if (code)
1489         ERROR_EXIT(code);
1490     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1491
1492   error_exit:
1493     if (ctPtr)
1494         free(ctPtr);
1495     if (readBuffer)
1496         free(readBuffer);
1497     if (fid != -1) {
1498         close(fid);
1499         unlink(filename);
1500     }
1501     return (code);
1502 }
1503
1504
1505 /* ----------------------------------
1506  * Tape data buffering - for reading database dumps
1507  * ----------------------------------
1508  */
1509
1510 static char *tapeReadBuffer = 0;        /* input buffer */
1511 static char *tapeReadBufferPtr = 0;     /* position in buffer */
1512
1513 /* getTapeData
1514  *      Read information from tape, and place the requested number of bytes
1515  *      in the buffer supplied
1516  * entry:
1517  *      tapeInfo
1518  *      rstTapeInfoPtr - Info about the dump being restored.
1519  *      buffer - buffer for requested data
1520  *      requestedBytes - no. of bytes requested
1521  * exit:
1522  *      fn retn - 0, ok, n, error
1523  */
1524
1525 int
1526 getTapeData(struct butm_tapeInfo *tapeInfoPtr,
1527             struct rstTapeInfo *rstTapeInfoPtr,
1528             void *out, afs_int32 requestedBytes)
1529 {
1530     char *buffer = (char *) out;
1531     afs_int32 taskId, transferBytes;
1532     afs_int32 code = 0;
1533
1534     taskId = rstTapeInfoPtr->taskId;
1535
1536     if (checkAbortByTaskId(taskId))
1537         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1538
1539     if (!tapeReadBuffer) {
1540         tapeReadBuffer = malloc(BUTM_BLOCKSIZE);
1541         if (!tapeReadBuffer)
1542             ERROR_EXIT(TC_NOMEMORY);
1543     }
1544
1545     while (requestedBytes > 0) {
1546         if (nbytes == 0) {
1547             tapeReadBufferPtr = &tapeReadBuffer[sizeof(struct blockMark)];
1548
1549             /* get more data */
1550             code =
1551                 butm_ReadFileData(tapeInfoPtr, tapeReadBufferPtr,
1552                                   BUTM_BLKSIZE, &nbytes);
1553             if (code) {
1554                 /* detect if we hit the end-of-tape and get next tape */
1555                 if (code == BUTM_ENDVOLUME) {
1556                     /* Update fields in tape entry for this tape */
1557                     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
1558                     tapeEntryPtr->useKBytes =
1559                         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
1560
1561                     unmountTape(taskId, tapeInfoPtr);
1562
1563                     rstTapeInfoPtr->tapeSeq++;
1564                     code = readDbTape(tapeInfoPtr, rstTapeInfoPtr, 1);
1565                     if (code)
1566                         ERROR_EXIT(code);
1567
1568                     code = butm_ReadFileBegin(tapeInfoPtr);
1569                     if (code) {
1570                         ErrorLog(0, taskId, code, tapeInfoPtr->error,
1571                                  "Can't read FileBegin on tape\n");
1572                         ERROR_EXIT(code);
1573                     }
1574
1575                     continue;
1576                 }
1577
1578                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
1579                          "Can't read FileData on tape\n");
1580                 ERROR_EXIT(code);
1581             }
1582         }
1583
1584         /* copy out data */
1585         transferBytes = (nbytes < requestedBytes) ? nbytes : requestedBytes;
1586         memcpy(buffer, tapeReadBufferPtr, transferBytes);
1587         tapeReadBufferPtr += transferBytes;
1588         buffer += transferBytes;
1589         nbytes -= transferBytes;
1590         requestedBytes -= transferBytes;
1591     }
1592
1593   error_exit:
1594     return (code);
1595 }