2 * Copyright 2000, International Business Machines Corporation and others.
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
10 /* Read a VLDB file and verify it for correctness */
12 #define VL 0x001 /* good volume entry */
13 #define FR 0x002 /* free volume entry */
14 #define MH 0x004 /* multi-homed entry */
16 #define RWH 0x010 /* on rw hash chain */
17 #define ROH 0x020 /* on ro hash chain */
18 #define BKH 0x040 /* on bk hash chain */
19 #define NH 0x080 /* on name hash chain */
21 #define MHC 0x100 /* on multihomed chain */
22 #define FRC 0x200 /* on free chain */
24 #define REFRW 0x1000 /* linked from something (RW) */
25 #define REFRO 0x2000 /* linked from something (RO) */
26 #define REFBK 0x4000 /* linked from something (BK) */
27 #define REFN 0x8000 /* linked from something (name) */
29 #define MULTRW 0x10000 /* multiply-chained (RW) */
30 #define MULTRO 0x20000 /* multiply-chained (RO) */
31 #define MULTBK 0x40000 /* multiply-chained (BK) */
32 #define MULTN 0x80000 /* multiply-chained (name) */
34 #define MISRWH 0x100000 /* mischained (RW) */
35 #define MISROH 0x200000 /* mischained (RO) */
36 #define MISBKH 0x400000 /* mischained (BK) */
37 #define MISNH 0x800000 /* mischained (name) */
39 #define VLDB_CHECK_NO_VLDB_CHECK_ERROR 0
40 #define VLDB_CHECK_WARNING 1
41 #define VLDB_CHECK_ERROR 2
42 #define VLDB_CHECK_FATAL 4
43 #define vldbread(x,y,z) vldbio(x,y,z,0)
44 #define vldbwrite(x,y,z) vldbio(x,y,z,1)
46 #include <afsconfig.h>
47 #include <afs/param.h>
51 #include <sys/types.h>
58 #include <WINNT/afsevent.h>
61 #include <sys/socket.h>
63 #include <netinet/in.h>
69 #include <afs/afsutil.h>
72 #define ADDR(x) (x/sizeof(struct nvlentry))
75 int listentries, listservers, listheader, listuheader, verbose, quiet;
80 /* if quiet, don't send anything to stdout */
82 /* error level. 0 = no error, 1 = warning, 2 = error, 4 = fatal */
89 int serveraddrs[MAXSERVERID + 2];
91 /* Used to control what goes to stdout based on quiet flag */
93 quiet_println(const char *fmt,...) {
97 vfprintf(stdout, fmt, args);
102 /* Used to set the error level and ship messages to stderr */
104 log_error(int eval, const char *fmt, ...)
107 if (error_level < eval) error_level = eval ; /* bump up the severity */
109 vfprintf(stderr, fmt, args);
112 if (error_level == VLDB_CHECK_FATAL) exit(VLDB_CHECK_FATAL);
120 /* Bump the version number?? We could cheat and push a new db... */
129 struct ubik_hdr uheader;
131 offset = lseek(fd, 0, 0);
133 log_error(VLDB_CHECK_FATAL,"error: lseek to 0 failed: %d %d\n", offset, errno);
134 return (VLDB_CHECK_FATAL);
137 /* now read the info */
138 r = read(fd, &uheader, sizeof(uheader));
139 if (r != sizeof(uheader)) {
140 log_error(VLDB_CHECK_FATAL,"error: read of %lu bytes failed: %d %d\n", sizeof(uheader), r,
142 return (VLDB_CHECK_FATAL);
145 uheader.magic = ntohl(uheader.magic);
146 uheader.size = ntohl(uheader.size);
147 uheader.version.epoch = ntohl(uheader.version.epoch);
148 uheader.version.counter = ntohl(uheader.version.counter);
151 quiet_println("Ubik Header\n");
152 quiet_println(" Magic = 0x%x\n", uheader.magic);
153 quiet_println(" Size = %u\n", uheader.size);
154 quiet_println(" Version.epoch = %u\n", uheader.version.epoch);
155 quiet_println(" Version.counter = %u\n", uheader.version.counter);
158 if (uheader.size != HDRSIZE)
159 log_error(VLDB_CHECK_WARNING,"VLDB_CHECK_WARNING: Ubik header size is %u (should be %u)\n", uheader.size,
161 if (uheader.magic != UBIK_MAGIC)
162 log_error(VLDB_CHECK_ERROR,"Ubik header magic is 0x%x (should be 0x%x)\n", uheader.magic,
169 vldbio(int position, void *buffer, int size, int rdwr)
173 /* seek to the correct spot. skip ubik stuff */
174 p = position + HDRSIZE;
175 offset = lseek(fd, p, 0);
177 log_error(VLDB_CHECK_FATAL,"error: lseek to %d failed: %d %d\n", p, offset, errno);
182 r = write(fd, buffer, size);
184 r = read(fd, buffer, size);
187 log_error(VLDB_CHECK_FATAL,"error: %s of %d bytes failed: %d %d\n", rdwr==1?"write":"read",
211 NameHash(char *volname)
217 for (vchar = volname + strlen(volname) - 1; vchar >= volname; vchar--)
218 hash = (hash * 63) + (*((unsigned char *)vchar) - 63);
219 return (hash % HASHSIZE);
223 IdHash(afs_uint32 volid)
225 return ((abs(volid)) % HASHSIZE);
228 #define LEGALCHARS ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
230 InvalidVolname(char *volname)
236 slen = strlen(volname);
237 if (slen >= VL_MAXNAMELEN)
239 return (slen != strspn(volname, map));
243 readheader(struct vlheader *headerp)
247 vldbread(0, (char *)headerp, sizeof(*headerp));
249 headerp->vital_header.vldbversion =
250 ntohl(headerp->vital_header.vldbversion);
251 headerp->vital_header.headersize =
252 ntohl(headerp->vital_header.headersize);
253 headerp->vital_header.freePtr = ntohl(headerp->vital_header.freePtr);
254 headerp->vital_header.eofPtr = ntohl(headerp->vital_header.eofPtr);
255 headerp->vital_header.allocs = ntohl(headerp->vital_header.allocs);
256 headerp->vital_header.frees = ntohl(headerp->vital_header.frees);
257 headerp->vital_header.MaxVolumeId =
258 ntohl(headerp->vital_header.MaxVolumeId);
259 headerp->vital_header.totalEntries[0] =
260 ntohl(headerp->vital_header.totalEntries[0]);
261 for (i = 0; i < MAXTYPES; i++)
262 headerp->vital_header.totalEntries[i] =
263 ntohl(headerp->vital_header.totalEntries[1]);
265 headerp->SIT = ntohl(headerp->SIT);
266 for (i = 0; i < MAXSERVERID; i++)
267 headerp->IpMappedAddr[i] = ntohl(headerp->IpMappedAddr[i]);
268 for (i = 0; i < HASHSIZE; i++)
269 headerp->VolnameHash[i] = ntohl(headerp->VolnameHash[i]);
270 for (i = 0; i < MAXTYPES; i++)
271 for (j = 0; j < HASHSIZE; j++)
272 headerp->VolidHash[i][j] = ntohl(headerp->VolidHash[i][j]);
275 quiet_println("vldb header\n");
276 quiet_println(" vldbversion = %u\n",
277 headerp->vital_header.vldbversion);
278 quiet_println(" headersize = %u [actual=%lu]\n",
279 headerp->vital_header.headersize, sizeof(*headerp));
280 quiet_println(" freePtr = 0x%x\n", headerp->vital_header.freePtr);
281 quiet_println(" eofPtr = %u\n", headerp->vital_header.eofPtr);
282 quiet_println(" allocblock calls = %10u\n", headerp->vital_header.allocs);
283 quiet_println(" freeblock calls = %10u\n", headerp->vital_header.frees);
284 quiet_println(" MaxVolumeId = %u\n",
285 headerp->vital_header.MaxVolumeId);
286 quiet_println(" rw vol entries = %u\n",
287 headerp->vital_header.totalEntries[0]);
288 quiet_println(" ro vol entries = %u\n",
289 headerp->vital_header.totalEntries[1]);
290 quiet_println(" bk vol entries = %u\n",
291 headerp->vital_header.totalEntries[2]);
292 quiet_println(" multihome info = 0x%x (%u)\n", headerp->SIT,
294 quiet_println(" server ip addr table: size = %d entries\n",
296 quiet_println(" volume name hash table: size = %d buckets\n", HASHSIZE);
297 quiet_println(" volume id hash table: %d tables with %d buckets each\n",
301 /* Check the header size */
302 if (headerp->vital_header.headersize != sizeof(*headerp))
303 log_error(VLDB_CHECK_WARNING,"Header reports its size as %d (should be %lu)\n",
304 headerp->vital_header.headersize, sizeof(*headerp));
309 writeheader(struct vlheader *headerp)
313 headerp->vital_header.vldbversion =
314 htonl(headerp->vital_header.vldbversion);
315 headerp->vital_header.headersize =
316 htonl(headerp->vital_header.headersize);
317 headerp->vital_header.freePtr = htonl(headerp->vital_header.freePtr);
318 headerp->vital_header.eofPtr = htonl(headerp->vital_header.eofPtr);
319 headerp->vital_header.allocs = htonl(headerp->vital_header.allocs);
320 headerp->vital_header.frees = htonl(headerp->vital_header.frees);
321 headerp->vital_header.MaxVolumeId =
322 htonl(headerp->vital_header.MaxVolumeId);
323 headerp->vital_header.totalEntries[0] =
324 htonl(headerp->vital_header.totalEntries[0]);
325 for (i = 0; i < MAXTYPES; i++)
326 headerp->vital_header.totalEntries[i] =
327 htonl(headerp->vital_header.totalEntries[1]);
329 headerp->SIT = htonl(headerp->SIT);
330 for (i = 0; i < MAXSERVERID; i++)
331 headerp->IpMappedAddr[i] = htonl(headerp->IpMappedAddr[i]);
332 for (i = 0; i < HASHSIZE; i++)
333 headerp->VolnameHash[i] = htonl(headerp->VolnameHash[i]);
334 for (i = 0; i < MAXTYPES; i++)
335 for (j = 0; j < HASHSIZE; j++)
336 headerp->VolidHash[i][j] = htonl(headerp->VolidHash[i][j]);
338 vldbwrite(0, (char *)headerp, sizeof(*headerp));
342 readMH(afs_int32 addr, struct extentaddr *mhblockP)
345 struct extentaddr *e;
347 vldbread(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
349 mhblockP->ex_count = ntohl(mhblockP->ex_count);
350 mhblockP->ex_flags = ntohl(mhblockP->ex_flags);
351 for (i = 0; i < VL_MAX_ADDREXTBLKS; i++)
352 mhblockP->ex_contaddrs[i] = ntohl(mhblockP->ex_contaddrs[i]);
354 for (i = 1; i < VL_MHSRV_PERBLK; i++) {
357 /* won't convert hostuuid */
358 e->ex_uniquifier = ntohl(e->ex_uniquifier);
359 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++)
360 e->ex_addrs[j] = ntohl(e->ex_addrs[j]);
366 readentry(afs_int32 addr, struct nvlentry *vlentryp, afs_int32 *type)
370 vldbread(addr, (char *)vlentryp, sizeof(*vlentryp));
372 for (i = 0; i < MAXTYPES; i++)
373 vlentryp->volumeId[i] = ntohl(vlentryp->volumeId[i]);
374 vlentryp->flags = ntohl(vlentryp->flags);
375 vlentryp->LockAfsId = ntohl(vlentryp->LockAfsId);
376 vlentryp->LockTimestamp = ntohl(vlentryp->LockTimestamp);
377 vlentryp->cloneId = ntohl(vlentryp->cloneId);
378 for (i = 0; i < MAXTYPES; i++)
379 vlentryp->nextIdHash[i] = ntohl(vlentryp->nextIdHash[i]);
380 vlentryp->nextNameHash = ntohl(vlentryp->nextNameHash);
381 for (i = 0; i < NMAXNSERVERS; i++) {
382 vlentryp->serverNumber[i] = ntohl(vlentryp->serverNumber[i]);
383 vlentryp->serverPartition[i] = ntohl(vlentryp->serverPartition[i]);
384 vlentryp->serverFlags[i] = ntohl(vlentryp->serverFlags[i]);
387 if (vlentryp->flags == VLCONTBLOCK) {
389 } else if (vlentryp->flags == VLFREE) {
396 quiet_println("address %u: ", addr);
397 if (vlentryp->flags == VLCONTBLOCK) {
398 quiet_println("mh extension block\n");
399 } else if (vlentryp->flags == VLFREE) {
400 quiet_println("free vlentry\n");
402 quiet_println("vlentry %s\n", vlentryp->name);
403 quiet_println(" rw id = %u ; ro id = %u ; bk id = %u\n",
404 vlentryp->volumeId[0], vlentryp->volumeId[1],
405 vlentryp->volumeId[2]);
406 quiet_println(" flags =");
407 if (vlentryp->flags & VLF_RWEXISTS)
408 quiet_println(" rw");
409 if (vlentryp->flags & VLF_ROEXISTS)
410 quiet_println(" ro");
411 if (vlentryp->flags & VLF_BACKEXISTS)
412 quiet_println(" bk");
413 if (vlentryp->flags & 0xffff8fff)
414 quiet_println(" errorflag(0x%x)", vlentryp->flags);
416 quiet_println(" LockAfsId = %d\n", vlentryp->LockAfsId);
417 quiet_println(" LockTimestamp = %d\n", vlentryp->LockTimestamp);
418 quiet_println(" cloneId = %u\n", vlentryp->cloneId);
420 (" next hash for rw = %u ; ro = %u ; bk = %u ; name = %u\n",
421 vlentryp->nextIdHash[0], vlentryp->nextIdHash[1],
422 vlentryp->nextIdHash[2], vlentryp->nextNameHash);
423 for (i = 0; i < NMAXNSERVERS; i++) {
424 if (vlentryp->serverNumber[i] != 255) {
425 quiet_println(" server %d ; partition %d ; flags =",
426 vlentryp->serverNumber[i],
427 vlentryp->serverPartition[i]);
428 if (vlentryp->serverFlags[i] & VLSF_RWVOL)
429 quiet_println(" rw");
430 if (vlentryp->serverFlags[i] & VLSF_ROVOL)
431 quiet_println(" ro");
432 if (vlentryp->serverFlags[i] & VLSF_BACKVOL)
433 quiet_println(" bk");
434 if (vlentryp->serverFlags[i] & VLSF_NEWREPSITE)
435 quiet_println(" newro");
445 writeentry(afs_int32 addr, struct nvlentry *vlentryp)
449 if (verbose) quiet_println("Writing back entry at addr %u\n", addr);
451 for (i = 0; i < MAXTYPES; i++)
452 vlentryp->volumeId[i] = htonl(vlentryp->volumeId[i]);
453 vlentryp->flags = htonl(vlentryp->flags);
454 vlentryp->LockAfsId = htonl(vlentryp->LockAfsId);
455 vlentryp->LockTimestamp = htonl(vlentryp->LockTimestamp);
456 vlentryp->cloneId = htonl(vlentryp->cloneId);
457 for (i = 0; i < MAXTYPES; i++)
458 vlentryp->nextIdHash[i] = htonl(vlentryp->nextIdHash[i]);
459 vlentryp->nextNameHash = htonl(vlentryp->nextNameHash);
460 for (i = 0; i < NMAXNSERVERS; i++) {
461 vlentryp->serverNumber[i] = htonl(vlentryp->serverNumber[i]);
462 vlentryp->serverPartition[i] = htonl(vlentryp->serverPartition[i]);
463 vlentryp->serverFlags[i] = htonl(vlentryp->serverFlags[i]);
465 vldbwrite(addr, (char *)vlentryp, sizeof(*vlentryp));
469 readSIT(int base, int addr)
472 char sitbuf[VL_ADDREXTBLK_SIZE];
473 struct extentaddr *extent;
477 vldbread(addr, sitbuf, VL_ADDREXTBLK_SIZE);
478 extent = (struct extentaddr *)sitbuf;
480 quiet_println("multihome info block: base %d\n", base);
482 quiet_println(" count = %u\n", ntohl(extent->ex_count));
483 quiet_println(" flags = %u\n", ntohl(extent->ex_flags));
484 for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
485 quiet_println(" contaddrs[%d] = %u\n", i,
486 ntohl(extent->ex_contaddrs[i]));
489 for (i = 1; i < VL_MHSRV_PERBLK; i++) {
490 /* should we skip this entry */
491 for (j = 0; j < VL_MAX_ADDREXTBLKS; j++) {
492 if (extent[i].ex_addrs[j])
495 if (j >= VL_MAX_ADDREXTBLKS)
498 quiet_println(" base %d index %d:\n", base, i);
500 quiet_println(" afsuuid = (%x %x %x /%d/%d/ /%x/%x/%x/%x/%x/%x/)\n",
501 ntohl(extent[i].ex_hostuuid.time_low),
502 ntohl(extent[i].ex_hostuuid.time_mid),
503 ntohl(extent[i].ex_hostuuid.time_hi_and_version),
504 ntohl(extent[i].ex_hostuuid.clock_seq_hi_and_reserved),
505 ntohl(extent[i].ex_hostuuid.clock_seq_low),
506 ntohl(extent[i].ex_hostuuid.node[0]),
507 ntohl(extent[i].ex_hostuuid.node[1]),
508 ntohl(extent[i].ex_hostuuid.node[2]),
509 ntohl(extent[i].ex_hostuuid.node[3]),
510 ntohl(extent[i].ex_hostuuid.node[4]),
511 ntohl(extent[i].ex_hostuuid.node[5]));
512 quiet_println(" uniquifier = %u\n", ntohl(extent[i].ex_uniquifier));
513 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
514 a = ntohl(extent[i].ex_addrs[j]);
516 quiet_println(" %d.%d.%d.%d\n", (a >> 24) & 0xff,
517 (a >> 16) & 0xff, (a >> 8) & 0xff, (a) & 0xff);
524 * Read each entry in the database:
525 * Record what type of entry it is and its address in the record array.
526 * Remember what the maximum volume id we found is and check against the header.
529 ReadAllEntries(struct vlheader *header)
531 afs_int32 type, rindex, i, j, e;
532 int freecount = 0, mhcount = 0, vlcount = 0;
533 int rwcount = 0, rocount = 0, bkcount = 0;
534 struct nvlentry vlentry;
536 afs_uint32 entrysize = 0;
537 afs_uint32 maxvolid = 0;
539 if (verbose) quiet_println("Read each entry in the database\n");
540 for (addr = header->vital_header.headersize;
541 addr < header->vital_header.eofPtr; addr += entrysize) {
543 /* Remember the highest volume id */
544 readentry(addr, &vlentry, &type);
546 if (!(vlentry.flags & VLF_RWEXISTS))
547 log_error(VLDB_CHECK_WARNING,"VLDB_CHECK_WARNING: VLDB entry '%s' has no RW volume\n",
550 for (i = 0; i < MAXTYPES; i++)
551 if (maxvolid < vlentry.volumeId[i])
552 maxvolid = vlentry.volumeId[i];
555 for (j = 0; j < NMAXNSERVERS; j++) {
556 if (vlentry.serverNumber[j] == 255)
558 if (vlentry.serverFlags[j] & (VLSF_ROVOL | VLSF_NEWREPSITE)) {
562 if (vlentry.serverFlags[j] & VLSF_RWVOL) {
564 if (vlentry.flags & VLF_BACKEXISTS)
568 if (!vlentry.serverFlags[j]) {
574 (VLDB_CHECK_ERROR,"VLDB entry '%s' contains an unknown RW/RO index serverFlag\n",
579 (" index %d : serverNumber %d : serverPartition %d : serverFlag %d\n",
580 j, vlentry.serverNumber[j], vlentry.serverPartition[j],
581 vlentry.serverFlags[j]);
585 rindex = addr / sizeof(vlentry);
586 if (record[rindex].type) {
587 log_error(VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: record holder %d already in use\n",
591 record[rindex].addr = addr;
592 record[rindex].type = type;
594 /* Determine entrysize and keep count */
596 entrysize = sizeof(vlentry);
598 } else if (type == FR) {
599 entrysize = sizeof(vlentry);
601 } else if (type == MH) {
602 entrysize = VL_ADDREXTBLK_SIZE;
605 log_error(VLDB_CHECK_ERROR, "Unknown entry at %u. Aborting\n", addr);
610 quiet_println("Found %d entries, %d free entries, %d multihomed blocks\n",
611 vlcount, freecount, mhcount);
612 quiet_println("Found %d RW volumes, %d BK volumes, %d RO volumes\n", rwcount,
616 /* Check the maxmimum volume id in the header */
617 if (maxvolid != header->vital_header.MaxVolumeId - 1)
619 ("Header's maximum volume id is %u and largest id found in VLDB is %u\n",
620 header->vital_header.MaxVolumeId, maxvolid);
625 SetHashEnd(long addr, int type, long new)
627 struct nvlentry vlentry;
628 afs_int32 type2, next = -1;
630 for (; addr; addr = next) {
631 readentry(addr, &vlentry, &type2);
632 switch(type & 0xf0) {
634 next = vlentry.nextIdHash[0];
637 next = vlentry.nextIdHash[1];
640 next = vlentry.nextIdHash[2];
643 next = vlentry.nextNameHash;
650 switch(type & 0xf0) {
652 if (vlentry.nextIdHash[0] != 0) {quiet_println("bwoop\n");}
653 vlentry.nextIdHash[0] = new;
656 if (vlentry.nextIdHash[1] != 0) {quiet_println("bwoop\n");}
657 vlentry.nextIdHash[1] = new;
660 if (vlentry.nextIdHash[2] != 0) {quiet_println("bwoop\n");}
661 vlentry.nextIdHash[2] = new;
664 if (vlentry.nextNameHash != 0) {quiet_println("bwoop\n");}
665 vlentry.nextNameHash = new;
668 writeentry(addr, &vlentry);
675 * Follow each Name hash bucket marking it as read in the record array.
676 * Record we found it in the name hash within the record array.
677 * Check that the name is hashed correctly.
680 FollowNameHash(struct vlheader *header)
682 int count = 0, longest = 0, shortest = -1, chainlength;
683 struct nvlentry vlentry;
685 afs_int32 i, type, rindex;
687 /* Now follow the Name Hash Table */
688 if (verbose) quiet_println("Check Volume Name Hash\n");
689 for (i = 0; i < HASHSIZE; i++) {
691 for (addr = header->VolnameHash[i]; addr; addr = vlentry.nextNameHash) {
692 readentry(addr, &vlentry, &type);
694 log_error(VLDB_CHECK_ERROR,"Name Hash %d: Bad entry at %u: Not a valid vlentry\n",
699 rindex = addr / sizeof(vlentry);
701 if (record[rindex].addr != addr && record[rindex].addr) {
703 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
704 record[rindex].addr, addr, rindex);
706 if (record[rindex].type & NH) {
708 (VLDB_CHECK_ERROR,"Name Hash %d: Bad entry '%s': Already in the name hash\n",
710 record[rindex].type |= MULTN;
713 record[rindex].type |= NH;
714 record[rindex].type |= REFN;
719 /* Hash the name and check if in correct hash table */
720 if (NameHash(vlentry.name) != i) {
722 (VLDB_CHECK_ERROR,"Name Hash %d: Bad entry '%s': Incorrect name hash chain (should be in %d)\n",
723 i, vlentry.name, NameHash(vlentry.name));
724 record[rindex].type |= MULTN;
727 if (chainlength > longest)
728 longest = chainlength;
729 if ((shortest == -1) || (chainlength < shortest))
730 shortest = chainlength;
734 ("%d entries in name hash, longest is %d, shortest is %d, average length is %f\n",
735 count, longest, shortest, ((float)count / (float)HASHSIZE));
741 * Follow the ID hash chains for the RW, RO, and BK hash tables.
742 * Record we found it in the id hash within the record array.
743 * Check that the ID is hashed correctly.
746 FollowIdHash(struct vlheader *header)
748 int count = 0, longest = 0, shortest = -1, chainlength;
749 struct nvlentry vlentry;
751 afs_int32 i, j, hash, type, rindex, ref, badref, badhash;
753 /* Now follow the RW, RO, and BK Hash Tables */
754 if (verbose) quiet_println("Check RW, RO, and BK id Hashes\n");
755 for (i = 0; i < MAXTYPES; i++) {
756 hash = ((i == 0) ? RWH : ((i == 1) ? ROH : BKH));
757 ref = ((i == 0) ? REFRW : ((i == 1) ? REFRO : REFBK));
758 badref = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
759 badhash = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
763 for (j = 0; j < HASHSIZE; j++) {
765 for (addr = header->VolidHash[i][j]; addr;
766 addr = vlentry.nextIdHash[i]) {
767 readentry(addr, &vlentry, &type);
770 (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry at %u: Not a valid vlentry\n",
775 rindex = addr / sizeof(vlentry);
776 if (record[rindex].addr != addr && record[rindex].addr) {
778 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
779 record[rindex].addr, addr, rindex);
781 if (record[rindex].type & hash) {
783 (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry '%s': Already in the hash table\n",
784 vtype(i), j, vlentry.name);
785 record[rindex].type |= badref;
788 record[rindex].type |= hash;
789 record[rindex].type |= ref;
794 /* Hash the id and check if in correct hash table */
795 if (IdHash(vlentry.volumeId[i]) != j) {
797 (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry '%s': Incorrect Id hash chain (should be in %d)\n",
798 vtype(i), j, vlentry.name,
799 IdHash(vlentry.volumeId[i]));
800 record[rindex].type |= badhash;
801 printf("%d: %x\n", rindex, record[rindex].type);
805 if (chainlength > longest)
806 longest = chainlength;
807 if ((shortest == -1) || (chainlength < shortest))
808 shortest = chainlength;
812 ("%d entries in %s hash, longest is %d, shortest is %d, average length is %f\n",
813 count, vtype(i), longest, shortest,((float)count / (float)HASHSIZE));
820 * Follow the free chain.
821 * Record we found it in the free chain within the record array.
824 FollowFreeChain(struct vlheader *header)
827 struct nvlentry vlentry;
829 afs_int32 type, rindex;
831 /* Now follow the Free Chain */
832 if (verbose) quiet_println("Check Volume Free Chain\n");
833 for (addr = header->vital_header.freePtr; addr;
834 addr = vlentry.nextIdHash[0]) {
835 readentry(addr, &vlentry, &type);
838 (VLDB_CHECK_ERROR,"Free Chain %d: Bad entry at %u: Not a valid free vlentry (0x%x)\n",
843 rindex = addr / sizeof(vlentry);
844 if (record[rindex].addr != addr && record[rindex].addr) {
846 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u and %ld use same record slot %d\n",
847 record[rindex].addr, addr, rindex);
849 if (record[rindex].type & FRC) {
850 log_error(VLDB_CHECK_ERROR,"Free Chain: Bad entry at %u: Already in the free chain\n",
854 record[rindex].type |= FRC;
859 quiet_println("%d entries on free chain\n", count);
864 * Read each multihomed block and mark it as found in the record.
865 * Read each entry in each multihomed block and mark the serveraddrs
866 * array with the number of ip addresses found for this entry.
868 * Then read the IpMappedAddr array in the header.
869 * Verify that multihomed entries base and index are valid and points to
870 * a good multhomed entry.
871 * Mark the serveraddrs array with 1 ip address for regular entries.
873 * By the end, the severaddrs array will have a 0 if the entry has no
874 * IP addresses in it or the count of the number of IP addresses.
876 * The code does not verify if there are duplicate IP addresses in the
877 * list. The vlserver does this when a fileserver registeres itself.
880 CheckIpAddrs(struct vlheader *header)
883 afs_int32 i, j, m, rindex;
884 afs_int32 mhentries, regentries;
885 afs_int32 caddrs[VL_MAX_ADDREXTBLKS];
886 char mhblock[VL_ADDREXTBLK_SIZE];
887 struct extentaddr *MHblock = (struct extentaddr *)mhblock;
888 struct extentaddr *e;
889 int ipindex, ipaddrs;
892 memset(&nulluuid, 0, sizeof(nulluuid));
895 quiet_println("Check Multihomed blocks\n");
898 /* Read the first MH block and from it, gather the
899 * addresses of all the mh blocks.
901 readMH(header->SIT, MHblock);
902 if (MHblock->ex_flags != VLCONTBLOCK) {
904 (VLDB_CHECK_ERROR,"Multihomed Block 0: Bad entry at %u: Not a valid multihomed block\n",
908 for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
909 caddrs[i] = MHblock->ex_contaddrs[i];
912 if (header->SIT != caddrs[0]) {
914 (VLDB_CHECK_ERROR,"MH block does not point to self %u in header, %u in block\n",
915 header->SIT, caddrs[0]);
918 /* Now read each MH block and record it in the record array */
919 for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
923 readMH(caddrs[i], MHblock);
924 if (MHblock->ex_flags != VLCONTBLOCK) {
926 (VLDB_CHECK_ERROR,"Multihomed Block 0: Bad entry at %u: Not a valid multihomed block\n",
930 rindex = caddrs[i] / sizeof(vlentry);
931 if (record[rindex].addr != caddrs[i] && record[rindex].addr) {
933 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u and %u use same record slot %d\n",
934 record[rindex].addr, caddrs[i], rindex);
936 if (record[rindex].type & FRC) {
938 (VLDB_CHECK_ERROR,"MH Blocks Chain %d: Bad entry at %ld: Already a MH block\n",
939 i, record[rindex].addr);
942 record[rindex].type |= MHC;
946 /* Read each entry in a multihomed block.
947 * Find the pointer to the entry in the IpMappedAddr array and
948 * verify that the entry is good (has IP addresses in it).
951 for (j = 1; j < VL_MHSRV_PERBLK; j++) {
952 e = (struct extentaddr *)&(MHblock[j]);
954 /* Search the IpMappedAddr array for the reference to this entry */
955 for (ipindex = 0; ipindex < MAXSERVERID; ipindex++) {
956 if (((header->IpMappedAddr[ipindex] & 0xff000000) ==
960 IpMappedAddr[ipindex] & 0x00ff0000) >> 16) == i)
961 && ((header->IpMappedAddr[ipindex] & 0x0000ffff) ==
966 if (ipindex >= MAXSERVERID)
969 serveraddrs[ipindex] = -1;
971 if (memcmp(&e->ex_hostuuid, &nulluuid, sizeof(afsUUID)) == 0) {
974 (VLDB_CHECK_ERROR,"Server Addrs index %d references null MH block %d, index %d\n",
976 serveraddrs[ipindex] = 0; /* avoids printing 2nd error below */
981 /* Step through each ip address and count the good addresses */
983 for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
988 /* If we found any good ip addresses, mark it in the serveraddrs record */
993 (VLDB_CHECK_ERROR,"MH block %d, index %d: Not referenced by server addrs\n",
996 serveraddrs[ipindex] = ipaddrs; /* It is good */
1000 if (listservers && ipaddrs) {
1001 quiet_println("MH block %d, index %d:", i, j);
1002 for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
1003 if (!e->ex_addrs[m])
1005 quiet_println(" %d.%d.%d.%d",
1006 (e->ex_addrs[m] & 0xff000000) >> 24,
1007 (e->ex_addrs[m] & 0x00ff0000) >> 16,
1008 (e->ex_addrs[m] & 0x0000ff00) >> 8,
1009 (e->ex_addrs[m] & 0x000000ff));
1011 quiet_println("\n");
1015 * if (mhentries != MHblock->ex_count) {
1016 * quiet_println("MH blocks says it has %d entries (found %d)\n",
1017 * MHblock->ex_count, mhentries);
1023 quiet_println("%d multihomed blocks\n", mhblocks);
1025 /* Check the server addresses */
1027 quiet_println("Check server addresses\n");
1028 mhentries = regentries = 0;
1029 for (i = 0; i <= MAXSERVERID; i++) {
1030 if (header->IpMappedAddr[i]) {
1031 if ((header->IpMappedAddr[i] & 0xff000000) == 0xff000000) {
1033 if (((header->IpMappedAddr[i] & 0x00ff0000) >> 16) >
1036 (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome block is bad (%d)\n",
1037 i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
1038 if (((header->IpMappedAddr[i] & 0x0000ffff) > VL_MHSRV_PERBLK)
1039 || ((header->IpMappedAddr[i] & 0x0000ffff) < 1))
1041 (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome index is bad (%d)\n",
1042 i, (header->IpMappedAddr[i] & 0x0000ffff));
1043 if (serveraddrs[i] == -1) {
1045 (VLDB_CHECK_WARNING,"warning: IP Addr for entry %d: Multihome entry has no ip addresses\n",
1050 quiet_println(" Server ip addr %d = MH block %d, index %d\n",
1051 i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1052 (header->IpMappedAddr[i] & 0x0000ffff));
1056 serveraddrs[i] = 1; /* It is good */
1058 quiet_println(" Server ip addr %d = %d.%d.%d.%d\n", i,
1059 (header->IpMappedAddr[i] & 0xff000000) >> 24,
1060 (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1061 (header->IpMappedAddr[i] & 0x0000ff00) >> 8,
1062 (header->IpMappedAddr[i] & 0x000000ff));
1068 quiet_println("%d simple entries, %d multihomed entries, Total = %d\n",
1069 regentries, mhentries, mhentries + regentries);
1075 FixBad(afs_uint32 idx, afs_uint32 addr, afs_uint32 type, afs_uint32 tmp,
1076 struct nvlentry *vlentry, afs_uint32 hash) {
1077 SetHashEnd(addr, type, tmp);
1078 quiet_println("linked unlinked chain %u (index %lu) to end of chain %d for %s hash\n",
1079 tmp, ADDR(tmp), hash, type==NH?"Name":(type==RWH?"RW":(type==ROH?"RO":"BK")));
1083 WorkerBee(struct cmd_syndesc *as, void *arock)
1086 afs_int32 maxentries, type;
1087 struct vlheader header;
1088 struct nvlentry vlentry, vlentry2;
1091 error_level = 0; /* start clean with no error status */
1092 dbfile = as->parms[0].items->data; /* -database */
1093 listuheader = (as->parms[1].items ? 1 : 0); /* -uheader */
1094 listheader = (as->parms[2].items ? 1 : 0); /* -vheader */
1095 listservers = (as->parms[3].items ? 1 : 0); /* -servers */
1096 listentries = (as->parms[4].items ? 1 : 0); /* -entries */
1097 verbose = (as->parms[5].items ? 1 : 0); /* -verbose */
1098 quiet = (as->parms[6].items ? 1 : 0); /* -quiet */
1099 fix = (as->parms[7].items ? 1 : 0); /* -fix */
1102 if (quiet && (verbose || listuheader || listheader ||listservers \
1104 log_error(VLDB_CHECK_FATAL," -quiet cannot be used other display flags\n");
1105 return VLDB_CHECK_FATAL;
1109 /* open the vldb database file */
1110 fd = open(dbfile, (fix > 0)?O_RDWR:O_RDONLY, 0);
1112 log_error(VLDB_CHECK_FATAL,"can't open file '%s'. error = %d\n", dbfile, errno);
1116 /* read the ubik header and the vldb database header */
1118 readheader(&header);
1119 if (header.vital_header.vldbversion < 3) {
1120 log_error(VLDB_CHECK_FATAL,"does not support vldb with version less than 3\n");
1121 return VLDB_CHECK_FATAL;
1124 maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
1125 record = (struct er *)malloc(maxentries * sizeof(struct er));
1126 memset((char *)record, 0, (maxentries * sizeof(struct er)));
1127 memset((char *)serveraddrs, 0, sizeof(serveraddrs));
1129 /* Will fill in the record array of entries it found */
1130 ReadAllEntries(&header);
1131 listentries = 0; /* Listed all the entries */
1133 /* Check the multihomed blocks for valid entries as well as
1134 * the IpMappedAddrs array in the header for valid entries.
1136 CheckIpAddrs(&header);
1138 /* Follow the hash tables */
1139 FollowNameHash(&header);
1140 FollowIdHash(&header);
1142 /* Follow the chain of free entries */
1143 FollowFreeChain(&header);
1145 /* Now check the record we have been keeping for inconsistencies
1146 * For valid vlentries, also check that the server we point to is
1147 * valid (the serveraddrs array).
1150 quiet_println("Verify each volume entry\n");
1151 for (i = 0; i < maxentries; i++) {
1159 if (record[i].type == 0)
1162 /* If a vlentry, verify that its name is valid, its name and ids are
1163 * on the hash chains, and its server numbers are good.
1165 if (record[i].type & VL) {
1169 readentry(record[i].addr, &vlentry, &type);
1171 if (InvalidVolname(vlentry.name))
1172 log_error(VLDB_CHECK_ERROR,"Volume '%s' at addr %ld has an invalid name\n",
1173 vlentry.name, record[i].addr);
1175 if (!(record[i].type & NH)) {
1176 nextp = ADDR(vlentry.nextNameHash);
1178 hash = NameHash(vlentry.name);
1179 nextpp = &vlentry.nextNameHash;
1181 sprintf(volidbuf, "");
1185 if (vlentry.volumeId[0] && !(record[i].type & RWH)) {
1186 nextp = ADDR(vlentry.nextIdHash[0]);
1188 hash = IdHash(vlentry.volumeId[0]);
1189 nextpp = &(vlentry.nextIdHash[0]);
1191 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1195 if (vlentry.volumeId[1] && !(record[i].type & ROH)) {
1196 nextp = ADDR(vlentry.nextIdHash[1]);
1198 hash = IdHash(vlentry.volumeId[1]);
1199 nextpp = &(vlentry.nextIdHash[1]);
1201 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1205 if (vlentry.volumeId[2] && !(record[i].type & BKH)) {
1206 nextp = ADDR(vlentry.nextIdHash[2]);
1208 hash = IdHash(vlentry.volumeId[2]);
1209 nextpp = &(vlentry.nextIdHash[2]);
1211 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1215 if (record[ADDR(vlentry.nextNameHash)].type & MULTN) {
1216 nextp = ADDR(vlentry.nextNameHash);
1218 hash = NameHash(vlentry.name);
1219 nextpp = &vlentry.nextNameHash;
1221 sprintf(volidbuf, "");
1222 readentry(nextp, &vlentry2, &type);
1223 nexthash = NameHash(vlentry2.name);
1224 if (hash != nexthash)
1228 if ((record[ADDR(vlentry.nextIdHash[0])].type & MULTRW)) {
1229 nextp = ADDR(vlentry.nextIdHash[0]);
1231 hash = IdHash(vlentry.volumeId[0]);
1232 nextpp = &(vlentry.nextIdHash[0]);
1234 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1235 readentry(nextp, &vlentry2, &type);
1236 nexthash = IdHash(vlentry2.volumeId[0]);
1237 if (hash != nexthash)
1241 if ((record[ADDR(vlentry.nextIdHash[1])].type & MULTRO)) {
1242 nextp = ADDR(vlentry.nextIdHash[1]);
1244 hash = IdHash(vlentry.volumeId[1]);
1245 nextpp = &(vlentry.nextIdHash[1]);
1247 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1248 readentry(nextp, &vlentry2, &type);
1249 nexthash = IdHash(vlentry2.volumeId[1]);
1250 if (hash != nexthash)
1254 if ((record[ADDR(vlentry.nextIdHash[2])].type & MULTBK)) {
1255 nextp = ADDR(vlentry.nextIdHash[2]);
1257 hash = IdHash(vlentry.volumeId[2]);
1258 nextpp = &(vlentry.nextIdHash[2]);
1260 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1261 readentry(nextp, &vlentry2, &type);
1262 nexthash = IdHash(vlentry2.volumeId[2]);
1263 if (hash != nexthash)
1268 log_error(VLDB_CHECK_ERROR,"%d: Volume '%s' %snot found in %s hash %d", i,
1269 vlentry.name, volidbuf, which, hash);
1271 log_error(VLDB_CHECK_ERROR," (next %d", nextp);
1272 if (!(record[nextp].type & reft)) {
1273 log_error(VLDB_CHECK_ERROR," not in chain ");
1274 record[nextp].type |= reft;
1275 } else if (nextp != 0) {
1276 log_error(VLDB_CHECK_ERROR," next in chain");
1278 log_error(VLDB_CHECK_ERROR,", unchaining");
1280 writeentry(record[i].addr, &vlentry);
1283 log_error(VLDB_CHECK_ERROR,")");
1285 log_error(VLDB_CHECK_ERROR,"\n");
1288 for (j = 0; j < NMAXNSERVERS; j++) {
1289 if ((vlentry.serverNumber[j] != 255)
1290 && (serveraddrs[vlentry.serverNumber[j]] == 0)) {
1292 (VLDB_CHECK_ERROR,"Volume '%s', index %d points to empty server entry %d\n",
1293 vlentry.name, j, vlentry.serverNumber[j]);
1297 if (record[i].type & 0xffff0f00)
1299 (VLDB_CHECK_ERROR,"Volume '%s' id %u also found on other chains (0x%x)\n",
1300 vlentry.name, vlentry.volumeId[0], record[i].type);
1303 } else if (record[i].type & FR) {
1304 if (!(record[i].type & FRC))
1305 log_error(VLDB_CHECK_ERROR,"Free vlentry at %ld not on free chain\n",
1308 if (record[i].type & 0xfffffdf0)
1310 (VLDB_CHECK_ERROR,"Free vlentry at %ld also found on other chains (0x%x)\n",
1311 record[i].addr, record[i].type);
1313 /* A multihomed entry */
1314 } else if (record[i].type & MH) {
1315 if (!(record[i].type & MHC))
1316 log_error(VLDB_CHECK_ERROR,"Multihomed block at %ld is orphaned\n",
1319 if (record[i].type & 0xfffffef0)
1321 (VLDB_CHECK_ERROR,"Multihomed block at %ld also found on other chains (0x%x)\n",
1322 record[i].addr, record[i].type);
1325 log_error(VLDB_CHECK_ERROR,"Unknown entry type at %u (0x%x)\n", record[i].addr,
1330 if (verbose) quiet_println("Verify each chain head\n");
1335 for (j = 0; j < HASHSIZE; j++) {
1336 for (addr = header.VolnameHash[j]; j < HASHSIZE; j++) {
1337 if (record[ADDR(addr)].type & MULTN) {
1338 hash = NameHash(vlentry.name);
1340 header.VolnameHash[j] = vlentry.nextNameHash;
1341 vlentry.nextNameHash = 0;
1343 writeentry(record[i].addr, &vlentry);
1348 for (i = 0; i <= 2; i++) {
1349 for (j = 0, addr = header.VolidHash[i][j]; j < HASHSIZE; j++) {
1350 if (verbose) quiet_println("got %d %d %d\n", i, j, ADDR(addr));
1351 if (i == 0 && (record[ADDR(addr)].type & MULTRW)) {
1352 hash = IdHash(vlentry.volumeId[i]);
1354 header.VolidHash[i][j] = vlentry.nextIdHash[i];
1355 vlentry.nextIdHash[i] = 0;
1357 quiet_println("fix %d %d %d\n", i, j, ADDR(addr));
1358 writeentry(record[i].addr, &vlentry);
1363 if (i == 1 && (record[ADDR(addr)].type & MULTRO)) {
1364 hash = IdHash(vlentry.volumeId[i]);
1366 header.VolidHash[i][j] = vlentry.nextIdHash[i];
1367 vlentry.nextIdHash[i] = 0;
1369 quiet_println("fix %d %d %d\n", i, j, addr);
1370 writeentry(record[i].addr, &vlentry);
1375 if (i == 2 && (record[ADDR(addr)].type & MULTBK)) {
1376 hash = IdHash(vlentry.volumeId[i]);
1378 header.VolidHash[i][j] = vlentry.nextIdHash[i];
1379 vlentry.nextIdHash[i] = 0;
1381 quiet_println("fix %d %d %d\n", i, j, addr);
1382 writeentry(record[i].addr, &vlentry);
1389 /* By the time we get here, unchained entries are really unchained */
1390 quiet_println("Scanning %u entries for possible repairs\n", maxentries);
1391 for (i = 0; i < maxentries; i++) {
1393 if (record[i].type & VL) {
1394 readentry(record[i].addr, &vlentry, &type);
1395 if (!(record[i].type & REFN)) {
1396 log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a name chain\n", i,
1397 record[i].addr, record[i].type);
1398 if (strlen(vlentry.name)>0) {
1400 if (header.VolnameHash[NameHash(vlentry.name)] == 0)
1401 header.VolnameHash[NameHash(vlentry.name)] = record[i].addr;
1403 FixBad(i, header.VolnameHash[NameHash(vlentry.name)], NH, record[i].addr, &vlentry, NameHash(vlentry.name));
1406 nextpp = &vlentry.nextNameHash;
1407 if (fix && *nextpp) {
1408 printf(", unchaining");
1410 writeentry(record[i].addr, &vlentry);
1414 if (vlentry.volumeId[0] && !(record[i].type & REFRW)) {
1415 log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RW chain\n", i,
1416 record[i].addr, record[i].type);
1418 if (header.VolidHash[0][IdHash(vlentry.volumeId[0])] == 0)
1419 header.VolidHash[0][IdHash(vlentry.volumeId[0])] = record[i].addr;
1421 FixBad(i, header.VolidHash[0][IdHash(vlentry.volumeId[0])], RWH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[0]));
1424 if (vlentry.volumeId[1] && !(record[i].type & REFRO)) {
1425 log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RO chain\n", i,
1426 record[i].addr, record[i].type);
1428 if (header.VolidHash[1][IdHash(vlentry.volumeId[1])] == 0)
1429 header.VolidHash[1][IdHash(vlentry.volumeId[1])] = record[i].addr;
1431 FixBad(i, header.VolidHash[1][IdHash(vlentry.volumeId[1])], ROH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[1]));
1434 if (vlentry.volumeId[2] && !(record[i].type & REFBK)) {
1435 log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a BK chain\n", i,
1436 record[i].addr, record[i].type);
1438 if (header.VolidHash[2][IdHash(vlentry.volumeId[2])] == 0)
1439 header.VolidHash[2][IdHash(vlentry.volumeId[2])] = record[i].addr;
1441 FixBad(i, header.VolidHash[2][IdHash(vlentry.volumeId[2])], BKH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[2]));
1448 writeheader(&header);
1464 main(int argc, char **argv)
1466 struct cmd_syndesc *ts;
1470 ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "vldb check");
1471 cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "vldb_file");
1472 cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
1473 "Display UBIK header");
1474 cmd_AddParm(ts, "-vheader", CMD_FLAG, CMD_OPTIONAL,
1475 "Display VLDB header");
1476 cmd_AddParm(ts, "-servers", CMD_FLAG, CMD_OPTIONAL,
1477 "Display server list");
1478 cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
1479 cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
1480 cmd_AddParm(ts, "-quiet", CMD_FLAG, CMD_OPTIONAL, "quiet");
1481 cmd_AddParm(ts, "-fix", CMD_FLAG, CMD_OPTIONAL, "attempt to patch the database (potentially dangerous)");
1483 return cmd_Dispatch(argc, argv);