2 * Copyright 2000, International Business Machines Corporation and others.
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
11 * This file implements the vos related funtions for afscp
14 #include <afsconfig.h>
15 #include <afs/param.h>
27 * Generic fuction for converting input string to an integer. Pass
28 * the error_msg you want displayed if there is an error converting
33 GetIntFromString(const char *int_str, const char *error_msg)
36 char *bad_char = NULL;
38 i = strtoul(int_str, &bad_char, 10);
39 if ((bad_char == NULL) || (*bad_char == 0)) {
47 * Generic fuction for converting input string to a volume number
48 * It will accept integer strings as well as volume names.
52 GetVolumeIdFromString(const char *volume)
54 unsigned int volume_id;
55 char *bad_char = NULL;
57 vos_vldbEntry_t entry;
59 volume_id = strtoul(volume, &bad_char, 10);
60 if ((bad_char == NULL) || (*bad_char == 0)) {
65 * We failed to convert the string to a number, so see if it
69 (cellHandle, 0, (const unsigned int *)0, volume, &entry, &st)) {
70 return entry.volumeId[VOS_READ_WRITE_VOLUME];
72 ERR_EXT("failed to convert specified volume to an id");
77 * Generic fuction for converting input string to a partition number
78 * It will accept integer strings as well as partition names.
82 GetPartitionIdFromString(const char *partition)
84 unsigned int partition_id;
85 char *bad_char = NULL;
90 partition_id = strtoul(partition, &bad_char, 10);
91 if ((bad_char == NULL) || (*bad_char == 0)) {
96 * We failed to convert the string to a number, so see if it
100 pname_len = strlen(partition);
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);
110 ERR_EXT("invalid partition");
113 if (!vos_PartitionNameToId((const char *)pname, &partition_id, &st)) {
114 ERR_ST_EXT("invalid partition", st);
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"
126 GetAddressFromString(const char *addr_str)
128 int addr = inet_addr(addr_str);
131 ERR_EXT("failed to convert specified address");
138 PrintMessage(vos_messageType_t type, char *message)
140 printf("%s\n", message);
144 DoVosBackupVolumeCreate(struct cmd_syndesc *as, char *arock)
146 typedef enum { VOLUME } DoVosBackupVolumeCreate_parm_t;
148 unsigned int volume_id;
150 if (as->parms[VOLUME].items) {
151 const char *volume = as->parms[VOLUME].items->data;
152 volume_id = GetVolumeIdFromString(volume);
155 if (!vos_BackupVolumeCreate(cellHandle, 0, volume_id, &st)) {
156 ERR_ST_EXT("vos_BackupVolumeCreate", st);
162 DoVosBackupVolumeCreateMultiple(struct cmd_syndesc *as, char *arock)
164 typedef enum { SERVER, PARTITION, PREFIX,
165 EXCLUDE } DoVosBackupVolumeCreate_parm_t;
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;
173 if (as->parms[SERVER].items) {
175 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
176 ERR_ST_EXT("vos_ServerOpen", st);
180 if (as->parms[PARTITION].items) {
182 GetPartitionIdFromString(as->parms[PARTITION].items->data);
183 part_ptr = &partition_id;
186 if (as->parms[PREFIX].items) {
187 prefix = as->parms[PREFIX].items->data;
190 if (as->parms[EXCLUDE].items) {
191 exclude = VOS_EXCLUDE;
194 if (!vos_BackupVolumeCreateMultiple
195 (cellHandle, vos_server, (vos_MessageCallBack_t) 0, part_ptr, prefix,
197 ERR_ST_EXT("vos_BackupVolumeCreate", st);
203 Print_vos_partitionEntry_p(vos_partitionEntry_p part, const char *prefix)
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);
213 DoVosPartitionGet(struct cmd_syndesc *as, char *arock)
215 typedef enum { SERVER, PARTITION } DoVosPartitionGet_parm_t;
217 void *vos_server = NULL;
218 unsigned int partition_id;
219 vos_partitionEntry_t entry;
221 if (as->parms[SERVER].items) {
223 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
224 ERR_ST_EXT("vos_ServerOpen", st);
228 if (as->parms[PARTITION].items) {
230 GetPartitionIdFromString(as->parms[PARTITION].items->data);
233 if (!vos_PartitionGet
234 (cellHandle, vos_server, 0, partition_id, &entry, &st)) {
235 ERR_ST_EXT("vos_PartitionGet", st);
238 Print_vos_partitionEntry_p(&entry, "");
244 DoVosPartitionList(struct cmd_syndesc *as, char *arock)
246 typedef enum { SERVER } DoVosPartitionGet_parm_t;
248 void *vos_server = NULL;
250 vos_partitionEntry_t entry;
252 if (as->parms[SERVER].items) {
254 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
255 ERR_ST_EXT("vos_ServerOpen", st);
259 if (!vos_PartitionGetBegin(cellHandle, vos_server, 0, &iter, &st)) {
260 ERR_ST_EXT("vos_PartitionGetBegin", st);
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, " ");
269 if (st != ADMITERATORDONE) {
270 ERR_ST_EXT("vos_PartitionGetNext", st);
273 if (!vos_PartitionGetDone(iter, &st)) {
274 ERR_ST_EXT("vos_PartitionGetDone", st);
280 DoVosServerSync(struct cmd_syndesc *as, char *arock)
282 typedef enum { SERVER, PARTITION } DoVosServerSync_parm_t;
284 void *vos_server = NULL;
285 unsigned int partition_id;
286 const unsigned int *part_ptr = NULL;
288 if (as->parms[SERVER].items) {
290 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
291 ERR_ST_EXT("vos_ServerOpen", st);
295 if (as->parms[PARTITION].items) {
297 GetPartitionIdFromString(as->parms[PARTITION].items->data);
298 part_ptr = &partition_id;
301 if (!vos_ServerSync(cellHandle, vos_server, 0, part_ptr, &st)) {
302 ERR_ST_EXT("vos_PartitionGetDone", st);
308 DoVosFileServerAddressChange(struct cmd_syndesc *as, char *arock)
310 typedef enum { OLDADDRESS,
311 NEWADDRESS } DoVosFileServerAddressChange_parm_t;
313 int old_addr, new_addr;
315 if (as->parms[OLDADDRESS].items) {
316 const char *addr = as->parms[OLDADDRESS].items->data;
317 old_addr = GetAddressFromString(addr);
320 if (as->parms[NEWADDRESS].items) {
321 const char *addr = as->parms[OLDADDRESS].items->data;
322 new_addr = GetAddressFromString(addr);
325 if (!vos_FileServerAddressChange(cellHandle, 0, old_addr, new_addr, &st)) {
326 ERR_ST_EXT("vos_FileServerAddressChange", st);
332 DoVosFileServerAddressRemove(struct cmd_syndesc *as, char *arock)
334 typedef enum { ADDRESS } DoVosFileServerAddressRemove_parm_t;
338 if (as->parms[ADDRESS].items) {
339 const char *addr = as->parms[ADDRESS].items->data;
340 address = GetAddressFromString(addr);
343 if (!vos_FileServerAddressRemove(cellHandle, 0, address, &st)) {
344 ERR_ST_EXT("vos_FileServerAddressRemove", st);
350 Print_vos_fileServerEntry_p(vos_fileServerEntry_p serv, const char *prefix)
354 for (i = 0; i < serv->count; i++) {
355 printf("%s%x ", prefix, serv->serverAddress[i]);
361 DoVosFileServerList(struct cmd_syndesc *as, char *arock)
365 vos_fileServerEntry_t entry;
367 if (!vos_FileServerGetBegin(cellHandle, 0, &iter, &st)) {
368 ERR_ST_EXT("vos_FileServerGetBegin", st);
371 while (vos_FileServerGetNext(iter, &entry, &st)) {
372 Print_vos_fileServerEntry_p(&entry, "");
375 if (st != ADMITERATORDONE) {
376 ERR_ST_EXT("vos_FileServerGetNext", st);
379 if (!vos_FileServerGetDone(iter, &st)) {
380 ERR_ST_EXT("vos_FileServerGetDone", st);
387 Print_vos_serverTransactionStatus_p(vos_serverTransactionStatus_p tran,
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);
412 DoVosServerTransactionStatusList(struct cmd_syndesc *as, char *arock)
414 typedef enum { SERVER } DoVosServerTransactionStatusList_parm_t;
416 void *vos_server = NULL;
418 vos_serverTransactionStatus_t tran;
421 if (as->parms[SERVER].items) {
423 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
424 ERR_ST_EXT("vos_ServerOpen", st);
428 if (!vos_ServerTransactionStatusGetBegin
429 (cellHandle, vos_server, 0, &iter, &st)) {
430 ERR_ST_EXT("vos_ServerTransactionStatusGetBegin", st);
433 while (vos_ServerTransactionStatusGetNext(iter, &tran, &st)) {
434 Print_vos_serverTransactionStatus_p(&tran, "");
437 if (st != ADMITERATORDONE) {
438 ERR_ST_EXT("vos_ServerTransactionStatusGetNext", st);
441 if (!vos_ServerTransactionStatusGetDone(iter, &st)) {
442 ERR_ST_EXT("vos_ServerTransactionStatusGetDone", st);
448 Print_vos_vldbEntry_p(vos_vldbEntry_p entry, const char *prefix)
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);
462 printf("%sVolume entry status:\n", prefix);
463 if (entry->status & VOS_VLDB_ENTRY_OK) {
464 printf("%s\tVOS_VLDB_ENTRY_OK\n", prefix);
466 if (entry->status & VOS_VLDB_ENTRY_MOVE) {
467 printf("%s\tVOS_VLDB_ENTRY_MOVE\n", prefix);
469 if (entry->status & VOS_VLDB_ENTRY_RELEASE) {
470 printf("%s\tVOS_VLDB_ENTRY_RELEASE\n", prefix);
472 if (entry->status & VOS_VLDB_ENTRY_BACKUP) {
473 printf("%s\tVOS_VLDB_ENTRY_BACKUP\n", prefix);
475 if (entry->status & VOS_VLDB_ENTRY_DELETE) {
476 printf("%s\tVOS_VLDB_ENTRY_DELETE\n", prefix);
478 if (entry->status & VOS_VLDB_ENTRY_DUMP) {
479 printf("%s\tVOS_VLDB_ENTRY_DUMP\n", prefix);
481 if (entry->status & VOS_VLDB_ENTRY_LOCKED) {
482 printf("%s\tVOS_VLDB_ENTRY_LOCKED\n", prefix);
484 if (entry->status & VOS_VLDB_ENTRY_RWEXISTS) {
485 printf("%s\tVOS_VLDB_ENTRY_RWEXISTS\n", prefix);
487 if (entry->status & VOS_VLDB_ENTRY_ROEXISTS) {
488 printf("%s\tVOS_VLDB_ENTRY_ROEXISTS\n", prefix);
490 if (entry->status & VOS_VLDB_ENTRY_BACKEXISTS) {
491 printf("%s\tVOS_VLDB_ENTRY_BACKEXISTS\n", prefix);
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);
503 if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_ONLY) {
504 printf("%s\tVOS_VLDB_READ_ONLY\n", prefix);
506 if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_WRITE) {
507 printf("%s\tVOS_VLDB_READ_WRITE\n", prefix);
509 if (entry->volumeSites[i].serverFlags & VOS_VLDB_BACKUP) {
510 printf("%s\tVOS_VLDB_BACKUP\n", prefix);
512 if (entry->volumeSites[i].serverFlags & VOS_VLDB_DONT_USE) {
513 printf("%s\tVOS_VLDB_DONT_USE\n", prefix);
520 DoVosVLDBGet(struct cmd_syndesc *as, char *arock)
522 typedef enum { VOLUME } DoVosVLDBGet_parm_t;
524 vos_vldbEntry_t entry;
525 unsigned int volume_id;
526 const char *volume_name = NULL;
528 if (as->parms[VOLUME].items) {
529 const char *volume = as->parms[VOLUME].items->data;
530 volume_id = GetVolumeIdFromString(volume);
534 if (!vos_VLDBGet(cellHandle, 0, &volume_id, volume_name, &entry, &st)) {
535 ERR_ST_EXT("vos_VLDBGet", st);
538 Print_vos_vldbEntry_p(&entry, "");
544 DoVosVLDBList(struct cmd_syndesc *as, char *arock)
546 typedef enum { SERVER, PARTITION } DoVosVLDBList_parm_t;
548 void *vos_server = NULL;
549 unsigned int partition_id;
550 unsigned int *part_ptr = NULL;
552 vos_vldbEntry_t entry;
555 if (as->parms[SERVER].items) {
557 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
558 ERR_ST_EXT("vos_ServerOpen", st);
563 if (as->parms[PARTITION].items) {
565 ERR_EXT("must specify server when specifying partition");
568 GetPartitionIdFromString(as->parms[PARTITION].items->data);
569 part_ptr = &partition_id;
572 if (!vos_VLDBGetBegin(cellHandle, vos_server, 0, part_ptr, &iter, &st)) {
573 ERR_ST_EXT("vos_VLDBGetBegin", st);
576 while (vos_VLDBGetNext(iter, &entry, &st)) {
577 Print_vos_vldbEntry_p(&entry, "");
580 if (st != ADMITERATORDONE) {
581 ERR_ST_EXT("vos_VLDBGetNext", st);
584 if (!vos_VLDBGetDone(iter, &st)) {
585 ERR_ST_EXT("vos_VLDBGetDone", st);
592 DoVosVLDBEntryRemove(struct cmd_syndesc *as, char *arock)
594 typedef enum { SERVER, PARTITION, VOLUME } DoVosVLDBEntryRemove_parm_t;
596 void *vos_server = NULL;
597 unsigned int partition_id;
598 unsigned int *part_ptr = NULL;
600 unsigned int volume_id;
601 unsigned int *vol_ptr = NULL;
603 if (as->parms[SERVER].items) {
605 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
606 ERR_ST_EXT("vos_ServerOpen", st);
611 if (as->parms[PARTITION].items) {
613 ERR_EXT("must specify server when specifying partition");
616 GetPartitionIdFromString(as->parms[PARTITION].items->data);
617 part_ptr = &partition_id;
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;
626 if (!vos_VLDBEntryRemove
627 (cellHandle, vos_server, 0, part_ptr, vol_ptr, &st)) {
628 ERR_ST_EXT("vos_VLDBEntryRemove", st);
635 DoVosVLDBUnlock(struct cmd_syndesc *as, char *arock)
637 typedef enum { SERVER, PARTITION } DoVosVLDBUnlock_parm_t;
639 void *vos_server = NULL;
640 unsigned int partition_id;
641 unsigned int *part_ptr = NULL;
644 if (as->parms[SERVER].items) {
646 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
647 ERR_ST_EXT("vos_ServerOpen", st);
652 if (as->parms[PARTITION].items) {
654 ERR_EXT("must specify server when specifying partition");
657 GetPartitionIdFromString(as->parms[PARTITION].items->data);
658 part_ptr = &partition_id;
661 if (!vos_VLDBUnlock(cellHandle, vos_server, 0, part_ptr, &st)) {
662 ERR_ST_EXT("vos_VLDBUnlock", st);
669 DoVosVLDBEntryLock(struct cmd_syndesc *as, char *arock)
671 typedef enum { VOLUME } DoVosVLDBEntryLoc_parm_tk;
673 unsigned int volume_id;
675 if (as->parms[VOLUME].items) {
676 const char *volume = as->parms[VOLUME].items->data;
677 volume_id = GetVolumeIdFromString(volume);
680 if (!vos_VLDBEntryLock(cellHandle, 0, volume_id, &st)) {
681 ERR_ST_EXT("vos_VLDBEntryLock", st);
688 DoVosVLDBEntryUnlock(struct cmd_syndesc *as, char *arock)
690 typedef enum { VOLUME } DoVosVLDBEntryUnlock_parm_t;
692 unsigned int volume_id;
694 if (as->parms[VOLUME].items) {
695 const char *volume = as->parms[VOLUME].items->data;
696 volume_id = GetVolumeIdFromString(volume);
699 if (!vos_VLDBEntryUnlock(cellHandle, 0, volume_id, &st)) {
700 ERR_ST_EXT("vos_VLDBEntryUnlock", st);
707 DoVosVLDBReadOnlySiteCreate(struct cmd_syndesc *as, char *arock)
709 typedef enum { SERVER, PARTITION,
710 VOLUME } DoVosVLDBReadOnlySiteCreate_parm_t;
712 void *vos_server = NULL;
713 unsigned int partition_id;
714 unsigned int volume_id;
716 if (as->parms[SERVER].items) {
718 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
719 ERR_ST_EXT("vos_ServerOpen", st);
723 if (as->parms[PARTITION].items) {
725 GetPartitionIdFromString(as->parms[PARTITION].items->data);
728 if (as->parms[VOLUME].items) {
729 const char *volume = as->parms[VOLUME].items->data;
730 volume_id = GetVolumeIdFromString(volume);
733 if (!vos_VLDBReadOnlySiteCreate
734 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
735 ERR_ST_EXT("vos_VLDBReadOnlySiteCreate", st);
741 DoVosVLDBReadOnlySiteDelete(struct cmd_syndesc *as, char *arock)
743 typedef enum { SERVER, PARTITION,
744 VOLUME } DoVosVLDBReadOnlySiteDelete_parm_t;
746 void *vos_server = NULL;
747 unsigned int partition_id;
748 unsigned int volume_id;
750 if (as->parms[SERVER].items) {
752 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
753 ERR_ST_EXT("vos_ServerOpen", st);
757 if (as->parms[PARTITION].items) {
759 GetPartitionIdFromString(as->parms[PARTITION].items->data);
762 if (as->parms[VOLUME].items) {
763 const char *volume = as->parms[VOLUME].items->data;
764 volume_id = GetVolumeIdFromString(volume);
767 if (!vos_VLDBReadOnlySiteDelete
768 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
769 ERR_ST_EXT("vos_VLDBReadOnlySiteDelete", st);
776 DoVosVLDBSync(struct cmd_syndesc *as, char *arock)
778 typedef enum { SERVER, PARTITION, FORCE } DoVosVLDBSync_parm_t;
780 void *vos_server = NULL;
781 unsigned int partition_id;
782 unsigned int *part_ptr = NULL;
784 vos_force_t force = VOS_NORMAL;
786 if (as->parms[SERVER].items) {
788 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
789 ERR_ST_EXT("vos_ServerOpen", st);
794 if (as->parms[PARTITION].items) {
796 ERR_EXT("must specify server when specifying partition");
799 GetPartitionIdFromString(as->parms[PARTITION].items->data);
800 part_ptr = &partition_id;
803 if (as->parms[FORCE].items) {
807 if (!vos_VLDBSync(cellHandle, vos_server, 0, part_ptr, force, &st)) {
808 ERR_ST_EXT("vos_VLDBSync", st);
815 DoVosVolumeCreate(struct cmd_syndesc *as, char *arock)
817 typedef enum { SERVER, PARTITION, VOLUME,
818 QUOTA } DoVosVolumeCreate_parm_t;
820 void *vos_server = NULL;
821 unsigned int partition_id;
822 unsigned int volume_id;
823 const char *volume = NULL;
826 if (as->parms[SERVER].items) {
828 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
829 ERR_ST_EXT("vos_ServerOpen", st);
833 if (as->parms[PARTITION].items) {
835 GetPartitionIdFromString(as->parms[PARTITION].items->data);
838 if (as->parms[VOLUME].items) {
839 volume = as->parms[VOLUME].items->data;
842 if (as->parms[QUOTA].items) {
844 GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
847 if (!vos_VolumeCreate
848 (cellHandle, vos_server, 0, partition_id, volume, quota, &volume_id,
850 ERR_ST_EXT("vos_VolumeCreate", st);
853 printf("Created volume %u\n", volume_id);
859 DoVosVolumeDelete(struct cmd_syndesc *as, char *arock)
861 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeDelete_parm_t;
863 void *vos_server = NULL;
864 unsigned int partition_id;
865 unsigned int volume_id;
867 if (as->parms[SERVER].items) {
869 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
870 ERR_ST_EXT("vos_ServerOpen", st);
874 if (as->parms[PARTITION].items) {
876 GetPartitionIdFromString(as->parms[PARTITION].items->data);
879 if (as->parms[VOLUME].items) {
880 const char *volume = as->parms[VOLUME].items->data;
881 volume_id = GetVolumeIdFromString(volume);
884 if (!vos_VolumeDelete
885 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
886 ERR_ST_EXT("vos_VolumeDelete", st);
893 DoVosVolumeRename(struct cmd_syndesc *as, char *arock)
895 typedef enum { OLDVOLUME, NEWVOLUME } DoVosVolumeRename_parm_t;
897 unsigned int old_volume;
898 const char *new_volume;
900 if (as->parms[OLDVOLUME].items) {
901 const char *volume = as->parms[OLDVOLUME].items->data;
902 old_volume = GetVolumeIdFromString(volume);
905 if (as->parms[NEWVOLUME].items) {
906 new_volume = as->parms[NEWVOLUME].items->data;
909 if (!vos_VolumeRename(cellHandle, 0, old_volume, new_volume, &st)) {
910 ERR_ST_EXT("vos_VolumeRename", st);
917 DoVosVolumeDump(struct cmd_syndesc *as, char *arock)
919 typedef enum { SERVER, PARTITION, VOLUME, STARTTIME,
920 DUMPFILE } DoVosVolumeDump_parm_t;
922 void *vos_server = NULL;
923 unsigned int partition_id;
924 unsigned int *part_ptr = NULL;
926 unsigned int volume_id;
927 unsigned int start_time;
928 const char *dumpfile;
930 if (as->parms[SERVER].items) {
932 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
933 ERR_ST_EXT("vos_ServerOpen", st);
938 if (as->parms[PARTITION].items) {
940 ERR_EXT("must specify server when specifying partition");
943 GetPartitionIdFromString(as->parms[PARTITION].items->data);
944 part_ptr = &partition_id;
947 if (as->parms[VOLUME].items) {
948 const char *volume = as->parms[VOLUME].items->data;
949 volume_id = GetVolumeIdFromString(volume);
952 if (as->parms[STARTTIME].items) {
954 GetIntFromString(as->parms[STARTTIME].items->data,
955 "invalid start time");
958 if (as->parms[DUMPFILE].items) {
959 dumpfile = as->parms[DUMPFILE].items->data;
963 (cellHandle, vos_server, 0, part_ptr, volume_id, start_time, dumpfile,
965 ERR_ST_EXT("vos_VolumeDump", st);
972 DoVosVolumeRestore(struct cmd_syndesc *as, char *arock)
974 typedef enum { SERVER, PARTITION, ID, VOLUME, DUMPFILE,
975 FULL } DoVosVolumeRestore_parm_t;
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;
985 if (as->parms[SERVER].items) {
987 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
988 ERR_ST_EXT("vos_ServerOpen", st);
992 if (as->parms[PARTITION].items) {
994 GetPartitionIdFromString(as->parms[PARTITION].items->data);
997 if (as->parms[VOLUME].items) {
998 volume_name = as->parms[VOLUME].items->data;
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;
1007 if (as->parms[DUMPFILE].items) {
1008 dumpfile = as->parms[DUMPFILE].items->data;
1011 if (as->parms[FULL].items) {
1012 restore = VOS_RESTORE_FULL;
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);
1025 DoVosVolumeOnline(struct cmd_syndesc *as, char *arock)
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;
1034 vos_volumeOnlineType_t type = VOS_ONLINE_OFFLINE;
1036 if (as->parms[SERVER].items) {
1038 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1039 ERR_ST_EXT("vos_ServerOpen", st);
1043 if (as->parms[PARTITION].items) {
1045 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1048 if (as->parms[VOLUME].items) {
1049 const char *volume = as->parms[VOLUME].items->data;
1050 volume_id = GetVolumeIdFromString(volume);
1053 if (as->parms[SLEEP].items) {
1055 GetIntFromString(as->parms[SLEEP].items->data,
1056 "invalid sleep time");
1059 if (as->parms[BUSY].items) {
1060 type = VOS_ONLINE_BUSY;
1063 if (!vos_VolumeOnline
1064 (vos_server, 0, partition_id, volume_id, sleep, type, &st)) {
1065 ERR_ST_EXT("vos_VolumeOnline", st);
1072 DoVosVolumeOffline(struct cmd_syndesc *as, char *arock)
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;
1080 if (as->parms[SERVER].items) {
1082 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1083 ERR_ST_EXT("vos_ServerOpen", st);
1087 if (as->parms[PARTITION].items) {
1089 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1092 if (as->parms[VOLUME].items) {
1093 const char *volume = as->parms[VOLUME].items->data;
1094 volume_id = GetVolumeIdFromString(volume);
1097 if (!vos_VolumeOffline(vos_server, 0, partition_id, volume_id, &st)) {
1098 ERR_ST_EXT("vos_VolumeOffline", st);
1105 Print_vos_volumeEntry_p(vos_volumeEntry_p entry, const char *prefix)
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);
1124 printf("%sVolume status: VOS_OK\n", prefix);
1126 printf("%sVolume disposition:\n", prefix);
1128 switch (entry->volumeDisposition) {
1130 printf("%s\tVOS_OK\n", prefix);
1133 printf("%s\tVOS_SALVAGE\n", prefix);
1136 printf("%s\tVOS_NO_VNODE\n", prefix);
1139 printf("%s\tVOS_NO_VOL\n", prefix);
1141 case VOS_VOL_EXISTS:
1142 printf("%s\tVOS_VOL_EXISTS\n", prefix);
1144 case VOS_NO_SERVICE:
1145 printf("%s\tVOS_NO_SERVICE\n", prefix);
1148 printf("%s\tVOS_OFFLINE\n", prefix);
1151 printf("%s\tVOS_ONLINE\n", prefix);
1154 printf("%s\tVOS_DISK_FULL\n", prefix);
1156 case VOS_OVER_QUOTA:
1157 printf("%s\tVOS_OVER_QUOTA\n", prefix);
1160 printf("%s\tVOS_BUSY\n", prefix);
1163 printf("%s\tVOS_MOVED\n", prefix);
1166 printf("Unknown volume disposition %d\n",
1167 entry->volumeDisposition);
1171 printf("%sVolume type: ", prefix);
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");
1181 printf("\n%s\tSame Network\tSame Network Authenticated"
1182 "\tDifferent Network\tDifferent Network Authenticated\n\n",
1184 printf("%sRead\t%d\t%d\t%d\t%d\n", prefix,
1185 entry->readStats[VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK],
1188 [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1190 readStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
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],
1198 [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1200 writeStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
1203 [VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK_AUTHENTICATED]);
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",
1208 printf("%sFile Author Write Same Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1211 fileAuthorWriteSameNetwork
1212 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1214 fileAuthorWriteSameNetwork
1215 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1217 fileAuthorWriteSameNetwork
1218 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1220 fileAuthorWriteSameNetwork
1221 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1223 fileAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
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",
1230 fileAuthorWriteDifferentNetwork
1231 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1233 fileAuthorWriteDifferentNetwork
1234 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1236 fileAuthorWriteDifferentNetwork
1237 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1239 fileAuthorWriteDifferentNetwork
1240 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1242 fileAuthorWriteDifferentNetwork
1243 [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
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",
1250 dirAuthorWriteSameNetwork
1251 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1253 dirAuthorWriteSameNetwork
1254 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1256 dirAuthorWriteSameNetwork
1257 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1259 dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1261 dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
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",
1268 dirAuthorWriteDifferentNetwork
1269 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1271 dirAuthorWriteDifferentNetwork
1272 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1274 dirAuthorWriteDifferentNetwork
1275 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1277 dirAuthorWriteDifferentNetwork
1278 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1280 dirAuthorWriteDifferentNetwork
1281 [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1283 dirAuthorWriteDifferentNetwork
1284 [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1286 printf("%sUnable to print volume because volume status:\n", prefix);
1287 switch (entry->status) {
1289 printf("%s\tVOS_SALVAGE\n", prefix);
1292 printf("%s\tVOS_NO_VNODE\n", prefix);
1295 printf("%s\tVOS_NO_VOL\n", prefix);
1297 case VOS_VOL_EXISTS:
1298 printf("%s\tVOS_VOL_EXISTS\n", prefix);
1300 case VOS_NO_SERVICE:
1301 printf("%s\tVOS_NO_SERVICE\n", prefix);
1304 printf("%s\tVOS_OFFLINE\n", prefix);
1307 printf("%s\tVOS_ONLINE\n", prefix);
1310 printf("%s\tVOS_DISK_FULL\n", prefix);
1312 case VOS_OVER_QUOTA:
1313 printf("%s\tVOS_OVER_QUOTA\n", prefix);
1316 printf("%s\tVOS_BUSY\n", prefix);
1319 printf("%s\tVOS_MOVED\n", prefix);
1322 printf("Unknown volume status %d\n", entry->status);
1329 DoVosVolumeGet(struct cmd_syndesc *as, char *arock)
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;
1338 if (as->parms[SERVER].items) {
1340 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1341 ERR_ST_EXT("vos_ServerOpen", st);
1345 if (as->parms[PARTITION].items) {
1347 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1350 if (as->parms[VOLUME].items) {
1351 const char *volume = as->parms[VOLUME].items->data;
1352 volume_id = GetVolumeIdFromString(volume);
1356 (cellHandle, vos_server, 0, partition_id, volume_id, &entry, &st)) {
1357 ERR_ST_EXT("vos_VolumeGet", st);
1360 Print_vos_volumeEntry_p(&entry, "");
1366 DoVosVolumeList(struct cmd_syndesc *as, char *arock)
1368 typedef enum { SERVER, PARTITION } DoVosVolumeList_parm_t;
1369 afs_status_t st = 0;
1370 void *vos_server = NULL;
1372 unsigned int partition_id;
1373 vos_volumeEntry_t entry;
1375 if (as->parms[SERVER].items) {
1377 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1378 ERR_ST_EXT("vos_ServerOpen", st);
1382 if (as->parms[PARTITION].items) {
1384 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1387 if (!vos_VolumeGetBegin
1388 (cellHandle, vos_server, 0, partition_id, &iter, &st)) {
1389 ERR_ST_EXT("vos_VolumeGetBegin", st);
1392 printf("Volumes located at %s partition %s\n",
1393 as->parms[SERVER].items->data, as->parms[PARTITION].items->data);
1395 while (vos_VolumeGetNext(iter, &entry, &st)) {
1396 Print_vos_volumeEntry_p(&entry, " ");
1400 if (st != ADMITERATORDONE) {
1401 ERR_ST_EXT("vos_VolumeGetNext", st);
1404 if (!vos_VolumeGetDone(iter, &st)) {
1405 ERR_ST_EXT("vos_VolumeGetDone", st);
1412 DoVosVolumeMove(struct cmd_syndesc *as, char *arock)
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;
1423 if (as->parms[FROMSERVER].items) {
1425 (cellHandle, as->parms[FROMSERVER].items->data, &from_server,
1427 ERR_ST_EXT("vos_ServerOpen", st);
1431 if (as->parms[TOSERVER].items) {
1433 (cellHandle, as->parms[TOSERVER].items->data, &to_server, &st)) {
1434 ERR_ST_EXT("vos_ServerOpen", st);
1438 if (as->parms[FROMPARTITION].items) {
1440 GetPartitionIdFromString(as->parms[FROMPARTITION].items->data);
1443 if (as->parms[TOPARTITION].items) {
1445 GetPartitionIdFromString(as->parms[TOPARTITION].items->data);
1448 if (as->parms[VOLUME].items) {
1449 const char *volume = as->parms[VOLUME].items->data;
1450 volume_id = GetVolumeIdFromString(volume);
1454 (cellHandle, 0, volume_id, from_server, from_partition, to_server,
1455 to_partition, &st)) {
1456 ERR_ST_EXT("vos_VolumeMove", st);
1463 DoVosVolumeRelease(struct cmd_syndesc *as, char *arock)
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;
1470 if (as->parms[VOLUME].items) {
1471 const char *volume = as->parms[VOLUME].items->data;
1472 volume_id = GetVolumeIdFromString(volume);
1475 if (as->parms[FORCE].items) {
1479 if (!vos_VolumeRelease(cellHandle, 0, volume_id, force, &st)) {
1480 ERR_ST_EXT("vos_VolumeRelease", st);
1486 DoVosVolumeZap(struct cmd_syndesc *as, char *arock)
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;
1495 if (as->parms[SERVER].items) {
1497 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1498 ERR_ST_EXT("vos_ServerOpen", st);
1502 if (as->parms[PARTITION].items) {
1504 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1507 if (as->parms[VOLUME].items) {
1508 const char *volume = as->parms[VOLUME].items->data;
1509 volume_id = GetVolumeIdFromString(volume);
1512 if (as->parms[FORCE].items) {
1517 (cellHandle, vos_server, 0, partition_id, volume_id, force, &st)) {
1518 ERR_ST_EXT("vos_VolumeZap", st);
1525 DoVosPartitionNameToId(struct cmd_syndesc *as, char *arock)
1527 typedef enum { PARTITION } DoVosPartitionNameToId_parm_t;
1528 afs_status_t st = 0;
1529 unsigned int partition_id;
1531 if (as->parms[PARTITION].items) {
1533 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1536 printf("The id for partition %s is %u\n",
1537 as->parms[PARTITION].items->data, partition_id);
1543 DoVosPartitionIdToName(struct cmd_syndesc *as, char *arock)
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];
1550 if (as->parms[PARTITIONID].items) {
1552 GetIntFromString(as->parms[PARTITIONID].items->data,
1553 "bad partition id");
1556 if (!vos_PartitionIdToName(partition_id, partition, &st)) {
1557 ERR_ST_EXT("bad partition id", st);
1560 printf("The partition for id %u is %s\n", partition_id, partition);
1566 DoVosVolumeQuotaChange(struct cmd_syndesc *as, char *arock)
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;
1576 if (as->parms[SERVER].items) {
1578 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1579 ERR_ST_EXT("vos_ServerOpen", st);
1583 if (as->parms[PARTITION].items) {
1585 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1588 if (as->parms[VOLUME].items) {
1589 const char *volume = as->parms[VOLUME].items->data;
1590 volume_id = GetVolumeIdFromString(volume);
1593 if (as->parms[QUOTA].items) {
1595 GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
1598 if (!vos_VolumeQuotaChange
1599 (cellHandle, vos_server, 0, partition_id, volume_id, quota, &st)) {
1600 ERR_ST_EXT("vos_VolumeQuotaChange", st);
1607 SetupVosAdminCmd(void)
1609 struct cmd_syndesc *ts;
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);
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);
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);
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);
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);
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);
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);
1665 ts = cmd_CreateSyntax("VosFileServerList", DoVosFileServerList, 0,
1666 "list the file servers in a cell");
1667 SetupCommonCmdArgs(ts);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
1757 ts = cmd_CreateSyntax("VosVolumeDelete", DoVosVolumeDelete, 0,
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);
1766 ts = cmd_CreateSyntax("VosVolumeRename", DoVosVolumeRename, 0,
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);
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);
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);
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);
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);
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);
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);
1840 ts = cmd_CreateSyntax("VosVolumeMove", DoVosVolumeMove, 0,
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);
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);
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);
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);
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);
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);