src/libadmin/test/vos.c

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