296652c78f877555d9af53136a50bc4bdd1a5a16
[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 <rx/xdr.h>
21 #include <rx/rx.h>
22 #include <afs/afsint.h>
23 #include <afs/afs_assert.h>
24 #include <afs/prs_fs.h>
25 #include <afs/nfs.h>
26 #include <lwp.h>
27 #include <lock.h>
28 #include <afs/cellconfig.h>
29 #include <afs/keys.h>
30 #include <ubik.h>
31 #include <afs/acl.h>
32 #include <afs/volser.h>
33 #include <afs/vlserver.h>
34 #include <afs/tcdata.h>
35 #include <afs/budb.h>
36 #include <afs/budb_client.h>
37 #include <afs/bubasics.h>
38 #include <afs/bucoord_prototypes.h>
39 #include <afs/butm_prototypes.h>
40 #include <afs/budb_prototypes.h>
41 #include <afs/afsutil.h>
42
43 #include "butc_internal.h"
44 #include "error_macros.h"
45
46 /* GLOBAL CONFIGURATION PARAMETERS */
47 #define BIGCHUNK 102400
48
49 extern int dump_namecheck;
50 extern int autoQuery;
51
52 struct rstTapeInfo {
53     afs_int32 taskId;
54     afs_int32 tapeSeq;
55     afs_uint32 dumpid;
56 };
57
58 static void initTapeBuffering(void);
59 static int writeDbDump(struct butm_tapeInfo *, afs_uint32, Date, afs_uint32);
60 static int restoreDbEntries(struct butm_tapeInfo *, struct rstTapeInfo *);
61
62 int getTapeData(struct butm_tapeInfo *, struct rstTapeInfo *, void *,
63                 afs_int32);
64 int restoreDbHeader(struct butm_tapeInfo *, struct rstTapeInfo *,
65                     struct structDumpHeader *);
66 int restoreDbDump(struct butm_tapeInfo *, struct rstTapeInfo *,
67                   struct structDumpHeader *);
68 int restoreText(struct butm_tapeInfo *, struct rstTapeInfo *,
69                 struct structDumpHeader *);
70
71
72
73 void * KeepAlive(void *);
74 /* CreateDBDump
75  *      create a dump entry for a saved database
76  */
77
78 afs_int32
79 CreateDBDump(struct budb_dumpEntry *dumpEntryPtr)
80 {
81     afs_int32 code = 0;
82
83     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
84
85     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
86     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
87     strcat(dumpEntryPtr->tapes.format, ".%d");
88     strcpy(dumpEntryPtr->volumeSetName, "");
89     strcpy(dumpEntryPtr->dumpPath, "");
90     dumpEntryPtr->created = 0;  /* let database assign it */
91     dumpEntryPtr->incTime = 0;
92     dumpEntryPtr->nVolumes = 0;
93     dumpEntryPtr->initialDumpID = 0;
94     dumpEntryPtr->parent = 0;
95     dumpEntryPtr->level = 0;
96     dumpEntryPtr->tapes.maxTapes = 0;
97     dumpEntryPtr->tapes.b = 1;
98
99     /* now call the database to create the entry */
100     code = bcdb_CreateDump(dumpEntryPtr);
101     return (code);
102 }
103
104 struct tapeEntryList {
105     struct tapeEntryList *next;
106     afs_uint32 oldDumpId;
107     struct budb_tapeEntry tapeEnt;
108 };
109 struct tapeEntryList *listEntryHead;
110 struct tapeEntryList *listEntryPtr;
111 #define tapeEntryPtr (&listEntryPtr->tapeEnt)
112 struct budb_dumpEntry lastDump; /* the last dump of this volset */
113
114 /* GetDBTape
115  *      Load a DB tape, read and over write its label.
116  *      Leave the tape mounted.
117  */
118 afs_int32
119 GetDBTape(afs_int32 taskId, Date expires, struct butm_tapeInfo *tapeInfoPtr,
120           afs_uint32 dumpid, afs_int32 sequence, int queryFlag,
121           int *wroteLabel)
122 {
123     afs_int32 code = 0;
124     int interactiveFlag;
125     char tapeName[BU_MAXTAPELEN];
126     char strlevel[5];
127     struct timeval tp;
128     afs_int32 curTime;
129     int tapecount = 1;
130
131     struct butm_tapeLabel oldTapeLabel, newLabel;
132     struct tapeEntryList *endList;
133
134     /* construct the name of the tape */
135     sprintf(tapeName, "%s.%-d", DUMP_TAPE_NAME, sequence);
136
137     interactiveFlag = queryFlag;
138     *wroteLabel = 0;
139
140     while (!*wroteLabel) {      /*w */
141         if (interactiveFlag) {  /* need a tape to write */
142             code =
143                 PromptForTape(SAVEDBOPCODE, tapeName, dumpid, taskId,
144                               tapecount);
145             if (code)
146                 ERROR_EXIT(code);
147         }
148         interactiveFlag = 1;
149         tapecount++;
150
151         code = butm_Mount(tapeInfoPtr, tapeName);
152         if (code) {
153             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
154             goto getNewTape;
155         }
156
157         memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
158         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* rewind tape */
159         if (code) {
160             oldTapeLabel.useCount = 0;  /* no label exists */
161             oldTapeLabel.structVersion = 0;
162             strcpy(oldTapeLabel.pName, "");
163         } else {
164             /* If tape has a name, it must be null or database tape name */
165             if (dump_namecheck && strcmp(oldTapeLabel.AFSName, "")
166                 && !databaseTape(oldTapeLabel.AFSName)) {
167                 char gotName[BU_MAXTAPELEN + 32];
168
169                 LABELNAME(gotName, &oldTapeLabel);
170                 TLog(taskId,
171                      "This tape %s must be a database tape or NULL tape\n",
172                      gotName);
173
174               getNewTape:
175                 unmountTape(taskId, tapeInfoPtr);
176                 continue;
177             }
178
179             /* Do not overwrite a tape that belongs to this dump */
180             if (oldTapeLabel.dumpid && (oldTapeLabel.dumpid == dumpid)) {
181                 ErrorLog(0, taskId, 0, 0,
182                          "Can't overwrite tape containing the dump in progress\n");
183                 goto getNewTape;
184             }
185
186             /* On first tape, the savedb has not started yet, so the database is not locked
187              * and we can therefore, access information from it. This is easier to do because
188              * database dumps don't have appended dumps (nor appended).
189              */
190             if (sequence == 1) {
191                 afs_uint32 dmp;
192                 struct budb_dumpEntry de, de2;
193
194                 /* Verify the tape has not expired
195                  * Early database dumps don't have a dumpid
196                  */
197                 if (!tapeExpired(&oldTapeLabel)) {
198                     TLog(taskId, "This tape has not expired\n");
199                     goto getNewTape;
200                 }
201
202                 /* Since the dumpset on this tape will be deleted from database, check if
203                  * any of the dumps in this dumpset are most-recent-dumps.
204                  */
205                 for (dmp = oldTapeLabel.dumpid; dmp; dmp = de.appendedDumpID) {
206                     if (dmp == lastDump.id) {
207                         memcpy(&de, &lastDump, sizeof(de));
208                         memcpy(&de2, &lastDump, sizeof(de2));
209                     } else {
210                         code = bcdb_FindDumpByID(dmp, &de);
211                         if (code)
212                             break;
213                         sprintf(strlevel, "%d", de.level);
214                         code =
215                             bcdb_FindLatestDump(de.volumeSetName, strlevel,
216                                                 &de2);
217                         if (code)
218                             continue;
219                     }
220
221                     if (de.id == de2.id) {
222                         if (strcmp(DUMP_TAPE_NAME, de2.name) == 0) {
223                             ErrorLog(0, taskId, 0, 0,
224                                      "Warning: Overwriting most recent dump %s (DumpID %u)\n",
225                                      de.name, de.id);
226                         } else {
227                             ErrorLog(0, taskId, 0, 0,
228                                      "Warning: Overwriting most recent dump of the '%s' volumeset: %s (DumpID %u)\n",
229                                      de.volumeSetName, de.name, de.id);
230                         }
231                     }
232                 }
233             }
234
235             /* Otherwise, the savedb is in progress and we can't
236              * access the database (it's locked). So we rely on the
237              * information available (and not the backup database).
238              */
239             else {
240                 /* Check the tape's expiration date. Use the expiration on the label */
241                 gettimeofday(&tp, NULL);
242                 curTime = tp.tv_sec;
243                 if (curTime < oldTapeLabel.expirationDate) {
244                     TLog(taskId, "This tape has not expired\n");
245                     goto getNewTape;
246                 }
247
248                 /* Check if this previous-dump of the dump-in-progress is on this tape */
249                 if (oldTapeLabel.dumpid
250                     && (oldTapeLabel.dumpid == lastDump.id)) {
251                     ErrorLog(0, taskId, 0, 0,
252                              "Warning: Overwriting most recent dump %s (DumpID %u)\n",
253                              lastDump.name, lastDump.id);
254                 }
255
256             }
257         }
258
259         GetNewLabel(tapeInfoPtr, oldTapeLabel.pName, tapeName, &newLabel);
260         newLabel.expirationDate = expires;
261         newLabel.useCount = oldTapeLabel.useCount + 1;
262         newLabel.dumpid = dumpid;
263         newLabel.size = tapeInfoPtr->tapeSize;
264
265         code = butm_Create(tapeInfoPtr, &newLabel, 1);  /* rewind tape */
266         if (code) {
267             TapeLog(0, taskId, code, tapeInfoPtr->error,
268                     "Can't label tape\n");
269             goto getNewTape;
270         }
271
272         *wroteLabel = 1;
273
274         /* Initialize a tapeEntry for later inclusion into the database */
275         listEntryPtr =
276             (struct tapeEntryList *)malloc(sizeof(struct tapeEntryList));
277         if (!listEntryPtr)
278             ERROR_EXIT(TC_NOMEMORY);
279         memset(listEntryPtr, 0, sizeof(struct tapeEntryList));
280
281         /* Remember dumpid so we can delete it later */
282         if ((oldTapeLabel.structVersion >= TAPE_VERSION_3)
283             && oldTapeLabel.dumpid)
284             listEntryPtr->oldDumpId = oldTapeLabel.dumpid;
285
286         /* Fill in tape entry so we can save it later */
287         strcpy(tapeEntryPtr->name, TNAME(&newLabel));
288         tapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
289         tapeEntryPtr->written = newLabel.creationTime;
290         tapeEntryPtr->expires = expires;
291         tapeEntryPtr->seq = sequence;
292         tapeEntryPtr->useCount = oldTapeLabel.useCount + 1;
293         tapeEntryPtr->dump = dumpid;
294         tapeEntryPtr->useKBytes = 0;
295         tapeEntryPtr->labelpos = 0;
296
297         /* Thread onto end of single-linked list */
298         if (listEntryHead) {
299             endList = listEntryHead;
300             while (endList->next)
301                 endList = endList->next;
302             endList->next = listEntryPtr;
303         } else
304             listEntryHead = listEntryPtr;
305     }                           /*w */
306
307   error_exit:
308     return (code);
309 }
310
311 /* freeTapeList
312  *       With the list of tapes, free the structures.
313  */
314
315 afs_int32
316 freeTapeList(void)
317 {
318     struct tapeEntryList *next;
319
320     listEntryPtr = listEntryHead;
321     while (listEntryPtr) {
322         next = listEntryPtr->next;
323         free(listEntryPtr);
324         listEntryPtr = next;
325     }
326
327     listEntryHead = NULL;
328     return (0);
329 }
330
331 /* addTapesToDb
332  *       With the list of tapes, add them to the database.
333  *       Also delete any olddumpids that are around.
334  */
335
336 afs_int32
337 addTapesToDb(afs_int32 taskId)
338 {
339     afs_int32 code = 0;
340     afs_int32 i, new;
341     struct tapeEntryList *next;
342
343     listEntryPtr = listEntryHead;
344     while (listEntryPtr) {
345         next = listEntryPtr->next;
346
347         /* Remove the old database entry */
348         if (listEntryPtr->oldDumpId) {
349             i = bcdb_deleteDump(listEntryPtr->oldDumpId, 0, 0, 0);
350             if (i && (i != BUDB_NOENT)) {
351                 ErrorLog(0, taskId, i, 0,
352                          "Unable to delete old DB entry %u.\n",
353                          listEntryPtr->oldDumpId);
354             }
355         }
356
357         /* Add the tape to the database */
358         code = bcdb_UseTape(tapeEntryPtr, &new);
359         if (code) {
360             ErrorLog(0, taskId, code, 0, "Can't add tape to database: %s\n",
361                      tapeEntryPtr->name);
362             ERROR_EXIT(code);
363         }
364
365         code = bcdb_FinishTape(tapeEntryPtr);
366         if (code) {
367             ErrorLog(0, taskId, code, 0, "Can't finish tape: %s\n",
368                      tapeEntryPtr->name);
369             ERROR_EXIT(code);
370         }
371
372         listEntryPtr = next;
373     }
374
375   error_exit:
376     return (code);
377 }
378
379 /* writeDbDump
380  * notes:
381  *      this code assumes that the blocksize on reads is smaller than
382  *      the blocksize on writes
383  */
384
385 static int
386 writeDbDump(struct butm_tapeInfo *tapeInfoPtr, afs_uint32 taskId,
387             Date expires, afs_uint32 dumpid)
388 {
389     afs_int32 blockSize;
390     afs_int32 writeBufNbytes = 0;
391     char *writeBlock = 0;
392     char *writeBuffer = 0;
393     char *writeBufPtr;
394     afs_int32 transferSize;
395
396     char *readBufPtr = NULL;
397     afs_int32 maxReadSize;
398
399     charListT charList;
400     afs_int32 done;
401     afs_int32 code;
402     afs_int32 chunksize = 0;
403     afs_int32 tc_EndMargin, tc_KEndMargin, kRemaining;
404     int sequence;
405     int wroteLabel;
406     int firstcall;
407 #ifdef AFS_PTHREAD_ENV
408     pthread_t alivePid;
409     pthread_attr_t tattr;
410     AFS_SIGSET_DECL;
411 #else
412     PROCESS alivePid;
413 #endif
414
415     extern struct tapeConfig globalTapeConfig;
416     extern struct udbHandleS udbHandle;
417
418     blockSize = BUTM_BLKSIZE;
419     writeBlock = (char *)malloc(BUTM_BLOCKSIZE);
420     if (!writeBlock)
421         ERROR_EXIT(TC_NOMEMORY);
422
423     writeBuffer = writeBlock + sizeof(struct blockMark);
424     memset(writeBuffer, 0, BUTM_BLKSIZE);
425     maxReadSize = 1024;
426
427     /*
428      * The margin of space to check for end of tape is set to the
429      * amount of space used to write an end-of-tape multiplied by 2.
430      * The amount of space is size of a 16K EODump marker, its EOF
431      * marker, and up to two EOF markers done on close (1 16K blocks +
432      * 3 EOF * markers).
433      */
434     tc_EndMargin = (16384 + 3 * globalTapeConfig.fileMarkSize) * 2;
435     tc_KEndMargin = tc_EndMargin / 1024;
436
437     /* have to write enclose the dump in file marks */
438     code = butm_WriteFileBegin(tapeInfoPtr);
439     if (code) {
440         ErrorLog(0, taskId, code, tapeInfoPtr->error,
441                  "Can't write FileBegin on tape\n");
442         ERROR_EXIT(code);
443     }
444
445     writeBufPtr = &writeBuffer[0];
446     firstcall = 1;
447     sequence = 1;
448     charList.charListT_val = 0;
449     charList.charListT_len = 0;
450
451     while (1) {                 /*w */
452         /* When no data in buffer, read data from the budb_server */
453         if (charList.charListT_len == 0) {
454             /* get more data. let rx allocate space */
455             if (charList.charListT_val) {
456                 free(charList.charListT_val);
457                 charList.charListT_val = 0;
458             }
459
460             /* get the data */
461             code =
462                 ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
463                                        UF_SINGLESERVER, firstcall,
464                                        maxReadSize, &charList, &done);
465             if (code) {
466                 ErrorLog(0, taskId, code, 0, "Can't read database\n");
467                 ERROR_EXIT(code);
468             }
469
470             /* If this if the first call to the budb server, create a thread
471              * that will keep the connection alive (during tape changes).
472              */
473             if (firstcall) {
474 #ifdef AFS_PTHREAD_ENV
475                 code = pthread_attr_init(&tattr);
476                 if (code) {
477                     ErrorLog(0, taskId, code, 0,
478                              "Can't pthread_attr_init Keep-alive process\n");
479                     ERROR_EXIT(code);
480                 }
481
482                 code =
483                     pthread_attr_setdetachstate(&tattr,
484                                                 PTHREAD_CREATE_DETACHED);
485                 if (code) {
486                     ErrorLog(0, taskId, code, 0,
487                              "Can't pthread_attr_setdetachstate Keep-alive process\n");
488                     ERROR_EXIT(code);
489                 }
490
491                 AFS_SIGSET_CLEAR();
492                 code = pthread_create(&alivePid, &tattr, KeepAlive, 0);
493                 AFS_SIGSET_RESTORE();
494 #else
495                 code =
496                     LWP_CreateProcess(KeepAlive, 16384, 1, (void *)NULL,
497                                       "Keep-alive process", &alivePid);
498 #endif
499                 /* XXX should we check code here ??? XXX */
500             }
501             firstcall = 0;
502
503             readBufPtr = charList.charListT_val;
504         }
505
506         if ((charList.charListT_len == 0) && done)
507             break;
508
509         /* compute how many bytes and transfer to the write Buffer */
510         transferSize =
511             (charList.charListT_len <
512              (blockSize -
513               writeBufNbytes)) ? charList.charListT_len : (blockSize -
514                                                            writeBufNbytes);
515
516         memcpy(writeBufPtr, readBufPtr, transferSize);
517         charList.charListT_len -= transferSize;
518         writeBufPtr += transferSize;
519         readBufPtr += transferSize;
520         writeBufNbytes += transferSize;
521
522         /* If filled the write buffer, then write it to tape */
523         if (writeBufNbytes == blockSize) {
524             code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
525             if (code) {
526                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
527                          "Can't write data on tape\n");
528                 ERROR_EXIT(code);
529             }
530
531             memset(writeBuffer, 0, blockSize);
532             writeBufPtr = &writeBuffer[0];
533             writeBufNbytes = 0;
534
535             /* Every BIGCHUNK bytes check if aborted */
536             chunksize += blockSize;
537             if (chunksize > BIGCHUNK) {
538                 chunksize = 0;
539                 if (checkAbortByTaskId(taskId))
540                     ERROR_EXIT(TC_ABORTEDBYREQUEST);
541             }
542
543             /*
544              * check if tape is full - since we filled a blockSize worth of data
545              * assume that there is more data.
546              */
547             kRemaining = butm_remainingKSpace(tapeInfoPtr);
548             if (kRemaining < tc_KEndMargin) {
549                 code = butm_WriteFileEnd(tapeInfoPtr);
550                 if (code) {
551                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
552                              "Can't write FileEnd on tape\n");
553                     ERROR_EXIT(code);
554                 }
555
556                 code = butm_WriteEOT(tapeInfoPtr);
557                 if (code) {
558                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
559                              "Can't write end-of-dump on tape\n");
560                     ERROR_EXIT(code);
561                 }
562
563                 /* Mark tape as having been written */
564                 tapeEntryPtr->useKBytes =
565                     tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
566                 tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
567
568                 unmountTape(taskId, tapeInfoPtr);
569
570                 /* Get next tape and writes its label */
571                 sequence++;
572                 code =
573                     GetDBTape(taskId, expires, tapeInfoPtr, dumpid, sequence,
574                               1, &wroteLabel);
575                 if (code)
576                     ERROR_EXIT(code);
577
578                 code = butm_WriteFileBegin(tapeInfoPtr);
579                 if (code) {
580                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
581                              "Can't write FileBegin on tape\n");
582                     ERROR_EXIT(code);
583                 }
584             }
585         }
586     }                           /*w */
587
588     /* no more data to be read - if necessary, flush out the last buffer */
589     if (writeBufNbytes > 0) {
590         code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
591         if (code) {
592             ErrorLog(1, taskId, code, tapeInfoPtr->error,
593                      "Can't write data on tape\n");
594             ERROR_EXIT(code);
595         }
596     }
597
598     code = butm_WriteFileEnd(tapeInfoPtr);
599     if (code) {
600         ErrorLog(0, taskId, code, tapeInfoPtr->error,
601                  "Can't write FileEnd on tape\n");
602         ERROR_EXIT(code);
603     }
604
605     /* Mark tape as having been written */
606     tapeEntryPtr->useKBytes =
607         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
608     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
609
610   error_exit:
611     /* Let the KeepAlive process stop on its own */
612     code =
613         ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
614                                UF_END_SINGLESERVER, 0);
615
616     if (writeBlock)
617         free(writeBlock);
618     if (charList.charListT_val)
619         free(charList.charListT_val);
620     return (code);
621 }
622
623 /* saveDbToTape
624  *      dump backup database to tape
625  */
626
627 void *
628 saveDbToTape(void *param)
629 {
630     struct saveDbIf *saveDbIfPtr = (struct saveDbIf *)param;
631     afs_int32 code = 0;
632     afs_int32 i;
633     int wroteLabel;
634     afs_uint32 taskId;
635     Date expires;
636
637     struct butm_tapeInfo tapeInfo;
638     struct budb_dumpEntry dumpEntry;
639
640     extern struct deviceSyncNode *deviceLatch;
641     extern struct tapeConfig globalTapeConfig;
642
643     afs_pthread_setname_self("Db save");
644     expires = (saveDbIfPtr->archiveTime ? NEVERDATE : 0);
645     taskId = saveDbIfPtr->taskId;
646
647     setStatus(taskId, DRIVE_WAIT);
648     EnterDeviceQueue(deviceLatch);      /* lock tape device */
649     clearStatus(taskId, DRIVE_WAIT);
650
651     printf("\n\n");
652     TLog(taskId, "SaveDb\n");
653
654     tapeInfo.structVersion = BUTM_MAJORVERSION;
655     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
656     if (code) {
657         ErrorLog(0, taskId, code, tapeInfo.error,
658                  "Can't initialize tape module\n");
659         ERROR_EXIT(code);
660     }
661
662     /* Determine what the last database dump was */
663     memset(&lastDump, 0, sizeof(lastDump));
664     code = bcdb_FindLatestDump("", "", &lastDump);
665     if (code) {
666         if (code != BUDB_NODUMPNAME) {
667             ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
668             ERROR_EXIT(code);
669         }
670         memset(&lastDump, 0, sizeof(lastDump));
671     }
672
673     code = CreateDBDump(&dumpEntry);    /* Create a dump for this tape */
674     if (code) {
675         ErrorLog(0, taskId, code, 0, "Can't create dump in database\n");
676         ERROR_EXIT(code);
677     }
678
679
680     listEntryHead = NULL;
681
682     /* Get the tape and write a new label to it */
683     code =
684         GetDBTape(taskId, expires, &tapeInfo, dumpEntry.id, 1, autoQuery,
685                   &wroteLabel);
686
687     /*
688      * If did not write the label, remove created dump
689      * Else if wrote the label, remove old dump from db so it's not saved.
690      */
691     if (!wroteLabel) {
692         i = bcdb_deleteDump(dumpEntry.id, 0, 0, 0);
693         dumpEntry.id = 0;
694         if (i && (i != BUDB_NOENT))
695             ErrorLog(0, taskId, i, 0, "Unable to delete DB entry %u.\n",
696                      dumpEntry.id);
697     } else if (listEntryHead->oldDumpId) {
698         i = bcdb_deleteDump(listEntryHead->oldDumpId, 0, 0, 0);
699         listEntryHead->oldDumpId = 0;
700         if (i && (i != BUDB_NOENT)) {
701             ErrorLog(0, taskId, i, 0, "Unable to delete old DB entry %u.\n",
702                      listEntryHead->oldDumpId);
703             ERROR_EXIT(i);
704         }
705     }
706     if (code)
707         ERROR_EXIT(code);
708
709     TapeLog(1, taskId, 0, 0, "Tape accepted - now dumping database\n");
710
711     /* we have a writable tape */
712     code = writeDbDump(&tapeInfo, taskId, expires, dumpEntry.id);
713     if (code)
714         ERROR_EXIT(code);
715
716     /* Now delete the entries between time 0 and archive-time */
717     if (saveDbIfPtr->archiveTime)
718         code = bcdb_deleteDump(0, 0, saveDbIfPtr->archiveTime, 0);
719
720   error_exit:
721     unmountTape(taskId, &tapeInfo);
722
723     /* Add this dump's tapes to the database and mark it finished */
724     if (dumpEntry.id) {
725         i = addTapesToDb(taskId);
726         if (!code)
727             code = i;
728
729         i = bcdb_FinishDump(&dumpEntry);
730         if (!code)
731             code = i;
732     }
733     freeTapeList();
734
735     if (code == TC_ABORTEDBYREQUEST) {
736         TLog(taskId, "SaveDb: Aborted by request\n");
737         clearStatus(taskId, ABORT_REQUEST);
738         setStatus(taskId, ABORT_DONE);
739     } else if (code) {
740         TapeLog(0, taskId, code, 0, "SaveDb: Finished with errors\n");
741         setStatus(taskId, TASK_ERROR);
742     } else {
743         TLog(taskId, "SaveDb: Finished\n");
744     }
745     setStatus(taskId, TASK_DONE);
746
747     free(saveDbIfPtr);
748     LeaveDeviceQueue(deviceLatch);
749     return (void *)(intptr_t)(code);
750 }
751
752
753 /* makeDbDumpEntry()
754  *      Make a database dump entry given a tape label.
755  */
756
757 afs_int32
758 makeDbDumpEntry(struct budb_tapeEntry *tapeEntPtr,
759                 struct budb_dumpEntry *dumpEntryPtr)
760 {
761     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
762
763     dumpEntryPtr->id = tapeEntPtr->dump;
764     dumpEntryPtr->initialDumpID = 0;
765     dumpEntryPtr->parent = 0;
766     dumpEntryPtr->level = 0;
767     dumpEntryPtr->flags = 0;
768
769     strcpy(dumpEntryPtr->volumeSetName, "");
770     strcpy(dumpEntryPtr->dumpPath, "");
771     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
772
773     dumpEntryPtr->created = tapeEntPtr->dump;
774     dumpEntryPtr->incTime = 0;
775     dumpEntryPtr->nVolumes = 0;
776
777     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
778     strcat(dumpEntryPtr->tapes.format, ".%d");
779     dumpEntryPtr->tapes.b = tapeEntPtr->seq;
780     dumpEntryPtr->tapes.maxTapes = 0;
781     return 0;
782 }
783
784 /* readDbTape
785  *      prompt for a specific database tape
786  */
787
788 afs_int32
789 readDbTape(struct butm_tapeInfo *tapeInfoPtr,
790            struct rstTapeInfo *rstTapeInfoPtr, int query)
791 {
792     afs_int32 code = 0;
793     int interactiveFlag;
794     afs_int32 taskId;
795     struct butm_tapeLabel oldTapeLabel;
796     char AFStapeName[BU_MAXTAPELEN], tapeName[BU_MAXTAPELEN];
797     struct tapeEntryList *endList;
798     int tapecount = 1;
799     struct budb_dumpEntry de;
800     struct budb_tapeEntry te;
801
802     taskId = rstTapeInfoPtr->taskId;
803     interactiveFlag = query;
804
805     /* construct the name of the tape */
806     sprintf(AFStapeName, "%s.%-d", DUMP_TAPE_NAME, rstTapeInfoPtr->tapeSeq);
807     strcpy(tapeName, AFStapeName);
808
809     /* Will prompt for the latest saved database tape, but will accept any one */
810     if (rstTapeInfoPtr->tapeSeq == 1) {
811         code = bcdb_FindLatestDump("", "", &de);
812         if (!code)
813             rstTapeInfoPtr->dumpid = de.id;
814     }
815     if (rstTapeInfoPtr->dumpid) {
816         code =
817             bcdb_FindTapeSeq(rstTapeInfoPtr->dumpid, rstTapeInfoPtr->tapeSeq,
818                              &te);
819         if (!code)
820             strcpy(tapeName, te.name);
821     }
822     code = 0;
823
824     while (1) {                 /*w */
825         if (interactiveFlag) {  /* need a tape to read */
826             code =
827                 PromptForTape(RESTOREDBOPCODE, tapeName,
828                               rstTapeInfoPtr->dumpid, taskId, tapecount);
829             if (code)
830                 ERROR_EXIT(code);
831         }
832         interactiveFlag = 1;
833         tapecount++;
834
835         code = butm_Mount(tapeInfoPtr, tapeName);
836         if (code) {
837             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
838             goto getNewTape;
839         }
840
841         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* will rewind the tape */
842         if (code) {
843             TapeLog(0, taskId, code, tapeInfoPtr->error,
844                     "Can't read tape label\n");
845             goto getNewTape;
846         }
847
848         /* Check for name of tape and matching dump id (if applicable). */
849         if ((strcmp(oldTapeLabel.AFSName, AFStapeName) != 0)
850             || ((rstTapeInfoPtr->tapeSeq != 1)
851                 && (oldTapeLabel.dumpid != rstTapeInfoPtr->dumpid))) {
852             char expTape[BU_MAXTAPELEN + 32];
853             char gotTape[BU_MAXTAPELEN + 32];
854
855             TAPENAME(expTape, tapeName, rstTapeInfoPtr->dumpid);
856             TAPENAME(gotTape, oldTapeLabel.AFSName, oldTapeLabel.dumpid);
857
858             TLog(taskId, "Tape label expected %s, label seen %s\n", expTape,
859                  gotTape);
860             goto getNewTape;
861         }
862
863         if (rstTapeInfoPtr->tapeSeq == 1)       /* Remember this dumpId */
864             rstTapeInfoPtr->dumpid = oldTapeLabel.dumpid;
865
866         break;
867
868       getNewTape:
869         unmountTape(taskId, tapeInfoPtr);
870     }                           /*w */
871
872
873     /* Initialize a tapeEntry for later inclusion into the database */
874     listEntryPtr =
875         (struct tapeEntryList *)malloc(sizeof(struct tapeEntryList));
876     if (!listEntryPtr)
877         ERROR_EXIT(TC_NOMEMORY);
878     memset(listEntryPtr, 0, sizeof(struct tapeEntryList));
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 = (udbClientTextP) malloc(sizeof(*ctPtr));
1352     if (!ctPtr)
1353         ERROR_EXIT(TC_NOMEMORY);
1354
1355     memset(ctPtr, 0, sizeof(*ctPtr));
1356     ctPtr->textType = textType;
1357
1358     /* lock the text in the database */
1359     code = bc_LockText(ctPtr);
1360     if (code) {
1361         ErrorLog(0, taskId, code, 0, "Can't lock text file\n");
1362         ERROR_EXIT(code);
1363     }
1364     tlock = 1;
1365
1366     ctPtr->textStream = fopen(fileName, "r");
1367     if (!ctPtr->textStream) {
1368         ErrorLog(0, taskId, errno, 0, "Can't open text file\n");
1369         ERROR_EXIT(errno);
1370     }
1371
1372     /* now send the text to the database */
1373     code = bcdb_SaveTextFile(ctPtr);
1374     if (code) {
1375         ErrorLog(0, taskId, code, 0, "Can't save text file\n");
1376         ERROR_EXIT(code);
1377     }
1378
1379   error_exit:
1380     if (ctPtr) {
1381         if (ctPtr->textStream)
1382             fclose(ctPtr->textStream);
1383         if (tlock)
1384             bc_UnlockText(ctPtr);
1385         free(ctPtr);
1386     }
1387     return (code);
1388 }
1389
1390 /* restoreText
1391  *      read the text off the tape, and store it in the appropriate
1392  *      text type in the database.
1393  * entry:
1394  *      nextHeader - ptr to struct for return information
1395  * exit:
1396  *      nextHeader - struct header for next item on the tape
1397  */
1398
1399 int
1400 restoreText(struct butm_tapeInfo *tapeInfo,
1401             struct rstTapeInfo *rstTapeInfoPtr,
1402             struct structDumpHeader *nextHeader)
1403 {
1404     char filename[64];
1405     afs_int32 nbytes;
1406     char *readBuffer = 0;
1407     afs_int32 readBlockSize;
1408     afs_int32 transferSize;
1409     struct structDumpHeader netItemHeader;
1410     int fid = -1;
1411     afs_int32 code = 0;
1412
1413     udbClientTextP ctPtr = 0;
1414     afs_int32 textType;
1415
1416     ctPtr = (udbClientTextP) malloc(sizeof(*ctPtr));
1417     if (!ctPtr)
1418         ERROR_EXIT(TC_NOMEMORY);
1419
1420     /* determine the type of text block */
1421     switch (nextHeader->type) {
1422     case SD_TEXT_DUMPSCHEDULE:
1423         textType = TB_DUMPSCHEDULE;
1424         break;
1425
1426     case SD_TEXT_VOLUMESET:
1427         textType = TB_VOLUMESET;
1428         break;
1429
1430     case SD_TEXT_TAPEHOSTS:
1431         textType = TB_TAPEHOSTS;
1432         break;
1433
1434     default:
1435         ErrorLog(0, rstTapeInfoPtr->taskId, TC_INTERNALERROR, 0,
1436                  "Unknown text block\n");
1437         ERROR_EXIT(TC_INTERNALERROR);
1438         break;
1439     }
1440
1441     /* open the text file */
1442     sprintf(filename, "%s/bu_XXXXXX", gettmpdir());
1443     fid = mkstemp(filename);
1444     if (fid < 0) {
1445         ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1446                  "Can't open temporary text file: %s\n", filename);
1447         ERROR_EXIT(errno);
1448     }
1449
1450     /* allocate buffer for text */
1451     readBlockSize = BUTM_BLKSIZE;
1452     readBuffer = (char *)malloc(readBlockSize);
1453     if (!readBuffer)
1454         ERROR_EXIT(TC_NOMEMORY);
1455
1456     /* read the text into the temporary file */
1457     nbytes = nextHeader->size;
1458     while (nbytes > 0) {
1459         transferSize = (readBlockSize < nbytes) ? readBlockSize : nbytes;
1460
1461         /* read it from the tape */
1462         code =
1463             getTapeData(tapeInfo, rstTapeInfoPtr, readBuffer, transferSize);
1464         if (code)
1465             ERROR_EXIT(code);
1466
1467         /* write to the file */
1468         if (write(fid, readBuffer, transferSize) != transferSize) {
1469             ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1470                      "Can't write temporary text file: %s\n", filename);
1471             ERROR_EXIT(errno);
1472         }
1473
1474         nbytes -= transferSize;
1475     }
1476
1477     close(fid);
1478     fid = -1;
1479     code = saveTextFile(rstTapeInfoPtr->taskId, textType, filename);
1480     if (code)
1481         ERROR_EXIT(code);
1482     unlink(filename);
1483
1484     /* get the next item-header */
1485     memset(nextHeader, 0, sizeof(*nextHeader));
1486     code =
1487         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1488                     sizeof(netItemHeader));
1489     if (code)
1490         ERROR_EXIT(code);
1491     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1492
1493   error_exit:
1494     if (ctPtr)
1495         free(ctPtr);
1496     if (readBuffer)
1497         free(readBuffer);
1498     if (fid != -1) {
1499         close(fid);
1500         unlink(filename);
1501     }
1502     return (code);
1503 }
1504
1505
1506 /* ----------------------------------
1507  * Tape data buffering - for reading database dumps
1508  * ----------------------------------
1509  */
1510
1511 static char *tapeReadBuffer = 0;        /* input buffer */
1512 static char *tapeReadBufferPtr = 0;     /* position in buffer */
1513
1514 /* getTapeData
1515  *      Read information from tape, and place the requested number of bytes
1516  *      in the buffer supplied
1517  * entry:
1518  *      tapeInfo
1519  *      rstTapeInfoPtr - Info about the dump being restored.
1520  *      buffer - buffer for requested data
1521  *      requestedBytes - no. of bytes requested
1522  * exit:
1523  *      fn retn - 0, ok, n, error
1524  */
1525
1526 int
1527 getTapeData(struct butm_tapeInfo *tapeInfoPtr,
1528             struct rstTapeInfo *rstTapeInfoPtr,
1529             void *out, afs_int32 requestedBytes)
1530 {
1531     char *buffer = (char *) out;
1532     afs_int32 taskId, transferBytes;
1533     afs_int32 code = 0;
1534
1535     taskId = rstTapeInfoPtr->taskId;
1536
1537     if (checkAbortByTaskId(taskId))
1538         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1539
1540     if (!tapeReadBuffer) {
1541         tapeReadBuffer = (char *)malloc(BUTM_BLOCKSIZE);
1542         if (!tapeReadBuffer)
1543             ERROR_EXIT(TC_NOMEMORY);
1544     }
1545
1546     while (requestedBytes > 0) {
1547         if (nbytes == 0) {
1548             tapeReadBufferPtr = &tapeReadBuffer[sizeof(struct blockMark)];
1549
1550             /* get more data */
1551             code =
1552                 butm_ReadFileData(tapeInfoPtr, tapeReadBufferPtr,
1553                                   BUTM_BLKSIZE, &nbytes);
1554             if (code) {
1555                 /* detect if we hit the end-of-tape and get next tape */
1556                 if (code == BUTM_ENDVOLUME) {
1557                     /* Update fields in tape entry for this tape */
1558                     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
1559                     tapeEntryPtr->useKBytes =
1560                         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
1561
1562                     unmountTape(taskId, tapeInfoPtr);
1563
1564                     rstTapeInfoPtr->tapeSeq++;
1565                     code = readDbTape(tapeInfoPtr, rstTapeInfoPtr, 1);
1566                     if (code)
1567                         ERROR_EXIT(code);
1568
1569                     code = butm_ReadFileBegin(tapeInfoPtr);
1570                     if (code) {
1571                         ErrorLog(0, taskId, code, tapeInfoPtr->error,
1572                                  "Can't read FileBegin on tape\n");
1573                         ERROR_EXIT(code);
1574                     }
1575
1576                     continue;
1577                 }
1578
1579                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
1580                          "Can't read FileData on tape\n");
1581                 ERROR_EXIT(code);
1582             }
1583         }
1584
1585         /* copy out data */
1586         transferBytes = (nbytes < requestedBytes) ? nbytes : requestedBytes;
1587         memcpy(buffer, tapeReadBufferPtr, transferBytes);
1588         tapeReadBufferPtr += transferBytes;
1589         buffer += transferBytes;
1590         nbytes -= transferBytes;
1591         requestedBytes -= transferBytes;
1592     }
1593
1594   error_exit:
1595     return (code);
1596 }