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