int listentries, listservers, listheader, listuheader, verbose, quiet;
int fix = 0;
-int fixed = 0;
int passes = 0;
/* if quiet, don't send anything to stdout */
int quiet = 0;
}
uheader.magic = ntohl(uheader.magic);
- uheader.size = ntohl(uheader.size);
+ uheader.size = ntohs(uheader.size);
uheader.version.epoch = ntohl(uheader.version.epoch);
uheader.version.counter = ntohl(uheader.version.counter);
quiet_println(" ro");
if (vlentryp->flags & VLF_BACKEXISTS)
quiet_println(" bk");
- if (vlentryp->flags & 0xffff8fff)
+ if (vlentryp->flags & VLOP_MOVE)
+ quiet_println(" lock_move");
+ if (vlentryp->flags & VLOP_RELEASE)
+ quiet_println(" lock_release");
+ if (vlentryp->flags & VLOP_BACKUP)
+ quiet_println(" lock_backup");
+ if (vlentryp->flags & VLOP_DELETE)
+ quiet_println(" lock_delete");
+ if (vlentryp->flags & VLOP_DUMP)
+ quiet_println(" lock_dump");
+
+ /* all bits not covered by VLF_* and VLOP_* constants */
+ if (vlentryp->flags & 0xffff8e0f)
quiet_println(" errorflag(0x%x)", vlentryp->flags);
quiet_println("\n");
quiet_println(" LockAfsId = %d\n", vlentryp->LockAfsId);
int i;
if (verbose) quiet_println("Writing back entry at addr %u\n", addr);
- fixed++;
for (i = 0; i < MAXTYPES; i++)
vlentryp->volumeId[i] = htonl(vlentryp->volumeId[i]);
vlentryp->flags = htonl(vlentryp->flags);
header->vital_header.MaxVolumeId, maxvolid);
}
-
-void
-SetHashEnd(long addr, int type, long new)
-{
- struct nvlentry vlentry;
- afs_int32 type2, next = -1;
-
- for (; addr; addr = next) {
- readentry(addr, &vlentry, &type2);
- switch(type & 0xf0) {
- case RWH:
- next = vlentry.nextIdHash[0];
- break;
- case ROH:
- next = vlentry.nextIdHash[1];
- break;
- case BKH:
- next = vlentry.nextIdHash[2];
- break;
- case NH:
- next = vlentry.nextNameHash;
- break;
- default:
- next = -1;
- }
-
- if (next < 1) {
- switch(type & 0xf0) {
- case RWH:
- if (vlentry.nextIdHash[0] != 0) {quiet_println("bwoop\n");}
- vlentry.nextIdHash[0] = new;
- break;
- case ROH:
- if (vlentry.nextIdHash[1] != 0) {quiet_println("bwoop\n");}
- vlentry.nextIdHash[1] = new;
- break;
- case BKH:
- if (vlentry.nextIdHash[2] != 0) {quiet_println("bwoop\n");}
- vlentry.nextIdHash[2] = new;
- break;
- case NH:
- if (vlentry.nextNameHash != 0) {quiet_println("bwoop\n");}
- vlentry.nextNameHash = new;
- break;
- }
- writeentry(addr, &vlentry);
- return;
- }
- }
-}
-
/*
* Follow each Name hash bucket marking it as read in the record array.
* Record we found it in the name hash within the record array.
int mhblocks = 0;
afs_int32 i, j, m, rindex;
afs_int32 mhentries, regentries;
- afs_int32 caddrs[VL_MAX_ADDREXTBLKS];
+ afs_uint32 caddrs[VL_MAX_ADDREXTBLKS];
char mhblock[VL_ADDREXTBLK_SIZE];
struct extentaddr *MHblock = (struct extentaddr *)mhblock;
struct extentaddr *e;
return;
}
-void
-FixBad(afs_uint32 idx, afs_uint32 addr, afs_uint32 type, afs_uint32 tmp,
- struct nvlentry *vlentry, afs_uint32 hash) {
- SetHashEnd(addr, type, tmp);
- quiet_println("linked unlinked chain %u (index %lu) to end of chain %d for %s hash\n",
- tmp, ADDR(tmp), hash, type==NH?"Name":(type==RWH?"RW":(type==ROH?"RO":"BK")));
+char *
+nameForAddr(afs_uint32 addr, int hashtype, afs_uint32 *hash, char *buffer)
+{
+ /*
+ * We need to simplify the reporting, while retaining
+ * legible messages. This is a helper function. The return address
+ * is either a fixed char or the provided buffer - so don't use the
+ * name after the valid lifetime of the buffer.
+ */
+ afs_int32 type;
+ struct nvlentry entry;
+ if (!addr) {
+ /* Distinguished, invalid, hash */
+ *hash = 0xFFFFFFFF;
+ return "empty";
+ } else if (!validVolumeAddr(addr)) {
+ /* Different, invalid, hash */
+ *hash = 0XFFFFFFFE;
+ return "invalid";
+ }
+ readentry(addr, &entry, &type);
+ if (VL != type) {
+ *hash = 0XFFFFFFFE;
+ return "invalid";
+ }
+ if (hashtype >= MAXTYPES) {
+ *hash = NameHash(entry.name);
+ } else {
+ *hash = IdHash(entry.volumeId[hashtype]);
+ }
+ sprintf(buffer, "for '%s'", entry.name);
+ return buffer;
+}
+
+void
+reportHashChanges(struct vlheader *header, afs_uint32 oldnamehash[HASHSIZE], afs_uint32 oldidhash[MAXTYPES][HASHSIZE])
+{
+ int i, j;
+ afs_uint32 oldhash, newhash;
+ char oldNameBuffer[10 + VL_MAXNAMELEN];
+ char newNameBuffer[10 + VL_MAXNAMELEN];
+ char *oldname, *newname;
+ /*
+ * report hash changes
+ */
+
+ for (i = 0; i < HASHSIZE; i++) {
+ if (oldnamehash[i] != header->VolnameHash[i]) {
+
+ oldname = nameForAddr(oldnamehash[i], MAXTYPES, &oldhash, oldNameBuffer);
+ newname = nameForAddr(header->VolnameHash[i], MAXTYPES, &newhash, newNameBuffer);
+ if (verbose || (oldhash != newhash)) {
+ quiet_println("FIX: Name hash header at %d was %s, is now %s\n", i, oldname, newname);
+ }
+ }
+ for (j = 0; j < MAXTYPES; j++) {
+ if (oldidhash[j][i] != header->VolidHash[j][i]) {
+
+ oldname = nameForAddr(oldidhash[j][i], j, &oldhash, oldNameBuffer);
+ newname = nameForAddr(header->VolidHash[j][i], j, &newhash, newNameBuffer);
+ if (verbose || (oldhash != newhash)) {
+ quiet_println("FIX: %s hash header at %d was %s, is now %s\n", vtype(j), i, oldname, newname);
+ }
+ }
+ }
+ }
}
int
struct vlheader header;
struct nvlentry vlentry, vlentry2;
int i, j;
+ afs_uint32 oldnamehash[HASHSIZE];
+ afs_uint32 oldidhash[MAXTYPES][HASHSIZE];
error_level = 0; /* start clean with no error status */
dbfile = as->parms[0].items->data; /* -database */
return VLDB_CHECK_FATAL;
}
- restart:
+
/* open the vldb database file */
fd = open(dbfile, (fix > 0)?O_RDWR:O_RDONLY, 0);
if (fd < 0) {
}
if (foundbroken) {
- log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)", i,
+ log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)\n", i,
vlentry.name, volidbuf, which, hash, nexthash);
} else if (foundbad) {
- log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %snot found in %s hash %d", i,
+ log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %snot found in %s hash %d\n", i,
vlentry.name, volidbuf, which, hash);
}
- if (foundbad || foundbroken) {
- if (nextp && fix) {
- log_error(VLDB_CHECK_ERROR, ", unchaining next (%d)\n", nextp);
- *nextpp = 0;
- writeentry(record[i].addr, &vlentry);
- } else {
- log_error(VLDB_CHECK_ERROR, "\n");
- }
-
- }
-
for (j = 0; j < NMAXNSERVERS; j++) {
if ((vlentry.serverNumber[j] != 255)
&& (serveraddrs[vlentry.serverNumber[j]] == 0)) {
}
}
- if (verbose) quiet_println("Verify each chain head\n");
- {
- afs_uint32 addr;
- int hash;
-
- for (j = 0; j < HASHSIZE; j++) {
- for (addr = header.VolnameHash[j]; j < HASHSIZE; j++) {
- if (record[ADDR(addr)].type & MULTN) {
- hash = NameHash(vlentry.name);
- if (hash != j) {
- header.VolnameHash[j] = vlentry.nextNameHash;
- vlentry.nextNameHash = 0;
- if (fix)
- writeentry(record[i].addr, &vlentry);
- }
- }
- }
- }
- for (i = 0; i <= 2; i++) {
- for (j = 0, addr = header.VolidHash[i][j]; j < HASHSIZE; j++) {
- if (verbose) quiet_println("got %d %d %d\n", i, j, ADDR(addr));
- if (i == 0 && (record[ADDR(addr)].type & MULTRW)) {
- hash = IdHash(vlentry.volumeId[i]);
- if (hash != j) {
- header.VolidHash[i][j] = vlentry.nextIdHash[i];
- vlentry.nextIdHash[i] = 0;
- if (fix) {
- quiet_println("fix %d %d %d\n", i, j, ADDR(addr));
- writeentry(record[i].addr, &vlentry);
- }
- }
- }
-
- if (i == 1 && (record[ADDR(addr)].type & MULTRO)) {
- hash = IdHash(vlentry.volumeId[i]);
- if (hash != j) {
- header.VolidHash[i][j] = vlentry.nextIdHash[i];
- vlentry.nextIdHash[i] = 0;
- if (fix) {
- quiet_println("fix %d %d %d\n", i, j, addr);
- writeentry(record[i].addr, &vlentry);
- }
- }
- }
+ if (fix) {
+ /*
+ * If we are fixing we will rebuild all the hash lists from the ground up
+ */
+ memcpy(oldnamehash, header.VolnameHash, sizeof(oldnamehash));
+ memset(header.VolnameHash, 0, sizeof(header.VolnameHash));
- if (i == 2 && (record[ADDR(addr)].type & MULTBK)) {
- hash = IdHash(vlentry.volumeId[i]);
- if (hash != j) {
- header.VolidHash[i][j] = vlentry.nextIdHash[i];
- vlentry.nextIdHash[i] = 0;
- if (fix) {
- quiet_println("fix %d %d %d\n", i, j, addr);
- writeentry(record[i].addr, &vlentry);
- }
- }
- }
- }
- }
+ memcpy(oldidhash, header.VolidHash, sizeof(oldidhash));
+ memset(header.VolidHash, 0, sizeof(header.VolidHash));
+ quiet_println("Rebuilding %u entries\n", maxentries);
+ } else {
+ quiet_println("Scanning %u entries for possible repairs\n", maxentries);
}
- /* By the time we get here, unchained entries are really unchained */
- quiet_println("Scanning %u entries for possible repairs\n", maxentries);
for (i = 0; i < maxentries; i++) {
- int *nextpp;
+ afs_uint32 hash;
if (record[i].type & VL) {
readentry(record[i].addr, &vlentry, &type);
if (!(record[i].type & REFN)) {
log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a name chain\n", i,
record[i].addr, record[i].type);
- if (strlen(vlentry.name)>0) {
- if (fix) {
- if (header.VolnameHash[NameHash(vlentry.name)] == 0)
- header.VolnameHash[NameHash(vlentry.name)] = record[i].addr;
- else
- FixBad(i, header.VolnameHash[NameHash(vlentry.name)], NH, record[i].addr, &vlentry, NameHash(vlentry.name));
- }
- } else {
- nextpp = &vlentry.nextNameHash;
- if (fix && *nextpp) {
- printf(", unchaining");
- *nextpp = 0;
- writeentry(record[i].addr, &vlentry);
- }
- }
}
if (vlentry.volumeId[0] && !(record[i].type & REFRW)) {
log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RW chain\n", i,
record[i].addr, record[i].type);
- if (fix) {
- if (header.VolidHash[0][IdHash(vlentry.volumeId[0])] == 0)
- header.VolidHash[0][IdHash(vlentry.volumeId[0])] = record[i].addr;
- else
- FixBad(i, header.VolidHash[0][IdHash(vlentry.volumeId[0])], RWH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[0]));
- }
}
if (vlentry.volumeId[1] && !(record[i].type & REFRO)) {
log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RO chain\n", i,
record[i].addr, record[i].type);
- if (fix) {
- if (header.VolidHash[1][IdHash(vlentry.volumeId[1])] == 0)
- header.VolidHash[1][IdHash(vlentry.volumeId[1])] = record[i].addr;
- else
- FixBad(i, header.VolidHash[1][IdHash(vlentry.volumeId[1])], ROH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[1]));
- }
}
if (vlentry.volumeId[2] && !(record[i].type & REFBK)) {
log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a BK chain\n", i,
record[i].addr, record[i].type);
- if (fix) {
- if (header.VolidHash[2][IdHash(vlentry.volumeId[2])] == 0)
- header.VolidHash[2][IdHash(vlentry.volumeId[2])] = record[i].addr;
- else
- FixBad(i, header.VolidHash[2][IdHash(vlentry.volumeId[2])], BKH, record[i].addr, &vlentry, IdHash(vlentry.volumeId[2]));
+ }
+ if (fix) {
+ afs_uint32 oldhash, newhash;
+ char oldNameBuffer[10 + VL_MAXNAMELEN];
+ char newNameBuffer[10 + VL_MAXNAMELEN];
+ char *oldname, *newname;
+
+ /*
+ * Put the current hash table contexts into our 'next'
+ * and our address into the hash table.
+ */
+ hash = NameHash(vlentry.name);
+
+ if (vlentry.nextNameHash != header.VolnameHash[hash]) {
+ oldname = nameForAddr(vlentry.nextNameHash, MAXTYPES, &oldhash, oldNameBuffer);
+ newname = nameForAddr(header.VolnameHash[hash], MAXTYPES, &newhash, newNameBuffer);
+ if (verbose || ((oldhash != newhash) &&
+ (0 != vlentry.nextNameHash) &&
+ (0 != header.VolnameHash[hash]))) {
+ /*
+ * That is, only report if we are verbose
+ * or the hash is changing (and one side wasn't NULL
+ */
+ quiet_println("FIX: Name hash link for '%s' was %s, is now %s\n",
+ vlentry.name, oldname, newname);
+ }
}
+ vlentry.nextNameHash = header.VolnameHash[hash];
+ header.VolnameHash[hash] = record[i].addr;
+
+ for (j = 0; j < MAXTYPES; j++) {
+
+ if (0 == vlentry.volumeId[j]) {
+ /*
+ * No volume of that type. Continue
+ */
+ continue;
+ }
+ hash = IdHash(vlentry.volumeId[j]);
+
+ if (vlentry.nextIdHash[j] != header.VolidHash[j][hash]) {
+ oldname = nameForAddr(vlentry.nextIdHash[j], j, &oldhash, oldNameBuffer);
+ newname = nameForAddr(header.VolidHash[j][hash], j, &newhash, newNameBuffer);
+ if (verbose || ((oldhash != newhash) &&
+ (0 != vlentry.nextIdHash[j]) &&
+ (0 != header.VolidHash[j][hash]))) {
+ quiet_println("FIX: %s hash link for '%s' was %s, is now %s\n",
+ vtype(j), vlentry.name, oldname, newname);
+ }
+ }
+
+ vlentry.nextIdHash[j] = header.VolidHash[j][hash];
+ header.VolidHash[j][hash] = record[i].addr;
+ }
+ writeentry(record[i].addr, &vlentry);
}
}
}
- if (fix)
+ if (fix) {
+ reportHashChanges(&header, oldnamehash, oldidhash);
writeheader(&header);
+ }
close(fd);
- if (fixed) {
- fixed=0;
- passes++;
- if (passes < 20)
- goto restart;
- else
- return 1;
- }
return error_level;
}
git://git.openafs.org / openafs.git / blobdiff