?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge 1.8.0~pre4 packaging into master
[pkg-k5-afs_openafs.git] / src / budb / procs.c
blobf2987d3115cfb07ad08d37bd744ea686d66355c1
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 /* TBD
11 * ht_lookupEntry - tape ids
12 * Truncate Tape - tape id's
13 * usetape - tape id's
14 */
15
16 #include <afsconfig.h>
17 #include <afs/param.h>
18
19 #include <roken.h>
20
21 #include <afs/stds.h>
22 #include <afs/bubasics.h>
23 #include <lock.h>
24 #include <ubik.h>
25 #include <lwp.h>
26 #include <rx/xdr.h>
27 #include <rx/rx.h>
28 #include <rx/rxkad.h>
29 #include <afs/cellconfig.h>
30 #include <afs/auth.h>
31 #include <afs/audit.h>
32 #include <afs/afsutil.h>
33
34 #include "budb.h"
35 #include "budb_errs.h"
36 #include "database.h"
37 #include "budb_internal.h"
38 #include "error_macros.h"
39 #include "globals.h"
40
41 #undef min
42 #undef max
43
44
45 extern struct ubik_dbase *BU_dbase;
46 extern struct afsconf_dir *BU_conf; /* for getting cell info */
47
48 afs_int32 AddVolume(struct rx_call *, struct budb_volumeEntry *);
49 afs_int32 AddVolumes(struct rx_call *, struct budb_volumeList *);
50 afs_int32 CreateDump(struct rx_call *, struct budb_dumpEntry *);
51 afs_int32 DoDeleteDump(struct rx_call *, dumpId, Date, Date, budb_dumpsList *);
52 afs_int32 DoDeleteTape(struct rx_call *, struct budb_tapeEntry *);
53 afs_int32 ListDumps(struct rx_call *, afs_int32, afs_int32, Date, Date,
54 budb_dumpsList *, budb_dumpsList *);
55 afs_int32 DeleteVDP(struct rx_call *, char *, char *, afs_int32);
56 afs_int32 FindClone(struct rx_call *, afs_int32, char *, afs_int32 *);
57 afs_int32 FindDump(struct rx_call *, char *, afs_int32,
58 struct budb_dumpEntry *);
59 afs_int32 FindLatestDump(struct rx_call *, char *, char *,
60 struct budb_dumpEntry *);
61 afs_int32 FinishDump(struct rx_call *, struct budb_dumpEntry *);
62 afs_int32 FinishTape(struct rx_call *, struct budb_tapeEntry *);
63 afs_int32 GetDumps(struct rx_call *, afs_int32, afs_int32, char *,
64 afs_int32, afs_int32, afs_int32, afs_int32 *,
65 afs_int32 *, budb_dumpList *);
66 afs_int32 getExpiration(struct ubik_trans *ut, struct tape *);
67 afs_int32 makeAppended(struct ubik_trans *ut, afs_int32, afs_int32,
68 afs_int32);
69 afs_int32 MakeDumpAppended(struct rx_call *, afs_int32, afs_int32,
70 afs_int32);
71 afs_int32 FindLastTape(struct rx_call *, afs_int32, struct budb_dumpEntry *,
72 struct budb_tapeEntry *, struct budb_volumeEntry *);
73 afs_int32 GetTapes(struct rx_call *, afs_int32, afs_int32, char *, afs_int32,
74 afs_int32, afs_int32, afs_int32 *, afs_int32 *,
75 budb_tapeList *);
76 afs_int32 GetVolumes(struct rx_call *, afs_int32, afs_int32, char *,
77 afs_int32, afs_int32, afs_int32, afs_int32 *,
78 afs_int32 *, budb_volumeList *);
79 afs_int32 UseTape(struct rx_call *, struct budb_tapeEntry *, int *);
80 afs_int32 T_DumpHashTable(struct rx_call *, int, char *);
81 afs_int32 T_GetVersion(struct rx_call *, int *);
82 afs_int32 T_DumpDatabase(struct rx_call *, char *);
83
84 int volFragsDump(struct ubik_trans *, FILE *, dbadr);
85
86 /* Text block management */
87
88 struct memTextBlock {
89 struct memTextBlock *mtb_next; /* next in chain */
90 afs_int32 mtb_nbytes; /* # of bytes in this block */
91 struct blockHeader mtb_blkHeader; /* in memory header */
92 dbadr mtb_addr; /* disk address of block */
93 };
94
95 typedef struct memTextBlock memTextBlockT;
96 typedef memTextBlockT *memTextBlockP;
97
98 /* These variable are for returning debugging info about the state of the
99 server. If they get trashed during multi-threaded operation it doesn't
100 matter. */
101
102 /* This is global so COUNT_REQ in krb_udp.c can refer to it. */
103 char *lastOperation; /* name of last operation */
104 static Date lastTrans; /* time of last transaction */
105
106 /* procsInited is sort of a lock: during a transaction only one process runs
107 while procsInited is false. */
108
109 static int procsInited = 0;
110
111 /* This variable is protected by the procsInited flag. */
112
113 static int (*rebuildDatabase) (struct ubik_trans *);
114
115 /* AwaitInitialization
116 * Wait unitl budb has initialized (InitProcs). If it hasn't
117 * within 5 seconds, then return no quorum.
118 */
119 afs_int32
120 AwaitInitialization(void)
121 {
122 afs_int32 start = 0;
123
124 while (!procsInited) {
125 if (!start)
126 start = time(0);
127 else if (time(0) - start > 5)
128 return UNOQUORUM;
129 #ifdef AFS_PTHREAD_ENV
130 sleep(1);
131 #else
132 IOMGR_Sleep(1);
133 #endif
134 }
135 return 0;
136 }
137
138 /* tailCompPtr
139 * name is a pathname style name, determine trailing name and return
140 * pointer to it
141 */
142
143 char *
144 tailCompPtr(char *pathNamePtr)
145 {
146 char *ptr;
147 ptr = strrchr(pathNamePtr, '/');
148 if (ptr == 0) {
149 /* this should never happen */
150 LogError(0, "tailCompPtr: could not find / in name(%s)\n",
151 pathNamePtr);
152 return (pathNamePtr);
153 } else
154 ptr++; /* skip the / */
155 return (ptr);
156 }
157
158 /* callPermitted
159 * Check to see if the caller is a SuperUser.
160 * exit:
161 * 0 - no
162 * 1 - yes
163 */
164
165 int
166 callPermitted(struct rx_call *call)
167 {
168 int permitted = 0;
169 struct afsconf_dir *acdir;
170
171 acdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
172 if (!acdir)
173 return 0;
174
175 if (afsconf_SuperUser(acdir, call, NULL))
176 permitted = 1;
177
178 if (acdir)
179 afsconf_Close(acdir);
180 return (permitted);
181 }
182
183 /* InitRPC
184 * This is called by every RPC interface to create a Ubik transaction
185 * and read the database header into core
186 * entry:
187 * ut
188 * lock
189 * this_op
190 * notes:
191 * sets a lock on byte 1 of the database. Looks like it enforces
192 * single threading by use of the lock.
193 */
194
195 afs_int32
196 InitRPC(struct ubik_trans **ut,
197 int lock, /* indicate read/write transaction */
198 int this_op) /* opcode of RCP, for COUNT_ABO */
199 {
200 int code;
201 float wait = 0.91; /* start waiting for 1 second */
202
203 start:
204 /* wait for server initialization to finish if this is not InitProcs calling */
205 if (this_op)
206 if ((code = AwaitInitialization()))
207 return code;
208
209 for (code = UNOQUORUM; code == UNOQUORUM;) {
210 code =
211 ubik_BeginTrans(BU_dbase,
212 ((lock ==
213 LOCKREAD) ? UBIK_READTRANS : UBIK_WRITETRANS),
214 ut);
215 if (code == UNOQUORUM) { /* no quorum elected */
216 if (wait < 1)
217 Log("Waiting for quorum election\n");
218 if (wait < 15.0)
219 wait *= 1.1;
220 #ifdef AFS_PTHREAD_ENV
221 sleep((int)wait);
222 #else
223 IOMGR_Sleep((int)wait);
224 #endif
225 }
226 }
227 if (code)
228 return code;
229 if (wait > 1)
230 Log("Have established quorum\n");
231
232 /* set lock at posiion 1, for 1 byte of type lock */
233 if ((code = ubik_SetLock(*ut, 1, 1, lock))) {
234 ubik_AbortTrans(*ut);
235 return code;
236 }
237
238 /* check that dbase is initialized and setup cheader */
239 if (lock == LOCKREAD) {
240 /* init but don't fix because this is read only */
241 if ((code = CheckInit(*ut, 0))) {
242 ubik_AbortTrans(*ut);
243 if ((code = InitRPC(ut, LOCKWRITE, 0))) { /* Now fix the database */
244 LogError(code, "InitRPC: InitRPC failed\n");
245 return code;
246 }
247 if ((code = ubik_EndTrans(*ut))) {
248 LogError(code, "InitRPC: ubik_EndTrans failed\n");
249 return code;
250 }
251 goto start; /* now redo the read transaction */
252 }
253 } else {
254 if ((code = CheckInit(*ut, rebuildDatabase))) {
255 ubik_AbortTrans(*ut);
256 return code;
257 }
258 }
259 lastTrans = time(0);
260 return 0;
261 }
262
263 /* This is called to initialize a newly created database */
264 static int
265 initialize_database(struct ubik_trans *ut)
266 {
267 return 0;
268 }
269
270 static int noAuthenticationRequired; /* global state */
271 static int recheckNoAuth; /* global state */
272
273 afs_int32
274 InitProcs(void)
275 {
276 struct ubik_trans *ut;
277 afs_int32 code = 0;
278
279 procsInited = 0;
280
281 if ((globalConfPtr->myHost == 0) || (BU_conf == 0))
282 ERROR(BUDB_INTERNALERROR);
283
284 recheckNoAuth = 1;
285
286 if (globalConfPtr->debugFlags & DF_NOAUTH)
287 noAuthenticationRequired = 1;
288
289 if (globalConfPtr->debugFlags & DF_RECHECKNOAUTH)
290 recheckNoAuth = 0;
291
292 if (recheckNoAuth)
293 noAuthenticationRequired = afsconf_GetNoAuthFlag(BU_conf);
294
295 if (noAuthenticationRequired)
296 LogError(0, "Running server with security disabled\n");
297
298 InitDB();
299
300 rebuildDatabase = initialize_database;
301
302 if ((code = InitRPC(&ut, LOCKREAD, 0))) {
303 LogError(code, "InitProcs: InitRPC failed\n");
304 return code;
305 }
306 code = ubik_EndTrans(ut);
307 if (code) {
308 LogError(code, "InitProcs: ubik_EndTrans failed\n");
309 return code;
310 }
311
312 rebuildDatabase = 0; /* only do this during init */
313 procsInited = 1;
314
315 error_exit:
316 return (code);
317 }
318
319 struct returnList {
320 int nElements; /* number in list */
321 int allocSize; /* number of elements allocated */
322 dbadr *elements; /* array of addresses */
323 };
324
325 static void
326 InitReturnList(struct returnList *list)
327 {
328 list->nElements = 0;
329 list->allocSize = 0;
330 list->elements = (dbadr *) 0;
331 }
332
333 static void
334 FreeReturnList(struct returnList *list)
335 {
336 if (list->elements)
337 free(list->elements);
338 list->elements = (dbadr *) 0;
339 list->nElements = 0;
340 }
341
342 /* As entries are collected, they are added to a return list. Once all
343 * entries have been collected, it is then placed in the return buffer
344 * with SendReturnList(). The first *to_skipP are not recorded.
345 */
346 static afs_int32
347 AddToReturnList(struct returnList *list, dbadr a, afs_int32 *to_skipP)
348 {
349 dbadr *tmp;
350 afs_int32 size;
351
352 if (a == 0)
353 return 0;
354 if (*to_skipP > 0) {
355 (*to_skipP)--;
356 return 0;
357 }
358
359 /* Up to 5 plus a maximum so SendReturnList() knows if we
360 * need to come back for more.
361 */
362 if (list->nElements >= BUDB_MAX_RETURN_LIST + 5)
363 return BUDB_LIST2BIG;
364
365 if (list->nElements >= list->allocSize) {
366 if (list->elements == 0) {
367 size = 10;
368 tmp = malloc(sizeof(dbadr) * size);
369 } else {
370 size = list->allocSize + 10;
371 tmp = realloc(list->elements, sizeof(dbadr) * size);
372 }
373 if (!tmp)
374 return BUDB_NOMEM;
375 list->elements = tmp;
376 list->allocSize = size;
377 }
378
379 list->elements[list->nElements] = a;
380 list->nElements++;
381 return 0;
382 }
383
384 afs_int32
385 FillVolEntry(struct ubik_trans *ut, dbadr va, void *rock)
386 {
387 struct budb_volumeEntry *vol = (struct budb_volumeEntry *) rock;
388 struct dump d;
389 struct tape t;
390 struct volInfo vi;
391 struct volFragment vf;
392
393 if (dbread(ut, va, &vf, sizeof(vf)))
394 return BUDB_IO; /* The volFrag */
395 if (dbread(ut, ntohl(vf.vol), &vi, sizeof(vi)))
396 return BUDB_IO; /* The volInfo */
397 if (dbread(ut, ntohl(vf.tape), &t, sizeof(t)))
398 return BUDB_IO; /* The tape */
399 if (dbread(ut, ntohl(t.dump), &d, sizeof(d)))
400 return BUDB_IO; /* The dump */
401
402 strcpy(vol->name, vi.name);
403 strcpy(vol->server, vi.server);
404 strcpy(vol->tape, t.name);
405 vol->tapeSeq = ntohl(t.seq);
406 vol->dump = ntohl(d.id);
407 vol->position = ntohl(vf.position);
408 vol->clone = ntohl(vf.clone);
409 vol->incTime = ntohl(vf.incTime);
410 vol->nBytes = ntohl(vf.nBytes);
411 vol->startByte = ntohl(vf.startByte);
412 vol->flags = (ntohs(vf.flags) & VOLFRAGMENTFLAGS); /* low 16 bits here */
413 vol->flags |= (ntohl(vi.flags) & VOLINFOFLAGS); /* high 16 bits here */
414 vol->seq = ntohs(vf.sequence);
415 vol->id = ntohl(vi.id);
416 vol->partition = ntohl(vi.partition);
417
418 return 0;
419 }
420
421 afs_int32
422 FillDumpEntry(struct ubik_trans *ut, dbadr da, void *rock)
423 {
424 struct budb_dumpEntry *dump = (struct budb_dumpEntry *)rock;
425 struct dump d, ad;
426
427 if (dbread(ut, da, &d, sizeof(d)))
428 return BUDB_IO;
429 dump->id = ntohl(d.id);
430 dump->flags = ntohl(d.flags);
431 dump->created = ntohl(d.created);
432 strncpy(dump->name, d.dumpName, sizeof(dump->name));
433 strncpy(dump->dumpPath, d.dumpPath, sizeof(dump->dumpPath));
434 strncpy(dump->volumeSetName, d.volumeSet, sizeof(dump->volumeSetName));
435
436 dump->parent = ntohl(d.parent);
437 dump->level = ntohl(d.level);
438 dump->nVolumes = ntohl(d.nVolumes);
439
440 tapeSet_ntoh(&d.tapes, &dump->tapes);
441
442 if (strlen(d.dumper.name) < sizeof(dump->dumper.name))
443 strcpy(dump->dumper.name, d.dumper.name);
444 if (strlen(d.dumper.instance) < sizeof(dump->dumper.instance))
445 strcpy(dump->dumper.instance, d.dumper.instance);
446 if (strlen(d.dumper.cell) < sizeof(dump->dumper.cell))
447 strcpy(dump->dumper.cell, d.dumper.cell);
448
449 /* Get the initial dumpid and the appended dump id */
450 dump->initialDumpID = ntohl(d.initialDumpID);
451 if (d.appendedDumpChain) {
452 if (dbread(ut, ntohl(d.appendedDumpChain), &ad, sizeof(ad)))
453 return BUDB_IO;
454 dump->appendedDumpID = ntohl(ad.id);
455 } else
456 dump->appendedDumpID = 0;
457
458 /* printf("dump name %s, parent %d, level %d\n",
459 * d.dumpName, ntohl(d.parent), ntohl(d.level)); */
460
461 return 0;
462 }
463
464 afs_int32
465 FillTapeEntry(struct ubik_trans *ut, dbadr ta, void *rock)
466 {
467 struct budb_tapeEntry *tape=(struct budb_tapeEntry *) rock;
468 struct tape t;
469 struct dump d;
470 afs_int32 code;
471
472 if (dbread(ut, ta, &t, sizeof(t)))
473 return BUDB_IO;
474
475 /* Get the tape's expiration date */
476 if ((code = getExpiration(ut, &t)))
477 return (code);
478
479 strcpy(tape->name, t.name);
480 tape->flags = ntohl(t.flags);
481 tape->written = ntohl(t.written);
482 tape->expires = ntohl(t.expires);
483 tape->nMBytes = ntohl(t.nMBytes);
484 tape->nBytes = ntohl(t.nBytes);
485 tape->nFiles = ntohl(t.nFiles);
486 tape->nVolumes = ntohl(t.nVolumes);
487 tape->seq = ntohl(t.seq);
488 tape->labelpos = ntohl(t.labelpos);
489 tape->useCount = ntohl(t.useCount);
490 tape->useKBytes = ntohl(t.useKBytes);
491
492 if (dbread(ut, ntohl(t.dump), &d, sizeof(d)))
493 return BUDB_IO;
494 tape->dump = ntohl(d.id);
495 return 0;
496 }
497
498 #define returnList_t budb_dumpList *
499
500 /* SendReturnList
501 * A list of elements of size e_size is in list, collected
502 * with AddToReturnList(). We will move this to a correspoding
503 * return list, eList, via FillProc(). nextInodeP tells us
504 * if there are more and how many to skip on the next request.
505 */
506 static afs_int32
507 SendReturnList(struct ubik_trans *ut,
508 struct returnList *list, /* list of elements to return */
509 afs_int32(*FillProc) (struct ubik_trans *, dbadr da,
510 void *),
511 /* proc to fill entry */
512 int e_size, /* size of each element */
513 afs_int32 index, /* index from previous call */
514 afs_int32 *nextIndexP, /* if more elements are available */
515 afs_int32 *dbTimeP, /* time of last db update */
516 budb_dumpList *eList) /* rxgen list structure (e.g.) */
517 {
518 afs_int32 code;
519 int to_return;
520 int i;
521 char *e;
522
523 *nextIndexP = -1;
524 *dbTimeP = ntohl(db.h.lastUpdate);
525
526 /* Calculate how many to return. Don't let if go over
527 * BUDB_MAX_RETURN_LIST nor the size of our return list.
528 */
529 to_return = list->nElements;
530 if (to_return > BUDB_MAX_RETURN_LIST)
531 to_return = BUDB_MAX_RETURN_LIST;
532 if (eList->budb_dumpList_len && (to_return > eList->budb_dumpList_len))
533 to_return = eList->budb_dumpList_len;
534
535 /* Allocate space for the return values if needed and zero it */
536 if (eList->budb_dumpList_val == 0) {
537 if (to_return > 0) {
538 eList->budb_dumpList_val = calloc(to_return, e_size);
539 if (!eList->budb_dumpList_val)
540 return (BUDB_NOMEM);
541 } else
542 eList->budb_dumpList_val = NULL;
543 } else {
544 memset(eList->budb_dumpList_val, 0, e_size * to_return);
545 }
546
547 eList->budb_dumpList_len = to_return;
548
549 e = (char *)(eList->budb_dumpList_val);
550 for (i = 0; i < to_return; i++, e += e_size) {
551 code = (*FillProc) (ut, list->elements[i], (budb_dumpEntry *) e);
552 if (code)
553 return code;
554 }
555
556 if (list->nElements > i)
557 *nextIndexP = index + i;
558 return 0;
559 }
560
561 /* Come here to delete a volInfo structure. */
562
563 static afs_int32
564 DeleteVolInfo(struct ubik_trans *ut, dbadr via, struct volInfo *vi)
565 {
566 afs_int32 code;
567 dbadr hvia;
568 struct volInfo hvi;
569
570 if (vi->firstFragment)
571 return 0; /* still some frags, don't free yet */
572 if (vi->sameNameHead == 0) { /* this is the head */
573 if (vi->sameNameChain)
574 return 0; /* empty head, some non-heads left */
575
576 code = ht_HashOut(ut, &db.volName, via, vi);
577 if (code)
578 return code;
579 code = FreeStructure(ut, volInfo_BLOCK, via);
580 return code;
581 }
582 hvia = ntohl(vi->sameNameHead);
583 if (dbread(ut, hvia, &hvi, sizeof(hvi)))
584 return BUDB_IO;
585 code =
586 RemoveFromList(ut, hvia, &hvi, &hvi.sameNameChain, via, vi,
587 &vi->sameNameChain);
588 if (code == -1)
589 return BUDB_DATABASEINCONSISTENT;
590 if (code == 0)
591 code = FreeStructure(ut, volInfo_BLOCK, via);
592 return code;
593 }
594
595 /* Detach a volume fragment from its volInfo structure. Its tape chain is
596 already freed. This routine frees the structure and the caller must not
597 write it out. */
598
599 static afs_int32
600 DeleteVolFragment(struct ubik_trans *ut, dbadr va, struct volFragment *v)
601 {
602 afs_int32 code;
603 struct volInfo vi;
604 dbadr via;
605
606 via = ntohl(v->vol);
607 if (dbread(ut, via, &vi, sizeof(vi)))
608 return BUDB_IO;
609 code =
610 RemoveFromList(ut, via, &vi, &vi.firstFragment, va, v,
611 &v->sameNameChain);
612 if (code == -1)
613 return BUDB_DATABASEINCONSISTENT;
614 if (code)
615 return code;
616 if (vi.firstFragment == 0)
617 if ((code = DeleteVolInfo(ut, via, &vi)))
618 return code;
619 if ((code = FreeStructure(ut, volFragment_BLOCK, va)))
620 return code;
621
622 /* decrement frag counter */
623 code =
624 set_word_addr(ut, via, &vi, &vi.nFrags, htonl(ntohl(vi.nFrags) - 1));
625 if (code)
626 return code;
627 return 0;
628 }
629
630 /* DeleteTape - by freeing all its volumes and removing it from its dump chain.
631 * The caller will remove it from the hash table if necessary. The caller is
632 * also responsible for writing the tape out if necessary. */
633
634 static afs_int32
635 DeleteTape(struct ubik_trans *ut, dbadr ta, struct tape *t)
636 {
637 afs_int32 code;
638 struct dump d;
639 dbadr da;
640
641 da = ntohl(t->dump);
642 if (da == 0)
643 return BUDB_DATABASEINCONSISTENT;
644 if (dbread(ut, da, &d, sizeof(d)))
645 return BUDB_IO;
646 if (d.firstTape == 0)
647 return BUDB_DATABASEINCONSISTENT;
648
649 code = RemoveFromList(ut, da, &d, &d.firstTape, ta, t, &t->nextTape);
650 if (code == -1)
651 return BUDB_DATABASEINCONSISTENT;
652 if (code)
653 return code;
654
655 /* Since the tape should have been truncated there should never be any
656 * volumes in the tape. */
657 if (t->firstVol || t->nVolumes)
658 return BUDB_DATABASEINCONSISTENT;
659
660 return 0;
661 }
662
663 static afs_int32
664 DeleteDump(struct ubik_trans *ut, dbadr da, struct dump *d)
665 {
666 afs_int32 code = 0;
667
668 code = ht_HashOut(ut, &db.dumpIden, da, d);
669 if (code)
670 ERROR(code);
671
672 code = ht_HashOut(ut, &db.dumpName, da, d);
673 if (code)
674 ERROR(code);
675
676 /* Since the tape should have been truncated this should never happen. */
677 if (d->firstTape || d->nVolumes)
678 ERROR(BUDB_DATABASEINCONSISTENT);
679
680 code = FreeStructure(ut, dump_BLOCK, da);
681 if (code)
682 ERROR(code);
683
684 error_exit:
685 return code;
686 }
687
688 /*
689 * VolInfoMatch()
690 *
691 * This is called with a volumeEntry and a volInfo structure and compares
692 * them. It returns non-zero if they are equal. It is used by GetVolInfo to
693 * search volInfo structures once it has the head volInfo structure from the
694 * volName hash table.
695 *
696 * When called from GetVolInfo the name compare is redundant.
697 * Always AND the flags with VOLINFOFLAGS for backwards compatability (3.3).
698 */
699
700 static int
701 VolInfoMatch(struct budb_volumeEntry *vol, struct volInfo *vi)
702 {
703 return ((strcmp(vol->name, vi->name) == 0) && /* same volume name */
704 (vol->id == ntohl(vi->id)) && /* same volume id */
705 ((vol->flags & VOLINFOFLAGS) == (ntohl(vi->flags) & VOLINFOFLAGS)) && /* same flags */
706 (vol->partition == ntohl(vi->partition)) && /* same partition (N/A) */
707 (strcmp(vol->server, vi->server) == 0)); /* same server (N/A) */
708 }
709
710 /*
711 * GetVolInfo()
712 * This routine takes a volumeEntry structure from an RPC interface and
713 * returns the corresponding volInfo structure, creating it if necessary.
714 *
715 * The caller must write the entry out.
716 */
717
718 static afs_int32
719 GetVolInfo(struct ubik_trans *ut, struct budb_volumeEntry *volP, dbadr *viaP,
720 struct volInfo *viP)
721 {
722 dbadr hvia, via;
723 struct volInfo hvi;
724 afs_int32 eval, code = 0;
725
726 eval = ht_LookupEntry(ut, &db.volName, volP->name, &via, viP);
727 if (eval)
728 ERROR(eval);
729
730 if (!via) {
731 /* allocate a new volinfo structure */
732 eval = AllocStructure(ut, volInfo_BLOCK, 0, &via, viP);
733 if (eval)
734 ERROR(eval);
735
736 strcpy(viP->name, volP->name);
737 strcpy(viP->server, volP->server);
738 viP->sameNameHead = 0; /* The head of same name chain */
739 viP->sameNameChain = 0; /* Same name chain is empty */
740 viP->firstFragment = 0;
741 viP->nFrags = 0;
742 viP->id = htonl(volP->id);
743 viP->partition = htonl(volP->partition);
744 viP->flags = htonl(volP->flags & VOLINFOFLAGS);
745
746 /* Chain onto volname hash table */
747 eval = ht_HashIn(ut, &db.volName, via, viP);
748 if (eval)
749 ERROR(eval);
750
751 LogDebug(4, "volume Info for %s placed at %d\n", volP->name, via);
752 }
753
754 else if (!VolInfoMatch(volP, viP)) { /* Not the head volinfo struct */
755 hvia = via; /* remember the head volinfo struct */
756 memcpy(&hvi, viP, sizeof(hvi));
757
758 /* Search the same name chain for the correct volinfo structure */
759 for (via = ntohl(viP->sameNameChain); via;
760 via = ntohl(viP->sameNameChain)) {
761 eval = dbread(ut, via, viP, sizeof(*viP));
762 if (eval)
763 ERROR(eval);
764
765 if (VolInfoMatch(volP, viP))
766 break; /* found the one */
767 }
768
769 /* if the correct volinfo struct isn't found, create one */
770 if (!via) {
771 eval = AllocStructure(ut, volInfo_BLOCK, 0, &via, viP);
772 if (eval)
773 ERROR(eval);
774
775 strcpy(viP->name, volP->name);
776 strcpy(viP->server, volP->server);
777 viP->nameHashChain = 0; /* not in hash table */
778 viP->sameNameHead = htonl(hvia); /* chain to head of sameNameChain */
779 viP->sameNameChain = hvi.sameNameChain;
780 viP->firstFragment = 0;
781 viP->nFrags = 0;
782 viP->id = htonl(volP->id);
783 viP->partition = htonl(volP->partition);
784 viP->flags = htonl(volP->flags & VOLINFOFLAGS);
785
786 /* write the head entry's sameNameChain link */
787 eval =
788 set_word_addr(ut, hvia, &hvi, &hvi.sameNameChain, htonl(via));
789 if (eval)
790 ERROR(eval);
791 }
792 }
793
794 *viaP = via;
795
796 error_exit:
797 return code;
798 }
799
800 /* deletesomevolumesfromtape
801 * Deletes a specified number of volumes from a tape. The tape
802 * and dump are modified to reflect the smaller number of volumes.
803 * The transaction is not terminated, it is up to the caller to
804 * finish the transaction and start a new one (if desired).
805 * entry:
806 * maxvolumestodelete - don't delete more than this many volumes
807 */
808
809 afs_int32
810 deleteSomeVolumesFromTape(struct ubik_trans *ut, dbadr tapeAddr,
811 struct tape *tapePtr, int maxVolumesToDelete)
812 {
813 dbadr volFragAddr, nextVolFragAddr, dumpAddr;
814 struct volFragment volFrag;
815 struct dump dump;
816 int volumesDeleted = 0;
817 afs_int32 eval, code = 0;
818
819 if (!tapePtr)
820 ERROR(0);
821
822 for (volFragAddr = ntohl(tapePtr->firstVol);
823 (volFragAddr && (maxVolumesToDelete > 0));
824 volFragAddr = nextVolFragAddr) {
825 eval = dbread(ut, volFragAddr, &volFrag, sizeof(volFrag));
826 if (eval)
827 ERROR(eval);
828
829 nextVolFragAddr = ntohl(volFrag.sameTapeChain);
830
831 eval = DeleteVolFragment(ut, volFragAddr, &volFrag);
832 if (eval)
833 ERROR(eval);
834
835 maxVolumesToDelete--;
836 volumesDeleted++;
837 }
838
839 /* reset the volume fragment pointer in the tape */
840 tapePtr->firstVol = htonl(volFragAddr);
841
842 /* diminish the tape's volume count */
843 tapePtr->nVolumes = htonl(ntohl(tapePtr->nVolumes) - volumesDeleted);
844
845 eval = dbwrite(ut, tapeAddr, tapePtr, sizeof(*tapePtr));
846 if (eval)
847 ERROR(eval);
848
849 /* diminish the dump's volume count */
850 dumpAddr = ntohl(tapePtr->dump);
851 eval = dbread(ut, dumpAddr, &dump, sizeof(dump));
852 if (eval)
853 ERROR(eval);
854
855 dump.nVolumes = htonl(ntohl(dump.nVolumes) - volumesDeleted);
856 eval = dbwrite(ut, dumpAddr, &dump, sizeof(dump));
857 if (eval)
858 ERROR(eval);
859
860 error_exit:
861 return (code);
862 }
863
864 /* deleteDump
865 * deletes a dump in stages, by repeatedly deleting a small number of
866 * volumes from the dump until none are left. The dump is then deleted.
867 *
868 * In the case where multiple calls are made to delete the same
869 * dump, the operation will succeed but contention for structures
870 * will result in someone getting back an error.
871 *
872 * entry:
873 * id - id of dump to delete
874 */
875
876 afs_int32
877 deleteDump(struct rx_call *call, dumpId id, budb_dumpsList *dumps)
878 {
879 struct ubik_trans *ut;
880 dbadr dumpAddr, tapeAddr, appendedDump;
881 struct dump dump;
882 struct tape tape;
883 dumpId dumpid;
884 afs_int32 eval, code = 0;
885 int partialDel = 0;
886
887 /* iterate until the dump is truly deleted */
888
889 dumpid = id;
890 while (dumpid) {
891 partialDel = 0;
892 while (1) {
893 eval = InitRPC(&ut, LOCKWRITE, 1);
894 if (eval)
895 ERROR(eval); /* can't start transaction */
896
897 eval =
898 ht_LookupEntry(ut, &db.dumpIden, &dumpid, &dumpAddr, &dump);
899 if (eval)
900 ABORT(eval);
901 if (!dumpAddr)
902 ABORT(BUDB_NOENT); /* can't find dump */
903
904 if ((dumpid == id) && (dump.initialDumpID)) /* can't be an appended dump */
905 ABORT(BUDB_NOTINITIALDUMP);
906
907 tapeAddr = ntohl(dump.firstTape);
908 if (tapeAddr == 0)
909 break;
910
911 /* there is a tape to delete */
912 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
913 if (eval)
914 ABORT(eval);
915
916 if (ntohl(tape.nVolumes)) {
917 /* tape is not empty */
918 eval = deleteSomeVolumesFromTape(ut, tapeAddr, &tape, 10);
919 if (eval)
920 ABORT(eval);
921 }
922
923 if (ntohl(tape.nVolumes) == 0) {
924 /* tape is now empty, delete it */
925 eval = DeleteTape(ut, tapeAddr, &tape);
926 if (eval)
927 ABORT(eval);
928 eval = ht_HashOut(ut, &db.tapeName, tapeAddr, &tape);
929 if (eval)
930 ABORT(eval);
931 eval = FreeStructure(ut, tape_BLOCK, tapeAddr);
932 if (eval)
933 ABORT(eval);
934 }
935
936 eval = ubik_EndTrans(ut);
937 if (eval)
938 ERROR(eval);
939 partialDel = 1;
940 } /* next deletion portion */
941
942 /* Record the dump just deleted */
943 if (dumps && (dumps->budb_dumpsList_len < BUDB_MAX_RETURN_LIST)) {
944 if (dumps->budb_dumpsList_len == 0)
945 dumps->budb_dumpsList_val = malloc(sizeof(afs_int32));
946 else
947 dumps->budb_dumpsList_val =
948 realloc(dumps->budb_dumpsList_val,
949 (dumps->budb_dumpsList_len + 1)
950 * sizeof(afs_int32));
951
952 if (!dumps->budb_dumpsList_val)
953 ABORT(BUDB_NOMEM);
954
955 dumps->budb_dumpsList_val[dumps->budb_dumpsList_len] = dumpid;
956 dumps->budb_dumpsList_len++;
957 }
958
959 appendedDump = ntohl(dump.appendedDumpChain);
960
961 /* finally done. No more tapes left in the dump. Delete the dump itself */
962 eval = DeleteDump(ut, dumpAddr, &dump);
963 if (eval)
964 ABORT(eval);
965
966 /* Now delete the appended dump too */
967 if (appendedDump) {
968 eval = dbread(ut, appendedDump, &dump, sizeof(dump));
969 if (eval)
970 ABORT(eval);
971
972 dumpid = ntohl(dump.id);
973 } else
974 dumpid = 0;
975
976 eval = ubik_EndTrans(ut);
977 if (eval)
978 ERROR(eval);
979
980 Log("Delete dump %s (DumpID %u), path %s\n", dump.dumpName,
981 ntohl(dump.id), dump.dumpPath);
982 }
983
984 error_exit:
985 if (code && partialDel) {
986 Log("Delete dump %s (DumpID %u), path %s - INCOMPLETE (code = %u)\n",
987 dump.dumpName, ntohl(dump.id), dump.dumpPath, code);
988 }
989 return (code);
990
991 abort_exit:
992 ubik_AbortTrans(ut);
993 goto error_exit;
994 }
995
996 /* --------------
997 * dump selection routines - used by BUDB_GetDumps
998 * --------------
999 */
1000
1001 /* most recent dump selection */
1002
1003 struct chosenDump {
1004 struct chosenDump *next;
1005 dbadr addr;
1006 afs_uint32 date;
1007 };
1008
1009 struct wantDumpRock {
1010 int maxDumps; /* max wanted */
1011 int ndumps; /* actual in chain */
1012 struct chosenDump *chain;
1013 };
1014
1015
1016 int
1017 wantDump(dbadr dumpAddr, void *dumpParam, void *dumpListPtrParam)
1018 {
1019 struct dump *dumpPtr;
1020 struct wantDumpRock *rockPtr;
1021
1022 dumpPtr = (struct dump *)dumpParam;
1023 rockPtr = (struct wantDumpRock *)dumpListPtrParam;
1024
1025 /* if we don't have our full complement, just add another */
1026 if (rockPtr->ndumps < rockPtr->maxDumps)
1027 return (1);
1028
1029 /* got the number we need, select based on date */
1030 if ((afs_uint32) ntohl(dumpPtr->created) > rockPtr->chain->date)
1031 return (1);
1032
1033 return (0);
1034 }
1035
1036 int
1037 rememberDump(dbadr dumpAddr, void *dumpParam, void *dumpListPtrParam)
1038 {
1039 struct dump *dumpPtr;
1040 struct wantDumpRock *rockPtr;
1041 struct chosenDump *ptr, *deletedPtr, **nextPtr;
1042
1043 dumpPtr = (struct dump *)dumpParam;
1044 rockPtr = (struct wantDumpRock *)dumpListPtrParam;
1045
1046 ptr = calloc(1, sizeof(*ptr));
1047 if (!ptr)
1048 return (0);
1049 ptr->addr = dumpAddr;
1050 ptr->date = (afs_uint32) ntohl(dumpPtr->created);
1051
1052 /* Don't overflow the max */
1053 while (rockPtr->ndumps >= rockPtr->maxDumps) {
1054 /* have to drop one */
1055 deletedPtr = rockPtr->chain;
1056 rockPtr->chain = deletedPtr->next;
1057 free(deletedPtr);
1058 rockPtr->ndumps--;
1059 }
1060
1061 /* now insert in the right place */
1062 for (nextPtr = &rockPtr->chain; *nextPtr; nextPtr = &((*nextPtr)->next)) {
1063 if (ptr->date < (*nextPtr)->date)
1064 break;
1065 }
1066 ptr->next = *nextPtr;
1067 *nextPtr = ptr;
1068 rockPtr->ndumps++;
1069
1070 return (0);
1071 }
1072
1073
1074 /* ---------------------------------------------
1075 * general interface routines - alphabetic
1076 * ---------------------------------------------
1077 */
1078
1079 afs_int32
1080 SBUDB_AddVolume(struct rx_call *call, struct budb_volumeEntry *vol)
1081 {
1082 afs_int32 code;
1083
1084 code = AddVolume(call, vol);
1085 osi_auditU(call, BUDB_AddVolEvent, code, AUD_LONG, (vol ? vol->id : 0),
1086 AUD_END);
1087 return code;
1088 }
1089
1090 afs_int32
1091 AddVolume(struct rx_call *call, struct budb_volumeEntry *vol)
1092 {
1093 struct ubik_trans *ut;
1094 dbadr da, ta, via, va;
1095 struct dump d;
1096 struct tape t;
1097 struct volInfo vi;
1098 struct volFragment v;
1099 afs_uint32 bytes;
1100 afs_int32 eval, code = 0;
1101
1102 if (!callPermitted(call))
1103 return BUDB_NOTPERMITTED;
1104
1105 if ((strlen(vol->name) >= sizeof(vi.name))
1106 || (strlen(vol->server) >= sizeof(vi.server))
1107 || (strlen(vol->tape) >= sizeof(t.name)))
1108 return BUDB_BADARGUMENT;
1109
1110 eval = InitRPC(&ut, LOCKWRITE, 1);
1111 if (eval)
1112 return eval;
1113
1114 /* Find the dump in dumpid hash table */
1115 eval = ht_LookupEntry(ut, &db.dumpIden, &vol->dump, &da, &d);
1116 if (eval)
1117 ABORT(eval);
1118 if (!da)
1119 ABORT(BUDB_NODUMPID);
1120
1121 /* search for the right tape in the dump */
1122 for (ta = ntohl(d.firstTape); ta; ta = ntohl(t.nextTape)) {
1123 /* read the tape entry */
1124 eval = dbread(ut, ta, &t, sizeof(t));
1125 if (eval)
1126 ABORT(eval);
1127
1128 /* Check if the right tape name */
1129 if (strcmp(t.name, vol->tape) == 0)
1130 break;
1131 }
1132 if (!ta)
1133 ABORT(BUDB_NOTAPENAME);
1134
1135 if ((t.dump != htonl(da)) || /* tape must belong to dump */
1136 ((ntohl(t.flags) & BUDB_TAPE_BEINGWRITTEN) == 0) || /* tape must be being written */
1137 ((ntohl(d.flags) & BUDB_DUMP_INPROGRESS) == 0)) /* dump must be in progress */
1138 ABORT(BUDB_BADPROTOCOL);
1139
1140 /* find or create a volume info structure */
1141 eval = GetVolInfo(ut, vol, &via, &vi);
1142 if (eval)
1143 ABORT(eval);
1144
1145 /* Create a volume fragment */
1146 eval = AllocStructure(ut, volFragment_BLOCK, 0, &va, &v);
1147 if (eval)
1148 ABORT(eval);
1149
1150 v.vol = htonl(via); /* vol frag points to vol info */
1151 v.sameNameChain = vi.firstFragment; /* vol frag is chained to vol info */
1152 vi.firstFragment = htonl(va);
1153 vi.nFrags = htonl(ntohl(vi.nFrags) + 1);
1154
1155 eval = dbwrite(ut, via, &vi, sizeof(vi)); /* write the vol info struct */
1156 if (eval)
1157 ABORT(eval);
1158
1159 v.tape = htonl(ta); /* vol frag points to tape */
1160 v.sameTapeChain = t.firstVol; /* vol frag is chained to tape info */
1161 t.firstVol = htonl(va);
1162 t.nVolumes = htonl(ntohl(t.nVolumes) + 1);
1163 bytes = ntohl(t.nBytes) + vol->nBytes; /* update bytes on tape */
1164 t.nMBytes = htonl(ntohl(t.nMBytes) + bytes / (1024 * 1024));
1165 t.nBytes = htonl(bytes % (1024 * 1024));
1166
1167 eval = dbwrite(ut, ta, &t, sizeof(t)); /* write the tape structure */
1168 if (eval)
1169 ABORT(eval);
1170
1171 d.nVolumes = htonl(ntohl(d.nVolumes) + 1); /* one more volume on dump */
1172
1173 eval = dbwrite(ut, da, &d, sizeof(d)); /* write out the dump structure */
1174 if (eval)
1175 ABORT(eval);
1176
1177 v.position = htonl(vol->position); /* vol frag info */
1178 v.clone = htonl(vol->clone);
1179 v.incTime = htonl(vol->incTime);
1180 v.startByte = htonl(vol->startByte);
1181 v.nBytes = htonl(vol->nBytes);
1182 v.flags = htons(vol->flags & VOLFRAGMENTFLAGS);
1183 v.sequence = htons(vol->seq);
1184
1185 eval = dbwrite(ut, va, &v, sizeof(v)); /* write out the vol frag struct */
1186 if (eval)
1187 ABORT(eval);
1188
1189 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
1190 if (eval)
1191 ABORT(eval);
1192
1193 LogDebug(4, "added volume %s at %d\n", vol->name, va);
1194
1195 code = ubik_EndTrans(ut);
1196 return code;
1197
1198 abort_exit:
1199 ubik_AbortTrans(ut);
1200 return code;
1201 }
1202
1203
1204 afs_int32
1205 SBUDB_AddVolumes(struct rx_call *call, struct budb_volumeList *vols)
1206 {
1207 afs_int32 code;
1208
1209 code = AddVolumes(call, vols);
1210 osi_auditU(call, BUDB_AddVolEvent, code, AUD_LONG, 0, AUD_END);
1211 return code;
1212 }
1213
1214 afs_int32
1215 AddVolumes(struct rx_call *call, struct budb_volumeList *vols)
1216 {
1217 struct budb_volumeEntry *vol, *vol1;
1218 struct ubik_trans *ut;
1219 dbadr da, ta, via, va;
1220 struct dump d;
1221 struct tape t;
1222 struct volInfo vi;
1223 struct volFragment v;
1224 afs_uint32 bytes;
1225 afs_int32 eval, e, code = 0;
1226
1227 if (!callPermitted(call))
1228 return BUDB_NOTPERMITTED;
1229
1230 if (!vols || (vols->budb_volumeList_len <= 0)
1231 || !vols->budb_volumeList_val)
1232 return BUDB_BADARGUMENT;
1233
1234 /* The first volume in the list of volumes to add */
1235 vol1 = (struct budb_volumeEntry *)vols->budb_volumeList_val;
1236
1237 eval = InitRPC(&ut, LOCKWRITE, 1);
1238 if (eval)
1239 return eval;
1240
1241 /* Find the dump in dumpid hash table */
1242 eval = ht_LookupEntry(ut, &db.dumpIden, &vol1->dump, &da, &d);
1243 if (eval)
1244 ABORT(eval);
1245 if (!da)
1246 ABORT(BUDB_NODUMPID);
1247
1248 /* search for the right tape in the dump */
1249 for (ta = ntohl(d.firstTape); ta; ta = ntohl(t.nextTape)) {
1250 /* read the tape entry */
1251 eval = dbread(ut, ta, &t, sizeof(t));
1252 if (eval)
1253 ABORT(eval);
1254
1255 /* Check if the right tape name */
1256 if (strcmp(t.name, vol1->tape) == 0)
1257 break;
1258 }
1259 if (!ta)
1260 ABORT(BUDB_NOTAPENAME);
1261
1262 if ((t.dump != htonl(da)) || /* tape must belong to dump */
1263 ((ntohl(t.flags) & BUDB_TAPE_BEINGWRITTEN) == 0) || /* tape must be being written */
1264 ((ntohl(d.flags) & BUDB_DUMP_INPROGRESS) == 0)) /* dump must be in progress */
1265 ABORT(BUDB_BADPROTOCOL);
1266
1267 for (vol = vol1, e = 0; e < vols->budb_volumeList_len; vol++, e++) {
1268 /*v */
1269 if ((strlen(vol->name) >= sizeof(vi.name)) || (strcmp(vol->name, "") == 0) || /* no null volnames */
1270 (strlen(vol->server) >= sizeof(vi.server))
1271 || (strlen(vol->tape) >= sizeof(t.name))
1272 || (strcmp(vol->tape, vol1->tape) != 0)) {
1273 Log("Volume '%s' %u, tape '%s', dumpID %u is an invalid entry - not added\n", vol->name, vol->id, vol->tape, vol->dump);
1274 continue;
1275 }
1276
1277 /* find or create a volume info structure */
1278 eval = GetVolInfo(ut, vol, &via, &vi);
1279 if (eval)
1280 ABORT(eval);
1281 if (*(afs_int32 *) (&vi) == 0) {
1282 Log("Volume '%s', tape '%s', dumpID %u is an invalid entry - aborted\n", vol->name, vol->tape, vol->dump);
1283 ABORT(BUDB_BADARGUMENT);
1284 }
1285
1286 /* Create a volume fragment */
1287 eval = AllocStructure(ut, volFragment_BLOCK, 0, &va, &v);
1288 if (eval)
1289 ABORT(eval);
1290
1291 v.vol = htonl(via); /* vol frag points to vol info */
1292 v.sameNameChain = vi.firstFragment; /* vol frag is chained to vol info */
1293 vi.firstFragment = htonl(va);
1294 vi.nFrags = htonl(ntohl(vi.nFrags) + 1);
1295 eval = dbwrite(ut, via, &vi, sizeof(vi)); /* write the vol info struct */
1296 if (eval)
1297 ABORT(eval);
1298
1299 v.tape = htonl(ta); /* vol frag points to tape */
1300 v.sameTapeChain = t.firstVol; /* vol frag is chained to tape info */
1301 t.firstVol = htonl(va);
1302 t.nVolumes = htonl(ntohl(t.nVolumes) + 1);
1303 bytes = ntohl(t.nBytes) + vol->nBytes; /* update bytes on tape */
1304 t.nMBytes = htonl(ntohl(t.nMBytes) + bytes / (1024 * 1024));
1305 t.nBytes = htonl(bytes % (1024 * 1024));
1306
1307 d.nVolumes = htonl(ntohl(d.nVolumes) + 1); /* one more volume on dump */
1308
1309 v.position = htonl(vol->position); /* vol frag info */
1310 v.clone = htonl(vol->clone);
1311 v.incTime = htonl(vol->incTime);
1312 v.startByte = htonl(vol->startByte);
1313 v.nBytes = htonl(vol->nBytes);
1314 v.flags = htons(vol->flags & VOLFRAGMENTFLAGS);
1315 v.sequence = htons(vol->seq);
1316
1317 eval = dbwrite(ut, va, &v, sizeof(v)); /* write out the vol frag struct */
1318 if (eval)
1319 ABORT(eval);
1320
1321 LogDebug(4, "added volume %s at %d\n", vol->name, va);
1322 } /*v */
1323
1324 eval = dbwrite(ut, ta, &t, sizeof(t)); /* write the tape structure */
1325 if (eval)
1326 ABORT(eval);
1327
1328 eval = dbwrite(ut, da, &d, sizeof(d)); /* write out the dump structure */
1329 if (eval)
1330 ABORT(eval);
1331
1332 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
1333 if (eval)
1334 ABORT(eval);
1335
1336 code = ubik_EndTrans(ut);
1337 return code;
1338
1339 abort_exit:
1340 ubik_AbortTrans(ut);
1341 return code;
1342 }
1343
1344
1345 /* BUDB_CreateDump
1346 * records the existence of a dump in the database. This creates only
1347 * the dump record, to which one must attach tape and volume records.
1348 * TBD
1349 * 1) record the volume set
1350 */
1351
1352 afs_int32
1353 SBUDB_CreateDump(struct rx_call *call, struct budb_dumpEntry *dump)
1354 {
1355 afs_int32 code;
1356
1357 code = CreateDump(call, dump);
1358 osi_auditU(call, BUDB_CrDmpEvent, code, AUD_DATE, (dump ? dump->id : 0),
1359 AUD_END);
1360 if (dump && !code) {
1361 Log("Create dump %s (DumpID %u), path %s\n", dump->name, dump->id,
1362 dump->dumpPath);
1363 }
1364 return code;
1365 }
1366
1367 afs_int32
1368 CreateDump(struct rx_call *call, struct budb_dumpEntry *dump)
1369 {
1370 struct ubik_trans *ut;
1371 dbadr findDumpAddr, da;
1372 struct dump findDump, d;
1373 afs_int32 eval, code = 0;
1374
1375 rxkad_level level;
1376 afs_int32 kvno;
1377 Date expiration; /* checked by Security Module */
1378 struct ktc_principal principal;
1379
1380 if (!callPermitted(call))
1381 return BUDB_NOTPERMITTED;
1382
1383 if (strlen(dump->name) >= sizeof(d.dumpName))
1384 return BUDB_BADARGUMENT;
1385
1386 eval = InitRPC(&ut, LOCKWRITE, 1);
1387 if (eval)
1388 return eval;
1389
1390 eval =
1391 rxkad_GetServerInfo(rx_ConnectionOf(call), &level, &expiration,
1392 principal.name, principal.instance,
1393 principal.cell, &kvno);
1394
1395 if (eval) {
1396 if (eval != RXKADNOAUTH)
1397 ABORT(eval);
1398
1399 strcpy(principal.name, "");
1400 strcpy(principal.instance, "");
1401 strcpy(principal.cell, "");
1402 expiration = 0;
1403 } else {
1404 /* authenticated. Take user supplied principal information */
1405 if (strcmp(dump->dumper.name, "") != 0)
1406 strncpy(principal.name, dump->dumper.name,
1407 sizeof(principal.name));
1408
1409 if (strcmp(dump->dumper.instance, "") != 0)
1410 strncpy(principal.instance, dump->dumper.instance,
1411 sizeof(principal.instance));
1412
1413 if (strcmp(dump->dumper.cell, "") != 0)
1414 strncpy(principal.cell, dump->dumper.cell,
1415 sizeof(principal.cell));
1416 }
1417
1418 /* dump id's are time stamps */
1419 if (!dump->id) {
1420 while (1) { /* allocate a unique dump id *//*w */
1421 dump->id = time(0);
1422
1423 /* ensure it is unique - seach for dumpid in hash table */
1424 eval =
1425 ht_LookupEntry(ut, &db.dumpIden, &dump->id, &findDumpAddr,
1426 &findDump);
1427 if (eval)
1428 ABORT(eval);
1429
1430 if (!findDumpAddr) { /* dumpid not in use */
1431 /* update the last dump id allocated */
1432 eval = set_header_word(ut, lastDumpId, htonl(dump->id));
1433 if (eval)
1434 ABORT(eval);
1435 break;
1436 }
1437
1438 /* dump id is in use - wait a while */
1439 #ifdef AFS_PTHREAD_ENV
1440 sleep(1);
1441 #else
1442 IOMGR_Sleep(1);
1443 #endif
1444 } /*w */
1445 } else {
1446 /* dump id supplied (e.g. for database restore) */
1447 eval =
1448 ht_LookupEntry(ut, &db.dumpIden, &dump->id, &findDumpAddr,
1449 &findDump);
1450 if (eval)
1451 ABORT(eval);
1452
1453 /* Dump id must not already exist */
1454 if (findDumpAddr)
1455 ABORT(BUDB_DUMPIDEXISTS);
1456 }
1457
1458 /* Allocate a dump structure */
1459 memset(&d, 0, sizeof(d));
1460 eval = AllocStructure(ut, dump_BLOCK, 0, &da, &d);
1461 if (eval)
1462 ABORT(eval);
1463
1464 strcpy(d.dumpName, dump->name); /* volset.dumpname */
1465 strcpy(d.dumpPath, dump->dumpPath); /* dump node path */
1466 strcpy(d.volumeSet, dump->volumeSetName); /* volume set */
1467 d.id = htonl(dump->id);
1468 d.parent = htonl(dump->parent); /* parent id */
1469 d.level = htonl(dump->level);
1470
1471 LogDebug(4, "dump name %s, parent %d level %d\n", dump->name,
1472 dump->parent, dump->level);
1473
1474 /* if creation time specified, use that. Else use the dumpid time */
1475 if (dump->created == 0)
1476 dump->created = dump->id;
1477 d.created = htonl(dump->created);
1478
1479 d.dumper = principal;
1480 tapeSet_hton(&dump->tapes, &d.tapes);
1481
1482 d.flags = htonl(dump->flags | BUDB_DUMP_INPROGRESS);
1483
1484 eval = ht_HashIn(ut, &db.dumpName, da, &d); /* Into dump name hash table */
1485 if (eval)
1486 ABORT(eval);
1487
1488 eval = ht_HashIn(ut, &db.dumpIden, da, &d); /* Into dumpid hash table */
1489 if (eval)
1490 ABORT(eval);
1491
1492 eval = dbwrite(ut, da, (char *)&d, sizeof(d)); /* Write the dump structure */
1493 if (eval)
1494 ABORT(eval);
1495
1496 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
1497 if (eval)
1498 ABORT(eval);
1499
1500 /* If to append this dump, then append it - will write the appended dump */
1501 eval = makeAppended(ut, dump->id, dump->initialDumpID, dump->tapes.b);
1502 if (eval)
1503 ABORT(eval);
1504
1505 code = ubik_EndTrans(ut);
1506 LogDebug(5, "made dump %s, path %s\n", d.dumpName, d.dumpPath);
1507 return code;
1508
1509 abort_exit:
1510 ubik_AbortTrans(ut);
1511 return code;
1512 }
1513
1514 afs_int32
1515 SBUDB_DeleteDump(struct rx_call *call, dumpId id, Date fromTime, Date toTime,
1516 budb_dumpsList *dumps)
1517 {
1518 afs_int32 code;
1519
1520 code = DoDeleteDump(call, id, fromTime, toTime, dumps);
1521 osi_auditU(call, BUDB_DelDmpEvent, code, AUD_DATE, id, AUD_END);
1522 return code;
1523 }
1524
1525 #define MAXOFFS 30
1526
1527 afs_int32
1528 DoDeleteDump(struct rx_call *call, dumpId id, Date fromTime, Date toTime,
1529 budb_dumpsList *dumps)
1530 {
1531 afs_int32 code = 0;
1532
1533 if (!callPermitted(call))
1534 return BUDB_NOTPERMITTED;
1535
1536 if (id)
1537 code = deleteDump(call, id, dumps);
1538 return (code);
1539 }
1540
1541 afs_int32
1542 SBUDB_ListDumps(struct rx_call *call, afs_int32 sflags, char *name,
1543 afs_int32 groupid, Date fromTime, Date toTime,
1544 budb_dumpsList *dumps, budb_dumpsList *flags)
1545 {
1546 afs_int32 code;
1547
1548 code = ListDumps(call, sflags, groupid, fromTime, toTime, dumps, flags);
1549 osi_auditU(call, BUDB_LstDmpEvent, code, AUD_LONG, flags, AUD_END);
1550 return code;
1551 }
1552
1553 afs_int32
1554 ListDumps(struct rx_call *call, afs_int32 sflags, afs_int32 groupid,
1555 Date fromTime, Date toTime, budb_dumpsList *dumps,
1556 budb_dumpsList *flags)
1557 {
1558 struct ubik_trans *ut;
1559 struct memoryHashTable *mht;
1560 struct dump diskDump, appDiskDump;
1561 dbadr dbAddr, dbAppAddr;
1562
1563 afs_int32 eval, code = 0;
1564 int old, hash, length, entrySize, count = 0;
1565
1566 if (!callPermitted(call))
1567 return BUDB_NOTPERMITTED;
1568
1569 eval = InitRPC(&ut, LOCKREAD, 1);
1570 if (eval)
1571 return (eval);
1572
1573 /* Search the database */
1574 mht = ht_GetType(HT_dumpIden_FUNCTION, &entrySize);
1575 if (!mht)
1576 return (BUDB_BADARGUMENT);
1577
1578 for (old = 0; old <= 1; old++) { /*o *//* old and new hash tables */
1579 length = (old ? mht->oldLength : mht->length);
1580 if (length == 0)
1581 continue;
1582
1583 for (hash = 0; hash < length; hash++) { /*h *//* for each hash bucket */
1584 for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr; dbAddr = ntohl(diskDump.idHashChain)) { /*d */
1585
1586 /* read the entry */
1587 eval = dbread(ut, dbAddr, &diskDump, sizeof(diskDump));
1588 if (eval)
1589 ABORT(eval);
1590
1591 /* Skip appended dumps */
1592 if (ntohl(diskDump.initialDumpID) != 0) {
1593 continue;
1594 }
1595
1596 /* Skip dumps with different goup id */
1597 if ((sflags & BUDB_OP_GROUPID)
1598 && (ntohl(diskDump.tapes.id) != groupid)) {
1599 continue; /*nope */
1600 }
1601
1602 /* Look at this dump to see if it meets the criteria for listing */
1603 if (sflags & BUDB_OP_DATES) {
1604 /* This and each appended dump should be in time */
1605 for (dbAppAddr = dbAddr; dbAppAddr;
1606 dbAppAddr = ntohl(appDiskDump.appendedDumpChain)) {
1607 eval =
1608 dbread(ut, dbAppAddr, &appDiskDump,
1609 sizeof(appDiskDump));
1610 if (eval)
1611 ABORT(eval);
1612
1613 if ((ntohl(appDiskDump.id) < fromTime)
1614 || (ntohl(appDiskDump.id) > toTime))
1615 break; /*nope */
1616 }
1617 if (dbAppAddr)
1618 continue; /*nope */
1619 }
1620
1621 /* Add it and each of its appended dump to our list to return */
1622 for (dbAppAddr = dbAddr; dbAppAddr;
1623 dbAppAddr = ntohl(appDiskDump.appendedDumpChain)) {
1624 eval =
1625 dbread(ut, dbAppAddr, &appDiskDump,
1626 sizeof(appDiskDump));
1627 if (eval)
1628 ABORT(eval);
1629
1630 /* Make sure we have space to list it */
1631 if (dumps->budb_dumpsList_len >= count) {
1632 count += 10;
1633 if (count == 10) {
1634 dumps->budb_dumpsList_val =
1635 malloc(count * sizeof(afs_int32));
1636 flags->budb_dumpsList_val =
1637 malloc(count * sizeof(afs_int32));
1638 } else {
1639 dumps->budb_dumpsList_val =
1640 realloc(dumps->budb_dumpsList_val,
1641 count * sizeof(afs_int32));
1642 flags->budb_dumpsList_val =
1643 realloc(flags->budb_dumpsList_val,
1644 count * sizeof(afs_int32));
1645 }
1646 if (!dumps->budb_dumpsList_val
1647 || !dumps->budb_dumpsList_val)
1648 ABORT(BUDB_NOMEM);
1649 }
1650
1651 /* Add it to our list */
1652 dumps->budb_dumpsList_val[dumps->budb_dumpsList_len] =
1653 ntohl(appDiskDump.id);
1654 flags->budb_dumpsList_val[flags->budb_dumpsList_len] = 0;
1655 if (ntohl(appDiskDump.initialDumpID) != 0) {
1656 flags->budb_dumpsList_val[flags->
1657 budb_dumpsList_len] |=
1658 BUDB_OP_APPDUMP;
1659 }
1660 if (strcmp(appDiskDump.dumpName, DUMP_TAPE_NAME) == 0) {
1661 flags->budb_dumpsList_val[flags->
1662 budb_dumpsList_len] |=
1663 BUDB_OP_DBDUMP;
1664 }
1665 dumps->budb_dumpsList_len++;
1666 flags->budb_dumpsList_len++;
1667 }
1668 } /*d */
1669 } /*h */
1670 } /*o */
1671
1672 code = ubik_EndTrans(ut);
1673 return (code);
1674
1675 abort_exit:
1676 ubik_AbortTrans(ut);
1677 return (code);
1678 }
1679
1680 afs_int32
1681 SBUDB_DeleteTape(struct rx_call *call,
1682 struct budb_tapeEntry *tape) /* tape info */
1683 {
1684 afs_int32 code;
1685
1686 code = DoDeleteTape(call, tape);
1687 osi_auditU(call, BUDB_DelTpeEvent, code, AUD_DATE,
1688 (tape ? tape->dump : 0), AUD_END);
1689 return code;
1690 }
1691
1692 afs_int32
1693 DoDeleteTape(struct rx_call *call,
1694 struct budb_tapeEntry *tape) /* tape info */
1695 {
1696 struct ubik_trans *ut;
1697 struct tape t;
1698 dbadr a;
1699 afs_int32 eval, code;
1700
1701 if (!callPermitted(call))
1702 return BUDB_NOTPERMITTED;
1703
1704 eval = InitRPC(&ut, LOCKWRITE, 1);
1705 if (eval)
1706 return eval;
1707
1708 eval = ht_LookupEntry(ut, &db.tapeName, tape->name, &a, &t);
1709 if (eval)
1710 ABORT(eval);
1711
1712 eval = DeleteTape(ut, a, &t);
1713 if (eval)
1714 ABORT(eval);
1715
1716 eval = FreeStructure(ut, tape_BLOCK, a);
1717 if (eval)
1718 ABORT(eval);
1719
1720 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
1721 if (eval)
1722 ABORT(eval);
1723
1724 code = ubik_EndTrans(ut);
1725 return code;
1726
1727 abort_exit:
1728 ubik_AbortTrans(ut);
1729 return code;
1730 }
1731
1732 /* BUDB_DeleteVDP
1733 * Deletes old information from the database for a particular dump path
1734 * and volumset. This supercedes the old policy implemented in
1735 * UseTape, which simply matched on the volumeset.dump. Consequently
1736 * it was unable to handle name re-use.
1737 * entry:
1738 * dsname - dumpset name, i.e. volumeset.dumpname
1739 * dumpPath - full path of dump node
1740 * curDumpID - current dump in progress - so that is may be excluded
1741 * exit:
1742 * 0 - ok
1743 * n - some error. May or may not have deleted information.
1744 */
1745
1746 afs_int32
1747 SBUDB_DeleteVDP(struct rx_call *call, char *dsname, char *dumpPath,
1748 afs_int32 curDumpId)
1749 {
1750 afs_int32 code;
1751
1752 code = DeleteVDP(call, dsname, dumpPath, curDumpId);
1753 osi_auditU(call, BUDB_DelVDPEvent, code, AUD_STR, dsname, AUD_END);
1754 return code;
1755 }
1756
1757 afs_int32
1758 DeleteVDP(struct rx_call *call, char *dsname, char *dumpPath,
1759 afs_int32 curDumpId)
1760 {
1761 struct dump dump;
1762 dbadr dumpAddr;
1763
1764 struct ubik_trans *ut;
1765 afs_int32 eval, code = 0;
1766
1767 if (!callPermitted(call))
1768 return BUDB_NOTPERMITTED;
1769
1770 while (1) {
1771 eval = InitRPC(&ut, LOCKREAD, 1);
1772 if (eval)
1773 return (eval);
1774
1775 eval = ht_LookupEntry(ut, &db.dumpName, dsname, &dumpAddr, &dump);
1776 if (eval)
1777 ABORT(eval);
1778
1779 while (dumpAddr != 0) { /*wd */
1780 if ((strcmp(dump.dumpName, dsname) == 0)
1781 && (strcmp(dump.dumpPath, dumpPath) == 0)
1782 && (ntohl(dump.id) != curDumpId)) {
1783 eval = ubik_EndTrans(ut);
1784 if (eval)
1785 return (eval);
1786
1787 eval = deleteDump(call, ntohl(dump.id), 0);
1788 if (eval)
1789 return (eval);
1790
1791 /* start the traversal over since the various chains may
1792 * have changed
1793 */
1794 break;
1795 }
1796
1797 dumpAddr = ntohl(dump.nameHashChain);
1798 if (dumpAddr) {
1799 eval = dbread(ut, dumpAddr, &dump, sizeof(dump));
1800 if (eval)
1801 ABORT(eval);
1802 }
1803 } /*wd */
1804
1805 /* check if all the dumps have been examined - can terminate */
1806 if (!dumpAddr) {
1807 eval = ubik_EndTrans(ut);
1808 return (eval);
1809 }
1810 }
1811
1812 abort_exit:
1813 ubik_AbortTrans(ut);
1814 return (code);
1815 }
1816
1817 /* BUDB_FindClone
1818 * notes:
1819 * Given a volume name, and a dumpID, find the volume in that dump and
1820 * return the clone date of the volume (this is the clone date of the
1821 * volume at the time it was dumped).
1822 *
1823 * Hashes on the volume name and traverses the fragments. Will need to read
1824 * the volumes tape entry to determine if it belongs to the dump. If the
1825 * volume is not found in the dump, then look for it in its parent dump.
1826 */
1827
1828 afs_int32
1829 SBUDB_FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1830 afs_int32 *clonetime)
1831 {
1832 afs_int32 code;
1833
1834 code = FindClone(call, dumpID, volName, clonetime);
1835 osi_auditU(call, BUDB_FndClnEvent, code, AUD_STR, volName, AUD_END);
1836 return code;
1837 }
1838
1839 afs_int32
1840 FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1841 afs_int32 *clonetime)
1842 {
1843 struct ubik_trans *ut;
1844 dbadr da, hvia, via, vfa;
1845 struct dump d;
1846 struct tape t;
1847 struct volFragment vf;
1848 struct volInfo vi;
1849 int rvi; /* read the volInfo struct */
1850 afs_int32 eval, code = 0;
1851
1852 if (!callPermitted(call))
1853 return BUDB_NOTPERMITTED;
1854
1855 eval = InitRPC(&ut, LOCKREAD, 1);
1856 if (eval)
1857 return (eval);
1858
1859 *clonetime = 0;
1860
1861 /* Search for the volume by name */
1862 eval = ht_LookupEntry(ut, &db.volName, volName, &hvia, &vi);
1863 if (eval)
1864 ABORT(eval);
1865 if (!hvia)
1866 ABORT(BUDB_NOVOLUMENAME);
1867 rvi = 0;
1868
1869 /* Follw the dump levels up */
1870 for (; dumpID; dumpID = ntohl(d.parent)) { /*d */
1871 /* Get the dump entry */
1872 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &da, &d);
1873 if (eval)
1874 ABORT(eval);
1875 if (!da)
1876 ABORT(BUDB_NODUMPID);
1877
1878 /* seach all the volInfo entries on the sameNameChain */
1879 for (via = hvia; via; via = ntohl(vi.sameNameChain)) { /*via */
1880 if (rvi) { /* Read the volInfo entry - except first time */
1881 eval = dbread(ut, via, &vi, sizeof(vi));
1882 if (eval)
1883 ABORT(eval);
1884 }
1885 rvi = 1;
1886
1887 /* search all the volFrag entries on the volFrag */
1888 for (vfa = ntohl(vi.firstFragment); vfa; vfa = ntohl(vf.sameNameChain)) { /*vfa */
1889 eval = dbread(ut, vfa, &vf, sizeof(vf)); /* Read the volFrag entry */
1890 if (eval)
1891 ABORT(eval);
1892
1893 eval = dbread(ut, ntohl(vf.tape), &t, sizeof(t)); /* Read the tape */
1894 if (eval)
1895 ABORT(eval);
1896
1897 /* Now check to see if this fragment belongs to the dump we have */
1898 if (ntohl(t.dump) == da) {
1899 *clonetime = ntohl(vf.clone); /* return the clone */
1900 ERROR(0);
1901 }
1902 } /*vfa */
1903 } /*via */
1904 } /*d */
1905
1906 error_exit:
1907 code = ubik_EndTrans(ut);
1908 return (code);
1909
1910 abort_exit:
1911 ubik_EndTrans(ut);
1912 return (code);
1913 }
1914
1915 #ifdef notdef
1916 /*
1917 * Searches each tape and each volume in the dump until the volume is found.
1918 * If the volume is not in the dump, then we search it's parent dump.
1919 *
1920 * Re-write to do lookups by volume name.
1921 */
1922 afs_int32
1923 FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1924 afs_int32 *clonetime)
1925 {
1926 struct ubik_trans *ut;
1927 dbadr diskAddr, tapeAddr, volFragmentAddr;
1928 struct dump dump;
1929 struct tape tape;
1930 struct volFragment volFragment;
1931 struct volInfo volInfo;
1932 afs_int32 eval, code = 0;
1933
1934 if (!callPermitted(call))
1935 return BUDB_NOTPERMITTED;
1936
1937 eval = InitRPC(&ut, LOCKREAD, 1);
1938 if (eval)
1939 return (eval);
1940
1941 *clonetime = 0;
1942
1943 for (; dumpID; dumpID = ntohl(dump.parent)) { /*d */
1944 /* Get the dump entry */
1945 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &diskAddr, &dump);
1946 if (eval)
1947 ABORT(eval);
1948 if (!diskAddr)
1949 ABORT(BUDB_NODUMPID);
1950
1951 /* just to be sure */
1952 if (ntohl(dump.id) != dumpID) {
1953 LogDebug(4, "BUDB_FindClone: requested %d, found %d\n", dumpID,
1954 ntohl(dump.id));
1955 ABORT(BUDB_INTERNALERROR);
1956 }
1957
1958 /* search all the tapes in this dump */
1959 for (tapeAddr = ntohl(dump.firstTape); tapeAddr; tapeAddr = ntohl(tape.nextTape)) { /*t */
1960 /* Get the tape entry */
1961 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
1962 if (eval)
1963 ABORT(eval);
1964
1965 /* search all the volume fragments on this tape */
1966 for (volFragmentAddr = ntohl(tape.firstVol); volFragmentAddr; volFragmentAddr = ntohl(volFragment.sameTapeChain)) { /*vf */
1967 /* Get the volume fragment entry */
1968 eval =
1969 dbread(ut, volFragmentAddr, &volFragment,
1970 sizeof(volFragment));
1971 if (eval)
1972 ABORT(eval);
1973
1974 /* Get the volume info entry */
1975 eval =
1976 dbread(ut, ntohl(volFragment.vol), &volInfo,
1977 sizeof(volInfo));
1978 if (eval)
1979 ABORT(eval);
1980
1981 /* check if this volume is the one we want */
1982 if (strcmp(volInfo.name, volName) == 0) {
1983 *clonetime = ntohl(volFragment.clone);
1984 ERROR(0);
1985 }
1986 } /*vf */
1987 } /*t */
1988 } /*d */
1989
1990 error_exit:
1991 code = ubik_EndTrans(ut);
1992 return (code);
1993
1994 abort_exit:
1995 ubik_EndTrans(ut);
1996 return (code);
1997 }
1998 #endif
1999
2000 /* BUDB_FindDump
2001 * Find latest volume dump before adate.
2002 * Used by restore code when restoring a user requested volume(s)
2003 * entry:
2004 * volumeName - name of volume to match on
2005 * beforeDate - look for dumps older than this date
2006 * exit:
2007 * deptr - descriptor of most recent dump
2008 */
2009
2010 afs_int32
2011 SBUDB_FindDump(struct rx_call *call, char *volumeName, afs_int32 beforeDate,
2012 struct budb_dumpEntry *deptr)
2013 {
2014 afs_int32 code;
2015
2016 code = FindDump(call, volumeName, beforeDate, deptr);
2017 osi_auditU(call, BUDB_FndDmpEvent, code, AUD_STR, volumeName, AUD_END);
2018 return code;
2019 }
2020
2021 afs_int32
2022 FindDump(struct rx_call *call, char *volumeName, afs_int32 beforeDate,
2023 struct budb_dumpEntry *deptr)
2024 {
2025 struct ubik_trans *ut;
2026 dbadr volInfoAddr, volFragmentAddr;
2027 struct tape tape;
2028 struct volInfo volInfo;
2029 struct volFragment volFragment;
2030
2031 dbadr selectedDumpAddr = 0;
2032 afs_int32 selectedDate = 0;
2033 afs_int32 volCloned;
2034 int rvoli;
2035 afs_int32 eval, code = 0;
2036
2037 if (!callPermitted(call))
2038 return BUDB_NOTPERMITTED;
2039
2040 eval = InitRPC(&ut, LOCKREAD, 1);
2041 if (eval)
2042 return eval;
2043
2044 /* Find volinfo struct for volume name in hash table */
2045 eval =
2046 ht_LookupEntry(ut, &db.volName, volumeName, &volInfoAddr, &volInfo);
2047 if (eval)
2048 ABORT(eval);
2049 if (!volInfoAddr)
2050 ABORT(BUDB_NOVOLUMENAME);
2051
2052 /* Step through all the volinfo structures on the same name chain.
2053 * No need to read the first - we read it above.
2054 */
2055 for (rvoli = 0; volInfoAddr;
2056 rvoli = 1, volInfoAddr = ntohl(volInfo.sameNameChain)) {
2057 if (rvoli) { /* read the volinfo structure */
2058 eval = dbread(ut, volInfoAddr, &volInfo, sizeof(volInfo));
2059 if (eval)
2060 ABORT(eval);
2061 }
2062
2063 /* step through the volfrag structures */
2064 for (volFragmentAddr = ntohl(volInfo.firstFragment); volFragmentAddr;
2065 volFragmentAddr = ntohl(volFragment.sameNameChain)) {
2066 /* read the volfrag struct */
2067 eval =
2068 dbread(ut, volFragmentAddr, &volFragment,
2069 sizeof(volFragment));
2070 if (eval)
2071 ABORT(eval);
2072
2073 volCloned = ntohl(volFragment.clone);
2074
2075 /* now we can examine the date for most recent dump */
2076 if ((volCloned > selectedDate) && (volCloned < beforeDate)) {
2077 /* from the volfrag struct, read the tape struct */
2078 eval =
2079 dbread(ut, ntohl(volFragment.tape), &tape, sizeof(tape));
2080 if (eval)
2081 ABORT(eval);
2082
2083 selectedDate = volCloned;
2084 selectedDumpAddr = ntohl(tape.dump);
2085 }
2086 }
2087 }
2088
2089 if (!selectedDumpAddr)
2090 ABORT(BUDB_NOENT);
2091
2092 eval = FillDumpEntry(ut, selectedDumpAddr, deptr);
2093 if (eval)
2094 ABORT(eval);
2095
2096 code = ubik_EndTrans(ut);
2097 return (code);
2098
2099 abort_exit:
2100 ubik_EndTrans(ut);
2101 return (code);
2102 }
2103
2104 /* BUDB_FindLatestDump
2105 * Find the latest dump of volumeset vsname with dump name dname.
2106 * entry:
2107 * vsname - volumeset name
2108 * dname - dumpname
2109 */
2110
2111 afs_int32
2112 SBUDB_FindLatestDump(struct rx_call *call, char *vsname, char *dumpPath,
2113 struct budb_dumpEntry *dumpentry)
2114 {
2115 afs_int32 code;
2116
2117 code = FindLatestDump(call, vsname, dumpPath, dumpentry);
2118 osi_auditU(call, BUDB_FndLaDEvent, code, AUD_STR, vsname, AUD_END);
2119 return code;
2120 }
2121
2122 afs_int32
2123 FindLatestDump(struct rx_call *call, char *vsname, char *dumpPath,
2124 struct budb_dumpEntry *dumpentry)
2125 {
2126 struct ubik_trans *ut;
2127 dbadr curdbaddr, retdbaddr, firstdbaddr;
2128 struct dump d;
2129 Date latest;
2130 char dumpName[BU_MAXNAMELEN + 2];
2131 afs_int32 eval, code = 0;
2132
2133 if (!callPermitted(call))
2134 return BUDB_NOTPERMITTED;
2135
2136 eval = InitRPC(&ut, LOCKREAD, 1);
2137 if (eval)
2138 return (eval);
2139
2140 if ((strcmp(vsname, "") == 0) && (strcmp(dumpPath, "") == 0)) {
2141 /* Construct a database dump name */
2142 strcpy(dumpName, DUMP_TAPE_NAME);
2143 } else if (strchr(dumpPath, '/') == 0) {
2144 int level, old, length, hash;
2145 struct dump hostDump, diskDump;
2146 struct memoryHashTable *mht;
2147 int entrySize;
2148 dbadr dbAddr;
2149 afs_uint32 bestDumpId = 0;
2150
2151 level = atoi(dumpPath);
2152 if (level < 0) {
2153 ABORT(BUDB_BADARGUMENT);
2154 }
2155
2156 /* Brute force search of all the dumps in the database - yuck! */
2157
2158 retdbaddr = 0;
2159 mht = ht_GetType(HT_dumpIden_FUNCTION, &entrySize);
2160 if (!mht)
2161 ABORT(BUDB_BADARGUMENT);
2162
2163 for (old = 0; old <= 1; old++) { /*fo */
2164 length = (old ? mht->oldLength : mht->length);
2165 if (!length)
2166 continue;
2167
2168 for (hash = 0; hash < length; hash++) {
2169 /*f */
2170 for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr;
2171 dbAddr = hostDump.idHashChain) {
2172 /*w */
2173 eval = dbread(ut, dbAddr, &diskDump, sizeof(diskDump));
2174 if (eval)
2175 ABORT(eval);
2176 dump_ntoh(&diskDump, &hostDump);
2177
2178 if ((strcmp(hostDump.volumeSet, vsname) == 0) && /* the volumeset */
2179 (hostDump.level == level) && /* same level */
2180 (hostDump.id > bestDumpId)) { /* more recent */
2181 bestDumpId = hostDump.id;
2182 retdbaddr = dbAddr;
2183 }
2184 } /*w */
2185 } /*f */
2186 } /*fo */
2187 if (!retdbaddr)
2188 ABORT(BUDB_NODUMPNAME);
2189
2190 goto finished;
2191 } else {
2192 /* construct the name of the dump */
2193 if ((strlen(vsname) + strlen(tailCompPtr(dumpPath))) > BU_MAXNAMELEN)
2194 ABORT(BUDB_NODUMPNAME);
2195
2196 strcpy(dumpName, vsname);
2197 strcat(dumpName, ".");
2198 strcat(dumpName, tailCompPtr(dumpPath));
2199 }
2200
2201 LogDebug(5, "lookup on :%s:\n", dumpName);
2202
2203 /* Lookup on dumpname in hash table */
2204 eval = ht_LookupEntry(ut, &db.dumpName, dumpName, &firstdbaddr, &d);
2205 if (eval)
2206 ABORT(eval);
2207
2208 latest = 0;
2209 retdbaddr = 0;
2210
2211 /* folow remaining dumps in hash chain, looking for most latest dump */
2212 for (curdbaddr = firstdbaddr; curdbaddr;
2213 curdbaddr = ntohl(d.nameHashChain)) {
2214 if (curdbaddr != firstdbaddr) {
2215 eval = dbread(ut, curdbaddr, &d, sizeof(d));
2216 if (eval)
2217 ABORT(eval);
2218 }
2219
2220 if ((strcmp(d.dumpPath, dumpPath) == 0) && /* Same dumppath */
2221 (strcmp(d.dumpName, dumpName) == 0) && /* Same dumpname */
2222 (ntohl(d.created) > latest)) { /* most recent */
2223 latest = ntohl(d.created);
2224 retdbaddr = curdbaddr;
2225 }
2226 }
2227 if (!retdbaddr)
2228 ABORT(BUDB_NODUMPNAME);
2229
2230 finished:
2231 /* return the dump found */
2232 FillDumpEntry(ut, retdbaddr, dumpentry);
2233
2234 code = ubik_EndTrans(ut);
2235 return (code);
2236
2237 abort_exit:
2238 ubik_AbortTrans(ut);
2239 return (code);
2240 }
2241
2242
2243 afs_int32
2244 SBUDB_FinishDump(struct rx_call *call, struct budb_dumpEntry *dump)
2245 {
2246 afs_int32 code;
2247
2248 code = FinishDump(call, dump);
2249 osi_auditU(call, BUDB_FinDmpEvent, code, AUD_DATE, (dump ? dump->id : 0),
2250 AUD_END);
2251 return code;
2252 }
2253
2254 afs_int32
2255 FinishDump(struct rx_call *call, struct budb_dumpEntry *dump)
2256 {
2257 struct ubik_trans *ut;
2258 dbadr a;
2259 struct dump d;
2260 afs_int32 eval, code = 0;
2261
2262 if (!callPermitted(call))
2263 return BUDB_NOTPERMITTED;
2264
2265 eval = InitRPC(&ut, LOCKWRITE, 1);
2266 if (eval)
2267 return eval;
2268
2269 eval = ht_LookupEntry(ut, &db.dumpIden, &dump->id, &a, &d);
2270 if (eval)
2271 ABORT(eval);
2272 if (!a)
2273 ABORT(BUDB_NODUMPID);
2274
2275 if ((ntohl(d.flags) & BUDB_DUMP_INPROGRESS) == 0)
2276 ABORT(BUDB_DUMPNOTINUSE);
2277
2278 d.flags = htonl(dump->flags & ~BUDB_DUMP_INPROGRESS);
2279
2280 /* if creation time specified set it */
2281 if (dump->created)
2282 d.created = htonl(dump->created);
2283 dump->created = ntohl(d.created);
2284
2285 /* Write the dump entry out */
2286 eval = dbwrite(ut, a, &d, sizeof(d));
2287 if (eval)
2288 ABORT(eval);
2289
2290 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
2291 if (eval)
2292 ABORT(eval);
2293
2294 code = ubik_EndTrans(ut);
2295 return code;
2296
2297 abort_exit:
2298 ubik_AbortTrans(ut);
2299 return code;
2300 }
2301
2302 afs_int32
2303 SBUDB_FinishTape(struct rx_call *call, struct budb_tapeEntry *tape)
2304 {
2305 afs_int32 code;
2306
2307 code = FinishTape(call, tape);
2308 osi_auditU(call, BUDB_FinTpeEvent, code, AUD_DATE,
2309 (tape ? tape->dump : 0), AUD_END);
2310 return code;
2311 }
2312
2313 afs_int32
2314 FinishTape(struct rx_call *call, struct budb_tapeEntry *tape)
2315 {
2316 struct ubik_trans *ut;
2317 dbadr a;
2318 struct tape t;
2319 struct dump d;
2320 afs_int32 eval, code = 0;
2321
2322 if (!callPermitted(call))
2323 return BUDB_NOTPERMITTED;
2324
2325 eval = InitRPC(&ut, LOCKWRITE, 1);
2326 if (eval)
2327 return eval;
2328
2329 /* find the tape struct in the tapename hash chain */
2330 eval = ht_LookupEntry(ut, &db.tapeName, tape->name, &a, &t);
2331 if (eval)
2332 ABORT(eval);
2333 if (!a)
2334 ABORT(BUDB_NOTAPENAME);
2335
2336 /* Read the dump structure */
2337 eval = dbread(ut, ntohl(t.dump), &d, sizeof(d));
2338 if (eval)
2339 ABORT(eval);
2340
2341 /* search for the right tape on the rest of the chain */
2342 while (ntohl(d.id) != tape->dump) {
2343 a = ntohl(t.nameHashChain);
2344 if (!a)
2345 ABORT(BUDB_NOTAPENAME);
2346
2347 eval = dbread(ut, a, &t, sizeof(t));
2348 if (eval)
2349 ABORT(eval);
2350
2351 eval = dbread(ut, ntohl(t.dump), &d, sizeof(d));
2352 if (eval)
2353 ABORT(eval);
2354 }
2355
2356 if ((ntohl(t.flags) & BUDB_TAPE_BEINGWRITTEN) == 0)
2357 ABORT(BUDB_TAPENOTINUSE);
2358
2359 /* t.nBytes = htonl(tape->nBytes); */
2360 t.nFiles = htonl(tape->nFiles);
2361 t.useKBytes = htonl(tape->useKBytes);
2362 t.flags = htonl(tape->flags & ~BUDB_TAPE_BEINGWRITTEN);
2363
2364 eval = dbwrite(ut, a, &t, sizeof(t));
2365 if (eval)
2366 ABORT(BUDB_IO);
2367
2368 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
2369 if (eval)
2370 ABORT(eval);
2371
2372 code = ubik_EndTrans(ut);
2373 return code;
2374
2375 abort_exit:
2376 ubik_AbortTrans(ut);
2377 return code;
2378 }
2379
2380 /* BUDB_GetDumps
2381 * return a set of dumps that match the specified criteria
2382 * entry:
2383 * call - rx call
2384 * majorVersion - version of interface structures. Permits compatibility
2385 * checks to be made
2386 * flags - for search and select operations. Broken down into flags
2387 * for name, start point, end point and time.
2388 * name - name to search for. Interpretation based on flags
2389 * end
2390 * index
2391 * nextIndexP
2392 * dbTimeP
2393 * exit:
2394 * nextIndexP
2395 * dbTimeP - time at which the database was last modified. Up to
2396 * caller (client) to take appropriate action if database
2397 * modified between successive calls
2398 * dumps - list of matching dumps
2399 * notes:
2400 * currently supported are:
2401 * BUDB_OP_DUMPNAME
2402 * BUDB_OP_DUMPID
2403 */
2404
2405 afs_int32
2406 SBUDB_GetDumps(struct rx_call *call,
2407 afs_int32 majorVersion, /* version of interface structures */
2408 afs_int32 flags, /* search & select controls */
2409 char *name, /* s&s parameters */
2410 afs_int32 start,
2411 afs_int32 end,
2412 afs_int32 index, /* start index of returned entries */
2413 afs_int32 *nextIndexP, /* output index for next call */
2414 afs_int32 *dbTimeP,
2415 budb_dumpList *dumps) /* pointer to buffer */
2416 {
2417 afs_int32 code;
2418
2419 code =
2420 GetDumps(call, majorVersion, flags, name, start, end, index,
2421 nextIndexP, dbTimeP, dumps);
2422 osi_auditU(call, BUDB_GetDmpEvent, code, AUD_END);
2423 return code;
2424 }
2425
2426 afs_int32
2427 GetDumps(struct rx_call *call,
2428 afs_int32 majorVersion, /* version of interface structures */
2429 afs_int32 flags, /* search & select controls */
2430 char *name, /* s&s parameters */
2431 afs_int32 start,
2432 afs_int32 end,
2433 afs_int32 index, /* start index of returned entries */
2434 afs_int32 *nextIndexP, /* output index for next call */
2435 afs_int32 *dbTimeP,
2436 budb_dumpList *dumps) /* pointer to buffer */
2437 {
2438 struct ubik_trans *ut;
2439 dbadr da;
2440 struct dump d;
2441 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
2442 afs_int32 eval, code = 0;
2443 afs_int32 toskip;
2444 struct returnList list;
2445
2446 /* Don't check permissions when we look up a specific dump id */
2447 if (((flags & BUDB_OP_STARTS) != BUDB_OP_DUMPID) && !callPermitted(call))
2448 return BUDB_NOTPERMITTED;
2449
2450 if (majorVersion != BUDB_MAJORVERSION)
2451 return BUDB_OLDINTERFACE;
2452 if (index < 0)
2453 return BUDB_ENDOFLIST;
2454
2455 eval = InitRPC(&ut, LOCKREAD, 1);
2456 if (eval)
2457 return eval;
2458
2459 nameFlags = flags & BUDB_OP_NAMES;
2460 startFlags = flags & BUDB_OP_STARTS;
2461 endFlags = flags & BUDB_OP_ENDS;
2462 timeFlags = flags & BUDB_OP_TIMES;
2463
2464 InitReturnList(&list);
2465 toskip = index;
2466
2467 if (nameFlags == BUDB_OP_DUMPNAME) {
2468 /* not yet implemented */
2469 if (startFlags || endFlags || timeFlags)
2470 ABORT(BUDB_BADFLAGS);
2471
2472 eval = ht_LookupEntry(ut, &db.dumpName, name, &da, &d);
2473 if (eval)
2474 ABORT(eval);
2475 if (!da)
2476 ABORT(BUDB_NODUMPNAME);
2477
2478 while (1) {
2479 if (strcmp(d.dumpName, name) == 0) {
2480 eval = AddToReturnList(&list, da, &toskip);
2481 if (eval == BUDB_LIST2BIG)
2482 break;
2483 if (eval)
2484 ABORT(eval);
2485 }
2486
2487 da = ntohl(d.nameHashChain); /* get next dump w/ name */
2488 if (!da)
2489 break;
2490
2491 eval = dbread(ut, da, &d, sizeof(d));
2492 if (eval)
2493 ABORT(eval);
2494 }
2495 } else if (nameFlags == BUDB_OP_VOLUMENAME) {
2496 #ifdef PA
2497 struct volInfo vi;
2498
2499 LogError(0, "NYI, BUDB_OP_VOLUMENAME\n");
2500 ABORT(BUDB_BADFLAGS);
2501
2502
2503 if (startFlags != BUDB_OP_STARTTIME)
2504 ABORT(BUDB_BADFLAGS);
2505
2506 /* lookup a dump by volumename and time stamp. Find the most recent
2507 * dump of the specified volumename, that occured before the supplied
2508 * time
2509 */
2510
2511 /* get us a volInfo for name */
2512 eval = ht_LookupEntry(ut, &db.volName, name, &da, &vi);
2513 if (eval)
2514 ABORT(eval);
2515
2516 while (1) {
2517 /* now iterate over all the entries of this name */
2518 for (va = vi.firstFragment; va != 0; va = v.sameNameChain) {
2519 va = ntohl(va);
2520 eval = dbread(ut, va, &v, sizeof(v));
2521 if (eval)
2522 ABORT(eval);
2523
2524 if date
2525 on fragment > date ignore it - too recent;
2526
2527 if (date on fragment < date && date on fragment > bestfound)
2528 bestfound = date on fragment;
2529
2530 } /* for va */
2531
2532 da = vi.sameNameChain;
2533 if (da == 0)
2534 break;
2535 da = ntohl(da);
2536 eval = dbread(ut, da, &vi, sizeof(vi));
2537 if (eval)
2538 ABORT(eval);
2539 }
2540
2541 /*
2542 if nothing found
2543 return error
2544
2545 from saved volfragment address, compute dump.
2546 otherwise, return dump found
2547 */
2548
2549 #endif /* PA */
2550
2551 } else if (startFlags == BUDB_OP_DUMPID) {
2552 if (endFlags || timeFlags)
2553 ABORT(BUDB_BADFLAGS);
2554 if (nameFlags)
2555 ABORT(BUDB_BADFLAGS); /* NYI */
2556
2557 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &da, &d);
2558 if (eval)
2559 ABORT(eval);
2560 if (!da)
2561 ABORT(BUDB_NODUMPID);
2562
2563 eval = AddToReturnList(&list, da, &toskip);
2564 if (eval)
2565 ABORT(eval);
2566 } else if (endFlags == BUDB_OP_NPREVIOUS) {
2567 struct wantDumpRock rock;
2568 struct chosenDump *ptr, *nextPtr;
2569
2570 /* no other flags should be set */
2571
2572 /* end specifies how many dumps */
2573 if (!end)
2574 ABORT(BUDB_BADFLAGS);
2575
2576 memset(&rock, 0, sizeof(rock));
2577 rock.maxDumps = end;
2578
2579 scanHashTable(ut, &db.dumpName, wantDump, rememberDump,
2580 (char *)&rock);
2581
2582 for (ptr = rock.chain; ptr; ptr = nextPtr) {
2583 nextPtr = ptr->next;
2584 AddToReturnList(&list, ptr->addr, &toskip); /* ignore error for free */
2585 free(ptr);
2586 }
2587 } else {
2588 ABORT(BUDB_BADFLAGS);
2589 }
2590
2591 eval =
2592 SendReturnList(ut, &list, FillDumpEntry,
2593 sizeof(struct budb_dumpEntry), index, nextIndexP,
2594 dbTimeP, (returnList_t) dumps);
2595 if (eval)
2596 ABORT(eval);
2597
2598 FreeReturnList(&list);
2599 code = ubik_EndTrans(ut);
2600 return code;
2601
2602 abort_exit:
2603 FreeReturnList(&list);
2604 ubik_AbortTrans(ut);
2605 return code;
2606 }
2607
2608 /*
2609 * Get the expiration of a tape. Since the dump could have appended dumps,
2610 * we should use the most recent expiration date. Put the most recent
2611 * expiration tape into the given tape structure.
2612 */
2613 afs_int32
2614 getExpiration(struct ubik_trans *ut, struct tape *tapePtr)
2615 {
2616 dbadr ad;
2617 struct dump d;
2618 struct tape t;
2619 afs_int32 initDump;
2620 afs_int32 eval, code = 0;
2621
2622 if (!tapePtr)
2623 ERROR(0);
2624
2625 /* Get the dump for this tape */
2626 ad = ntohl(tapePtr->dump);
2627 eval = dbread(ut, ad, &d, sizeof(d));
2628 if (eval)
2629 ERROR(eval);
2630
2631 /* If not an initial dump, get the initial dump */
2632 if (d.initialDumpID) {
2633 initDump = ntohl(d.initialDumpID);
2634 eval = ht_LookupEntry(ut, &db.dumpIden, &initDump, &ad, &d);
2635 if (eval)
2636 ERROR(eval);
2637 }
2638
2639 /* Cycle through the dumps and appended dumps */
2640 while (ad) {
2641 /* Get the first tape in this dump. No need to check the rest of the tapes */
2642 /* for this dump since they will all have the same expiration date */
2643 eval = dbread(ut, ntohl(d.firstTape), &t, sizeof(t));
2644 if (eval)
2645 ERROR(eval);
2646
2647 /* Take the greater of the expiration dates */
2648 if (ntohl(tapePtr->expires) < ntohl(t.expires))
2649 tapePtr->expires = t.expires;
2650
2651 /* Step to and read the next appended dump */
2652 if ((ad = ntohl(d.appendedDumpChain))) {
2653 eval = dbread(ut, ad, &d, sizeof(d));
2654 if (eval)
2655 ERROR(eval);
2656 }
2657 }
2658
2659 error_exit:
2660 return (code);
2661 }
2662
2663 /* Mark the following dump as appended to another, intial dump */
2664 afs_int32
2665 makeAppended(struct ubik_trans *ut, afs_int32 appendedDumpID,
2666 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2667 {
2668 dbadr ada, da, lastDumpAddr;
2669 struct dump ad, d;
2670 afs_int32 eval, code = 0;
2671
2672 if (!initialDumpID)
2673 ERROR(0);
2674 if (appendedDumpID == initialDumpID)
2675 ERROR(BUDB_INTERNALERROR);
2676
2677 /* If there is an initial dump, append this dump to it */
2678 /* Find the appended dump via its id */
2679 eval = ht_LookupEntry(ut, &db.dumpIden, &appendedDumpID, &ada, &ad);
2680 if (eval)
2681 ERROR(eval);
2682
2683 /* If the dump is already marked as appended,
2684 * then we have an internal error.
2685 */
2686 if (ad.initialDumpID) {
2687 if (ntohl(ad.initialDumpID) != initialDumpID)
2688 ERROR(BUDB_INTERNALERROR);
2689 }
2690
2691 /* Update the appended dump to point to the initial dump */
2692 ad.initialDumpID = htonl(initialDumpID);
2693 ad.tapes.b = htonl(startTapeSeq);
2694
2695 /* find the initial dump via its id */
2696 eval = ht_LookupEntry(ut, &db.dumpIden, &initialDumpID, &da, &d);
2697 if (eval)
2698 ERROR(eval);
2699
2700 /* Update the appended dump's tape format with that of the initial */
2701 strcpy(ad.tapes.format, d.tapes.format);
2702
2703 /* starting with the initial dump step through its appended dumps till
2704 * we reach the last appended dump.
2705 */
2706 lastDumpAddr = da;
2707 while (d.appendedDumpChain) {
2708 lastDumpAddr = ntohl(d.appendedDumpChain);
2709 if (lastDumpAddr == ada)
2710 ERROR(0); /* Already appended */
2711 eval = dbread(ut, lastDumpAddr, &d, sizeof(d));
2712 if (eval)
2713 ERROR(eval);
2714 }
2715
2716 /* Update the last dump to point to our new appended dump.
2717 * The appended dump is the last one in the dump chain.
2718 */
2719 d.appendedDumpChain = htonl(ada);
2720 ad.appendedDumpChain = 0;
2721
2722 /* Write the appended dump and the initial dump */
2723 eval = dbwrite(ut, ada, (char *)&ad, sizeof(ad));
2724 if (eval)
2725 ERROR(eval);
2726
2727 eval = dbwrite(ut, lastDumpAddr, (char *)&d, sizeof(d));
2728 if (eval)
2729 ERROR(eval);
2730
2731 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
2732 if (eval)
2733 ERROR(eval);
2734
2735 error_exit:
2736 return (code);
2737 }
2738
2739 afs_int32
2740 SBUDB_MakeDumpAppended(struct rx_call *call, afs_int32 appendedDumpID,
2741 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2742 {
2743 afs_int32 code;
2744
2745 code =
2746 MakeDumpAppended(call, appendedDumpID, initialDumpID, startTapeSeq);
2747 osi_auditU(call, BUDB_AppDmpEvent, code, AUD_LONG, appendedDumpID,
2748 AUD_END);
2749 return code;
2750 }
2751
2752 afs_int32
2753 MakeDumpAppended(struct rx_call *call, afs_int32 appendedDumpID,
2754 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2755 {
2756 struct ubik_trans *ut;
2757 afs_int32 eval, code = 0;
2758
2759 if (!callPermitted(call))
2760 return BUDB_NOTPERMITTED;
2761
2762 eval = InitRPC(&ut, LOCKWRITE, 1);
2763 if (eval)
2764 return (eval);
2765
2766 eval = makeAppended(ut, appendedDumpID, initialDumpID, startTapeSeq);
2767 if (eval)
2768 ABORT(eval);
2769
2770 code = ubik_EndTrans(ut);
2771 return (code);
2772
2773 abort_exit:
2774 ubik_AbortTrans(ut);
2775 return (code);
2776 }
2777
2778 /* Find the last tape of a dump-set. This includes any appended dumps */
2779 afs_int32
2780 SBUDB_FindLastTape(struct rx_call *call, afs_int32 dumpID,
2781 struct budb_dumpEntry *dumpEntry,
2782 struct budb_tapeEntry *tapeEntry,
2783 struct budb_volumeEntry *volEntry)
2784 {
2785 afs_int32 code;
2786
2787 code = FindLastTape(call, dumpID, dumpEntry, tapeEntry, volEntry);
2788 osi_auditU(call, BUDB_FndLTpeEvent, code, AUD_LONG, dumpID, AUD_END);
2789 return code;
2790 }
2791
2792 afs_int32
2793 FindLastTape(struct rx_call *call, afs_int32 dumpID,
2794 struct budb_dumpEntry *dumpEntry,
2795 struct budb_tapeEntry *tapeEntry,
2796 struct budb_volumeEntry *volEntry)
2797 {
2798 struct ubik_trans *ut;
2799 struct dump d;
2800 dbadr lastDump;
2801 struct tape t;
2802 dbadr lastTape, thisTape;
2803 afs_int32 lastTapeSeq;
2804 struct volFragment vf;
2805 dbadr lastVol, thisVol;
2806 afs_int32 lastVolPos;
2807 afs_int32 eval, code = 0;
2808
2809 if (!callPermitted(call))
2810 return BUDB_NOTPERMITTED;
2811
2812 if (!dumpID)
2813 return (BUDB_BADARGUMENT);
2814
2815 eval = InitRPC(&ut, LOCKREAD, 1);
2816 if (eval)
2817 return (eval);
2818
2819 /* find and read its initial dump via its id */
2820 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &lastDump, &d);
2821 if (eval)
2822 ABORT(eval);
2823 if (!lastDump)
2824 ABORT(BUDB_NODUMPID);
2825
2826 /* Follow the append dumps link chain until we reach the last dump */
2827 while (d.appendedDumpChain) {
2828 lastDump = ntohl(d.appendedDumpChain);
2829 eval = dbread(ut, lastDump, &d, sizeof(d));
2830 if (eval)
2831 ABORT(eval);
2832 }
2833
2834 /* We now have the last dump of the last appended dump */
2835 /* Copy this into our return structure */
2836 eval = FillDumpEntry(ut, lastDump, dumpEntry);
2837 if (eval)
2838 ABORT(eval);
2839
2840 /* Fail if the last dump has no tapes */
2841 if (!d.firstTape)
2842 ABORT(BUDB_NOTAPENAME);
2843
2844 /* Follow the tapes in this dump until we reach the last tape */
2845 eval = dbread(ut, ntohl(d.firstTape), &t, sizeof(t));
2846 if (eval)
2847 ABORT(eval);
2848
2849 lastTape = ntohl(d.firstTape);
2850 lastTapeSeq = ntohl(t.seq);
2851 lastVol = ntohl(t.firstVol);
2852
2853 while (t.nextTape) {
2854 thisTape = ntohl(t.nextTape);
2855 eval = dbread(ut, thisTape, &t, sizeof(t));
2856 if (eval)
2857 ABORT(eval);
2858
2859 if (ntohl(t.seq) > lastTapeSeq) {
2860 lastTape = thisTape;
2861 lastTapeSeq = ntohl(t.seq);
2862 lastVol = ntohl(t.firstVol);
2863 }
2864 }
2865
2866 /* We now have the last tape of the last appended dump */
2867 /* Copy this into our return structure */
2868 eval = FillTapeEntry(ut, lastTape, tapeEntry);
2869 if (eval)
2870 ABORT(eval);
2871
2872 /* Zero volume entry if the last tape has no volumes */
2873 if (!lastVol) {
2874 memset(volEntry, 0, sizeof(*volEntry));
2875 } else {
2876 /* Follow the volumes until we reach the last volume */
2877 eval = dbread(ut, lastVol, &vf, sizeof(vf));
2878 if (eval)
2879 ABORT(eval);
2880
2881 lastVolPos = vf.position;
2882
2883 while (vf.sameTapeChain) {
2884 thisVol = ntohl(vf.sameTapeChain);
2885 eval = dbread(ut, thisVol, &vf, sizeof(vf));
2886 if (eval)
2887 ABORT(eval);
2888
2889 if (vf.position > lastVolPos) {
2890 lastVol = thisVol;
2891 lastVolPos = vf.position;
2892 }
2893 }
2894
2895 /* We now have the last volume of this tape */
2896 /* Copy this into our return structure */
2897 eval = FillVolEntry(ut, lastVol, volEntry);
2898 if (eval)
2899 ABORT(eval);
2900 }
2901
2902 eval = ubik_EndTrans(ut);
2903 if (!code)
2904 code = eval;
2905 return (code);
2906
2907 abort_exit:
2908 ubik_AbortTrans(ut);
2909 return (code);
2910 }
2911
2912
2913 afs_int32
2914 SBUDB_GetTapes(struct rx_call *call,
2915 afs_int32 majorVersion, /* version of interface structures */
2916 afs_int32 flags, /* search & select controls */
2917 char *name, /* s&s parameters */
2918 afs_int32 start,
2919 afs_int32 end, /* reserved: MBZ */
2920 afs_int32 index, /* start index of returned entries */
2921 afs_int32 *nextIndexP, /* output index for next call */
2922 afs_int32 *dbTimeP,
2923 budb_tapeList *tapes) /* pointer to buffer */
2924 {
2925 afs_int32 code;
2926
2927 code =
2928 GetTapes(call, majorVersion, flags, name, start, end, index,
2929 nextIndexP, dbTimeP, tapes);
2930 osi_auditU(call, BUDB_GetTpeEvent, code, AUD_END);
2931 return code;
2932 }
2933
2934 afs_int32
2935 GetTapes(struct rx_call *call,
2936 afs_int32 majorVersion, /* version of interface structures */
2937 afs_int32 flags, /* search & select controls */
2938 char *name, /* s&s parameters */
2939 afs_int32 start,
2940 afs_int32 end, /* reserved: MBZ */
2941 afs_int32 index, /* start index of returned entries */
2942 afs_int32 *nextIndexP, /* output index for next call */
2943 afs_int32 *dbTimeP,
2944 budb_tapeList *tapes) /* pointer to buffer */
2945 {
2946 struct ubik_trans *ut;
2947 dbadr da, ta;
2948 struct dump d;
2949 struct tape t;
2950 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
2951 struct returnList list;
2952 afs_int32 eval, code = 0;
2953 afs_int32 toskip;
2954
2955 if (!callPermitted(call))
2956 return BUDB_NOTPERMITTED;
2957
2958 if (majorVersion != BUDB_MAJORVERSION)
2959 return BUDB_OLDINTERFACE;
2960
2961 if (index < 0)
2962 return BUDB_ENDOFLIST;
2963
2964 eval = InitRPC(&ut, LOCKREAD, 1);
2965 if (eval)
2966 return eval;
2967
2968 nameFlags = flags & BUDB_OP_NAMES;
2969 startFlags = flags & BUDB_OP_STARTS;
2970 endFlags = flags & BUDB_OP_ENDS;
2971 timeFlags = flags & BUDB_OP_TIMES;
2972
2973 InitReturnList(&list);
2974 toskip = index;
2975
2976 if (nameFlags == BUDB_OP_TAPENAME) { /*it */
2977 eval = ht_LookupEntry(ut, &db.tapeName, name, &ta, &t);
2978 if (eval)
2979 ABORT(eval);
2980 if (!ta)
2981 ABORT(BUDB_NOTAPENAME);
2982
2983 /* NYI */
2984 if ((startFlags & ~BUDB_OP_DUMPID) || endFlags || timeFlags)
2985 ABORT(BUDB_BADFLAGS);
2986
2987 /* follow the hash chain to the end */
2988 while (ta) { /*w */
2989 if (startFlags & BUDB_OP_DUMPID) {
2990 /* read in the dump */
2991 eval = dbread(ut, ntohl(t.dump), &d, sizeof(d));
2992 if (eval)
2993 ABORT(eval);
2994
2995 /* check if both name and dump id match */
2996 if ((strcmp(name, t.name) == 0) && (ntohl(d.id) == start)) {
2997 eval = AddToReturnList(&list, ta, &toskip);
2998 if (eval && (eval != BUDB_LIST2BIG))
2999 ABORT(eval);
3000 break;
3001 }
3002 } else {
3003 /* Add to return list and continue search */
3004 if (strcmp(name, t.name) == 0) {
3005 eval = AddToReturnList(&list, ta, &toskip);
3006 if (eval == BUDB_LIST2BIG)
3007 break;
3008 if (eval)
3009 ABORT(eval);
3010 }
3011 }
3012
3013 ta = ntohl(t.nameHashChain);
3014 if (ta)
3015 dbread(ut, ta, &t, sizeof(t));
3016 } /*w */
3017 } /*it */
3018 else if (nameFlags == BUDB_OP_TAPESEQ) {
3019 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &da, &d);
3020 if (eval)
3021 ABORT(eval);
3022 if (!da)
3023 ABORT(BUDB_NODUMPNAME);
3024
3025 /* search for the right tape */
3026 ta = ntohl(d.firstTape);
3027 for (ta = ntohl(d.firstTape); ta; ta = ntohl(t.nextTape)) {
3028 eval = dbread(ut, ta, &t, sizeof(t));
3029 if (eval)
3030 ABORT(eval);
3031
3032 if (ntohl(t.seq) == end) {
3033 eval = AddToReturnList(&list, ta, &toskip);
3034 if (eval && (eval != BUDB_LIST2BIG))
3035 ABORT(eval);
3036 break;
3037 }
3038 }
3039 } else {
3040 ABORT(BUDB_BADFLAGS);
3041 }
3042
3043 eval =
3044 SendReturnList(ut, &list, FillTapeEntry,
3045 sizeof(struct budb_tapeEntry), index, nextIndexP,
3046 dbTimeP, (returnList_t) tapes);
3047 if (eval)
3048 ABORT(eval);
3049
3050 FreeReturnList(&list);
3051 code = ubik_EndTrans(ut);
3052 return code;
3053
3054 abort_exit:
3055 FreeReturnList(&list);
3056 ubik_AbortTrans(ut);
3057 return (code);
3058 }
3059
3060 /* BUDB_GetVolumes
3061 * get a set of volumes according to the specified criteria.
3062 * See BUDB_GetDumps for general information on parameters
3063 * Currently supports:
3064 * 1) volume match - returns volumes based on volume name only.
3065 * 2) flags = BUDB_OP_DUMPID in which case name is a volume name
3066 * and start is a dumpid. Returns all volumes of the specified
3067 * name on the selected dumpid.
3068 */
3069
3070 afs_int32
3071 SBUDB_GetVolumes(struct rx_call *call,
3072 afs_int32 majorVersion, /* version of interface structures */
3073 afs_int32 flags, /* search & select controls */
3074 char *name, /* - parameters for search */
3075 afs_int32 start, /* - usage depends which BUDP_OP */
3076 afs_int32 end, /* - bits are set */
3077 afs_int32 index, /* start index of returned entries */
3078 afs_int32 *nextIndexP, /* output index for next call */
3079 afs_int32 *dbTimeP,
3080 budb_volumeList *volumes) /* pointer to buffer */
3081 {
3082 afs_int32 code;
3083
3084 code =
3085 GetVolumes(call, majorVersion, flags, name, start, end, index,
3086 nextIndexP, dbTimeP, volumes);
3087 osi_auditU(call, BUDB_GetVolEvent, code, AUD_END);
3088 return code;
3089 }
3090
3091 afs_int32
3092 GetVolumes(struct rx_call *call,
3093 afs_int32 majorVersion, /* version of interface structures */
3094 afs_int32 flags, /* search & select controls */
3095 char *name, /* - parameters for search */
3096 afs_int32 start, /* - usage depends which BUDP_OP_* */
3097 afs_int32 end, /* - bits are set */
3098 afs_int32 index, /* start index of returned entries */
3099 afs_int32 *nextIndexP, /* output index for next call */
3100 afs_int32 *dbTimeP,
3101 budb_volumeList *volumes) /* pointer to buffer */
3102 {
3103 struct ubik_trans *ut;
3104 dbadr via;
3105 struct volInfo vi;
3106 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
3107 afs_int32 eval, code = 0;
3108 struct returnList vollist;
3109 afs_int32 toskip;
3110
3111 /* Don't check permissions when we look up a specific volume name */
3112 if (((flags & BUDB_OP_NAMES) != BUDB_OP_VOLUMENAME)
3113 && !callPermitted(call))
3114 return BUDB_NOTPERMITTED;
3115
3116 if (majorVersion != BUDB_MAJORVERSION)
3117 return BUDB_OLDINTERFACE;
3118 if (index < 0)
3119 return BUDB_ENDOFLIST;
3120
3121 eval = InitRPC(&ut, LOCKREAD, 1);
3122 if (eval)
3123 return eval;
3124
3125 nameFlags = flags & BUDB_OP_NAMES;
3126 startFlags = flags & BUDB_OP_STARTS;
3127 endFlags = flags & BUDB_OP_ENDS;
3128 timeFlags = flags & BUDB_OP_TIMES;
3129
3130 InitReturnList(&vollist);
3131 toskip = index;
3132
3133 /* lookup a the volume (specified by name) in the dump (specified by id) */
3134 if (nameFlags == BUDB_OP_VOLUMENAME) {
3135 /* dumpid permissible, all others off */
3136 if (((startFlags & ~BUDB_OP_DUMPID) != 0) || endFlags || timeFlags)
3137 ABORT(BUDB_BADFLAGS);
3138
3139 /* returns ptr to volinfo of requested name */
3140 eval = ht_LookupEntry(ut, &db.volName, name, &via, &vi);
3141 if (eval)
3142 ABORT(eval);
3143 if (!via)
3144 ABORT(BUDB_NOVOLUMENAME);
3145
3146 /* Iterate over all volume fragments with this name */
3147 while (1) {
3148 struct volFragment v;
3149 afs_int32 va;
3150
3151 /* traverse all the volume fragments for this volume info structure */
3152 for (va = vi.firstFragment; va; va = v.sameNameChain) {
3153 va = ntohl(va);
3154 eval = dbread(ut, va, &v, sizeof(v));
3155 if (eval)
3156 ABORT(eval);
3157
3158 if (startFlags & BUDB_OP_DUMPID) {
3159 struct tape atape;
3160 struct dump adump;
3161
3162 /* get the dump id for this fragment */
3163 eval = dbread(ut, ntohl(v.tape), &atape, sizeof(atape));
3164 if (eval)
3165 ABORT(eval);
3166
3167 eval =
3168 dbread(ut, ntohl(atape.dump), &adump, sizeof(adump));
3169 if (eval)
3170 ABORT(BUDB_IO);
3171
3172 /* dump id does not match */
3173 if (ntohl(adump.id) != start)
3174 continue;
3175 }
3176
3177 eval = AddToReturnList(&vollist, va, &toskip);
3178 if (eval == BUDB_LIST2BIG)
3179 break;
3180 if (eval)
3181 ABORT(eval);
3182 }
3183 if (eval == BUDB_LIST2BIG)
3184 break;
3185
3186 via = vi.sameNameChain;
3187 if (via == 0)
3188 break;
3189 via = ntohl(via);
3190
3191 eval = dbread(ut, via, &vi, sizeof(vi));
3192 if (eval)
3193 ABORT(eval);
3194 }
3195 } else if (((nameFlags == 0) || (nameFlags == BUDB_OP_TAPENAME))
3196 && (startFlags == BUDB_OP_DUMPID)) {
3197 struct dump dump;
3198 dbadr dumpAddr;
3199 struct tape tape;
3200 dbadr tapeAddr;
3201 struct volFragment volFrag;
3202 dbadr volFragAddr;
3203
3204 /* lookup all volumes for a specified dump id */
3205
3206 /* no other flags should be set */
3207 if (endFlags || timeFlags)
3208 ABORT(BUDB_BADFLAGS);
3209
3210 /* find the dump */
3211 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &dumpAddr, &dump);
3212 if (eval)
3213 ABORT(eval);
3214
3215 /* traverse all the tapes */
3216 for (tapeAddr = ntohl(dump.firstTape); tapeAddr; tapeAddr = ntohl(tape.nextTape)) { /*w */
3217 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
3218 if (eval)
3219 ABORT(eval);
3220
3221 if ((nameFlags != BUDB_OP_TAPENAME)
3222 || ((nameFlags == BUDB_OP_TAPENAME)
3223 && (strcmp(tape.name, name) == 0))) {
3224 /* now return all the volumes */
3225 for (volFragAddr = ntohl(tape.firstVol); volFragAddr;
3226 volFragAddr = ntohl(volFrag.sameTapeChain)) {
3227 eval = dbread(ut, volFragAddr, &volFrag, sizeof(volFrag));
3228 if (eval)
3229 ABORT(eval);
3230
3231 eval = AddToReturnList(&vollist, volFragAddr, &toskip);
3232 if (eval == BUDB_LIST2BIG)
3233 break;
3234 if (eval)
3235 ABORT(eval);
3236 }
3237 }
3238 if (eval == BUDB_LIST2BIG)
3239 break;
3240 } /*w */
3241 } else {
3242 ABORT(BUDB_BADFLAGS);
3243 }
3244
3245 eval =
3246 SendReturnList(ut, &vollist, FillVolEntry,
3247 sizeof(struct budb_volumeEntry), index, nextIndexP,
3248 dbTimeP, (returnList_t) volumes);
3249 if (eval)
3250 ABORT(eval);
3251
3252 /* error_exit: */
3253 FreeReturnList(&vollist);
3254 code = ubik_EndTrans(ut);
3255 return code;
3256
3257 abort_exit:
3258 FreeReturnList(&vollist);
3259 ubik_AbortTrans(ut);
3260 return code;
3261 }
3262
3263 afs_int32
3264 SBUDB_UseTape(struct rx_call *call,
3265 struct budb_tapeEntry *tape, /* tape info */
3266 afs_int32 *new) /* set if tape is new */
3267 {
3268 afs_int32 code;
3269
3270 code = UseTape(call, tape, new);
3271 osi_auditU(call, BUDB_UseTpeEvent, code, AUD_DATE,
3272 (tape ? tape->dump : 0), AUD_END);
3273 return code;
3274 }
3275
3276 afs_int32
3277 UseTape(struct rx_call *call,
3278 struct budb_tapeEntry *tape, /* tape info */
3279 int *new) /* set if tape is new */
3280 {
3281 struct ubik_trans *ut;
3282 dbadr da, a;
3283 struct dump d;
3284 struct tape t;
3285 afs_int32 eval, code;
3286
3287 if (!callPermitted(call))
3288 return BUDB_NOTPERMITTED;
3289
3290 if (strlen(tape->name) >= sizeof(t.name))
3291 return BUDB_BADARGUMENT;
3292
3293 eval = InitRPC(&ut, LOCKWRITE, 1);
3294 if (eval)
3295 return eval;
3296
3297 *new = 0;
3298
3299 memset(&t, 0, sizeof(t));
3300 eval = AllocStructure(ut, tape_BLOCK, 0, &a, &t);
3301 if (eval)
3302 ABORT(eval);
3303
3304 strcpy(t.name, tape->name);
3305
3306 eval = ht_HashIn(ut, &db.tapeName, a, &t);
3307 if (eval)
3308 ABORT(eval);
3309
3310 *new = 1;
3311
3312 /* Since deleting a tape may change the dump (if its the same one), read in
3313 * the dump after the call to DeleteTape. */
3314
3315 eval = ht_LookupEntry(ut, &db.dumpIden, &tape->dump, &da, &d);
3316 if (eval)
3317 ABORT(eval);
3318 if (!da)
3319 ABORT(BUDB_NODUMPID);
3320
3321 if (!tape->written)
3322 tape->written = time(0); /* fill in tape struct */
3323 t.written = htonl(tape->written);
3324 t.expires = htonl(tape->expires);
3325 t.dump = htonl(da);
3326 t.seq = htonl(tape->seq);
3327 t.useCount = htonl(tape->useCount);
3328 t.labelpos = htonl(tape->labelpos);
3329 t.useKBytes = 0;
3330 t.flags = htonl(tape->flags | BUDB_TAPE_BEINGWRITTEN);
3331
3332 t.nextTape = d.firstTape; /* Chain the tape to the dump */
3333 d.firstTape = htonl(a);
3334
3335 if (tape->seq >= ntohl(d.tapes.maxTapes)) /* inc # tapes in the dump */
3336 d.tapes.maxTapes = htonl(tape->seq);
3337
3338 eval = dbwrite(ut, a, &t, sizeof(t)); /* write tape struct */
3339 if (eval)
3340 ABORT(eval);
3341
3342 eval = dbwrite(ut, da, &d, sizeof(d)); /* write the dump struct */
3343 if (eval)
3344 ABORT(eval);
3345
3346 eval = set_header_word(ut, lastUpdate, htonl(time(0)));
3347 if (eval)
3348 ABORT(eval);
3349
3350 LogDebug(5, "added tape %s\n", tape->name);
3351
3352 code = ubik_EndTrans(ut);
3353 return code;
3354
3355 abort_exit:
3356 ubik_AbortTrans(ut);
3357 return code;
3358
3359 }
3360
3361
3362 /* ---------------------------------------------
3363 * debug interface routines
3364 * ---------------------------------------------
3365 */
3366
3367 afs_int32
3368 SBUDB_T_DumpHashTable(struct rx_call *call, afs_int32 type, char *filename)
3369 {
3370 afs_int32 code;
3371
3372 code = T_DumpHashTable(call, type, filename);
3373 osi_auditU(call, BUDB_TDmpHaEvent, code, AUD_STR, filename, AUD_END);
3374 return code;
3375 }
3376
3377 afs_int32
3378 T_DumpHashTable(struct rx_call *call, int type, char *filename)
3379 {
3380 struct ubik_trans *ut;
3381 struct memoryHashTable *mht;
3382 int ent;
3383 afs_int32 eval, code = 0;
3384 char path[64];
3385 FILE *DUMP;
3386
3387 int length;
3388 afs_uint32 hash;
3389 dbadr a, first_a;
3390 char e[sizeof(struct block)]; /* unnecessarily conservative */
3391 struct dump e_dump;
3392 struct tape e_tape;
3393 struct volInfo e_volinfo;
3394 int e_size;
3395 int old;
3396
3397 if (!callPermitted(call))
3398 return BUDB_NOTPERMITTED;
3399
3400 if (strlen(filename) >= sizeof(path) - 5)
3401 return BUDB_BADARGUMENT;
3402
3403 eval = InitRPC(&ut, LOCKWRITE, 1);
3404 if (eval)
3405 return eval;
3406
3407 if ((mht = ht_GetType(type, &e_size)) == 0)
3408 return BUDB_BADARGUMENT;
3409
3410 sprintf(path, "%s/%s", gettmpdir(), filename);
3411
3412 DUMP = fopen(path, "w");
3413 if (!DUMP)
3414 ABORT(BUDB_BADARGUMENT);
3415
3416 ent = 0;
3417 for (old = 0;; old++) {
3418 length = (old ? mht->oldLength : mht->length);
3419 if (length)
3420 fprintf(DUMP, "Dumping %sHash Table:\n", (old ? "Old " : ""));
3421
3422 for (hash = 0; hash < length; hash++) {
3423 a = ht_LookupBucket(ut, mht, hash, old);
3424 first_a = a;
3425 while (a) {
3426 eval = dbread(ut, a, e, e_size);
3427 if (eval)
3428 ABORT(eval);
3429
3430 ent++;
3431 if (a == first_a)
3432 fprintf(DUMP, " in bucket %d at %d is ", hash, a);
3433 else
3434 fprintf(DUMP, " at %d is ", a);
3435 switch (type) {
3436 case HT_dumpIden_FUNCTION:
3437 memcpy(&e_dump, e, sizeof(e_dump));
3438 fprintf(DUMP, "%d\n", ntohl(e_dump.id));
3439 break;
3440 case HT_dumpName_FUNCTION:
3441 memcpy(&e_dump, e, sizeof(e_dump));
3442 fprintf(DUMP, "%s\n", e_dump.dumpName);
3443 break;
3444 case HT_tapeName_FUNCTION:
3445 memcpy(&e_tape, e, sizeof(e_tape));
3446 fprintf(DUMP, "%s\n", e_tape.name);
3447 break;
3448 case HT_volName_FUNCTION:
3449 memcpy(&e_volinfo, e, sizeof(e_volinfo));
3450 fprintf(DUMP, "%s\n", e_volinfo.name);
3451 break;
3452 }
3453 if ((ht_HashEntry(mht, e) % length) != hash)
3454 ABORT(BUDB_DATABASEINCONSISTENT);
3455 a = ntohl(*(dbadr *) (e + mht->threadOffset));
3456 }
3457 }
3458 if (old)
3459 break;
3460 }
3461
3462 fprintf(DUMP, "%d entries found\n", ent);
3463 if (ntohl(mht->ht->entries) != ent)
3464 ABORT(BUDB_DATABASEINCONSISTENT);
3465
3466 code = ubik_EndTrans(ut);
3467 if (DUMP)
3468 fclose(DUMP);
3469 return code;
3470
3471 abort_exit:
3472 ubik_AbortTrans(ut);
3473 if (DUMP)
3474 fclose(DUMP);
3475 return code;
3476 }
3477
3478 afs_int32
3479 SBUDB_T_GetVersion(struct rx_call *call, afs_int32 *majorVersion)
3480 {
3481 afs_int32 code;
3482
3483 code = T_GetVersion(call, majorVersion);
3484 osi_auditU(call, BUDB_TGetVrEvent, code, AUD_END);
3485 return code;
3486 }
3487
3488 afs_int32
3489 T_GetVersion(struct rx_call *call, int *majorVersion)
3490 {
3491 struct ubik_trans *ut;
3492 afs_int32 code;
3493
3494 code = InitRPC(&ut, LOCKREAD, 0);
3495 if (code)
3496 return (code);
3497
3498 *majorVersion = BUDB_MAJORVERSION;
3499
3500 code = ubik_EndTrans(ut);
3501 return (code);
3502 }
3503
3504 /* BUDB_T_DumpDatabase
3505 * dump as much of the database as possible int /tmp/<filename>
3506 */
3507
3508 afs_int32
3509 SBUDB_T_DumpDatabase(struct rx_call *call, char *filename)
3510 {
3511 afs_int32 code;
3512
3513 code = T_DumpDatabase(call, filename);
3514 osi_auditU(call, BUDB_TDmpDBEvent, code, AUD_STR, filename, AUD_END);
3515 return code;
3516 }
3517
3518 afs_int32
3519 T_DumpDatabase(struct rx_call *call, char *filename)
3520 {
3521 FILE *dumpfid;
3522 int entrySize;
3523 struct ubik_trans *ut;
3524 char *path = 0;
3525 dbadr dbAddr;
3526 int type, old, length, hash;
3527 struct memoryHashTable *mht;
3528 afs_int32 eval, code = 0;
3529
3530 if (!callPermitted(call))
3531 return BUDB_NOTPERMITTED;
3532
3533 length = asprintf(&path, "%s/%s", gettmpdir(), filename);
3534 if (length < 0 || !path)
3535 return (BUDB_INTERNALERROR);
3536
3537 dumpfid = fopen(path, "w");
3538 if (!dumpfid)
3539 return (BUDB_BADARGUMENT);
3540
3541 eval = InitRPC(&ut, LOCKWRITE, 1);
3542 if (eval)
3543 return (eval);
3544
3545 /* dump all items in the database */
3546 for (type = 1; type <= HT_MAX_FUNCTION; type++) { /*ft */
3547 mht = ht_GetType(type, &entrySize);
3548 if (!mht)
3549 ERROR(BUDB_BADARGUMENT);
3550
3551 for (old = 0; old <= 1; old++) { /*fo */
3552 length = (old ? mht->oldLength : mht->length);
3553 if (!length)
3554 continue;
3555
3556 fprintf(dumpfid, "Dumping %s Hash Table:\n", (old ? "Old " : ""));
3557
3558 for (hash = 0; hash < length; hash++) { /*f */
3559 dbAddr = ht_LookupBucket(ut, mht, hash, old);
3560
3561 while (dbAddr) { /*w */
3562 switch (type) { /*s */
3563 case HT_dumpIden_FUNCTION:
3564 {
3565 struct dump hostDump, diskDump;
3566
3567 eval =
3568 cdbread(ut, dump_BLOCK, dbAddr, &diskDump,
3569 sizeof(diskDump));
3570 if (eval)
3571 ERROR(eval);
3572
3573 fprintf(dumpfid,
3574 "\ndumpId hash %d, entry at %u\n",
3575 hash, dbAddr);
3576 fprintf(dumpfid,
3577 "----------------------------\n");
3578 dump_ntoh(&diskDump, &hostDump);
3579 printDump(dumpfid, &hostDump);
3580 dbAddr = hostDump.idHashChain;
3581 }
3582 break;
3583
3584 case HT_dumpName_FUNCTION:
3585 {
3586 struct dump hostDump, diskDump;
3587
3588 eval =
3589 cdbread(ut, dump_BLOCK, dbAddr, &diskDump,
3590 sizeof(diskDump));
3591 if (eval)
3592 ERROR(eval);
3593
3594 fprintf(dumpfid,
3595 "\ndumpname hash %d, entry at %u\n",
3596 hash, dbAddr);
3597 fprintf(dumpfid,
3598 "----------------------------\n");
3599 dump_ntoh(&diskDump, &hostDump);
3600 printDump(dumpfid, &hostDump);
3601 dbAddr = hostDump.nameHashChain;
3602 }
3603 break;
3604
3605 case HT_tapeName_FUNCTION:
3606 {
3607 struct tape hostTape, diskTape;
3608
3609 eval =
3610 cdbread(ut, tape_BLOCK, dbAddr, &diskTape,
3611 sizeof(diskTape));
3612 if (eval)
3613 ERROR(eval);
3614
3615 fprintf(dumpfid,
3616 "\ntapename hash %d, entry at %u\n",
3617 hash, dbAddr);
3618 fprintf(dumpfid,
3619 "----------------------------\n");
3620 tape_ntoh(&diskTape, &hostTape);
3621 printTape(dumpfid, &hostTape);
3622 dbAddr = hostTape.nameHashChain;
3623 }
3624 break;
3625
3626 case HT_volName_FUNCTION:
3627 {
3628 struct volInfo hostVolInfo, diskVolInfo;
3629
3630 eval =
3631 cdbread(ut, volInfo_BLOCK, dbAddr,
3632 &diskVolInfo, sizeof(diskVolInfo));
3633 if (eval)
3634 ERROR(eval);
3635
3636 fprintf(dumpfid,
3637 "\nvolname hash %d, entry at %u\n",
3638 hash, dbAddr);
3639 fprintf(dumpfid,
3640 "----------------------------\n");
3641 volInfo_ntoh(&diskVolInfo, &hostVolInfo);
3642 printVolInfo(dumpfid, &hostVolInfo);
3643 dbAddr = hostVolInfo.nameHashChain;
3644
3645 volFragsDump(ut, dumpfid,
3646 hostVolInfo.firstFragment);
3647 }
3648 break;
3649
3650 default:
3651 fprintf(dumpfid, "unknown type %d\n", type);
3652 break;
3653
3654 } /*s */
3655 } /*w */
3656 } /*f */
3657 } /*fo */
3658 } /*ft */
3659
3660 error_exit:
3661 code = ubik_EndTrans(ut); /* is this safe if no ut started ? */
3662 if (dumpfid)
3663 fclose(dumpfid);
3664 if (path)
3665 free(path);
3666 return (code);
3667 }
3668
3669 int
3670 volFragsDump(struct ubik_trans *ut, FILE *dumpfid, dbadr dbAddr)
3671 {
3672 struct volFragment hostVolFragment, diskVolFragment;
3673 afs_int32 code;
3674
3675 while (dbAddr) {
3676 code =
3677 cdbread(ut, volFragment_BLOCK, dbAddr, &diskVolFragment,
3678 sizeof(diskVolFragment));
3679 if (code) { /* don't be fussy about errors */
3680 fprintf(dumpfid, "volFragsDump: Error reading database\n");
3681 return (0);
3682 }
3683
3684 fprintf(dumpfid, "\nvolfragment entry at %u\n", dbAddr);
3685 fprintf(dumpfid, "----------------------------\n");
3686 volFragment_ntoh(&diskVolFragment, &hostVolFragment);
3687 printVolFragment(dumpfid, &hostVolFragment);
3688 dbAddr = hostVolFragment.sameNameChain;
3689 }
3690 return (0);
3691 }
3692
3693 #ifdef notdef
3694 /* utilities - network to host conversion
3695 * currently used for debug only
3696 */
3697
3698 void
3699 volFragmentDiskToHost(struct volFragment *diskVfPtr,
3700 struct volFragment *hostVfPtr)
3701 {
3702 hostVfPtr->vol = ntohl(diskVfPtr->vol);
3703 hostVfPtr->sameNameChain = ntohl(diskVfPtr->sameNameChain);
3704 hostVfPtr->tape = ntohl(diskVfPtr->tape);
3705 hostVfPtr->sameTapeChain = ntohl(diskVfPtr->sameTapeChain);
3706 hostVfPtr->position = ntohl(diskVfPtr->position);
3707 hostVfPtr->clone = ntohl(diskVfPtr->clone);
3708 hostVfPtr->incTime = ntohl(diskVfPtr->incTime);
3709 hostVfPtr->startByte = ntohl(diskVfPtr->startByte);
3710 hostVfPtr->nBytes = ntohl(diskVfPtr->nBytes);
3711 hostVfPtr->flags = ntohs(diskVfPtr->flags);
3712 hostVfPtr->sequence = ntohs(diskVfPtr->sequence);
3713 }
3714
3715 void
3716 volInfoDiskToHost(struct volInfo *diskViPtr, struct volInfo *hostViPtr)
3717 {
3718 strcpy(hostViPtr->name, diskViPtr->name);
3719 hostViPtr->nameHashChain = ntohl(diskViPtr->nameHashChain);
3720 hostViPtr->id = ntohl(diskViPtr->id);
3721 strcpy(hostViPtr->server, diskViPtr->server);
3722 hostViPtr->partition = ntohl(diskViPtr->partition);
3723 hostViPtr->flags = ntohl(diskViPtr->flags);
3724 hostViPtr->sameNameHead = ntohl(diskViPtr->sameNameHead);
3725 hostViPtr->sameNameChain = ntohl(diskViPtr->sameNameChain);
3726 hostViPtr->firstFragment = ntohl(diskViPtr->firstFragment);
3727 hostViPtr->nFrags = ntohl(diskViPtr->nFrags);
3728 }
3729
3730 void
3731 tapeDiskToHost(struct tape *diskTapePtr, struct tape *hostTapePtr)
3732 {
3733 strcpy(hostTapePtr->name, diskTapePtr->name);
3734 hostTapePtr->nameHashChain = ntohl(diskTapePtr->nameHashChain);
3735 hostTapePtr->flags = ntohl(diskTapePtr->flags);
3736
3737 /* tape id conversion here */
3738 hostTapePtr->written = ntohl(diskTapePtr->written);
3739 hostTapePtr->nBytes = ntohl(diskTapePtr->nBytes);
3740 hostTapePtr->nFiles = ntohl(diskTapePtr->nFiles);
3741 hostTapePtr->nVolumes = ntohl(diskTapePtr->nVolumes);
3742 hostTapePtr->seq = ntohl(diskTapePtr->seq);
3743 hostTapePtr->dump = ntohl(diskTapePtr->dump);
3744 hostTapePtr->nextTape = ntohl(diskTapePtr->nextTape);
3745 hostTapePtr->firstVol = ntohl(diskTapePtr->firstVol);
3746 hostTapePtr->useCount = ntohl(diskTapePtr->useCount);
3747 }
3748
3749 void
3750 dumpDiskToHost(struct dump *diskDumpPtr, struct dump *hostDumpPtr)
3751 {
3752 hostDumpPtr->id = ntohl(diskDumpPtr->id);
3753 hostDumpPtr->idHashChain = ntohl(diskDumpPtr->idHashChain);
3754 strcpy(hostDumpPtr->dumpName, diskDumpPtr->dumpName);
3755 strcpy(hostDumpPtr->dumpPath, diskDumpPtr->dumpPath);
3756 strcpy(hostDumpPtr->volumeSet, diskDumpPtr->volumeSet);
3757 hostDumpPtr->nameHashChain = ntohl(diskDumpPtr->nameHashChain);
3758 hostDumpPtr->flags = ntohl(diskDumpPtr->flags);
3759 hostDumpPtr->parent = ntohl(diskDumpPtr->parent);
3760 hostDumpPtr->created = ntohl(diskDumpPtr->created);
3761 /* hostDumpPtr->incTime = ntohl(diskDumpPtr->incTime); */
3762 hostDumpPtr->nVolumes = ntohl(diskDumpPtr->nVolumes);
3763
3764 /* tapeset conversion here */
3765
3766 hostDumpPtr->firstTape = ntohl(diskDumpPtr->firstTape);
3767
3768 /* principal conversion here */
3769 }
3770
3771 #endif /* notdef */
3772
3773 int
3774 checkHash(struct ubik_trans *ut, int hashType)
3775 {
3776 struct memoryHashTable *mhtPtr;
3777 int entrySize, hashTableLength;
3778 int bucket;
3779 int old;
3780 afs_int32 code = 0;
3781
3782 mhtPtr = ht_GetType(hashType, &entrySize);
3783 if (mhtPtr == 0)
3784 ERROR(-1);
3785
3786 for (old = 0; old < 1; old++) {
3787 LogDebug(5, "\nold = %d\n", old);
3788 printMemoryHashTable(stdout, mhtPtr);
3789 LogDebug(5, "\n");
3790 hashTableLength = (old ? mhtPtr->oldLength : mhtPtr->length);
3791
3792 for (bucket = 0; bucket < hashTableLength; bucket++) {
3793 dbadr entryAddr;
3794
3795 entryAddr = ht_LookupBucket(ut, mhtPtr, bucket, old);
3796 while (entryAddr != 0) {
3797 LogDebug(6, "bucket %d has disk addr %d\n", bucket,
3798 entryAddr);
3799 switch (hashType) {
3800 case HT_dumpIden_FUNCTION:
3801 {
3802 struct dump diskDump, hostDump;
3803
3804 code = dbread(ut, entryAddr, &diskDump, entrySize);
3805 if (code)
3806 ERROR(-1);
3807
3808 dump_ntoh(&diskDump, &hostDump);
3809 printDump(stdout, &hostDump);
3810 entryAddr = hostDump.idHashChain;
3811 }
3812 break;
3813
3814 case HT_dumpName_FUNCTION:
3815 break;
3816
3817 case HT_tapeName_FUNCTION:
3818 break;
3819
3820 case HT_volName_FUNCTION:
3821 {
3822 struct volInfo diskVolInfo, hostVolInfo;
3823
3824 code = dbread(ut, entryAddr, &diskVolInfo, entrySize);
3825 if (code)
3826 ERROR(-1);
3827
3828 volInfo_ntoh(&diskVolInfo, &hostVolInfo);
3829 printVolInfo(stdout, &hostVolInfo);
3830 entryAddr = hostVolInfo.nameHashChain;
3831 break;
3832 }
3833 }
3834 }
3835 }
3836 }
3837 error_exit:
3838 return (code);
3839 }
Mirror of pkg-k5-afs/openafs.git (OpenAFS Debian packaging)