9067f086a23959b15f19f43c93087f740a782448
[openafs.git] / src / vlserver / vlutils.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14
15 #include <lock.h>
16 #include <rx/xdr.h>
17 #include <ubik.h>
18
19 #include "vlserver.h"
20 #include "vlserver_internal.h"
21
22 struct vlheader xheader;
23 extern int maxnservers;
24 extern afs_uint32 rd_HostAddress[MAXSERVERID + 1];
25 extern afs_uint32 wr_HostAddress[MAXSERVERID + 1];
26 struct extentaddr *rd_ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0 };
27 struct extentaddr *wr_ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0 };
28 struct vlheader rd_cheader;     /* kept in network byte order */
29 struct vlheader wr_cheader;
30 int vldbversion = 0;
31
32 static int index_OK(struct vl_ctx *ctx, afs_int32 blockindex);
33
34 #define ERROR_EXIT(code) do { \
35     error = (code); \
36     goto error_exit; \
37 } while (0)
38
39 /* Hashing algorithm based on the volume id; HASHSIZE must be prime */
40 afs_int32
41 IDHash(afs_int32 volumeid)
42 {
43     return ((abs(volumeid)) % HASHSIZE);
44 }
45
46
47 /* Hashing algorithm based on the volume name; name's size is implicit (64 chars) and if changed it should be reflected here. */
48 afs_int32
49 NameHash(char *volumename)
50 {
51     unsigned int hash;
52     int i;
53
54     hash = 0;
55     for (i = strlen(volumename), volumename += i - 1; i--; volumename--)
56         hash = (hash * 63) + (*((unsigned char *)volumename) - 63);
57     return (hash % HASHSIZE);
58 }
59
60
61 /* package up seek and write into one procedure for ease of use */
62 afs_int32
63 vlwrite(struct ubik_trans *trans, afs_int32 offset, void *buffer,
64         afs_int32 length)
65 {
66     afs_int32 errorcode;
67
68     if ((errorcode = ubik_Seek(trans, 0, offset)))
69         return errorcode;
70     return (ubik_Write(trans, buffer, length));
71 }
72
73
74 /* Package up seek and read into one procedure for ease of use */
75 afs_int32
76 vlread(struct ubik_trans *trans, afs_int32 offset, char *buffer,
77        afs_int32 length)
78 {
79     afs_int32 errorcode;
80
81     if ((errorcode = ubik_Seek(trans, 0, offset)))
82         return errorcode;
83     return (ubik_Read(trans, buffer, length));
84 }
85
86
87 /* take entry and convert to network order and write to disk */
88 afs_int32
89 vlentrywrite(struct ubik_trans *trans, afs_int32 offset, void *buffer,
90              afs_int32 length)
91 {
92     struct vlentry oentry;
93     struct nvlentry nentry, *nep;
94     char *bufp;
95     afs_int32 i;
96
97     if (length != sizeof(oentry))
98         return -1;
99     if (maxnservers == 13) {
100         nep = (struct nvlentry *)buffer;
101         for (i = 0; i < MAXTYPES; i++)
102             nentry.volumeId[i] = htonl(nep->volumeId[i]);
103         nentry.flags = htonl(nep->flags);
104         nentry.LockAfsId = htonl(nep->LockAfsId);
105         nentry.LockTimestamp = htonl(nep->LockTimestamp);
106         nentry.cloneId = htonl(nep->cloneId);
107         for (i = 0; i < MAXTYPES; i++)
108             nentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
109         nentry.nextNameHash = htonl(nep->nextNameHash);
110         memcpy(nentry.name, nep->name, VL_MAXNAMELEN);
111         memcpy(nentry.serverNumber, nep->serverNumber, NMAXNSERVERS);
112         memcpy(nentry.serverPartition, nep->serverPartition, NMAXNSERVERS);
113         memcpy(nentry.serverFlags, nep->serverFlags, NMAXNSERVERS);
114         bufp = (char *)&nentry;
115     } else {
116         memset(&oentry, 0, sizeof(struct vlentry));
117         nep = (struct nvlentry *)buffer;
118         for (i = 0; i < MAXTYPES; i++)
119             oentry.volumeId[i] = htonl(nep->volumeId[i]);
120         oentry.flags = htonl(nep->flags);
121         oentry.LockAfsId = htonl(nep->LockAfsId);
122         oentry.LockTimestamp = htonl(nep->LockTimestamp);
123         oentry.cloneId = htonl(nep->cloneId);
124         for (i = 0; i < MAXTYPES; i++)
125             oentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
126         oentry.nextNameHash = htonl(nep->nextNameHash);
127         memcpy(oentry.name, nep->name, VL_MAXNAMELEN);
128         memcpy(oentry.serverNumber, nep->serverNumber, OMAXNSERVERS);
129         memcpy(oentry.serverPartition, nep->serverPartition, OMAXNSERVERS);
130         memcpy(oentry.serverFlags, nep->serverFlags, OMAXNSERVERS);
131         bufp = (char *)&oentry;
132     }
133     return vlwrite(trans, offset, bufp, length);
134 }
135
136 /* read entry and convert to host order and write to disk */
137 afs_int32
138 vlentryread(struct ubik_trans *trans, afs_int32 offset, char *buffer,
139             afs_int32 length)
140 {
141     struct vlentry *oep, tentry;
142     struct nvlentry *nep, *nbufp;
143     char *bufp = (char *)&tentry;
144     afs_int32 i;
145
146     if (length != sizeof(vlentry))
147         return -1;
148     i = vlread(trans, offset, bufp, length);
149     if (i)
150         return i;
151     if (maxnservers == 13) {
152         nep = (struct nvlentry *)bufp;
153         nbufp = (struct nvlentry *)buffer;
154         for (i = 0; i < MAXTYPES; i++)
155             nbufp->volumeId[i] = ntohl(nep->volumeId[i]);
156         nbufp->flags = ntohl(nep->flags);
157         nbufp->LockAfsId = ntohl(nep->LockAfsId);
158         nbufp->LockTimestamp = ntohl(nep->LockTimestamp);
159         nbufp->cloneId = ntohl(nep->cloneId);
160         for (i = 0; i < MAXTYPES; i++)
161             nbufp->nextIdHash[i] = ntohl(nep->nextIdHash[i]);
162         nbufp->nextNameHash = ntohl(nep->nextNameHash);
163         memcpy(nbufp->name, nep->name, VL_MAXNAMELEN);
164         memcpy(nbufp->serverNumber, nep->serverNumber, NMAXNSERVERS);
165         memcpy(nbufp->serverPartition, nep->serverPartition, NMAXNSERVERS);
166         memcpy(nbufp->serverFlags, nep->serverFlags, NMAXNSERVERS);
167     } else {
168         oep = (struct vlentry *)bufp;
169         nbufp = (struct nvlentry *)buffer;
170         memset(nbufp, 0, sizeof(struct nvlentry));
171         for (i = 0; i < MAXTYPES; i++)
172             nbufp->volumeId[i] = ntohl(oep->volumeId[i]);
173         nbufp->flags = ntohl(oep->flags);
174         nbufp->LockAfsId = ntohl(oep->LockAfsId);
175         nbufp->LockTimestamp = ntohl(oep->LockTimestamp);
176         nbufp->cloneId = ntohl(oep->cloneId);
177         for (i = 0; i < MAXTYPES; i++)
178             nbufp->nextIdHash[i] = ntohl(oep->nextIdHash[i]);
179         nbufp->nextNameHash = ntohl(oep->nextNameHash);
180         memcpy(nbufp->name, oep->name, VL_MAXNAMELEN);
181         memcpy(nbufp->serverNumber, oep->serverNumber, OMAXNSERVERS);
182         memcpy(nbufp->serverPartition, oep->serverPartition, OMAXNSERVERS);
183         memcpy(nbufp->serverFlags, oep->serverFlags, OMAXNSERVERS);
184         /* initilize the last elements to BADSERVERID */
185         for (i = OMAXNSERVERS; i < NMAXNSERVERS; i++) {
186             nbufp->serverNumber[i] = BADSERVERID;
187             nbufp->serverPartition[i] = BADSERVERID;
188             nbufp->serverFlags[i] = BADSERVERID;
189         }
190     }
191     return 0;
192 }
193
194 /* Convenient write of small critical vldb header info to the database. */
195 int
196 write_vital_vlheader(struct vl_ctx *ctx)
197 {
198     if (vlwrite
199         (ctx->trans, 0, (char *)&ctx->cheader->vital_header, sizeof(vital_vlheader)))
200         return VL_IO;
201     return 0;
202 }
203
204
205 int extent_mod = 0;
206
207 /* This routine reads in the extent blocks for multi-homed servers.
208  * There used to be an initialization bug that would cause the contaddrs
209  * pointers in the first extent block to be bad. Here we will check the
210  * pointers and zero them in the in-memory copy if we find them bad. We
211  * also try to write the extent blocks back out. If we can't, then we
212  * will wait until the next write transaction to write them out
213  * (extent_mod tells us the on-disk copy is bad).
214  */
215 afs_int32
216 readExtents(struct ubik_trans *trans)
217 {
218     afs_uint32 extentAddr;
219     afs_int32 error = 0, code;
220     int i;
221
222     extent_mod = 0;
223     extentAddr = ntohl(rd_cheader.SIT);
224     if (!extentAddr)
225         return 0;
226
227     /* Read the first extension block */
228     if (!rd_ex_addr[0]) {
229         rd_ex_addr[0] = malloc(VL_ADDREXTBLK_SIZE);
230         if (!rd_ex_addr[0])
231             ERROR_EXIT(VL_NOMEM);
232     }
233     code = vlread(trans, extentAddr, (char *)rd_ex_addr[0], VL_ADDREXTBLK_SIZE);
234     if (code) {
235         free(rd_ex_addr[0]);    /* Not the place to create it */
236         rd_ex_addr[0] = 0;
237         ERROR_EXIT(VL_IO);
238     }
239
240     /* In case more that 64 mh servers are in use they're kept in these
241      * continuation blocks
242      */
243     for (i = 1; i < VL_MAX_ADDREXTBLKS; i++) {
244         if (!rd_ex_addr[0]->ex_contaddrs[i])
245             continue;
246
247         /* Before reading it in, check to see if the address is good */
248         if ((ntohl(rd_ex_addr[0]->ex_contaddrs[i]) <
249              ntohl(rd_ex_addr[0]->ex_contaddrs[i - 1]) + VL_ADDREXTBLK_SIZE)
250             || (ntohl(rd_ex_addr[0]->ex_contaddrs[i]) >
251                 ntohl(rd_cheader.vital_header.eofPtr) - VL_ADDREXTBLK_SIZE)) {
252             extent_mod = 1;
253             rd_ex_addr[0]->ex_contaddrs[i] = 0;
254             continue;
255         }
256
257
258         /* Read the continuation block */
259         if (!rd_ex_addr[i]) {
260             rd_ex_addr[i] = malloc(VL_ADDREXTBLK_SIZE);
261             if (!rd_ex_addr[i])
262                 ERROR_EXIT(VL_NOMEM);
263         }
264         code =
265             vlread(trans, ntohl(rd_ex_addr[0]->ex_contaddrs[i]),
266                    (char *)rd_ex_addr[i], VL_ADDREXTBLK_SIZE);
267         if (code) {
268             free(rd_ex_addr[i]);        /* Not the place to create it */
269             rd_ex_addr[i] = 0;
270             ERROR_EXIT(VL_IO);
271         }
272
273         /* After reading it in, check to see if its a real continuation block */
274         if (ntohl(rd_ex_addr[i]->ex_hdrflags) != VLCONTBLOCK) {
275             extent_mod = 1;
276             rd_ex_addr[0]->ex_contaddrs[i] = 0;
277             free(rd_ex_addr[i]);        /* Not the place to create it */
278             rd_ex_addr[i] = 0;
279             continue;
280         }
281     }
282
283     if (extent_mod) {
284         code = vlwrite(trans, extentAddr, rd_ex_addr[0], VL_ADDREXTBLK_SIZE);
285         if (!code) {
286             VLog(0, ("Multihome server support modification\n"));
287         }
288         /* Keep extent_mod true in-case the transaction aborts */
289         /* Don't return error so we don't abort transaction */
290     }
291
292   error_exit:
293     return error;
294 }
295
296 /* Check that the database has been initialized.  Be careful to fail in a safe
297    manner, to avoid bogusly reinitializing the db.  */
298 /**
299  * reads in db cache from ubik.
300  *
301  * @param[in] ut ubik transaction
302  * @param[in] rock  opaque pointer to an int*; if 1, we should rebuild the db
303  *                  if it appears empty, if 0 we should return an error if the
304  *                  db appears empty
305  *
306  * @return operation status
307  *   @retval 0 success
308  */
309 static afs_int32
310 UpdateCache(struct ubik_trans *trans, void *rock)
311 {
312     int *builddb_rock = rock;
313     int builddb = *builddb_rock;
314     afs_int32 error = 0, i, code, ubcode;
315
316     /* if version changed (or first call), read the header */
317     ubcode = vlread(trans, 0, (char *)&rd_cheader, sizeof(rd_cheader));
318     vldbversion = ntohl(rd_cheader.vital_header.vldbversion);
319
320     if (!ubcode && (vldbversion != 0)) {
321         memcpy(rd_HostAddress, rd_cheader.IpMappedAddr, sizeof(rd_cheader.IpMappedAddr));
322         for (i = 0; i < MAXSERVERID + 1; i++) { /* cvt HostAddress to host order */
323             rd_HostAddress[i] = ntohl(rd_HostAddress[i]);
324         }
325
326         code = readExtents(trans);
327         if (code)
328             ERROR_EXIT(code);
329     }
330
331     /* now, if can't read, or header is wrong, write a new header */
332     if (ubcode || vldbversion == 0) {
333         if (builddb) {
334             VLog(0, ("Can't read VLDB header, re-initialising...\n"));
335
336             /* try to write a good header */
337             /* The read cache will be sync'ed to this new header
338              * when the ubik transaction is ended by vlsynccache(). */
339             memset(&wr_cheader, 0, sizeof(wr_cheader));
340             wr_cheader.vital_header.vldbversion = htonl(VLDBVERSION);
341             wr_cheader.vital_header.headersize = htonl(sizeof(wr_cheader));
342             /* DANGER: Must get this from a master place!! */
343             wr_cheader.vital_header.MaxVolumeId = htonl(0x20000000);
344             wr_cheader.vital_header.eofPtr = htonl(sizeof(wr_cheader));
345             for (i = 0; i < MAXSERVERID + 1; i++) {
346                 wr_cheader.IpMappedAddr[i] = 0;
347                 wr_HostAddress[i] = 0;
348             }
349             code = vlwrite(trans, 0, (char *)&wr_cheader, sizeof(wr_cheader));
350             if (code) {
351                 VLog(0, ("Can't write VLDB header (error = %d)\n", code));
352                 ERROR_EXIT(VL_IO);
353             }
354             vldbversion = ntohl(wr_cheader.vital_header.vldbversion);
355         } else {
356             VLog(1, ("Unable to read VLDB header.\n"));
357             ERROR_EXIT(VL_EMPTY);
358         }
359     }
360
361     if ((vldbversion != VLDBVERSION) && (vldbversion != OVLDBVERSION)
362         && (vldbversion != VLDBVERSION_4)) {
363         VLog(0,
364             ("VLDB version %d doesn't match this software version(%d, %d or %d), quitting!\n",
365              vldbversion, VLDBVERSION_4, VLDBVERSION, OVLDBVERSION));
366         ERROR_EXIT(VL_BADVERSION);
367     }
368
369     maxnservers = ((vldbversion == 3 || vldbversion == 4) ? 13 : 8);
370
371   error_exit:
372     /* all done */
373     return error;
374 }
375
376 afs_int32
377 CheckInit(struct ubik_trans *trans, int builddb)
378 {
379     afs_int32 code;
380
381     code = ubik_CheckCache(trans, UpdateCache, &builddb);
382     if (code) {
383         return code;
384     }
385
386     /* these next two cases shouldn't happen (UpdateCache should either
387      * rebuild the db or return an error if these cases occur), but just to
388      * be on the safe side... */
389     if (vldbversion == 0) {
390         return VL_EMPTY;
391     }
392     if ((vldbversion != VLDBVERSION) && (vldbversion != OVLDBVERSION)
393         && (vldbversion != VLDBVERSION_4)) {
394         return VL_BADVERSION;
395     }
396
397     return 0;
398 }
399
400
401 afs_int32
402 GetExtentBlock(struct vl_ctx *ctx, afs_int32 base)
403 {
404     afs_int32 blockindex, code, error = 0;
405
406     /* Base 0 must exist before any other can be created */
407     if ((base != 0) && !ctx->ex_addr[0])
408         ERROR_EXIT(VL_CREATEFAIL);      /* internal error */
409
410     if (!ctx->ex_addr[0] || !ctx->ex_addr[0]->ex_contaddrs[base]) {
411         /* Create a new extension block */
412         if (!ctx->ex_addr[base]) {
413             ctx->ex_addr[base] = malloc(VL_ADDREXTBLK_SIZE);
414             if (!ctx->ex_addr[base])
415                 ERROR_EXIT(VL_NOMEM);
416         }
417         memset(ctx->ex_addr[base], 0, VL_ADDREXTBLK_SIZE);
418
419         /* Write the full extension block at end of vldb */
420         ctx->ex_addr[base]->ex_hdrflags = htonl(VLCONTBLOCK);
421         blockindex = ntohl(ctx->cheader->vital_header.eofPtr);
422         code =
423             vlwrite(ctx->trans, blockindex, (char *)ctx->ex_addr[base],
424                     VL_ADDREXTBLK_SIZE);
425         if (code)
426             ERROR_EXIT(VL_IO);
427
428         /* Update the cheader.vitalheader structure on disk */
429         ctx->cheader->vital_header.eofPtr = blockindex + VL_ADDREXTBLK_SIZE;
430         ctx->cheader->vital_header.eofPtr = htonl(ctx->cheader->vital_header.eofPtr);
431         code = write_vital_vlheader(ctx);
432         if (code)
433             ERROR_EXIT(VL_IO);
434
435         /* Write the address of the base extension block in the vldb header */
436         if (base == 0) {
437             ctx->cheader->SIT = htonl(blockindex);
438             code =
439                 vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->SIT),
440                         (char *)&ctx->cheader->SIT, sizeof(ctx->cheader->SIT));
441             if (code)
442                 ERROR_EXIT(VL_IO);
443         }
444
445         /* Write the address of this extension block into the base extension block */
446         ctx->ex_addr[0]->ex_contaddrs[base] = htonl(blockindex);
447         code =
448             vlwrite(ctx->trans, ntohl(ctx->cheader->SIT), ctx->ex_addr[0],
449                     sizeof(struct extentaddr));
450         if (code)
451             ERROR_EXIT(VL_IO);
452     }
453
454   error_exit:
455     return error;
456 }
457
458
459 afs_int32
460 FindExtentBlock(struct vl_ctx *ctx, afsUUID *uuidp,
461                 afs_int32 createit, afs_int32 hostslot,
462                 struct extentaddr **expp, afs_int32 *basep)
463 {
464     afsUUID tuuid;
465     struct extentaddr *exp;
466     afs_int32 i, j, code, base, index, error = 0;
467
468     *expp = NULL;
469     *basep = 0;
470
471     /* Create the first extension block if it does not exist */
472     if (!ctx->cheader->SIT) {
473         code = GetExtentBlock(ctx, 0);
474         if (code)
475             ERROR_EXIT(code);
476     }
477
478     for (i = 0; i < MAXSERVERID + 1; i++) {
479         if ((ctx->hostaddress[i] & 0xff000000) == 0xff000000) {
480             if ((base = (ctx->hostaddress[i] >> 16) & 0xff) > VL_MAX_ADDREXTBLKS) {
481                 ERROR_EXIT(VL_INDEXERANGE);
482             }
483             if ((index = ctx->hostaddress[i] & 0x0000ffff) > VL_MHSRV_PERBLK) {
484                 ERROR_EXIT(VL_INDEXERANGE);
485             }
486             exp = &ctx->ex_addr[base][index];
487             tuuid = exp->ex_hostuuid;
488             afs_ntohuuid(&tuuid);
489             if (afs_uuid_equal(uuidp, &tuuid)) {
490                 *expp = exp;
491                 *basep = base;
492                 ERROR_EXIT(0);
493             }
494         }
495     }
496
497     if (createit) {
498         if (hostslot == -1) {
499             for (i = 0; i < MAXSERVERID + 1; i++) {
500                 if (!ctx->hostaddress[i])
501                     break;
502             }
503             if (i > MAXSERVERID)
504                 ERROR_EXIT(VL_REPSFULL);
505         } else {
506             i = hostslot;
507         }
508
509         for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) {
510             if (!ctx->ex_addr[0]->ex_contaddrs[base]) {
511                 code = GetExtentBlock(ctx, base);
512                 if (code)
513                     ERROR_EXIT(code);
514             }
515             for (j = 1; j < VL_MHSRV_PERBLK; j++) {
516                 exp = &ctx->ex_addr[base][j];
517                 tuuid = exp->ex_hostuuid;
518                 afs_ntohuuid(&tuuid);
519                 if (afs_uuid_is_nil(&tuuid)) {
520                     tuuid = *uuidp;
521                     afs_htonuuid(&tuuid);
522                     exp->ex_hostuuid = tuuid;
523                     code =
524                         vlwrite(ctx->trans,
525                                 DOFFSET(ntohl(ctx->ex_addr[0]->ex_contaddrs[base]),
526                                         (char *)ctx->ex_addr[base], (char *)exp),
527                                 (char *)&tuuid, sizeof(tuuid));
528                     if (code)
529                         ERROR_EXIT(VL_IO);
530                     ctx->hostaddress[i] =
531                         0xff000000 | ((base << 16) & 0xff0000) | (j & 0xffff);
532                     *expp = exp;
533                     *basep = base;
534                     if (vldbversion != VLDBVERSION_4) {
535                         ctx->cheader->vital_header.vldbversion =
536                             htonl(VLDBVERSION_4);
537                         code = write_vital_vlheader(ctx);
538                         if (code)
539                             ERROR_EXIT(VL_IO);
540                     }
541                     ctx->cheader->IpMappedAddr[i] = htonl(ctx->hostaddress[i]);
542                     code =
543                         vlwrite(ctx->trans,
544                                 DOFFSET(0, ctx->cheader,
545                                         &ctx->cheader->IpMappedAddr[i]),
546                                 (char *)&ctx->cheader->IpMappedAddr[i],
547                                 sizeof(afs_int32));
548                     if (code)
549                         ERROR_EXIT(VL_IO);
550                     ERROR_EXIT(0);
551                 }
552             }
553         }
554         ERROR_EXIT(VL_REPSFULL);        /* No reason to utilize a new error code */
555     }
556
557   error_exit:
558     return error;
559 }
560
561 /* Allocate a free block of storage for entry, returning address of a new
562    zeroed entry (or zero if something is wrong).  */
563 afs_int32
564 AllocBlock(struct vl_ctx *ctx, struct nvlentry *tentry)
565 {
566     afs_int32 blockindex;
567
568     if (ctx->cheader->vital_header.freePtr) {
569         /* allocate this dude */
570         blockindex = ntohl(ctx->cheader->vital_header.freePtr);
571         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(vlentry)))
572             return 0;
573         ctx->cheader->vital_header.freePtr = htonl(tentry->nextIdHash[0]);
574     } else {
575         /* hosed, nothing on free list, grow file */
576         blockindex = ntohl(ctx->cheader->vital_header.eofPtr);  /* remember this guy */
577         ctx->cheader->vital_header.eofPtr = htonl(blockindex + sizeof(vlentry));
578     }
579     ctx->cheader->vital_header.allocs++;
580     if (write_vital_vlheader(ctx))
581         return 0;
582     memset(tentry, 0, sizeof(nvlentry));        /* zero new entry */
583     return blockindex;
584 }
585
586
587 /* Free a block given its index.  It must already have been unthreaded. Returns zero for success or an error code on failure. */
588 int
589 FreeBlock(struct vl_ctx *ctx, afs_int32 blockindex)
590 {
591     struct nvlentry tentry;
592
593     /* check validity of blockindex just to be on the safe side */
594     if (!index_OK(ctx, blockindex))
595         return VL_BADINDEX;
596     memset(&tentry, 0, sizeof(nvlentry));
597     tentry.nextIdHash[0] = ctx->cheader->vital_header.freePtr;  /* already in network order */
598     tentry.flags = htonl(VLFREE);
599     ctx->cheader->vital_header.freePtr = htonl(blockindex);
600     if (vlwrite(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
601         return VL_IO;
602     ctx->cheader->vital_header.frees++;
603     if (write_vital_vlheader(ctx))
604         return VL_IO;
605     return 0;
606 }
607
608
609 /* Look for a block by volid and voltype (if not known use -1 which searches
610  * all 3 volid hash lists. Note that the linked lists are read in first from
611  * the database header.  If found read the block's contents into the area
612  * pointed to by tentry and return the block's index.  If not found return 0.
613  */
614 afs_int32
615 FindByID(struct vl_ctx *ctx, afs_uint32 volid, afs_int32 voltype,
616          struct nvlentry *tentry, afs_int32 *error)
617 {
618     afs_int32 typeindex, hashindex, blockindex;
619
620     *error = 0;
621     hashindex = IDHash(volid);
622     if (voltype == -1) {
623 /* Should we have one big hash table for volids as opposed to the three ones? */
624         for (typeindex = 0; typeindex < MAXTYPES; typeindex++) {
625             for (blockindex = ntohl(ctx->cheader->VolidHash[typeindex][hashindex]);
626                  blockindex != NULLO;
627                  blockindex = tentry->nextIdHash[typeindex]) {
628                 if (vlentryread
629                     (ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
630                     *error = VL_IO;
631                     return 0;
632                 }
633                 if (volid == tentry->volumeId[typeindex])
634                     return blockindex;
635             }
636         }
637     } else {
638         for (blockindex = ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
639              blockindex != NULLO; blockindex = tentry->nextIdHash[voltype]) {
640             if (vlentryread
641                 (ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
642                 *error = VL_IO;
643                 return 0;
644             }
645             if (volid == tentry->volumeId[voltype])
646                 return blockindex;
647         }
648     }
649     return 0;                   /* no such entry */
650 }
651
652
653 /* Look for a block by volume name. If found read the block's contents into
654  * the area pointed to by tentry and return the block's index.  If not
655  * found return 0.
656  */
657 afs_int32
658 FindByName(struct vl_ctx *ctx, char *volname, struct nvlentry *tentry,
659            afs_int32 *error)
660 {
661     afs_int32 hashindex;
662     afs_int32 blockindex;
663     char tname[VL_MAXNAMELEN];
664
665     /* remove .backup or .readonly extensions for stupid backwards
666      * compatibility
667      */
668     hashindex = strlen(volname);        /* really string length */
669     if (hashindex >= 8 && strcmp(volname + hashindex - 7, ".backup") == 0) {
670         /* this is a backup volume */
671         strcpy(tname, volname);
672         tname[hashindex - 7] = 0;       /* zap extension */
673     } else if (hashindex >= 10
674                && strcmp(volname + hashindex - 9, ".readonly") == 0) {
675         /* this is a readonly volume */
676         strcpy(tname, volname);
677         tname[hashindex - 9] = 0;       /* zap extension */
678     } else
679         strcpy(tname, volname);
680
681     *error = 0;
682     hashindex = NameHash(tname);
683     for (blockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
684          blockindex != NULLO; blockindex = tentry->nextNameHash) {
685         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
686             *error = VL_IO;
687             return 0;
688         }
689         if (!strcmp(tname, tentry->name))
690             return blockindex;
691     }
692     return 0;                   /* no such entry */
693 }
694
695 /**
696  * Returns whether or not any of the supplied volume IDs already exist
697  * in the vldb.
698  *
699  * @param ctx      transaction context
700  * @param ids      an array of volume IDs
701  * @param ids_len  the number of elements in the 'ids' array
702  * @param error    filled in with an error code in case of error
703  *
704  * @return whether any of the volume IDs are already used
705  *  @retval 1  at least one of the volume IDs is already used
706  *  @retval 0  none of the volume IDs are used, or an error occurred
707  */
708 int
709 EntryIDExists(struct vl_ctx *ctx, const afs_uint32 *ids,
710               afs_int32 ids_len, afs_int32 *error)
711 {
712     afs_int32 typeindex;
713     struct nvlentry tentry;
714
715     *error = 0;
716
717     for (typeindex = 0; typeindex < ids_len; typeindex++) {
718         if (ids[typeindex]
719             && FindByID(ctx, ids[typeindex], -1, &tentry, error)) {
720
721             return 1;
722         } else if (*error) {
723             return 0;
724         }
725     }
726
727     return 0;
728 }
729
730 /**
731  * Finds the next range of unused volume IDs in the vldb.
732  *
733  * @param ctx       transaction context
734  * @param maxvolid  the current max vol ID, and where to start looking
735  *                  for an unused volume ID range
736  * @param bump      how many volume IDs we need to be unused
737  * @param error     filled in with an error code in case of error
738  *
739  * @return the next volume ID 'volid' such that the range
740  *         [volid, volid+bump) of volume IDs is unused, or 0 if there's
741  *         an error
742  */
743 afs_uint32
744 NextUnusedID(struct vl_ctx *ctx, afs_uint32 maxvolid, afs_uint32 bump,
745              afs_int32 *error)
746 {
747     struct nvlentry tentry;
748     afs_uint32 id;
749     afs_uint32 nfree;
750
751     *error = 0;
752
753      /* we simply start at the given maxvolid, keep a running tally of
754       * how many free volume IDs we've seen in a row, and return when
755       * we've seen 'bump' unused IDs in a row */
756     for (id = maxvolid, nfree = 0; nfree < bump; ++id) {
757         if (FindByID(ctx, id, -1, &tentry, error)) {
758             nfree = 0;
759         } else if (*error) {
760             return 0;
761         } else {
762             ++nfree;
763         }
764     }
765
766     /* 'id' is now at the end of the [maxvolid,maxvolid+bump) range,
767      * but we need to return the first unused id, so subtract the
768      * number of current running free IDs to get the beginning */
769     return id - nfree;
770 }
771
772 int
773 HashNDump(struct vl_ctx *ctx, int hashindex)
774 {
775     int i = 0;
776     int blockindex;
777     struct nvlentry tentry;
778
779     for (blockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
780          blockindex != NULLO; blockindex = tentry.nextNameHash) {
781         if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
782             return 0;
783         i++;
784         VLog(0,
785              ("[%d]#%d: %10d %d %d (%s)\n", hashindex, i, tentry.volumeId[0],
786               tentry.nextIdHash[0], tentry.nextNameHash, tentry.name));
787     }
788     return 0;
789 }
790
791
792 int
793 HashIdDump(struct vl_ctx *ctx, int hashindex)
794 {
795     int i = 0;
796     int blockindex;
797     struct nvlentry tentry;
798
799     for (blockindex = ntohl(ctx->cheader->VolidHash[0][hashindex]);
800          blockindex != NULLO; blockindex = tentry.nextIdHash[0]) {
801         if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
802             return 0;
803         i++;
804         VLog(0,
805              ("[%d]#%d: %10d %d %d (%s)\n", hashindex, i, tentry.volumeId[0],
806               tentry.nextIdHash[0], tentry.nextNameHash, tentry.name));
807     }
808     return 0;
809 }
810
811
812 /* Add a block to the hash table given a pointer to the block and its index.
813  * The block is threaded onto both hash tables and written to disk.  The
814  * routine returns zero if there were no errors.
815  */
816 int
817 ThreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
818               struct nvlentry *tentry)
819 {
820     int errorcode;
821
822     if (!index_OK(ctx, blockindex))
823         return VL_BADINDEX;
824     /* Insert into volid's hash linked list */
825     if ((errorcode = HashVolid(ctx, RWVOL, blockindex, tentry)))
826         return errorcode;
827
828     /* For rw entries we also enter the RO and BACK volume ids (if they
829      * exist) in the hash tables; note all there volids (RW, RO, BACK)
830      * should not be hashed yet! */
831     if (tentry->volumeId[ROVOL]) {
832         if ((errorcode = HashVolid(ctx, ROVOL, blockindex, tentry)))
833             return errorcode;
834     }
835     if (tentry->volumeId[BACKVOL]) {
836         if ((errorcode = HashVolid(ctx, BACKVOL, blockindex, tentry)))
837             return errorcode;
838     }
839
840     /* Insert into volname's hash linked list */
841     HashVolname(ctx, blockindex, tentry);
842
843     /* Update cheader entry */
844     if (write_vital_vlheader(ctx))
845         return VL_IO;
846
847     /* Update hash list pointers in the entry itself */
848     if (vlentrywrite(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry)))
849         return VL_IO;
850     return 0;
851 }
852
853
854 /* Remove a block from both the hash tables.  If success return 0, else
855  * return an error code. */
856 int
857 UnthreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
858                 struct nvlentry *aentry)
859 {
860     afs_int32 errorcode, typeindex;
861
862     if (!index_OK(ctx, blockindex))
863         return VL_BADINDEX;
864     if ((errorcode = UnhashVolid(ctx, RWVOL, blockindex, aentry)))
865         return errorcode;
866
867     /* Take the RO/RW entries of their respective hash linked lists. */
868     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
869         if ((errorcode = UnhashVolid(ctx, typeindex, blockindex, aentry)))
870             return errorcode;
871     }
872
873     /* Take it out of the Volname hash list */
874     if ((errorcode = UnhashVolname(ctx, blockindex, aentry)))
875         return errorcode;
876
877     /* Update cheader entry */
878     write_vital_vlheader(ctx);
879
880     return 0;
881 }
882
883 /* cheader must have be read before this routine is called. */
884 int
885 HashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
886           struct nvlentry *tentry)
887 {
888     afs_int32 hashindex, errorcode;
889     struct nvlentry ventry;
890
891     if (FindByID
892         (ctx, tentry->volumeId[voltype], voltype, &ventry, &errorcode))
893         return VL_IDALREADYHASHED;
894     else if (errorcode)
895         return errorcode;
896     hashindex = IDHash(tentry->volumeId[voltype]);
897     tentry->nextIdHash[voltype] =
898         ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
899     ctx->cheader->VolidHash[voltype][hashindex] = htonl(blockindex);
900     if (vlwrite
901         (ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolidHash[voltype][hashindex]),
902          (char *)&ctx->cheader->VolidHash[voltype][hashindex], sizeof(afs_int32)))
903         return VL_IO;
904     return 0;
905 }
906
907
908 /* cheader must have be read before this routine is called. */
909 int
910 UnhashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
911             struct nvlentry *aentry)
912 {
913     int hashindex, nextblockindex, prevblockindex;
914     struct nvlentry tentry;
915     afs_int32 code;
916     afs_int32 temp;
917
918     if (aentry->volumeId[voltype] == NULLO)     /* Assume no volume id */
919         return 0;
920     /* Take it out of the VolId[voltype] hash list */
921     hashindex = IDHash(aentry->volumeId[voltype]);
922     nextblockindex = ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
923     if (nextblockindex == blockindex) {
924         /* First on the hash list; just adjust pointers */
925         ctx->cheader->VolidHash[voltype][hashindex] =
926             htonl(aentry->nextIdHash[voltype]);
927         code =
928             vlwrite(ctx->trans,
929                     DOFFSET(0, ctx->cheader,
930                             &ctx->cheader->VolidHash[voltype][hashindex]),
931                     (char *)&ctx->cheader->VolidHash[voltype][hashindex],
932                     sizeof(afs_int32));
933         if (code)
934             return VL_IO;
935     } else {
936         while (nextblockindex != blockindex) {
937             prevblockindex = nextblockindex;    /* always done once */
938             if (vlentryread
939                 (ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
940                 return VL_IO;
941             if ((nextblockindex = tentry.nextIdHash[voltype]) == NULLO)
942                 return VL_NOENT;
943         }
944         temp = tentry.nextIdHash[voltype] = aentry->nextIdHash[voltype];
945         temp = htonl(temp);     /* convert to network byte order before writing */
946         if (vlwrite
947             (ctx->trans,
948              DOFFSET(prevblockindex, &tentry, &tentry.nextIdHash[voltype]),
949              (char *)&temp, sizeof(afs_int32)))
950             return VL_IO;
951     }
952     aentry->nextIdHash[voltype] = 0;
953     return 0;
954 }
955
956
957 int
958 HashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
959             struct nvlentry *aentry)
960 {
961     afs_int32 hashindex;
962     afs_int32 code;
963
964     /* Insert into volname's hash linked list */
965     hashindex = NameHash(aentry->name);
966     aentry->nextNameHash = ntohl(ctx->cheader->VolnameHash[hashindex]);
967     ctx->cheader->VolnameHash[hashindex] = htonl(blockindex);
968     code =
969         vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolnameHash[hashindex]),
970                 (char *)&ctx->cheader->VolnameHash[hashindex], sizeof(afs_int32));
971     if (code)
972         return VL_IO;
973     return 0;
974 }
975
976
977 int
978 UnhashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
979               struct nvlentry *aentry)
980 {
981     afs_int32 hashindex, nextblockindex, prevblockindex;
982     struct nvlentry tentry;
983     afs_int32 temp;
984
985     /* Take it out of the Volname hash list */
986     hashindex = NameHash(aentry->name);
987     nextblockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
988     if (nextblockindex == blockindex) {
989         /* First on the hash list; just adjust pointers */
990         ctx->cheader->VolnameHash[hashindex] = htonl(aentry->nextNameHash);
991         if (vlwrite
992             (ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolnameHash[hashindex]),
993              (char *)&ctx->cheader->VolnameHash[hashindex], sizeof(afs_int32)))
994             return VL_IO;
995     } else {
996         while (nextblockindex != blockindex) {
997             prevblockindex = nextblockindex;    /* always done at least once */
998             if (vlentryread
999                 (ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
1000                 return VL_IO;
1001             if ((nextblockindex = tentry.nextNameHash) == NULLO)
1002                 return VL_NOENT;
1003         }
1004         tentry.nextNameHash = aentry->nextNameHash;
1005         temp = htonl(tentry.nextNameHash);
1006         if (vlwrite
1007             (ctx->trans, DOFFSET(prevblockindex, &tentry, &tentry.nextNameHash),
1008              (char *)&temp, sizeof(afs_int32)))
1009             return VL_IO;
1010     }
1011     aentry->nextNameHash = 0;
1012     return 0;
1013 }
1014
1015
1016 /* Returns the vldb entry tentry at offset index; remaining is the number of
1017  * entries left; the routine also returns the index of the next sequential
1018  * entry in the vldb
1019  */
1020
1021 afs_int32
1022 NextEntry(struct vl_ctx *ctx, afs_int32 blockindex,
1023           struct nvlentry *tentry, afs_int32 *remaining)
1024 {
1025     afs_int32 lastblockindex;
1026
1027     if (blockindex == 0)        /* get first one */
1028         blockindex = sizeof(*ctx->cheader);
1029     else {
1030         if (!index_OK(ctx, blockindex)) {
1031             *remaining = -1;    /* error */
1032             return 0;
1033         }
1034         blockindex += sizeof(nvlentry);
1035     }
1036     /* now search for the first entry that isn't free */
1037     for (lastblockindex = ntohl(ctx->cheader->vital_header.eofPtr);
1038          blockindex < lastblockindex;) {
1039         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
1040             *remaining = -1;
1041             return 0;
1042         }
1043         if (tentry->flags == VLCONTBLOCK) {
1044             /*
1045              * This is a special mh extension block just simply skip over it
1046              */
1047             blockindex += VL_ADDREXTBLK_SIZE;
1048         } else {
1049             if (tentry->flags != VLFREE) {
1050                 /* estimate remaining number of entries, not including this one */
1051                 *remaining =
1052                     (lastblockindex - blockindex) / sizeof(nvlentry) - 1;
1053                 return blockindex;
1054             }
1055             blockindex += sizeof(nvlentry);
1056         }
1057     }
1058     *remaining = 0;             /* no more entries */
1059     return 0;
1060 }
1061
1062
1063 /* Routine to verify that index is a legal offset to a vldb entry in the
1064  * table
1065  */
1066 static int
1067 index_OK(struct vl_ctx *ctx, afs_int32 blockindex)
1068 {
1069     if ((blockindex < sizeof(*ctx->cheader))
1070         || (blockindex >= ntohl(ctx->cheader->vital_header.eofPtr)))
1071         return 0;
1072     return 1;
1073 }
1074
1075 /* makes a deep copy of src_ex into dst_ex */
1076 static int
1077 vlexcpy(struct extentaddr **dst_ex, struct extentaddr **src_ex)
1078 {
1079     int i;
1080     for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
1081         if (src_ex[i]) {
1082             if (!dst_ex[i]) {
1083                 dst_ex[i] = malloc(VL_ADDREXTBLK_SIZE);
1084             }
1085             if (!dst_ex[i]) {
1086                 return VL_NOMEM;
1087             }
1088             memcpy(dst_ex[i], src_ex[i], VL_ADDREXTBLK_SIZE);
1089
1090         } else if (dst_ex[i]) {
1091             /* we have no src, but we have a dst... meaning, this block
1092              * has gone away */
1093             free(dst_ex[i]);
1094             dst_ex[i] = NULL;
1095         }
1096     }
1097     return 0;
1098 }
1099
1100 int
1101 vlsetcache(struct vl_ctx *ctx, int locktype)
1102 {
1103     if (locktype == LOCKREAD) {
1104         ctx->hostaddress = rd_HostAddress;
1105         ctx->ex_addr = rd_ex_addr;
1106         ctx->cheader = &rd_cheader;
1107         return 0;
1108     } else {
1109         memcpy(wr_HostAddress, rd_HostAddress, sizeof(wr_HostAddress));
1110         memcpy(&wr_cheader, &rd_cheader, sizeof(wr_cheader));
1111
1112         ctx->hostaddress = wr_HostAddress;
1113         ctx->ex_addr = wr_ex_addr;
1114         ctx->cheader = &wr_cheader;
1115
1116         return vlexcpy(wr_ex_addr, rd_ex_addr);
1117     }
1118 }
1119
1120 int
1121 vlsynccache(void)
1122 {
1123     memcpy(rd_HostAddress, wr_HostAddress, sizeof(rd_HostAddress));
1124     memcpy(&rd_cheader, &wr_cheader, sizeof(rd_cheader));
1125     return vlexcpy(rd_ex_addr, wr_ex_addr);
1126 }