HCoop / hcoop / debian / openafs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
backport to buster
[hcoop/debian/openafs.git] / src / vlserver / vlclient.c
CommitLineData
805e021f
CE		 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#include <afs/stds.h>
13
14#include <roken.h>
15
16#ifdef AFS_NT40_ENV
17#include <WINNT/afsevent.h>
18#endif
19#ifdef HAVE_SYS_FILE_H
20#include <sys/file.h>
21#endif
22#include <ctype.h>
23
24#include <afs/afsutil.h>
25#include <rx/xdr.h>
26#include <rx/rx.h>
27#include <rx/rx_globals.h>
28#include <rx/rxkad.h>
29#include <afs/cellconfig.h>
30#include <afs/keys.h>
31#include <afs/cmd.h>
32#include <lock.h>
33#include <ubik.h>
34
35#include "vlserver.h"
36
37void fill_listattributes_entry(struct VldbListByAttributes *, char **, int);
38void display_listattributes_entry(struct VldbListByAttributes *,int);
39void display_entry(struct vldbentry *, int);
40void display_entryN(struct nvldbentry *, int);
41void display_update_entry(struct VldbUpdateEntry *, int);
42void dump_stats(vldstats *, vital_vlheader *);
43void GetArgs(char *, char **, int *);
44void print_usage(void);
45void fill_entry(struct vldbentry *, char **, int);
46void fill_update_entry(struct VldbUpdateEntry *, char **, int);
47
48#define VL_NUMBER_OPCODESX 34
49static char *opcode_names[VL_NUMBER_OPCODESX] = {
50 "CreateEntry",
51 "DeleteEntry",
52 "GetEntryByID",
53 "GetEntryByName",
54 "GetNewVolumeId",
55 "ReplaceEntry",
56 "UpdateEntry",
57 "SetLock",
58 "ReleaseLock",
59 "ListEntry",
60 "ListAttributes",
61 "LinkedList",
62 "GetStats",
63 "Probe", /* RPC is ProbeServer */
64 "GetAddrs",
65 "ChangeAddr",
66 "CreateEntryN",
67 "GetEntryByIDN",
68 "GetEntryByNameN",
69 "ReplaceEntryN",
70 "ListEntryN",
71 "ListAttributesN",
72 "LinkedListN",
73 "UpdateeEntryByName",
74 "CreateEntryU",
75 "GetEntryByIDU",
76 "GetEntryByNameU",
77 "ReplaceEntryU",
78 "ListEntryU",
79 "ListAttributesU",
80 "LinkedListU",
81 "RegisterAddr",
82 "GetAddrsU",
83 "ListAttributesN2"
84};
85
86struct Vlent {
87 struct Vlent *next;
88 afs_int32 rwid;
89 afs_int32 roid;
90 afs_int32 baid;
91 char name[64];
92};
93
94#define NVOLS 1000
95#define ALLOCNT 50000
96struct Vlent *VLa[NVOLS];
97#define VHash(avol) ((avol)&(NVOLS-1))
98struct Vlent *VL, *SVL;
99int VLcnt = 0;
100struct ubik_client *cstruct;
101struct rx_connection *serverconns[MAXSERVERS];
102char confdir[AFSDIR_PATH_MAX];
103char *(args[50]);
104
105struct Vlent *
106GetVolume(int vol, struct vldbentry *entry)
107{
108 int i;
109 struct Vlent *vl;
110
111 if (!vol)
112 return NULL;
113 i = VHash(vol);
114 for (vl = VLa[i]; vl; vl = vl->next) {
115 if ((vl->rwid == vol && vol != entry->volumeId[0])
116 || (vl->roid == vol && vol != entry->volumeId[1])
117 || (vl->baid == vol && vol != entry->volumeId[2])) {
118 return vl;
119 }
120 }
121 VL->rwid = entry->volumeId[0];
122 VL->roid = entry->volumeId[1];
123 VL->baid = entry->volumeId[2];
124 strcpy(entry->name, VL->name);
125 VL->next = VLa[i];
126 VLa[i] = VL;
127 if (VLcnt++ > ALLOCNT) { /* XXXX FIX XXXXXXXXX */
128 printf("Too many entries (> %d)\n", ALLOCNT);
129 exit(1);
130 }
131 VL++;
132 return NULL;
133}
134
135/* Almost identical's to pr_Initialize in vlserver/pruser.c */
136afs_int32
137vl_Initialize(char *confDir, int secFlags, int server, char *cellp)
138{
139 return ugen_ClientInitServer(confDir, cellp, secFlags, &cstruct,
140 MAXSERVERS, AFSCONF_VLDBSERVICE, 90,
141 server, htons(AFSCONF_VLDBPORT));
142}
143
144/* return host address in network byte order */
145afs_int32
146GetServer(char *aname)
147{
148 struct hostent *th;
149 afs_uint32 addr;
150 int b1, b2, b3, b4;
151 afs_int32 code;
152
153 code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
154 if (code == 4) {
155 addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
156 return htonl(addr); /* convert to network order (128 in byte 0) */
157 }
158 th = gethostbyname(aname);
159 if (!th)
160 return 0;
161 memcpy(&addr, th->h_addr, sizeof(addr));
162 return addr;
163}
164
165
166static int
167handleit(struct cmd_syndesc *as, void *arock)
168{
169 struct cmd_item *ti;
170 afs_int32 code, server = 0, sawserver = 0;
171 afs_int32 id, voltype;
172 struct vldbentry entry;
173 char *cellp = 0;
174 struct VldbUpdateEntry updateentry;
175 struct VldbListByAttributes listbyattributes;
176 int secFlags = AFSCONF_SECOPTS_FALLBACK_NULL;
177
178 if ((ti = as->parms[0].items)) /* -cellpath <dir> */
179 strcpy(confdir, ti->data);
180 if (as->parms[1].items) /* -server */
181 strcpy(confdir, AFSDIR_SERVER_ETC_DIRPATH);
182 if (as->parms[2].items) /* -noauth */
183 secFlags |= AFSCONF_SECOPTS_NOAUTH;
184 if ((ti = as->parms[3].items)) { /* -host */
185 server = GetServer(ti->data);
186 if (server == 0) {
187 printf("server '%s' not found in host table\n", ti->data);
188 exit(1);
189 }
190 sawserver = 1;
191 }
192 if (sawserver && !as->parms[2].items && (!(ti = as->parms[4].items))) {
193 printf
194 ("Must also specify the -cell' option along with -host for authenticated conns\n");
195 exit(1);
196 }
197 if ((ti = as->parms[4].items)) { /* -cell */
198 cellp = ti->data;
199 }
200 if ((code = vl_Initialize(confdir, secFlags, server, cellp))) {
201 printf("Couldn't initialize vldb library (code=%d).\n", code);
202 exit(1);
203 }
204
205 if (as->parms[6].items) { /* -probe */
206 int nconns = 0;
207 int status = 0;
208 int i;
209 char hoststr[16];
210 afs_uint32 addr;
211
212 for (i = 0; cstruct->conns[i]; i++, nconns++) {
213 rx_SetConnDeadTime(cstruct->conns[i], 6);
214 addr = rx_HostOf(rx_PeerOf(cstruct->conns[i]));
215 if (!nconns) {
216 printf("probing");
217 }
218 printf(" %s", afs_inet_ntoa_r(addr, hoststr));
219 }
220 if (nconns == 0) {
221 printf("no connections\n");
222 return 255;
223 }
224 printf("\n");
225 multi_Rx(cstruct->conns, nconns) {
226 multi_VL_ProbeServer();
227 addr = rx_HostOf(rx_PeerOf(cstruct->conns[multi_i]));
228 if (!multi_error) {
229 printf(" ok: %s\n", afs_inet_ntoa_r(addr, hoststr));
230 } else {
231 status = 255;
232 printf(" not ok (%d): %s\n", multi_error,
233 afs_inet_ntoa_r(addr, hoststr));
234 }
235 }
236 multi_End;
237 return status;
238 }
239
240 if (as->parms[5].items) { /* -getstats */
241 vldstats stats;
242 vital_vlheader vital_header;
243 code = ubik_VL_GetStats(cstruct, 0, &stats, &vital_header);
244 if (!code)
245 dump_stats(&stats, &vital_header);
246 exit(0);
247 }
248
249 while (1) {
250 char line[500];
251 int nargs, releasetype;
252 memset(&entry, 0, sizeof(entry));
253 memset(&updateentry, 0, sizeof(updateentry));
254 memset(&listbyattributes, 0, sizeof(listbyattributes));
255 printf("vl> ");
256 if (fgets(line, 499, stdin) == NULL) {
257 printf("\n");
258 exit(0);
259 } else {
260 char *oper, *vname;
261 char **argp = args;
262
263 GetArgs(line, argp, &nargs);
264 oper = &argp[0][0];
265 ++argp, --nargs;
266 if (!*line) {
267 } else if (!strcmp(oper, "cr")) {
268 fill_entry(&entry, argp, nargs);
269 display_entry(&entry, 0);
270 code = ubik_VL_CreateEntry(cstruct, 0, &entry);
271 printf("return code is %d\n", code);
272 } else if (!strcmp(oper, "rm")) {
273 sscanf(&(*argp)[0], "%d", &id);
274 ++argp, --nargs;
275 sscanf(&(*argp)[0], "%d", &voltype);
276 code = ubik_VL_DeleteEntry(cstruct, 0, id, voltype);
277 printf("return code is %d\n", code);
278 } else if (!strcmp(oper, "re")) {
279 sscanf(&(*argp)[0], "%d", &id);
280 ++argp, --nargs;
281 sscanf(&(*argp)[0], "%d", &voltype);
282 ++argp, --nargs;
283 sscanf(&(*argp)[0], "%d", &releasetype);
284 ++argp, --nargs;
285 fill_entry(&entry, argp, nargs);
286 display_entry(&entry, 0);
287 code =
288 ubik_VL_ReplaceEntry(
289 cstruct, 0, id, voltype,
290 &entry, releasetype);
291 printf("return code is %d\n", code);
292 } else if (!strcmp(oper, "up")) {
293 sscanf(&(*argp)[0], "%d", &id);
294 ++argp, --nargs;
295 sscanf(&(*argp)[0], "%d", &voltype);
296 ++argp, --nargs;
297 sscanf(&(*argp)[0], "%d", &releasetype);
298 ++argp, --nargs;
299 fill_update_entry(&updateentry, argp, nargs);
300 display_update_entry(&updateentry, 0);
301 code =
302 ubik_VL_UpdateEntry(cstruct, 0, id, voltype,
303 &updateentry, releasetype);
304 printf("return code is %d\n", code);
305 } else if (!strcmp(oper, "ls")) {
306 afs_int32 index, count, next_index;
307 for (index = 0; 1; index = next_index) {
308 memset(&entry, 0, sizeof(entry));
309 code =
310 ubik_VL_ListEntry(cstruct, 0, index, &count,
311 &next_index, &entry);
312 if (code) {
313 printf("VL_ListEntry returned code = %d\n", code);
314 break;
315 }
316 if (!next_index)
317 break;
318 display_entry(&entry, 0);
319 }
320 } else if (!strcmp(oper, "ldups")) {
321 afs_int32 index, count, num = 0, num1 = 0, next_index;
322 struct Vlent *vl1;
323
324 VL = SVL = malloc(ALLOCNT * sizeof(struct Vlent));
325 if (VL == NULL) {
326 printf("Can't allocate memory...\n");
327 exit(1);
328 }
329 printf("Enumerating all entries in vldb...\n");
330 for (index = 0; 1; index = next_index) {
331 memset(&entry, 0, sizeof(entry));
332 code =
333 ubik_VL_ListEntry(cstruct, 0, index, &count,
334 &next_index, &entry);
335 if (code) {
336 printf("VL_ListEntry returned code = %d\n", code);
337 break;
338 }
339 if (!next_index)
340 break;
341 num++;
342 if ((vl1 = GetVolume(entry.volumeId[0], &entry))) {
343 num1++;
344 printf
345 ("Duplicate entry is found for RW vol %u: [RW %u, RO %u, BA %u, name=%s]\n",
346 entry.volumeId[0], vl1->rwid, vl1->roid,
347 vl1->baid, vl1->name);
348 }
349 if ((vl1 = GetVolume(entry.volumeId[1], &entry))) {
350 num1++;
351 printf
352 ("Duplicate entry is found for RO vol %u: [RW %u, RO %u, BA %u, name=%s]\n",
353 entry.volumeId[1], vl1->rwid, vl1->roid,
354 vl1->baid, vl1->name);
355 }
356 if ((vl1 = GetVolume(entry.volumeId[2], &entry))) {
357 num1++;
358 printf
359 ("Duplicate entry is found for BA vol %u: [RW %u, RO %u, BA %u, name=%s]\n",
360 entry.volumeId[2], vl1->rwid, vl1->roid,
361 vl1->baid, vl1->name);
362 }
363 /*display_entry(&entry, 0); */
364 }
365 printf("(%d vldb entries found - %d duplicates)\n", num,
366 num1);
367 } else if (!strcmp(oper, "checkhash")) {
368 int index, count, num = 0, num1 = 0, num2 = 0, num3 =
369 0, num31 = 0, num4 = 0, num41 = 0, next_index;
370 struct vldbentry tentry;
371
372 VL = SVL = malloc(ALLOCNT * sizeof(struct Vlent));
373 if (VL == NULL) {
374 printf("Can't allocate memory...\n");
375 exit(1);
376 }
377 printf("Volumes not found in main hash tables in vldb...\n");
378 for (index = 0; 1; index = next_index) {
379 memset(&entry, 0, sizeof(entry));
380 code =
381 ubik_VL_ListEntry(cstruct, 0, index, &count,
382 &next_index, &entry);
383 if (code) {
384 printf("VL_ListEntry returned code = %d\n", code);
385 break;
386 }
387 if (!next_index)
388 break;
389 num++;
390 code =
391 ubik_VL_GetEntryByNameO(cstruct, 0, entry.name,
392 &tentry);
393 if (code == VL_NOENT) {
394 num1++;
395 printf("\tVolume %s %d (not in namehash)\n",
396 entry.name, entry.volumeId[RWVOL]);
397 }
398 code =
399 ubik_VL_GetEntryByID(cstruct, 0,
400 entry.volumeId[RWVOL], RWVOL, &tentry);
401 if (code == VL_NOENT) {
402 num2++;
403 printf("\tVolume %s %d (not in rwid hash)\n",
404 entry.name, entry.volumeId[RWVOL]);
405 }
406 if (entry.volumeId[BACKVOL]) {
407 code =
408 ubik_VL_GetEntryByID(cstruct, 0,
409 entry.volumeId[BACKVOL], BACKVOL,
410 &tentry);
411 num31++;
412 if (code == VL_NOENT) {
413 num3++;
414 printf("\tVolume %s %d (not in backup id hash)\n",
415 entry.name, entry.volumeId[BACKVOL]);
416 }
417 }
418 if (entry.volumeId[ROVOL]) {
419 code =
420 ubik_VL_GetEntryByID(cstruct, 0,
421 entry.volumeId[ROVOL], ROVOL, &tentry);
422 num41++;
423 if (code == VL_NOENT) {
424 num4++;
425 printf("\tVolume %s %d (not in RO id hash)\n",
426 entry.name, entry.volumeId[ROVOL]);
427 }
428 }
429 }
430 printf
431 ("\nTotal vldb entries %d\nTotal volumes %d (%d rw, %d backup, %d ro)\n",
432 num, num + num31 + num41, num, num31, num41);
433 printf
434 ("\n\t%d didn't hash properly by name\n\t%d didn't hash properly by rw volid\n",
435 num1, num2);
436 printf
437 ("\t%d didn't hash properly by backup volid (out of %d)\n\t%d didn't hash properly by ro volid (out of %d)\n",
438 num3, num31, num4, num41);
439 } else if (!strcmp(oper, "fixhash")) {
440 int index, count, num = 0, num1 = 0, num2 = 0, next_index, x =
441 0;
442 struct vldbentry tentry;
443
444 VL = SVL = malloc(ALLOCNT * sizeof(struct Vlent));
445 if (VL == NULL) {
446 printf("Can't allocate memory...\n");
447 exit(1);
448 }
449 printf
450 ("Volumes not found in main hash tables in vldb will be fixed...\n");
451 memset(&updateentry, 0, sizeof(updateentry));
452 for (index = 0; 1; index = next_index) {
453 memset(&entry, 0, sizeof(entry));
454 code =
455 ubik_VL_ListEntry(cstruct, 0, index, &count,
456 &next_index, &entry);
457 if (code) {
458 printf("VL_ListEntry returned code = %d\n", code);
459 break;
460 }
461 if (!next_index)
462 break;
463 num++;
464 code =
465 ubik_VL_GetEntryByNameO(cstruct, 0, entry.name,
466 &tentry);
467 if (code == VL_NOENT) {
468 num1++;
469 updateentry.Mask = VLUPDATE_VOLNAMEHASH;
470 printf("\tVolume %s %d (not in namehash)\n",
471 entry.name, entry.volumeId[RWVOL]);
472 code =
473 ubik_VL_UpdateEntry(cstruct, 0,
474 entry.volumeId[RWVOL], -1, &updateentry,
475 0);
476 if (code) {
477 x++;
478 printf("\tFailed to update volume %s (err=%d)\n",
479 entry.name, code);
480 }
481 }
482 code =
483 ubik_VL_GetEntryByID(cstruct, 0,
484 entry.volumeId[RWVOL], RWVOL, &tentry);
485 if (code == VL_NOENT) {
486 num1++;
487 num2++;
488 updateentry.Mask = VLUPDATE_RWID;
489 updateentry.spares3 = entry.volumeId[RWVOL];
490 printf("\tVolume %s %d (not in rw id hash)\n",
491 entry.name, entry.volumeId[RWVOL]);
492 code =
493 ubik_VL_UpdateEntryByName(cstruct, 0,
494 entry.name, &updateentry, 0);
495 if (code) {
496 printf("\tFailed to update volume %s (err=%d)\n",
497 entry.name, code);
498 x++;
499 }
500 x++;
501 }
502 if (entry.volumeId[BACKVOL]) {
503 code =
504 ubik_VL_GetEntryByID(cstruct, 0,
505 entry.volumeId[BACKVOL], BACKVOL,
506 &tentry);
507 if (code == VL_NOENT) {
508 num1++;
509 updateentry.Mask = VLUPDATE_BACKUPID;
510 updateentry.BackupId = entry.volumeId[BACKVOL];
511 printf("\tVolume %s %d (not in backup id hash)\n",
512 entry.name, entry.volumeId[BACKVOL]);
513 code =
514 ubik_VL_UpdateEntry(cstruct, 0,
515 entry.volumeId[RWVOL], -1,
516 &updateentry, 0);
517 if (code) {
518 printf
519 ("\tFailed to update volume %s (err=%d)\n",
520 entry.name, code);
521 x++;
522 }
523 }
524 }
525 if (entry.volumeId[ROVOL]) {
526 code =
527 ubik_VL_GetEntryByID(cstruct, 0,
528 entry.volumeId[ROVOL], ROVOL, &tentry);
529 if (code == VL_NOENT) {
530 num1++;
531 updateentry.Mask = VLUPDATE_READONLYID;
532 updateentry.ReadOnlyId = entry.volumeId[ROVOL];
533 printf("\tVolume %s %d (not in RO id hash)\n",
534 entry.name, entry.volumeId[ROVOL]);
535 code =
536 ubik_VL_UpdateEntry(cstruct, 0,
537 entry.volumeId[RWVOL], -1,
538 &updateentry, 0);
539 if (code) {
540 printf
541 ("\tFailed to update volume %s (err=%d)\n",
542 entry.name, code);
543 x++;
544 }
545 }
546 }
547 }
548 printf
549 ("\nTotal vldb entries found %d:\n\t%d entries didn't hash properly and are fixed except %d that need to be handled manually\n",
550 num, num1, x);
551 } else if (!strcmp(oper, "la")) {
552 int nentries = 0, i;
553 bulkentries entries;
554 struct vldbentry *entry;
555
556 memset(&entries, 0, sizeof(entries));
557 fill_listattributes_entry(&listbyattributes, argp, nargs);
558 display_listattributes_entry(&listbyattributes, 0);
559 code =
560 ubik_VL_ListAttributes(cstruct, 0,
561 &listbyattributes, &nentries, &entries);
562 if (code) {
563 printf("VL_ListAttributes returned code = %d\n", code);
564 continue;
565 }
566 entry = (struct vldbentry *)entries.bulkentries_val;
567 for (i = 0; i < nentries; i++, entry++)
568 display_entry(entry, 0);
569 if (entries.bulkentries_val)
570 free(entries.bulkentries_val);
571 } else if (!strcmp(oper, "lan2")) {
572 int nentries, i, si, nsi, t = 0;
573 nbulkentries entries;
574 struct nvldbentry *entry;
575 char name[64];
576
577 /* The volume name to search for (supports wildcarding) */
578 if (nargs > 0) {
579 strcpy(name, argp[0]);
580 ++argp, --nargs;
581 } else {
582 strcpy(name, "");
583 }
584
585 fill_listattributes_entry(&listbyattributes, argp, nargs);
586 display_listattributes_entry(&listbyattributes, 0);
587 printf("Wildcard VolName: '%s'\n", name);
588
589 for (si = 0; si != -1; si = nsi) {
590 nentries = 0;
591 memset(&entries, 0, sizeof(entries));
592 code =
593 ubik_VL_ListAttributesN2(cstruct, 0,
594 &listbyattributes, name, si, &nentries,
595 &entries, &nsi);
596 if (code) {
597 printf("VL_ListAttributesN2 returned code = %d\n",
598 code);
599 break;
600 }
601
602 t += nentries;
603 entry = (struct nvldbentry *)entries.nbulkentries_val;
604 for (i = 0; i < nentries; i++, entry++)
605 display_entryN(entry, 0);
606 if (entries.nbulkentries_val)
607 free(entries.nbulkentries_val);
608 }
609 printf("--- %d volumes ---\n", t);
610 } else if (!strcmp(oper, "ln")) {
611 int netries;
612 vldb_list linkedvldbs;
613 vldblist vllist, vllist1;
614
615 fill_listattributes_entry(&listbyattributes, argp, nargs);
616 display_listattributes_entry(&listbyattributes, 0);
617 memset(&linkedvldbs, 0, sizeof(vldb_list));
618 code =
619 ubik_VL_LinkedList(cstruct, 0, &listbyattributes,
620 &netries, &linkedvldbs);
621 if (code) {
622 printf("VL_LinkedList returned code = %d\n", code);
623 continue;
624 }
625 printf("Found %d entr%s\n", netries,
626 (netries == 1 ? "y" : "ies"));
627 for (vllist = linkedvldbs.node; vllist; vllist = vllist1) {
628 vllist1 = vllist->next_vldb;
629 display_entry((struct vldbentry *) &vllist->VldbEntry, 0);
630 free(vllist);
631 }
632 } else if (!strcmp(oper, "lnn")) {
633 int netries;
634 nvldb_list linkedvldbs;
635 nvldblist vllist, vllist1;
636
637 fill_listattributes_entry(&listbyattributes, argp, nargs);
638 display_listattributes_entry(&listbyattributes, 0);
639 memset(&linkedvldbs, 0, sizeof(vldb_list));
640 code =
641 ubik_VL_LinkedListN(cstruct, 0, &listbyattributes,
642 &netries, &linkedvldbs);
643 if (code) {
644 printf("VL_LinkedList returned code = %d\n", code);
645 continue;
646 }
647 printf("Found %d entr%s\n", netries,
648 (netries == 1 ? "y" : "ies"));
649 for (vllist = linkedvldbs.node; vllist; vllist = vllist1) {
650 vllist1 = vllist->next_vldb;
651 display_entry((struct vldbentry *)&vllist->VldbEntry, 0);
652 free(vllist);
653 }
654 } else if (!strcmp(oper, "di")) {
655 sscanf(&(*argp)[0], "%d", &id);
656 ++argp, --nargs;
657 sscanf(&(*argp)[0], "%d", &voltype);
658 code =
659 ubik_VL_GetEntryByID(cstruct, 0, id, voltype,
660 &entry);
661 display_entry(&entry, code);
662 printf("return code is %d.\n", code);
663 } else if (!strcmp(oper, "rmnh")) {
664 sscanf(&(*argp)[0], "%d", &id);
665 ++argp, --nargs;
666 sscanf(&(*argp)[0], "%d", &voltype);
667 code =
668 ubik_VL_GetEntryByID(cstruct, 0, id, voltype,
669 &entry);
670 display_entry(&entry, code);
671 memset(&updateentry, 0, sizeof(updateentry));
672 updateentry.Mask = VLUPDATE_VOLNAMEHASH;
673 printf("\tRehashing namehash table for %s (%d)\n", entry.name,
674 entry.volumeId[RWVOL]);
675 code =
676 ubik_VL_UpdateEntry(cstruct, 0,
677 entry.volumeId[RWVOL], -1, &updateentry, 0);
678 if (code) {
679 printf("\tFailed to update volume %s (err=%d)\n",
680 entry.name, code);
681 }
682 printf("return code is %d.\n", code);
683 } else if (!strcmp(oper, "undelete")) {
684 afs_int32 index, count, next_index;
685
686 memset(&updateentry, 0, sizeof(updateentry));
687 sscanf(&(*argp)[0], "%d", &id);
688 ++argp, --nargs;
689 sscanf(&(*argp)[0], "%d", &voltype);
690 if (voltype < 0 || voltype > 2) {
691 printf("Illegal voltype; must be 0, 1 or 2\n");
692 continue;
693 }
694 printf("Searching vldb for volume %d...\n", id);
695 for (index = 0; 1; index = next_index) {
696 memset(&entry, 0, sizeof(entry));
697 code =
698 ubik_VL_ListEntry(cstruct, 0, index, &count,
699 &next_index, &entry);
700 if (code) {
701 printf("VL_ListEntry returned code = %d\n", code);
702 break;
703 }
704 if (!next_index)
705 break;
706 if (entry.volumeId[voltype] == id) {
707 printf("\nThe current contents of the vldb for %d:\n",
708 id);
709 display_entry(&entry, 0);
710
711 if (entry.flags & VLDELETED) {
712 updateentry.Mask = VLUPDATE_FLAGS;
713 updateentry.flags = entry.flags;
714 updateentry.flags &= ~VLDELETED;
715 printf
716 ("\tUndeleting vldb entry for vol %d (%s)\n",
717 id, entry.name);
718 code =
719 ubik_VL_UpdateEntry(cstruct, 0, id, -1,
720 &updateentry, 0);
721 if (code) {
722 printf
723 ("\tFailed to update volume %s (err=%d)\n",
724 entry.name, code);
725 }
726 } else {
727 printf("Entry not deleted; ignored\n");
728 }
729 break;
730 }
731 }
732 } else if (!strcmp(oper, "dn")) {
733 vname = &argp[0][0];
734 code =
735 ubik_VL_GetEntryByNameO(cstruct, 0, vname, &entry);
736 display_entry(&entry, code);
737 printf("return code is %d.\n", code);
738 } else if (!strcmp(oper, "nv")) {
739 unsigned int newvolid;
740 sscanf(&(*argp)[0], "%d", &id);
741 code =
742 ubik_VL_GetNewVolumeId(cstruct, 0, id, &newvolid);
743 if (!code)
744 printf("Current Max volid is (in hex):0x%x\n", newvolid);
745 printf("return code is %d\n", code);
746 } else if (!strcmp(oper, "gs")) {
747 vldstats stats;
748 vital_vlheader vital_header;
749 code =
750 ubik_VL_GetStats(cstruct, 0, &stats, &vital_header);
751 if (!code)
752 dump_stats(&stats, &vital_header);
753 printf("return code is %d.\n", code);
754 } else if (!strcmp(oper, "ga")) {
755 int nentries, i;
756 afs_uint32 *addrp;
757 bulkaddrs addrs;
758 struct VLCallBack vlcb;
759
760 addrs.bulkaddrs_val = 0;
761 addrs.bulkaddrs_len = 0;
762 code = ubik_VL_GetAddrs(cstruct, 0, 0 /*Handle */ ,
763 0 /*spare2 */ , &vlcb,
764 &nentries, &addrs);
765 if (code) {
766 printf("VL_GetAddrs returned code = %d\n", code);
767 continue;
768 }
769 addrp = addrs.bulkaddrs_val;
770 for (i = 0; i < nentries; i++, addrp++) {
771 if ((*addrp & 0xff000000) == 0xff000000)
772 printf("[0x%x %u] (special multi-homed entry)\n",
773 *addrp, *addrp);
774 else
775 printf("[0x%x %u] %s\n", *addrp, *addrp,
776 hostutil_GetNameByINet(ntohl(*addrp)));
777 }
778 free(addrs.bulkaddrs_val);
779 } else if (!strcmp(oper, "gau")) {
780 int nentries, i, j;
781 afs_uint32 *addrp;
782 bulkaddrs addrs;
783 struct VLCallBack vlcb;
784
785 addrs.bulkaddrs_val = 0;
786 addrs.bulkaddrs_len = 0;
787 code = ubik_VL_GetAddrs(cstruct, 0, 0 /*Handle */ ,
788 0 /*spare2 */ , &vlcb,
789 &nentries, &addrs);
790 if (code) {
791 printf("VL_GetAddrs returned code = %d\n", code);
792 continue;
793 }
794 addrp = addrs.bulkaddrs_val;
795 for (i = 0; i < nentries; i++, addrp++) {
796 if ((*addrp & 0xff000000) == 0xff000000) {
797 int mhnentries, unique;
798 struct in_addr hostAddr;
799 afs_uint32 *mhaddrp;
800 bulkaddrs mhaddrs;
801 ListAddrByAttributes attrs;
802 afsUUID uuid;
803
804 printf("[0x%x %u] (special multi-homed entry)\n",
805 *addrp, *addrp);
806 memset(&attrs, 0, sizeof(attrs));
807 attrs.Mask = VLADDR_INDEX;
808 mhaddrs.bulkaddrs_val = 0;
809 mhaddrs.bulkaddrs_len = 0;
810 attrs.index = *addrp & 0x00ffffff;
811
812 code =
813 ubik_VL_GetAddrsU(cstruct, 0, &attrs, &uuid,
814 &unique, &mhnentries, &mhaddrs);
815 if (code) {
816 printf("VL_GetAddrsU returned code = %d\n", code);
817 continue;
818 }
819 printf
820 (" [%d]: uuid[%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x]\n addrunique=%d, ip address(es):\n",
821 attrs.index, uuid.time_low, uuid.time_mid,
822 uuid.time_hi_and_version,
823 uuid.clock_seq_hi_and_reserved,
824 uuid.clock_seq_low, uuid.node[0], uuid.node[1],
825 uuid.node[2], uuid.node[3], uuid.node[4],
826 uuid.node[5], unique);
827 mhaddrp = mhaddrs.bulkaddrs_val;
828 for (j = 0; j < mhnentries; j++) {
829 mhaddrp[j] = ntohl(mhaddrp[j]);
830 hostAddr.s_addr = mhaddrp[j];
831 printf("\t%s (%s)\n", inet_ntoa(hostAddr),
832 hostutil_GetNameByINet(mhaddrp[j]));
833 }
834 if (mhaddrs.bulkaddrs_val)
835 free(mhaddrs.bulkaddrs_val);
836 } else {
837 printf("[0x%x %u] %s\n", *addrp, *addrp,
838 hostutil_GetNameByINet(ntohl(*addrp)));
839 }
840 }
841 free(addrs.bulkaddrs_val);
842 } else if (!strcmp(oper, "mhc")) {
843 afs_uint32 serveraddrs[MAXSERVERID + 1][VL_MAXIPADDRS_PERMH];
844 afs_int32 serveraddrtype[MAXSERVERID + 1];
845 int nentries1, nentries2, i, j, x, y, unique, found;
846 afs_uint32 *addrp1, *addrp2;
847 bulkaddrs addrs1, addrs2;
848 struct VLCallBack vlcb;
849 ListAddrByAttributes attrs;
850 afsUUID uuid;
851 afs_int32 base, index;
852
853 for (i = 0; i < MAXSERVERID + 1; i++) {
854 serveraddrtype[i] = 0;
855 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++)
856 serveraddrs[i][j] = 0;
857 }
858
859 /* Collect a list of all registered IP addresses */
860 addrs1.bulkaddrs_val = 0;
861 addrs1.bulkaddrs_len = 0;
862 code =
863 ubik_VL_GetAddrs(cstruct, 0, 0, 0, &vlcb,
864 &nentries1, &addrs1);
865 if (code) {
866 printf("VL_GetAddrs returned code = %d\n", code);
867 continue;
868 }
869 addrp1 = addrs1.bulkaddrs_val;
870 for (i = 0; i < nentries1; i++, addrp1++) {
871 if ((*addrp1 & 0xff000000) != 0xff000000) {
872 serveraddrs[i][0] = ntohl(*addrp1);
873 serveraddrtype[i] = 1;
874 } else {
875 /* It's multihomed. Get all of its addresses */
876 serveraddrtype[i] = 2;
877 base = (*addrp1 >> 16) & 0xff;
878 index = *addrp1 & 0xffff;
879
880 addrs2.bulkaddrs_val = 0;
881 addrs2.bulkaddrs_len = 0;
882 memset(&attrs, 0, sizeof(attrs));
883 attrs.Mask = VLADDR_INDEX;
884 attrs.index = (base * VL_MHSRV_PERBLK) + index;
885 code =
886 ubik_VL_GetAddrsU(cstruct, 0, &attrs, &uuid,
887 &unique, &nentries2, &addrs2);
888 if (code) {
889 printf("VL_GetAddrsU returned code = %d\n", code);
890 break;
891 }
892
893 addrp2 = addrs2.bulkaddrs_val;
894 for (j = 0; j < nentries2; j++) {
895 serveraddrs[i][j] = ntohl(addrp2[j]);
896 }
897 free(addrs2.bulkaddrs_val);
898 }
899
900 if (nargs) {
901 if (serveraddrtype[i] == 1) {
902 printf("%u\n", serveraddrs[i][0]);
903 } else {
904 printf("[");
905 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++)
906 if (serveraddrs[i][j])
907 printf(" %u", serveraddrs[i][j]);
908 printf(" ]\n");
909 }
910 }
911 }
912 free(addrs1.bulkaddrs_val);
913
914 /* Look for any duplicates */
915 for (i = 0; i < MAXSERVERID + 1; i++) {
916 if (!serveraddrtype[i])
917 continue;
918 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
919 if (!serveraddrs[i][j])
920 continue;
921
922 found = 0;
923 for (x = i + 1; x < MAXSERVERID + 1; x++) {
924 if (!serveraddrtype[x])
925 continue;
926 for (y = 0; y < VL_MAXIPADDRS_PERMH; y++) {
927 if (!serveraddrs[x][y])
928 continue;
929 if (serveraddrs[i][j] == serveraddrs[x][y]) {
930 serveraddrs[x][y] = 0;
931 found++;
932 }
933 }
934 }
935 if (found) {
936 printf
937 ("Found %d entries of IP address %u (0x%x)\n",
938 found + 1, serveraddrs[i][j],
939 serveraddrs[i][j]);
940 }
941 }
942 }
943
944 /*----------------------------------------*/
945
946 } else if (!strcmp(oper, "regaddr")) {
947 int i;
948 afs_uint32 *addrp, tad;
949 bulkaddrs addrs;
950 afsUUID uuid;
951
952 memset(&uuid, 0, sizeof(uuid));
953 sscanf(&(*argp)[0], "%d", &i);
954 ++argp, --nargs;
955 memcpy(uuid.node, &i, sizeof(i));
956
957 if (nargs < 0 || nargs > 16) {
958 printf("Illegal # entries = %d\n", nargs);
959 continue;
960 }
961 addrp = malloc(20 * 4);
962 addrs.bulkaddrs_val = addrp;
963 addrs.bulkaddrs_len = nargs;
964 while (nargs > 0) {
965 sscanf(&(*argp)[0], "%d", &tad);
966 *addrp++ = tad;
967 ++argp, --nargs;
968 }
969 code =
970 ubik_VL_RegisterAddrs(cstruct, 0, &uuid,
971 0 /*spare */ , &addrs);
972 if (code) {
973 printf("VL_RegisterAddrs returned code = %d\n", code);
974 continue;
975 }
976 } else if (!strcmp(oper, "ca")) {
977 struct hostent *h1, *h2;
978 afs_uint32 a1, a2;
979
980 printf("changing %s", *argp);
981 h1 = hostutil_GetHostByName(&(*argp)[0]);
982 if (!h1) {
983 printf("cmdebug: can't resolve address for host %s",
984 *argp);
985 continue;
986 }
987 memcpy(&a1, (afs_int32 *) h1->h_addr, sizeof(afs_uint32));
988
989 ++argp, --nargs;
990 printf(" to %s\n", *argp);
991 h2 = hostutil_GetHostByName(&(*argp)[0]);
992 if (!h2) {
993 printf("cmdebug: can't resolve address for host %s",
994 *argp);
995 continue;
996 }
997 memcpy(&a2, (afs_int32 *) h2->h_addr, sizeof(afs_uint32));
998
999 printf("changing 0x%x to 0x%x\n", ntohl(a1), ntohl(a2));
1000 code =
1001 ubik_VL_ChangeAddr(cstruct, 0, ntohl(a1),
1002 ntohl(a2));
1003 if (code) {
1004 printf("VL_ChangeAddr returned code = %d\n", code);
1005 continue;
1006 }
1007 } else if (!strcmp(oper, "caid")) {
1008 afs_uint32 a1, a2;
1009
1010 sscanf(&(*argp)[0], "%d", &a1);
1011 printf("changing %d (0x%x)", a1, a1);
1012 ++argp, --nargs;
1013 sscanf(&(*argp)[0], "%d", &a2);
1014 printf(" to %d (0x%x)\n", a2, a2);
1015 code = ubik_VL_ChangeAddr(cstruct, 0, a1, a2);
1016 if (code) {
1017 printf("VL_ChangeAddr returned code = %d\n", code);
1018 continue;
1019 }
1020 } else if ((!strcmp(oper, "?")) || !strcmp(oper, "h") || !strcmp(oper, "help"))
1021 print_usage();
1022 else if ((!strcmp(oper, "q")) || !strcmp(oper, "quit"))
1023 exit(0);
1024 else {
1025 printf("Unknown oper (%s)!\n", oper);
1026 print_usage();
1027 }
1028 }
1029 }
1030}
1031
1032
1033#include "AFS_component_version_number.c"
1034
1035int
1036main(int argc, char **argv)
1037{
1038 struct cmd_syndesc *ts;
1039 afs_int32 code;
1040
1041 strcpy(confdir, AFSDIR_CLIENT_ETC_DIRPATH);
1042 ts = cmd_CreateSyntax("initcmd", handleit, NULL, 0, "initialize the program");
1043 cmd_AddParm(ts, "-cellpath", CMD_LIST, CMD_OPTIONAL,
1044 "Cell configuration directory");
1045 cmd_AddParm(ts, "-server", CMD_LIST, CMD_OPTIONAL,
1046 "Use the cell config in /usr/afs/etc (default /usr/vice/etc)");
1047 cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL,
1048 "Run it without authentication");
1049 cmd_AddParm(ts, "-host", CMD_LIST, CMD_OPTIONAL,
1050 "vldb server to talk to");
1051 cmd_AddParm(ts, "-cell", CMD_LIST, CMD_OPTIONAL,
1052 "cellname '-host' belongs to (required for auth conns)");
1053 cmd_AddParm(ts, "-getstats", CMD_FLAG, CMD_OPTIONAL,
1054 "print vldb statistics (non interactive)");
1055 cmd_AddParm(ts, "-probe", CMD_FLAG, CMD_OPTIONAL,
1056 "probe vldb servers, use with -host to probe only one. (non interactive)");
1057 code = cmd_Dispatch(argc, argv);
1058 exit(code);
1059}
1060
1061
1062void
1063fill_entry(struct vldbentry *entry, char **argp, int nargs)
1064{
1065 char *name;
1066 int i;
1067
1068 name = &argp[0][0];
1069 ++argp, --nargs;
1070 sscanf(&(*argp)[0], "%d", &entry->spares3);
1071 ++argp, --nargs;
1072 sscanf(&(*argp)[0], "%d", &entry->nServers);
1073 strcpy(entry->name, name);
1074 for (i = 0; i < entry->nServers; i++) {
1075 ++argp, --nargs;
1076 sscanf(&(*argp)[0], "%u", &entry->serverNumber[i]);
1077 }
1078 for (i = 0; i < entry->nServers; i++) {
1079 ++argp, --nargs;
1080 sscanf(&(*argp)[0], "%d", &entry->serverPartition[i]);
1081 }
1082 for (i = 0; i < entry->nServers; i++) {
1083 ++argp, --nargs;
1084 sscanf(&(*argp)[0], "%d", &entry->serverFlags[i]);
1085 }
1086 for (i = 0; i < MAXTYPES; i++) {
1087 ++argp, --nargs;
1088 sscanf(&(*argp)[0], "%u", &entry->volumeId[i]);
1089 }
1090 ++argp, --nargs;
1091 sscanf(&(*argp)[0], "%d", &entry->flags);
1092 ++argp, --nargs;
1093 sscanf(&(*argp)[0], "%u", &entry->cloneId);
1094}
1095
1096void
1097fill_update_entry(struct VldbUpdateEntry *entry, char **argp, int nargs)
1098{
1099 int i, Mask;
1100 char *name;
1101
1102 entry->Mask = 0;
1103 name = &argp[0][0];
1104 if (strcmp(name, "null")) {
1105 strcpy(entry->name, name);
1106 entry->Mask |= VLUPDATE_VOLUMENAME;
1107 }
1108 ++argp, --nargs;
1109 sscanf(&(*argp)[0], "%d", &entry->flags);
1110 if (entry->flags != -1)
1111 entry->Mask |= VLUPDATE_FLAGS;
1112 ++argp, --nargs;
1113 sscanf(&(*argp)[0], "%u", &entry->cloneId);
1114 if (entry->flags != -1)
1115 entry->Mask |= VLUPDATE_CLONEID;
1116 ++argp, --nargs;
1117 sscanf(&(*argp)[0], "%u", &entry->ReadOnlyId);
1118 if (entry->ReadOnlyId != -1)
1119 entry->Mask |= VLUPDATE_READONLYID;
1120 ++argp, --nargs;
1121 sscanf(&(*argp)[0], "%u", &entry->BackupId);
1122 if (entry->BackupId != -1)
1123 entry->Mask |= VLUPDATE_BACKUPID;
1124 ++argp, --nargs;
1125 sscanf(&(*argp)[0], "%d", &entry->nModifiedRepsites);
1126 if (entry->nModifiedRepsites != -1)
1127 entry->Mask |= VLUPDATE_REPSITES;
1128 for (i = 0; i < entry->nModifiedRepsites; i++) {
1129 ++argp, --nargs;
1130 sscanf(&(*argp)[0], "%x", &Mask);
1131 ++argp, --nargs;
1132 sscanf(&(*argp)[0], "%u", &entry->RepsitesTargetServer[i]);
1133 ++argp, --nargs;
1134 sscanf(&(*argp)[0], "%d", &entry->RepsitesTargetPart[i]);
1135 if (Mask & VLUPDATE_REPS_DELETE)
1136 entry->RepsitesMask[i] |= VLUPDATE_REPS_DELETE;
1137 if (Mask & VLUPDATE_REPS_MODSERV) {
1138 ++argp, --nargs;
1139 sscanf(&(*argp)[0], "%u", &entry->RepsitesNewServer[i]);
1140 entry->RepsitesMask[i] |= VLUPDATE_REPS_MODSERV;
1141 } else if (Mask & VLUPDATE_REPS_MODPART) {
1142 ++argp, --nargs;
1143 sscanf(&(*argp)[0], "%d", &entry->RepsitesNewPart[i]);
1144 entry->RepsitesMask[i] |= VLUPDATE_REPS_MODPART;
1145 } else if (Mask & VLUPDATE_REPS_MODFLAG) {
1146 ++argp, --nargs;
1147 sscanf(&(*argp)[0], "%d", &entry->RepsitesNewFlags[i]);
1148 entry->RepsitesMask[i] |= VLUPDATE_REPS_MODFLAG;
1149 } else if (Mask & VLUPDATE_REPS_ADD) {
1150 ++argp, --nargs;
1151 sscanf(&(*argp)[0], "%u", &entry->RepsitesNewServer[i]);
1152 ++argp, --nargs;
1153 sscanf(&(*argp)[0], "%d", &entry->RepsitesNewPart[i]);
1154 ++argp, --nargs;
1155 sscanf(&(*argp)[0], "%d", &entry->RepsitesNewFlags[i]);
1156 entry->RepsitesMask[i] |= VLUPDATE_REPS_ADD;
1157 }
1158 }
1159}
1160
1161void
1162fill_listattributes_entry(struct VldbListByAttributes *entry, char **argp,
1163 int nargs)
1164{
1165 entry->Mask = 0;
1166
1167 if (nargs <= 0)
1168 return;
1169 entry->server = ntohl(GetServer(argp[0]));
1170 sscanf(&(*argp)[0], "%d", &entry->server);
1171 if (entry->server != 0)
1172 entry->Mask |= VLLIST_SERVER;
1173 ++argp, --nargs;
1174
1175 if (nargs <= 0)
1176 return;
1177 sscanf(&(*argp)[0], "%d", &entry->partition);
1178 if (entry->partition != -1)
1179 entry->Mask |= VLLIST_PARTITION;
1180 ++argp, --nargs;
1181
1182 if (nargs <= 0)
1183 return;
1184 sscanf(&(*argp)[0], "%d", &entry->volumeid);
1185 if (entry->volumeid != -1)
1186 entry->Mask |= VLLIST_VOLUMEID;
1187 ++argp, --nargs;
1188
1189 if (nargs <= 0)
1190 return;
1191 sscanf(&(*argp)[0], "%d", &entry->flag);
1192 if (entry->flag != -1)
1193 entry->Mask |= VLLIST_FLAG;
1194}
1195
1196void
1197display_listattributes_entry(struct VldbListByAttributes *entry, int error)
1198{
1199 if (error)
1200 return;
1201 printf("\nList entry values (Mask=%x)\n", entry->Mask);
1202 if (entry->Mask & VLLIST_SERVER)
1203 printf("\tServer: %d.%d.%d.%d\n", (entry->server >> 24) & 0xff,
1204 (entry->server >> 16) & 0xff, (entry->server >> 8) & 0xff,
1205 (entry->server) & 0xff);
1206 if (entry->Mask & VLLIST_PARTITION)
1207 printf("\tPartition: %d\n", entry->partition);
1208 if (entry->Mask & VLLIST_VOLUMEID)
1209 printf("\tVolumeId: %u\n", entry->volumeid);
1210 if (entry->Mask & VLLIST_FLAG)
1211 printf("\tFlag: %x\n", entry->flag);
1212}
1213
1214
1215#define volumetype_string(type) (type == RWVOL? "read/write":type == ROVOL? "readonly":type == BACKVOL? "backup":"unknown")
1216
1217void
1218display_entry(struct vldbentry *entry, int error)
1219{
1220 int i;
1221
1222 if (error)
1223 return;
1224 printf("\nEntry for volume name: %s, volid=%u (flags=%X) are:\n",
1225 entry->name, entry->volumeId[RWVOL], entry->flags);
1226 printf("ParentID=%u, ReadOnlyID=%u, backupID=%u, CloneId=%u ",
1227 entry->volumeId[0], entry->volumeId[1], entry->volumeId[2],
1228 entry->cloneId);
1229 printf("nServers=%d\n", entry->nServers);
1230 printf("ServerNumber\tServerPart\tserverFlag\n");
1231 for (i = 0; i < entry->nServers; i++)
1232 printf("%12u\t%10d\t%10x\n", entry->serverNumber[i],
1233 entry->serverPartition[i], entry->serverFlags[i]);
1234}
1235
1236void
1237display_entryN(struct nvldbentry *entry, int error)
1238{
1239 int i, et, ei;
1240
1241 if (error)
1242 return;
1243 printf("\nEntry for volume name: %s, volid=%u (flags=%X) are:\n",
1244 entry->name, entry->volumeId[RWVOL], entry->flags);
1245 printf("ParentID=%u, ReadOnlyID=%u, backupID=%u, CloneId=%u ",
1246 entry->volumeId[0], entry->volumeId[1], entry->volumeId[2],
1247 entry->cloneId);
1248 printf("nServers=%d\n", entry->nServers);
1249 printf("ServerNumber\tServerPart\tserverFlag\n");
1250 ei = entry->matchindex & 0xffff;
1251 et = (entry->matchindex >> 16) & 0xffff;
1252 for (i = 0; i < entry->nServers; i++) {
1253 printf("%12u\t%10d\t%10x", entry->serverNumber[i],
1254 entry->serverPartition[i], entry->serverFlags[i]);
1255 if (i == ei) {
1256 printf(" <--- %s", (et == 4) ? "RW" : ((et == 8) ? "BK" : "RO"));
1257 }
1258 printf("\n");
1259 }
1260}
1261
1262void
1263display_update_entry(struct VldbUpdateEntry *entry, int error)
1264{
1265 int i;
1266
1267 if (error)
1268 return;
1269 printf("\nUpdate entry values (Mask=%x)\n", entry->Mask);
1270 if (entry->Mask & VLUPDATE_VOLUMENAME)
1271 printf("\tNew name: %s\n", entry->name);
1272 if (entry->Mask & VLUPDATE_FLAGS)
1273 printf("\tNew flags: %X\n", entry->flags);
1274 if (entry->Mask & VLUPDATE_CLONEID)
1275 printf("\tNew CloneId: %X\n", entry->cloneId);
1276 if (entry->Mask & VLUPDATE_READONLYID)
1277 printf("\tNew RO id: %d\n", entry->ReadOnlyId);
1278 if (entry->Mask & VLUPDATE_BACKUPID)
1279 printf("\tNew BACKUP id: %d\n", entry->BackupId);
1280 if (entry->Mask & VLUPDATE_REPSITES) {
1281 printf("\tRepsites info:\n");
1282 printf("\tFlag\tTServer\tTPart\tNServer\tNPart\tNFlag\n");
1283 for (i = 0; i < entry->nModifiedRepsites; i++) {
1284 printf("\t%4x\t%7u\t%5d", entry->RepsitesMask[i],
1285 entry->RepsitesTargetServer[i],
1286 entry->RepsitesTargetPart[i]);
1287 if ((entry->RepsitesMask[i] & VLUPDATE_REPS_ADD)
1288 || (entry->RepsitesMask[i] & VLUPDATE_REPS_MODSERV))
1289 printf("\t%7u", entry->RepsitesNewServer[i]);
1290 else
1291 printf("\t-------");
1292 if ((entry->RepsitesMask[i] & VLUPDATE_REPS_ADD)
1293 || (entry->RepsitesMask[i] & VLUPDATE_REPS_MODPART))
1294 printf("\t%5d", entry->RepsitesNewPart[i]);
1295 else
1296 printf("\t-----");
1297 if ((entry->RepsitesMask[i] & VLUPDATE_REPS_ADD)
1298 || (entry->RepsitesMask[i] & VLUPDATE_REPS_MODFLAG))
1299 printf("\t%5x\n", entry->RepsitesNewFlags[i]);
1300 else
1301 printf("\t-----\n");
1302 }
1303 }
1304}
1305
1306void
1307dump_stats(vldstats *stats, vital_vlheader *vital_header)
1308{
1309 int i;
1310 char strg[30];
1311 time_t start_time = stats->start_time;
1312 struct tm tm;
1313
1314 strftime(strg, sizeof(strg), "%a %b %d %H:%M:%S %Y",
1315 localtime_r(&start_time, &tm));
1316 printf("Dynamic statistics stats (starting time: %s):\n", strg);
1317 printf("OpcodeName\t# Requests\t# Aborts\n");
1318 for (i = 0; i < VL_NUMBER_OPCODESX; i++)
1319 printf("%10s\t%10d\t%8d\n", opcode_names[i], stats->requests[i],
1320 stats->aborts[i]);
1321 printf("\nVldb header stats (version=%d)\n",
1322 ntohl(vital_header->vldbversion));
1323 printf("headersize=%d, allocs=%d, frees=%d, MaxVolid=%X\n",
1324 ntohl(vital_header->headersize), ntohl(vital_header->allocs),
1325 ntohl(vital_header->frees), ntohl(vital_header->MaxVolumeId));
1326 for (i = 0; i < MAXTYPES; i++)
1327 printf("total %s entries=%d\n", volumetype_string(i),
1328 ntohl(vital_header->totalEntries[i]));
1329}
1330
1331void
1332GetArgs(char *line, char **args, int *nargs)
1333{
1334 *nargs = 0;
1335 while (*line) {
1336 char *last = line;
1337 while (isspace(*line))
1338 line++;
1339 if (isspace(*last))
1340 *last = 0;
1341 if (!*line)
1342 break;
1343 *args++ = line, (*nargs)++;
1344 while (*line && !isspace(*line))
1345 line++;
1346 }
1347}
1348
1349void
1350print_usage(void)
1351{
1352 printf("Valid Commands:\n");
1353
1354 printf(" CreateEntry:\n");
1355 printf
1356 ("\tcr <vname> <vtype> <#S> <Saddr1>.<Saddrn> <Spart1>.<Spartn> <Sflag1>.<Sflagn> <Volid1-3> <flag>\n");
1357
1358 printf(" DeleteEntry:\n");
1359 printf("\trm <volid> <voltype>\n");
1360
1361 printf(" ReplaceEntry:\n");
1362 printf("\tre <volid> <voltype> <New vldb entry ala 'cr'>\n");
1363
1364 printf(" UpdateEntry:\n");
1365 printf
1366 ("\tup <volid> <voltype> <vname> <vtype> <#AddSer> [<Saddr1>.<Saddrn> <Spart1>.<Spartn> <Sflag1>.<Sflagn>] <Volid1-3> <flag>\n");
1367
1368 printf(" ListEntry:\n");
1369 printf("\tls\n");
1370
1371 printf(" Find duplicate entries of a volume\n");
1372 printf("\tldups\n");
1373
1374 printf(" For each vlentry, find it by name, RW id, BK id, and RO id\n");
1375 printf("\tcheckhash\n");
1376
1377 printf
1378 (" UpdateEntry (update the volname, RW id, BK id, RO id hashes):\n");
1379 printf("\tfixhash\n");
1380
1381 printf(" ListAttributes:\n");
1382 printf("\tla [server] [partition] [volumeid] [flag]\n");
1383
1384 printf(" ListAttributesN2:\n");
1385 printf("\tlan2 [volname] [server] [partition] [volumeid] [flag]\n");
1386
1387 printf(" GetEntryByID:\n");
1388 printf("\tdi <volid> <voltype>\n");
1389
1390 printf(" UpdateEntry (refresh namehash table):\n");
1391 printf("\trmnh <volid> <voltype>\n");
1392
1393 printf(" GetEntryByName:\n");
1394 printf("\tdn <volname> <voltype>\n");
1395
1396 printf(" UpdateEntry (undelete a vol entry):\n");
1397 printf("\tundelete <volid> <voltype>\n");
1398/*
1399 * printf(" LinkedList\n");
1400 * printf("\t:ln [server] [partition] [volumeid] [flag]\n");
1401 *
1402 * printf(" LinkedListN\n");
1403 * printf("\t:lnn [server] [partition] [volumeid] [flag]\n");
1404 */
1405 printf(" GetNewVoumeId:\n");
1406 printf("\tnv <bump-count>\n");
1407
1408 printf(" GetStats:\n");
1409 printf("\tgs\n");
1410
1411 printf(" ChangeAddr:\n");
1412 printf("\tca <oldmachname> <newmachname>\n");
1413
1414/*
1415 * printf(" ChangeAddr\n");
1416 * printf("\t:caid <oldaddr> <newaddr>\n");
1417 */
1418 printf(" GetAddrs:\n");
1419 printf("\tga\n");
1420
1421 printf(" GetAddrsU:\n");
1422 printf("\tgau\n");
1423
1424 printf(" RegisterAddrs:\n");
1425 printf("\tregaddr uuidNumber <ip1 .. ipn>\n");
1426
1427 printf("\tmisc: q, quit, ?, h\n");
1428}
openafs packaging