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