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>
18 #include <netinet/in.h>
19 #include <arpa/inet.h>
20 #include <afs/afsutil.h>
33 * Generic fuction for converting input string to an integer. Pass
34 * the error_msg you want displayed if there is an error converting
39 GetIntFromString(const char *int_str, const char *error_msg)
42 char *bad_char = NULL;
44 i = strtoul(int_str, &bad_char, 10);
45 if ((bad_char == NULL) || (*bad_char == 0)) {
53 * Generic fuction for converting input string to a volume number
54 * It will accept integer strings as well as volume names.
58 GetVolumeIdFromString(const char *volume)
60 unsigned int volume_id;
61 char *bad_char = NULL;
63 vos_vldbEntry_t entry;
65 volume_id = strtoul(volume, &bad_char, 10);
66 if ((bad_char == NULL) || (*bad_char == 0)) {
71 * We failed to convert the string to a number, so see if it
75 (cellHandle, 0, (const unsigned int *)0, volume, &entry, &st)) {
76 return entry.volumeId[VOS_READ_WRITE_VOLUME];
78 ERR_EXT("failed to convert specified volume to an id");
83 * Generic fuction for converting input string to a partition number
84 * It will accept integer strings as well as partition names.
88 GetPartitionIdFromString(const char *partition)
90 unsigned int partition_id;
91 char *bad_char = NULL;
96 partition_id = strtoul(partition, &bad_char, 10);
97 if ((bad_char == NULL) || (*bad_char == 0)) {
102 * We failed to convert the string to a number, so see if it
103 * is a partition name
106 pname_len = strlen(partition);
108 sprintf(pname, "%s", "/vicep");
109 if (pname_len <= 2) {
110 strcat(pname, partition);
111 } else if (!strncmp(partition, "/vicep", 6)) {
112 strcat(pname, partition + 6);
113 } else if (!strncmp(partition, "vicep", 5)) {
114 strcat(pname, partition + 5);
116 ERR_EXT("invalid partition");
119 if (!vos_PartitionNameToId((const char *)pname, &partition_id, &st)) {
120 ERR_ST_EXT("invalid partition", st);
127 * Generic fuction for converting input string to an address in host order.
128 * It will accept strings in the form "128.98.12.1"
132 GetAddressFromString(const char *addr_str)
134 int addr = inet_addr(addr_str);
137 ERR_EXT("failed to convert specified address");
144 PrintMessage(vos_messageType_t type, char *message)
146 printf("%s\n", message);
150 DoVosBackupVolumeCreate(struct cmd_syndesc *as, void *arock)
152 typedef enum { VOLUME } DoVosBackupVolumeCreate_parm_t;
154 unsigned int volume_id = 0;
156 if (as->parms[VOLUME].items) {
157 const char *volume = as->parms[VOLUME].items->data;
158 volume_id = GetVolumeIdFromString(volume);
161 if (!vos_BackupVolumeCreate(cellHandle, 0, volume_id, &st)) {
162 ERR_ST_EXT("vos_BackupVolumeCreate", st);
168 DoVosBackupVolumeCreateMultiple(struct cmd_syndesc *as, void *arock)
170 typedef enum { SERVER, PARTITION, PREFIX,
172 } DoVosBackupVolumeCreate_parm_t;
174 void *vos_server = NULL;
175 unsigned int partition_id;
176 const unsigned int *part_ptr = NULL;
177 const char *prefix = NULL;
178 vos_exclude_t exclude = VOS_INCLUDE;
180 if (as->parms[SERVER].items) {
182 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
183 ERR_ST_EXT("vos_ServerOpen", st);
187 if (as->parms[PARTITION].items) {
189 GetPartitionIdFromString(as->parms[PARTITION].items->data);
190 part_ptr = &partition_id;
193 if (as->parms[PREFIX].items) {
194 prefix = as->parms[PREFIX].items->data;
197 if (as->parms[EXCLUDE].items) {
198 exclude = VOS_EXCLUDE;
201 if (!vos_BackupVolumeCreateMultiple
202 (cellHandle, vos_server, (vos_MessageCallBack_t) 0, part_ptr, prefix,
204 ERR_ST_EXT("vos_BackupVolumeCreate", st);
210 Print_vos_partitionEntry_p(vos_partitionEntry_p part, const char *prefix)
212 printf("%sInformation for partition %s\n", prefix, part->name);
213 printf("%s\tDevice name: %s\n", prefix, part->deviceName);
214 printf("%s\tlockFileDescriptor: %d\n", prefix, part->lockFileDescriptor);
215 printf("%s\tTotal space: %d\n", prefix, part->totalSpace);
216 printf("%s\tTotal Free space: %d\n", prefix, part->totalFreeSpace);
220 DoVosPartitionGet(struct cmd_syndesc *as, void *arock)
222 typedef enum { SERVER, PARTITION } DoVosPartitionGet_parm_t;
224 void *vos_server = NULL;
225 unsigned int partition_id = 0;
226 vos_partitionEntry_t entry;
228 if (as->parms[SERVER].items) {
230 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
231 ERR_ST_EXT("vos_ServerOpen", st);
235 if (as->parms[PARTITION].items) {
237 GetPartitionIdFromString(as->parms[PARTITION].items->data);
240 if (!vos_PartitionGet
241 (cellHandle, vos_server, 0, partition_id, &entry, &st)) {
242 ERR_ST_EXT("vos_PartitionGet", st);
245 Print_vos_partitionEntry_p(&entry, "");
251 DoVosPartitionList(struct cmd_syndesc *as, void *arock)
253 typedef enum { SERVER } DoVosPartitionGet_parm_t;
255 void *vos_server = NULL;
257 vos_partitionEntry_t entry;
259 if (as->parms[SERVER].items) {
261 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
262 ERR_ST_EXT("vos_ServerOpen", st);
266 if (!vos_PartitionGetBegin(cellHandle, vos_server, 0, &iter, &st)) {
267 ERR_ST_EXT("vos_PartitionGetBegin", st);
270 printf("Listing partitions at server %s\n",
271 as->parms[SERVER].items->data);
272 while (vos_PartitionGetNext(iter, &entry, &st)) {
273 Print_vos_partitionEntry_p(&entry, " ");
276 if (st != ADMITERATORDONE) {
277 ERR_ST_EXT("vos_PartitionGetNext", st);
280 if (!vos_PartitionGetDone(iter, &st)) {
281 ERR_ST_EXT("vos_PartitionGetDone", st);
287 DoVosServerSync(struct cmd_syndesc *as, void *arock)
289 typedef enum { SERVER, PARTITION } DoVosServerSync_parm_t;
291 void *vos_server = NULL;
292 unsigned int partition_id;
293 const unsigned int *part_ptr = NULL;
295 if (as->parms[SERVER].items) {
297 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
298 ERR_ST_EXT("vos_ServerOpen", st);
302 if (as->parms[PARTITION].items) {
304 GetPartitionIdFromString(as->parms[PARTITION].items->data);
305 part_ptr = &partition_id;
308 if (!vos_ServerSync(cellHandle, vos_server, 0, part_ptr, &st)) {
309 ERR_ST_EXT("vos_PartitionGetDone", st);
315 DoVosFileServerAddressChange(struct cmd_syndesc *as, void *arock)
317 typedef enum { OLDADDRESS,
319 } DoVosFileServerAddressChange_parm_t;
324 if (as->parms[OLDADDRESS].items) {
325 const char *addr = as->parms[OLDADDRESS].items->data;
326 old_addr = GetAddressFromString(addr);
329 if (as->parms[NEWADDRESS].items) {
330 const char *addr = as->parms[OLDADDRESS].items->data;
331 new_addr = GetAddressFromString(addr);
334 if (!vos_FileServerAddressChange(cellHandle, 0, old_addr, new_addr, &st)) {
335 ERR_ST_EXT("vos_FileServerAddressChange", st);
341 DoVosFileServerAddressRemove(struct cmd_syndesc *as, void *arock)
343 typedef enum { ADDRESS } DoVosFileServerAddressRemove_parm_t;
347 if (as->parms[ADDRESS].items) {
348 const char *addr = as->parms[ADDRESS].items->data;
349 address = GetAddressFromString(addr);
352 if (!vos_FileServerAddressRemove(cellHandle, 0, address, &st)) {
353 ERR_ST_EXT("vos_FileServerAddressRemove", st);
359 Print_vos_fileServerEntry_p(vos_fileServerEntry_p serv, const char *prefix)
363 for (i = 0; i < serv->count; i++) {
364 printf("%s%x ", prefix, serv->serverAddress[i]);
370 DoVosFileServerList(struct cmd_syndesc *as, void *arock)
374 vos_fileServerEntry_t entry;
376 if (!vos_FileServerGetBegin(cellHandle, 0, &iter, &st)) {
377 ERR_ST_EXT("vos_FileServerGetBegin", st);
380 while (vos_FileServerGetNext(iter, &entry, &st)) {
381 Print_vos_fileServerEntry_p(&entry, "");
384 if (st != ADMITERATORDONE) {
385 ERR_ST_EXT("vos_FileServerGetNext", st);
388 if (!vos_FileServerGetDone(iter, &st)) {
389 ERR_ST_EXT("vos_FileServerGetDone", st);
396 Print_vos_serverTransactionStatus_p(vos_serverTransactionStatus_p tran,
399 printf("%sTransaction id\t\t\t%d\n", prefix, tran->transactionId);
400 printf("%sLast active time\t\t\t%d\n", prefix, tran->lastActiveTime);
401 printf("%sCreation time\t\t\t%d\n", prefix, tran->creationTime);
402 printf("%sError code\t\t\t%d\n", prefix, tran->errorCode);
403 printf("%sVolume id\t\t\t\t%u\n", prefix, tran->volumeId);
404 printf("%sPartition\t\t\t\t%d\n", prefix, tran->partition);
405 printf("%sLast procedure name\t\t\t%s\n", prefix,
406 tran->lastProcedureName);
407 printf("%sNext receive packet seq num\t\t\t%d\n", prefix,
408 tran->nextReceivePacketSequenceNumber);
409 printf("%sNext send packet seq num\t\t\t%d\n", prefix,
410 tran->nextSendPacketSequenceNumber);
411 printf("%sLast receive time\t\t\t%d\n", prefix, tran->lastReceiveTime);
412 printf("%sLast send time\t\t\t%d\n", prefix, tran->lastSendTime);
413 printf("%sVolume attach mode\t\t\t%d\n", prefix, tran->volumeAttachMode);
414 printf("%sVolume active status\t\t\t%d\n", prefix,
415 tran->volumeActiveStatus);
416 printf("%sVolume tran status\t\t\t%d\n", prefix,
417 tran->volumeTransactionStatus);
421 DoVosServerTransactionStatusList(struct cmd_syndesc *as, void *arock)
423 typedef enum { SERVER } DoVosServerTransactionStatusList_parm_t;
425 void *vos_server = NULL;
427 vos_serverTransactionStatus_t tran;
430 if (as->parms[SERVER].items) {
432 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
433 ERR_ST_EXT("vos_ServerOpen", st);
437 if (!vos_ServerTransactionStatusGetBegin
438 (cellHandle, vos_server, 0, &iter, &st)) {
439 ERR_ST_EXT("vos_ServerTransactionStatusGetBegin", st);
442 while (vos_ServerTransactionStatusGetNext(iter, &tran, &st)) {
443 Print_vos_serverTransactionStatus_p(&tran, "");
446 if (st != ADMITERATORDONE) {
447 ERR_ST_EXT("vos_ServerTransactionStatusGetNext", st);
450 if (!vos_ServerTransactionStatusGetDone(iter, &st)) {
451 ERR_ST_EXT("vos_ServerTransactionStatusGetDone", st);
457 Print_vos_vldbEntry_p(vos_vldbEntry_p entry, const char *prefix)
461 printf("%sVolume entry %s\n", prefix, entry->name);
462 printf("%sNumber of servers %d\n", prefix, entry->numServers);
463 printf("%sRead write volume %u\n", prefix,
464 entry->volumeId[VOS_READ_WRITE_VOLUME]);
465 printf("%sRead only volume %u\n", prefix,
466 entry->volumeId[VOS_READ_ONLY_VOLUME]);
467 printf("%sBackup volume %u\n", prefix,
468 entry->volumeId[VOS_BACKUP_VOLUME]);
469 printf("%sClone volume %u\n", prefix, entry->cloneId);
471 printf("%sVolume entry status:\n", prefix);
472 if (entry->status & VOS_VLDB_ENTRY_OK) {
473 printf("%s\tVOS_VLDB_ENTRY_OK\n", prefix);
475 if (entry->status & VOS_VLDB_ENTRY_MOVE) {
476 printf("%s\tVOS_VLDB_ENTRY_MOVE\n", prefix);
478 if (entry->status & VOS_VLDB_ENTRY_RELEASE) {
479 printf("%s\tVOS_VLDB_ENTRY_RELEASE\n", prefix);
481 if (entry->status & VOS_VLDB_ENTRY_BACKUP) {
482 printf("%s\tVOS_VLDB_ENTRY_BACKUP\n", prefix);
484 if (entry->status & VOS_VLDB_ENTRY_DELETE) {
485 printf("%s\tVOS_VLDB_ENTRY_DELETE\n", prefix);
487 if (entry->status & VOS_VLDB_ENTRY_DUMP) {
488 printf("%s\tVOS_VLDB_ENTRY_DUMP\n", prefix);
490 if (entry->status & VOS_VLDB_ENTRY_LOCKED) {
491 printf("%s\tVOS_VLDB_ENTRY_LOCKED\n", prefix);
493 if (entry->status & VOS_VLDB_ENTRY_RWEXISTS) {
494 printf("%s\tVOS_VLDB_ENTRY_RWEXISTS\n", prefix);
496 if (entry->status & VOS_VLDB_ENTRY_ROEXISTS) {
497 printf("%s\tVOS_VLDB_ENTRY_ROEXISTS\n", prefix);
499 if (entry->status & VOS_VLDB_ENTRY_BACKEXISTS) {
500 printf("%s\tVOS_VLDB_ENTRY_BACKEXISTS\n", prefix);
503 printf("%sVolume location information for replicas:\n", prefix);
504 for (i = 0; i < entry->numServers; i++) {
505 printf("%s\tServer %x\n", prefix,
506 entry->volumeSites[i].serverAddress);
507 printf("%s\tPartition %x\n", prefix,
508 entry->volumeSites[i].serverPartition);
509 if (entry->volumeSites[i].serverFlags & VOS_VLDB_NEW_REPSITE) {
510 printf("%s\tVOS_VLDB_NEW_REPSITE\n", prefix);
512 if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_ONLY) {
513 printf("%s\tVOS_VLDB_READ_ONLY\n", prefix);
515 if (entry->volumeSites[i].serverFlags & VOS_VLDB_READ_WRITE) {
516 printf("%s\tVOS_VLDB_READ_WRITE\n", prefix);
518 if (entry->volumeSites[i].serverFlags & VOS_VLDB_BACKUP) {
519 printf("%s\tVOS_VLDB_BACKUP\n", prefix);
521 if (entry->volumeSites[i].serverFlags & VOS_VLDB_DONT_USE) {
522 printf("%s\tVOS_VLDB_DONT_USE\n", prefix);
529 DoVosVLDBGet(struct cmd_syndesc *as, void *arock)
531 typedef enum { VOLUME } DoVosVLDBGet_parm_t;
533 vos_vldbEntry_t entry;
534 unsigned int volume_id;
535 const char *volume_name = NULL;
537 if (as->parms[VOLUME].items) {
538 const char *volume = as->parms[VOLUME].items->data;
539 volume_id = GetVolumeIdFromString(volume);
543 if (!vos_VLDBGet(cellHandle, 0, &volume_id, volume_name, &entry, &st)) {
544 ERR_ST_EXT("vos_VLDBGet", st);
547 Print_vos_vldbEntry_p(&entry, "");
553 DoVosVLDBList(struct cmd_syndesc *as, void *arock)
555 typedef enum { SERVER, PARTITION } DoVosVLDBList_parm_t;
557 void *vos_server = NULL;
558 unsigned int partition_id;
559 unsigned int *part_ptr = NULL;
561 vos_vldbEntry_t entry;
564 if (as->parms[SERVER].items) {
566 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
567 ERR_ST_EXT("vos_ServerOpen", st);
572 if (as->parms[PARTITION].items) {
574 ERR_EXT("must specify server when specifying partition");
577 GetPartitionIdFromString(as->parms[PARTITION].items->data);
578 part_ptr = &partition_id;
581 if (!vos_VLDBGetBegin(cellHandle, vos_server, 0, part_ptr, &iter, &st)) {
582 ERR_ST_EXT("vos_VLDBGetBegin", st);
585 while (vos_VLDBGetNext(iter, &entry, &st)) {
586 Print_vos_vldbEntry_p(&entry, "");
589 if (st != ADMITERATORDONE) {
590 ERR_ST_EXT("vos_VLDBGetNext", st);
593 if (!vos_VLDBGetDone(iter, &st)) {
594 ERR_ST_EXT("vos_VLDBGetDone", st);
601 DoVosVLDBEntryRemove(struct cmd_syndesc *as, void *arock)
603 typedef enum { SERVER, PARTITION, VOLUME } DoVosVLDBEntryRemove_parm_t;
605 void *vos_server = NULL;
606 unsigned int partition_id;
607 unsigned int *part_ptr = NULL;
609 unsigned int volume_id;
610 unsigned int *vol_ptr = NULL;
612 if (as->parms[SERVER].items) {
614 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
615 ERR_ST_EXT("vos_ServerOpen", st);
620 if (as->parms[PARTITION].items) {
622 ERR_EXT("must specify server when specifying partition");
625 GetPartitionIdFromString(as->parms[PARTITION].items->data);
626 part_ptr = &partition_id;
629 if (as->parms[VOLUME].items) {
630 const char *volume = as->parms[VOLUME].items->data;
631 volume_id = GetVolumeIdFromString(volume);
632 vol_ptr = &volume_id;
635 if (!vos_VLDBEntryRemove
636 (cellHandle, vos_server, 0, part_ptr, vol_ptr, &st)) {
637 ERR_ST_EXT("vos_VLDBEntryRemove", st);
644 DoVosVLDBUnlock(struct cmd_syndesc *as, void *arock)
646 typedef enum { SERVER, PARTITION } DoVosVLDBUnlock_parm_t;
648 void *vos_server = NULL;
649 unsigned int partition_id;
650 unsigned int *part_ptr = NULL;
653 if (as->parms[SERVER].items) {
655 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
656 ERR_ST_EXT("vos_ServerOpen", st);
661 if (as->parms[PARTITION].items) {
663 ERR_EXT("must specify server when specifying partition");
666 GetPartitionIdFromString(as->parms[PARTITION].items->data);
667 part_ptr = &partition_id;
670 if (!vos_VLDBUnlock(cellHandle, vos_server, 0, part_ptr, &st)) {
671 ERR_ST_EXT("vos_VLDBUnlock", st);
678 DoVosVLDBEntryLock(struct cmd_syndesc *as, void *arock)
680 typedef enum { VOLUME } DoVosVLDBEntryLoc_parm_tk;
682 unsigned int volume_id = 0;
684 if (as->parms[VOLUME].items) {
685 const char *volume = as->parms[VOLUME].items->data;
686 volume_id = GetVolumeIdFromString(volume);
689 if (!vos_VLDBEntryLock(cellHandle, 0, volume_id, &st)) {
690 ERR_ST_EXT("vos_VLDBEntryLock", st);
697 DoVosVLDBEntryUnlock(struct cmd_syndesc *as, void *arock)
699 typedef enum { VOLUME } DoVosVLDBEntryUnlock_parm_t;
701 unsigned int volume_id = 0;
703 if (as->parms[VOLUME].items) {
704 const char *volume = as->parms[VOLUME].items->data;
705 volume_id = GetVolumeIdFromString(volume);
708 if (!vos_VLDBEntryUnlock(cellHandle, 0, volume_id, &st)) {
709 ERR_ST_EXT("vos_VLDBEntryUnlock", st);
716 DoVosVLDBReadOnlySiteCreate(struct cmd_syndesc *as, void *arock)
718 typedef enum { SERVER, PARTITION,
720 } DoVosVLDBReadOnlySiteCreate_parm_t;
722 void *vos_server = NULL;
723 unsigned int partition_id = 0;
724 unsigned int volume_id = 0;
726 if (as->parms[SERVER].items) {
728 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
729 ERR_ST_EXT("vos_ServerOpen", st);
733 if (as->parms[PARTITION].items) {
735 GetPartitionIdFromString(as->parms[PARTITION].items->data);
738 if (as->parms[VOLUME].items) {
739 const char *volume = as->parms[VOLUME].items->data;
740 volume_id = GetVolumeIdFromString(volume);
743 if (!vos_VLDBReadOnlySiteCreate
744 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
745 ERR_ST_EXT("vos_VLDBReadOnlySiteCreate", st);
751 DoVosVLDBReadOnlySiteDelete(struct cmd_syndesc *as, void *arock)
753 typedef enum { SERVER, PARTITION,
755 } DoVosVLDBReadOnlySiteDelete_parm_t;
757 void *vos_server = NULL;
758 unsigned int partition_id = 0;
759 unsigned int volume_id = 0;
761 if (as->parms[SERVER].items) {
763 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
764 ERR_ST_EXT("vos_ServerOpen", st);
768 if (as->parms[PARTITION].items) {
770 GetPartitionIdFromString(as->parms[PARTITION].items->data);
773 if (as->parms[VOLUME].items) {
774 const char *volume = as->parms[VOLUME].items->data;
775 volume_id = GetVolumeIdFromString(volume);
778 if (!vos_VLDBReadOnlySiteDelete
779 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
780 ERR_ST_EXT("vos_VLDBReadOnlySiteDelete", st);
787 DoVosVLDBSync(struct cmd_syndesc *as, void *arock)
789 typedef enum { SERVER, PARTITION, FORCE } DoVosVLDBSync_parm_t;
791 void *vos_server = NULL;
792 unsigned int partition_id;
793 unsigned int *part_ptr = NULL;
795 vos_force_t force = VOS_NORMAL;
797 if (as->parms[SERVER].items) {
799 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
800 ERR_ST_EXT("vos_ServerOpen", st);
805 if (as->parms[PARTITION].items) {
807 ERR_EXT("must specify server when specifying partition");
810 GetPartitionIdFromString(as->parms[PARTITION].items->data);
811 part_ptr = &partition_id;
814 if (as->parms[FORCE].items) {
818 if (!vos_VLDBSync(cellHandle, vos_server, 0, part_ptr, force, &st)) {
819 ERR_ST_EXT("vos_VLDBSync", st);
826 DoVosVolumeCreate(struct cmd_syndesc *as, void *arock)
828 typedef enum { SERVER, PARTITION, VOLUME,
830 } DoVosVolumeCreate_parm_t;
832 void *vos_server = NULL;
833 unsigned int partition_id = 0;
834 unsigned int volume_id;
835 const char *volume = NULL;
836 unsigned int quota = 0;
838 if (as->parms[SERVER].items) {
840 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
841 ERR_ST_EXT("vos_ServerOpen", st);
845 if (as->parms[PARTITION].items) {
847 GetPartitionIdFromString(as->parms[PARTITION].items->data);
850 if (as->parms[VOLUME].items) {
851 volume = as->parms[VOLUME].items->data;
854 if (as->parms[QUOTA].items) {
856 GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
859 if (!vos_VolumeCreate
860 (cellHandle, vos_server, 0, partition_id, volume, quota, &volume_id,
862 ERR_ST_EXT("vos_VolumeCreate", st);
865 printf("Created volume %u\n", volume_id);
871 DoVosVolumeDelete(struct cmd_syndesc *as, void *arock)
873 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeDelete_parm_t;
875 void *vos_server = NULL;
876 unsigned int partition_id = 0;
877 unsigned int volume_id = 0;
879 if (as->parms[SERVER].items) {
881 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
882 ERR_ST_EXT("vos_ServerOpen", st);
886 if (as->parms[PARTITION].items) {
888 GetPartitionIdFromString(as->parms[PARTITION].items->data);
891 if (as->parms[VOLUME].items) {
892 const char *volume = as->parms[VOLUME].items->data;
893 volume_id = GetVolumeIdFromString(volume);
896 if (!vos_VolumeDelete
897 (cellHandle, vos_server, 0, partition_id, volume_id, &st)) {
898 ERR_ST_EXT("vos_VolumeDelete", st);
905 DoVosVolumeRename(struct cmd_syndesc *as, void *arock)
907 typedef enum { OLDVOLUME, NEWVOLUME } DoVosVolumeRename_parm_t;
909 unsigned int old_volume = 0;
910 const char *new_volume = 0;
912 if (as->parms[OLDVOLUME].items) {
913 const char *volume = as->parms[OLDVOLUME].items->data;
914 old_volume = GetVolumeIdFromString(volume);
917 if (as->parms[NEWVOLUME].items) {
918 new_volume = as->parms[NEWVOLUME].items->data;
921 if (!vos_VolumeRename(cellHandle, 0, old_volume, new_volume, &st)) {
922 ERR_ST_EXT("vos_VolumeRename", st);
929 DoVosVolumeDump(struct cmd_syndesc *as, void *arock)
931 typedef enum { SERVER, PARTITION, VOLUME, STARTTIME,
933 } DoVosVolumeDump_parm_t;
935 void *vos_server = NULL;
936 unsigned int partition_id;
937 unsigned int *part_ptr = NULL;
939 unsigned int volume_id = 0;
940 unsigned int start_time = 0;
941 const char *dumpfile = NULL;
943 if (as->parms[SERVER].items) {
945 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
946 ERR_ST_EXT("vos_ServerOpen", st);
951 if (as->parms[PARTITION].items) {
953 ERR_EXT("must specify server when specifying partition");
956 GetPartitionIdFromString(as->parms[PARTITION].items->data);
957 part_ptr = &partition_id;
960 if (as->parms[VOLUME].items) {
961 const char *volume = as->parms[VOLUME].items->data;
962 volume_id = GetVolumeIdFromString(volume);
965 if (as->parms[STARTTIME].items) {
967 GetIntFromString(as->parms[STARTTIME].items->data,
968 "invalid start time");
971 if (as->parms[DUMPFILE].items) {
972 dumpfile = as->parms[DUMPFILE].items->data;
976 (cellHandle, vos_server, 0, part_ptr, volume_id, start_time, dumpfile,
978 ERR_ST_EXT("vos_VolumeDump", st);
985 DoVosVolumeRestore(struct cmd_syndesc *as, void *arock)
987 typedef enum { SERVER, PARTITION, ID, VOLUME, DUMPFILE,
989 } DoVosVolumeRestore_parm_t;
991 void *vos_server = NULL;
992 unsigned int partition_id = 0;
993 unsigned int volume_id;
994 unsigned int *vol_ptr = NULL;
995 const char *dumpfile = NULL;
996 const char *volume_name = NULL;
997 vos_volumeRestoreType_t restore = VOS_RESTORE_INCREMENTAL;
999 if (as->parms[SERVER].items) {
1001 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1002 ERR_ST_EXT("vos_ServerOpen", st);
1006 if (as->parms[PARTITION].items) {
1008 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1011 if (as->parms[VOLUME].items) {
1012 volume_name = as->parms[VOLUME].items->data;
1015 if (as->parms[ID].items) {
1016 const char *volume = as->parms[ID].items->data;
1017 volume_id = GetVolumeIdFromString(volume);
1018 vol_ptr = &volume_id;
1021 if (as->parms[DUMPFILE].items) {
1022 dumpfile = as->parms[DUMPFILE].items->data;
1025 if (as->parms[FULL].items) {
1026 restore = VOS_RESTORE_FULL;
1029 if (!vos_VolumeRestore
1030 (cellHandle, vos_server, 0, partition_id, vol_ptr, volume_name,
1031 dumpfile, restore, &st)) {
1032 ERR_ST_EXT("vos_VolumeRestore", st);
1039 DoVosVolumeOnline(struct cmd_syndesc *as, void *arock)
1041 typedef enum { SERVER, PARTITION, VOLUME, SLEEP,
1043 } DoVosVolumeOnline_parm_t;
1044 afs_status_t st = 0;
1045 void *vos_server = NULL;
1046 unsigned int partition_id = 0;
1047 unsigned int volume_id = 0;
1048 unsigned int sleep = 0;
1049 vos_volumeOnlineType_t type = VOS_ONLINE_OFFLINE;
1051 if (as->parms[SERVER].items) {
1053 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1054 ERR_ST_EXT("vos_ServerOpen", st);
1058 if (as->parms[PARTITION].items) {
1060 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1063 if (as->parms[VOLUME].items) {
1064 const char *volume = as->parms[VOLUME].items->data;
1065 volume_id = GetVolumeIdFromString(volume);
1068 if (as->parms[SLEEP].items) {
1070 GetIntFromString(as->parms[SLEEP].items->data,
1071 "invalid sleep time");
1074 if (as->parms[BUSY].items) {
1075 type = VOS_ONLINE_BUSY;
1078 if (!vos_VolumeOnline
1079 (vos_server, 0, partition_id, volume_id, sleep, type, &st)) {
1080 ERR_ST_EXT("vos_VolumeOnline", st);
1087 DoVosVolumeOffline(struct cmd_syndesc *as, void *arock)
1089 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeOffline_parm_t;
1090 afs_status_t st = 0;
1091 void *vos_server = NULL;
1092 unsigned int partition_id = 0;
1093 unsigned int volume_id = 0;
1095 if (as->parms[SERVER].items) {
1097 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1098 ERR_ST_EXT("vos_ServerOpen", st);
1102 if (as->parms[PARTITION].items) {
1104 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1107 if (as->parms[VOLUME].items) {
1108 const char *volume = as->parms[VOLUME].items->data;
1109 volume_id = GetVolumeIdFromString(volume);
1112 if (!vos_VolumeOffline(vos_server, 0, partition_id, volume_id, &st)) {
1113 ERR_ST_EXT("vos_VolumeOffline", st);
1120 Print_vos_volumeEntry_p(vos_volumeEntry_p entry, const char *prefix)
1122 if (entry->status == VOS_OK) {
1123 printf("%sVolume name %s id %u\n", prefix, entry->name, entry->id);
1124 printf("%sRead write id %u\n", prefix, entry->readWriteId);
1125 printf("%sRead only id %u\n", prefix, entry->readOnlyId);
1126 printf("%sBackup id %u\n", prefix, entry->backupId);
1127 printf("%sCreation date %lu\n", prefix, entry->creationDate);
1128 printf("%sLast access date %lu\n", prefix, entry->lastAccessDate);
1129 printf("%sLast update date %lu\n", prefix, entry->lastUpdateDate);
1130 printf("%sLast backup date %lu\n", prefix, entry->lastBackupDate);
1131 printf("%sLast copy creation date %lu\n", prefix,
1132 entry->copyCreationDate);
1133 printf("%sAccesses since midnight %d\n", prefix,
1134 entry->accessesSinceMidnight);
1135 printf("%sFile count %d\n", prefix, entry->fileCount);
1136 printf("%sMax quota %d\n", prefix, entry->maxQuota);
1137 printf("%sCurrent size %d\n", prefix, entry->currentSize);
1139 printf("%sVolume status: VOS_OK\n", prefix);
1141 printf("%sVolume disposition:\n", prefix);
1143 switch (entry->volumeDisposition) {
1145 printf("%s\tVOS_OK\n", prefix);
1148 printf("%s\tVOS_SALVAGE\n", prefix);
1151 printf("%s\tVOS_NO_VNODE\n", prefix);
1154 printf("%s\tVOS_NO_VOL\n", prefix);
1156 case VOS_VOL_EXISTS:
1157 printf("%s\tVOS_VOL_EXISTS\n", prefix);
1159 case VOS_NO_SERVICE:
1160 printf("%s\tVOS_NO_SERVICE\n", prefix);
1163 printf("%s\tVOS_OFFLINE\n", prefix);
1166 printf("%s\tVOS_ONLINE\n", prefix);
1169 printf("%s\tVOS_DISK_FULL\n", prefix);
1171 case VOS_OVER_QUOTA:
1172 printf("%s\tVOS_OVER_QUOTA\n", prefix);
1175 printf("%s\tVOS_BUSY\n", prefix);
1178 printf("%s\tVOS_MOVED\n", prefix);
1181 printf("Unknown volume disposition %d\n",
1182 entry->volumeDisposition);
1186 printf("%sVolume type: ", prefix);
1188 if (entry->type == VOS_READ_WRITE_VOLUME) {
1189 printf("read write\n");
1190 } else if (entry->type == VOS_READ_ONLY_VOLUME) {
1191 printf("read only\n");
1196 printf("\n%s\tSame Network\tSame Network Authenticated"
1197 "\tDifferent Network\tDifferent Network Authenticated\n\n",
1199 printf("%sRead\t%d\t%d\t%d\t%d\n", prefix,
1200 entry->readStats[VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK],
1203 [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1205 readStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
1208 [VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK_AUTHENTICATED]);
1209 printf("%sWrite\t%d\t%d\t%d\t%d\n", prefix,
1210 entry->writeStats[VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK],
1213 [VOS_VOLUME_READ_WRITE_STATS_SAME_NETWORK_AUTHENTICATED],
1215 writeStats[VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK],
1218 [VOS_VOLUME_READ_WRITE_STATS_DIFFERENT_NETWORK_AUTHENTICATED]);
1221 ("\n%s\t0 to 60 secs\t1 to 10 mins\t10 to 60 mins\t1 to 24 hrs\t1 to 7 days\t more than 7 days\n",
1223 printf("%sFile Author Write Same Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1226 fileAuthorWriteSameNetwork
1227 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1229 fileAuthorWriteSameNetwork
1230 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1232 fileAuthorWriteSameNetwork
1233 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1235 fileAuthorWriteSameNetwork
1236 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1238 fileAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1240 fileAuthorWriteSameNetwork
1241 [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1242 printf("%sFile Author Write Diff Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1245 fileAuthorWriteDifferentNetwork
1246 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1248 fileAuthorWriteDifferentNetwork
1249 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1251 fileAuthorWriteDifferentNetwork
1252 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1254 fileAuthorWriteDifferentNetwork
1255 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1257 fileAuthorWriteDifferentNetwork
1258 [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1260 fileAuthorWriteDifferentNetwork
1261 [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1262 printf("%sDir Author Write Same Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1265 dirAuthorWriteSameNetwork
1266 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1268 dirAuthorWriteSameNetwork
1269 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1271 dirAuthorWriteSameNetwork
1272 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1274 dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1276 dirAuthorWriteSameNetwork[VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1278 dirAuthorWriteSameNetwork
1279 [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1280 printf("%sDir Author Write Diff Network\t%d\t%d\t%d\t%d\t%d\t%d\n",
1283 dirAuthorWriteDifferentNetwork
1284 [VOS_VOLUME_TIME_STATS_0_TO_60_SECONDS],
1286 dirAuthorWriteDifferentNetwork
1287 [VOS_VOLUME_TIME_STATS_1_TO_10_MINUTES],
1289 dirAuthorWriteDifferentNetwork
1290 [VOS_VOLUME_TIME_STATS_10_TO_60_MINUTES],
1292 dirAuthorWriteDifferentNetwork
1293 [VOS_VOLUME_TIME_STATS_1_TO_24_HOURS],
1295 dirAuthorWriteDifferentNetwork
1296 [VOS_VOLUME_TIME_STATS_1_TO_7_DAYS],
1298 dirAuthorWriteDifferentNetwork
1299 [VOS_VOLUME_TIME_STATS_GREATER_THAN_7_DAYS]);
1301 printf("%sUnable to print volume because volume status:\n", prefix);
1302 switch (entry->status) {
1304 printf("%s\tVOS_SALVAGE\n", prefix);
1307 printf("%s\tVOS_NO_VNODE\n", prefix);
1310 printf("%s\tVOS_NO_VOL\n", prefix);
1312 case VOS_VOL_EXISTS:
1313 printf("%s\tVOS_VOL_EXISTS\n", prefix);
1315 case VOS_NO_SERVICE:
1316 printf("%s\tVOS_NO_SERVICE\n", prefix);
1319 printf("%s\tVOS_OFFLINE\n", prefix);
1322 printf("%s\tVOS_ONLINE\n", prefix);
1325 printf("%s\tVOS_DISK_FULL\n", prefix);
1327 case VOS_OVER_QUOTA:
1328 printf("%s\tVOS_OVER_QUOTA\n", prefix);
1331 printf("%s\tVOS_BUSY\n", prefix);
1334 printf("%s\tVOS_MOVED\n", prefix);
1337 printf("Unknown volume status %d\n", entry->status);
1344 DoVosVolumeGet(struct cmd_syndesc *as, void *arock)
1346 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1347 afs_status_t st = 0;
1348 void *vos_server = NULL;
1349 unsigned int partition_id = 0;
1350 unsigned int volume_id = 0;
1351 vos_volumeEntry_t entry;
1353 if (as->parms[SERVER].items) {
1355 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1356 ERR_ST_EXT("vos_ServerOpen", st);
1360 if (as->parms[PARTITION].items) {
1362 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1365 if (as->parms[VOLUME].items) {
1366 const char *volume = as->parms[VOLUME].items->data;
1367 volume_id = GetVolumeIdFromString(volume);
1371 (cellHandle, vos_server, 0, partition_id, volume_id, &entry, &st)) {
1372 ERR_ST_EXT("vos_VolumeGet", st);
1375 Print_vos_volumeEntry_p(&entry, "");
1381 DoVosVolumeList(struct cmd_syndesc *as, void *arock)
1383 typedef enum { SERVER, PARTITION } DoVosVolumeList_parm_t;
1384 afs_status_t st = 0;
1385 void *vos_server = NULL;
1387 unsigned int partition_id = 0;
1388 vos_volumeEntry_t entry;
1390 if (as->parms[SERVER].items) {
1392 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1393 ERR_ST_EXT("vos_ServerOpen", st);
1397 if (as->parms[PARTITION].items) {
1399 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1402 if (!vos_VolumeGetBegin
1403 (cellHandle, vos_server, 0, partition_id, &iter, &st)) {
1404 ERR_ST_EXT("vos_VolumeGetBegin", st);
1407 printf("Volumes located at %s partition %s\n",
1408 as->parms[SERVER].items->data, as->parms[PARTITION].items->data);
1410 while (vos_VolumeGetNext(iter, &entry, &st)) {
1411 Print_vos_volumeEntry_p(&entry, " ");
1415 if (st != ADMITERATORDONE) {
1416 ERR_ST_EXT("vos_VolumeGetNext", st);
1419 if (!vos_VolumeGetDone(iter, &st)) {
1420 ERR_ST_EXT("vos_VolumeGetDone", st);
1427 DoVosVolumeMove(struct cmd_syndesc *as, void *arock)
1429 typedef enum { VOLUME, FROMSERVER, FROMPARTITION, TOSERVER,
1431 } DoVosVolumeMove_parm_t;
1432 afs_status_t st = 0;
1433 void *from_server = NULL;
1434 void *to_server = NULL;
1435 unsigned int from_partition = 0;
1436 unsigned int to_partition = 0;
1437 unsigned int volume_id = 0;
1439 if (as->parms[FROMSERVER].items) {
1441 (cellHandle, as->parms[FROMSERVER].items->data, &from_server,
1443 ERR_ST_EXT("vos_ServerOpen", st);
1447 if (as->parms[TOSERVER].items) {
1449 (cellHandle, as->parms[TOSERVER].items->data, &to_server, &st)) {
1450 ERR_ST_EXT("vos_ServerOpen", st);
1454 if (as->parms[FROMPARTITION].items) {
1456 GetPartitionIdFromString(as->parms[FROMPARTITION].items->data);
1459 if (as->parms[TOPARTITION].items) {
1461 GetPartitionIdFromString(as->parms[TOPARTITION].items->data);
1464 if (as->parms[VOLUME].items) {
1465 const char *volume = as->parms[VOLUME].items->data;
1466 volume_id = GetVolumeIdFromString(volume);
1470 (cellHandle, 0, volume_id, from_server, from_partition, to_server,
1471 to_partition, &st)) {
1472 ERR_ST_EXT("vos_VolumeMove", st);
1479 DoVosVolumeRelease(struct cmd_syndesc *as, void *arock)
1481 typedef enum { VOLUME, FORCE } DoVosVolumeRelease_parm_t;
1482 afs_status_t st = 0;
1483 unsigned int volume_id = 0;
1484 vos_force_t force = VOS_NORMAL;
1486 if (as->parms[VOLUME].items) {
1487 const char *volume = as->parms[VOLUME].items->data;
1488 volume_id = GetVolumeIdFromString(volume);
1491 if (as->parms[FORCE].items) {
1495 if (!vos_VolumeRelease(cellHandle, 0, volume_id, force, &st)) {
1496 ERR_ST_EXT("vos_VolumeRelease", st);
1502 DoVosVolumeZap(struct cmd_syndesc *as, void *arock)
1504 typedef enum { SERVER, PARTITION, VOLUME, FORCE } DoVosVolumeZap_parm_t;
1505 afs_status_t st = 0;
1506 void *vos_server = NULL;
1507 unsigned int partition_id = 0;
1508 unsigned int volume_id = 0;
1509 vos_force_t force = VOS_NORMAL;
1511 if (as->parms[SERVER].items) {
1513 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1514 ERR_ST_EXT("vos_ServerOpen", st);
1518 if (as->parms[PARTITION].items) {
1520 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1523 if (as->parms[VOLUME].items) {
1524 const char *volume = as->parms[VOLUME].items->data;
1525 volume_id = GetVolumeIdFromString(volume);
1528 if (as->parms[FORCE].items) {
1533 (cellHandle, vos_server, 0, partition_id, volume_id, force, &st)) {
1534 ERR_ST_EXT("vos_VolumeZap", st);
1541 DoVosPartitionNameToId(struct cmd_syndesc *as, void *arock)
1543 typedef enum { PARTITION } DoVosPartitionNameToId_parm_t;
1544 afs_status_t st = 0;
1545 unsigned int partition_id = 0;
1547 if (as->parms[PARTITION].items) {
1549 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1552 printf("The id for partition %s is %u\n",
1553 as->parms[PARTITION].items->data, partition_id);
1559 DoVosPartitionIdToName(struct cmd_syndesc *as, void *arock)
1561 typedef enum { PARTITIONID } DoVosPartitionIdToName_parm_t;
1562 afs_status_t st = 0;
1563 unsigned int partition_id = 0;
1564 char partition[VOS_MAX_PARTITION_NAME_LEN];
1566 if (as->parms[PARTITIONID].items) {
1568 GetIntFromString(as->parms[PARTITIONID].items->data,
1569 "bad partition id");
1572 if (!vos_PartitionIdToName(partition_id, partition, &st)) {
1573 ERR_ST_EXT("bad partition id", st);
1576 printf("The partition for id %u is %s\n", partition_id, partition);
1582 DoVosVolumeQuotaChange(struct cmd_syndesc *as, void *arock)
1584 typedef enum { SERVER, PARTITION, VOLUME,
1586 } DoVosVolumeQuotaChange_parm_t;
1587 afs_status_t st = 0;
1588 void *vos_server = NULL;
1589 unsigned int partition_id = 0;
1590 unsigned int volume_id = 0;
1591 unsigned int quota = 0;
1593 if (as->parms[SERVER].items) {
1595 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1596 ERR_ST_EXT("vos_ServerOpen", st);
1600 if (as->parms[PARTITION].items) {
1602 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1605 if (as->parms[VOLUME].items) {
1606 const char *volume = as->parms[VOLUME].items->data;
1607 volume_id = GetVolumeIdFromString(volume);
1610 if (as->parms[QUOTA].items) {
1612 GetIntFromString(as->parms[QUOTA].items->data, "invalid quota");
1615 if (!vos_VolumeQuotaChange
1616 (cellHandle, vos_server, 0, partition_id, volume_id, quota, &st)) {
1617 ERR_ST_EXT("vos_VolumeQuotaChange", st);
1624 * Parse a server name/address and return the address in HOST BYTE order
1627 GetServer(char *aname)
1629 register struct hostent *th;
1632 register afs_int32 code;
1633 char hostname[MAXHOSTCHARS];
1635 code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
1637 addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
1638 addr = ntohl(addr); /* convert to host order */
1640 th = gethostbyname(aname);
1643 memcpy(&addr, th->h_addr, sizeof(addr));
1646 if (addr == htonl(0x7f000001)) { /* local host */
1647 code = gethostname(hostname, MAXHOSTCHARS);
1650 th = gethostbyname(hostname); /* returns host byte order */
1653 memcpy(&addr, th->h_addr, sizeof(addr));
1660 Print_vos_volintInfo(afs_uint32 server, afs_uint32 partition, volintInfo* pinfo, const char *prefix)
1662 static afs_uint32 server_cache;
1663 static int cache_valid = 0;
1664 static char hostname[256], address[32];
1666 if (!cache_valid || server != server_cache) {
1670 strcpy(hostname, hostutil_GetNameByINet(server));
1671 strcpy(address, inet_ntoa(s));
1672 server_cache = server;
1677 printf("%sname\t\t%s\n",prefix, pinfo->name);
1678 printf("%sid\t\t%lu\n",prefix, pinfo->volid);
1679 printf("%sserv\t\t%s\t%s\n",prefix, address,hostname);
1680 printf("%spart\t\t%u\n", prefix,partition);
1682 switch (pinfo->status) {
1684 printf("%sstatus\t\tOK\n",prefix);
1686 case 101: /* VBUSY */
1687 printf("%sstatus\t\tBUSY\n",prefix);
1690 printf("%sstatus\t\tUNATTACHABLE\n",prefix);
1693 printf("%sbackupID\t%lu\n",prefix, pinfo->backupID);
1694 printf("%sparentID\t%lu\n",prefix, pinfo->parentID);
1695 printf("%scloneID\t%lu\n",prefix, pinfo->cloneID);
1696 printf("%sinUse\t\t%s\n",prefix, pinfo->inUse ? "Y" : "N");
1697 printf("%sneedsSalvaged\t%s\n",prefix, pinfo->needsSalvaged ? "Y" : "N");
1698 /* 0xD3 is from afs/volume.h since I had trouble including the file */
1699 printf("%sdestroyMe\t%s\n",prefix, pinfo->destroyMe == 0xD3 ? "Y" : "N");
1700 switch (pinfo->type) {
1702 printf("%stype\t\tRW\n",prefix);
1705 printf("%stype\t\tRO\n",prefix);
1708 printf("%stype\t\tBK\n",prefix);
1711 printf("%stype\t\t?\n",prefix);
1714 printf("%screationDate\t%-9lu\n", prefix,pinfo->creationDate);
1715 printf("%saccessDate\t%-9lu\n", prefix,pinfo->accessDate);
1716 printf("%supdateDate\t%-9lu\n", prefix,pinfo->updateDate);
1717 printf("%sbackupDate\t%-9lu\n", prefix,pinfo->backupDate);
1718 printf("%scopyDate\t%-9lu\n", prefix,pinfo->copyDate);
1720 printf("%sflags\t\t%#lx\t(Optional)\n",prefix, pinfo->flags);
1721 printf("%sdiskused\t%u\n",prefix, pinfo->size);
1722 printf("%smaxquota\t%u\n",prefix, pinfo->maxquota);
1723 printf("%sminquota\t%lu\t(Optional)\n",prefix, pinfo->spare0);
1724 printf("%sfilecount\t%u\n",prefix, pinfo->filecount);
1725 printf("%sdayUse\t\t%u\n",prefix, pinfo->dayUse);
1726 printf("%sweekUse\t%lu\t(Optional)\n",prefix, pinfo->spare1);
1727 printf("%svolUpdateCounter\t\t%lu\t(Optional)\n",prefix, pinfo->spare2);
1728 printf("%sspare3\t\t%lu\t(Optional)\n",prefix, pinfo->spare3);
1732 DoVosVolumeGet2(struct cmd_syndesc *as, void *arock)
1734 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1735 afs_status_t st = 0;
1736 void *vos_server = NULL;
1737 afs_uint32 partition_id = 0;
1738 afs_uint32 volume_id = 0;
1741 memset(&info, 0, sizeof(struct volintInfo));
1743 if (as->parms[SERVER].items) {
1745 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1746 ERR_ST_EXT("vos_ServerOpen", st);
1750 if (as->parms[PARTITION].items) {
1752 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1755 if (as->parms[VOLUME].items) {
1756 const char *volume = as->parms[VOLUME].items->data;
1757 volume_id = GetVolumeIdFromString(volume);
1762 (cellHandle, vos_server, 0, partition_id, volume_id, &info, &st)) {
1763 ERR_ST_EXT("vos_VolumeGet2", st);
1767 Print_vos_volintInfo(GetServer(as->parms[SERVER].items->data),partition_id,&info," ");
1774 DoVos_ClearVolUpdateCounter(struct cmd_syndesc *as, void *arock)
1776 typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
1777 afs_status_t st = 0;
1778 void *vos_server = NULL;
1779 unsigned int partition_id = 0;
1780 unsigned int volume_id = 0;
1782 if (as->parms[SERVER].items) {
1784 (cellHandle, as->parms[SERVER].items->data, &vos_server, &st)) {
1785 ERR_ST_EXT("vos_ServerOpen", st);
1789 if (as->parms[PARTITION].items) {
1791 GetPartitionIdFromString(as->parms[PARTITION].items->data);
1794 if (as->parms[VOLUME].items) {
1795 const char *volume = as->parms[VOLUME].items->data;
1796 volume_id = GetVolumeIdFromString(volume);
1799 if (!vos_ClearVolUpdateCounter
1800 (cellHandle, vos_server,partition_id, volume_id, &st)) {
1801 ERR_ST_EXT("vos_ClearVolUpdateCounter", st);
1808 SetupVosAdminCmd(void)
1810 struct cmd_syndesc *ts;
1812 ts = cmd_CreateSyntax("VosBackupVolumeCreate", DoVosBackupVolumeCreate, NULL,
1813 "create a backup volume");
1814 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to back up");
1815 SetupCommonCmdArgs(ts);
1817 ts = cmd_CreateSyntax("VosBackupVolumeCreateMultiple",
1818 DoVosBackupVolumeCreateMultiple, NULL,
1819 "create a backup volume");
1820 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1821 "server housing volumes to back up");
1822 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1823 "partition housing volumes to back up");
1824 cmd_AddParm(ts, "-prefix", CMD_SINGLE, CMD_OPTIONAL,
1825 "common prefix of volumes to back up");
1826 cmd_AddParm(ts, "-exclude", CMD_FLAG, CMD_OPTIONAL,
1827 "exclude volumes from backup that match prefix");
1828 SetupCommonCmdArgs(ts);
1830 ts = cmd_CreateSyntax("VosPartitionGet", DoVosPartitionGet, NULL,
1831 "get information about a partition");
1832 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1833 "server housing partition of interest");
1834 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1835 "partition to query");
1836 SetupCommonCmdArgs(ts);
1838 ts = cmd_CreateSyntax("VosPartitionList", DoVosPartitionList, NULL,
1839 "list information about all partitions at a server");
1840 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1841 "server housing partitions of interest");
1842 SetupCommonCmdArgs(ts);
1844 ts = cmd_CreateSyntax("VosServerSync", DoVosServerSync, NULL,
1845 "sync server with vldb");
1846 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
1847 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1848 "partition to sync");
1849 SetupCommonCmdArgs(ts);
1851 ts = cmd_CreateSyntax("VosFileServerAddressChange",
1852 DoVosFileServerAddressChange, NULL,
1853 "change a server's address in the vldb");
1854 cmd_AddParm(ts, "-oldaddress", CMD_SINGLE, CMD_REQUIRED,
1855 "old address to change");
1856 cmd_AddParm(ts, "-newaddress", CMD_SINGLE, CMD_REQUIRED, "new address");
1857 SetupCommonCmdArgs(ts);
1859 ts = cmd_CreateSyntax("VosFileServerAddressRemove",
1860 DoVosFileServerAddressRemove, NULL,
1861 "remove a server's address from the vldb");
1862 cmd_AddParm(ts, "-address", CMD_SINGLE, CMD_REQUIRED,
1863 "address to remove");
1864 SetupCommonCmdArgs(ts);
1866 ts = cmd_CreateSyntax("VosFileServerList", DoVosFileServerList, NULL,
1867 "list the file servers in a cell");
1868 SetupCommonCmdArgs(ts);
1870 ts = cmd_CreateSyntax("VosServerTransactionStatusList",
1871 DoVosServerTransactionStatusList, NULL,
1872 "list the active transactions at a server");
1873 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1874 SetupCommonCmdArgs(ts);
1876 ts = cmd_CreateSyntax("VosVLDBGet", DoVosVLDBGet, NULL,
1877 "get a vldb entry for a volume");
1878 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1879 "volume to retrieve");
1880 SetupCommonCmdArgs(ts);
1882 ts = cmd_CreateSyntax("VosVLDBList", DoVosVLDBList, NULL,
1883 "list a group of vldb entries");
1884 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1885 "limit entries to a particular server");
1886 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1887 "limit entries to a particular partition");
1888 SetupCommonCmdArgs(ts);
1890 ts = cmd_CreateSyntax("VosVLDBEntryRemove", DoVosVLDBEntryRemove, NULL,
1891 "remove vldb entries");
1892 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1893 "limit entries to a particular server");
1894 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1895 "limit entries to a particular partition");
1896 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume to remove");
1897 SetupCommonCmdArgs(ts);
1899 ts = cmd_CreateSyntax("VosVLDBUnlock", DoVosVLDBUnlock, NULL,
1900 "unlock a group of vldb entries");
1901 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1902 "limit entries to a particular server");
1903 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1904 "limit entries to a particular partition");
1905 SetupCommonCmdArgs(ts);
1907 ts = cmd_CreateSyntax("VosVLDBEntryLock", DoVosVLDBList, NULL,
1908 "lock a single vldb entry");
1909 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to lock");
1910 SetupCommonCmdArgs(ts);
1912 ts = cmd_CreateSyntax("VosVLDBEntryUnlock", DoVosVLDBEntryUnlock, NULL,
1913 "unlock a single vldb entry");
1914 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to unlock");
1915 SetupCommonCmdArgs(ts);
1917 ts = cmd_CreateSyntax("VosVLDBReadOnlySiteCreate",
1918 DoVosVLDBReadOnlySiteCreate, NULL,
1919 "create a read only site");
1920 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1921 "server where read only will be created");
1922 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1923 "partition where read only will be created");
1924 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1925 "volume to replicate");
1926 SetupCommonCmdArgs(ts);
1928 ts = cmd_CreateSyntax("VosVLDBReadOnlySiteDelete",
1929 DoVosVLDBReadOnlySiteDelete, NULL,
1930 "delete a read only site before initial replication");
1931 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1932 "server where read only will be deleted");
1933 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1934 "partition where read only will be deleted");
1935 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
1936 SetupCommonCmdArgs(ts);
1938 ts = cmd_CreateSyntax("VosVLDBSync", DoVosVLDBSync, NULL,
1939 "sync vldb with server");
1940 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
1941 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1942 "limit sync to a particular partition");
1943 cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force sync to occur");
1944 SetupCommonCmdArgs(ts);
1946 ts = cmd_CreateSyntax("VosVolumeCreate", DoVosVolumeCreate, NULL,
1947 "create a read write volume");
1948 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1949 "server where volume will be created");
1950 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1951 "partition where volume will be created");
1952 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1953 "name of new volume");
1954 cmd_AddParm(ts, "-quota", CMD_SINGLE, CMD_REQUIRED,
1955 "size quota of new volume in 1kb units");
1956 SetupCommonCmdArgs(ts);
1958 ts = cmd_CreateSyntax("VosVolumeDelete", DoVosVolumeDelete, NULL,
1960 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1961 "server where volume exists");
1962 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1963 "partition where volume exists");
1964 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
1965 SetupCommonCmdArgs(ts);
1967 ts = cmd_CreateSyntax("VosVolumeRename", DoVosVolumeRename, NULL,
1969 cmd_AddParm(ts, "-oldname", CMD_SINGLE, CMD_REQUIRED, "old volume name");
1970 cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new volume name");
1971 SetupCommonCmdArgs(ts);
1973 ts = cmd_CreateSyntax("VosVolumeDump", DoVosVolumeDump, NULL,
1974 "dump a volume to a file");
1975 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
1976 "dump volume at a particular server");
1977 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
1978 "dump volume at a particular partition");
1979 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to dump");
1980 cmd_AddParm(ts, "-starttime", CMD_SINGLE, CMD_REQUIRED,
1981 "files modified after this time will be dumped");
1982 cmd_AddParm(ts, "-dumpfile", CMD_SINGLE, CMD_REQUIRED,
1983 "file to contain dump results");
1984 SetupCommonCmdArgs(ts);
1986 ts = cmd_CreateSyntax("VosVolumeRestore", DoVosVolumeRestore, NULL,
1987 "restore a volume from a dumpfile");
1988 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1989 "server that houses volume to restore");
1990 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
1991 "partition that houses volume to restore");
1992 cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "id of volume restored");
1993 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1994 "name of volume restored");
1995 cmd_AddParm(ts, "-dumpfile", CMD_SINGLE, CMD_REQUIRED,
1996 "file contained dump of volume");
1997 cmd_AddParm(ts, "-full", CMD_FLAG, CMD_OPTIONAL,
1998 "does a full restore of volume");
1999 SetupCommonCmdArgs(ts);
2001 ts = cmd_CreateSyntax("VosVolumeOnline", DoVosVolumeOnline, NULL,
2002 "bring a volume online");
2003 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2004 "server that houses volume");
2005 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2006 "partition that houses volume");
2007 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2008 "volume to bring online");
2009 cmd_AddParm(ts, "-sleep", CMD_SINGLE, CMD_REQUIRED, "seconds to sleep");
2010 cmd_AddParm(ts, "-busy", CMD_FLAG, CMD_OPTIONAL, "mark volume busy");
2011 SetupCommonCmdArgs(ts);
2013 ts = cmd_CreateSyntax("VosVolumeOffline", DoVosVolumeOffline, NULL,
2014 "take a volume offline");
2015 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2016 "server that houses volume");
2017 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2018 "partition that houses volume");
2019 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2020 "volume to bring offline");
2021 SetupCommonCmdArgs(ts);
2023 ts = cmd_CreateSyntax("VosVolumeGet", DoVosVolumeGet, NULL,
2024 "get a volume entry");
2025 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2026 "server that houses volume");
2027 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2028 "partition that houses volume");
2029 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2030 "volume to retrieve");
2031 SetupCommonCmdArgs(ts);
2033 ts = cmd_CreateSyntax("VosVolumeList", DoVosVolumeList, NULL,
2034 "list a group of volumes");
2035 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2036 "limit volumes to a particular server");
2037 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2038 "limit volumes to a particular partition");
2039 SetupCommonCmdArgs(ts);
2041 ts = cmd_CreateSyntax("VosVolumeMove", DoVosVolumeMove, NULL,
2043 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to move");
2044 cmd_AddParm(ts, "-fromserver", CMD_SINGLE, CMD_REQUIRED, "source server");
2045 cmd_AddParm(ts, "-frompartition", CMD_SINGLE, CMD_REQUIRED,
2046 "source partition");
2047 cmd_AddParm(ts, "-toserver", CMD_SINGLE, CMD_REQUIRED,
2048 "destination server");
2049 cmd_AddParm(ts, "-topartition", CMD_SINGLE, CMD_REQUIRED,
2050 "destination partition");
2051 SetupCommonCmdArgs(ts);
2053 ts = cmd_CreateSyntax("VosVolumeRelease", DoVosVolumeRelease, NULL,
2054 "release updates to read only");
2055 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2056 "volume to replicate");
2057 cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
2058 "force release to occur");
2059 SetupCommonCmdArgs(ts);
2061 ts = cmd_CreateSyntax("VosVolumeZap", DoVosVolumeZap, NULL, "zap a volume");
2062 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2063 "server that houses the volume to zap");
2064 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2065 "partition that houses the volume to zap");
2066 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to zap");
2067 cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force zap");
2068 SetupCommonCmdArgs(ts);
2070 ts = cmd_CreateSyntax("VosPartitionNameToId", DoVosPartitionNameToId, NULL,
2071 "convert a partition name to a number");
2072 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2073 "partition to convert");
2074 SetupCommonCmdArgs(ts);
2076 ts = cmd_CreateSyntax("VosPartitionIdToName", DoVosPartitionIdToName, NULL,
2077 "convert a number to a partition");
2078 cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED, "number to convert");
2079 SetupCommonCmdArgs(ts);
2081 ts = cmd_CreateSyntax("VosVolumeQuotaChange", DoVosVolumeQuotaChange, NULL,
2082 "change the quota for a partition");
2083 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2084 "server that houses the volume");
2085 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2086 "partition that houses the volume");
2087 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to change");
2088 cmd_AddParm(ts, "-quota", CMD_SINGLE, CMD_REQUIRED,
2089 "new quota in 1kb units");
2090 SetupCommonCmdArgs(ts);
2092 ts = cmd_CreateSyntax("VosVolumeGet2", DoVosVolumeGet2, NULL,
2093 "get a volume entry");
2094 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2095 "server that houses volume");
2096 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2097 "partition that houses volume");
2098 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2099 "volume to retrieve");
2100 SetupCommonCmdArgs(ts);
2102 ts = cmd_CreateSyntax("ClearVolUpdateCounter", DoVos_ClearVolUpdateCounter, NULL,
2103 "clear volUpdateCounter");
2104 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2105 "server that houses volume");
2106 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
2107 "partition that houses volume");
2108 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
2110 SetupCommonCmdArgs(ts);