Bug Summary

File:vlserver/vlprocs.c
Location:line 3115, column 2
Description:Value stored to 'j' is never read

Annotated Source Code

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 <afs/afsutil.h>
17#include <ubik.h>
18#include <rx/xdr.h>
19#include <rx/rx.h>
20#include <rx/rxkad.h>
21#include <afs/keys.h>
22#include <afs/cellconfig.h>
23
24#include "vlserver.h"
25#include "vlserver_internal.h"
26#include "afs/audit.h"
27
28#ifdef HAVE_POSIX_REGEX1 /* use POSIX regexp library */
29#include <regex.h>
30#endif
31
32extern int smallMem;
33extern int extent_mod;
34extern struct afsconf_dir *vldb_confdir;
35extern struct ubik_dbase *VL_dbase;
36int maxnservers;
37#define ABORT(c)do { code = (c); goto abort; } while (0) do { \
38 code = (c); \
39 goto abort; \
40} while (0)
41#undef END
42#define END(c)do { code = (c); goto end; } while (0) do { \
43 code = (c); \
44 goto end; \
45} while (0)
46
47#define VLDBALLOCLIMIT10000 10000
48#define VLDBALLOCINCR2048 2048
49
50static int put_attributeentry(struct vl_ctx *ctx,
51 struct vldbentry **, struct vldbentry **,
52 struct vldbentry **, bulkentries *,
53 struct nvlentry *, afs_int32 *, afs_int32 *);
54static int put_nattributeentry(struct vl_ctx *ctx,
55 struct nvldbentry **, struct nvldbentry **,
56 struct nvldbentry **, nbulkentries *,
57 struct nvlentry *, afs_int32, afs_int32,
58 afs_int32 *, afs_int32 *);
59static int RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
60 struct nvlentry *tentry);
61static void ReleaseEntry(struct nvlentry *tentry, afs_int32 releasetype);
62static int check_vldbentry(struct vldbentry *aentry);
63static int check_nvldbentry(struct nvldbentry *aentry);
64static int vldbentry_to_vlentry(struct vl_ctx *ctx,
65 struct vldbentry *VldbEntry,
66 struct nvlentry *VlEntry);
67static int nvldbentry_to_vlentry(struct vl_ctx *ctx,
68 struct nvldbentry *VldbEntry,
69 struct nvlentry *VlEntry);
70static int get_vldbupdateentry(struct vl_ctx *ctx, afs_int32 blockindex,
71 struct VldbUpdateEntry *updateentry,
72 struct nvlentry *VlEntry);
73static int repsite_exists(struct nvlentry *VlEntry, int server, int partition);
74static void repsite_compress(struct nvlentry *VlEntry, int offset);
75static int vlentry_to_vldbentry(struct vl_ctx *ctx,
76 struct nvlentry *VlEntry,
77 struct vldbentry *VldbEntry);
78static int vlentry_to_nvldbentry(struct vl_ctx *ctx,
79 struct nvlentry *VlEntry,
80 struct nvldbentry *VldbEntry);
81static int vlentry_to_uvldbentry(struct vl_ctx *ctx,
82 struct nvlentry *VlEntry,
83 struct uvldbentry *VldbEntry);
84static int InvalidVolname(char *volname);
85static int InvalidVoltype(afs_int32 voltype);
86static int InvalidOperation(afs_int32 voloper);
87static int InvalidReleasetype(afs_int32 releasetype);
88static int IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create);
89static int ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1,
90 afs_uint32 ipaddr2);
91
92static_inlinestatic inline void
93countRequest(int opcode)
94{
95 if (opcode != 0) {
96 dynamic_statistics.requests[opcode - VL_LOWEST_OPCODE501]++;
97 }
98}
99
100static_inlinestatic inline void
101countAbort(int opcode)
102{
103 if (opcode != 0) {
104 dynamic_statistics.aborts[opcode - VL_LOWEST_OPCODE501]++;
105 }
106}
107
108
109static_inlinestatic inline int
110multiHomedExtentBase(struct vl_ctx *ctx, int srvidx, struct extentaddr **exp,
111 int *basePtr)
112{
113 int base;
114 int index;
115
116 *exp = NULL((void *)0);
117 *basePtr = 0;
118
119 if ((ctx->hostaddress[srvidx] & 0xff000000) == 0xff000000) {
120 base = (ctx->hostaddress[srvidx] >> 16) & 0xff;
121 index = ctx->hostaddress[srvidx] & 0x0000ffff;
122 if (base >= VL_MAX_ADDREXTBLKS4) {
123 VLog(0, ("Internal error: Multihome extent base is too large. "do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent base is too large. "
"Base %d index %d\n", base, index)); } while (0)
124 "Base %d index %d\n", base, index))do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent base is too large. "
"Base %d index %d\n", base, index)); } while (0);
125 return VL_IO(363521L);
126 }
127 if (index >= VL_MHSRV_PERBLK64) {
128 VLog(0, ("Internal error: Multihome extent index is too large. "do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent index is too large. "
"Base %d index %d\n", base, index)); } while (0)
129 "Base %d index %d\n", base, index))do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent index is too large. "
"Base %d index %d\n", base, index)); } while (0);
130 return VL_IO(363521L);
131 }
132 if (!ctx->ex_addr[base]) {
133 VLog(0, ("Internal error: Multihome extent does not exist. "do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent does not exist. "
"Base %d\n", base)); } while (0)
134 "Base %d\n", base))do { if ((0) <= LogLevel) (FSLog ("Internal error: Multihome extent does not exist. "
"Base %d\n", base)); } while (0);
135 return VL_IO(363521L);
136 }
137
138 *basePtr = base;
139 *exp = &ctx->ex_addr[base][index];
140 }
141
142 return 0;
143}
144
145static_inlinestatic inline int
146multiHomedExtent(struct vl_ctx *ctx, int srvidx, struct extentaddr **exp)
147{
148 int base;
149
150 return multiHomedExtentBase(ctx, srvidx, exp, &base);
151}
152
153#define AFS_RXINFO_LEN128 128
154static char *
155rxkadInfo(char *str, struct rx_connection *conn, struct in_addr hostAddr)
156{
157 int code;
158 char tname[64] = "";
159 char tinst[64] = "";
160 char tcell[64] = "";
161 afs_uint32 exp;
162
163 code = rxkad_GetServerInfo(conn, NULL((void *)0), &exp, tname, tinst, tcell,
164 NULL((void *)0));
165 if (!code)
166 snprintf(str, AFS_RXINFO_LEN128,
167 "%s rxkad:%s%s%s%s%s", inet_ntoa__inet_ntoa(hostAddr), tname,
168 (tinst[0] == '\0') ? "" : ".",
169 (tinst[0] == '\0') ? "" : tinst,
170 (tcell[0] == '\0') ? "" : "@",
171 (tcell[0] == '\0') ? "" : tcell);
172 else
173 snprintf(str, AFS_RXINFO_LEN128, "%s noauth", inet_ntoa__inet_ntoa(hostAddr));
174 return (str);
175}
176
177static char *
178rxinfo(char *str, struct rx_call *rxcall)
179{
180 struct rx_connection *conn;
181 struct in_addr hostAddr;
182 rx_securityIndex authClass;
183
184 conn = rx_ConnectionOf(rxcall)((rxcall)->conn);
185 authClass = rx_SecurityClassOf(conn)((conn)->securityIndex);
186 hostAddr.s_addr = rx_HostOf(rx_PeerOf(conn))((((conn)->peer))->host);
187
188 switch(authClass) {
189 case RX_SECIDX_KAD:
190 return rxkadInfo(str, conn, hostAddr);
191 default:
192 ;
193 }
194
195 snprintf(str, AFS_RXINFO_LEN128, "%s noauth", inet_ntoa__inet_ntoa(hostAddr));
196 return str;
197}
198
199
200/* This is called to initialize the database, set the appropriate locks and make sure that the vldb header is valid */
201int
202Init_VLdbase(struct vl_ctx *ctx,
203 int locktype, /* indicate read or write transaction */
204 int opcode)
205{
206 int code = 0, pass, wl;
207
208 for (pass = 1; pass <= 3; pass++) {
209 if (pass == 2) { /* take write lock to rebuild the db */
210 code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS1, &ctx->trans);
211 wl = 1;
212 } else if (locktype == LOCKREAD1) {
213 code =
214 ubik_BeginTransReadAnyWrite(VL_dbase, UBIK_READTRANS0, &ctx->trans);
215 wl = 0;
216 } else {
217 code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS1, &ctx->trans);
218 wl = 1;
219 }
220 if (code)
221 return code;
222
223 code = ubik_SetLock(ctx->trans, 1, 1, locktype);
224 if (code) {
225 countAbort(opcode);
226 ubik_AbortTrans(ctx->trans);
227 return code;
228 }
229
230 /* check that dbase is initialized and setup cheader */
231 /* 2nd pass we try to rebuild the header */
232 code = CheckInit(ctx->trans, ((pass == 2) ? 1 : 0));
233 if (!code && wl && extent_mod)
234 code = readExtents(ctx->trans); /* Fix the mh extent blocks */
235 if (code) {
236 countAbort(opcode);
237 ubik_AbortTrans(ctx->trans);
238 /* Only rebuld if the database is empty */
239 /* Exit if can't rebuild */
240 if ((pass == 1) && (code != VL_EMPTY(363525L)))
241 return code;
242 if (pass == 2)
243 return code;
244 } else { /* No code */
245 if (pass == 2) {
246 ubik_EndTrans(ctx->trans); /* Rebuilt db. End trans, then retake original lock */
247 } else {
248 break; /* didn't rebuild and successful - exit */
249 }
250 }
251 }
252 if (code == 0) {
253 code = vlsetcache(ctx, locktype);
254 }
255 return code;
256}
257
258
259/* Create a new vldb entry; both new volume id and name must be unique
260 * (non-existant in vldb).
261 */
262
263afs_int32
264SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
265{
266 int this_op = VLCREATEENTRY501;
267 struct vl_ctx ctx;
268 afs_int32 code, blockindex;
269 struct nvlentry tentry;
270 char rxstr[AFS_RXINFO_LEN128];
271
272 countRequest(this_op);
273 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0))) {
274 code = VL_PERM(363546L);
275 goto end;
276 }
277
278 /* Do some validity tests on new entry */
279 if ((code = check_vldbentry(newentry))
280 || (code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
281 goto end;
282
283 VLog(1,do { if ((1) <= LogLevel) (FSLog ("OCreate Volume %d %s\n"
, newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0)
284 ("OCreate Volume %d %s\n", newentry->volumeId[RWVOL],do { if ((1) <= LogLevel) (FSLog ("OCreate Volume %d %s\n"
, newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0)
285 rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("OCreate Volume %d %s\n"
, newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0);
286 if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES3, &code)) {
287 /* at least one of the specified IDs already exists; we fail */
288 code = VL_IDEXIST(363520L);
289 goto abort;
290 } else if (code) {
291 goto abort;
292 }
293
294 /* Is this following check (by volume name) necessary?? */
295 /* If entry already exists, we fail */
296 if (FindByName(&ctx, newentry->name, &tentry, &code)) {
297 code = VL_NAMEEXIST(363522L);
298 goto abort;
299 } else if (code) {
300 goto abort;
301 }
302
303 blockindex = AllocBlock(&ctx, &tentry);
304 if (blockindex == 0) {
305 code = VL_CREATEFAIL(363523L);
306 goto abort;
307 }
308
309 memset(&tentry, 0, sizeof(struct nvlentry));
310 /* Convert to its internal representation; both in host byte order */
311 if ((code = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
312 FreeBlock(&ctx, blockindex);
313 goto abort;
314 }
315
316 /* Actually insert the entry in vldb */
317 code = ThreadVLentry(&ctx, blockindex, &tentry);
318 if (code) {
319 FreeBlock(&ctx, blockindex);
320 goto abort;
321 } else {
322 code = ubik_EndTrans(ctx.trans);
323 goto end;
324 }
325
326 abort:
327 countAbort(this_op);
328 ubik_AbortTrans(ctx.trans);
329
330 end:
331 osi_auditU(rxcall, VLCreateEntryEvent"AFS_VL_CreEnt", code, AUD_STR1,
332 (newentry ? newentry->name : NULL((void *)0)), AUD_END0);
333 return code;
334}
335
336
337afs_int32
338SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
339{
340 int this_op = VLCREATEENTRYN517;
341 struct vl_ctx ctx;
342 afs_int32 code, blockindex;
343 struct nvlentry tentry;
344 char rxstr[AFS_RXINFO_LEN128];
345
346 countRequest(this_op);
347 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0))) {
348 code = VL_PERM(363546L);
349 goto end;
350 }
351
352 /* Do some validity tests on new entry */
353 if ((code = check_nvldbentry(newentry))
354 || (code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
355 goto end;
356
357 VLog(1,do { if ((1) <= LogLevel) (FSLog ("Create Volume %d %s\n",
newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0)
358 ("Create Volume %d %s\n", newentry->volumeId[RWVOL],do { if ((1) <= LogLevel) (FSLog ("Create Volume %d %s\n",
newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0)
359 rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("Create Volume %d %s\n",
newentry->volumeId[0], rxinfo(rxstr, rxcall))); } while (
0);
360 if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES3, &code)) {
361 /* at least one of the specified IDs already exists; we fail */
362 code = VL_IDEXIST(363520L);
363 goto abort;
364 } else if (code) {
365 goto abort;
366 }
367
368 /* Is this following check (by volume name) necessary?? */
369 /* If entry already exists, we fail */
370 if (FindByName(&ctx, newentry->name, &tentry, &code)) {
371 code = VL_NAMEEXIST(363522L);
372 goto abort;
373 } else if (code) {
374 goto abort;
375 }
376
377 blockindex = AllocBlock(&ctx, &tentry);
378 if (blockindex == 0) {
379 code = VL_CREATEFAIL(363523L);
380 goto abort;
381 }
382
383 memset(&tentry, 0, sizeof(struct nvlentry));
384 /* Convert to its internal representation; both in host byte order */
385 if ((code = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
386 FreeBlock(&ctx, blockindex);
387 goto abort;
388 }
389
390 /* Actually insert the entry in vldb */
391 code = ThreadVLentry(&ctx, blockindex, &tentry);
392 if (code) {
393 FreeBlock(&ctx, blockindex);
394 goto abort;
395 } else {
396 code = ubik_EndTrans(ctx.trans);
397 goto end;
398 }
399
400 abort:
401 countAbort(this_op);
402 ubik_AbortTrans(ctx.trans);
403
404 end:
405 osi_auditU(rxcall, VLCreateEntryEvent"AFS_VL_CreEnt", code, AUD_STR1,
406 (newentry ? newentry->name : NULL((void *)0)), AUD_END0);
407 return code;
408}
409
410
411afs_int32
412SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
413{
414 int this_op = VLCHANGEADDR516;
415 struct vl_ctx ctx;
416 afs_int32 code;
417 char rxstr[AFS_RXINFO_LEN128];
418
419 countRequest(this_op);
420 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0))) {
421 code = VL_PERM(363546L);
422 goto end;
423 }
424
425 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
426 goto end;
427
428 VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("Change Addr %u -> %u %s\n"
, ip1, ip2, rxinfo(rxstr, rxcall))); } while (0);
429 if ((code = ChangeIPAddr(&ctx, ip1, ip2)))
430 goto abort;
431 else {
432 code = ubik_EndTrans(ctx.trans);
433 goto end;
434 }
435
436 abort:
437 countAbort(this_op);
438 ubik_AbortTrans(ctx.trans);
439
440 end:
441 osi_auditU(rxcall, VLChangeAddrEvent"AFS_VL_ChgAdd", code, AUD_LONG5, ip1, AUD_LONG5,
442 ip2, AUD_END0);
443 return code;
444}
445
446/* Delete a vldb entry given the volume id. */
447afs_int32
448SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
449{
450 int this_op = VLDELETEENTRY502;
451 struct vl_ctx ctx;
452 afs_int32 blockindex, code;
453 struct nvlentry tentry;
454 char rxstr[AFS_RXINFO_LEN128];
455
456 countRequest(this_op);
457 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
458 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
459
460 if ((voltype != -1) && (InvalidVoltype(voltype)))
461 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
462
463 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
464 goto end;
465
466 VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("Delete Volume %u %s\n",
volid, rxinfo(rxstr, rxcall))); } while (0);
467 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
468 if (blockindex == 0) { /* volid not found */
469 if (!code)
470 code = VL_NOENT(363524L);
471 goto abort;
472 }
473
474 if (tentry.flags & VLDELETED2) { /* Already deleted; return */
475 ABORT(VL_ENTDELETED)do { code = ((363526L)); goto abort; } while (0);
476 }
477 if ((code = RemoveEntry(&ctx, blockindex, &tentry))) {
478 goto abort;
479 }
480 code = (ubik_EndTrans(ctx.trans));
481 goto end;
482
483 abort:
484 countAbort(this_op);
485 ubik_AbortTrans(ctx.trans);
486
487 end:
488 osi_auditU(rxcall, VLDeleteEntryEvent"AFS_VL_DelEnt", code, AUD_LONG5, volid,
489 AUD_END0);
490 return code;
491}
492
493
494/* Get a vldb entry given its volume id; make sure it's not a deleted entry. */
495int
496GetEntryByID(struct rx_call *rxcall,
497 afs_uint32 volid,
498 afs_int32 voltype,
499 char *aentry, /* entry data copied here */
500 afs_int32 new,
501 afs_int32 this_op)
502{
503 struct vl_ctx ctx;
504 afs_int32 blockindex, code;
505 struct nvlentry tentry;
506 char rxstr[AFS_RXINFO_LEN128];
507
508 countRequest(this_op);
509
510 if ((voltype != -1) && (InvalidVoltype(voltype)))
511 return VL_BADVOLTYPE(363529L);
512 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
513 return code;
514
515 VLog(5, ("GetVolumeByID %u (%d) %s\n", volid, new,do { if ((5) <= LogLevel) (FSLog ("GetVolumeByID %u (%d) %s\n"
, volid, new, rxinfo(rxstr, rxcall))); } while (0)
516 rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("GetVolumeByID %u (%d) %s\n"
, volid, new, rxinfo(rxstr, rxcall))); } while (0);
517 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
518 if (blockindex == 0) { /* entry not found */
519 if (!code)
520 code = VL_NOENT(363524L);
521 goto abort;
522 }
523 if (tentry.flags & VLDELETED2) { /* Entry is deleted! */
524 code = VL_ENTDELETED(363526L);
525 goto abort;
526 }
527 /* Convert from the internal to external form */
528 if (new == 1)
529 code = vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
530 else if (new == 2)
531 code = vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
532 else
533 code = vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
534
535 if (code)
536 goto abort;
537
538 return (ubik_EndTrans(ctx.trans));
539
540abort:
541 countAbort(this_op);
542 ubik_AbortTrans(ctx.trans);
543 return code;
544}
545
546afs_int32
547SVL_GetEntryByID(struct rx_call *rxcall,
548 afs_uint32 volid,
549 afs_int32 voltype,
550 vldbentry *aentry) /* entry data copied here */
551{
552 return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 0,
553 VLGETENTRYBYID503));
554}
555
556afs_int32
557SVL_GetEntryByIDN(struct rx_call *rxcall,
558 afs_uint32 volid,
559 afs_int32 voltype,
560 nvldbentry *aentry) /* entry data copied here */
561{
562 return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 1,
563 VLGETENTRYBYIDN518));
564}
565
566afs_int32
567SVL_GetEntryByIDU(struct rx_call *rxcall,
568 afs_uint32 volid,
569 afs_int32 voltype,
570 uvldbentry *aentry) /* entry data copied here */
571{
572 return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 2,
573 VLGETENTRYBYIDU526));
574}
575
576/* returns true if the id is a decimal integer, in which case we interpret
577 * it as an id. make the cache manager much simpler */
578static int
579NameIsId(char *aname)
580{
581 int tc;
582 while ((tc = *aname++)) {
583 if (tc > '9' || tc < '0')
584 return 0;
585 }
586 return 1;
587}
588
589/* Get a vldb entry given the volume's name; of course, very similar to
590 * VLGetEntryByID() above. */
591afs_int32
592GetEntryByName(struct rx_call *rxcall,
593 char *volname,
594 char *aentry, /* entry data copied here */
595 int new,
596 int this_op)
597{
598 struct vl_ctx ctx;
599 afs_int32 blockindex, code;
600 struct nvlentry tentry;
601 char rxstr[AFS_RXINFO_LEN128];
602
603 if (NameIsId(volname)) {
604 return GetEntryByID(rxcall, atoi(volname), -1, aentry, new, this_op);
605 }
606 if (InvalidVolname(volname))
607 return VL_BADNAME(363527L);
608 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
609 return code;
610 VLog(5, ("GetVolumeByName %s (%d) %s\n", volname, new, rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("GetVolumeByName %s (%d) %s\n"
, volname, new, rxinfo(rxstr, rxcall))); } while (0);
611 blockindex = FindByName(&ctx, volname, &tentry, &code);
612 if (blockindex == 0) { /* entry not found */
613 if (!code)
614 code = VL_NOENT(363524L);
615 goto abort;
616 }
617 if (tentry.flags & VLDELETED2) { /* Entry is deleted */
618 code = VL_ENTDELETED(363526L);
619 goto abort;
620 }
621 /* Convert to external entry representation */
622 if (new == 1)
623 code = vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
624 else if (new == 2)
625 code = vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
626 else
627 code = vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
628
629 if (code)
630 goto abort;
631
632 return (ubik_EndTrans(ctx.trans));
633
634abort:
635 countAbort(this_op);
636 ubik_AbortTrans(ctx.trans);
637 return code;
638
639}
640
641afs_int32
642SVL_GetEntryByNameO(struct rx_call *rxcall,
643 char *volname,
644 struct vldbentry *aentry) /* entry data copied here */
645{
646 return (GetEntryByName(rxcall, volname, (char *)aentry, 0,
647 VLGETENTRYBYNAME504));
648}
649
650
651afs_int32
652SVL_GetEntryByNameN(struct rx_call *rxcall,
653 char *volname,
654 struct nvldbentry *aentry) /* entry data copied here */
655{
656 return (GetEntryByName(rxcall, volname, (char *)aentry, 1,
657 VLGETENTRYBYNAMEN519));
658}
659
660afs_int32
661SVL_GetEntryByNameU(struct rx_call *rxcall,
662 char *volname,
663 struct uvldbentry *aentry) /* entry data copied here */
664{
665 return (GetEntryByName(rxcall, volname, (char *)aentry, 2,
666 VLGETENTRYBYNAMEU527));
667}
668
669
670
671/* Get the current value of the maximum volume id and bump the volume id counter by Maxvolidbump. */
672afs_int32
673SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
674 afs_uint32 *newvolumeid)
675{
676 int this_op = VLGETNEWVOLUMEID505;
677 afs_int32 code;
678 afs_uint32 maxvolumeid;
679 struct vl_ctx ctx;
680 char rxstr[AFS_RXINFO_LEN128];
681
682 countRequest(this_op);
683 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
684 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
685
686 if (Maxvolidbump < 0 || Maxvolidbump > MAXBUMPCOUNT0x7fffffff)
687 END(VL_BADVOLIDBUMP)do { code = ((363539L)); goto end; } while (0);
688
689 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
690 goto end;
691
692 *newvolumeid = maxvolumeid = NextUnusedID(&ctx,
693 ntohl(ctx.cheader->vital_header.MaxVolumeId)(__builtin_constant_p(ctx.cheader->vital_header.MaxVolumeId
) ? ((((__uint32_t)(ctx.cheader->vital_header.MaxVolumeId)
) >> 24) | ((((__uint32_t)(ctx.cheader->vital_header
.MaxVolumeId)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ctx.cheader->vital_header.MaxVolumeId)) & (0xff <<
8)) << 8) | (((__uint32_t)(ctx.cheader->vital_header
.MaxVolumeId)) << 24)) : __bswap32_var(ctx.cheader->
vital_header.MaxVolumeId)), Maxvolidbump, &code);
694 if (code) {
695 goto abort;
696 }
697
698 maxvolumeid += Maxvolidbump;
699 VLog(1, ("GetNewVolid newmax=%u %s\n", maxvolumeid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("GetNewVolid newmax=%u %s\n"
, maxvolumeid, rxinfo(rxstr, rxcall))); } while (0);
700 ctx.cheader->vital_header.MaxVolumeId = htonl(maxvolumeid)(__builtin_constant_p(maxvolumeid) ? ((((__uint32_t)(maxvolumeid
)) >> 24) | ((((__uint32_t)(maxvolumeid)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(maxvolumeid)) & (0xff
<< 8)) << 8) | (((__uint32_t)(maxvolumeid)) <<
24)) : __bswap32_var(maxvolumeid));
701 if (write_vital_vlheader(&ctx)) {
702 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
703 }
704 code = (ubik_EndTrans(ctx.trans));
705 goto end;
706
707 abort:
708 countAbort(this_op);
709 ubik_AbortTrans(ctx.trans);
710
711 end:
712 osi_auditU(rxcall, VLGetNewVolumeIdEvent"AFS_VL_GetNVlID", code, AUD_END0);
713 return code;
714}
715
716
717/* Simple replace the contents of the vldb entry, volid, with
718 * newentry. No individual checking/updating per field (alike
719 * VLUpdateEntry) is done. */
720
721afs_int32
722SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
723 struct vldbentry *newentry, afs_int32 releasetype)
724{
725 int this_op = VLREPLACEENTRY506;
726 struct vl_ctx ctx;
727 afs_int32 blockindex, code, typeindex;
728 int hashnewname;
729 int hashVol[MAXTYPES3];
730 struct nvlentry tentry;
731 afs_uint32 checkids[MAXTYPES3];
732 char rxstr[AFS_RXINFO_LEN128];
733
734 countRequest(this_op);
735 for (typeindex = 0; typeindex < MAXTYPES3; typeindex++)
736 hashVol[typeindex] = 0;
737 hashnewname = 0;
738 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
739 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
740
741 if ((code = check_vldbentry(newentry)))
742 goto end;
743
744 if (voltype != -1 && InvalidVoltype(voltype))
745 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
746
747 if (releasetype && InvalidReleasetype(releasetype))
748 END(VL_BADRELLOCKTYPE)do { code = ((363543L)); goto end; } while (0);
749 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
750 goto end;
751
752 VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("OReplace Volume %u %s\n"
, volid, rxinfo(rxstr, rxcall))); } while (0);
753 /* find vlentry we're changing */
754 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
755 if (blockindex == 0) { /* entry not found */
756 if (!code)
757 code = VL_NOENT(363524L);
758 goto abort;
759 }
760
761 /* check that we're not trying to change the RW vol ID */
762 if (newentry->volumeId[RWVOL0] != tentry.volumeId[RWVOL0]) {
763 ABORT(VL_BADENTRY)do { code = ((363538L)); goto abort; } while (0);
764 }
765
766 /* make sure none of the IDs we are changing to are already in use */
767 memset(&checkids, 0, sizeof(checkids));
768 for (typeindex = ROVOL1; typeindex < MAXTYPES3; typeindex++) {
769 if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
770 checkids[typeindex] = newentry->volumeId[typeindex];
771 }
772 }
773 if (EntryIDExists(&ctx, checkids, MAXTYPES3, &code)) {
774 ABORT(VL_IDEXIST)do { code = ((363520L)); goto abort; } while (0);
775 } else if (code) {
776 goto abort;
777 }
778
779 /* make sure the name we're changing to doesn't already exist */
780 if (strcmp(newentry->name, tentry.name)) {
781 struct nvlentry tmp_entry;
782 if (FindByName(&ctx, newentry->name, &tmp_entry, &code)) {
783 ABORT(VL_NAMEEXIST)do { code = ((363522L)); goto abort; } while (0);
784 } else if (code) {
785 goto abort;
786 }
787 }
788
789 /* unhash volid entries if they're disappearing or changing.
790 * Remember if we need to hash in the new value (we don't have to
791 * rehash if volid stays same */
792 for (typeindex = ROVOL1; typeindex <= BACKVOL2; typeindex++) {
793 if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
794 if (tentry.volumeId[typeindex])
795 if ((code =
796 UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
797 goto abort;
798 }
799 /* we must rehash new id if the id is different and the ID is nonzero */
800 hashVol[typeindex] = 1; /* must rehash this guy if he exists */
801 }
802 }
803
804 /* Rehash volname if it changes */
805 if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */
806 if ((code = UnhashVolname(&ctx, blockindex, &tentry))) {
807 goto abort;
808 }
809 hashnewname = 1;
810 }
811
812 /* after this, tentry is new entry, not old one. vldbentry_to_vlentry
813 * doesn't touch hash chains */
814 if ((code = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
815 goto abort;
816 }
817
818 for (typeindex = ROVOL1; typeindex <= BACKVOL2; typeindex++) {
819 if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
820 if ((code = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
821 goto abort;
822 }
823 }
824 }
825
826 if (hashnewname)
827 HashVolname(&ctx, blockindex, &tentry);
828
829 if (releasetype)
830 ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
831 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
832 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
833 }
834
835 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
836
837 abort:
838 countAbort(this_op);
839 ubik_AbortTrans(ctx.trans);
840
841 end:
842 osi_auditU(rxcall, VLReplaceVLEntryEvent"AFS_VL_RepEnt", code, AUD_LONG5, volid,
843 AUD_END0);
844 return code;
845}
846
847afs_int32
848SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
849 struct nvldbentry *newentry, afs_int32 releasetype)
850{
851 int this_op = VLREPLACEENTRYN520;
852 struct vl_ctx ctx;
853 afs_int32 blockindex, code, typeindex;
854 int hashnewname;
855 int hashVol[MAXTYPES3];
856 struct nvlentry tentry;
857 char rxstr[AFS_RXINFO_LEN128];
858
859 countRequest(this_op);
860 for (typeindex = 0; typeindex < MAXTYPES3; typeindex++)
861 hashVol[typeindex] = 0;
862 hashnewname = 0;
863 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
864 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
865
866 if ((code = check_nvldbentry(newentry)))
867 goto end;
868
869 if (voltype != -1 && InvalidVoltype(voltype))
870 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
871
872 if (releasetype && InvalidReleasetype(releasetype))
873 END(VL_BADRELLOCKTYPE)do { code = ((363543L)); goto end; } while (0);
874 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
875 goto end;
876
877 VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("Replace Volume %u %s\n"
, volid, rxinfo(rxstr, rxcall))); } while (0);
878 /* find vlentry we're changing */
879 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
880 if (blockindex == 0) { /* entry not found */
881 if (!code)
882 code = VL_NOENT(363524L);
883 goto abort;
884 }
885
886 /* check that we're not trying to change the RW vol ID */
887 if (newentry->volumeId[RWVOL0] != tentry.volumeId[RWVOL0]) {
888 ABORT(VL_BADENTRY)do { code = ((363538L)); goto abort; } while (0);
889 }
890
891 /* unhash volid entries if they're disappearing or changing.
892 * Remember if we need to hash in the new value (we don't have to
893 * rehash if volid stays same */
894 for (typeindex = ROVOL1; typeindex <= BACKVOL2; typeindex++) {
895 if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
896 if (tentry.volumeId[typeindex])
897 if ((code =
898 UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
899 goto abort;
900 }
901 /* we must rehash new id if the id is different and the ID is nonzero */
902 hashVol[typeindex] = 1; /* must rehash this guy if he exists */
903 }
904 }
905
906 /* Rehash volname if it changes */
907 if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */
908 if ((code = UnhashVolname(&ctx, blockindex, &tentry))) {
909 goto abort;
910 }
911 hashnewname = 1;
912 }
913
914 /* after this, tentry is new entry, not old one. vldbentry_to_vlentry
915 * doesn't touch hash chains */
916 if ((code = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
917 goto abort;
918 }
919
920 for (typeindex = ROVOL1; typeindex <= BACKVOL2; typeindex++) {
921 if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
922 if ((code = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
923 goto abort;
924 }
925 }
926 }
927
928 if (hashnewname)
929 HashVolname(&ctx, blockindex, &tentry);
930
931 if (releasetype)
932 ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
933 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
934 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
935 }
936
937 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
938
939 abort:
940 countAbort(this_op);
941 ubik_AbortTrans(ctx.trans);
942
943 end:
944 osi_auditU(rxcall, VLReplaceVLEntryEvent"AFS_VL_RepEnt", code, AUD_LONG5, volid,
945 AUD_END0);
946 return code;
947}
948
949
950/* Update a vldb entry (accessed thru its volume id). Almost all of the
951 * entry's fields can be modified in a single call by setting the
952 * appropriate bits in the Mask field in VldbUpdateentry. */
953/* this routine may never have been tested; use replace entry instead
954 * unless you're brave */
955afs_int32
956SVL_UpdateEntry(struct rx_call *rxcall,
957 afs_uint32 volid,
958 afs_int32 voltype,
959 struct VldbUpdateEntry *updateentry, /* Update entry copied here */
960 afs_int32 releasetype)
961{
962 int this_op = VLUPDATEENTRY507;
963 struct vl_ctx ctx;
964 afs_int32 blockindex, code;
965 struct nvlentry tentry;
966 char rxstr[AFS_RXINFO_LEN128];
967
968 countRequest(this_op);
969 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
970 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
971 if ((voltype != -1) && (InvalidVoltype(voltype)))
972 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
973 if (releasetype && InvalidReleasetype(releasetype))
974 END(VL_BADRELLOCKTYPE)do { code = ((363543L)); goto end; } while (0);
975 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
976 goto end;
977
978 VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("Update Volume %u %s\n",
volid, rxinfo(rxstr, rxcall))); } while (0);
979 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
980 if (blockindex == 0) { /* entry not found */
981 if (!code)
982 code = VL_NOENT(363524L);
983 goto abort;
984 }
985
986 /* Do the actual updating of the entry, tentry. */
987 if ((code =
988 get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
989 goto abort;
990 }
991 if (releasetype)
992 ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
993 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
994 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
995 }
996 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
997
998 abort:
999 countAbort(this_op);
1000 ubik_AbortTrans(ctx.trans);
1001
1002 end:
1003 osi_auditU(rxcall, VLUpdateEntryEvent"AFS_VL_UpdEnt", code, AUD_LONG5, volid,
1004 AUD_END0);
1005 return code;
1006}
1007
1008
1009afs_int32
1010SVL_UpdateEntryByName(struct rx_call *rxcall,
1011 char *volname,
1012 struct VldbUpdateEntry *updateentry, /* Update entry copied here */
1013 afs_int32 releasetype)
1014{
1015 int this_op = VLUPDATEENTRYBYNAME524;
1016 struct vl_ctx ctx;
1017 afs_int32 blockindex, code;
1018 struct nvlentry tentry;
1019
1020 countRequest(this_op);
1021 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
1022 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
1023 if (releasetype && InvalidReleasetype(releasetype))
1024 END(VL_BADRELLOCKTYPE)do { code = ((363543L)); goto end; } while (0);
1025 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
1026 goto end;
1027
1028 blockindex = FindByName(&ctx, volname, &tentry, &code);
1029 if (blockindex == 0) { /* entry not found */
1030 if (!code)
1031 code = VL_NOENT(363524L);
1032 goto abort;
1033 }
1034
1035 /* Do the actual updating of the entry, tentry. */
1036 if ((code =
1037 get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
1038 goto abort;
1039 }
1040 if (releasetype)
1041 ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
1042 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1043 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
1044 }
1045 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
1046
1047 abort:
1048 countAbort(this_op);
1049 ubik_AbortTrans(ctx.trans);
1050
1051 end:
1052 osi_auditU(rxcall, VLUpdateEntryEvent"AFS_VL_UpdEnt", code, AUD_LONG5, -1, AUD_END0);
1053 return code;
1054}
1055
1056
1057/* Set a lock to the vldb entry for volid (of type voltype if not -1). */
1058afs_int32
1059SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
1060 afs_int32 voloper)
1061{
1062 int this_op = VLSETLOCK508;
1063 afs_int32 timestamp, blockindex, code;
1064 struct vl_ctx ctx;
1065 struct nvlentry tentry;
1066 char rxstr[AFS_RXINFO_LEN128];
1067
1068 countRequest(this_op);
1069 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
1070 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
1071 if ((voltype != -1) && (InvalidVoltype(voltype)))
1072 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
1073 if (InvalidOperation(voloper))
1074 END(VL_BADVOLOPER)do { code = ((363542L)); goto end; } while (0);
1075 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
1076 goto end;
1077
1078 VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("SetLock Volume %u %s\n"
, volid, rxinfo(rxstr, rxcall))); } while (0);
1079 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
1080 if (blockindex == NULLO0) {
1081 if (!code)
1082 code = VL_NOENT(363524L);
1083 goto abort;
1084 }
1085 if (tentry.flags & VLDELETED2) {
1086 ABORT(VL_ENTDELETED)do { code = ((363526L)); goto abort; } while (0);
1087 }
1088 timestamp = FT_ApproxTime();
1089
1090 /* Check if entry is already locked; note that we unlock any entry
1091 * locked more than MAXLOCKTIME seconds */
1092 if ((tentry.LockTimestamp)
1093 && ((timestamp - tentry.LockTimestamp) < MAXLOCKTIME0x7fffffff)) {
1094 ABORT(VL_ENTRYLOCKED)do { code = ((363541L)); goto abort; } while (0);
1095 }
1096
1097 /* Consider it an unlocked entry: set current timestamp, caller
1098 * and active vol operation */
1099 tentry.LockTimestamp = timestamp;
1100 tentry.LockAfsId = 0; /* Not implemented yet */
1101 if (tentry.flags & VLOP_RELEASE0x20) {
1102 ABORT(VL_RERELEASE)do { code = ((363544L)); goto abort; } while (0);
1103 }
1104 tentry.flags &= ~VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100); /* Clear any possible older operation bit */
1105 tentry.flags |= voloper;
1106
1107 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1108 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
1109 }
1110 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
1111
1112 abort:
1113 countAbort(this_op);
1114 ubik_AbortTrans(ctx.trans);
1115
1116 end:
1117 osi_auditU(rxcall, VLSetLockEvent"AFS_VL_SetLck", code, AUD_LONG5, volid, AUD_END0);
1118 return code;
1119}
1120
1121
1122/* Release an already locked vldb entry. Releasetype determines what
1123 * fields (afsid and/or volume operation) will be cleared along with
1124 * the lock time stamp. */
1125
1126afs_int32
1127SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
1128 afs_int32 releasetype)
1129{
1130 int this_op = VLRELEASELOCK509;
1131 afs_int32 blockindex, code;
1132 struct vl_ctx ctx;
1133 struct nvlentry tentry;
1134 char rxstr[AFS_RXINFO_LEN128];
1135
1136 countRequest(this_op);
1137 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
1138 END(VL_PERM)do { code = ((363546L)); goto end; } while (0);
1139 if ((voltype != -1) && (InvalidVoltype(voltype)))
1140 END(VL_BADVOLTYPE)do { code = ((363529L)); goto end; } while (0);
1141 if (releasetype && InvalidReleasetype(releasetype))
1142 END(VL_BADRELLOCKTYPE)do { code = ((363543L)); goto end; } while (0);
1143 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
1144 goto end;
1145
1146 VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)))do { if ((1) <= LogLevel) (FSLog ("ReleaseLock Volume %u %s\n"
, volid, rxinfo(rxstr, rxcall))); } while (0);
1147 blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
1148 if (blockindex == NULLO0) {
1149 if (!code)
1150 code = VL_NOENT(363524L);
1151 goto abort;
1152 }
1153 if (tentry.flags & VLDELETED2) {
1154 ABORT(VL_ENTDELETED)do { code = ((363526L)); goto abort; } while (0);
1155 }
1156 if (releasetype)
1157 ReleaseEntry(&tentry, releasetype); /* Unlock the appropriate fields */
1158 if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1159 ABORT(VL_IO)do { code = ((363521L)); goto abort; } while (0);
1160 }
1161 END(ubik_EndTrans(ctx.trans))do { code = (ubik_EndTrans(ctx.trans)); goto end; } while (0);
1162
1163 abort:
1164 countAbort(this_op);
1165 ubik_AbortTrans(ctx.trans);
1166
1167 end:
1168 osi_auditU(rxcall, VLReleaseLockEvent"AFS_VL_RelLck", code, AUD_LONG5, volid,
1169 AUD_END0);
1170 return code;
1171}
1172
1173
1174/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
1175 * the remaining parameters (i.e. next_index) are used so that sequential
1176 * calls to this routine will get the next (all) vldb entries.
1177 */
1178afs_int32
1179SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
1180 afs_int32 *count, afs_int32 *next_index,
1181 struct vldbentry *aentry)
1182{
1183 int this_op = VLLISTENTRY510;
1184 int code;
1185 struct vl_ctx ctx;
1186 struct nvlentry tentry;
1187 char rxstr[AFS_RXINFO_LEN128];
1188
1189 countRequest(this_op);
1190 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1191 return code;
1192 VLog(25, ("OListEntry index=%d %s\n", previous_index,do { if ((25) <= LogLevel) (FSLog ("OListEntry index=%d %s\n"
, previous_index, rxinfo(rxstr, rxcall))); } while (0)
1193 rxinfo(rxstr, rxcall)))do { if ((25) <= LogLevel) (FSLog ("OListEntry index=%d %s\n"
, previous_index, rxinfo(rxstr, rxcall))); } while (0);
1194 *next_index = NextEntry(&ctx, previous_index, &tentry, count);
1195 if (*next_index) {
1196 code = vlentry_to_vldbentry(&ctx, &tentry, aentry);
1197 if (code) {
1198 countAbort(this_op);
1199 ubik_AbortTrans(ctx.trans);
1200 return code;
1201 }
1202 }
1203 return (ubik_EndTrans(ctx.trans));
1204}
1205
1206/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
1207 * the remaining parameters (i.e. next_index) are used so that sequential
1208 * calls to this routine will get the next (all) vldb entries.
1209 */
1210afs_int32
1211SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
1212 afs_int32 *count, afs_int32 *next_index,
1213 struct nvldbentry *aentry)
1214{
1215 int this_op = VLLISTENTRYN521;
1216 int code;
1217 struct vl_ctx ctx;
1218 struct nvlentry tentry;
1219 char rxstr[AFS_RXINFO_LEN128];
1220
1221 countRequest(this_op);
1222 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1223 return code;
1224 VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxstr, rxcall)))do { if ((25) <= LogLevel) (FSLog ("ListEntry index=%d %s\n"
, previous_index, rxinfo(rxstr, rxcall))); } while (0);
1225 *next_index = NextEntry(&ctx, previous_index, &tentry, count);
1226 if (*next_index) {
1227 code = vlentry_to_nvldbentry(&ctx, &tentry, aentry);
1228 if (code) {
1229 countAbort(this_op);
1230 ubik_AbortTrans(ctx.trans);
1231 return code;
1232 }
1233 }
1234
1235 return (ubik_EndTrans(ctx.trans));
1236}
1237
1238
1239/* Retrieves in vldbentries all vldb entries that match the specified
1240 * attributes (by server number, partition, volume type, and flag); if volume
1241 * id is specified then the associated list for that entry is returned.
1242 * CAUTION: This could be a very expensive call since in most cases
1243 * sequential search of all vldb entries is performed.
1244 */
1245afs_int32
1246SVL_ListAttributes(struct rx_call *rxcall,
1247 struct VldbListByAttributes *attributes,
1248 afs_int32 *nentries,
1249 bulkentries *vldbentries)
1250{
1251 int this_op = VLLISTATTRIBUTES511;
1252 int code, allocCount = 0;
1253 struct vl_ctx ctx;
1254 struct nvlentry tentry;
1255 struct vldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1256 int pollcount = 0;
1257 char rxstr[AFS_RXINFO_LEN128];
1258
1259 countRequest(this_op);
1260 vldbentries->bulkentries_val = 0;
1261 vldbentries->bulkentries_len = *nentries = 0;
1262 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1263 return code;
1264 allocCount = VLDBALLOCCOUNT500;
1265 Vldbentry = VldbentryFirst = vldbentries->bulkentries_val =
1266 (vldbentry *) malloc(allocCount * sizeof(vldbentry));
1267 if (Vldbentry == NULL((void *)0)) {
1268 code = VL_NOMEM(363547L);
1269 goto abort;
1270 }
1271 VldbentryLast = VldbentryFirst + allocCount;
1272 /* Handle the attribute by volume id totally separate of the rest
1273 * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */
1274 if (attributes->Mask & VLLIST_VOLUMEID0x8) {
1275 afs_int32 blockindex;
1276
1277 blockindex =
1278 FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1279 if (blockindex == 0) {
1280 if (!code)
1281 code = VL_NOENT(363524L);
1282 goto abort;
1283 }
1284
1285 code = put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1286 &VldbentryLast, vldbentries, &tentry,
1287 nentries, &allocCount);
1288 if (code)
1289 goto abort;
1290 } else {
1291 afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
1292 while ((nextblockindex =
1293 NextEntry(&ctx, nextblockindex, &tentry, &count))) {
1294 if (++pollcount > 50) {
1295#ifndef AFS_PTHREAD_ENV
1296 IOMGR_Poll();
1297#endif
1298 pollcount = 0;
1299 }
1300 match = 0;
1301 if (attributes->Mask & VLLIST_SERVER0x1) {
1302 int serverindex;
1303 if ((serverindex =
1304 IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
1305 continue;
1306 for (k = 0; k < OMAXNSERVERS8; k++) {
1307 if (tentry.serverNumber[k] == BADSERVERID255)
1308 break;
1309 if (tentry.serverNumber[k] == serverindex) {
1310 match = 1;
1311 break;
1312 }
1313 }
1314 if (!match)
1315 continue;
1316 }
1317 if (attributes->Mask & VLLIST_PARTITION0x2) {
1318 if (match) {
1319 if (tentry.serverPartition[k] != attributes->partition)
1320 continue;
1321 } else {
1322 for (k = 0; k < OMAXNSERVERS8; k++) {
1323 if (tentry.serverNumber[k] == BADSERVERID255)
1324 break;
1325 if (tentry.serverPartition[k] ==
1326 attributes->partition) {
1327 match = 1;
1328 break;
1329 }
1330 }
1331 if (!match)
1332 continue;
1333 }
1334 }
1335
1336 if (attributes->Mask & VLLIST_FLAG0x10) {
1337 if (!(tentry.flags & attributes->flag))
1338 continue;
1339 }
1340 code = put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1341 &VldbentryLast, vldbentries, &tentry,
1342 nentries, &allocCount);
1343 if (code)
1344 goto abort;
1345 }
1346 }
1347 if (vldbentries->bulkentries_len
1348 && (allocCount > vldbentries->bulkentries_len)) {
1349
1350 vldbentries->bulkentries_val =
1351 (vldbentry *) realloc(vldbentries->bulkentries_val,
1352 vldbentries->bulkentries_len *
1353 sizeof(vldbentry));
1354 if (vldbentries->bulkentries_val == NULL((void *)0)) {
1355 code = VL_NOMEM(363547L);
1356 goto abort;
1357 }
1358 }
1359 VLog(5,do { if ((5) <= LogLevel) (FSLog ("ListAttrs nentries=%d %s\n"
, vldbentries->bulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1360 ("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len,do { if ((5) <= LogLevel) (FSLog ("ListAttrs nentries=%d %s\n"
, vldbentries->bulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1361 rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("ListAttrs nentries=%d %s\n"
, vldbentries->bulkentries_len, rxinfo(rxstr, rxcall))); }
while (0);
1362 return (ubik_EndTrans(ctx.trans));
1363
1364abort:
1365 if (vldbentries->bulkentries_val)
1366 free(vldbentries->bulkentries_val);
1367 vldbentries->bulkentries_val = 0;
1368 vldbentries->bulkentries_len = 0;
1369
1370 countAbort(this_op);
1371 ubik_AbortTrans(ctx.trans);
1372
1373 return code;
1374}
1375
1376afs_int32
1377SVL_ListAttributesN(struct rx_call *rxcall,
1378 struct VldbListByAttributes *attributes,
1379 afs_int32 *nentries,
1380 nbulkentries *vldbentries)
1381{
1382 int this_op = VLLISTATTRIBUTESN522;
1383 int code, allocCount = 0;
1384 struct vl_ctx ctx;
1385 struct nvlentry tentry;
1386 struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1387 int pollcount = 0;
1388 char rxstr[AFS_RXINFO_LEN128];
1389
1390 countRequest(this_op);
1391 vldbentries->nbulkentries_val = 0;
1392 vldbentries->nbulkentries_len = *nentries = 0;
1393 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1394 return code;
1395 allocCount = VLDBALLOCCOUNT500;
1396 Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
1397 (nvldbentry *) malloc(allocCount * sizeof(nvldbentry));
1398 if (Vldbentry == NULL((void *)0)) {
1399 code = VL_NOMEM(363547L);
1400 goto abort;
1401 }
1402 VldbentryLast = VldbentryFirst + allocCount;
1403 /* Handle the attribute by volume id totally separate of the rest
1404 * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */
1405 if (attributes->Mask & VLLIST_VOLUMEID0x8) {
1406 afs_int32 blockindex;
1407
1408 blockindex =
1409 FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1410 if (blockindex == 0) {
1411 if (!code)
1412 code = VL_NOENT(363524L);
1413 goto abort;
1414 }
1415
1416 code = put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1417 &VldbentryLast, vldbentries, &tentry,
1418 0, 0, nentries, &allocCount);
1419 if (code)
1420 goto abort;
1421 } else {
1422 afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
1423 while ((nextblockindex =
1424 NextEntry(&ctx, nextblockindex, &tentry, &count))) {
1425 if (++pollcount > 50) {
1426#ifndef AFS_PTHREAD_ENV
1427 IOMGR_Poll();
1428#endif
1429 pollcount = 0;
1430 }
1431
1432 match = 0;
1433 if (attributes->Mask & VLLIST_SERVER0x1) {
1434 int serverindex;
1435 if ((serverindex =
1436 IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
1437 continue;
1438 for (k = 0; k < NMAXNSERVERS13; k++) {
1439 if (tentry.serverNumber[k] == BADSERVERID255)
1440 break;
1441 if (tentry.serverNumber[k] == serverindex) {
1442 match = 1;
1443 break;
1444 }
1445 }
1446 if (!match)
1447 continue;
1448 }
1449 if (attributes->Mask & VLLIST_PARTITION0x2) {
1450 if (match) {
1451 if (tentry.serverPartition[k] != attributes->partition)
1452 continue;
1453 } else {
1454 for (k = 0; k < NMAXNSERVERS13; k++) {
1455 if (tentry.serverNumber[k] == BADSERVERID255)
1456 break;
1457 if (tentry.serverPartition[k] ==
1458 attributes->partition) {
1459 match = 1;
1460 break;
1461 }
1462 }
1463 if (!match)
1464 continue;
1465 }
1466 }
1467
1468 if (attributes->Mask & VLLIST_FLAG0x10) {
1469 if (!(tentry.flags & attributes->flag))
1470 continue;
1471 }
1472 code = put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1473 &VldbentryLast, vldbentries,
1474 &tentry, 0, 0, nentries, &allocCount);
1475 if (code)
1476 goto abort;
1477 }
1478 }
1479 if (vldbentries->nbulkentries_len
1480 && (allocCount > vldbentries->nbulkentries_len)) {
1481
1482 vldbentries->nbulkentries_val =
1483 (nvldbentry *) realloc(vldbentries->nbulkentries_val,
1484 vldbentries->nbulkentries_len *
1485 sizeof(nvldbentry));
1486 if (vldbentries->nbulkentries_val == NULL((void *)0)) {
1487 code = VL_NOMEM(363547L);
1488 goto abort;
1489 }
1490 }
1491 VLog(5,do { if ((5) <= LogLevel) (FSLog ("NListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1492 ("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,do { if ((5) <= LogLevel) (FSLog ("NListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1493 rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("NListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0);
1494 return (ubik_EndTrans(ctx.trans));
1495
1496abort:
1497 countAbort(this_op);
1498 ubik_AbortTrans(ctx.trans);
1499 if (vldbentries->nbulkentries_val)
1500 free(vldbentries->nbulkentries_val);
1501 vldbentries->nbulkentries_val = 0;
1502 vldbentries->nbulkentries_len = 0;
1503 return code;
1504}
1505
1506
1507afs_int32
1508SVL_ListAttributesN2(struct rx_call *rxcall,
1509 struct VldbListByAttributes *attributes,
1510 char *name, /* Wildcarded volume name */
1511 afs_int32 startindex,
1512 afs_int32 *nentries,
1513 nbulkentries *vldbentries,
1514 afs_int32 *nextstartindex)
1515{
1516 int this_op = VLLISTATTRIBUTESN2534;
1517 int code = 0, maxCount = VLDBALLOCCOUNT500;
1518 struct vl_ctx ctx;
1519 struct nvlentry tentry;
1520 struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1521 afs_int32 blockindex = 0, count = 0, k, match;
1522 afs_int32 matchindex = 0;
1523 int serverindex = -1; /* no server found */
1524 int findserver = 0, findpartition = 0, findflag = 0, findname = 0;
1525 int pollcount = 0;
1526 int namematchRWBK, namematchRO, thismatch;
1527 int matchtype = 0;
1528 char volumename[VL_MAXNAMELEN65+2]; /* regex anchors */
1529 char rxstr[AFS_RXINFO_LEN128];
1530#ifdef HAVE_POSIX_REGEX1
1531 regex_t re;
1532 int need_regfree = 0;
1533#else
1534 char *t;
1535#endif
1536
1537 countRequest(this_op);
1538 vldbentries->nbulkentries_val = 0;
1539 vldbentries->nbulkentries_len = 0;
1540 *nentries = 0;
1541 *nextstartindex = -1;
1542
1543 code = Init_VLdbase(&ctx, LOCKREAD1, this_op);
1544 if (code)
1545 return code;
1546
1547 Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
1548 (nvldbentry *) malloc(maxCount * sizeof(nvldbentry));
1549 if (Vldbentry == NULL((void *)0)) {
1550 countAbort(this_op);
1551 ubik_AbortTrans(ctx.trans);
1552 return VL_NOMEM(363547L);
1553 }
1554
1555 VldbentryLast = VldbentryFirst + maxCount;
1556
1557 /* Handle the attribute by volume id totally separate of the rest
1558 * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!)
1559 */
1560 if (attributes->Mask & VLLIST_VOLUMEID0x8) {
1561 blockindex =
1562 FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1563 if (blockindex == 0) {
1564 if (!code)
1565 code = VL_NOENT(363524L);
1566 } else {
1567 code =
1568 put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1569 &VldbentryLast, vldbentries, &tentry, 0,
1570 0, nentries, &maxCount);
1571 if (code)
1572 goto done;
1573 }
1574 }
1575
1576 /* Search each entry in the database and return all entries
1577 * that match the request. It checks volumename (with
1578 * wildcarding), entry flags, server, and partition.
1579 */
1580 else {
1581 /* Get the server index for matching server address */
1582 if (attributes->Mask & VLLIST_SERVER0x1) {
1583 serverindex =
1584 IpAddrToRelAddr(&ctx, attributes->server, 0);
1585 if (serverindex == -1)
1586 goto done;
1587 findserver = 1;
1588 }
1589 findpartition = ((attributes->Mask & VLLIST_PARTITION0x2) ? 1 : 0);
1590 findflag = ((attributes->Mask & VLLIST_FLAG0x10) ? 1 : 0);
1591 if (name && (strcmp(name, ".*") != 0) && (strcmp(name, "") != 0)) {
1592 sprintf(volumename, "^%s$", name);
1593#ifdef HAVE_POSIX_REGEX1
1594 if (regcomp(&re, volumename, REG_NOSUB0004) != 0) {
1595 code = VL_BADNAME(363527L);
1596 goto done;
1597 }
1598 need_regfree = 1;
1599#else
1600 t = (char *)re_comp(volumename);
1601 if (t) {
1602 code = VL_BADNAME(363527L);
1603 goto done;
1604 }
1605#endif
1606 findname = 1;
1607 }
1608
1609 /* Read each entry and see if it is the one we want */
1610 blockindex = startindex;
1611 while ((blockindex = NextEntry(&ctx, blockindex, &tentry, &count))) {
1612 if (++pollcount > 50) {
1613#ifndef AFS_PTHREAD_ENV
1614 IOMGR_Poll();
1615#endif
1616 pollcount = 0;
1617 }
1618
1619 /* Step through each server index searching for a match.
1620 * Match to an existing RW, BK, or RO volume name (preference
1621 * is in this order). Remember which index we matched against.
1622 */
1623 namematchRWBK = namematchRO = 0; /* 0->notTried; 1->match; 2->noMatch */
1624 match = 0;
1625 for (k = 0;
1626 (k < NMAXNSERVERS13
1627 && (tentry.serverNumber[k] != BADSERVERID255)); k++) {
1628 thismatch = 0; /* does this index match */
1629
1630 /* Match against the RW or BK volume name. Remember
1631 * results in namematchRWBK. Prefer RW over BK.
1632 */
1633 if (tentry.serverFlags[k] & VLSF_RWVOL0x04) {
1634 /* Does the name match the RW name */
1635 if (tentry.flags & VLF_RWEXISTS0x1000) {
1636 if (findname) {
1637 sprintf(volumename, "%s", tentry.name);
1638#ifdef HAVE_POSIX_REGEX1
1639 if (regexec(&re, volumename, 0, NULL((void *)0), 0) == 0) {
1640 thismatch = VLSF_RWVOL0x04;
1641 }
1642#else
1643 if (re_exec(volumename)) {
1644 thismatch = VLSF_RWVOL0x04;
1645 }
1646#endif
1647 } else {
1648 thismatch = VLSF_RWVOL0x04;
1649 }
1650 }
1651
1652 /* Does the name match the BK name */
1653 if (!thismatch && (tentry.flags & VLF_BACKEXISTS0x4000)) {
1654 if (findname) {
1655 sprintf(volumename, "%s.backup", tentry.name);
1656#ifdef HAVE_POSIX_REGEX1
1657 if (regexec(&re, volumename, 0, NULL((void *)0), 0) == 0) {
1658 thismatch = VLSF_BACKVOL0x08;
1659 }
1660#else
1661 if (re_exec(volumename)) {
1662 thismatch = VLSF_BACKVOL0x08;
1663 }
1664#endif
1665 } else {
1666 thismatch = VLSF_BACKVOL0x08;
1667 }
1668 }
1669
1670 namematchRWBK = (thismatch ? 1 : 2);
1671 }
1672
1673 /* Match with the RO volume name. Compare once and
1674 * remember results in namematchRO. Note that this will
1675 * pick up entries marked NEWREPSITEs and DONTUSE.
1676 */
1677 else {
1678 if (tentry.flags & VLF_ROEXISTS0x2000) {
1679 if (findname) {
1680 if (namematchRO) {
1681 thismatch =
1682 ((namematchRO == 1) ? VLSF_ROVOL0x02 : 0);
1683 } else {
1684 sprintf(volumename, "%s.readonly",
1685 tentry.name);
1686#ifdef HAVE_POSIX_REGEX1
1687 if (regexec(&re, volumename, 0, NULL((void *)0), 0) == 0) {
1688 thismatch = VLSF_ROVOL0x02;
1689 }
1690#else
1691 if (re_exec(volumename))
1692 thismatch = VLSF_ROVOL0x02;
1693#endif
1694 }
1695 } else {
1696 thismatch = VLSF_ROVOL0x02;
1697 }
1698 }
1699 namematchRO = (thismatch ? 1 : 2);
1700 }
1701
1702 /* Is there a server match */
1703 if (thismatch && findserver
1704 && (tentry.serverNumber[k] != serverindex))
1705 thismatch = 0;
1706
1707 /* Is there a partition match */
1708 if (thismatch && findpartition
1709 && (tentry.serverPartition[k] != attributes->partition))
1710 thismatch = 0;
1711
1712 /* Is there a flag match */
1713 if (thismatch && findflag
1714 && !(tentry.flags & attributes->flag))
1715 thismatch = 0;
1716
1717 /* We found a match. Remember the index, and type */
1718 if (thismatch) {
1719 match = 1;
1720 matchindex = k;
1721 matchtype = thismatch;
1722 }
1723
1724 /* Since we prefer RW and BK volume matches over RO matches,
1725 * if we have already checked the RWBK name, then we already
1726 * found the best match and so end the search.
1727 *
1728 * If we tried matching against the RW, BK, and RO volume names
1729 * and both failed, then we end the search (none will match).
1730 */
1731 if ((match && namematchRWBK)
1732 || ((namematchRWBK == 2) && (namematchRO == 2)))
1733 break;
1734 }
1735
1736 /* Passed all the tests. Take it */
1737 if (match) {
1738 code =
1739 put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1740 &VldbentryLast, vldbentries, &tentry,
1741 matchtype, matchindex, nentries,
1742 &maxCount);
1743 if (code)
1744 goto done;
1745
1746 if (*nentries >= maxCount)
1747 break; /* collected the max */
1748 }
1749 }
1750 *nextstartindex = (blockindex ? blockindex : -1);
1751 }
1752
1753 done:
1754#ifdef HAVE_POSIX_REGEX1
1755 if (need_regfree)
1756 regfree(&re);
1757#endif
1758
1759 if (code) {
1760 countAbort(this_op);
1761 ubik_AbortTrans(ctx.trans);
1762 if (vldbentries->nbulkentries_val)
1763 free((char *)vldbentries->nbulkentries_val);
1764 vldbentries->nbulkentries_val = 0;
1765 vldbentries->nbulkentries_len = 0;
1766 *nextstartindex = -1;
1767 return code;
1768 } else {
1769 VLog(5,do { if ((5) <= LogLevel) (FSLog ("N2ListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1770 ("N2ListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,do { if ((5) <= LogLevel) (FSLog ("N2ListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0)
1771 rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("N2ListAttrs nentries=%d %s\n"
, vldbentries->nbulkentries_len, rxinfo(rxstr, rxcall))); }
while (0);
1772 return (ubik_EndTrans(ctx.trans));
1773 }
1774}
1775
1776
1777/* Retrieves in vldbentries all vldb entries that match the specified
1778 * attributes (by server number, partition, volume type, and flag); if
1779 * volume id is specified then the associated list for that entry is
1780 * returned. CAUTION: This could be a very expensive call since in most
1781 * cases sequential search of all vldb entries is performed.
1782 */
1783afs_int32
1784SVL_LinkedList(struct rx_call *rxcall,
1785 struct VldbListByAttributes *attributes,
1786 afs_int32 *nentries,
1787 vldb_list *vldbentries)
1788{
1789 int this_op = VLLINKEDLIST512;
1790 int code;
1791 struct vl_ctx ctx;
1792 struct nvlentry tentry;
1793 vldblist vllist, *vllistptr;
1794 afs_int32 blockindex, count, match;
1795 afs_int32 k = 0;
1796 int serverindex;
1797 int pollcount = 0;
1798
1799 countRequest(this_op);
1800 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1801 return code;
1802
1803 *nentries = 0;
1804 vldbentries->node = NULL((void *)0);
1805 vllistptr = &vldbentries->node;
1806
1807 /* List by volumeid */
1808 if (attributes->Mask & VLLIST_VOLUMEID0x8) {
1809 blockindex =
1810 FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1811 if (!blockindex) {
1812 if (!code)
1813 code = VL_NOENT(363524L);
1814 goto abort;
1815 }
1816
1817 vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
1818 if (vllist == NULL((void *)0)) {
1819 code = VL_NOMEM(363547L);
1820 goto abort;
1821 }
1822 code = vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
1823 if (code)
1824 goto abort;
1825
1826 vllist->next_vldb = NULL((void *)0);
1827
1828 *vllistptr = vllist; /* Thread onto list */
1829 vllistptr = &vllist->next_vldb;
1830 (*nentries)++;
1831 }
1832
1833 /* Search by server, partition, and flags */
1834 else {
1835 for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
1836 blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
1837 match = 0;
1838
1839 if (++pollcount > 50) {
1840#ifndef AFS_PTHREAD_ENV
1841 IOMGR_Poll();
1842#endif
1843 pollcount = 0;
1844 }
1845
1846 /* Does this volume exist on the desired server */
1847 if (attributes->Mask & VLLIST_SERVER0x1) {
1848 serverindex =
1849 IpAddrToRelAddr(&ctx, attributes->server, 0);
1850 if (serverindex == -1)
1851 continue;
1852 for (k = 0; k < OMAXNSERVERS8; k++) {
1853 if (tentry.serverNumber[k] == BADSERVERID255)
1854 break;
1855 if (tentry.serverNumber[k] == serverindex) {
1856 match = 1;
1857 break;
1858 }
1859 }
1860 if (!match)
1861 continue;
1862 }
1863
1864 /* Does this volume exist on the desired partition */
1865 if (attributes->Mask & VLLIST_PARTITION0x2) {
1866 if (match) {
1867 if (tentry.serverPartition[k] != attributes->partition)
1868 match = 0;
1869 } else {
1870 for (k = 0; k < OMAXNSERVERS8; k++) {
1871 if (tentry.serverNumber[k] == BADSERVERID255)
1872 break;
1873 if (tentry.serverPartition[k] ==
1874 attributes->partition) {
1875 match = 1;
1876 break;
1877 }
1878 }
1879 }
1880 if (!match)
1881 continue;
1882 }
1883
1884 /* Does this volume have the desired flags */
1885 if (attributes->Mask & VLLIST_FLAG0x10) {
1886 if (!(tentry.flags & attributes->flag))
1887 continue;
1888 }
1889
1890 vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
1891 if (vllist == NULL((void *)0)) {
1892 code = VL_NOMEM(363547L);
1893 goto abort;
1894 }
1895 code = vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
1896 if (code)
1897 goto abort;
1898
1899 vllist->next_vldb = NULL((void *)0);
1900
1901 *vllistptr = vllist; /* Thread onto list */
1902 vllistptr = &vllist->next_vldb;
1903 (*nentries)++;
1904 if (smallMem && (*nentries >= VLDBALLOCCOUNT500)) {
1905 code = VL_SIZEEXCEEDED(363537L);
1906 goto abort;
1907 }
1908 }
1909 }
1910 *vllistptr = NULL((void *)0);
1911 return (ubik_EndTrans(ctx.trans));
1912
1913abort:
1914 countAbort(this_op);
1915 ubik_AbortTrans(ctx.trans);
1916 return code;
1917}
1918
1919afs_int32
1920SVL_LinkedListN(struct rx_call *rxcall,
1921 struct VldbListByAttributes *attributes,
1922 afs_int32 *nentries,
1923 nvldb_list *vldbentries)
1924{
1925 int this_op = VLLINKEDLISTN523;
1926 int code;
1927 struct vl_ctx ctx;
1928 struct nvlentry tentry;
1929 nvldblist vllist, *vllistptr;
1930 afs_int32 blockindex, count, match;
1931 afs_int32 k = 0;
1932 int serverindex;
1933 int pollcount = 0;
1934
1935 countRequest(this_op);
1936 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
1937 return code;
1938
1939 *nentries = 0;
1940 vldbentries->node = NULL((void *)0);
1941 vllistptr = &vldbentries->node;
1942
1943 /* List by volumeid */
1944 if (attributes->Mask & VLLIST_VOLUMEID0x8) {
1945 blockindex =
1946 FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1947 if (!blockindex) {
1948 if (!code)
1949 code = VL_NOENT(363524L);
1950 goto abort;
1951 }
1952
1953 vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
1954 if (vllist == NULL((void *)0)) {
1955 code = VL_NOMEM(363547L);
1956 goto abort;
1957 }
1958 code = vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
1959 if (code)
1960 goto abort;
1961
1962 vllist->next_vldb = NULL((void *)0);
1963
1964 *vllistptr = vllist; /* Thread onto list */
1965 vllistptr = &vllist->next_vldb;
1966 (*nentries)++;
1967 }
1968
1969 /* Search by server, partition, and flags */
1970 else {
1971 for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
1972 blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
1973 match = 0;
1974
1975 if (++pollcount > 50) {
1976#ifndef AFS_PTHREAD_ENV
1977 IOMGR_Poll();
1978#endif
1979 pollcount = 0;
1980 }
1981
1982 /* Does this volume exist on the desired server */
1983 if (attributes->Mask & VLLIST_SERVER0x1) {
1984 serverindex =
1985 IpAddrToRelAddr(&ctx, attributes->server, 0);
1986 if (serverindex == -1)
1987 continue;
1988 for (k = 0; k < NMAXNSERVERS13; k++) {
1989 if (tentry.serverNumber[k] == BADSERVERID255)
1990 break;
1991 if (tentry.serverNumber[k] == serverindex) {
1992 match = 1;
1993 break;
1994 }
1995 }
1996 if (!match)
1997 continue;
1998 }
1999
2000 /* Does this volume exist on the desired partition */
2001 if (attributes->Mask & VLLIST_PARTITION0x2) {
2002 if (match) {
2003 if (tentry.serverPartition[k] != attributes->partition)
2004 match = 0;
2005 } else {
2006 for (k = 0; k < NMAXNSERVERS13; k++) {
2007 if (tentry.serverNumber[k] == BADSERVERID255)
2008 break;
2009 if (tentry.serverPartition[k] ==
2010 attributes->partition) {
2011 match = 1;
2012 break;
2013 }
2014 }
2015 }
2016 if (!match)
2017 continue;
2018 }
2019
2020 /* Does this volume have the desired flags */
2021 if (attributes->Mask & VLLIST_FLAG0x10) {
2022 if (!(tentry.flags & attributes->flag))
2023 continue;
2024 }
2025
2026 vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
2027 if (vllist == NULL((void *)0)) {
2028 code = VL_NOMEM(363547L);
2029 goto abort;
2030 }
2031 code = vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
2032 if (code)
2033 goto abort;
2034
2035 vllist->next_vldb = NULL((void *)0);
2036
2037 *vllistptr = vllist; /* Thread onto list */
2038 vllistptr = &vllist->next_vldb;
2039 (*nentries)++;
2040 if (smallMem && (*nentries >= VLDBALLOCCOUNT500)) {
2041 code = VL_SIZEEXCEEDED(363537L);
2042 goto abort;
2043 }
2044 }
2045 }
2046 *vllistptr = NULL((void *)0);
2047 return (ubik_EndTrans(ctx.trans));
2048
2049abort:
2050 countAbort(this_op);
2051 ubik_AbortTrans(ctx.trans);
2052 return code;
2053}
2054
2055/* Get back vldb header statistics (allocs, frees, maxvolumeid,
2056 * totalentries, etc) and dynamic statistics (number of requests and/or
2057 * aborts per remote procedure call, etc)
2058 */
2059afs_int32
2060SVL_GetStats(struct rx_call *rxcall,
2061 vldstats *stats,
2062 vital_vlheader *vital_header)
2063{
2064 int this_op = VLGETSTATS513;
2065 afs_int32 code;
2066 struct vl_ctx ctx;
2067 char rxstr[AFS_RXINFO_LEN128];
2068
2069 countRequest(this_op);
2070#ifdef notdef
2071 /* Allow users to get statistics freely */
2072 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0))) /* Must be in 'UserList' to use */
2073 return VL_PERM(363546L);
2074#endif
2075 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
2076 return code;
2077 VLog(5, ("GetStats %s\n", rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("GetStats %s\n", rxinfo(
rxstr, rxcall))); } while (0);
2078 memcpy((char *)vital_header, (char *)&ctx.cheader->vital_header,
2079 sizeof(vital_vlheader));
2080 memcpy((char *)stats, (char *)&dynamic_statistics, sizeof(vldstats));
2081 return (ubik_EndTrans(ctx.trans));
2082}
2083
2084/* Get the list of file server addresses from the VLDB. Currently it's pretty
2085 * easy to do. In the future, it might require a little bit of grunging
2086 * through the VLDB, but that's life.
2087 */
2088afs_int32
2089SVL_GetAddrs(struct rx_call *rxcall,
2090 afs_int32 Handle,
2091 afs_int32 spare2,
2092 struct VLCallBack *spare3,
2093 afs_int32 *nentries,
2094 bulkaddrs *addrsp)
2095{
2096 int this_op = VLGETADDRS515;
2097 afs_int32 code;
2098 struct vl_ctx ctx;
2099 int nservers, i;
2100 afs_uint32 *taddrp;
2101
2102 countRequest(this_op);
2103 addrsp->bulkaddrs_len = *nentries = 0;
2104 addrsp->bulkaddrs_val = 0;
2105 memset(spare3, 0, sizeof(struct VLCallBack));
2106
2107 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
2108 return code;
2109
2110 VLog(5, ("GetAddrs\n"))do { if ((5) <= LogLevel) (FSLog ("GetAddrs\n")); } while (
0);
2111 addrsp->bulkaddrs_val = taddrp =
2112 (afs_uint32 *) malloc(sizeof(afs_int32) * (MAXSERVERID254 + 1));
2113 nservers = *nentries = addrsp->bulkaddrs_len = 0;
2114
2115 if (!taddrp) {
2116 code = VL_NOMEM(363547L);
2117 goto abort;
2118 }
2119
2120 for (i = 0; i <= MAXSERVERID254; i++) {
2121 if ((*taddrp = ntohl(ctx.cheader->IpMappedAddr[i])(__builtin_constant_p(ctx.cheader->IpMappedAddr[i]) ? ((((
__uint32_t)(ctx.cheader->IpMappedAddr[i])) >> 24) | (
(((__uint32_t)(ctx.cheader->IpMappedAddr[i])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(ctx.cheader->IpMappedAddr
[i])) & (0xff << 8)) << 8) | (((__uint32_t)(ctx
.cheader->IpMappedAddr[i])) << 24)) : __bswap32_var(
ctx.cheader->IpMappedAddr[i])))) {
2122 taddrp++;
2123 nservers++;
2124 }
2125 }
2126
2127 addrsp->bulkaddrs_len = *nentries = nservers;
2128 return (ubik_EndTrans(ctx.trans));
2129
2130abort:
2131 countAbort(this_op);
2132 ubik_AbortTrans(ctx.trans);
2133 return code;
2134}
2135
2136#define PADDR(addr)do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (addr>>
24)&0xff, (addr>>16)&0xff, (addr>>8) &
0xff, addr&0xff)); } while (0); VLog(0,("%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8) &0xff, addr&0xff))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (addr>>
24)&0xff, (addr>>16)&0xff, (addr>>8) &
0xff, addr&0xff)); } while (0);
2137
2138afs_int32
2139SVL_RegisterAddrs(struct rx_call *rxcall, afsUUID *uuidp, afs_int32 spare1,
2140 bulkaddrs *addrsp)
2141{
2142 int this_op = VLREGADDR532;
2143 afs_int32 code;
2144 struct vl_ctx ctx;
2145 int cnt, h, i, j, k, m;
2146 struct extentaddr *exp = 0, *tex;
2147 afsUUID tuuid;
2148 afs_uint32 addrs[VL_MAXIPADDRS_PERMH15];
2149 int base;
2150 int count, willChangeEntry, foundUuidEntry, willReplaceCnt;
2151 int WillReplaceEntry, WillChange[MAXSERVERID254 + 1];
2152 int FoundUuid = 0;
2153 int ReplaceEntry = 0;
2154 int srvidx, mhidx;
2155
2156 countRequest(this_op);
2157 if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL((void *)0)))
2158 return (VL_PERM(363546L));
2159 if ((code = Init_VLdbase(&ctx, LOCKWRITE2, this_op)))
2160 return code;
2161
2162 /* Eliminate duplicates from IP address list */
2163 for (k = 0, cnt = 0; k < addrsp->bulkaddrs_len; k++) {
2164 if (addrsp->bulkaddrs_val[k] == 0)
2165 continue;
2166 for (m = 0; m < cnt; m++) {
2167 if (addrs[m] == addrsp->bulkaddrs_val[k])
2168 break;
2169 }
2170 if (m == cnt) {
2171 if (m == VL_MAXIPADDRS_PERMH15) {
2172 VLog(0,do { if ((0) <= LogLevel) (FSLog ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n"
, 15, addrsp->bulkaddrs_val[k])); } while (0)
2173 ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n",do { if ((0) <= LogLevel) (FSLog ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n"
, 15, addrsp->bulkaddrs_val[k])); } while (0)
2174 VL_MAXIPADDRS_PERMH, addrsp->bulkaddrs_val[k]))do { if ((0) <= LogLevel) (FSLog ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n"
, 15, addrsp->bulkaddrs_val[k])); } while (0);
2175 } else {
2176 addrs[m] = addrsp->bulkaddrs_val[k];
2177 cnt++;
2178 }
2179 }
2180 }
2181 if (cnt <= 0) {
2182 code = VL_INDEXERANGE(363549L);
2183 goto abort;
2184 }
2185
2186 count = 0;
2187 willReplaceCnt = 0;
2188 foundUuidEntry = 0;
2189 /* For each server registered within the VLDB */
2190 for (srvidx = 0; srvidx <= MAXSERVERID254; srvidx++) {
2191 willChangeEntry = 0;
2192 WillReplaceEntry = 1;
2193 code = multiHomedExtent(&ctx, srvidx, &exp);
2194 if (code)
2195 continue;
2196
2197 if (exp) {
2198 /* See if the addresses to register will change this server entry */
2199 tuuid = exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid;
2200 afs_ntohuuid(&tuuid);
2201 if (afs_uuid_equal(uuidp, &tuuid)) {
2202 foundUuidEntry = 1;
2203 FoundUuid = srvidx;
2204 } else {
2205 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH15; mhidx++) {
2206 if (!exp->ex_addrs_ex_un._ex_addrentry.addrs[mhidx])
2207 continue;
2208 for (k = 0; k < cnt; k++) {
2209 if (ntohl(exp->ex_addrs[mhidx])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx])) == addrs[k]) {
2210 willChangeEntry = 1;
2211 WillChange[count] = srvidx;
2212 break;
2213 }
2214 }
2215 if (k >= cnt)
2216 WillReplaceEntry = 0;
2217 }
2218 }
2219 } else {
2220 /* The server is not registered as a multihomed.
2221 * See if the addresses to register will replace this server entry.
2222 */
2223 for (k = 0; k < cnt; k++) {
2224 if (ctx.hostaddress[srvidx] == addrs[k]) {
2225 willChangeEntry = 1;
2226 WillChange[count] = srvidx;
2227 WillReplaceEntry = 1;
2228 break;
2229 }
2230 }
2231 }
2232 if (willChangeEntry) {
2233 if (WillReplaceEntry) {
2234 willReplaceCnt++;
2235 ReplaceEntry = srvidx;
2236 }
2237 count++;
2238 }
2239 }
2240
2241 /* If we found the uuid in the VLDB and if we are replacing another
2242 * entire entry, then complain and fail. Also, if we did not find
2243 * the uuid in the VLDB and the IP addresses being registered was
2244 * found in more than one other entry, then we don't know which one
2245 * to replace and will complain and fail.
2246 */
2247 if ((foundUuidEntry && (willReplaceCnt > 0))
2248 || (!foundUuidEntry && (count > 1))) {
2249 VLog(0,do { if ((0) <= LogLevel) (FSLog ("The following fileserver is being registered in the VLDB:\n"
)); } while (0)
2250 ("The following fileserver is being registered in the VLDB:\n"))do { if ((0) <= LogLevel) (FSLog ("The following fileserver is being registered in the VLDB:\n"
)); } while (0);
2251 VLog(0, (" ["))do { if ((0) <= LogLevel) (FSLog (" [")); } while (0);
2252 for (k = 0; k < cnt; k++) {
2253 if (k > 0)
2254 VLog(0,(" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2255 PADDR(addrs[k])do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (addrs[k]
>>24)&0xff, (addrs[k]>>16)&0xff, (addrs[k
]>>8) &0xff, addrs[k]&0xff)); } while (0);;
2256 }
2257 VLog(0,("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2258
2259 if (foundUuidEntry) {
2260 code = multiHomedExtent(&ctx, FoundUuid, &exp);
2261 if (code == 0) {
2262 VLog(0, (" It would have replaced the existing VLDB server "do { if ((0) <= LogLevel) (FSLog (" It would have replaced the existing VLDB server "
"entry:\n")); } while (0)
2263 "entry:\n"))do { if ((0) <= LogLevel) (FSLog (" It would have replaced the existing VLDB server "
"entry:\n")); } while (0);
2264 VLog(0, (" entry %d: [", FoundUuid))do { if ((0) <= LogLevel) (FSLog (" entry %d: [", FoundUuid
)); } while (0);
2265 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH15; mhidx++) {
2266 if (!exp->ex_addrs_ex_un._ex_addrentry.addrs[mhidx])
2267 continue;
2268 if (mhidx > 0)
2269 VLog(0,(" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2270 PADDR(ntohl(exp->ex_addrs[mhidx]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(exp->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)
(exp->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | (
(((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx])) &
(0xff << 16)) >> 8) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 8)) <<
8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[mhidx]))>>24)&0xff, ((__builtin_constant_p(exp
->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) :
__bswap32_var(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>
16)&0xff, ((__builtin_constant_p(exp->_ex_un._ex_addrentry
.addrs[mhidx]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) >> 24) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 16)) >>
8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) & (0xff << 8)) << 8) | (((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>8) &0xff
, (__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx]))&0xff)); } while (0);;
2271 }
2272 VLog(0, ("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2273 }
2274 }
2275
2276 if (count == 1)
2277 VLog(0, (" Yet another VLDB server entry exists:\n"))do { if ((0) <= LogLevel) (FSLog (" Yet another VLDB server entry exists:\n"
)); } while (0);
2278 else
2279 VLog(0, (" Yet other VLDB server entries exist:\n"))do { if ((0) <= LogLevel) (FSLog (" Yet other VLDB server entries exist:\n"
)); } while (0);
2280 for (j = 0; j < count; j++) {
2281 srvidx = WillChange[j];
2282 VLog(0, (" entry %d: ", srvidx))do { if ((0) <= LogLevel) (FSLog (" entry %d: ", srvidx
)); } while (0);
2283
2284 code = multiHomedExtent(&ctx, srvidx, &exp);
2285 if (code)
2286 goto abort;
2287
2288 if (exp) {
2289 VLog(0, ("["))do { if ((0) <= LogLevel) (FSLog ("[")); } while (0);
2290 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH15; mhidx++) {
2291 if (!exp->ex_addrs_ex_un._ex_addrentry.addrs[mhidx])
2292 continue;
2293 if (mhidx > 0)
2294 VLog(0, (" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2295 PADDR(ntohl(exp->ex_addrs[mhidx]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(exp->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)
(exp->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | (
(((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx])) &
(0xff << 16)) >> 8) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 8)) <<
8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[mhidx]))>>24)&0xff, ((__builtin_constant_p(exp
->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) :
__bswap32_var(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>
16)&0xff, ((__builtin_constant_p(exp->_ex_un._ex_addrentry
.addrs[mhidx]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) >> 24) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 16)) >>
8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) & (0xff << 8)) << 8) | (((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>8) &0xff
, (__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx]))&0xff)); } while (0);;
2296 }
2297 VLog(0, ("]"))do { if ((0) <= LogLevel) (FSLog ("]")); } while (0);
2298 } else {
2299 PADDR(ctx.hostaddress[srvidx])do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (ctx.hostaddress
[srvidx]>>24)&0xff, (ctx.hostaddress[srvidx]>>
16)&0xff, (ctx.hostaddress[srvidx]>>8) &0xff, ctx
.hostaddress[srvidx]&0xff)); } while (0);;
2300 }
2301 VLog(0, ("\n"))do { if ((0) <= LogLevel) (FSLog ("\n")); } while (0);
2302 }
2303
2304 if (count == 1)
2305 VLog(0, (" You must 'vos changeaddr' this other server entry\n"))do { if ((0) <= LogLevel) (FSLog (" You must 'vos changeaddr' this other server entry\n"
)); } while (0);
2306 else
2307 VLog(0,do { if ((0) <= LogLevel) (FSLog (" You must 'vos changeaddr' these other server entries\n"
)); } while (0)
2308 (" You must 'vos changeaddr' these other server entries\n"))do { if ((0) <= LogLevel) (FSLog (" You must 'vos changeaddr' these other server entries\n"
)); } while (0);
2309 if (foundUuidEntry)
2310 VLog(0,do { if ((0) <= LogLevel) (FSLog (" and/or remove the sysid file from the registering fileserver\n"
)); } while (0)
2311 (" and/or remove the sysid file from the registering fileserver\n"))do { if ((0) <= LogLevel) (FSLog (" and/or remove the sysid file from the registering fileserver\n"
)); } while (0);
2312 VLog(0, (" before the fileserver can be registered in the VLDB.\n"))do { if ((0) <= LogLevel) (FSLog (" before the fileserver can be registered in the VLDB.\n"
)); } while (0);
2313
2314 code = VL_MULTIPADDR(363550L);
2315 goto abort;
2316 }
2317
2318 /* Passed the checks. Now find and update the existing mh entry, or create
2319 * a new mh entry.
2320 */
2321 if (foundUuidEntry) {
2322 /* Found the entry with same uuid. See if we need to change it */
2323 int change = 0;
2324
2325 code = multiHomedExtentBase(&ctx, FoundUuid, &exp, &base);
2326 if (code)
2327 goto abort;
2328
2329 /* Determine if the entry has changed */
2330 for (k = 0; ((k < cnt) && !change); k++) {
2331 if (ntohl(exp->ex_addrs[k])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[k]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[k])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[k])) != addrs[k])
2332 change = 1;
2333 }
2334 for (; ((k < VL_MAXIPADDRS_PERMH15) && !change); k++) {
2335 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[k] != 0)
2336 change = 1;
2337 }
2338 if (!change) {
2339 return (ubik_EndTrans(ctx.trans));
2340 }
2341 }
2342
2343 VLog(0, ("The following fileserver is being registered in the VLDB:\n"))do { if ((0) <= LogLevel) (FSLog ("The following fileserver is being registered in the VLDB:\n"
)); } while (0);
2344 VLog(0, (" ["))do { if ((0) <= LogLevel) (FSLog (" [")); } while (0);
2345 for (k = 0; k < cnt; k++) {
2346 if (k > 0)
2347 VLog(0, (" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2348 PADDR(addrs[k])do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (addrs[k]
>>24)&0xff, (addrs[k]>>16)&0xff, (addrs[k
]>>8) &0xff, addrs[k]&0xff)); } while (0);;
2349 }
2350 VLog(0, ("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2351
2352 if (foundUuidEntry) {
2353 VLog(0,do { if ((0) <= LogLevel) (FSLog (" It will replace the following existing entry in the VLDB (same uuid):\n"
)); } while (0)
2354 (" It will replace the following existing entry in the VLDB (same uuid):\n"))do { if ((0) <= LogLevel) (FSLog (" It will replace the following existing entry in the VLDB (same uuid):\n"
)); } while (0);
2355 VLog(0, (" entry %d: [", FoundUuid))do { if ((0) <= LogLevel) (FSLog (" entry %d: [", FoundUuid
)); } while (0);
2356 for (k = 0; k < VL_MAXIPADDRS_PERMH15; k++) {
2357 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[k] == 0)
2358 continue;
2359 if (k > 0)
2360 VLog(0, (" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2361 PADDR(ntohl(exp->ex_addrs[k]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(exp->_ex_un._ex_addrentry.addrs[k]) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[k])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[k])) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[k])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[k]))>>24)&0xff,
((__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[k]
) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[k])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[k]))>>16)&0xff, ((__builtin_constant_p(exp->
_ex_un._ex_addrentry.addrs[k]) ? ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[k])) >> 24) | ((((__uint32_t)(exp->
_ex_un._ex_addrentry.addrs[k])) & (0xff << 16)) >>
8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k]))
& (0xff << 8)) << 8) | (((__uint32_t)(exp->
_ex_un._ex_addrentry.addrs[k])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[k]))>>8) &0xff,
(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[k])
? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[k])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[k]))&0xff)); } while (0);;
2362 }
2363 VLog(0, ("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2364 } else if (willReplaceCnt || (count == 1)) {
2365 /* If we are not replacing an entry and there is only one entry to change,
2366 * then we will replace that entry.
2367 */
2368 if (!willReplaceCnt) {
2369 ReplaceEntry = WillChange[0];
2370 willReplaceCnt++;
2371 }
2372
2373 /* Have an entry that needs to be replaced */
2374 code = multiHomedExtentBase(&ctx, ReplaceEntry, &exp, &base);
2375 if (code)
2376 goto abort;
2377
2378 if (exp) {
2379 VLog(0,do { if ((0) <= LogLevel) (FSLog (" It will replace the following existing entry in the VLDB (new uuid):\n"
)); } while (0)
2380 (" It will replace the following existing entry in the VLDB (new uuid):\n"))do { if ((0) <= LogLevel) (FSLog (" It will replace the following existing entry in the VLDB (new uuid):\n"
)); } while (0);
2381 VLog(0, (" entry %d: [", ReplaceEntry))do { if ((0) <= LogLevel) (FSLog (" entry %d: [", ReplaceEntry
)); } while (0);
2382 for (k = 0; k < VL_MAXIPADDRS_PERMH15; k++) {
2383 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[k] == 0)
2384 continue;
2385 if (k > 0)
2386 VLog(0, (" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
2387 PADDR(ntohl(exp->ex_addrs[k]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(exp->_ex_un._ex_addrentry.addrs[k]) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[k])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[k])) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[k])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[k]))>>24)&0xff,
((__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[k]
) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[k])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[k]))>>16)&0xff, ((__builtin_constant_p(exp->
_ex_un._ex_addrentry.addrs[k]) ? ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[k])) >> 24) | ((((__uint32_t)(exp->
_ex_un._ex_addrentry.addrs[k])) & (0xff << 16)) >>
8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k]))
& (0xff << 8)) << 8) | (((__uint32_t)(exp->
_ex_un._ex_addrentry.addrs[k])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[k]))>>8) &0xff,
(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[k])
? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[k])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[k])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[k])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[k]))&0xff)); } while (0);;
2388 }
2389 VLog(0, ("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2390 } else {
2391 /* Not a mh entry. So we have to create a new mh entry and
2392 * put it on the ReplaceEntry slot of the ctx.hostaddress array.
2393 */
2394 VLog(0, (" It will replace existing entry %d, ", ReplaceEntry))do { if ((0) <= LogLevel) (FSLog (" It will replace existing entry %d, "
, ReplaceEntry)); } while (0);
2395 PADDR(ctx.hostaddress[ReplaceEntry])do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (ctx.hostaddress
[ReplaceEntry]>>24)&0xff, (ctx.hostaddress[ReplaceEntry
]>>16)&0xff, (ctx.hostaddress[ReplaceEntry]>>
8) &0xff, ctx.hostaddress[ReplaceEntry]&0xff)); } while
(0);;
2396 VLog(0,(", in the VLDB (new uuid):\n"))do { if ((0) <= LogLevel) (FSLog (", in the VLDB (new uuid):\n"
)); } while (0);
2397
2398 code =
2399 FindExtentBlock(&ctx, uuidp, 1, ReplaceEntry, &exp, &base);
2400 if (code || !exp) {
2401 if (!code)
2402 code = VL_IO(363521L);
2403 goto abort;
2404 }
2405 }
2406 } else {
2407 /* There is no entry for this server, must create a new mh entry as
2408 * well as use a new slot of the ctx.hostaddress array.
2409 */
2410 VLog(0, (" It will create a new entry in the VLDB.\n"))do { if ((0) <= LogLevel) (FSLog (" It will create a new entry in the VLDB.\n"
)); } while (0);
2411 code = FindExtentBlock(&ctx, uuidp, 1, -1, &exp, &base);
2412 if (code || !exp) {
2413 if (!code)
2414 code = VL_IO(363521L);
2415 goto abort;
2416 }
2417 }
2418
2419 /* Now we have a mh entry to fill in. Update the uuid, bump the
2420 * uniquifier, and fill in its IP addresses.
2421 */
2422 tuuid = *uuidp;
2423 afs_htonuuid(&tuuid);
2424 exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid = tuuid;
2425 exp->ex_uniquifier_ex_un._ex_addrentry.uniquifier = htonl(ntohl(exp->ex_uniquifier) + 1)(__builtin_constant_p((__builtin_constant_p(exp->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier)) + 1) ? ((((__uint32_t)((__builtin_constant_p(exp
->_ex_un._ex_addrentry.uniquifier) ? ((((__uint32_t)(exp->
_ex_un._ex_addrentry.uniquifier)) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.uniquifier)) + 1)) >> 24)
| ((((__uint32_t)((__builtin_constant_p(exp->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier)) + 1)) & (0xff << 16)) >> 8) | (
(((__uint32_t)((__builtin_constant_p(exp->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(exp->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier)) + 1)) << 24)) : __bswap32_var((__builtin_constant_p
(exp->_ex_un._ex_addrentry.uniquifier) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.uniquifier)) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.uniquifier)) + 1));
2426 for (k = 0; k < cnt; k++) {
2427 exp->ex_addrs_ex_un._ex_addrentry.addrs[k] = htonl(addrs[k])(__builtin_constant_p(addrs[k]) ? ((((__uint32_t)(addrs[k])) >>
24) | ((((__uint32_t)(addrs[k])) & (0xff << 16)) >>
8) | ((((__uint32_t)(addrs[k])) & (0xff << 8)) <<
8) | (((__uint32_t)(addrs[k])) << 24)) : __bswap32_var
(addrs[k]));
2428 }
2429 for (; k < VL_MAXIPADDRS_PERMH15; k++) {
2430 exp->ex_addrs_ex_un._ex_addrentry.addrs[k] = 0;
2431 }
2432
2433 /* Write the new mh entry out */
2434 if (vlwrite
2435 (ctx.trans,
2436 DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[base]),(((__builtin_constant_p(ctx.ex_addr[0]->_ex_un._ex_header.
contaddrs[base]) ? ((((__uint32_t)(ctx.ex_addr[0]->_ex_un.
_ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(ctx
.ex_addr[0]->_ex_un._ex_header.contaddrs[base])) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(ctx.ex_addr[0]->
_ex_un._ex_header.contaddrs[base])) & (0xff << 8)) <<
8) | (((__uint32_t)(ctx.ex_addr[0]->_ex_un._ex_header.contaddrs
[base])) << 24)) : __bswap32_var(ctx.ex_addr[0]->_ex_un
._ex_header.contaddrs[base])))+(((char *)((char *)exp)) - ((char
*)((char *)ctx.ex_addr[base]))))
2437 (char *)ctx.ex_addr[base], (char *)exp)(((__builtin_constant_p(ctx.ex_addr[0]->_ex_un._ex_header.
contaddrs[base]) ? ((((__uint32_t)(ctx.ex_addr[0]->_ex_un.
_ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(ctx
.ex_addr[0]->_ex_un._ex_header.contaddrs[base])) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(ctx.ex_addr[0]->
_ex_un._ex_header.contaddrs[base])) & (0xff << 8)) <<
8) | (((__uint32_t)(ctx.ex_addr[0]->_ex_un._ex_header.contaddrs
[base])) << 24)) : __bswap32_var(ctx.ex_addr[0]->_ex_un
._ex_header.contaddrs[base])))+(((char *)((char *)exp)) - ((char
*)((char *)ctx.ex_addr[base])))), (char *)exp,
2438 sizeof(*exp))) {
2439 code = VL_IO(363521L);
2440 goto abort;
2441 }
2442
2443 /* Remove any common addresses from other mh entres. We know these entries
2444 * are being changed and not replaced so they are mh entries.
2445 */
2446 m = 0;
2447 for (i = 0; i < count; i++) {
2448 afs_int32 doff;
2449
2450 /* Skip the entry we replaced */
2451 if (willReplaceCnt && (WillChange[i] == ReplaceEntry))
2452 continue;
2453
2454 code = multiHomedExtentBase(&ctx, WillChange[i], &tex, &base);
2455 if (code)
2456 goto abort;
2457
2458 if (++m == 1)
2459 VLog(0,do { if ((0) <= LogLevel) (FSLog (" The following existing entries in the VLDB will be updated:\n"
)); } while (0)
2460 (" The following existing entries in the VLDB will be updated:\n"))do { if ((0) <= LogLevel) (FSLog (" The following existing entries in the VLDB will be updated:\n"
)); } while (0);
2461
2462 VLog(0, (" entry %d: [", WillChange[i]))do { if ((0) <= LogLevel) (FSLog (" entry %d: [", WillChange
[i])); } while (0);
2463 for (h = j = 0; j < VL_MAXIPADDRS_PERMH15; j++) {
2464 if (tex->ex_addrs_ex_un._ex_addrentry.addrs[j]) {
2465 if (j > 0)
2466 printf(" ");
2467 PADDR(ntohl(tex->ex_addrs[j]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(tex->_ex_un._ex_addrentry.addrs[j]) ? ((((__uint32_t)(tex
->_ex_un._ex_addrentry.addrs[j])) >> 24) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.addrs[j])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.addrs[j])) & (0xff << 8)) << 8) | (((__uint32_t
)(tex->_ex_un._ex_addrentry.addrs[j])) << 24)) : __bswap32_var
(tex->_ex_un._ex_addrentry.addrs[j]))>>24)&0xff,
((__builtin_constant_p(tex->_ex_un._ex_addrentry.addrs[j]
) ? ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(tex
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.addrs[j]))>>16)&0xff, ((__builtin_constant_p(tex->
_ex_un._ex_addrentry.addrs[j]) ? ((((__uint32_t)(tex->_ex_un
._ex_addrentry.addrs[j])) >> 24) | ((((__uint32_t)(tex->
_ex_un._ex_addrentry.addrs[j])) & (0xff << 16)) >>
8) | ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j]))
& (0xff << 8)) << 8) | (((__uint32_t)(tex->
_ex_un._ex_addrentry.addrs[j])) << 24)) : __bswap32_var
(tex->_ex_un._ex_addrentry.addrs[j]))>>8) &0xff,
(__builtin_constant_p(tex->_ex_un._ex_addrentry.addrs[j])
? ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(tex
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.addrs[j]))&0xff)); } while (0);;
2468 }
2469
2470 for (k = 0; k < cnt; k++) {
2471 if (ntohl(tex->ex_addrs[j])(__builtin_constant_p(tex->_ex_un._ex_addrentry.addrs[j]) ?
((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(tex
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.addrs[j])) == addrs[k])
2472 break;
2473 }
2474 if (k >= cnt) {
2475 /* Not found, so we keep it */
2476 tex->ex_addrs_ex_un._ex_addrentry.addrs[h] = tex->ex_addrs_ex_un._ex_addrentry.addrs[j];
2477 h++;
2478 }
2479 }
2480 for (j = h; j < VL_MAXIPADDRS_PERMH15; j++) {
2481 tex->ex_addrs_ex_un._ex_addrentry.addrs[j] = 0; /* zero rest of mh entry */
2482 }
2483 VLog(0, ("]\n"))do { if ((0) <= LogLevel) (FSLog ("]\n")); } while (0);
2484
2485 /* Write out the modified mh entry */
2486 tex->ex_uniquifier_ex_un._ex_addrentry.uniquifier = htonl(ntohl(tex->ex_uniquifier) + 1)(__builtin_constant_p((__builtin_constant_p(tex->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(tex->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.uniquifier)) + 1) ? ((((__uint32_t)((__builtin_constant_p(tex
->_ex_un._ex_addrentry.uniquifier) ? ((((__uint32_t)(tex->
_ex_un._ex_addrentry.uniquifier)) >> 24) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 8)) << 8) | (((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) << 24)) : __bswap32_var
(tex->_ex_un._ex_addrentry.uniquifier)) + 1)) >> 24)
| ((((__uint32_t)((__builtin_constant_p(tex->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(tex->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.uniquifier)) + 1)) & (0xff << 16)) >> 8) | (
(((__uint32_t)((__builtin_constant_p(tex->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(tex->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.uniquifier)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(tex->_ex_un._ex_addrentry
.uniquifier) ? ((((__uint32_t)(tex->_ex_un._ex_addrentry.uniquifier
)) >> 24) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(tex->_ex_un._ex_addrentry
.uniquifier)) + 1)) << 24)) : __bswap32_var((__builtin_constant_p
(tex->_ex_un._ex_addrentry.uniquifier) ? ((((__uint32_t)(tex
->_ex_un._ex_addrentry.uniquifier)) >> 24) | ((((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tex->_ex_un._ex_addrentry
.uniquifier)) & (0xff << 8)) << 8) | (((__uint32_t
)(tex->_ex_un._ex_addrentry.uniquifier)) << 24)) : __bswap32_var
(tex->_ex_un._ex_addrentry.uniquifier)) + 1));
2487 doff =
2488 DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[base]),(((__builtin_constant_p(ctx.ex_addr[0]->_ex_un._ex_header.
contaddrs[base]) ? ((((__uint32_t)(ctx.ex_addr[0]->_ex_un.
_ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(ctx
.ex_addr[0]->_ex_un._ex_header.contaddrs[base])) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(ctx.ex_addr[0]->
_ex_un._ex_header.contaddrs[base])) & (0xff << 8)) <<
8) | (((__uint32_t)(ctx.ex_addr[0]->_ex_un._ex_header.contaddrs
[base])) << 24)) : __bswap32_var(ctx.ex_addr[0]->_ex_un
._ex_header.contaddrs[base])))+(((char *)((char *)tex)) - ((char
*)((char *)ctx.ex_addr[base]))))
2489 (char *)ctx.ex_addr[base], (char *)tex)(((__builtin_constant_p(ctx.ex_addr[0]->_ex_un._ex_header.
contaddrs[base]) ? ((((__uint32_t)(ctx.ex_addr[0]->_ex_un.
_ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(ctx
.ex_addr[0]->_ex_un._ex_header.contaddrs[base])) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(ctx.ex_addr[0]->
_ex_un._ex_header.contaddrs[base])) & (0xff << 8)) <<
8) | (((__uint32_t)(ctx.ex_addr[0]->_ex_un._ex_header.contaddrs
[base])) << 24)) : __bswap32_var(ctx.ex_addr[0]->_ex_un
._ex_header.contaddrs[base])))+(((char *)((char *)tex)) - ((char
*)((char *)ctx.ex_addr[base]))));
2490 if (vlwrite(ctx.trans, doff, (char *)tex, sizeof(*tex))) {
2491 code = VL_IO(363521L);
2492 goto abort;
2493 }
2494 }
2495
2496 return (ubik_EndTrans(ctx.trans));
2497
2498abort:
2499 countAbort(this_op);
2500 ubik_AbortTrans(ctx.trans);
2501 return code;
2502}
2503
2504afs_int32
2505SVL_GetAddrsU(struct rx_call *rxcall,
2506 struct ListAddrByAttributes *attributes,
2507 afsUUID *uuidpo,
2508 afs_int32 *uniquifier,
2509 afs_int32 *nentries,
2510 bulkaddrs *addrsp)
2511{
2512 int this_op = VLGETADDRSU533;
2513 afs_int32 code, index = -1, offset;
2514 struct vl_ctx ctx;
2515 int nservers, i, j, base = 0;
2516 struct extentaddr *exp = 0;
2517 afsUUID tuuid;
2518 afs_uint32 *taddrp, taddr;
2519 char rxstr[AFS_RXINFO_LEN128];
2520
2521 countRequest(this_op);
2522 addrsp->bulkaddrs_len = *nentries = 0;
2523 addrsp->bulkaddrs_val = 0;
2524 VLog(5, ("GetAddrsU %s\n", rxinfo(rxstr, rxcall)))do { if ((5) <= LogLevel) (FSLog ("GetAddrsU %s\n", rxinfo
(rxstr, rxcall))); } while (0);
2525 if ((code = Init_VLdbase(&ctx, LOCKREAD1, this_op)))
2526 return code;
2527
2528 if (attributes->Mask & VLADDR_IPADDR0x1) {
2529 if (attributes->Mask & (VLADDR_INDEX0x2 | VLADDR_UUID0x4)) {
2530 code = VL_BADMASK(363551L);
2531 goto abort;
2532 }
2533 for (base = 0; base < VL_MAX_ADDREXTBLKS4; base++) {
2534 if (!ctx.ex_addr[base])
2535 break;
2536 for (i = 1; i < VL_MHSRV_PERBLK64; i++) {
2537 exp = &ctx.ex_addr[base][i];
2538 tuuid = exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid;
2539 afs_ntohuuid(&tuuid);
2540 if (afs_uuid_is_nil(&tuuid))
2541 continue;
2542 for (j = 0; j < VL_MAXIPADDRS_PERMH15; j++) {
2543 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[j]
2544 && (ntohl(exp->ex_addrs[j])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[j]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[j])) == attributes->ipaddr)) {
2545 break;
2546 }
2547 }
2548 if (j < VL_MAXIPADDRS_PERMH15)
2549 break;
2550 }
2551 if (i < VL_MHSRV_PERBLK64)
2552 break;
2553 }
2554 if (base >= VL_MAX_ADDREXTBLKS4) {
2555 code = VL_NOENT(363524L);
2556 goto abort;
2557 }
2558 } else if (attributes->Mask & VLADDR_INDEX0x2) {
2559 if (attributes->Mask & (VLADDR_IPADDR0x1 | VLADDR_UUID0x4)) {
2560 code = VL_BADMASK(363551L);
2561 goto abort;
2562 }
2563 index = attributes->index;
2564 if (index < 1 || index >= (VL_MAX_ADDREXTBLKS4 * VL_MHSRV_PERBLK64)) {
2565 code = VL_INDEXERANGE(363549L);
2566 goto abort;
2567 }
2568 base = index / VL_MHSRV_PERBLK64;
2569 offset = index % VL_MHSRV_PERBLK64;
2570 if (offset == 0) {
2571 code = VL_NOENT(363524L);
2572 goto abort;
2573 }
2574 if (!ctx.ex_addr[base]) {
2575 code = VL_INDEXERANGE(363549L);
2576 goto abort;
2577 }
2578 exp = &ctx.ex_addr[base][offset];
2579 } else if (attributes->Mask & VLADDR_UUID0x4) {
2580 if (attributes->Mask & (VLADDR_IPADDR0x1 | VLADDR_INDEX0x2)) {
2581 code = VL_BADMASK(363551L);
2582 goto abort;
2583 }
2584 if (!ctx.ex_addr[0]) { /* mh servers probably aren't setup on this vldb */
2585 code = VL_NOENT(363524L);
2586 goto abort;
2587 }
2588 code = FindExtentBlock(&ctx, &attributes->uuid, 0, -1, &exp, &base);
2589 if (code)
2590 goto abort;
2591 } else {
2592 code = VL_BADMASK(363551L);
2593 goto abort;
2594 }
2595
2596 if (exp == NULL((void *)0)) {
2597 code = VL_NOENT(363524L);
2598 goto abort;
2599 }
2600 addrsp->bulkaddrs_val = taddrp =
2601 (afs_uint32 *) malloc(sizeof(afs_int32) * (MAXSERVERID254 + 1));
2602 nservers = *nentries = addrsp->bulkaddrs_len = 0;
2603 if (!taddrp) {
2604 code = VL_NOMEM(363547L);
2605 goto abort;
2606 }
2607 tuuid = exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid;
2608 afs_ntohuuid(&tuuid);
2609 if (afs_uuid_is_nil(&tuuid)) {
2610 code = VL_NOENT(363524L);
2611 goto abort;
2612 }
2613 if (uuidpo)
2614 *uuidpo = tuuid;
2615 if (uniquifier)
2616 *uniquifier = ntohl(exp->ex_uniquifier)(__builtin_constant_p(exp->_ex_un._ex_addrentry.uniquifier
) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier))
>> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.
uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier));
2617 for (i = 0; i < VL_MAXIPADDRS_PERMH15; i++) {
2618 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[i]) {
2619 taddr = ntohl(exp->ex_addrs[i])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[i]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[i])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[i])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[i])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[i])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[i]));
2620 /* Weed out duplicates */
2621 for (j = 0; j < nservers; j++) {
2622 if (taddrp[j] == taddr)
2623 break;
2624 }
2625 if ((j == nservers) && (j <= MAXSERVERID254)) {
2626 taddrp[nservers] = taddr;
2627 nservers++;
2628 }
2629 }
2630 }
2631 addrsp->bulkaddrs_len = *nentries = nservers;
2632 return (ubik_EndTrans(ctx.trans));
2633
2634abort:
2635 countAbort(this_op);
2636 ubik_AbortTrans(ctx.trans);
2637 return code;
2638}
2639
2640/* ============> End of Exported vldb RPC functions <============= */
2641
2642
2643/* Routine that copies the given vldb entry to the output buffer, vldbentries. */
2644static int
2645put_attributeentry(struct vl_ctx *ctx,
2646 struct vldbentry **Vldbentry,
2647 struct vldbentry **VldbentryFirst,
2648 struct vldbentry **VldbentryLast,
2649 bulkentries *vldbentries,
2650 struct nvlentry *entry,
2651 afs_int32 *nentries,
2652 afs_int32 *alloccnt)
2653{
2654 vldbentry *reall;
2655 afs_int32 allo;
2656 int code;
2657
2658 if (*Vldbentry == *VldbentryLast) {
2659 if (smallMem)
2660 return VL_SIZEEXCEEDED(363537L); /* no growing if smallMem defined */
2661
2662 /* Allocate another set of memory; each time allocate twice as
2663 * many blocks as the last time. When we reach VLDBALLOCLIMIT,
2664 * then grow in increments of VLDBALLOCINCR.
2665 */
2666 allo = (*alloccnt > VLDBALLOCLIMIT10000) ? VLDBALLOCINCR2048 : *alloccnt;
2667 reall =
2668 (vldbentry *) realloc(*VldbentryFirst,
2669 (*alloccnt + allo) * sizeof(vldbentry));
2670 if (reall == NULL((void *)0))
2671 return VL_NOMEM(363547L);
2672
2673 *VldbentryFirst = vldbentries->bulkentries_val = reall;
2674 *Vldbentry = *VldbentryFirst + *alloccnt;
2675 *VldbentryLast = *Vldbentry + allo;
2676 *alloccnt += allo;
2677 }
2678
2679 code = vlentry_to_vldbentry(ctx, entry, *Vldbentry);
2680 if (code)
2681 return code;
2682
2683 (*Vldbentry)++;
2684 (*nentries)++;
2685 vldbentries->bulkentries_len++;
2686 return 0;
2687}
2688
2689static int
2690put_nattributeentry(struct vl_ctx *ctx,
2691 struct nvldbentry **Vldbentry,
2692 struct nvldbentry **VldbentryFirst,
2693 struct nvldbentry **VldbentryLast,
2694 nbulkentries *vldbentries,
2695 struct nvlentry *entry,
2696 afs_int32 matchtype,
2697 afs_int32 matchindex,
2698 afs_int32 *nentries,
2699 afs_int32 *alloccnt)
2700{
2701 nvldbentry *reall;
2702 afs_int32 allo;
2703 int code;
2704
2705 if (*Vldbentry == *VldbentryLast) {
2706 if (smallMem)
2707 return VL_SIZEEXCEEDED(363537L); /* no growing if smallMem defined */
2708
2709 /* Allocate another set of memory; each time allocate twice as
2710 * many blocks as the last time. When we reach VLDBALLOCLIMIT,
2711 * then grow in increments of VLDBALLOCINCR.
2712 */
2713 allo = (*alloccnt > VLDBALLOCLIMIT10000) ? VLDBALLOCINCR2048 : *alloccnt;
2714 reall =
2715 (nvldbentry *) realloc(*VldbentryFirst,
2716 (*alloccnt + allo) * sizeof(nvldbentry));
2717 if (reall == NULL((void *)0))
2718 return VL_NOMEM(363547L);
2719
2720 *VldbentryFirst = vldbentries->nbulkentries_val = reall;
2721 *Vldbentry = *VldbentryFirst + *alloccnt;
2722 *VldbentryLast = *Vldbentry + allo;
2723 *alloccnt += allo;
2724 }
2725 code = vlentry_to_nvldbentry(ctx, entry, *Vldbentry);
2726 if (code)
2727 return code;
2728
2729 (*Vldbentry)->matchindex = (matchtype << 16) + matchindex;
2730 (*Vldbentry)++;
2731 (*nentries)++;
2732 vldbentries->nbulkentries_len++;
2733 return 0;
2734}
2735
2736
2737/* Common code to actually remove a vldb entry from the database. */
2738static int
2739RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
2740 struct nvlentry *tentry)
2741{
2742 int code;
2743
2744 if ((code = UnthreadVLentry(ctx, entryptr, tentry)))
2745 return code;
2746 if ((code = FreeBlock(ctx, entryptr)))
2747 return code;
2748 return 0;
2749}
2750
2751static void
2752ReleaseEntry(struct nvlentry *tentry, afs_int32 releasetype)
2753{
2754 if (releasetype & LOCKREL_TIMESTAMP1)
2755 tentry->LockTimestamp = 0;
2756 if (releasetype & LOCKREL_OPCODE2)
2757 tentry->flags &= ~VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100);
2758 if (releasetype & LOCKREL_AFSID4)
2759 tentry->LockAfsId = 0;
2760}
2761
2762
2763/* Verify that the incoming vldb entry is valid; multi type of error codes
2764 * are returned. */
2765static int
2766check_vldbentry(struct vldbentry *aentry)
2767{
2768 afs_int32 i;
2769
2770 if (InvalidVolname(aentry->name))
2771 return VL_BADNAME(363527L);
2772 if (aentry->nServers <= 0 || aentry->nServers > OMAXNSERVERS8)
2773 return VL_BADSERVER(363530L);
2774 for (i = 0; i < aentry->nServers; i++) {
2775/* if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID)
2776 return VL_BADSERVER; */
2777 if (aentry->serverPartition[i] < 0
2778 || aentry->serverPartition[i] > MAXPARTITIONID255)
2779 return VL_BADPARTITION(363531L);
2780 if (aentry->serverFlags[i] < 0
2781 || aentry->serverFlags[i] > MAXSERVERFLAG0x80)
2782 return VL_BADSERVERFLAG(363545L);
2783 }
2784 return 0;
2785}
2786
2787static int
2788check_nvldbentry(struct nvldbentry *aentry)
2789{
2790 afs_int32 i;
2791
2792 if (InvalidVolname(aentry->name))
2793 return VL_BADNAME(363527L);
2794 if (aentry->nServers <= 0 || aentry->nServers > NMAXNSERVERS13)
2795 return VL_BADSERVER(363530L);
2796 for (i = 0; i < aentry->nServers; i++) {
2797/* if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID)
2798 return VL_BADSERVER; */
2799 if (aentry->serverPartition[i] < 0
2800 || aentry->serverPartition[i] > MAXPARTITIONID255)
2801 return VL_BADPARTITION(363531L);
2802 if (aentry->serverFlags[i] < 0
2803 || aentry->serverFlags[i] > MAXSERVERFLAG0x80)
2804 return VL_BADSERVERFLAG(363545L);
2805 }
2806 return 0;
2807}
2808
2809
2810/* Convert from the external vldb entry representation to its internal
2811 (more compact) form. This call should not change the hash chains! */
2812static int
2813vldbentry_to_vlentry(struct vl_ctx *ctx,
2814 struct vldbentry *VldbEntry,
2815 struct nvlentry *VlEntry)
2816{
2817 int i, serverindex;
2818
2819 if (strcmp(VlEntry->name, VldbEntry->name))
2820 strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
2821 for (i = 0; i < VldbEntry->nServers; i++) {
2822 serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
2823 if (serverindex == -1)
2824 return VL_BADSERVER(363530L);
2825 VlEntry->serverNumber[i] = serverindex;
2826 VlEntry->serverPartition[i] = VldbEntry->serverPartition[i];
2827 VlEntry->serverFlags[i] = VldbEntry->serverFlags[i];
2828 }
2829 for (; i < OMAXNSERVERS8; i++)
2830 VlEntry->serverNumber[i] = VlEntry->serverPartition[i] =
2831 VlEntry->serverFlags[i] = BADSERVERID255;
2832 for (i = 0; i < MAXTYPES3; i++)
2833 VlEntry->volumeId[i] = VldbEntry->volumeId[i];
2834 VlEntry->cloneId = VldbEntry->cloneId;
2835 VlEntry->flags = VldbEntry->flags;
2836 return 0;
2837}
2838
2839static int
2840nvldbentry_to_vlentry(struct vl_ctx *ctx,
2841 struct nvldbentry *VldbEntry,
2842 struct nvlentry *VlEntry)
2843{
2844 int i, serverindex;
2845
2846 if (strcmp(VlEntry->name, VldbEntry->name))
2847 strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
2848 for (i = 0; i < VldbEntry->nServers; i++) {
2849 serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
2850 if (serverindex == -1)
2851 return VL_BADSERVER(363530L);
2852 VlEntry->serverNumber[i] = serverindex;
2853 VlEntry->serverPartition[i] = VldbEntry->serverPartition[i];
2854 VlEntry->serverFlags[i] = VldbEntry->serverFlags[i];
2855 }
2856 for (; i < NMAXNSERVERS13; i++)
2857 VlEntry->serverNumber[i] = VlEntry->serverPartition[i] =
2858 VlEntry->serverFlags[i] = BADSERVERID255;
2859 for (i = 0; i < MAXTYPES3; i++)
2860 VlEntry->volumeId[i] = VldbEntry->volumeId[i];
2861 VlEntry->cloneId = VldbEntry->cloneId;
2862 VlEntry->flags = VldbEntry->flags;
2863 return 0;
2864}
2865
2866
2867/* Update the vldb entry with the new fields as indicated by the value of
2868 * the Mask entry in the updateentry structure. All necessary validation
2869 * checks are performed.
2870 */
2871static int
2872get_vldbupdateentry(struct vl_ctx *ctx,
2873 afs_int32 blockindex,
2874 struct VldbUpdateEntry *updateentry,
2875 struct nvlentry *VlEntry)
2876{
2877 int i, j, code, serverindex;
2878 afs_uint32 checkids[MAXTYPES3];
2879
2880 /* check if any specified new IDs are already present in the db. Do
2881 * this check before doing anything else, so we don't get a half-
2882 * updated entry. */
2883 memset(&checkids, 0, sizeof(checkids));
2884 if (updateentry->Mask & VLUPDATE_RWID0x0200) {
2885 checkids[RWVOL0] = updateentry->spares3; /* rw id */
2886 }
2887 if (updateentry->Mask & VLUPDATE_READONLYID0x0008) {
2888 checkids[ROVOL1] = updateentry->ReadOnlyId;
2889 }
2890 if (updateentry->Mask & VLUPDATE_BACKUPID0x0010) {
2891 checkids[BACKVOL2] = updateentry->BackupId;
2892 }
2893
2894 if (EntryIDExists(ctx, checkids, MAXTYPES3, &code)) {
2895 return VL_IDEXIST(363520L);
2896 } else if (code) {
2897 return code;
2898 }
2899
2900 if (updateentry->Mask & VLUPDATE_VOLUMENAME0x0001) {
2901 struct nvlentry tentry;
2902
2903 if (InvalidVolname(updateentry->name))
2904 return VL_BADNAME(363527L);
2905
2906 if (FindByName(ctx, updateentry->name, &tentry, &code)) {
2907 return VL_NAMEEXIST(363522L);
2908 } else if (code) {
2909 return code;
2910 }
2911
2912 if ((code = UnhashVolname(ctx, blockindex, VlEntry)))
2913 return code;
2914 strncpy(VlEntry->name, updateentry->name, sizeof(VlEntry->name));
2915 HashVolname(ctx, blockindex, VlEntry);
2916 }
2917
2918 if (updateentry->Mask & VLUPDATE_VOLNAMEHASH0x0100) {
2919 if ((code = UnhashVolname(ctx, blockindex, VlEntry))) {
2920 if (code != VL_NOENT(363524L))
2921 return code;
2922 }
2923 HashVolname(ctx, blockindex, VlEntry);
2924 }
2925
2926 if (updateentry->Mask & VLUPDATE_FLAGS0x0004) {
2927 VlEntry->flags = updateentry->flags;
2928 }
2929 if (updateentry->Mask & VLUPDATE_CLONEID0x0080) {
2930 VlEntry->cloneId = updateentry->cloneId;
2931 }
2932 if (updateentry->Mask & VLUPDATE_RWID0x0200) {
2933 if ((code = UnhashVolid(ctx, RWVOL0, blockindex, VlEntry))) {
2934 if (code != VL_NOENT(363524L))
2935 return code;
2936 }
2937 VlEntry->volumeId[RWVOL0] = updateentry->spares3; /* rw id */
2938 if ((code = HashVolid(ctx, RWVOL0, blockindex, VlEntry)))
2939 return code;
2940 }
2941 if (updateentry->Mask & VLUPDATE_READONLYID0x0008) {
2942 if ((code = UnhashVolid(ctx, ROVOL1, blockindex, VlEntry))) {
2943 if (code != VL_NOENT(363524L))
2944 return code;
2945 }
2946 VlEntry->volumeId[ROVOL1] = updateentry->ReadOnlyId;
2947 if ((code = HashVolid(ctx, ROVOL1, blockindex, VlEntry)))
2948 return code;
2949 }
2950 if (updateentry->Mask & VLUPDATE_BACKUPID0x0010) {
2951 if ((code = UnhashVolid(ctx, BACKVOL2, blockindex, VlEntry))) {
2952 if (code != VL_NOENT(363524L))
2953 return code;
2954 }
2955 VlEntry->volumeId[BACKVOL2] = updateentry->BackupId;
2956 if ((code = HashVolid(ctx, BACKVOL2, blockindex, VlEntry)))
2957 return code;
2958 }
2959 if (updateentry->Mask & VLUPDATE_REPSITES0x0020) {
2960 if (updateentry->nModifiedRepsites <= 0
2961 || updateentry->nModifiedRepsites > OMAXNSERVERS8)
2962 return VL_BADSERVER(363530L);
2963 for (i = 0; i < updateentry->nModifiedRepsites; i++) {
2964/* if (updateentry->RepsitesTargetServer[i] < 0 || updateentry->RepsitesTargetServer[i] > MAXSERVERID)
2965 return VL_BADSERVER; */
2966 if (updateentry->RepsitesTargetPart[i] < 0
2967 || updateentry->RepsitesTargetPart[i] > MAXPARTITIONID255)
2968 return VL_BADPARTITION(363531L);
2969 if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_DELETE0x0100) {
2970 if ((j =
2971 repsite_exists(VlEntry,
2972 IpAddrToRelAddr(ctx, updateentry->
2973 RepsitesTargetServer[i],
2974 1),
2975 updateentry->RepsitesTargetPart[i])) !=
2976 -1)
2977 repsite_compress(VlEntry, j);
2978 else
2979 return VL_NOREPSERVER(363533L);
2980 }
2981 if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_ADD0x0200) {
2982/* if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID)
2983 return VL_BADSERVER; */
2984 if (updateentry->RepsitesNewPart[i] < 0
2985 || updateentry->RepsitesNewPart[i] > MAXPARTITIONID255)
2986 return VL_BADPARTITION(363531L);
2987 if (repsite_exists
2988 (VlEntry,
2989 IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i], 1),
2990 updateentry->RepsitesNewPart[i]) != -1)
2991 return VL_DUPREPSERVER(363534L);
2992 for (j = 0;
2993 VlEntry->serverNumber[j] != BADSERVERID255
2994 && j < OMAXNSERVERS8; j++);
2995 if (j >= OMAXNSERVERS8)
2996 return VL_REPSFULL(363532L);
2997 if ((serverindex =
2998 IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
2999 1)) == -1)
3000 return VL_BADSERVER(363530L);
3001 VlEntry->serverNumber[j] = serverindex;
3002 VlEntry->serverPartition[j] = updateentry->RepsitesNewPart[i];
3003 if (updateentry->RepsitesNewFlags[i] < 0
3004 || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG0x80)
3005 return VL_BADSERVERFLAG(363545L);
3006 VlEntry->serverFlags[j] = updateentry->RepsitesNewFlags[i];
3007 }
3008 if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODSERV0x0400) {
3009/*n if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID)
3010 return VL_BADSERVER; */
3011 if ((j =
3012 repsite_exists(VlEntry,
3013 IpAddrToRelAddr(ctx, updateentry->
3014 RepsitesTargetServer[i],
3015 1),
3016 updateentry->RepsitesTargetPart[i])) !=
3017 -1) {
3018 VlEntry->serverNumber[j] =
3019 IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
3020 1);
3021 } else
3022 return VL_NOREPSERVER(363533L);
3023 }
3024 if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODPART0x0800) {
3025 if (updateentry->RepsitesNewPart[i] < 0
3026 || updateentry->RepsitesNewPart[i] > MAXPARTITIONID255)
3027 return VL_BADPARTITION(363531L);
3028 if ((j =
3029 repsite_exists(VlEntry,
3030 IpAddrToRelAddr(ctx, updateentry->
3031 RepsitesTargetServer[i],
3032 1),
3033 updateentry->RepsitesTargetPart[i])) !=
3034 -1)
3035 VlEntry->serverPartition[j] =
3036 updateentry->RepsitesNewPart[i];
3037 else
3038 return VL_NOREPSERVER(363533L);
3039 }
3040 if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODFLAG0x1000) {
3041 if ((j =
3042 repsite_exists(VlEntry,
3043 IpAddrToRelAddr(ctx, updateentry->
3044 RepsitesTargetServer[i],
3045 1),
3046 updateentry->RepsitesTargetPart[i])) !=
3047 -1) {
3048 if (updateentry->RepsitesNewFlags[i] < 0
3049 || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG0x80)
3050 return VL_BADSERVERFLAG(363545L);
3051 VlEntry->serverFlags[j] =
3052 updateentry->RepsitesNewFlags[i];
3053 } else
3054 return VL_NOREPSERVER(363533L);
3055 }
3056 }
3057 }
3058 return 0;
3059}
3060
3061
3062/* Check if the specified [server,partition] entry is found in the vldb
3063 * entry's repsite table; it's offset in the table is returned, if it's
3064 * present there. */
3065static int
3066repsite_exists(struct nvlentry *VlEntry, int server, int partition)
3067{
3068 int i;
3069
3070 for (i = 0; VlEntry->serverNumber[i] != BADSERVERID255 && i < OMAXNSERVERS8;
3071 i++) {
3072 if ((VlEntry->serverNumber[i] == server)
3073 && (VlEntry->serverPartition[i] == partition))
3074 return i;
3075 }
3076 return -1;
3077}
3078
3079
3080
3081/* Repsite table compression: used when deleting a repsite entry so that
3082 * all active repsite entries are on the top of the table. */
3083static void
3084repsite_compress(struct nvlentry *VlEntry, int offset)
3085{
3086 int repsite_offset = offset;
3087 for (;
3088 VlEntry->serverNumber[repsite_offset] != BADSERVERID255
3089 && repsite_offset < OMAXNSERVERS8 - 1; repsite_offset++) {
3090 VlEntry->serverNumber[repsite_offset] =
3091 VlEntry->serverNumber[repsite_offset + 1];
3092 VlEntry->serverPartition[repsite_offset] =
3093 VlEntry->serverPartition[repsite_offset + 1];
3094 VlEntry->serverFlags[repsite_offset] =
3095 VlEntry->serverFlags[repsite_offset + 1];
3096 }
3097 VlEntry->serverNumber[repsite_offset] = BADSERVERID255;
3098}
3099
3100
3101/* Convert from the internal (compacted) vldb entry to the external
3102 * representation used by the interface. */
3103static int
3104vlentry_to_vldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3105 struct vldbentry *VldbEntry)
3106{
3107 int i, j, code;
3108 struct extentaddr *exp;
3109
3110 memset(VldbEntry, 0, sizeof(struct vldbentry));
3111 strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3112 for (i = 0; i < OMAXNSERVERS8; i++) {
3113 if (VlEntry->serverNumber[i] == BADSERVERID255)
3114 break;
3115 j = VlEntry->serverNumber[i];
Value stored to 'j' is never read
3116 code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3117 if (code)
3118 return code;
3119 if (exp) {
3120 /* For now return the first ip address back */
3121 for (j = 0; j < VL_MAXIPADDRS_PERMH15; j++) {
3122 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[j]) {
3123 VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[j]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[j]));
3124 break;
3125 }
3126 }
3127 } else
3128 VldbEntry->serverNumber[i] =
3129 ctx->hostaddress[VlEntry->serverNumber[i]];
3130 VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3131 VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3132 }
3133 VldbEntry->nServers = i;
3134 for (i = 0; i < MAXTYPES3; i++)
3135 VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3136 VldbEntry->cloneId = VlEntry->cloneId;
3137 VldbEntry->flags = VlEntry->flags;
3138
3139 return 0;
3140}
3141
3142
3143/* Convert from the internal (compacted) vldb entry to the external
3144 * representation used by the interface. */
3145static int
3146vlentry_to_nvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3147 struct nvldbentry *VldbEntry)
3148{
3149 int i, j, code;
3150 struct extentaddr *exp;
3151
3152 memset(VldbEntry, 0, sizeof(struct nvldbentry));
3153 strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3154 for (i = 0; i < NMAXNSERVERS13; i++) {
3155 if (VlEntry->serverNumber[i] == BADSERVERID255)
3156 break;
3157 code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3158 if (code)
3159 return code;
3160
3161 if (exp) {
3162 /* For now return the first ip address back */
3163 for (j = 0; j < VL_MAXIPADDRS_PERMH15; j++) {
3164 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[j]) {
3165 VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[j]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[j]));
3166 break;
3167 }
3168 }
3169 } else
3170 VldbEntry->serverNumber[i] =
3171 ctx->hostaddress[VlEntry->serverNumber[i]];
3172 VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3173 VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3174 }
3175 VldbEntry->nServers = i;
3176 for (i = 0; i < MAXTYPES3; i++)
3177 VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3178 VldbEntry->cloneId = VlEntry->cloneId;
3179 VldbEntry->flags = VlEntry->flags;
3180
3181 return 0;
3182}
3183
3184static int
3185vlentry_to_uvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3186 struct uvldbentry *VldbEntry)
3187{
3188 int i, code;
3189 struct extentaddr *exp;
3190
3191 memset(VldbEntry, 0, sizeof(struct uvldbentry));
3192 strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3193 for (i = 0; i < NMAXNSERVERS13; i++) {
3194 if (VlEntry->serverNumber[i] == BADSERVERID255)
3195 break;
3196 VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3197 VldbEntry->serverUnique[i] = 0;
3198 code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3199 if (code)
3200 return code;
3201
3202 if (exp) {
3203 afsUUID tuuid;
3204
3205 tuuid = exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid;
3206 afs_ntohuuid(&tuuid);
3207 VldbEntry->serverFlags[i] |= VLSERVER_FLAG_UUID0x0010;
3208 VldbEntry->serverNumber[i] = tuuid;
3209 VldbEntry->serverUnique[i] = ntohl(exp->ex_uniquifier)(__builtin_constant_p(exp->_ex_un._ex_addrentry.uniquifier
) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.uniquifier))
>> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.
uniquifier)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.uniquifier)) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.uniquifier)) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.uniquifier));
3210 } else {
3211 VldbEntry->serverNumber[i].time_low =
3212 ctx->hostaddress[VlEntry->serverNumber[i]];
3213 }
3214 VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3215
3216 }
3217 VldbEntry->nServers = i;
3218 for (i = 0; i < MAXTYPES3; i++)
3219 VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3220 VldbEntry->cloneId = VlEntry->cloneId;
3221 VldbEntry->flags = VlEntry->flags;
3222
3223 return 0;
3224}
3225
3226#define LEGALCHARS".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
3227
3228
3229/* Verify that the volname is a valid volume name. */
3230static int
3231InvalidVolname(char *volname)
3232{
3233 char *map;
3234 int slen;
3235
3236 map = LEGALCHARS".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
3237 slen = strlen(volname);
3238 if (slen >= VL_MAXNAMELEN65)
3239 return 1;
3240 return (slen != strspn(volname, map));
3241}
3242
3243
3244/* Verify that the given volume type is valid. */
3245static int
3246InvalidVoltype(afs_int32 voltype)
3247{
3248 if (voltype != RWVOL0 && voltype != ROVOL1 && voltype != BACKVOL2)
3249 return 1;
3250 return 0;
3251}
3252
3253
3254static int
3255InvalidOperation(afs_int32 voloper)
3256{
3257 if (voloper != VLOP_MOVE0x10 && voloper != VLOP_RELEASE0x20
3258 && voloper != VLOP_BACKUP0x40 && voloper != VLOP_DELETE0x80
3259 && voloper != VLOP_DUMP0x100)
3260 return 1;
3261 return 0;
3262}
3263
3264static int
3265InvalidReleasetype(afs_int32 releasetype)
3266{
3267 if ((releasetype & LOCKREL_TIMESTAMP1) || (releasetype & LOCKREL_OPCODE2)
3268 || (releasetype & LOCKREL_AFSID4))
3269 return 0;
3270 return 1;
3271}
3272
3273static int
3274IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create)
3275{
3276 int i, j;
3277 afs_int32 code;
3278 struct extentaddr *exp;
3279
3280 for (i = 0; i <= MAXSERVERID254; i++) {
3281 if (ctx->hostaddress[i] == ipaddr)
3282 return i;
3283 code = multiHomedExtent(ctx, i, &exp);
3284 if (code)
3285 return -1;
3286 if (exp) {
3287 for (j = 0; j < VL_MAXIPADDRS_PERMH15; j++) {
3288 if (exp->ex_addrs_ex_un._ex_addrentry.addrs[j] && (ntohl(exp->ex_addrs[j])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[j]) ?
((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])) >>
24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[j])
) & (0xff << 16)) >> 8) | ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[j])) & (0xff << 8))
<< 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs
[j])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[j])) == ipaddr)) {
3289 return i;
3290 }
3291 }
3292 }
3293 }
3294
3295 /* allocate the new server a server id pronto */
3296 if (create) {
3297 for (i = 0; i <= MAXSERVERID254; i++) {
3298 if (ctx->cheader->IpMappedAddr[i] == 0) {
3299 ctx->cheader->IpMappedAddr[i] = htonl(ipaddr)(__builtin_constant_p(ipaddr) ? ((((__uint32_t)(ipaddr)) >>
24) | ((((__uint32_t)(ipaddr)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr)) << 24)) : __bswap32_var(ipaddr
));
3300 code =
3301 vlwrite(ctx->trans,
3302 DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[i])((0)+(((char *)(&ctx->cheader->IpMappedAddr[i])) - (
(char *)(ctx->cheader)))),
3303 (char *)&ctx->cheader->IpMappedAddr[i],
3304 sizeof(afs_int32));
3305 ctx->hostaddress[i] = ipaddr;
3306 if (code)
3307 return -1;
3308 return i;
3309 }
3310 }
3311 }
3312 return -1;
3313}
3314
3315static int
3316ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1, afs_uint32 ipaddr2)
3317{
3318 int i, j;
3319 afs_int32 code;
3320 struct extentaddr *exp = NULL((void *)0);
3321 int base;
3322 int mhidx;
3323 afsUUID tuuid;
3324 afs_int32 blockindex, count;
3325 int pollcount = 0;
3326 struct nvlentry tentry;
3327 int ipaddr1_id = -1, ipaddr2_id = -1;
3328
3329 /* Don't let addr change to 256.*.*.* : Causes internal error below */
3330 if ((ipaddr2 & 0xff000000) == 0xff000000)
3331 return (VL_BADSERVER(363530L));
3332
3333 /* If we are removing an address, ip1 will be -1 and ip2 will be
3334 * the original address. This prevents an older revision vlserver
3335 * from removing the IP address (won't find server 0xfffffff in
3336 * the VLDB). An older revision vlserver does not have the check
3337 * to see if any volumes exist on the server being removed.
3338 */
3339 if (ipaddr1 == 0xffffffff) {
3340 ipaddr1 = ipaddr2;
3341 ipaddr2 = 0;
3342 }
3343
3344 for (i = 0; i <= MAXSERVERID254; i++) {
3345 code = multiHomedExtentBase(ctx, i, &exp, &base);
3346 if (code)
3347 return code;
3348
3349 if (exp) {
3350 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH15; mhidx++) {
3351 if (!exp->ex_addrs_ex_un._ex_addrentry.addrs[mhidx])
3352 continue;
3353 if (ntohl(exp->ex_addrs[mhidx])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx])) == ipaddr1) {
3354 ipaddr1_id = i;
3355 }
3356 if (ipaddr2 != 0 && ntohl(exp->ex_addrs[mhidx])(__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx])) == ipaddr2) {
3357 ipaddr2_id = i;
3358 }
3359 }
3360 } else {
3361 if (ctx->hostaddress[i] == ipaddr1) {
3362 exp = NULL((void *)0);
3363 ipaddr1_id = i;
3364 }
3365 if (ipaddr2 != 0 && ctx->hostaddress[i] == ipaddr2) {
3366 ipaddr2_id = i;
3367 }
3368 }
3369
3370 if (ipaddr1_id >= 0 && (ipaddr2 == 0 || ipaddr2_id >= 0)) {
3371 /* we've either found both IPs already in the VLDB, or we found
3372 * ipaddr1, and we're not going to find ipaddr2 because it's 0 */
3373 break;
3374 }
3375 }
3376
3377 if (ipaddr1_id < 0) {
3378 return VL_NOENT(363524L); /* not found */
3379 }
3380
3381 if (ipaddr2_id >= 0 && ipaddr2_id != ipaddr1_id) {
3382 char buf1[16], buf2[16];
3383 VLog(0, ("Cannot change IP address from %s to %s because the latter "do { if ((0) <= LogLevel) (FSLog ("Cannot change IP address from %s to %s because the latter "
"is in use by server id %d\n", afs_inet_ntoa_r((__builtin_constant_p
(ipaddr1) ? ((((__uint32_t)(ipaddr1)) >> 24) | ((((__uint32_t
)(ipaddr1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ipaddr1)) & (0xff << 8)) << 8) | (((__uint32_t
)(ipaddr1)) << 24)) : __bswap32_var(ipaddr1)), buf1), afs_inet_ntoa_r
((__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2)), buf2), ipaddr2_id)); } while (0)
3384 "is in use by server id %d\n",do { if ((0) <= LogLevel) (FSLog ("Cannot change IP address from %s to %s because the latter "
"is in use by server id %d\n", afs_inet_ntoa_r((__builtin_constant_p
(ipaddr1) ? ((((__uint32_t)(ipaddr1)) >> 24) | ((((__uint32_t
)(ipaddr1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ipaddr1)) & (0xff << 8)) << 8) | (((__uint32_t
)(ipaddr1)) << 24)) : __bswap32_var(ipaddr1)), buf1), afs_inet_ntoa_r
((__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2)), buf2), ipaddr2_id)); } while (0)
3385 afs_inet_ntoa_r(htonl(ipaddr1), buf1),do { if ((0) <= LogLevel) (FSLog ("Cannot change IP address from %s to %s because the latter "
"is in use by server id %d\n", afs_inet_ntoa_r((__builtin_constant_p
(ipaddr1) ? ((((__uint32_t)(ipaddr1)) >> 24) | ((((__uint32_t
)(ipaddr1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ipaddr1)) & (0xff << 8)) << 8) | (((__uint32_t
)(ipaddr1)) << 24)) : __bswap32_var(ipaddr1)), buf1), afs_inet_ntoa_r
((__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2)), buf2), ipaddr2_id)); } while (0)
3386 afs_inet_ntoa_r(htonl(ipaddr2), buf2),do { if ((0) <= LogLevel) (FSLog ("Cannot change IP address from %s to %s because the latter "
"is in use by server id %d\n", afs_inet_ntoa_r((__builtin_constant_p
(ipaddr1) ? ((((__uint32_t)(ipaddr1)) >> 24) | ((((__uint32_t
)(ipaddr1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ipaddr1)) & (0xff << 8)) << 8) | (((__uint32_t
)(ipaddr1)) << 24)) : __bswap32_var(ipaddr1)), buf1), afs_inet_ntoa_r
((__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2)), buf2), ipaddr2_id)); } while (0)
3387 ipaddr2_id))do { if ((0) <= LogLevel) (FSLog ("Cannot change IP address from %s to %s because the latter "
"is in use by server id %d\n", afs_inet_ntoa_r((__builtin_constant_p
(ipaddr1) ? ((((__uint32_t)(ipaddr1)) >> 24) | ((((__uint32_t
)(ipaddr1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ipaddr1)) & (0xff << 8)) << 8) | (((__uint32_t
)(ipaddr1)) << 24)) : __bswap32_var(ipaddr1)), buf1), afs_inet_ntoa_r
((__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2)), buf2), ipaddr2_id)); } while (0);
3388 return VL_MULTIPADDR(363550L);
3389 }
3390
3391 /* If we are removing a server entry, a volume cannot
3392 * exist on the server. If one does, don't remove the
3393 * server entry: return error "volume entry exists".
3394 */
3395 if (ipaddr2 == 0) {
3396 for (blockindex = NextEntry(ctx, 0, &tentry, &count); blockindex;
3397 blockindex = NextEntry(ctx, blockindex, &tentry, &count)) {
3398 if (++pollcount > 50) {
3399#ifndef AFS_PTHREAD_ENV
3400 IOMGR_Poll();
3401#endif
3402 pollcount = 0;
3403 }
3404 for (j = 0; j < NMAXNSERVERS13; j++) {
3405 if (tentry.serverNumber[j] == BADSERVERID255)
3406 break;
3407 if (tentry.serverNumber[j] == ipaddr1_id) {
3408 return VL_IDEXIST(363520L);
3409 }
3410 }
3411 }
3412 }
3413
3414 /* Log a message saying we are changing/removing an IP address */
3415 VLog(0,do { if ((0) <= LogLevel) (FSLog ("The following IP address is being %s:\n"
, (ipaddr2 ? "changed" : "removed"))); } while (0)
3416 ("The following IP address is being %s:\n",do { if ((0) <= LogLevel) (FSLog ("The following IP address is being %s:\n"
, (ipaddr2 ? "changed" : "removed"))); } while (0)
3417 (ipaddr2 ? "changed" : "removed")))do { if ((0) <= LogLevel) (FSLog ("The following IP address is being %s:\n"
, (ipaddr2 ? "changed" : "removed"))); } while (0);
3418 VLog(0, (" entry %d: ", i))do { if ((0) <= LogLevel) (FSLog (" entry %d: ", i));
} while (0);
3419 if (exp) {
3420 VLog(0, ("["))do { if ((0) <= LogLevel) (FSLog ("[")); } while (0);
3421 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH15; mhidx++) {
3422 if (!exp->ex_addrs_ex_un._ex_addrentry.addrs[mhidx])
3423 continue;
3424 if (mhidx > 0)
3425 VLog(0, (" "))do { if ((0) <= LogLevel) (FSLog (" ")); } while (0);
3426 PADDR(ntohl(exp->ex_addrs[mhidx]))do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", ((__builtin_constant_p
(exp->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)
(exp->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | (
(((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx])) &
(0xff << 16)) >> 8) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 8)) <<
8) | (((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) << 24)) : __bswap32_var(exp->_ex_un._ex_addrentry
.addrs[mhidx]))>>24)&0xff, ((__builtin_constant_p(exp
->_ex_un._ex_addrentry.addrs[mhidx]) ? ((((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) >> 24) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
16)) >> 8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 8)) << 8) | (((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) :
__bswap32_var(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>
16)&0xff, ((__builtin_constant_p(exp->_ex_un._ex_addrentry
.addrs[mhidx]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) >> 24) | ((((__uint32_t)(exp->_ex_un
._ex_addrentry.addrs[mhidx])) & (0xff << 16)) >>
8) | ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) & (0xff << 8)) << 8) | (((__uint32_t)(exp
->_ex_un._ex_addrentry.addrs[mhidx])) << 24)) : __bswap32_var
(exp->_ex_un._ex_addrentry.addrs[mhidx]))>>8) &0xff
, (__builtin_constant_p(exp->_ex_un._ex_addrentry.addrs[mhidx
]) ? ((((__uint32_t)(exp->_ex_un._ex_addrentry.addrs[mhidx
])) >> 24) | ((((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) & (0xff << 16)) >> 8) | ((((__uint32_t
)(exp->_ex_un._ex_addrentry.addrs[mhidx])) & (0xff <<
8)) << 8) | (((__uint32_t)(exp->_ex_un._ex_addrentry
.addrs[mhidx])) << 24)) : __bswap32_var(exp->_ex_un.
_ex_addrentry.addrs[mhidx]))&0xff)); } while (0);;
3427 }
3428 VLog(0, ("]"))do { if ((0) <= LogLevel) (FSLog ("]")); } while (0);
3429 } else {
3430 PADDR(ipaddr1)do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (ipaddr1>>
24)&0xff, (ipaddr1>>16)&0xff, (ipaddr1>>8
) &0xff, ipaddr1&0xff)); } while (0);;
3431 }
3432 if (ipaddr2) {
3433 VLog(0, (" -> "))do { if ((0) <= LogLevel) (FSLog (" -> ")); } while (0);
3434 PADDR(ipaddr2)do { if ((0) <= LogLevel) (FSLog ("%d.%d.%d.%d", (ipaddr2>>
24)&0xff, (ipaddr2>>16)&0xff, (ipaddr2>>8
) &0xff, ipaddr2&0xff)); } while (0);;
3435 }
3436 VLog(0, ("\n"))do { if ((0) <= LogLevel) (FSLog ("\n")); } while (0);
3437
3438 /* Change the registered uuuid addresses */
3439 if (exp) {
3440 memset(&tuuid, 0, sizeof(afsUUID));
3441 afs_htonuuid(&tuuid);
3442 exp->ex_hostuuid_ex_un._ex_addrentry.hostuuid = tuuid;
3443 code =
3444 vlwrite(ctx->trans,
3445 DOFFSET(ntohl(ctx->ex_addr[0]->ex_contaddrs[base]),(((__builtin_constant_p(ctx->ex_addr[0]->_ex_un._ex_header
.contaddrs[base]) ? ((((__uint32_t)(ctx->ex_addr[0]->_ex_un
._ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(
ctx->ex_addr[0]->_ex_un._ex_header.contaddrs[base])) &
(0xff << 16)) >> 8) | ((((__uint32_t)(ctx->ex_addr
[0]->_ex_un._ex_header.contaddrs[base])) & (0xff <<
8)) << 8) | (((__uint32_t)(ctx->ex_addr[0]->_ex_un
._ex_header.contaddrs[base])) << 24)) : __bswap32_var(ctx
->ex_addr[0]->_ex_un._ex_header.contaddrs[base])))+(((char
*)((char *)exp)) - ((char *)((char *)ctx->ex_addr[base]))
))
3446 (char *)ctx->ex_addr[base], (char *)exp)(((__builtin_constant_p(ctx->ex_addr[0]->_ex_un._ex_header
.contaddrs[base]) ? ((((__uint32_t)(ctx->ex_addr[0]->_ex_un
._ex_header.contaddrs[base])) >> 24) | ((((__uint32_t)(
ctx->ex_addr[0]->_ex_un._ex_header.contaddrs[base])) &
(0xff << 16)) >> 8) | ((((__uint32_t)(ctx->ex_addr
[0]->_ex_un._ex_header.contaddrs[base])) & (0xff <<
8)) << 8) | (((__uint32_t)(ctx->ex_addr[0]->_ex_un
._ex_header.contaddrs[base])) << 24)) : __bswap32_var(ctx
->ex_addr[0]->_ex_un._ex_header.contaddrs[base])))+(((char
*)((char *)exp)) - ((char *)((char *)ctx->ex_addr[base]))
)),
3447 (char *)&tuuid, sizeof(tuuid));
3448 if (code)
3449 return VL_IO(363521L);
3450 }
3451
3452 /* Now change the host address entry */
3453 ctx->cheader->IpMappedAddr[ipaddr1_id] = htonl(ipaddr2)(__builtin_constant_p(ipaddr2) ? ((((__uint32_t)(ipaddr2)) >>
24) | ((((__uint32_t)(ipaddr2)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ipaddr2)) & (0xff << 8)) <<
8) | (((__uint32_t)(ipaddr2)) << 24)) : __bswap32_var(
ipaddr2));
3454 code =
3455 vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[ipaddr1_id])((0)+(((char *)(&ctx->cheader->IpMappedAddr[ipaddr1_id
])) - ((char *)(ctx->cheader)))),
3456 (char *)
3457 &ctx->cheader->IpMappedAddr[ipaddr1_id], sizeof(afs_int32));
3458 ctx->hostaddress[ipaddr1_id] = ipaddr2;
3459 if (code)
3460 return VL_IO(363521L);
3461
3462 return 0;
3463}
3464
3465/* see if the vlserver is back yet */
3466afs_int32
3467SVL_ProbeServer(struct rx_call *rxcall)
3468{
3469 return 0;
3470}