src/libadmin/test/vos.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * This file implements the vos related funtions for afscp
  12  */
  13
  14 #include <afsconfig.h>
  15 #include <afs/param.h>
  16 #ifndef AFS_NT40_ENV
  17 #include <netdb.h>
  18 #include <netinet/in.h>
  19 #include <arpa/inet.h>
  20 #include <afs/afsutil.h>
  21 #include <unistd.h>
  22 #endif
  23
  24
  25 #include "vos.h"
  26
  27 /*
  28  * Utility functions
  29  */
  30
  31 /*
  32  * Generic fuction for converting input string to an integer.  Pass
  33  * the error_msg you want displayed if there is an error converting
  34  * the string.
  35  */
  36
  37 static unsigned int
  38 GetIntFromString(const char *int_str, const char *error_msg)
  39 {
  40     unsigned int i;
  41     char *bad_char = NULL;
  42
  43     i = strtoul(int_str, &bad_char, 10);
  44     if ((bad_char == NULL) || (*bad_char == 0)) {
  45         return i;
  46     }
  47
  48     ERR_EXT(error_msg);
  49 }
  50
  51 /*
  52  * Generic fuction for converting input string to a volume number
  53  * It will accept integer strings as well as volume names.
  54  */
  55
  56 static unsigned int
  57 GetVolumeIdFromString(const char *volume)
  58 {
  59     unsigned int volume_id;
  60     char *bad_char = NULL;
  61     afs_status_t st = 0;
  62     vos_vldbEntry_t entry;
  63
  64     volume_id = strtoul(volume, &bad_char, 10);
  65     if ((bad_char == NULL) || (*bad_char == 0)) {
  66         return volume_id;
  67     }
  68
  69     /*
  70      * We failed to convert the string to a number, so see if it
  71      * is a volume name
  72      */
  73     if (vos_VLDBGet
  74         (cellHandle, 0, NULL, (char *)volume, &entry, &st)) {
  75         return entry.volumeId[VOS_READ_WRITE_VOLUME];
  76     } else {
  77         ERR_EXT("failed to convert specified volume to an id");
  78     }
  79 }
  80
  81 /*
  82  * Generic fuction for converting input string to a partition number
  83  * It will accept integer strings as well as partition names.
  84  */
  85
  86 static unsigned int
  87 GetPartitionIdFromString(const char *partition)
  88 {
  89     unsigned int partition_id;
  90     char *bad_char = NULL;
  91     afs_status_t st = 0;
  92     char pname[20];
  93     int pname_len;
  94
  95     partition_id = strtoul(partition, &bad_char, 10);
  96     if ((bad_char == NULL) || (*bad_char == 0)) {
  97         return partition_id;
  98     }
  99
 100     /*
 101      * We failed to convert the string to a number, so see if it
 102      * is a partition name
 103      */
 104
 105     pname_len = strlen(partition);
 106
 107     sprintf(pname, "%s", "/vicep");
 108     if (pname_len <= 2) {
 109         strcat(pname, partition);
 110     } else if (!strncmp(partition, "/vicep", 6)) {
 111         strcat(pname, partition + 6);
 112     } else if (!strncmp(partition, "vicep", 5)) {
 113         strcat(pname, partition + 5);
 114     } else {
 115         ERR_EXT("invalid partition");
 116     }
 117
 118     if (!vos_PartitionNameToId((const char *)pname, &partition_id, &st)) {
 119         ERR_ST_EXT("invalid partition", st);
 120     }
 121
 122     return partition_id;
 123 }
 124
 125 /*
 126  * Generic fuction for converting input string to an address in host order.
 127  * It will accept strings in the form "128.98.12.1"
 128  */
 129
 130 static int
 131 GetAddressFromString(const char *addr_str)
 132 {
 133     int addr = inet_addr(addr_str);
 134
 135     if (addr == -1) {
 136         ERR_EXT("failed to convert specified address");
 137     }
 138
 139     return ntohl(addr);
 140 }
 141
 142 #if 0
 143 static void
 144 PrintMessage(vos_messageType_t type, char *message)
 145 {
 146     printf("%s\n", message);
 147 }
 148 #endif
 149
 150 int
 151 DoVosBackupVolumeCreate(struct cmd_syndesc *as, void *arock)
 152 {
 153     typedef enum { VOLUME } DoVosBackupVolumeCreate_parm_t;
 154     afs_status_t st = 0;
 155     unsigned int volume_id = 0;
 156
 157     if (as->parms[VOLUME].items) {
 158         const char *volume = as->parms[VOLUME].items->data;
 159         volume_id = GetVolumeIdFromString(volume);
 160     }
 161
 162     if (!vos_BackupVolumeCreate(cellHandle, 0, volume_id, &st)) {
 163         ERR_ST_EXT("vos_BackupVolumeCreate", st);
 164     }
 165     return 0;
 166 }
 167
 168 int
 169 DoVosBackupVolumeCreateMultiple(struct cmd_syndesc *as, void *arock)
 170 {
 171     typedef enum { SERVER, PARTITION, PREFIX,
 172         EXCLUDE
 173     } DoVosBackupVolumeCreate_parm_t;
 174     afs_status_t st = 0;
 175     void *vos_server = NULL;
 176     unsigned int partition_id;
 177     const unsigned int *part_ptr = NULL;
 178     const char *prefix = NULL;
 179     vos_exclude_t exclude = VOS_INCLUDE;
 180
 181     if (as->parms[SERVER].items) {
 182         if (!vos_ServerOpen
 183             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 184             ERR_ST_EXT("vos_ServerOpen", st);
 185         }
 186     }
 187
 188     if (as->parms[PARTITION].items) {
 189         partition_id =
 190             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 191         part_ptr = &partition_id;
 192     }
 193
 194     if (as->parms[PREFIX].items) {
 195         prefix = as->parms[PREFIX].items->data;
 196     }
 197
 198     if (as->parms[EXCLUDE].items) {
 199         exclude = VOS_EXCLUDE;
 200     }
 201
 202     if (!vos_BackupVolumeCreateMultiple
 203         (cellHandle, vos_server, (vos_MessageCallBack_t) 0, part_ptr, prefix,
 204          exclude, &st)) {
 205         ERR_ST_EXT("vos_BackupVolumeCreate", st);
 206     }
 207     return 0;
 208 }
 209
 210 static void
 211 Print_vos_partitionEntry_p(vos_partitionEntry_p part, const char *prefix)
 212 {
 213     printf("%sInformation for partition %s\n", prefix, part->name);
 214     printf("%s\tDevice name: %s\n", prefix, part->deviceName);
 215     printf("%s\tlockFileDescriptor: %d\n", prefix, part->lockFileDescriptor);
 216     printf("%s\tTotal space: %d\n", prefix, part->totalSpace);
 217     printf("%s\tTotal Free space: %d\n", prefix, part->totalFreeSpace);
 218 }
 219
 220 int
 221 DoVosPartitionGet(struct cmd_syndesc *as, void *arock)
 222 {
 223     typedef enum { SERVER, PARTITION } DoVosPartitionGet_parm_t;
 224     afs_status_t st = 0;
 225     void *vos_server = NULL;
 226     unsigned int partition_id = 0;
 227     vos_partitionEntry_t entry;
 228
 229     if (as->parms[SERVER].items) {
 230         if (!vos_ServerOpen
 231             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 232             ERR_ST_EXT("vos_ServerOpen", st);
 233         }
 234     }
 235
 236     if (as->parms[PARTITION].items) {
 237         partition_id =
 238             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 239     }
 240
 241     if (!vos_PartitionGet
 242         (cellHandle, vos_server, 0, partition_id, &entry, &st)) {
 243         ERR_ST_EXT("vos_PartitionGet", st);
 244     }
 245
 246     Print_vos_partitionEntry_p(&entry, "");
 247
 248     return 0;
 249 }
 250
 251 int
 252 DoVosPartitionList(struct cmd_syndesc *as, void *arock)
 253 {
 254     typedef enum { SERVER } DoVosPartitionGet_parm_t;
 255     afs_status_t st = 0;
 256     void *vos_server = NULL;
 257     void *iter;
 258     vos_partitionEntry_t entry;
 259
 260     if (as->parms[SERVER].items) {
 261         if (!vos_ServerOpen
 262             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 263             ERR_ST_EXT("vos_ServerOpen", st);
 264         }
 265     }
 266
 267     if (!vos_PartitionGetBegin(cellHandle, vos_server, 0, &iter, &st)) {
 268         ERR_ST_EXT("vos_PartitionGetBegin", st);
 269     }
 270
 271     printf("Listing partitions at server %s\n",
 272            as->parms[SERVER].items->data);
 273     while (vos_PartitionGetNext(iter, &entry, &st)) {
 274         Print_vos_partitionEntry_p(&entry, "    ");
 275     }
 276
 277     if (st != ADMITERATORDONE) {
 278         ERR_ST_EXT("vos_PartitionGetNext", st);
 279     }
 280
 281     if (!vos_PartitionGetDone(iter, &st)) {
 282         ERR_ST_EXT("vos_PartitionGetDone", st);
 283     }
 284     return 0;
 285 }
 286
 287 int
 288 DoVosServerSync(struct cmd_syndesc *as, void *arock)
 289 {
 290     typedef enum { SERVER, PARTITION } DoVosServerSync_parm_t;
 291     afs_status_t st = 0;
 292     void *vos_server = NULL;
 293     unsigned int partition_id;
 294     const unsigned int *part_ptr = NULL;
 295
 296     if (as->parms[SERVER].items) {
 297         if (!vos_ServerOpen
 298             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 299             ERR_ST_EXT("vos_ServerOpen", st);
 300         }
 301     }
 302
 303     if (as->parms[PARTITION].items) {
 304         partition_id =
 305             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 306         part_ptr = &partition_id;
 307     }
 308
 309     if (!vos_ServerSync(cellHandle, vos_server, 0, part_ptr, &st)) {
 310         ERR_ST_EXT("vos_PartitionGetDone", st);
 311     }
 312     return 0;
 313 }
 314
 315 int
 316 DoVosFileServerAddressChange(struct cmd_syndesc *as, void *arock)
 317 {
 318     typedef enum { OLDADDRESS,
 319         NEWADDRESS
 320     } DoVosFileServerAddressChange_parm_t;
 321     afs_status_t st = 0;
 322     int old_addr = 0;
 323     int new_addr = 0;
 324
 325     if (as->parms[OLDADDRESS].items) {
 326         const char *addr = as->parms[OLDADDRESS].items->data;
 327         old_addr = GetAddressFromString(addr);
 328     }
 329
 330     if (as->parms[NEWADDRESS].items) {
 331         const char *addr = as->parms[OLDADDRESS].items->data;
 332         new_addr = GetAddressFromString(addr);
 333     }
 334
 335     if (!vos_FileServerAddressChange(cellHandle, 0, old_addr, new_addr, &st)) {
 336         ERR_ST_EXT("vos_FileServerAddressChange", st);
 337     }
 338     return 0;
 339 }
 340
 341 int
 342 DoVosFileServerAddressRemove(struct cmd_syndesc *as, void *arock)
 343 {
 344     typedef enum { ADDRESS } DoVosFileServerAddressRemove_parm_t;
 345     afs_status_t st = 0;
 346     int address = 0;
 347
 348     if (as->parms[ADDRESS].items) {
 349         const char *addr = as->parms[ADDRESS].items->data;
 350         address = GetAddressFromString(addr);
 351     }
 352
 353     if (!vos_FileServerAddressRemove(cellHandle, 0, address, &st)) {
 354         ERR_ST_EXT("vos_FileServerAddressRemove", st);
 355     }
 356     return 0;
 357 }
 358
 359 static void
 360 Print_vos_fileServerEntry_p(vos_fileServerEntry_p serv, const char *prefix)
 361 {
 362     int i;
 363
 364     for (i = 0; i < serv->count; i++) {
 365         printf("%s%x ", prefix, serv->serverAddress[i]);
 366     }
 367     printf("\n");
 368 }
 369
 370 int
 371 DoVosFileServerList(struct cmd_syndesc *as, void *arock)
 372 {
 373     afs_status_t st = 0;
 374     void *iter;
 375     vos_fileServerEntry_t entry;
 376
 377     if (!vos_FileServerGetBegin(cellHandle, 0, &iter, &st)) {
 378         ERR_ST_EXT("vos_FileServerGetBegin", st);
 379     }
 380
 381     while (vos_FileServerGetNext(iter, &entry, &st)) {
 382         Print_vos_fileServerEntry_p(&entry, "");
 383     }
 384
 385     if (st != ADMITERATORDONE) {
 386         ERR_ST_EXT("vos_FileServerGetNext", st);
 387     }
 388
 389     if (!vos_FileServerGetDone(iter, &st)) {
 390         ERR_ST_EXT("vos_FileServerGetDone", st);
 391     }
 392
 393     return 0;
 394 }
 395
 396 static void
 397 Print_vos_serverTransactionStatus_p(vos_serverTransactionStatus_p tran,
 398                                     const char *prefix)
 399 {
 400     printf("%sTransaction id\t\t\t%d\n", prefix, tran->transactionId);
 401     printf("%sLast active time\t\t\t%d\n", prefix, tran->lastActiveTime);
 402     printf("%sCreation time\t\t\t%d\n", prefix, tran->creationTime);
 403     printf("%sError code\t\t\t%d\n", prefix, tran->errorCode);
 404     printf("%sVolume id\t\t\t\t%u\n", prefix, tran->volumeId);
 405     printf("%sPartition\t\t\t\t%d\n", prefix, tran->partition);
 406     printf("%sLast procedure name\t\t\t%s\n", prefix,
 407            tran->lastProcedureName);
 408     printf("%sNext receive packet seq num\t\t\t%d\n", prefix,
 409            tran->nextReceivePacketSequenceNumber);
 410     printf("%sNext send packet seq num\t\t\t%d\n", prefix,
 411            tran->nextSendPacketSequenceNumber);
 412     printf("%sLast receive time\t\t\t%d\n", prefix, tran->lastReceiveTime);
 413     printf("%sLast send time\t\t\t%d\n", prefix, tran->lastSendTime);
 414     printf("%sVolume attach mode\t\t\t%d\n", prefix, tran->volumeAttachMode);
 415     printf("%sVolume active status\t\t\t%d\n", prefix,
 416            tran->volumeActiveStatus);
 417     printf("%sVolume tran status\t\t\t%d\n", prefix,
 418            tran->volumeTransactionStatus);
 419 }
 420
 421 int
 422 DoVosServerTransactionStatusList(struct cmd_syndesc *as, void *arock)
 423 {
 424     typedef enum { SERVER } DoVosServerTransactionStatusList_parm_t;
 425     afs_status_t st = 0;
 426     void *vos_server = NULL;
 427     void *iter = NULL;
 428     vos_serverTransactionStatus_t tran;
 429
 430
 431     if (as->parms[SERVER].items) {
 432         if (!vos_ServerOpen
 433             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 434             ERR_ST_EXT("vos_ServerOpen", st);
 435         }
 436     }
 437
 438     if (!vos_ServerTransactionStatusGetBegin
 439         (cellHandle, vos_server, 0, &iter, &st)) {
 440         ERR_ST_EXT("vos_ServerTransactionStatusGetBegin", st);
 441     }
 442
 443     while (vos_ServerTransactionStatusGetNext(iter, &tran, &st)) {
 444         Print_vos_serverTransactionStatus_p(&tran, "");
 445     }
 446
 447     if (st != ADMITERATORDONE) {
 448         ERR_ST_EXT("vos_ServerTransactionStatusGetNext", st);
 449     }
 450
 451     if (!vos_ServerTransactionStatusGetDone(iter, &st)) {
 452         ERR_ST_EXT("vos_ServerTransactionStatusGetDone", st);
 453     }
 454     return 0;
 455 }
 456
 457 static void
 458 Print_vos_vldbEntry_p(vos_vldbEntry_p entry, const char *prefix)
 459 {
 460     int i;
 461
 462     printf("%sVolume entry %s\n", prefix, entry->name);
 463     printf("%sNumber of servers %d\n", prefix, entry->numServers);
 464     printf("%sRead write volume %u\n", prefix,
 465            entry->volumeId[VOS_READ_WRITE_VOLUME]);
 466     printf("%sRead only volume %u\n", prefix,
 467            entry->volumeId[VOS_READ_ONLY_VOLUME]);
 468     printf("%sBackup volume %u\n", prefix,
 469            entry->volumeId[VOS_BACKUP_VOLUME]);
 470     printf("%sClone volume %u\n", prefix, entry->cloneId);
 471
 472     printf("%sVolume entry status:\n", prefix);
 473     if (entry->status & VOS_VLDB_ENTRY_OK) {
 474         printf("%s\tVOS_VLDB_ENTRY_OK\n", prefix);
 475     }
 476     if (entry->status & VOS_VLDB_ENTRY_MOVE) {
 477         printf("%s\tVOS_VLDB_ENTRY_MOVE\n", prefix);
 478     }
 479     if (entry->status & VOS_VLDB_ENTRY_RELEASE) {
 480         printf("%s\tVOS_VLDB_ENTRY_RELEASE\n", prefix);
 481     }
 482     if (entry->status & VOS_VLDB_ENTRY_BACKUP) {
 483         printf("%s\tVOS_VLDB_ENTRY_BACKUP\n", prefix);
 484     }
 485     if (entry->status & VOS_VLDB_ENTRY_DELETE) {
 486         printf("%s\tVOS_VLDB_ENTRY_DELETE\n", prefix);
 487     }
 488     if (entry->status & VOS_VLDB_ENTRY_DUMP) {
 489         printf("%s\tVOS_VLDB_ENTRY_DUMP\n", prefix);
 490     }
 491     if (entry->status & VOS_VLDB_ENTRY_LOCKED) {
 492         printf("%s\tVOS_VLDB_ENTRY_LOCKED\n", prefix);
 493     }
 494     if (entry->status & VOS_VLDB_ENTRY_RWEXISTS) {
 495         printf("%s\tVOS_VLDB_ENTRY_RWEXISTS\n", prefix);
 496     }
 497     if (entry->status & VOS_VLDB_ENTRY_ROEXISTS) {
 498         printf("%s\tVOS_VLDB_ENTRY_ROEXISTS\n", prefix);
 499     }
 500     if (entry->status & VOS_VLDB_ENTRY_BACKEXISTS) {
 501         printf("%s\tVOS_VLDB_ENTRY_BACKEXISTS\n", prefix);
 502     }
 503
 504     printf("%sVolume location information for replicas:\n", prefix);
 505     for (i = 0; i < entry->numServers; i++) {
 506         printf("%s\tServer %x\n", prefix,
 507                entry->volumeSites[i].serverAddress);
 508         printf("%s\tPartition %x\n", prefix,
 509                entry->volumeSites[i].serverPartition);
 510         if (entry->volumeSites[i].serverFlags & VOS_VLDB_NEW_REPSITE) {
 511             printf("%s\tVOS_VLDB_NEW_REPSITE\n", prefix);
 512         }
 513         if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_ONLY) {
 514             printf("%s\tVOS_VLDB_READ_ONLY\n", prefix);
 515         }
 516         if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_WRITE) {
 517             printf("%s\tVOS_VLDB_READ_WRITE\n", prefix);
 518         }
 519         if (entry->volumeSites[i].serverFlags & VOS_VLDB_BACKUP) {
 520             printf("%s\tVOS_VLDB_BACKUP\n", prefix);
 521         }
 522         if (entry->volumeSites[i].serverFlags & VOS_VLDB_DONT_USE) {
 523             printf("%s\tVOS_VLDB_DONT_USE\n", prefix);
 524         }
 525     }
 526     printf("\n");
 527 }
 528
 529 int
 530 DoVosVLDBGet(struct cmd_syndesc *as, void *arock)
 531 {
 532     typedef enum { VOLUME } DoVosVLDBGet_parm_t;
 533     afs_status_t st = 0;
 534     vos_vldbEntry_t entry;
 535     unsigned int volume_id;
 536     char *volume_name = NULL;
 537
 538     if (as->parms[VOLUME].items) {
 539         const char *volume = as->parms[VOLUME].items->data;
 540         volume_id = GetVolumeIdFromString(volume);
 541     }
 542
 543
 544     if (!vos_VLDBGet(cellHandle, 0, &volume_id, volume_name, &entry, &st)) {
 545         ERR_ST_EXT("vos_VLDBGet", st);
 546     }
 547
 548     Print_vos_vldbEntry_p(&entry, "");
 549
 550     return 0;
 551 }
 552
 553 int
 554 DoVosVLDBList(struct cmd_syndesc *as, void *arock)
 555 {
 556     typedef enum { SERVER, PARTITION } DoVosVLDBList_parm_t;
 557     afs_status_t st = 0;
 558     void *vos_server = NULL;
 559     unsigned int partition_id;
 560     unsigned int *part_ptr = NULL;
 561     int have_server = 0;
 562     vos_vldbEntry_t entry;
 563     void *iter = NULL;
 564
 565     if (as->parms[SERVER].items) {
 566         if (!vos_ServerOpen
 567             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 568             ERR_ST_EXT("vos_ServerOpen", st);
 569         }
 570         have_server = 1;
 571     }
 572
 573     if (as->parms[PARTITION].items) {
 574         if (!have_server) {
 575             ERR_EXT("must specify server when specifying partition");
 576         }
 577         partition_id =
 578             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 579         part_ptr = &partition_id;
 580     }
 581
 582     if (!vos_VLDBGetBegin(cellHandle, vos_server, 0, part_ptr, &iter, &st)) {
 583         ERR_ST_EXT("vos_VLDBGetBegin", st);
 584     }
 585
 586     while (vos_VLDBGetNext(iter, &entry, &st)) {
 587         Print_vos_vldbEntry_p(&entry, "");
 588     }
 589
 590     if (st != ADMITERATORDONE) {
 591         ERR_ST_EXT("vos_VLDBGetNext", st);
 592     }
 593
 594     if (!vos_VLDBGetDone(iter, &st)) {
 595         ERR_ST_EXT("vos_VLDBGetDone", st);
 596     }
 597
 598     return 0;
 599 }
 600
 601 int
 602 DoVosVLDBEntryRemove(struct cmd_syndesc *as, void *arock)
 603 {
 604     typedef enum { SERVER, PARTITION, VOLUME } DoVosVLDBEntryRemove_parm_t;
 605     afs_status_t st = 0;
 606     void *vos_server = NULL;
 607     unsigned int partition_id;
 608     unsigned int *part_ptr = NULL;
 609     int have_server = 0;
 610     unsigned int volume_id;
 611     unsigned int *vol_ptr = NULL;
 612
 613     if (as->parms[SERVER].items) {
 614         if (!vos_ServerOpen
 615             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 616             ERR_ST_EXT("vos_ServerOpen", st);
 617         }
 618         have_server = 1;
 619     }
 620
 621     if (as->parms[PARTITION].items) {
 622         if (!have_server) {
 623             ERR_EXT("must specify server when specifying partition");
 624         }
 625         partition_id =
 626             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 627         part_ptr = &partition_id;
 628     }
 629
 630     if (as->parms[VOLUME].items) {
 631         const char *volume = as->parms[VOLUME].items->data;
 632         volume_id = GetVolumeIdFromString(volume);
 633         vol_ptr = &volume_id;
 634     }
 635
 636     if (!vos_VLDBEntryRemove
 637         (cellHandle, vos_server, 0, part_ptr, vol_ptr, &st)) {
 638         ERR_ST_EXT("vos_VLDBEntryRemove", st);
 639     }
 640
 641     return 0;
 642 }
 643
 644 int
 645 DoVosVLDBUnlock(struct cmd_syndesc *as, void *arock)
 646 {
 647     typedef enum { SERVER, PARTITION } DoVosVLDBUnlock_parm_t;
 648     afs_status_t st = 0;
 649     void *vos_server = NULL;
 650     unsigned int partition_id;
 651     unsigned int *part_ptr = NULL;
 652     int have_server = 0;
 653
 654     if (as->parms[SERVER].items) {
 655         if (!vos_ServerOpen
 656             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 657             ERR_ST_EXT("vos_ServerOpen", st);
 658         }
 659         have_server = 1;
 660     }
 661
 662     if (as->parms[PARTITION].items) {
 663         if (!have_server) {
 664             ERR_EXT("must specify server when specifying partition");
 665         }
 666         partition_id =
 667             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 668         part_ptr = &partition_id;
 669     }
 670
 671     if (!vos_VLDBUnlock(cellHandle, vos_server, 0, part_ptr, &st)) {
 672         ERR_ST_EXT("vos_VLDBUnlock", st);
 673     }
 674
 675     return 0;
 676 }
 677
 678 int
 679 DoVosVLDBEntryLock(struct cmd_syndesc *as, void *arock)
 680 {
 681     typedef enum { VOLUME } DoVosVLDBEntryLoc_parm_tk;
 682     afs_status_t st = 0;
 683     unsigned int volume_id = 0;
 684
 685     if (as->parms[VOLUME].items) {
 686         const char *volume = as->parms[VOLUME].items->data;
 687         volume_id = GetVolumeIdFromString(volume);
 688     }
 689
 690     if (!vos_VLDBEntryLock(cellHandle, 0, volume_id, &st)) {
 691         ERR_ST_EXT("vos_VLDBEntryLock", st);
 692     }
 693
 694     return 0;
 695 }
 696
 697 int
 698 DoVosVLDBEntryUnlock(struct cmd_syndesc *as, void *arock)
 699 {
 700     typedef enum { VOLUME } DoVosVLDBEntryUnlock_parm_t;
 701     afs_status_t st = 0;
 702     unsigned int volume_id = 0;
 703
 704     if (as->parms[VOLUME].items) {
 705         const char *volume = as->parms[VOLUME].items->data;
 706         volume_id = GetVolumeIdFromString(volume);
 707     }
 708
 709     if (!vos_VLDBEntryUnlock(cellHandle, 0, volume_id, &st)) {
 710         ERR_ST_EXT("vos_VLDBEntryUnlock", st);
 711     }
 712
 713     return 0;
 714 }
 715
 716 int
 717 DoVosVLDBReadOnlySiteCreate(struct cmd_syndesc *as, void *arock)
 718 {
 719     typedef enum { SERVER, PARTITION,
 720         VOLUME
 721     } DoVosVLDBReadOnlySiteCreate_parm_t;
 722     afs_status_t st = 0;
 723     void *vos_server = NULL;
 724     unsigned int partition_id = 0;
 725     unsigned int volume_id = 0;
 726
 727     if (as->parms[SERVER].items) {
 728         if (!vos_ServerOpen
 729             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 730             ERR_ST_EXT("vos_ServerOpen", st);
 731         }
 732     }
 733
 734     if (as->parms[PARTITION].items) {
 735         partition_id =
 736             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 737     }
 738
 739     if (as->parms[VOLUME].items) {
 740         const char *volume = as->parms[VOLUME].items->data;
 741         volume_id = GetVolumeIdFromString(volume);
 742     }
 743
 744     if (!vos_VLDBReadOnlySiteCreate
 745         (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
 746         ERR_ST_EXT("vos_VLDBReadOnlySiteCreate", st);
 747     }
 748     return 0;
 749 }
 750
 751 int
 752 DoVosVLDBReadOnlySiteDelete(struct cmd_syndesc *as, void *arock)
 753 {
 754     typedef enum { SERVER, PARTITION,
 755         VOLUME
 756     } DoVosVLDBReadOnlySiteDelete_parm_t;
 757     afs_status_t st = 0;
 758     void *vos_server = NULL;
 759     unsigned int partition_id = 0;
 760     unsigned int volume_id = 0;
 761
 762     if (as->parms[SERVER].items) {
 763         if (!vos_ServerOpen
 764             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 765             ERR_ST_EXT("vos_ServerOpen", st);
 766         }
 767     }
 768
 769     if (as->parms[PARTITION].items) {
 770         partition_id =
 771             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 772     }
 773
 774     if (as->parms[VOLUME].items) {
 775         const char *volume = as->parms[VOLUME].items->data;
 776         volume_id = GetVolumeIdFromString(volume);
 777     }
 778
 779     if (!vos_VLDBReadOnlySiteDelete
 780         (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
 781         ERR_ST_EXT("vos_VLDBReadOnlySiteDelete", st);
 782     }
 783
 784     return 0;
 785 }
 786
 787 int
 788 DoVosVLDBSync(struct cmd_syndesc *as, void *arock)
 789 {
 790     typedef enum { SERVER, PARTITION, FORCE } DoVosVLDBSync_parm_t;
 791     afs_status_t st = 0;
 792     void *vos_server = NULL;
 793     unsigned int partition_id;
 794     unsigned int *part_ptr = NULL;
 795     int have_server = 0;
 796     vos_force_t force = VOS_NORMAL;
 797
 798     if (as->parms[SERVER].items) {
 799         if (!vos_ServerOpen
 800             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 801             ERR_ST_EXT("vos_ServerOpen", st);
 802         }
 803         have_server = 1;
 804     }
 805
 806     if (as->parms[PARTITION].items) {
 807         if (!have_server) {
 808             ERR_EXT("must specify server when specifying partition");
 809         }
 810         partition_id =
 811             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 812         part_ptr = &partition_id;
 813     }
 814
 815     if (as->parms[FORCE].items) {
 816         force = VOS_FORCE;
 817     }
 818
 819     if (!vos_VLDBSync(cellHandle, vos_server, 0, part_ptr, force, &st)) {
 820         ERR_ST_EXT("vos_VLDBSync", st);
 821     }
 822
 823     return 0;
 824 }
 825
 826 int
 827 DoVosVolumeCreate(struct cmd_syndesc *as, void *arock)
 828 {
 829     typedef enum { SERVER, PARTITION, VOLUME,
 830         QUOTA
 831     } DoVosVolumeCreate_parm_t;
 832     afs_status_t st = 0;
 833     void *vos_server = NULL;
 834     unsigned int partition_id = 0;
 835     unsigned int volume_id;
 836     char *volume = NULL;
 837     unsigned int quota = 0;
 838
 839     if (as->parms[SERVER].items) {
 840         if (!vos_ServerOpen
 841             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 842             ERR_ST_EXT("vos_ServerOpen", st);
 843         }
 844     }
 845
 846     if (as->parms[PARTITION].items) {
 847         partition_id =
 848             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 849     }
 850
 851     if (as->parms[VOLUME].items) {
 852         volume = as->parms[VOLUME].items->data;
 853     }
 854
 855     if (as->parms[QUOTA].items) {
 856         quota =
 857             GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
 858     }
 859
 860     if (!vos_VolumeCreate
 861         (cellHandle, vos_server, 0, partition_id, volume, quota, &volume_id,
 862          &st)) {
 863         ERR_ST_EXT("vos_VolumeCreate", st);
 864     }
 865
 866     printf("Created volume %u\n", volume_id);
 867
 868     return 0;
 869 }
 870
 871 int
 872 DoVosVolumeDelete(struct cmd_syndesc *as, void *arock)
 873 {
 874     typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeDelete_parm_t;
 875     afs_status_t st = 0;
 876     void *vos_server = NULL;
 877     unsigned int partition_id = 0;
 878     unsigned int volume_id = 0;
 879
 880     if (as->parms[SERVER].items) {
 881         if (!vos_ServerOpen
 882             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 883             ERR_ST_EXT("vos_ServerOpen", st);
 884         }
 885     }
 886
 887     if (as->parms[PARTITION].items) {
 888         partition_id =
 889             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 890     }
 891
 892     if (as->parms[VOLUME].items) {
 893         const char *volume = as->parms[VOLUME].items->data;
 894         volume_id = GetVolumeIdFromString(volume);
 895     }
 896
 897     if (!vos_VolumeDelete
 898         (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
 899         ERR_ST_EXT("vos_VolumeDelete", st);
 900     }
 901
 902     return 0;
 903 }
 904
 905 int
 906 DoVosVolumeRename(struct cmd_syndesc *as, void *arock)
 907 {
 908     typedef enum { OLDVOLUME, NEWVOLUME } DoVosVolumeRename_parm_t;
 909     afs_status_t st = 0;
 910     unsigned int old_volume = 0;
 911     char *new_volume = NULL;
 912
 913     if (as->parms[OLDVOLUME].items) {
 914         const char *volume = as->parms[OLDVOLUME].items->data;
 915         old_volume = GetVolumeIdFromString(volume);
 916     }
 917
 918     if (as->parms[NEWVOLUME].items) {
 919         new_volume = as->parms[NEWVOLUME].items->data;
 920     }
 921
 922     if (!vos_VolumeRename(cellHandle, 0, old_volume, new_volume, &st)) {
 923         ERR_ST_EXT("vos_VolumeRename", st);
 924     }
 925
 926     return 0;
 927 }
 928
 929 int
 930 DoVosVolumeDump(struct cmd_syndesc *as, void *arock)
 931 {
 932     typedef enum { SERVER, PARTITION, VOLUME, STARTTIME,
 933         DUMPFILE
 934     } DoVosVolumeDump_parm_t;
 935     afs_status_t st = 0;
 936     void *vos_server = NULL;
 937     unsigned int partition_id;
 938     unsigned int *part_ptr = NULL;
 939     int have_server = 0;
 940     unsigned int volume_id = 0;
 941     unsigned int start_time = 0;
 942     const char *dumpfile = NULL;
 943
 944     if (as->parms[SERVER].items) {
 945         if (!vos_ServerOpen
 946             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
 947             ERR_ST_EXT("vos_ServerOpen", st);
 948         }
 949         have_server = 1;
 950     }
 951
 952     if (as->parms[PARTITION].items) {
 953         if (!have_server) {
 954             ERR_EXT("must specify server when specifying partition");
 955         }
 956         partition_id =
 957             GetPartitionIdFromString(as->parms[PARTITION].items->data);
 958         part_ptr = &partition_id;
 959     }
 960
 961     if (as->parms[VOLUME].items) {
 962         const char *volume = as->parms[VOLUME].items->data;
 963         volume_id = GetVolumeIdFromString(volume);
 964     }
 965
 966     if (as->parms[STARTTIME].items) {
 967         start_time =
 968             GetIntFromString(as->parms[STARTTIME].items->data,
 969                              "invalid start time");
 970     }
 971
 972     if (as->parms[DUMPFILE].items) {
 973         dumpfile = as->parms[DUMPFILE].items->data;
 974     }
 975
 976     if (!vos_VolumeDump
 977         (cellHandle, vos_server, 0, part_ptr, volume_id, start_time, dumpfile,
 978          &st)) {
 979         ERR_ST_EXT("vos_VolumeDump", st);
 980     }
 981
 982     return 0;
 983 }
 984
 985 int
 986 DoVosVolumeRestore(struct cmd_syndesc *as, void *arock)
 987 {
 988     typedef enum { SERVER, PARTITION, ID, VOLUME, DUMPFILE,
 989         FULL
 990     } DoVosVolumeRestore_parm_t;
 991     afs_status_t st = 0;
 992     void *vos_server = NULL;
 993     unsigned int partition_id = 0;
 994     unsigned int volume_id;
 995     unsigned int *vol_ptr = NULL;
 996     const char *dumpfile = NULL;
 997     char *volume_name = NULL;
 998     vos_volumeRestoreType_t restore = VOS_RESTORE_INCREMENTAL;
 999
1000     if (as->parms[SERVER].items) {
1001         if (!vos_ServerOpen
1002             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1003             ERR_ST_EXT("vos_ServerOpen", st);
1004         }
1005     }
1006
1007     if (as->parms[PARTITION].items) {
1008         partition_id =
1009             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1010     }
1011
1012     if (as->parms[VOLUME].items) {
1013         volume_name = as->parms[VOLUME].items->data;
1014     }
1015
1016     if (as->parms[ID].items) {
1017         const char *volume = as->parms[ID].items->data;
1018         volume_id = GetVolumeIdFromString(volume);
1019         vol_ptr = &volume_id;
1020     }
1021
1022     if (as->parms[DUMPFILE].items) {
1023         dumpfile = as->parms[DUMPFILE].items->data;
1024     }
1025
1026     if (as->parms[FULL].items) {
1027         restore = VOS_RESTORE_FULL;
1028     }
1029
1030     if (!vos_VolumeRestore
1031         (cellHandle, vos_server, 0, partition_id, vol_ptr, volume_name,
1032          dumpfile, restore, &st)) {
1033         ERR_ST_EXT("vos_VolumeRestore", st);
1034     }
1035
1036     return 0;
1037 }
1038
1039 int
1040 DoVosVolumeOnline(struct cmd_syndesc *as, void *arock)
1041 {
1042     typedef enum { SERVER, PARTITION, VOLUME, SLEEP,
1043         BUSY
1044     } DoVosVolumeOnline_parm_t;
1045     afs_status_t st = 0;
1046     void *vos_server = NULL;
1047     unsigned int partition_id = 0;
1048     unsigned int volume_id = 0;
1049     unsigned int sleep = 0;
1050     vos_volumeOnlineType_t type = VOS_ONLINE_OFFLINE;
1051
1052     if (as->parms[SERVER].items) {
1053         if (!vos_ServerOpen
1054             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1055             ERR_ST_EXT("vos_ServerOpen", st);
1056         }
1057     }
1058
1059     if (as->parms[PARTITION].items) {
1060         partition_id =
1061             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1062     }
1063
1064     if (as->parms[VOLUME].items) {
1065         const char *volume = as->parms[VOLUME].items->data;
1066         volume_id = GetVolumeIdFromString(volume);
1067     }
1068
1069     if (as->parms[SLEEP].items) {
1070         sleep =
1071             GetIntFromString(as->parms[SLEEP].items->data,
1072                              "invalid sleep time");
1073     }
1074
1075     if (as->parms[BUSY].items) {
1076         type = VOS_ONLINE_BUSY;
1077     }
1078
1079     if (!vos_VolumeOnline
1080         (vos_server, 0, partition_id, volume_id, sleep, type, &st)) {
1081         ERR_ST_EXT("vos_VolumeOnline", st);
1082     }
1083
1084     return 0;
1085 }
1086
1087 int
1088 DoVosVolumeOffline(struct cmd_syndesc *as, void *arock)
1089 {
1090     typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeOffline_parm_t;
1091     afs_status_t st = 0;
1092     void *vos_server = NULL;
1093     unsigned int partition_id = 0;
1094     unsigned int volume_id = 0;
1095
1096     if (as->parms[SERVER].items) {
1097         if (!vos_ServerOpen
1098             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1099             ERR_ST_EXT("vos_ServerOpen", st);
1100         }
1101     }
1102
1103     if (as->parms[PARTITION].items) {
1104         partition_id =
1105             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1106     }
1107
1108     if (as->parms[VOLUME].items) {
1109         const char *volume = as->parms[VOLUME].items->data;
1110         volume_id = GetVolumeIdFromString(volume);
1111     }
1112
1113     if (!vos_VolumeOffline(vos_server, 0, partition_id, volume_id, &st)) {
1114         ERR_ST_EXT("vos_VolumeOffline", st);
1115     }
1116
1117     return 0;
1118 }
1119
1120 static void
1121 Print_vos_volumeEntry_p(vos_volumeEntry_p entry, const char *prefix)
1122 {
1123     if (entry->status == VOS_OK) {
1124         printf("%sVolume name %s id %u\n", prefix, entry->name, entry->id);
1125         printf("%sRead write id %u\n", prefix, entry->readWriteId);
1126         printf("%sRead only id %u\n", prefix, entry->readOnlyId);
1127         printf("%sBackup id %u\n", prefix, entry->backupId);
1128         printf("%sCreation date %lu\n", prefix, entry->creationDate);
1129         printf("%sLast access date %lu\n", prefix, entry->lastAccessDate);
1130         printf("%sLast update date %lu\n", prefix, entry->lastUpdateDate);
1131         printf("%sLast backup date %lu\n", prefix, entry->lastBackupDate);
1132         printf("%sLast copy creation date %lu\n", prefix,
1133                entry->copyCreationDate);
1134         printf("%sAccesses since midnight %d\n", prefix,
1135                entry->accessesSinceMidnight);
1136         printf("%sFile count %d\n", prefix, entry->fileCount);
1137         printf("%sMax quota %d\n", prefix, entry->maxQuota);
1138         printf("%sCurrent size %d\n", prefix, entry->currentSize);
1139
1140         printf("%sVolume status: VOS_OK\n", prefix);
1141
1142         printf("%sVolume disposition:\n", prefix);
1143
1144         switch (entry->volumeDisposition) {
1145         case VOS_OK:
1146             printf("%s\tVOS_OK\n", prefix);
1147             break;
1148         case VOS_SALVAGE:
1149             printf("%s\tVOS_SALVAGE\n", prefix);
1150             break;
1151         case VOS_NO_VNODE:
1152             printf("%s\tVOS_NO_VNODE\n", prefix);
1153             break;
1154         case VOS_NO_VOL:
1155             printf("%s\tVOS_NO_VOL\n", prefix);
1156             break;
1157         case VOS_VOL_EXISTS:
1158             printf("%s\tVOS_VOL_EXISTS\n", prefix);
1159             break;
1160         case VOS_NO_SERVICE:
1161             printf("%s\tVOS_NO_SERVICE\n", prefix);
1162             break;
1163         case VOS_OFFLINE:
1164             printf("%s\tVOS_OFFLINE\n", prefix);
1165             break;
1166         case VOS_ONLINE:
1167             printf("%s\tVOS_ONLINE\n", prefix);
1168             break;
1169         case VOS_DISK_FULL:
1170             printf("%s\tVOS_DISK_FULL\n", prefix);
1171             break;
1172         case VOS_OVER_QUOTA:
1173             printf("%s\tVOS_OVER_QUOTA\n", prefix);
1174             break;
1175         case VOS_BUSY:
1176             printf("%s\tVOS_BUSY\n", prefix);
1177             break;
1178         case VOS_MOVED:
1179             printf("%s\tVOS_MOVED\n", prefix);
1180             break;
1181         default:
1182             printf("Unknown volume disposition %d\n",
1183                    entry->volumeDisposition);
1184             break;
1185         }
1186
1187         printf("%sVolume type: ", prefix);
1188
1189         if (entry->type == VOS_READ_WRITE_VOLUME) {
1190             printf("read write\n");
1191         } else if (entry->type == VOS_READ_ONLY_VOLUME) {
1192             printf("read only\n");
1193         } else {
1194             printf("backup\n");
1195         }
1196
1197         printf("\n%s\tSame Network\tSame Network Authenticated"
1198                "\tDifferent Network\tDifferent Network Authenticated\n\n",
1199                prefix);
1200         printf("%sRead\t%d\t%d\t%d\t%d\n", prefix,
1201                entry->readStats[VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK],
1202                entry->
1203                readStats
1204                [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1205                entry->
1206                readStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
1207                entry->
1208                readStats
1209                [VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK_AUTHENTICATED]);
1210         printf("%sWrite\t%d\t%d\t%d\t%d\n", prefix,
1211                entry->writeStats[VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK],
1212                entry->
1213                writeStats
1214                [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1215                entry->
1216                writeStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
1217                entry->
1218                writeStats
1219                [VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK_AUTHENTICATED]);
1220
1221         printf
1222             ("\n%s\t0 to 60 secs\t1 to 10 mins\t10 to 60 mins\t1 to 24 hrs\t1 to 7 days\t more than 7 days\n",
1223              prefix);
1224         printf("%sFile Author Write Same Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1225                prefix,
1226                entry->
1227                fileAuthorWriteSameNetwork
1228                [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1229                entry->
1230                fileAuthorWriteSameNetwork
1231                [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1232                entry->
1233                fileAuthorWriteSameNetwork
1234                [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1235                entry->
1236                fileAuthorWriteSameNetwork
1237                [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1238                entry->
1239                fileAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1240                entry->
1241                fileAuthorWriteSameNetwork
1242                [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1243         printf("%sFile Author Write Diff Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1244                prefix,
1245                entry->
1246                fileAuthorWriteDifferentNetwork
1247                [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1248                entry->
1249                fileAuthorWriteDifferentNetwork
1250                [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1251                entry->
1252                fileAuthorWriteDifferentNetwork
1253                [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1254                entry->
1255                fileAuthorWriteDifferentNetwork
1256                [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1257                entry->
1258                fileAuthorWriteDifferentNetwork
1259                [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1260                entry->
1261                fileAuthorWriteDifferentNetwork
1262                [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1263         printf("%sDir Author Write Same Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1264                prefix,
1265                entry->
1266                dirAuthorWriteSameNetwork
1267                [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1268                entry->
1269                dirAuthorWriteSameNetwork
1270                [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1271                entry->
1272                dirAuthorWriteSameNetwork
1273                [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1274                entry->
1275                dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1276                entry->
1277                dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1278                entry->
1279                dirAuthorWriteSameNetwork
1280                [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1281         printf("%sDir Author Write Diff Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1282                prefix,
1283                entry->
1284                dirAuthorWriteDifferentNetwork
1285                [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1286                entry->
1287                dirAuthorWriteDifferentNetwork
1288                [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1289                entry->
1290                dirAuthorWriteDifferentNetwork
1291                [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1292                entry->
1293                dirAuthorWriteDifferentNetwork
1294                [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1295                entry->
1296                dirAuthorWriteDifferentNetwork
1297                [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1298                entry->
1299                dirAuthorWriteDifferentNetwork
1300                [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1301     } else {
1302         printf("%sUnable to print volume because volume status:\n", prefix);
1303         switch (entry->status) {
1304         case VOS_SALVAGE:
1305             printf("%s\tVOS_SALVAGE\n", prefix);
1306             break;
1307         case VOS_NO_VNODE:
1308             printf("%s\tVOS_NO_VNODE\n", prefix);
1309             break;
1310         case VOS_NO_VOL:
1311             printf("%s\tVOS_NO_VOL\n", prefix);
1312             break;
1313         case VOS_VOL_EXISTS:
1314             printf("%s\tVOS_VOL_EXISTS\n", prefix);
1315             break;
1316         case VOS_NO_SERVICE:
1317             printf("%s\tVOS_NO_SERVICE\n", prefix);
1318             break;
1319         case VOS_OFFLINE:
1320             printf("%s\tVOS_OFFLINE\n", prefix);
1321             break;
1322         case VOS_ONLINE:
1323             printf("%s\tVOS_ONLINE\n", prefix);
1324             break;
1325         case VOS_DISK_FULL:
1326             printf("%s\tVOS_DISK_FULL\n", prefix);
1327             break;
1328         case VOS_OVER_QUOTA:
1329             printf("%s\tVOS_OVER_QUOTA\n", prefix);
1330             break;
1331         case VOS_BUSY:
1332             printf("%s\tVOS_BUSY\n", prefix);
1333             break;
1334         case VOS_MOVED:
1335             printf("%s\tVOS_MOVED\n", prefix);
1336             break;
1337         default:
1338             printf("Unknown volume status %d\n", entry->status);
1339             break;
1340         }
1341     }
1342 }
1343
1344 int
1345 DoVosVolumeGet(struct cmd_syndesc *as, void *arock)
1346 {
1347     typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1348     afs_status_t st = 0;
1349     void *vos_server = NULL;
1350     unsigned int partition_id = 0;
1351     unsigned int volume_id = 0;
1352     vos_volumeEntry_t entry;
1353
1354     if (as->parms[SERVER].items) {
1355         if (!vos_ServerOpen
1356             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1357             ERR_ST_EXT("vos_ServerOpen", st);
1358         }
1359     }
1360
1361     if (as->parms[PARTITION].items) {
1362         partition_id =
1363             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1364     }
1365
1366     if (as->parms[VOLUME].items) {
1367         const char *volume = as->parms[VOLUME].items->data;
1368         volume_id = GetVolumeIdFromString(volume);
1369     }
1370
1371     if (!vos_VolumeGet
1372         (cellHandle, vos_server, 0, partition_id, volume_id, &entry, &st)) {
1373         ERR_ST_EXT("vos_VolumeGet", st);
1374     }
1375
1376     Print_vos_volumeEntry_p(&entry, "");
1377
1378     return 0;
1379 }
1380
1381 int
1382 DoVosVolumeList(struct cmd_syndesc *as, void *arock)
1383 {
1384     typedef enum { SERVER, PARTITION } DoVosVolumeList_parm_t;
1385     afs_status_t st = 0;
1386     void *vos_server = NULL;
1387     void *iter = NULL;
1388     unsigned int partition_id = 0;
1389     vos_volumeEntry_t entry;
1390
1391     if (as->parms[SERVER].items) {
1392         if (!vos_ServerOpen
1393             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1394             ERR_ST_EXT("vos_ServerOpen", st);
1395         }
1396     }
1397
1398     if (as->parms[PARTITION].items) {
1399         partition_id =
1400             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1401     }
1402
1403     if (!vos_VolumeGetBegin
1404         (cellHandle, vos_server, 0, partition_id, &iter, &st)) {
1405         ERR_ST_EXT("vos_VolumeGetBegin", st);
1406     }
1407
1408     printf("Volumes located at %s partition %s\n",
1409            as->parms[SERVER].items->data, as->parms[PARTITION].items->data);
1410
1411     while (vos_VolumeGetNext(iter, &entry, &st)) {
1412         Print_vos_volumeEntry_p(&entry, "    ");
1413         printf("\n");
1414     }
1415
1416     if (st != ADMITERATORDONE) {
1417         ERR_ST_EXT("vos_VolumeGetNext", st);
1418     }
1419
1420     if (!vos_VolumeGetDone(iter, &st)) {
1421         ERR_ST_EXT("vos_VolumeGetDone", st);
1422     }
1423
1424     return 0;
1425 }
1426
1427 int
1428 DoVosVolumeMove(struct cmd_syndesc *as, void *arock)
1429 {
1430     typedef enum { VOLUME, FROMSERVER, FROMPARTITION, TOSERVER,
1431         TOPARTITION
1432     } DoVosVolumeMove_parm_t;
1433     afs_status_t st = 0;
1434     void *from_server = NULL;
1435     void *to_server = NULL;
1436     unsigned int from_partition = 0;
1437     unsigned int to_partition = 0;
1438     unsigned int volume_id = 0;
1439
1440     if (as->parms[FROMSERVER].items) {
1441         if (!vos_ServerOpen
1442             (cellHandle, as->parms[FROMSERVER].items->data, &from_server,
1443              &st)) {
1444             ERR_ST_EXT("vos_ServerOpen", st);
1445         }
1446     }
1447
1448     if (as->parms[TOSERVER].items) {
1449         if (!vos_ServerOpen
1450             (cellHandle, as->parms[TOSERVER].items->data, &to_server, &st)) {
1451             ERR_ST_EXT("vos_ServerOpen", st);
1452         }
1453     }
1454
1455     if (as->parms[FROMPARTITION].items) {
1456         from_partition =
1457             GetPartitionIdFromString(as->parms[FROMPARTITION].items->data);
1458     }
1459
1460     if (as->parms[TOPARTITION].items) {
1461         to_partition =
1462             GetPartitionIdFromString(as->parms[TOPARTITION].items->data);
1463     }
1464
1465     if (as->parms[VOLUME].items) {
1466         const char *volume = as->parms[VOLUME].items->data;
1467         volume_id = GetVolumeIdFromString(volume);
1468     }
1469
1470     if (!vos_VolumeMove
1471         (cellHandle, 0, volume_id, from_server, from_partition, to_server,
1472          to_partition, &st)) {
1473         ERR_ST_EXT("vos_VolumeMove", st);
1474     }
1475
1476     return 0;
1477 }
1478
1479 int
1480 DoVosVolumeRelease(struct cmd_syndesc *as, void *arock)
1481 {
1482     typedef enum { VOLUME, FORCE } DoVosVolumeRelease_parm_t;
1483     afs_status_t st = 0;
1484     unsigned int volume_id = 0;
1485     vos_force_t force = VOS_NORMAL;
1486
1487     if (as->parms[VOLUME].items) {
1488         const char *volume = as->parms[VOLUME].items->data;
1489         volume_id = GetVolumeIdFromString(volume);
1490     }
1491
1492     if (as->parms[FORCE].items) {
1493         force = VOS_FORCE;
1494     }
1495
1496     if (!vos_VolumeRelease(cellHandle, 0, volume_id, force, &st)) {
1497         ERR_ST_EXT("vos_VolumeRelease", st);
1498     }
1499     return 0;
1500 }
1501
1502 int
1503 DoVosVolumeZap(struct cmd_syndesc *as, void *arock)
1504 {
1505     typedef enum { SERVER, PARTITION, VOLUME, FORCE } DoVosVolumeZap_parm_t;
1506     afs_status_t st = 0;
1507     void *vos_server = NULL;
1508     unsigned int partition_id = 0;
1509     unsigned int volume_id = 0;
1510     vos_force_t force = VOS_NORMAL;
1511
1512     if (as->parms[SERVER].items) {
1513         if (!vos_ServerOpen
1514             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1515             ERR_ST_EXT("vos_ServerOpen", st);
1516         }
1517     }
1518
1519     if (as->parms[PARTITION].items) {
1520         partition_id =
1521             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1522     }
1523
1524     if (as->parms[VOLUME].items) {
1525         const char *volume = as->parms[VOLUME].items->data;
1526         volume_id = GetVolumeIdFromString(volume);
1527     }
1528
1529     if (as->parms[FORCE].items) {
1530         force = VOS_FORCE;
1531     }
1532
1533     if (!vos_VolumeZap
1534         (cellHandle, vos_server, 0, partition_id, volume_id, force, &st)) {
1535         ERR_ST_EXT("vos_VolumeZap", st);
1536     }
1537
1538     return 0;
1539 }
1540
1541 int
1542 DoVosPartitionNameToId(struct cmd_syndesc *as, void *arock)
1543 {
1544     typedef enum { PARTITION } DoVosPartitionNameToId_parm_t;
1545     unsigned int partition_id = 0;
1546
1547     if (as->parms[PARTITION].items) {
1548         partition_id =
1549             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1550     }
1551
1552     printf("The id for partition %s is %u\n",
1553            as->parms[PARTITION].items->data, partition_id);
1554
1555     return 0;
1556 }
1557
1558 int
1559 DoVosPartitionIdToName(struct cmd_syndesc *as, void *arock)
1560 {
1561     typedef enum { PARTITIONID } DoVosPartitionIdToName_parm_t;
1562     afs_status_t st = 0;
1563     unsigned int partition_id = 0;
1564     char partition[VOS_MAX_PARTITION_NAME_LEN];
1565
1566     if (as->parms[PARTITIONID].items) {
1567         partition_id =
1568             GetIntFromString(as->parms[PARTITIONID].items->data,
1569                              "bad partition id");
1570     }
1571
1572     if (!vos_PartitionIdToName(partition_id, partition, &st)) {
1573         ERR_ST_EXT("bad partition id", st);
1574     }
1575
1576     printf("The partition for id %u is %s\n", partition_id, partition);
1577
1578     return 0;
1579 }
1580
1581 int
1582 DoVosVolumeQuotaChange(struct cmd_syndesc *as, void *arock)
1583 {
1584     typedef enum { SERVER, PARTITION, VOLUME,
1585         QUOTA
1586     } DoVosVolumeQuotaChange_parm_t;
1587     afs_status_t st = 0;
1588     void *vos_server = NULL;
1589     unsigned int partition_id = 0;
1590     unsigned int volume_id = 0;
1591     unsigned int quota = 0;
1592
1593     if (as->parms[SERVER].items) {
1594         if (!vos_ServerOpen
1595             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1596             ERR_ST_EXT("vos_ServerOpen", st);
1597         }
1598     }
1599
1600     if (as->parms[PARTITION].items) {
1601         partition_id =
1602             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1603     }
1604
1605     if (as->parms[VOLUME].items) {
1606         const char *volume = as->parms[VOLUME].items->data;
1607         volume_id = GetVolumeIdFromString(volume);
1608     }
1609
1610     if (as->parms[QUOTA].items) {
1611         quota =
1612             GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
1613     }
1614
1615     if (!vos_VolumeQuotaChange
1616         (cellHandle, vos_server, 0, partition_id, volume_id, quota, &st)) {
1617         ERR_ST_EXT("vos_VolumeQuotaChange", st);
1618     }
1619
1620     return 0;
1621 }
1622
1623 /*
1624  * Parse a server name/address and return the address in HOST BYTE order
1625  */
1626 static afs_uint32
1627 GetServer(char *aname)
1628 {
1629     struct hostent *th;
1630     afs_uint32 addr;
1631     int b1, b2, b3, b4;
1632     afs_int32 code;
1633     char hostname[MAXHOSTCHARS];
1634
1635     code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
1636     if (code == 4) {
1637         addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
1638         addr = ntohl(addr);     /* convert to host order */
1639     } else {
1640         th = gethostbyname(aname);
1641         if (!th)
1642             return 0;
1643         memcpy(&addr, th->h_addr, sizeof(addr));
1644     }
1645
1646     if (rx_IsLoopbackAddr(ntohl(addr))) {       /* local host */
1647         code = gethostname(hostname, MAXHOSTCHARS);
1648         if (code)
1649             return 0;
1650         th = gethostbyname(hostname);   /* returns host byte order */
1651         if (!th)
1652             return 0;
1653         memcpy(&addr, th->h_addr, sizeof(addr));
1654     }
1655
1656     return (addr);
1657 }
1658
1659 static void
1660 Print_vos_volintInfo(afs_uint32 server, afs_uint32 partition, volintInfo* pinfo, const char *prefix)
1661 {
1662     static afs_uint32 server_cache;
1663     static int cache_valid = 0;
1664     static char hostname[256], address[32];
1665
1666     if (!cache_valid || server != server_cache) {
1667         struct in_addr s;
1668
1669         s.s_addr = server;
1670         strcpy(hostname, hostutil_GetNameByINet(server));
1671         strcpy(address, inet_ntoa(s));
1672         server_cache = server;
1673         cache_valid = 1;
1674     }
1675
1676
1677     printf("%sname\t\t%s\n",prefix, pinfo->name);
1678     printf("%sid\t\t%lu\n",prefix, afs_printable_uint32_lu(pinfo->volid));
1679     printf("%sserv\t\t%s\t%s\n",prefix, address,hostname);
1680     printf("%spart\t\t%u\n", prefix,partition);
1681
1682     switch (pinfo->status) {
1683     case 2: /* VOK */
1684         printf("%sstatus\t\tOK\n",prefix);
1685         break;
1686     case 101: /* VBUSY */
1687         printf("%sstatus\t\tBUSY\n",prefix);
1688         return;
1689     default:
1690         printf("%sstatus\t\tUNATTACHABLE\n",prefix);
1691         return;
1692     }
1693     printf("%sbackupID\t%lu\n",prefix,
1694            afs_printable_uint32_lu(pinfo->backupID));
1695     printf("%sparentID\t%lu\n",prefix,
1696            afs_printable_uint32_lu(pinfo->parentID));
1697     printf("%scloneID\t%lu\n",prefix,
1698            afs_printable_uint32_lu(pinfo->cloneID));
1699     printf("%sinUse\t\t%s\n",prefix, pinfo->inUse ? "Y" : "N");
1700     printf("%sneedsSalvaged\t%s\n",prefix, pinfo->needsSalvaged ? "Y" : "N");
1701     /* 0xD3 is from afs/volume.h since I had trouble including the file */
1702     printf("%sdestroyMe\t%s\n",prefix, pinfo->destroyMe == 0xD3 ? "Y" : "N");
1703     switch (pinfo->type) {
1704     case 0:
1705         printf("%stype\t\tRW\n",prefix);
1706         break;
1707     case 1:
1708         printf("%stype\t\tRO\n",prefix);
1709         break;
1710     case 2:
1711         printf("%stype\t\tBK\n",prefix);
1712         break;
1713     default:
1714         printf("%stype\t\t?\n",prefix);
1715         break;
1716     }
1717     printf("%screationDate\t%-9lu\n", prefix,
1718            afs_printable_uint32_lu(pinfo->creationDate));
1719     printf("%saccessDate\t%-9lu\n", prefix,
1720            afs_printable_uint32_lu(pinfo->accessDate));
1721     printf("%supdateDate\t%-9lu\n", prefix,
1722            afs_printable_uint32_lu(pinfo->updateDate));
1723     printf("%sbackupDate\t%-9lu\n", prefix,
1724            afs_printable_uint32_lu(pinfo->backupDate));
1725     printf("%scopyDate\t%-9lu\n", prefix,
1726            afs_printable_uint32_lu(pinfo->copyDate));
1727
1728     printf("%sflags\t\t%#lx\t(Optional)\n",prefix, afs_printable_int32_ld(pinfo->flags));
1729     printf("%sdiskused\t%u\n",prefix, pinfo->size);
1730     printf("%smaxquota\t%u\n",prefix, pinfo->maxquota);
1731     printf("%sminquota\t%lu\t(Optional)\n",prefix,
1732            afs_printable_uint32_lu(pinfo->spare0));
1733     printf("%sfilecount\t%u\n",prefix, pinfo->filecount);
1734     printf("%sdayUse\t\t%u\n",prefix, pinfo->dayUse);
1735     printf("%sweekUse\t%lu\t(Optional)\n",prefix,
1736            afs_printable_uint32_lu(pinfo->spare1));
1737     printf("%svolUpdateCounter\t\t%lu\t(Optional)\n",prefix,
1738            afs_printable_uint32_lu(pinfo->spare2));
1739     printf("%sspare3\t\t%lu\t(Optional)\n",prefix,
1740            afs_printable_uint32_lu(pinfo->spare3));
1741 }
1742
1743 int
1744 DoVosVolumeGet2(struct cmd_syndesc *as, void *arock)
1745 {
1746     typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1747     afs_status_t st = 0;
1748     void *vos_server = NULL;
1749     afs_uint32 partition_id = 0;
1750     afs_uint32 volume_id = 0;
1751
1752         volintInfo info;
1753         memset(&info, 0, sizeof(struct volintInfo));
1754
1755     if (as->parms[SERVER].items) {
1756         if (!vos_ServerOpen
1757             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1758             ERR_ST_EXT("vos_ServerOpen", st);
1759         }
1760     }
1761
1762     if (as->parms[PARTITION].items) {
1763         partition_id =
1764             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1765     }
1766
1767     if (as->parms[VOLUME].items) {
1768         const char *volume = as->parms[VOLUME].items->data;
1769         volume_id = GetVolumeIdFromString(volume);
1770     }
1771
1772
1773         if (!vos_VolumeGet2
1774         (cellHandle, vos_server, 0, partition_id, volume_id, &info, &st)) {
1775         ERR_ST_EXT("vos_VolumeGet2", st);
1776     }
1777
1778
1779     Print_vos_volintInfo(GetServer(as->parms[SERVER].items->data),partition_id,&info," ");
1780
1781     return 0;
1782 }
1783
1784
1785 int
1786 DoVos_ClearVolUpdateCounter(struct cmd_syndesc *as, void *arock)
1787 {
1788     typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1789     afs_status_t st = 0;
1790     void *vos_server = NULL;
1791     unsigned int partition_id = 0;
1792     unsigned int volume_id = 0;
1793
1794     if (as->parms[SERVER].items) {
1795         if (!vos_ServerOpen
1796             (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1797             ERR_ST_EXT("vos_ServerOpen", st);
1798         }
1799     }
1800
1801     if (as->parms[PARTITION].items) {
1802         partition_id =
1803             GetPartitionIdFromString(as->parms[PARTITION].items->data);
1804     }
1805
1806     if (as->parms[VOLUME].items) {
1807         const char *volume = as->parms[VOLUME].items->data;
1808         volume_id = GetVolumeIdFromString(volume);
1809     }
1810
1811     if (!vos_ClearVolUpdateCounter
1812         (cellHandle, vos_server,partition_id, volume_id, &st)) {
1813         ERR_ST_EXT("vos_ClearVolUpdateCounter", st);
1814     }
1815
1816     return 0;
1817 }
1818
1819 void
1820 SetupVosAdminCmd(void)
1821 {
1822     struct cmd_syndesc *ts;
1823
1824     ts = cmd_CreateSyntax("VosBackupVolumeCreate", DoVosBackupVolumeCreate, NULL,
1825                           "create a backup volume");
1826     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to back up");
1827     SetupCommonCmdArgs(ts);
1828
1829     ts = cmd_CreateSyntax("VosBackupVolumeCreateMultiple",
1830                           DoVosBackupVolumeCreateMultiple, NULL,
1831                           "create a backup volume");
1832     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1833                 "server housing volumes to back up");
1834     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1835                 "partition housing volumes to back up");
1836     cmd_AddParm(ts, "-prefix", CMD_SINGLE, CMD_OPTIONAL,
1837                 "common prefix of volumes to back up");
1838     cmd_AddParm(ts, "-exclude", CMD_FLAG, CMD_OPTIONAL,
1839                 "exclude volumes from backup that match prefix");
1840     SetupCommonCmdArgs(ts);
1841
1842     ts = cmd_CreateSyntax("VosPartitionGet", DoVosPartitionGet, NULL,
1843                           "get information about a partition");
1844     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1845                 "server housing partition of interest");
1846     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1847                 "partition to query");
1848     SetupCommonCmdArgs(ts);
1849
1850     ts = cmd_CreateSyntax("VosPartitionList", DoVosPartitionList, NULL,
1851                           "list information about all partitions at a server");
1852     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1853                 "server housing partitions of interest");
1854     SetupCommonCmdArgs(ts);
1855
1856     ts = cmd_CreateSyntax("VosServerSync", DoVosServerSync, NULL,
1857                           "sync server with vldb");
1858     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
1859     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1860                 "partition to sync");
1861     SetupCommonCmdArgs(ts);
1862
1863     ts = cmd_CreateSyntax("VosFileServerAddressChange",
1864                           DoVosFileServerAddressChange, NULL,
1865                           "change a server's address in the vldb");
1866     cmd_AddParm(ts, "-oldaddress", CMD_SINGLE, CMD_REQUIRED,
1867                 "old address to change");
1868     cmd_AddParm(ts, "-newaddress", CMD_SINGLE, CMD_REQUIRED, "new address");
1869     SetupCommonCmdArgs(ts);
1870
1871     ts = cmd_CreateSyntax("VosFileServerAddressRemove",
1872                           DoVosFileServerAddressRemove, NULL,
1873                           "remove a server's address from the vldb");
1874     cmd_AddParm(ts, "-address", CMD_SINGLE, CMD_REQUIRED,
1875                 "address to remove");
1876     SetupCommonCmdArgs(ts);
1877
1878     ts = cmd_CreateSyntax("VosFileServerList", DoVosFileServerList, NULL,
1879                           "list the file servers in a cell");
1880     SetupCommonCmdArgs(ts);
1881
1882     ts = cmd_CreateSyntax("VosServerTransactionStatusList",
1883                           DoVosServerTransactionStatusList, NULL,
1884                           "list the active transactions at a server");
1885     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1886     SetupCommonCmdArgs(ts);
1887
1888     ts = cmd_CreateSyntax("VosVLDBGet", DoVosVLDBGet, NULL,
1889                           "get a vldb entry for a volume");
1890     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1891                 "volume to retrieve");
1892     SetupCommonCmdArgs(ts);
1893
1894     ts = cmd_CreateSyntax("VosVLDBList", DoVosVLDBList, NULL,
1895                           "list a group of vldb entries");
1896     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1897                 "limit entries to a particular server");
1898     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1899                 "limit entries to a particular partition");
1900     SetupCommonCmdArgs(ts);
1901
1902     ts = cmd_CreateSyntax("VosVLDBEntryRemove", DoVosVLDBEntryRemove, NULL,
1903                           "remove vldb entries");
1904     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1905                 "limit entries to a particular server");
1906     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1907                 "limit entries to a particular partition");
1908     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume to remove");
1909     SetupCommonCmdArgs(ts);
1910
1911     ts = cmd_CreateSyntax("VosVLDBUnlock", DoVosVLDBUnlock, NULL,
1912                           "unlock a group of vldb entries");
1913     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1914                 "limit entries to a particular server");
1915     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1916                 "limit entries to a particular partition");
1917     SetupCommonCmdArgs(ts);
1918
1919     ts = cmd_CreateSyntax("VosVLDBEntryLock", DoVosVLDBList, NULL,
1920                           "lock a single vldb entry");
1921     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to lock");
1922     SetupCommonCmdArgs(ts);
1923
1924     ts = cmd_CreateSyntax("VosVLDBEntryUnlock", DoVosVLDBEntryUnlock, NULL,
1925                           "unlock a single vldb entry");
1926     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to unlock");
1927     SetupCommonCmdArgs(ts);
1928
1929     ts = cmd_CreateSyntax("VosVLDBReadOnlySiteCreate",
1930                           DoVosVLDBReadOnlySiteCreate, NULL,
1931                           "create a read only site");
1932     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1933                 "server where read only will be created");
1934     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1935                 "partition where read only will be created");
1936     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1937                 "volume to replicate");
1938     SetupCommonCmdArgs(ts);
1939
1940     ts = cmd_CreateSyntax("VosVLDBReadOnlySiteDelete",
1941                           DoVosVLDBReadOnlySiteDelete, NULL,
1942                           "delete a read only site before initial replication");
1943     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1944                 "server where read only will be deleted");
1945     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1946                 "partition where read only will be deleted");
1947     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
1948     SetupCommonCmdArgs(ts);
1949
1950     ts = cmd_CreateSyntax("VosVLDBSync", DoVosVLDBSync, NULL,
1951                           "sync vldb with server");
1952     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
1953     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1954                 "limit sync to a particular partition");
1955     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force sync to occur");
1956     SetupCommonCmdArgs(ts);
1957
1958     ts = cmd_CreateSyntax("VosVolumeCreate", DoVosVolumeCreate, NULL,
1959                           "create a read write volume");
1960     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1961                 "server where volume will be created");
1962     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1963                 "partition where volume will be created");
1964     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1965                 "name of new volume");
1966     cmd_AddParm(ts, "-quota", CMD_SINGLE, CMD_REQUIRED,
1967                 "size quota of new volume in 1kb units");
1968     SetupCommonCmdArgs(ts);
1969
1970     ts = cmd_CreateSyntax("VosVolumeDelete", DoVosVolumeDelete, NULL,
1971                           "delete a volume");
1972     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1973                 "server where volume exists");
1974     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1975                 "partition where volume exists");
1976     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
1977     SetupCommonCmdArgs(ts);
1978
1979     ts = cmd_CreateSyntax("VosVolumeRename", DoVosVolumeRename, NULL,
1980                           "rename a volume");
1981     cmd_AddParm(ts, "-oldname", CMD_SINGLE, CMD_REQUIRED, "old volume name");
1982     cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new volume name");
1983     SetupCommonCmdArgs(ts);
1984
1985     ts = cmd_CreateSyntax("VosVolumeDump", DoVosVolumeDump, NULL,
1986                           "dump a volume to a file");
1987     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1988                 "dump volume at a particular server");
1989     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1990                 "dump volume at a particular partition");
1991     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to dump");
1992     cmd_AddParm(ts, "-starttime", CMD_SINGLE, CMD_REQUIRED,
1993                 "files modified after this time will be dumped");
1994     cmd_AddParm(ts, "-dumpfile", CMD_SINGLE, CMD_REQUIRED,
1995                 "file to contain dump results");
1996     SetupCommonCmdArgs(ts);
1997
1998     ts = cmd_CreateSyntax("VosVolumeRestore", DoVosVolumeRestore, NULL,
1999                           "restore a volume from a dumpfile");
2000     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2001                 "server that houses volume to restore");
2002     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2003                 "partition that houses volume to restore");
2004     cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "id of volume restored");
2005     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2006                 "name of volume restored");
2007     cmd_AddParm(ts, "-dumpfile", CMD_SINGLE, CMD_REQUIRED,
2008                 "file contained dump of volume");
2009     cmd_AddParm(ts, "-full", CMD_FLAG, CMD_OPTIONAL,
2010                 "does a full restore of volume");
2011     SetupCommonCmdArgs(ts);
2012
2013     ts = cmd_CreateSyntax("VosVolumeOnline", DoVosVolumeOnline, NULL,
2014                           "bring a volume online");
2015     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2016                 "server that houses volume");
2017     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2018                 "partition that houses volume");
2019     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2020                 "volume to bring online");
2021     cmd_AddParm(ts, "-sleep", CMD_SINGLE, CMD_REQUIRED, "seconds to sleep");
2022     cmd_AddParm(ts, "-busy", CMD_FLAG, CMD_OPTIONAL, "mark volume busy");
2023     SetupCommonCmdArgs(ts);
2024
2025     ts = cmd_CreateSyntax("VosVolumeOffline", DoVosVolumeOffline, NULL,
2026                           "take a volume offline");
2027     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2028                 "server that houses volume");
2029     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2030                 "partition that houses volume");
2031     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2032                 "volume to bring offline");
2033     SetupCommonCmdArgs(ts);
2034
2035     ts = cmd_CreateSyntax("VosVolumeGet", DoVosVolumeGet, NULL,
2036                           "get a volume entry");
2037     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2038                 "server that houses volume");
2039     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2040                 "partition that houses volume");
2041     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2042                 "volume to retrieve");
2043     SetupCommonCmdArgs(ts);
2044
2045     ts = cmd_CreateSyntax("VosVolumeList", DoVosVolumeList, NULL,
2046                           "list a group of volumes");
2047     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2048                 "limit volumes to a particular server");
2049     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2050                 "limit volumes to a particular partition");
2051     SetupCommonCmdArgs(ts);
2052
2053     ts = cmd_CreateSyntax("VosVolumeMove", DoVosVolumeMove, NULL,
2054                           "move a volume");
2055     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to move");
2056     cmd_AddParm(ts, "-fromserver", CMD_SINGLE, CMD_REQUIRED, "source server");
2057     cmd_AddParm(ts, "-frompartition", CMD_SINGLE, CMD_REQUIRED,
2058                 "source partition");
2059     cmd_AddParm(ts, "-toserver", CMD_SINGLE, CMD_REQUIRED,
2060                 "destination server");
2061     cmd_AddParm(ts, "-topartition", CMD_SINGLE, CMD_REQUIRED,
2062                 "destination partition");
2063     SetupCommonCmdArgs(ts);
2064
2065     ts = cmd_CreateSyntax("VosVolumeRelease", DoVosVolumeRelease, NULL,
2066                           "release updates to read only");
2067     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2068                 "volume to replicate");
2069     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
2070                 "force release to occur");
2071     SetupCommonCmdArgs(ts);
2072
2073     ts = cmd_CreateSyntax("VosVolumeZap", DoVosVolumeZap, NULL, "zap a volume");
2074     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2075                 "server that houses the volume to zap");
2076     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2077                 "partition that houses the volume to zap");
2078     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to zap");
2079     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force zap");
2080     SetupCommonCmdArgs(ts);
2081
2082     ts = cmd_CreateSyntax("VosPartitionNameToId", DoVosPartitionNameToId, NULL,
2083                           "convert a partition name to a number");
2084     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2085                 "partition to convert");
2086     SetupCommonCmdArgs(ts);
2087
2088     ts = cmd_CreateSyntax("VosPartitionIdToName", DoVosPartitionIdToName, NULL,
2089                           "convert a number to a partition");
2090     cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED, "number to convert");
2091     SetupCommonCmdArgs(ts);
2092
2093     ts = cmd_CreateSyntax("VosVolumeQuotaChange", DoVosVolumeQuotaChange, NULL,
2094                           "change the quota for a partition");
2095     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2096                 "server that houses the volume");
2097     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2098                 "partition that houses the volume");
2099     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to change");
2100     cmd_AddParm(ts, "-quota", CMD_SINGLE, CMD_REQUIRED,
2101                 "new quota in 1kb units");
2102     SetupCommonCmdArgs(ts);
2103
2104     ts = cmd_CreateSyntax("VosVolumeGet2", DoVosVolumeGet2, NULL,
2105                           "get a volume entry");
2106     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2107                 "server that houses volume");
2108     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2109                 "partition that houses volume");
2110     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2111                 "volume to retrieve");
2112     SetupCommonCmdArgs(ts);
2113
2114     ts = cmd_CreateSyntax("ClearVolUpdateCounter", DoVos_ClearVolUpdateCounter, NULL,
2115                           "clear volUpdateCounter");
2116     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2117                 "server that houses volume");
2118     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2119                 "partition that houses volume");
2120     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2121                 "volume");
2122     SetupCommonCmdArgs(ts);
2123
2124 }
2125