58d8c74a30688f1987e4fcd830f63c9480beb3e0
[openafs.git] / src / libadmin / vos / afs_vosAdmin.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID("$Header$");
14
15 #include <afs/stds.h>
16 #include <stdio.h>
17 #ifdef HAVE_STRINGS_H
18 #include <strings.h>
19 #else
20 #ifdef HAVE_STRING_H
21 #include <string.h>
22 #endif
23 #endif
24 #include <ctype.h>
25 #ifdef AFS_NT40_ENV
26 #include <winsock2.h>
27 #include <io.h>
28 #else
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <unistd.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
34 #include <netdb.h>
35 #endif
36 #include "afs_vosAdmin.h"
37 #include "../adminutil/afs_AdminInternal.h"
38 #include <afs/afs_utilAdmin.h>
39 #include <afs/vlserver.h>
40 #include <afs/volser.h>
41 #include <afs/volint.h>
42 #include <afs/partition.h>
43 #include <rx/rx.h>
44 #include "vosutils.h"
45 #include "vsprocs.h"
46 #include "lockprocs.h"
47
48 extern int VL_GetAddrsU();
49
50 typedef struct file_server {
51     int begin_magic;
52     int is_valid;
53     struct rx_connection *serv;
54     int end_magic;
55 } file_server_t, *file_server_p;
56
57 /*
58  * IsValidServerHandle - test a server handle for validity.
59  *
60  * PARAMETERS
61  *
62  * IN serverHandle - the serverHandle to be validated.
63  *
64  * LOCKS
65  * 
66  * No locks are obtained or released by this function
67  *
68  * RETURN CODES
69  *
70  * Returns != 0 upon successful completion.
71  */
72
73 static int IsValidServerHandle(
74     file_server_p serverHandle,
75     afs_status_p st)
76 {
77     int rc = 0;
78     afs_status_t tst = 0;
79
80     if (serverHandle == NULL) {
81         tst = ADMVOSSERVERHANDLENULL;
82         goto fail_IsValidServerHandle;
83     }
84
85     if (serverHandle->is_valid != 1) {
86         tst = ADMVOSSERVERHANDLEINVALID;
87         goto fail_IsValidServerHandle;
88     }
89
90     if ((serverHandle->begin_magic != BEGIN_MAGIC) ||
91         (serverHandle->end_magic != END_MAGIC)) {
92         tst = ADMVOSSERVERHANDLEBADMAGIC;
93         goto fail_IsValidServerHandle;
94     }
95     rc = 1;
96
97 fail_IsValidServerHandle:
98
99     if (st != NULL) {
100         *st = tst;
101     }
102
103     return rc;
104 }
105
106 /*
107  * IsValidCellHandle - verify that a cell handle can be used to make vos 
108  * requests.
109  *
110  * PARAMETERS
111  *
112  * IN cellHandle - the cellHandle to be validated.
113  *
114  * LOCKS
115  * 
116  * No locks are obtained or released by this function
117  *
118  * RETURN CODES
119  *
120  * Returns != 0 upon successful completion.
121  */
122
123 static int IsValidCellHandle(
124   afs_cell_handle_p cellHandle,
125   afs_status_p st)
126 {
127     int rc = 0;
128     afs_status_t tst = 0;
129
130     if (!CellHandleIsValid((void *) cellHandle, &tst)) {
131         goto fail_IsValidCellHandle;
132     }
133
134     if (cellHandle->vos_valid == 0) {
135         tst = ADMVOSCELLHANDLEINVALIDVOS;
136         goto fail_IsValidCellHandle;
137     }
138     rc = 1;
139
140 fail_IsValidCellHandle:
141
142     if (st != NULL) {
143         *st = tst;
144     }
145     return rc;
146 }
147
148 /* set <server> and <part> to the correct values depending on
149  * <voltype> and <entry> */
150 static void GetServerAndPart (
151   struct nvldbentry *entry,
152   int voltype,
153   afs_int32 *server,
154   afs_int32 *part,
155   int *previdx)
156 {
157     int i, istart, vtype;
158  
159     *server = -1;
160     *part   = -1;
161  
162     /* Doesn't check for non-existance of backup volume */
163     if ((voltype == RWVOL) || (voltype == BACKVOL)) {
164        vtype = ITSRWVOL;
165        istart = 0;      /* seach the entire entry */
166     } else {
167        vtype = ITSROVOL;
168        /* Seach from beginning of entry or pick up where we left off */
169        istart = ((*previdx < 0) ? 0 : *previdx+1);
170     }
171  
172     for (i = istart; i < entry->nServers; i++) {
173        if (entry->serverFlags[i] & vtype) {
174           *server = entry->serverNumber[i];
175           *part   = entry->serverPartition[i];
176           *previdx = i;
177           return;
178        }
179     }
180  
181     /* Didn't find any, return -1 */
182     *previdx = -1;
183     return;
184 }
185
186 /*
187  * vos_BackupVolumeCreate - create a backup volume for a volume.
188  *
189  * PARAMETERS
190  *
191  * IN cellHandle - a previously opened cellHandle that corresponds
192  * to the cell where volume exists.
193  *
194  * IN callBack - a call back function pointer that may be called to report
195  * status information.  Can be null.
196  *
197  * IN volumeId - the volume to create the back up for.
198  *
199  * LOCKS
200  * 
201  * No locks are obtained or released by this function
202  *
203  * RETURN CODES
204  *
205  * Returns != 0 upon successful completion.
206  */
207
208 int ADMINAPI vos_BackupVolumeCreate(
209   const void *cellHandle,
210   vos_MessageCallBack_t callBack,
211   unsigned int volumeId,
212   afs_status_p st)
213 {
214     int rc = 0;
215     afs_status_t tst = 0;
216     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
217     struct nvldbentry rw_vol_entry;
218     afs_int32 rw_server;
219     afs_int32 rw_partition;
220     afs_int32 rw_vol_type;
221     struct nvldbentry bk_vol_entry;
222     afs_int32 bk_server;
223     afs_int32 bk_partition;
224     afs_int32 bk_vol_type;
225     int equal;
226  
227     /*
228      * Validate arguments
229      */
230
231     if (!IsValidCellHandle(c_handle, &tst)) {
232         goto fail_vos_BackupVolumeCreate;
233     }
234
235     /*
236      * Get the volume information and verify that we've been passed
237      * a read write volume id
238      */
239
240     if (!GetVolumeInfo(c_handle, volumeId, &rw_vol_entry, &rw_server,
241                        &rw_partition, &rw_vol_type, &tst)) {
242         goto fail_vos_BackupVolumeCreate;
243     }
244
245     if (rw_vol_type != RWVOL) {
246         tst = ADMVOSMUSTBERWVOL;
247         goto fail_vos_BackupVolumeCreate;
248     }
249
250     /*
251      * Check to see that if a backup volume exists, it exists on the
252      * same server as volumeId
253      */
254
255     if (rw_vol_entry.flags & BACK_EXISTS) {
256         if (!GetVolumeInfo(c_handle, rw_vol_entry.volumeId[BACKVOL],
257                            &bk_vol_entry, &bk_server, &bk_partition,
258                            &bk_vol_type, &tst)) {
259             goto fail_vos_BackupVolumeCreate;
260         }
261         if (!VLDB_IsSameAddrs(c_handle, bk_server, rw_server, &equal, &tst)) {
262             goto fail_vos_BackupVolumeCreate;
263         }
264         if (!equal) {
265             tst = ADMVOSBACKUPVOLWRONGSERVER;
266             goto fail_vos_BackupVolumeCreate;
267         }
268     }
269
270     /*
271      * Create the new backup volume
272      */
273
274     rc = UV_BackupVolume(c_handle, rw_server, rw_partition, volumeId, &tst);
275
276 fail_vos_BackupVolumeCreate:
277
278     if (st != NULL) {
279         *st = tst;
280     }
281     return rc;
282 }
283
284 /*
285  * vos_BackupVolumeCreateMultiple - create backup volumes en masse.
286  *
287  * PARAMETERS
288  *
289  * IN cellHandle - a previously opened cellHandle that corresponds
290  * to the cell where the volumes exist.
291  *
292  * IN serverHandle - the server where the backups are to be created.  Can be
293  * null.
294  *
295  * IN callBack - a call back function pointer that may be called to report
296  * status information.  Can be null.
297  *
298  * IN partition - the partition where the backups are to be created.  Can be
299  * null.
300  *
301  * IN volumePrefix - all volumes with this prefix will have backup volumes
302  * created. Can be null.
303  *
304  * IN excludePrefix - exclude the volumes that match volumePrefix.
305  *
306  * LOCKS
307  * 
308  * No locks are obtained or released by this function
309  *
310  * RETURN CODES
311  *
312  * Returns != 0 upon successful completion.
313  */
314
315 int ADMINAPI vos_BackupVolumeCreateMultiple(
316   const void *cellHandle,
317   const void *serverHandle,
318   vos_MessageCallBack_t callBack,
319   const unsigned int *partition,
320   const char *volumePrefix,
321   vos_exclude_t excludePrefix,
322   afs_status_p st)
323 {
324     int rc = 0;
325     afs_status_t tst = 0;
326     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
327     file_server_p f_server = (file_server_p) serverHandle;
328     struct VldbListByAttributes attr;
329     int exclude = 0;
330     int prefix = 0;
331     size_t prefix_len = 0;
332     nbulkentries arrayEntries;
333     afs_int32 nentries = 0;
334     register struct nvldbentry *entry;
335     int i;
336     afs_int32 rw_volid, rw_server, rw_partition;
337     int previdx;
338     int equal = 0;
339     char backbuf[1024];
340  
341     memset((void *) &attr, 0, sizeof(attr));
342
343     /*
344      * Validate arguments
345      *
346      * The only required argument to this function is the cellHandle.
347      * If the excludePrefix is set to VOS_EXCLUDE, volumePrefix must
348      * be non-null.
349      */
350
351     if (!IsValidCellHandle(c_handle, &tst)) {
352         goto fail_vos_BackupVolumeCreateMultiple;
353     }
354
355     if ((excludePrefix == VOS_EXCLUDE) &&
356         ((volumePrefix == NULL) || (*volumePrefix == 0))) {
357         tst = ADMVOSEXCLUDEREQUIRESPREFIX;
358         goto fail_vos_BackupVolumeCreateMultiple;
359     }
360
361     if (f_server != NULL) {
362         if (!IsValidServerHandle(f_server, &tst)) {
363             goto fail_vos_BackupVolumeCreateMultiple;
364         }
365         attr.server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
366         attr.Mask |= VLLIST_SERVER;
367     }
368
369     if (partition != NULL) {
370         if (*partition > VOLMAXPARTS) {
371             tst = ADMVOSPARTITIONTOOLARGE;
372             goto fail_vos_BackupVolumeCreateMultiple;
373         }
374         attr.partition = *partition;
375         attr.Mask |= VLLIST_PARTITION;
376     }
377
378     if (excludePrefix == VOS_EXCLUDE) {
379         exclude = 1;
380     }
381
382     if ((volumePrefix != NULL) && (*volumePrefix != 0)) {
383         prefix = 1;
384         prefix_len = strlen(volumePrefix);
385     }
386
387     memset((void *) &arrayEntries, 0, sizeof(arrayEntries));
388
389     /*
390      * Get a list of all the volumes in the cell
391      */
392
393     if (!VLDB_ListAttributes(c_handle, &attr, &nentries, &arrayEntries, &tst)) {
394         goto fail_vos_BackupVolumeCreateMultiple;
395     }
396
397     /*
398      * Cycle through the list of volumes and see if we should create a backup
399      * for each individual volume
400      */
401
402     for(i=0;i<nentries;i++) {
403         entry = &arrayEntries.nbulkentries_val[i];
404
405         /*
406          * Skip entries that don't have a RW volume
407          */
408
409         if (!(entry->flags & RW_EXISTS)) {
410             if (callBack != NULL) {
411                 const char *messageText;
412                 if (util_AdminErrorCodeTranslate(ADMVOSVOLUMENOREADWRITE, 0,
413                                                  &messageText, &tst)) {
414                     sprintf(backbuf, "%s %s", messageText, entry->name);
415                     (**callBack)(VOS_VERBOSE_MESSAGE, backbuf);
416                 }
417             }
418             continue;
419         }
420
421         /*
422          * See if we should skip this entry because of the prefix/exclude
423          * combination we've been passed
424          */
425
426         if (prefix) {
427             if (exclude) {
428                 if (!strncmp(entry->name, volumePrefix, prefix_len)) {
429                     continue;
430                 }
431             } else {
432                 if (strncmp(entry->name, volumePrefix, prefix_len)) {
433                     continue;
434                 }
435             }
436         }
437
438         rw_volid = entry->volumeId[RWVOL];
439         GetServerAndPart(entry, RWVOL, &rw_server, &rw_partition, &previdx);
440
441         if ((rw_server == -1) || (rw_partition == -1)) {
442             if (callBack != NULL) {
443                 const char *messageText;
444                 if (util_AdminErrorCodeTranslate(ADMVOSVLDBBADENTRY, 0,
445                                                  &messageText, &tst)) {
446                     sprintf(backbuf, "%s %s", messageText, entry->name);
447                     (**callBack)(VOS_ERROR_MESSAGE, backbuf);
448                 }
449             }
450             continue;
451         }
452
453         /*
454          * Check that the RW volume is on the same server that we were
455          * passed
456          */
457
458         if (serverHandle != NULL) {
459             if (!VLDB_IsSameAddrs(c_handle,
460                                   ntohl(rx_HostOf(rx_PeerOf(f_server->serv))),
461                                   rw_server, &equal, &tst)) {
462                 if (callBack != NULL) {
463                     const char *messageText;
464                     if (util_AdminErrorCodeTranslate(ADMVOSVLDBBADSERVER, 0,
465                                                      &messageText, &tst)) {
466                         sprintf(backbuf, "%s %x %d", messageText,
467                                 ntohl(rx_HostOf(rx_PeerOf(f_server->serv))),
468                                 tst);
469                         (**callBack)(VOS_ERROR_MESSAGE, backbuf);
470                     }
471                 }
472                 continue;
473             }
474             if (!equal) {
475                 if (callBack != NULL) {
476                     const char *messageText;
477                     if (util_AdminErrorCodeTranslate(ADMVOSVLDBDIFFERENTADDR, 0,
478                                                      &messageText, &tst)) {
479                         sprintf(backbuf, "%s %s", messageText,
480                                 entry->name);
481                         (**callBack)(VOS_ERROR_MESSAGE, backbuf);
482                     }
483                 }
484                 continue;
485             }
486         }
487
488         /*
489          * Check that the RW volume is on the same partition we were
490          * passed
491          */
492
493         if (partition != NULL) {
494             if (*partition != rw_partition) {
495                 continue;
496             }
497         }
498
499         /*
500          * Backup the volume
501          */
502
503         rc = UV_BackupVolume(c_handle, rw_server, rw_partition, rw_volid, &tst);
504     }
505
506 fail_vos_BackupVolumeCreateMultiple:
507
508     if (arrayEntries.nbulkentries_val) {
509         free(arrayEntries.nbulkentries_val);
510     }
511
512     if (st != NULL) {
513         *st = tst;
514     }
515     return rc;
516 }
517
518 /*
519  * vos_PartitionGet - get information about a single partition.
520  *
521  * PARAMETERS
522  *
523  * IN cellHandle - a previously opened cellHandle that corresponds
524  * to the cell where the server lives.
525  *
526  * IN serverHandle - a previously open vos server handle that holds
527  * the partition of interest.
528  *
529  * IN callBack - a call back function pointer that may be called to report
530  * status information.  Can be null.
531  *
532  * IN partition - the integer that represents the partition of interest.
533  *
534  * OUT partitionP - a pointer to a vos_partitionEntry_t that upon successful 
535  * completion contains information regarding the partition.
536  *
537  * LOCKS
538  * 
539  * No locks are obtained or released by this function
540  *
541  * RETURN CODES
542  *
543  * Returns != 0 upon successful completion.
544  */
545
546 int ADMINAPI vos_PartitionGet(
547   const void *cellHandle,
548   const void *serverHandle,
549   vos_MessageCallBack_t callBack,
550   unsigned int partition,
551   vos_partitionEntry_p partitionP,
552   afs_status_p st)
553 {
554     int rc = 0;
555     afs_status_t tst = 0;
556     struct diskPartition part_info;
557     file_server_p f_server = (file_server_p) serverHandle;
558     char partitionName[10]; /* this rpc requires a character partition name */
559
560     /*
561      * Validate arguments
562      */
563
564     if (!IsValidServerHandle(f_server, &tst)) {
565         goto fail_vos_PartitionGet;
566     }
567
568     if (partitionP == NULL) {
569         tst = ADMVOSPARTITIONPNULL;
570         goto fail_vos_PartitionGet;
571     }
572  
573     if (!vos_PartitionIdToName(partition, partitionName, &tst)) {
574         goto fail_vos_PartitionGet;
575     }
576
577     tst = AFSVolPartitionInfo(f_server->serv, partitionName, &part_info);
578     if (tst) {
579         goto fail_vos_PartitionGet;
580     }
581     strcpy(partitionP->name, part_info.name);
582     strcpy(partitionP->deviceName, part_info.devName);
583     partitionP->lockFileDescriptor = part_info.lock_fd;
584     partitionP->totalSpace = part_info.minFree;
585     partitionP->totalFreeSpace = part_info.free;
586     rc = 1;
587
588 fail_vos_PartitionGet:
589
590     if (st != NULL) {
591         *st = tst;
592     }
593     return rc;
594 }
595
596 /*
597  * The iterator functions and data for the partition retrieval functions.
598  */
599
600 typedef struct partition_get {
601     afs_int32 total_received; /* the total number of valid partiions retrieved */
602     int number_processed; /* the number of valid paritions we've handed out */
603     int index; /* the current index into the part_list array */
604     struct partList part_list; /* the list of partitions */
605     vos_partitionEntry_t partition[CACHED_ITEMS]; /* the cache of partitions */
606     const void *server; /* the server where the parititions exist */
607 } partition_get_t, *partition_get_p;
608
609 static int GetPartitionInfoRPC(
610   void *rpc_specific,
611   int slot,
612   int *last_item,
613   int *last_item_contains_data,
614   afs_status_p st)
615 {
616     int rc = 0;
617     afs_status_t tst = 0;
618     partition_get_p part = (partition_get_p) rpc_specific;
619     vos_partitionEntry_p ptr = (vos_partitionEntry_p) &part->partition[slot];
620
621     /*
622      * Skip partition entries that are not valid
623      */
624
625     while (!(part->part_list.partFlags[part->index] & PARTVALID)) {
626         part->index++;
627     }
628
629     /*
630      * Get information for the next partition
631      */
632
633     if (!vos_PartitionGet(0, part->server, 0,
634                           (unsigned int) part->part_list.partId[part->index],
635                           ptr, &tst)) {
636         goto fail_GetPartitionInfoRPC;
637     }
638
639     part->index++;
640     part->number_processed++;
641
642     if (part->number_processed == part->total_received) {
643         *last_item = 1;
644         *last_item_contains_data = 1;
645     }
646     rc = 1;
647
648 fail_GetPartitionInfoRPC:
649
650     if (st != NULL) {
651         *st = tst;
652     }
653     return rc;
654 }
655
656 static int GetPartitionInfoFromCache(
657   void *rpc_specific,
658   int slot,
659   void *dest,
660   afs_status_p st)
661 {
662     int rc = 0;
663     afs_status_t tst = 0;
664     partition_get_p part = (partition_get_p) rpc_specific;
665
666     memcpy(dest, (const void *) &part->partition[slot],
667            sizeof(vos_partitionEntry_t));
668     rc = 1;
669
670     if (st != NULL) {
671         *st = tst;
672     }
673     return rc;
674 }
675
676 /*
677  * vos_PartitionGetBegin - begin to iterate over the partitions at a 
678  * particular server.
679  *
680  * PARAMETERS
681  *
682  * IN cellHandle - a previously opened cellHandle that corresponds
683  * to the cell where the server exists.
684  *
685  * IN serverHandle - the server that houses the partitions of interest.
686  *
687  * IN callBack - a call back function pointer that may be called to report
688  * status information.  Can be null.
689  *
690  * OUT iterationIdP - upon successful completion, contains an iterator that can
691  * be passed to vos_PartitionGetNext.
692  *
693  * LOCKS
694  * 
695  * No locks are obtained or released by this function
696  *
697  * RETURN CODES
698  *
699  * Returns != 0 upon successful completion.
700  */
701
702 int ADMINAPI vos_PartitionGetBegin(
703   const void *cellHandle,
704   const void *serverHandle,
705   vos_MessageCallBack_t callBack,
706   void **iterationIdP,
707   afs_status_p st)
708 {
709     int rc = 0;
710     afs_status_t tst = 0;
711     file_server_p f_server = (file_server_p) serverHandle;
712     afs_admin_iterator_p iter = (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
713     partition_get_p part = (partition_get_p) calloc(1, sizeof(partition_get_t));
714
715     /*
716      * Validate arguments
717      */
718
719     if (!IsValidServerHandle(f_server, &tst)) {
720         goto fail_vos_PartitionGetBegin;
721     }
722
723     if (iterationIdP == NULL) {
724         goto fail_vos_PartitionGetBegin;
725     }
726         
727     if ((iter == NULL) || (part == NULL)) {
728         tst = ADMNOMEM;
729         goto fail_vos_PartitionGetBegin;
730     }
731
732     /*
733      * Fill in the part structure
734      */
735
736     part->server = serverHandle;
737     if (!UV_ListPartitions(f_server->serv, &part->part_list,
738                            &part->total_received, &tst)) {
739         goto fail_vos_PartitionGetBegin;
740     }
741
742     /*
743      * If we didn't receive any partitions, don't spawn a background thread.
744      * Mark the iterator complete.
745      */
746
747     if (part->total_received == 0) {
748         if (!IteratorInit(iter, (void *) part, NULL, NULL, NULL, NULL, &tst)) {
749             goto fail_vos_PartitionGetBegin;
750         }
751         iter->done_iterating = 1;
752         iter->st = ADMITERATORDONE;
753     } else {
754         if (!IteratorInit(iter, (void *) part, GetPartitionInfoRPC,
755                          GetPartitionInfoFromCache, NULL, NULL, &tst)) {
756             goto fail_vos_PartitionGetBegin;
757         }
758     }
759     *iterationIdP = (void *) iter;
760     rc = 1;
761  
762 fail_vos_PartitionGetBegin:
763
764     if (rc == 0) {
765         if (iter != NULL) {
766             free(iter);
767         }
768         if (part != NULL) {
769             free(part);
770         }
771     }
772
773     if (st != NULL) {
774         *st = tst;
775     }
776     return rc;
777 }
778
779 /*
780  * vos_PartitionGetNext - get the next partition at a server.
781  *
782  * PARAMETERS
783  *
784  * IN iterationId - an iterator previously returned by vos_PartitionGetBegin
785  *
786  * OUT partitionP - a pointer to a vos_partitionEntry_t that upon successful
787  * completion contains the next partition.
788  *
789  * LOCKS
790  * 
791  * The iterator is locked while the next parition is retrieved.
792  *
793  * RETURN CODES
794  *
795  * Returns != 0 upon successful completion.
796  */
797
798 int ADMINAPI vos_PartitionGetNext(
799   const void *iterationId,
800   vos_partitionEntry_p partitionP,
801   afs_status_p st)
802 {
803     int rc = 0;
804     afs_status_t tst = 0;
805     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
806
807     if (iter == NULL) {
808         tst = ADMITERATORNULL;
809         goto fail_vos_PartitionGetNext;
810     }
811
812     if (partitionP == NULL) {
813         tst = ADMVOSPARTITIONPNULL;
814         goto fail_vos_PartitionGetNext;
815     }
816
817     rc = IteratorNext(iter, (void *) partitionP, &tst);
818
819 fail_vos_PartitionGetNext:
820
821     if (st != NULL) {
822         *st = tst;
823     }
824     return rc;
825 }
826
827 /*
828  * vos_PartitionGetDone - finish using a partition iterator.
829  *
830  * PARAMETERS
831  *
832  * IN iterationId - an iterator previously returned by vos_PartitionGetBegin
833  *
834  * LOCKS
835  * 
836  * The iterator is locked and then destroyed.
837  *
838  * RETURN CODES
839  *
840  * Returns != 0 upon successful completion.
841  */
842
843 int ADMINAPI vos_PartitionGetDone(
844   const void *iterationId,
845   afs_status_p st)
846 {
847     int rc = 0;
848     afs_status_t tst = 0;
849     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
850  
851     /*
852      * Validate arguments
853      */
854  
855     if (iter == NULL) {
856         tst = ADMITERATORNULL;
857         goto fail_vos_PartitionGetDone;
858     }
859  
860     rc = IteratorDone(iter, &tst);
861
862 fail_vos_PartitionGetDone:
863  
864     if (st != NULL) {
865         *st = tst;
866     }
867     return rc;
868 }
869
870 /*
871  * vos_ServerOpen - open a handle to an individual server for future
872  * operations
873  *
874  * PARAMETERS
875  *
876  * IN cellHandle - a previously opened cellHandle that corresponds
877  * to the cell where the server lives.
878  *
879  * IN serverName - the machine name of the server
880  *
881  * OUT serverHandleP - a void pointer that upon successful completion 
882  * contains a handle that is used in future operations upon the server.
883  *
884  * LOCKS
885  * 
886  * No locks are obtained or released by this function
887  *
888  * RETURN CODES
889  *
890  * Returns != 0 upon successful completion.
891  */
892
893 int ADMINAPI vos_ServerOpen(
894   const void *cellHandle,
895   const char *serverName,
896   void **serverHandleP,
897   afs_status_p st)
898 {
899     int rc = 0;
900     afs_status_t tst = 0;
901     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
902     file_server_p f_server = (file_server_p) malloc(sizeof(file_server_t));
903     int server_address;
904     struct rx_securityClass *sc[3];
905     int scIndex;
906
907     if (f_server == NULL) {
908         tst = ADMNOMEM;
909         goto fail_vos_ServerOpen;
910     }
911
912     /*
913      * Validate arguments
914      */
915
916     if (!IsValidCellHandle(c_handle, &tst)) {
917         goto fail_vos_ServerOpen;
918     }
919
920     if (!c_handle->tokens->afs_token_set) {
921         tst = ADMVOSCELLHANDLENOAFSTOKENS;
922         goto fail_vos_ServerOpen;
923     }
924
925     if (!util_AdminServerAddressGetFromName(serverName, &server_address,
926                                             &tst)) {
927         goto fail_vos_ServerOpen;
928     }
929
930     scIndex = c_handle->tokens->sc_index;
931     sc[scIndex] = c_handle->tokens->afs_sc[scIndex];
932     f_server->serv = rx_GetCachedConnection(htonl(server_address),
933                                         htons(AFSCONF_VOLUMEPORT),
934                                         VOLSERVICE_ID, sc[scIndex], scIndex);
935     if (f_server->serv != NULL) {
936         f_server->begin_magic = BEGIN_MAGIC;
937         f_server->end_magic = END_MAGIC;
938         f_server->is_valid = 1;
939         *serverHandleP = (void *) f_server;
940         rc = 1;
941     } else {
942         tst = ADMVOSSERVERNOCONNECTION;
943         goto fail_vos_ServerOpen;
944     }
945  
946 fail_vos_ServerOpen:
947
948     if (st != NULL) {
949         *st = tst;
950     }
951     return rc;
952 }
953
954 /*
955  * vos_ServerClose - close a handle previously obtained from vos_ServerOpen
956  *
957  * PARAMETERS
958  *
959  * IN serverHandle - an existing server handle.
960  *
961  * LOCKS
962  * 
963  * No locks are obtained or released by this function
964  *
965  * RETURN CODES
966  *
967  * Returns != 0 upon successful completion.
968  */
969
970 int ADMINAPI vos_ServerClose(
971   const void *serverHandle,
972   afs_status_p st)
973 {
974     int rc = 0;
975     afs_status_t tst = 0;
976     file_server_p f_server = (file_server_p) serverHandle;
977  
978     if (!IsValidServerHandle(f_server, &tst)) {
979         goto fail_vos_ServerClose;
980     }
981
982     rx_ReleaseCachedConnection(f_server->serv);
983     f_server->is_valid = 0;
984     free(f_server);
985     rc = 1;
986
987 fail_vos_ServerClose:
988
989     if (st != NULL) {
990         *st = tst;
991     }
992     return rc;
993 }
994
995 /*
996  * vos_ServerSync - synchronize the vldb and the fileserver at a particular
997  * server.
998  *
999  * PARAMETERS
1000  *
1001  * IN cellHandle - a previously opened cellHandle that corresponds
1002  * to the cell where the server lives.
1003  *
1004  * IN serverHandle - a handle to the server machine.
1005  *
1006  * IN callBack - a call back function pointer that may be called to report
1007  * status information.  Can be null.
1008  *
1009  * IN partition - the partition to synchronize.  Can be NULL.
1010  *
1011  * IN force - force deletion of bad volumes.
1012  *
1013  * LOCKS
1014  * 
1015  * No locks are obtained or released by this function
1016  *
1017  * RETURN CODES
1018  *
1019  * Returns != 0 upon successful completion.
1020  */
1021
1022 int ADMINAPI vos_ServerSync(
1023   const void *cellHandle,
1024   const void *serverHandle,
1025   vos_MessageCallBack_t callBack,
1026   const unsigned int *partition,
1027   afs_status_p st)
1028 {
1029     int rc = 0;
1030     afs_status_t tst = 0;
1031     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1032     file_server_p f_server = (file_server_p) serverHandle;
1033     afs_int32 part = 0;
1034     int flags = 0;
1035  
1036     /*
1037      * Validate arguments
1038      */
1039
1040     if (!IsValidCellHandle(c_handle, &tst)) {
1041         goto fail_vos_ServerSync;
1042     }
1043
1044     if (!IsValidServerHandle(f_server, &tst)) {
1045         goto fail_vos_ServerSync;
1046     }
1047
1048     if (partition != NULL) {
1049         if (*partition > VOLMAXPARTS) {
1050             tst = ADMVOSPARTITIONTOOLARGE;
1051             goto fail_vos_ServerSync;
1052         }
1053         part = (afs_int32) *partition;
1054         flags = 1;
1055     }
1056
1057     /*
1058      * sync the server
1059      */
1060
1061     rc = UV_SyncServer(c_handle, f_server->serv, part, flags, &tst);
1062  
1063 fail_vos_ServerSync:
1064
1065     if (st != NULL) {
1066         *st = tst;
1067     }
1068     return rc;
1069 }
1070
1071 /*
1072  * vos_FileServerAddressChange - change an existing file server address.
1073  *
1074  * PARAMETERS
1075  *
1076  * IN cellHandle - a previously opened cellHandle that corresponds
1077  * to the cell where the address should be changed.
1078  *
1079  * IN callBack - a call back function pointer that may be called to report
1080  * status information.  Can be null.
1081  *
1082  * IN oldAddress - the old server address in host byte order
1083  *
1084  * IN newAddress - the new server address in host byte order
1085  *
1086  * LOCKS
1087  * 
1088  * No locks are obtained or released by this function
1089  *
1090  * RETURN CODES
1091  *
1092  * Returns != 0 upon successful completion.
1093  */
1094
1095 int ADMINAPI vos_FileServerAddressChange(
1096   const void *cellHandle,
1097   vos_MessageCallBack_t callBack,
1098   int oldAddress,
1099   int newAddress,
1100   afs_status_p st)
1101 {
1102     int rc = 0;
1103     afs_status_t tst = 0;
1104     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1105  
1106     /*
1107      * Validate arguments
1108      */
1109
1110     if (!IsValidCellHandle(c_handle, &tst)) {
1111         goto fail_vos_FileServerAddressChange;
1112     }
1113
1114     tst = ubik_Call_New(VL_ChangeAddr, c_handle->vos, 0,
1115                         oldAddress, newAddress);
1116     if (tst) {
1117         goto fail_vos_FileServerAddressChange;
1118     }
1119     rc = 1;
1120  
1121 fail_vos_FileServerAddressChange:
1122
1123     if (st != NULL) {
1124         *st = tst;
1125     }
1126     return rc;
1127 }
1128
1129 /*
1130  * vos_FileServerAddressRemove - remove an existing file server address.
1131  *
1132  * PARAMETERS
1133  *
1134  * IN cellHandle - a previously opened cellHandle that corresponds
1135  * to the cell where the address should be removed.
1136  *
1137  * IN callBack - a call back function pointer that may be called to report
1138  * status information.  Can be null.
1139  *
1140  * IN serverAddress - the server address to remove in host byte order.
1141  *
1142  * LOCKS
1143  * 
1144  * No locks are obtained or released by this function
1145  *
1146  * RETURN CODES
1147  *
1148  * Returns != 0 upon successful completion.
1149  */
1150
1151 int ADMINAPI vos_FileServerAddressRemove(
1152   const void *cellHandle,
1153   vos_MessageCallBack_t callBack,
1154   int serverAddress,
1155   afs_status_p st)
1156 {
1157     int rc = 0;
1158     afs_status_t tst = 0;
1159     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1160     int dummyAddress = 0xffffffff;
1161  
1162     /*
1163      * Validate arguments
1164      */
1165
1166     if (!IsValidCellHandle(c_handle, &tst)) {
1167         goto fail_vos_FileServerAddressRemove;
1168     }
1169
1170     tst = ubik_Call_New(VL_ChangeAddr, c_handle->vos, 0,
1171                         dummyAddress, serverAddress);
1172     if (tst) {
1173         goto fail_vos_FileServerAddressRemove;
1174     }
1175     rc = 1;
1176  
1177 fail_vos_FileServerAddressRemove:
1178
1179     if (st != NULL) {
1180         *st = tst;
1181     }
1182     return rc;
1183 }
1184
1185 /*
1186  * The iterator functions and data for the server retrieval functions.
1187  *
1188  * These functions are very similar to the FileServerAddressGet
1189  * functions.  The main difference being that instead of returning
1190  * a single address at a time for a server, we fill an array with
1191  * all the addresses of a server.
1192  */
1193
1194 typedef struct server_get {
1195   struct ubik_client *vldb; /* connection for future rpc's if neccessary */
1196   afs_int32 total_addresses; /* total number of addresses */
1197   bulkaddrs addresses; /* the list of addresses */
1198   int address_index; /* current index into address list */
1199   vos_fileServerEntry_t server[CACHED_ITEMS]; /* the cache of servers */
1200 } server_get_t, *server_get_p;
1201
1202 static int GetServerRPC(
1203   void *rpc_specific,
1204   int slot,
1205   int *last_item,
1206   int *last_item_contains_data,
1207   afs_status_p st)
1208 {
1209     int rc = 0;
1210     afs_status_t tst = 0;
1211     server_get_p serv = (server_get_p) rpc_specific;
1212     afs_uint32 *addrP = &serv->addresses.bulkaddrs_val[serv->address_index];
1213     afs_int32 base, index;
1214     afsUUID m_uuid;
1215     afs_int32 m_unique;
1216     ListAddrByAttributes m_attrs;
1217     afs_int32 total_multi;
1218     bulkaddrs addr_multi;
1219     int i;
1220
1221     /*
1222      * Check to see if this is a multihomed address server
1223      */
1224
1225     if ( ((*addrP & 0xff000000) == 0xff000000) && ((*addrP)&0xffff) ) {
1226         base = (*addrP>>16) & 0xff;
1227         index = (*addrP) & 0xffff;
1228
1229         if ((base >= 0) && (base <= VL_MAX_ADDREXTBLKS) &&
1230             (index >= 1) && (index <= VL_MHSRV_PERBLK)) {
1231
1232             /*
1233              * This is a multihomed server.  Make an rpc to retrieve
1234              * all its addresses.  Copy the addresses into the cache.
1235              */
1236
1237             m_attrs.Mask  = VLADDR_INDEX;
1238             m_attrs.index = (base * VL_MHSRV_PERBLK) + index;
1239             total_multi = 0;
1240             addr_multi.bulkaddrs_val = 0;
1241             addr_multi.bulkaddrs_len = 0;
1242             tst = ubik_Call(VL_GetAddrsU, serv->vldb, 0, &m_attrs, &m_uuid,
1243                             &m_unique,
1244                             &total_multi,
1245                             &addr_multi);
1246             if (tst) {
1247                 goto fail_GetServerRPC;
1248             }
1249
1250             /*
1251              * Remove any bogus IP addresses which the user may have
1252              * been unable to remove.
1253              */
1254
1255             RemoveBadAddresses (&total_multi, &addr_multi);
1256
1257             /*
1258              * Copy all the addresses into the cache
1259              */
1260
1261             for(i=0;i<total_multi;i++) {
1262                 serv->server[slot].serverAddress[i] = 
1263                     addr_multi.bulkaddrs_val[i];
1264             }
1265
1266             serv->server[slot].count = total_multi;
1267             serv->address_index++;
1268             free(addr_multi.bulkaddrs_val);
1269         }
1270
1271     /*
1272      * The next address is just a plain old address
1273      */
1274
1275     } else {
1276         serv->server[slot].serverAddress[0] = *addrP;
1277         serv->server[slot].count = 1;
1278         serv->address_index++;
1279     }
1280
1281     /*
1282      * See if we've processed all the entries
1283      */
1284
1285
1286     if (serv->address_index == serv->total_addresses) {
1287         *last_item = 1;
1288         *last_item_contains_data = 1;
1289     }
1290     rc = 1;
1291
1292 fail_GetServerRPC:
1293
1294     if (st != NULL) {
1295         *st = tst;
1296     }
1297     return rc;
1298 }
1299
1300 static int GetServerFromCache(
1301   void *rpc_specific,
1302   int slot,
1303   void *dest,
1304   afs_status_p st)
1305 {
1306     int rc = 0;
1307     afs_status_t tst = 0;
1308     server_get_p serv = (server_get_p) rpc_specific;
1309
1310     memcpy(dest, (const void *) &serv->server[slot],
1311            sizeof(vos_fileServerEntry_t));
1312     rc = 1;
1313
1314     if (st != NULL) {
1315         *st = tst;
1316     }
1317     return rc;
1318 }
1319
1320
1321 static int DestroyServer(
1322   void *rpc_specific,
1323   afs_status_p st)
1324 {
1325     int rc = 0;
1326     afs_status_t tst = 0;
1327     server_get_p serv = (server_get_p) rpc_specific;
1328
1329     if (serv->addresses.bulkaddrs_val != NULL) {
1330         free(serv->addresses.bulkaddrs_val);
1331     }
1332     rc = 1;
1333
1334     if (st != NULL) {
1335         *st = tst;
1336     }
1337     return rc;
1338 }
1339
1340 /*
1341  * vos_FileServerGetBegin - begin to iterate over the file servers in a cell.
1342  *
1343  * PARAMETERS
1344  *
1345  * IN cellHandle - a previously opened cellHandle that corresponds
1346  * to the cell where the file servers exist.
1347  *
1348  * IN callBack - a call back function pointer that may be called to report
1349  * status information.  Can be null.
1350  *
1351  * OUT iterationIdP - upon successful completion, contains an iterator that
1352  * can be passed to vos_FileServerGetNext.
1353  *
1354  * LOCKS
1355  * 
1356  * No locks are obtained or released by this function
1357  *
1358  * RETURN CODES
1359  *
1360  * Returns != 0 upon successful completion.
1361  */
1362
1363 int ADMINAPI vos_FileServerGetBegin(
1364   const void *cellHandle,
1365   vos_MessageCallBack_t callBack,
1366   void **iterationIdP,
1367   afs_status_p st)
1368 {
1369     int rc = 0;
1370     afs_status_t tst = 0;
1371     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1372     afs_admin_iterator_p iter = (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
1373     server_get_p serv = (server_get_p) calloc(1, sizeof(server_get_t));
1374     struct VLCallBack unused;
1375  
1376
1377     /*
1378      * Validate arguments
1379      */
1380
1381     if (!IsValidCellHandle(c_handle, &tst)) {
1382         goto fail_vos_FileServerGetBegin;
1383     }
1384
1385     if (iterationIdP == NULL) {
1386         goto fail_vos_FileServerGetBegin;
1387     }
1388         
1389     if ((iter == NULL) || (serv == NULL)) {
1390         tst = ADMNOMEM;
1391         goto fail_vos_FileServerGetBegin;
1392     }
1393
1394     /*
1395      * Fill in the serv structure
1396      */
1397
1398     serv->vldb = c_handle->vos;
1399     tst = ubik_Call_New(VL_GetAddrs, c_handle->vos, 0, 0, 0, &unused, 
1400                         &serv->total_addresses, &serv->addresses);
1401
1402     if (tst) {
1403         goto fail_vos_FileServerGetBegin;
1404     }
1405
1406     /*
1407      * Remove any bogus IP addresses which the user may have
1408      * been unable to remove.
1409      */
1410
1411     RemoveBadAddresses (&serv->total_addresses, &serv->addresses);
1412
1413     if (serv->total_addresses == 0) {
1414         if (!IteratorInit(iter, (void *) serv, NULL, NULL, NULL, NULL, &tst)) {
1415             goto fail_vos_FileServerGetBegin;
1416         }
1417         iter->done_iterating = 1;
1418         iter->st = ADMITERATORDONE;
1419     } else {
1420         if (!IteratorInit(iter, (void *) serv, GetServerRPC,
1421                          GetServerFromCache, NULL, DestroyServer, &tst)) {
1422             goto fail_vos_FileServerGetBegin;
1423         }
1424     }
1425     *iterationIdP = (void *) iter;
1426     rc = 1;
1427
1428 fail_vos_FileServerGetBegin:
1429
1430     if (rc == 0) {
1431         if (iter != NULL) {
1432             free(iter);
1433         }
1434         if (serv != NULL) {
1435             if (serv->addresses.bulkaddrs_val != NULL) {
1436                 free(serv->addresses.bulkaddrs_val);
1437             }
1438             free(serv);
1439         }
1440     }
1441
1442     if (st != NULL) {
1443         *st = tst;
1444     }
1445     return rc;
1446 }
1447
1448 /*
1449  * vos_FileServerGetNext - get information about the next fileserver in the cell.
1450  *
1451  * PARAMETERS
1452  *
1453  * IN iterationId - an iterator previously returned by
1454  * vos_FileServerGetBegin
1455  *
1456  * OUT serverEntryP - a pointer to a vos_fileServerEntry_t that upon successful
1457  * completion contains information about the next server in the cell.
1458  *
1459  * LOCKS
1460  * 
1461  * The iterator is locked while the next server is retrieved.
1462  *
1463  * RETURN CODES
1464  *
1465  * Returns != 0 upon successful completion.
1466  */
1467
1468 int ADMINAPI vos_FileServerGetNext(
1469   void *iterationId,
1470   vos_fileServerEntry_p serverEntryP,
1471   afs_status_p st)
1472 {
1473     int rc = 0;
1474     afs_status_t tst = 0;
1475     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1476
1477     if (iter == NULL) {
1478         tst = ADMITERATORNULL;
1479         goto fail_vos_FileServerGetNext;
1480     }
1481
1482     if (serverEntryP == NULL) {
1483         tst = ADMVOSSERVERENTRYPNULL;
1484         goto fail_vos_FileServerGetNext;
1485     }
1486
1487     rc = IteratorNext(iter, (void *) serverEntryP, &tst);
1488  
1489 fail_vos_FileServerGetNext:
1490
1491     if (st != NULL) {
1492         *st = tst;
1493     }
1494     return rc;
1495 }
1496
1497 /*
1498  * vos_FileServerGetDone - finish using a partition iterator.
1499  *
1500  * PARAMETERS
1501  *
1502  * IN iterationId - an iterator previously returned by vos_FileServerGetBegin
1503  *
1504  * LOCKS
1505  * 
1506  * The iterator is locked and then destroyed.
1507  *
1508  * RETURN CODES
1509  *
1510  * Returns != 0 upon successful completion.
1511  */
1512
1513 int ADMINAPI vos_FileServerGetDone(
1514   void *iterationId,
1515   afs_status_p st)
1516 {
1517     int rc = 0;
1518     afs_status_t tst = 0;
1519     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1520  
1521     /*
1522      * Validate arguments
1523      */
1524  
1525     if (iter == NULL) {
1526         tst = ADMITERATORNULL;
1527         goto fail_vos_FileServerGetDone;
1528     }
1529  
1530     rc = IteratorDone(iter, &tst);
1531  
1532 fail_vos_FileServerGetDone:
1533
1534     if (st != NULL) {
1535         *st = tst;
1536     }
1537     return rc;
1538 }
1539
1540 /*
1541  * The iterator functions and data for the transation retrieval functions.
1542  */
1543
1544 typedef struct transaction_get {
1545   afs_int32 total; /* total number of transactions */
1546   afs_int32 index; /* index to the current transaction */
1547   transDebugInfo *cur; /* the current transaction */
1548   vos_serverTransactionStatus_t tran[CACHED_ITEMS]; /* the cache of trans */
1549 } transaction_get_t, *transaction_get_p;
1550
1551 static int GetTransactionRPC(
1552   void *rpc_specific,
1553   int slot,
1554   int *last_item,
1555   int *last_item_contains_data,
1556   afs_status_p st)
1557 {
1558     int rc = 0;
1559     afs_status_t tst = 0;
1560     transaction_get_p t = (transaction_get_p) rpc_specific;
1561     int index = t->index;
1562
1563     /*
1564      * Copy the next transaction into the cache
1565      */
1566
1567     t->tran[slot].transactionId = t->cur[index].tid;
1568     t->tran[slot].lastActiveTime = t->cur[index].time;
1569     t->tran[slot].creationTime = t->cur[index].creationTime;
1570     t->tran[slot].errorCode = t->cur[index].returnCode;
1571     t->tran[slot].volumeId = t->cur[index].volid;
1572     t->tran[slot].partition = t->cur[index].partition;
1573     strcpy(t->tran[slot].lastProcedureName, t->cur[index].lastProcName);
1574     t->tran[slot].nextReceivePacketSequenceNumber = t->cur[index].readNext;
1575     t->tran[slot].nextSendPacketSequenceNumber = t->cur[index].transmitNext;
1576     t->tran[slot].lastReceiveTime = t->cur[index].lastReceiveTime;
1577     t->tran[slot].lastSendTime = t->cur[index].lastSendTime;
1578
1579     t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_OK;
1580
1581     switch(t->cur[index].iflags){
1582       case ITOffline: 
1583         t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_OFFLINE;
1584         break;
1585       case ITBusy:
1586         t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_BUSY;
1587         break;
1588       case ITReadOnly:
1589         t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_READONLY;
1590         break;
1591       case ITCreate:
1592         t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_CREATE;
1593         break;
1594       case ITCreateVolID:
1595         t->tran[slot].volumeAttachMode = VOS_VOLUME_ATTACH_MODE_CREATE_VOLID;
1596         break;
1597     }
1598
1599     t->tran[slot].volumeActiveStatus = VOS_VOLUME_ACTIVE_STATUS_OK;
1600
1601     switch(t->cur[index].vflags){
1602       case VTDeleteOnSalvage: 
1603         t->tran[slot].volumeActiveStatus = 
1604             VOS_VOLUME_ACTIVE_STATUS_DELETE_ON_SALVAGE;
1605         break;
1606       case VTOutOfService: 
1607         t->tran[slot].volumeActiveStatus = 
1608             VOS_VOLUME_ACTIVE_STATUS_OUT_OF_SERVICE;
1609         break;
1610       case VTDeleted: 
1611         t->tran[slot].volumeActiveStatus = 
1612             VOS_VOLUME_ACTIVE_STATUS_DELETED;
1613         break;
1614     }
1615
1616     t->tran[slot].volumeTransactionStatus = VOS_VOLUME_TRANSACTION_STATUS_OK;
1617
1618     if (t->cur[index].tflags) {
1619         t->tran[slot].volumeTransactionStatus =
1620             VOS_VOLUME_TRANSACTION_STATUS_DELETED;
1621     }
1622     t->index++;
1623
1624
1625     /*
1626      * See if we've processed all the entries
1627      */
1628
1629
1630     if (t->index == t->total) {
1631         *last_item = 1;
1632         *last_item_contains_data = 1;
1633     }
1634     rc = 1;
1635
1636     if (st != NULL) {
1637         *st = tst;
1638     }
1639     return rc;
1640 }
1641
1642 static int GetTransactionFromCache(
1643   void *rpc_specific,
1644   int slot,
1645   void *dest,
1646   afs_status_p st)
1647 {
1648     int rc = 0;
1649     afs_status_t tst = 0;
1650     transaction_get_p tran = (transaction_get_p) rpc_specific;
1651
1652     memcpy(dest, (const void *) &tran->tran[slot],
1653            sizeof(vos_serverTransactionStatus_p));
1654     rc = 1;
1655
1656     if (st != NULL) {
1657         *st = tst;
1658     }
1659     return rc;
1660 }
1661
1662
1663 static int DestroyTransaction(
1664   void *rpc_specific,
1665   afs_status_p st)
1666 {
1667     int rc = 0;
1668     afs_status_t tst = 0;
1669     transaction_get_p tran = (transaction_get_p) rpc_specific;
1670
1671     if (tran->cur != NULL) {
1672         free(tran->cur);
1673     }
1674     rc = 1;
1675
1676     if (st != NULL) {
1677         *st = tst;
1678     }
1679     return rc;
1680 }
1681
1682 /*
1683  * vos_ServerTransactionStatusGetBegin - begin to iterate over the transactions
1684  * at a volume server.
1685  *
1686  * PARAMETERS
1687  *
1688  * IN cellHandle - a previously opened cellHandle that corresponds
1689  * to the cell where the volume server exists.
1690  *
1691  * IN serverHandle - a handle to the server to query.
1692  *
1693  * IN callBack - a call back function pointer that may be called to report
1694  * status information.  Can be null.
1695  *
1696  * OUT iterationIdP - upon successful completion, contains an iterator that
1697  * can be passed to vos_ServerTransactionStatusGetNext.
1698  *
1699  * LOCKS
1700  * 
1701  * No locks are obtained or released by this function
1702  *
1703  * RETURN CODES
1704  *
1705  * Returns != 0 upon successful completion.
1706  */
1707
1708 int ADMINAPI vos_ServerTransactionStatusGetBegin(
1709   const void *cellHandle,
1710   const void *serverHandle,
1711   vos_MessageCallBack_t callBack,
1712   void **iterationIdP,
1713   afs_status_p st)
1714 {
1715     int rc = 0;
1716     afs_status_t tst = 0;
1717     file_server_p f_server = (file_server_p) serverHandle;
1718     afs_admin_iterator_p iter = (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
1719     transaction_get_p tran = (transaction_get_p) calloc(1, sizeof(transaction_get_t));
1720  
1721
1722     /*
1723      * Validate arguments
1724      */
1725
1726     if (!IsValidServerHandle(f_server, &tst)) {
1727         goto fail_vos_ServerTransactionStatusGetBegin;
1728     }
1729
1730     if (iterationIdP == NULL) {
1731         goto fail_vos_ServerTransactionStatusGetBegin;
1732     }
1733         
1734     if ((iter == NULL) || (tran == NULL)) {
1735         tst = ADMNOMEM;
1736         goto fail_vos_ServerTransactionStatusGetBegin;
1737     }
1738
1739     /*
1740      * Fill in the tran structure
1741      */
1742
1743     if (!UV_VolserStatus(f_server->serv, &tran->cur, &tran->total, &tst)) {
1744         goto fail_vos_ServerTransactionStatusGetBegin;
1745     }
1746
1747     if (tran->total == 0) {
1748         if (!IteratorInit(iter, (void *) tran, NULL,
1749                          NULL, NULL, NULL, &tst)) {
1750             goto fail_vos_ServerTransactionStatusGetBegin;
1751         }
1752         iter->done_iterating = 1;
1753         iter->st = ADMITERATORDONE;
1754     } else {
1755         if (!IteratorInit(iter, (void *) tran, GetTransactionRPC,
1756                          GetTransactionFromCache, NULL,
1757                          DestroyTransaction, &tst)) {
1758             goto fail_vos_ServerTransactionStatusGetBegin;
1759         }
1760     }
1761     *iterationIdP = (void *) iter;
1762     rc = 1;
1763
1764 fail_vos_ServerTransactionStatusGetBegin:
1765
1766     if (rc == 0) {
1767         if (iter != NULL) {
1768             free(iter);
1769         }
1770         if (tran != NULL) {
1771             if (tran->cur != NULL) {
1772                 free(tran->cur);
1773             }
1774             free(tran);
1775         }
1776     }
1777
1778     if (st != NULL) {
1779         *st = tst;
1780     }
1781     return rc;
1782 }
1783
1784 /*
1785  * vos_ServerTransactionStatusGetNext - get information about the next 
1786  * active transaction.
1787  *
1788  * PARAMETERS
1789  *
1790  * IN iterationId - an iterator previously returned by
1791  * vos_ServerTransactionStatusGetBegin
1792  *
1793  * OUT serverTransactionStatusP - a pointer to a vos_serverTransactionStatus_p
1794  * that upon successful completion contains information about the
1795  * next transaction.
1796  *
1797  * LOCKS
1798  * 
1799  * The iterator is locked while the next item is retrieved.
1800  *
1801  * RETURN CODES
1802  *
1803  * Returns != 0 upon successful completion.
1804  */
1805
1806 int ADMINAPI vos_ServerTransactionStatusGetNext(
1807   const void *iterationId,
1808   vos_serverTransactionStatus_p serverTransactionStatusP,
1809   afs_status_p st)
1810 {
1811     int rc = 0;
1812     afs_status_t tst = 0;
1813     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1814
1815     if (iter == NULL) {
1816         tst = ADMITERATORNULL;
1817         goto fail_vos_ServerTransactionStatusGetNext;
1818     }
1819
1820     if (serverTransactionStatusP == NULL) {
1821         tst = ADMVOSSERVERTRANSACTIONSTATUSPNULL;
1822         goto fail_vos_ServerTransactionStatusGetNext;
1823     }
1824
1825     rc = IteratorNext(iter, (void *) serverTransactionStatusP, &tst);
1826  
1827 fail_vos_ServerTransactionStatusGetNext:
1828
1829     if (st != NULL) {
1830         *st = tst;
1831     }
1832     return rc;
1833 }
1834
1835 /*
1836  * vos_ServerTransactionStatusGetDone - finish using a transaction iterator.
1837  *
1838  * PARAMETERS
1839  *
1840  * IN iterationId - an iterator previously returned by
1841  * vos_ServerTransactionStatusGetBegin
1842  *
1843  * LOCKS
1844  * 
1845  * The iterator is locked and then destroyed.
1846  *
1847  * RETURN CODES
1848  *
1849  * Returns != 0 upon successful completion.
1850  */
1851
1852 int ADMINAPI vos_ServerTransactionStatusGetDone(
1853   const void *iterationId,
1854   afs_status_p st)
1855 {
1856     int rc = 0;
1857     afs_status_t tst = 0;
1858     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1859  
1860     /*
1861      * Validate arguments
1862      */
1863  
1864     if (iter == NULL) {
1865         tst = ADMITERATORNULL;
1866         goto fail_vos_ServerTransactionStatusGetDone;
1867     }
1868  
1869     rc = IteratorDone(iter, &tst);
1870  
1871 fail_vos_ServerTransactionStatusGetDone:
1872
1873     if (st != NULL) {
1874         *st = tst;
1875     }
1876     return rc;
1877 }
1878
1879 static int copyVLDBEntry(
1880     struct nvldbentry *source,
1881     vos_vldbEntry_p dest,
1882     afs_status_p st)
1883 {
1884     int rc = 0;
1885     afs_status_t tst = 0;
1886     int i;
1887
1888     dest->numServers = source->nServers;
1889     for (i=0;i<VOS_MAX_VOLUME_TYPES;i++) {
1890         dest->volumeId[i] = source->volumeId[i];
1891     }
1892     dest->cloneId = source->cloneId;
1893     dest->status = VOS_VLDB_ENTRY_OK;
1894     if (source->flags & VLOP_ALLOPERS) {
1895         dest->status |= VOS_VLDB_ENTRY_LOCKED;
1896     }
1897     else {
1898         if (source->flags & VLOP_MOVE) {
1899             dest->status |= VOS_VLDB_ENTRY_MOVE;
1900         }
1901         if (source->flags & VLOP_RELEASE) {
1902             dest->status |= VOS_VLDB_ENTRY_RELEASE;
1903         }
1904         if (source->flags & VLOP_BACKUP) {
1905             dest->status |= VOS_VLDB_ENTRY_BACKUP;
1906         }
1907         if (source->flags & VLOP_DELETE) {
1908             dest->status |= VOS_VLDB_ENTRY_DELETE;
1909         }
1910         if (source->flags & VLOP_DUMP) {
1911             dest->status |= VOS_VLDB_ENTRY_DUMP;
1912         }
1913     }
1914     if (source->flags & VLF_RWEXISTS) {
1915         dest->status |= VOS_VLDB_ENTRY_RWEXISTS;
1916     }
1917     if (source->flags & VLF_ROEXISTS) {
1918         dest->status |= VOS_VLDB_ENTRY_ROEXISTS;
1919     }
1920     if (source->flags & VLF_BACKEXISTS) {
1921         dest->status |= VOS_VLDB_ENTRY_BACKEXISTS;
1922     }
1923
1924     strcpy(dest->name, source->name);
1925     for (i=0;i<VOS_MAX_REPLICA_SITES;i++) {
1926         dest->volumeSites[i].serverAddress = source->serverNumber[i];
1927         dest->volumeSites[i].serverPartition = source->serverPartition[i];
1928         dest->volumeSites[i].serverFlags = 0;
1929
1930         if (source->serverFlags[i] & NEW_REPSITE) {
1931             dest->volumeSites[i].serverFlags |= VOS_VLDB_NEW_REPSITE;
1932         }
1933         if (source->serverFlags[i] & ITSROVOL) {
1934             dest->volumeSites[i].serverFlags |= VOS_VLDB_READ_ONLY;
1935         }
1936         if (source->serverFlags[i] & ITSRWVOL) {
1937             dest->volumeSites[i].serverFlags |= VOS_VLDB_READ_WRITE;
1938         }
1939         if (source->serverFlags[i] & ITSBACKVOL) {
1940             dest->volumeSites[i].serverFlags |= VOS_VLDB_BACKUP;
1941         }
1942         if (source->serverFlags[i] & RO_DONTUSE) {
1943             dest->volumeSites[i].serverFlags |= VOS_VLDB_DONT_USE;
1944         }
1945         
1946     }
1947
1948     rc = 1;
1949     if (st != NULL) {
1950         *st = tst;
1951     }
1952     return rc;
1953 }
1954
1955 /*
1956  * vos_VLDBGet- get a volume's vldb entry.
1957  *
1958  * PARAMETERS
1959  *
1960  * IN cellHandle - a previously opened cellHandle that corresponds
1961  * to the cell where the volume entries exist.
1962  *
1963  * IN callBack - a call back function pointer that may be called to report
1964  * status information.  Can be null.
1965  *
1966  * IN volumeId - the id of the volume to retrieve.
1967  *
1968  * IN volumeName - the name of the volume to retrieve.
1969  *
1970  * OUT vldbEntry - upon successful completion, contains the information regarding
1971  * the volume.
1972  *
1973  * LOCKS
1974  * 
1975  * No locks are obtained or released by this function
1976  *
1977  * RETURN CODES
1978  *
1979  * Returns != 0 upon successful completion.
1980  */
1981
1982 int ADMINAPI vos_VLDBGet(
1983   const void *cellHandle,
1984   vos_MessageCallBack_t callBack,
1985   const unsigned int *volumeId,
1986   const char *volumeName,
1987   vos_vldbEntry_p vldbEntry,
1988   afs_status_p st)
1989 {
1990     int rc = 0;
1991     afs_status_t tst = 0;
1992     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1993     struct nvldbentry entry;
1994  
1995
1996     /*
1997      * Validate arguments
1998      */
1999
2000     if (!IsValidCellHandle(c_handle, &tst)) {
2001         goto fail_vos_VLDBGet;
2002     }
2003
2004     if (vldbEntry == NULL) {
2005         tst = ADMVOSVLDBENTRYNULL;
2006         goto fail_vos_VLDBGet;
2007     }
2008
2009     if (((volumeName == NULL) || (*volumeName == 0)) &&
2010         (volumeId == NULL)) {
2011         tst = ADMVOSVOLUMENAMEANDVOLUMEIDNULL;
2012         goto fail_vos_VLDBGet;
2013     }
2014
2015     /*
2016      * Retrieve the entry
2017      */
2018
2019     if (!((volumeName == NULL) || (*volumeName == 0))) {
2020         if (!ValidateVolumeName(volumeName, &tst)) {
2021             goto fail_vos_VLDBGet;
2022         }
2023         if (!VLDB_GetEntryByName(c_handle, volumeName, &entry, &tst)) {
2024             goto fail_vos_VLDBGet;
2025         }
2026     } else {
2027         if (!VLDB_GetEntryByID(c_handle, *volumeId, -1, &entry, &tst)) {
2028             goto fail_vos_VLDBGet;
2029         }
2030     }
2031
2032     /*
2033      * Copy the entry into our structure
2034      */
2035
2036     if (!copyVLDBEntry(&entry, vldbEntry, &tst)) {
2037         goto fail_vos_VLDBGet;
2038     }
2039     rc = 1;
2040  
2041 fail_vos_VLDBGet:
2042
2043     if (st != NULL) {
2044         *st = tst;
2045     }
2046     return rc;
2047 }
2048
2049 /*
2050  * The iterator functions and data for the vldb entry retrieval functions.
2051  */
2052
2053 typedef struct vldb_entry_get {
2054   afs_int32 total; /* total number of vldb entries */
2055   afs_int32 index; /* index to the current vldb entry */
2056   nbulkentries entries; /* the list of entries retrieved */
2057   vos_vldbEntry_t entry[CACHED_ITEMS]; /* the cache of entries */
2058 } vldb_entry_get_t, *vldb_entry_get_p;
2059
2060 static int GetVLDBEntryRPC(
2061   void *rpc_specific,
2062   int slot,
2063   int *last_item,
2064   int *last_item_contains_data,
2065   afs_status_p st)
2066 {
2067     int rc = 0;
2068     afs_status_t tst = 0;
2069     vldb_entry_get_p entry = (vldb_entry_get_p) rpc_specific;
2070
2071     /*
2072      * Copy the next entry into the cache
2073      */
2074
2075     if (!copyVLDBEntry(&entry->entries.nbulkentries_val[entry->index],
2076                        &entry->entry[slot],
2077                        &tst)) {
2078         goto fail_GetVLDBEntryRPC;
2079     }
2080     entry->index++;
2081
2082     /*
2083      * See if we've processed all the entries
2084      */
2085
2086
2087     if (entry->index == entry->total) {
2088         *last_item = 1;
2089         *last_item_contains_data = 1;
2090     }
2091     rc = 1;
2092
2093 fail_GetVLDBEntryRPC:
2094
2095     if (st != NULL) {
2096         *st = tst;
2097     }
2098     return rc;
2099 }
2100
2101 static int GetVLDBEntryFromCache(
2102   void *rpc_specific,
2103   int slot,
2104   void *dest,
2105   afs_status_p st)
2106 {
2107     int rc = 0;
2108     afs_status_t tst = 0;
2109     vldb_entry_get_p entry = (vldb_entry_get_p) rpc_specific;
2110
2111     memcpy(dest, (const void *) &entry->entry[slot],
2112            sizeof(vos_vldbEntry_t));
2113     rc = 1;
2114
2115     if (st != NULL) {
2116         *st = tst;
2117     }
2118     return rc;
2119 }
2120
2121
2122 static int DestroyVLDBEntry(
2123   void *rpc_specific,
2124   afs_status_p st)
2125 {
2126     int rc = 0;
2127     afs_status_t tst = 0;
2128     vldb_entry_get_p entry = (vldb_entry_get_p) rpc_specific;
2129
2130     if (entry->entries.nbulkentries_val != NULL) {
2131         free(entry->entries.nbulkentries_val);
2132     }
2133     rc = 1;
2134
2135     if (st != NULL) {
2136         *st = tst;
2137     }
2138     return rc;
2139 }
2140
2141
2142 /*
2143  * vos_VLDBGetBegin - begin to iterate over the VLDB.
2144  *
2145  * PARAMETERS
2146  *
2147  * IN cellHandle - a previously opened cellHandle that corresponds
2148  * to the cell where the volume entries exist.
2149  *
2150  * IN serverHandle - a handle to the server whose entries should be listed.
2151  * Can be null.
2152  *
2153  * IN callBack - a call back function pointer that may be called to report
2154  * status information.  Can be null.
2155  *
2156  * IN partition - the partition whose entries should be listed.
2157  * Can be null.
2158  *
2159  * OUT iterationIdP - upon successful completion, contains an iterator that
2160  * can be passed to vos_VLDBGetNext.
2161  *
2162  * LOCKS
2163  * 
2164  * No locks are obtained or released by this function
2165  *
2166  * RETURN CODES
2167  *
2168  * Returns != 0 upon successful completion.
2169  */
2170
2171 int ADMINAPI vos_VLDBGetBegin(
2172   const void *cellHandle,
2173   const void *serverHandle,
2174   vos_MessageCallBack_t callBack,
2175   unsigned int *partition,
2176   void **iterationIdP,
2177   afs_status_p st)
2178 {
2179     int rc = 0;
2180     afs_status_t tst = 0;
2181     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2182     file_server_p f_server = (file_server_p) serverHandle;
2183     afs_admin_iterator_p iter = (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
2184     vldb_entry_get_p entry = (vldb_entry_get_p) calloc(1, sizeof(vldb_entry_get_t));
2185     struct VldbListByAttributes attr;
2186
2187     attr.Mask = 0;
2188     memset(&attr, 0, sizeof(attr));
2189
2190     /*
2191      * Validate arguments
2192      */
2193
2194     if (!IsValidCellHandle(c_handle, &tst)) {
2195         goto fail_vos_VLDBGetBegin;
2196     }
2197
2198     if ((iter == NULL) || (entry == NULL)) {
2199         tst = ADMNOMEM;
2200         goto fail_vos_VLDBGetBegin;
2201     }
2202
2203     if (f_server != NULL) {
2204         if (!IsValidServerHandle(f_server, &tst)) {
2205             goto fail_vos_VLDBGetBegin;
2206         }
2207         attr.server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
2208         attr.Mask |= VLLIST_SERVER;
2209     }
2210
2211     if (partition != NULL) {
2212         if (*partition > VOLMAXPARTS) {
2213             tst = ADMVOSPARTITIONTOOLARGE;
2214             goto fail_vos_VLDBGetBegin;
2215         }
2216         attr.partition = *partition;
2217         attr.Mask |= VLLIST_PARTITION;
2218     }
2219
2220     if (!VLDB_ListAttributes(c_handle, &attr, &entry->total, &entry->entries, &tst)) {
2221         goto fail_vos_VLDBGetBegin;
2222     }
2223
2224     if (entry->total <= 0) {
2225         if (!IteratorInit(iter, (void *) entry, NULL,
2226                           NULL, NULL, NULL, &tst)) {
2227             goto fail_vos_VLDBGetBegin;
2228         }
2229         iter->done_iterating = 1;
2230         iter->st = ADMITERATORDONE;
2231     } else {
2232         if (!IteratorInit(iter, (void *) entry, GetVLDBEntryRPC,
2233                           GetVLDBEntryFromCache, NULL,
2234                           DestroyVLDBEntry, &tst)) {
2235             goto fail_vos_VLDBGetBegin;
2236         }
2237     }
2238     *iterationIdP = (void *) iter;
2239     rc = 1;
2240  
2241 fail_vos_VLDBGetBegin:
2242
2243     if (rc == 0) {
2244         if (iter != NULL) {
2245             free(iter);
2246         }
2247         if (entry->entries.nbulkentries_val != NULL) {
2248             free(entry->entries.nbulkentries_val);
2249         }
2250         if (entry != NULL) {
2251             free(entry);
2252         }
2253     }
2254
2255     if (st != NULL) {
2256         *st = tst;
2257     }
2258     return rc;
2259 }
2260
2261 /*
2262  * vos_VLDBGetNext - get information about the next volume.
2263  *
2264  * PARAMETERS
2265  *
2266  * IN iterationId - an iterator previously returned by
2267  * vos_VLDBGetBegin
2268  *
2269  * OUT vldbEntry - a pointer to a vos_vldbEntry_t
2270  * that upon successful completion contains information about the
2271  * next volume.
2272  *
2273  * LOCKS
2274  * 
2275  * The iterator is locked while the next item is retrieved.
2276  *
2277  * RETURN CODES
2278  *
2279  * Returns != 0 upon successful completion.
2280  */
2281
2282 int ADMINAPI vos_VLDBGetNext(
2283   const void *iterationId,
2284   vos_vldbEntry_p vldbEntry,
2285   afs_status_p st)
2286 {
2287     int rc = 0;
2288     afs_status_t tst = 0;
2289     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2290
2291     if (iter == NULL) {
2292         tst = ADMITERATORNULL;
2293         goto fail_vos_VLDBGetNext;
2294     }
2295
2296     if (vldbEntry == NULL) {
2297         tst = ADMVOSVLDBENTRYNULL;
2298         goto fail_vos_VLDBGetNext;
2299     }
2300
2301     rc = IteratorNext(iter, (void *) vldbEntry, &tst);
2302  
2303 fail_vos_VLDBGetNext:
2304
2305     if (st != NULL) {
2306         *st = tst;
2307     }
2308     return rc;
2309 }
2310
2311 /*
2312  * vos_VLDBGetDone - finish using a volume iterator.
2313  *
2314  * PARAMETERS
2315  *
2316  * IN iterationId - an iterator previously returned by vos_VLDBGetBegin
2317  *
2318  * LOCKS
2319  * 
2320  * The iterator is locked and then destroyed.
2321  *
2322  * RETURN CODES
2323  *
2324  * Returns != 0 upon successful completion.
2325  */
2326
2327 int ADMINAPI vos_VLDBGetDone(
2328   const void *iterationId,
2329   afs_status_p st)
2330 {
2331     int rc = 0;
2332     afs_status_t tst = 0;
2333     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2334  
2335     /*
2336      * Validate arguments
2337      */
2338  
2339     if (iter == NULL) {
2340         tst = ADMITERATORNULL;
2341         goto fail_vos_VLDBGetDone;
2342     }
2343  
2344     rc = IteratorDone(iter, &tst);
2345  
2346 fail_vos_VLDBGetDone:
2347
2348     if (st != NULL) {
2349         *st = tst;
2350     }
2351     return rc;
2352 }
2353
2354 /*
2355  * vos_VLDBEntryRemove - remove a vldb entry.
2356  *
2357  * PARAMETERS
2358  *
2359  * IN cellHandle - a previously opened cellHandle that corresponds
2360  * to the cell where the vldb entry exists.
2361  *
2362  * IN serverHandle - a previously opened serverHandle that corresponds
2363  * to the server where the vldb entry exists.  Can be null.
2364  *
2365  * IN callBack - a call back function pointer that may be called to report
2366  * status information.  Can be null.
2367  *
2368  * IN partition - the partition where the vldb entry exists.  Can be null.
2369  *
2370  * IN volumeId - the volume id of the vldb entry to be deleted. Can be null.
2371  *
2372  * LOCKS
2373  * 
2374  * No locks are obtained or released by this function
2375  *
2376  * RETURN CODES
2377  *
2378  * Returns != 0 upon successful completion.
2379  */
2380
2381 int ADMINAPI vos_VLDBEntryRemove(
2382   const void *cellHandle,
2383   const void *serverHandle,
2384   vos_MessageCallBack_t callBack,
2385   const unsigned int *partition,
2386   unsigned int *volumeId,
2387   afs_status_p st)
2388 {
2389     int rc = 0;
2390     afs_status_t tst = 0;
2391     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2392     file_server_p f_server = (file_server_p) serverHandle;
2393     struct VldbListByAttributes attr;
2394     nbulkentries entries;
2395     afs_int32 nentries;
2396     int i;
2397  
2398     memset(&attr, 0, sizeof(attr));
2399     memset(&entries, 0, sizeof(entries));
2400
2401     /*
2402      * Validate arguments
2403      */
2404
2405     if (!IsValidCellHandle(c_handle, &tst)) {
2406         goto fail_vos_VLDBEntryRemove;
2407     }
2408
2409     /*
2410      * If the volume is specified, just delete it
2411      */
2412
2413     if (volumeId != NULL) {
2414         tst = ubik_Call(VL_DeleteEntry, c_handle->vos, 0, *volumeId, -1);
2415         if (tst != 0) {
2416             goto fail_vos_VLDBEntryRemove;
2417         }
2418     }
2419
2420     if (f_server != NULL) {
2421         if (!IsValidServerHandle(f_server, &tst)) {
2422             goto fail_vos_VLDBEntryRemove;
2423         }
2424         attr.server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
2425         attr.Mask |= VLLIST_SERVER;
2426     }
2427
2428     if (partition != NULL) {
2429         if (*partition > VOLMAXPARTS) {
2430             tst = ADMVOSPARTITIONTOOLARGE;
2431             goto fail_vos_VLDBEntryRemove;
2432         }
2433         attr.partition = *partition;
2434         attr.Mask |= VLLIST_PARTITION;
2435     }
2436
2437     if ((f_server == NULL) && (partition == NULL)) {
2438         tst = ADMVOSVLDBDELETEALLNULL;
2439         goto fail_vos_VLDBEntryRemove;
2440     }
2441
2442     if (!VLDB_ListAttributes(c_handle, &attr, &nentries, &entries, &tst)) {
2443         goto fail_vos_VLDBEntryRemove;
2444     }
2445
2446     if (nentries <= 0) {
2447         tst = ADMVOSVLDBNOENTRIES;
2448         goto fail_vos_VLDBEntryRemove;
2449     }
2450
2451     for(i=0;i<nentries;i++) {
2452         ubik_Call(VL_DeleteEntry, c_handle->vos, 0, entries.nbulkentries_val[i].volumeId[RWVOL]);
2453     }
2454     rc = 1;
2455
2456 fail_vos_VLDBEntryRemove:
2457
2458     if (entries.nbulkentries_val) {
2459         free(entries.nbulkentries_val);
2460     }
2461
2462     if (st != NULL) {
2463         *st = tst;
2464     }
2465     return rc;
2466 }
2467  
2468 /*
2469  * vos_VLDBUnlock - unlock vldb entries en masse.
2470  *
2471  * PARAMETERS
2472  *
2473  * IN cellHandle - a previously opened cellHandle that corresponds
2474  * to the cell where the vldb entries exist.
2475  *
2476  * IN serverHandle - a previously opened serverHandle that corresponds
2477  * to the server where the vldb entries exist.  Can be null.
2478  *
2479  * IN callBack - a call back function pointer that may be called to report
2480  * status information.  Can be null.
2481  *
2482  * IN partition - the partition where the vldb entries exist.  Can be null.
2483  *
2484  * LOCKS
2485  * 
2486  * No locks are obtained or released by this function
2487  *
2488  * RETURN CODES
2489  *
2490  * Returns != 0 upon successful completion.
2491  */
2492
2493 int ADMINAPI vos_VLDBUnlock(
2494   const void *cellHandle,
2495   const void *serverHandle,
2496   vos_MessageCallBack_t callBack,
2497   const unsigned int *partition,
2498   afs_status_p st)
2499 {
2500     int rc = 0;
2501     afs_status_t tst = 0;
2502     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2503     file_server_p f_server = (file_server_p) serverHandle;
2504     struct VldbListByAttributes attr;
2505     nbulkentries entries;
2506     afs_int32 nentries;
2507     int i;
2508
2509     memset(&attr, 0, sizeof(attr));
2510     memset(&entries, 0, sizeof(entries));
2511
2512     /*
2513      * Validate arguments
2514      */
2515
2516     if (!IsValidCellHandle(c_handle, &tst)) {
2517         goto fail_vos_VLDBUnlock;
2518     }
2519
2520     if (f_server != NULL) {
2521         if (!IsValidServerHandle(f_server, &tst)) {
2522             goto fail_vos_VLDBUnlock;
2523         }
2524         attr.server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
2525         attr.Mask |= VLLIST_SERVER;
2526     }
2527
2528     if (partition != NULL) {
2529         if (*partition > VOLMAXPARTS) {
2530             tst = ADMVOSPARTITIONTOOLARGE;
2531             goto fail_vos_VLDBUnlock;
2532         }
2533         attr.partition = *partition;
2534         attr.Mask |= VLLIST_PARTITION;
2535     }
2536     attr.flag = VLOP_ALLOPERS;
2537     attr.Mask |= VLLIST_FLAG;
2538
2539
2540     if (!VLDB_ListAttributes(c_handle, &attr, &nentries, &entries, &tst)) {
2541         goto fail_vos_VLDBUnlock;
2542     }
2543
2544     if (nentries <= 0) {
2545         tst = ADMVOSVLDBNOENTRIES;
2546         goto fail_vos_VLDBUnlock;
2547     }
2548
2549     for(i=0;i<nentries;i++) {
2550         vos_VLDBEntryUnlock(cellHandle, 0,
2551                             entries.nbulkentries_val[i].volumeId[RWVOL], &tst);
2552     }
2553     rc = 1;
2554  
2555 fail_vos_VLDBUnlock:
2556
2557     if (entries.nbulkentries_val) {
2558         free(entries.nbulkentries_val);
2559     }
2560
2561     if (st != NULL) {
2562         *st = tst;
2563     }
2564     return rc;
2565 }
2566
2567
2568 /*
2569  * vos_VLDBEntryLock - lock a vldb entry.
2570  *
2571  * PARAMETERS
2572  *
2573  * IN cellHandle - a previously opened cellHandle that corresponds
2574  * to the cell where the vldb entry exists.
2575  *
2576  * IN callBack - a call back function pointer that may be called to report
2577  * status information.  Can be null.
2578  *
2579  * IN volumeId - the volume id of the vldb entry to be deleted.
2580  *
2581  * LOCKS
2582  * 
2583  * No locks are obtained or released by this function
2584  *
2585  * RETURN CODES
2586  *
2587  * Returns != 0 upon successful completion.
2588  */
2589
2590 int ADMINAPI vos_VLDBEntryLock(
2591   const void *cellHandle,
2592   vos_MessageCallBack_t callBack,
2593   unsigned int volumeId,
2594   afs_status_p st)
2595 {
2596     int rc = 0;
2597     afs_status_t tst = 0;
2598     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2599
2600     /*
2601      * Validate arguments
2602      */
2603
2604     if (!IsValidCellHandle(c_handle, &tst)) {
2605         goto fail_vos_VLDBEntryLock;
2606     }
2607
2608     tst = ubik_Call(VL_SetLock, c_handle->vos, 0, volumeId, -1, VLOP_DELETE);
2609     if (tst != 0) {
2610         goto fail_vos_VLDBEntryLock;
2611     }
2612     rc = 1;
2613  
2614 fail_vos_VLDBEntryLock:
2615
2616     if (st != NULL) {
2617         *st = tst;
2618     }
2619     return rc;
2620 }
2621
2622 /*
2623  * vos_VLDBEntryUnlock - unlock a vldb entry.
2624  *
2625  * PARAMETERS
2626  *
2627  * IN cellHandle - a previously opened cellHandle that corresponds
2628  * to the cell where the vldb entry exists.
2629  *
2630  * IN callBack - a call back function pointer that may be called to report
2631  * status information.  Can be null.
2632  *
2633  * IN volumeId - the volume id of the vldb entry to be unlocked.
2634  *
2635  * LOCKS
2636  * 
2637  * No locks are obtained or released by this function
2638  *
2639  * RETURN CODES
2640  *
2641  * Returns != 0 upon successful completion.
2642  */
2643
2644 int ADMINAPI vos_VLDBEntryUnlock(
2645   const void *cellHandle,
2646   vos_MessageCallBack_t callBack,
2647   unsigned int volumeId,
2648   afs_status_p st)
2649 {
2650     int rc = 0;
2651     afs_status_t tst = 0;
2652     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2653
2654     /*
2655      * Validate arguments
2656      */
2657
2658     if (!IsValidCellHandle(c_handle, &tst)) {
2659         goto fail_vos_VLDBEntryUnlock;
2660     }
2661
2662
2663     tst = ubik_Call(VL_ReleaseLock, c_handle->vos, 0, volumeId, -1,
2664                     LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
2665     if (tst != 0) {
2666         goto fail_vos_VLDBEntryUnlock;
2667     }
2668     rc = 1;
2669  
2670 fail_vos_VLDBEntryUnlock:
2671
2672     if (st != NULL) {
2673         *st = tst;
2674     }
2675     return rc;
2676 }
2677
2678 /*
2679  * vos_VLDBReadOnlySiteCreate - create a readonly site for a volume.
2680  *
2681  * PARAMETERS
2682  *
2683  * IN cellHandle - a previously opened cellHandle that corresponds
2684  * to the cell where the volume exists.
2685  *
2686  * IN serverHandle - a previously opened serverHandle that corresponds
2687  * to the server where the new volume should be created.
2688  *
2689  * IN callBack - a call back function pointer that may be called to report
2690  * status information.  Can be null.
2691  *
2692  * IN partition - the partition where then new volume should be created.
2693  *
2694  * IN volumeId - the volume id of the volume to be replicated.
2695  *
2696  * LOCKS
2697  * 
2698  * No locks are obtained or released by this function
2699  *
2700  * RETURN CODES
2701  *
2702  * Returns != 0 upon successful completion.
2703  */
2704
2705 int ADMINAPI vos_VLDBReadOnlySiteCreate(
2706   const void *cellHandle,
2707   const void *serverHandle,
2708   vos_MessageCallBack_t callBack,
2709   unsigned int partition,
2710   unsigned int volumeId,
2711   afs_status_p st)
2712 {
2713     int rc = 0;
2714     afs_status_t tst = 0;
2715     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2716     file_server_p f_server = (file_server_p) serverHandle;
2717  
2718     /*
2719      * Validate arguments
2720      */
2721
2722     if (!IsValidCellHandle(c_handle, &tst)) {
2723         goto fail_vos_VLDBReadOnlySiteCreate;
2724     }
2725
2726     if (!IsValidServerHandle(f_server, &tst)) {
2727         goto fail_vos_VLDBReadOnlySiteCreate;
2728     }
2729
2730     if (partition > VOLMAXPARTS) {
2731         tst = ADMVOSPARTITIONTOOLARGE;
2732         goto fail_vos_VLDBReadOnlySiteCreate;
2733     }
2734
2735     if (!UV_AddSite(c_handle, ntohl(rx_HostOf(rx_PeerOf(f_server->serv))),
2736                     partition, volumeId, &tst)) {
2737         goto fail_vos_VLDBReadOnlySiteCreate;
2738     }
2739     rc = 1;
2740  
2741 fail_vos_VLDBReadOnlySiteCreate:
2742
2743     if (st != NULL) {
2744         *st = tst;
2745     }
2746     return rc;
2747 }
2748
2749 /*
2750  * vos_VLDBReadOnlySiteDelete - delete a replication site for a volume.
2751  *
2752  * PARAMETERS
2753  *
2754  *
2755  * IN cellHandle - a previously opened cellHandle that corresponds
2756  * to the cell where the volume exists.
2757  *
2758  * IN serverHandle - a previously opened serverHandle that corresponds
2759  * to the server where the volume should be deleted.
2760  *
2761  * IN callBack - a call back function pointer that may be called to report
2762  * status information.  Can be null.
2763  *
2764  * IN partition - the partition where then volume should be deleted.
2765  *
2766  * IN volumeId - the volume id of the volume to be deleted.
2767  *
2768  * LOCKS
2769  * 
2770  * No locks are obtained or released by this function
2771  *
2772  * RETURN CODES
2773  *
2774  * Returns != 0 upon successful completion.
2775  */
2776
2777 int ADMINAPI vos_VLDBReadOnlySiteDelete(
2778   const void *cellHandle,
2779   const void *serverHandle,
2780   vos_MessageCallBack_t callBack,
2781   unsigned int partition,
2782   unsigned int volumeId,
2783   afs_status_p st)
2784 {
2785     int rc = 0;
2786     afs_status_t tst = 0;
2787     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2788     file_server_p f_server = (file_server_p) serverHandle;
2789  
2790     /*
2791      * Validate arguments
2792      */
2793
2794     if (!IsValidCellHandle(c_handle, &tst)) {
2795         goto fail_vos_VLDBReadOnlySiteDelete;
2796     }
2797
2798     if (!IsValidServerHandle(f_server, &tst)) {
2799         goto fail_vos_VLDBReadOnlySiteDelete;
2800     }
2801
2802     if (partition > VOLMAXPARTS) {
2803         tst = ADMVOSPARTITIONTOOLARGE;
2804         goto fail_vos_VLDBReadOnlySiteDelete;
2805     }
2806
2807     if (!UV_RemoveSite(c_handle, ntohl(rx_HostOf(rx_PeerOf(f_server->serv))),
2808                     partition, volumeId, &tst)) {
2809         goto fail_vos_VLDBReadOnlySiteDelete;
2810     }
2811     rc = 1;
2812  
2813 fail_vos_VLDBReadOnlySiteDelete:
2814
2815     if (st != NULL) {
2816         *st = tst;
2817     }
2818     return rc;
2819 }
2820
2821 /*
2822  * vos_VLDBSync - synchronize the vldb with the fileserver.
2823  *
2824  * PARAMETERS
2825  *
2826  * IN cellHandle - a previously opened cellHandle that corresponds
2827  * to the cell where the sync should occur.
2828  *
2829  * IN serverHandle - a previously opened serverHandle that corresponds
2830  * to the server where the sync should occur.
2831  *
2832  * IN callBack - a call back function pointer that may be called to report
2833  * status information.  Can be null.
2834  *
2835  * IN partition - the partition where the sync should occur.  Can be null.
2836  *
2837  * IN force - force deletion of bad volumes.
2838  *
2839  * LOCKS
2840  * 
2841  * No locks are obtained or released by this function
2842  *
2843  * RETURN CODES
2844  *
2845  * Returns != 0 upon successful completion.
2846  */
2847
2848 int ADMINAPI vos_VLDBSync(
2849   const void *cellHandle,
2850   const void *serverHandle,
2851   vos_MessageCallBack_t callBack,
2852   const unsigned int *partition,
2853   vos_force_t force,
2854   afs_status_p st)
2855 {
2856     int rc = 0;
2857     afs_status_t tst = 0;
2858     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2859     file_server_p f_server = (file_server_p) serverHandle;
2860     afs_int32 part = 0;
2861     int flags = 0;
2862     int force_flag = 0;
2863  
2864     /*
2865      * Validate arguments
2866      */
2867
2868     if (!IsValidCellHandle(c_handle, &tst)) {
2869         goto fail_vos_VLDBSync;
2870     }
2871
2872     if (!IsValidServerHandle(f_server, &tst)) {
2873         goto fail_vos_VLDBSync;
2874     }
2875
2876     if (partition != NULL) {
2877         if (*partition > VOLMAXPARTS) {
2878             tst = ADMVOSPARTITIONTOOLARGE;
2879             goto fail_vos_VLDBSync;
2880         }
2881         part = (afs_int32) *partition;
2882         flags = 1;
2883     }
2884
2885     if (force == VOS_FORCE) {
2886         force_flag = 1;
2887     }
2888
2889     /*
2890      * sync the vldb
2891      */
2892
2893     rc = UV_SyncVldb(c_handle, f_server->serv, part, flags, force_flag, &tst);
2894  
2895 fail_vos_VLDBSync:
2896
2897     if (st != NULL) {
2898         *st = tst;
2899     }
2900     return rc;
2901 }
2902
2903 /*
2904  * vos_VolumeCreate - create a new partition.
2905  *
2906  * PARAMETERS
2907  *
2908  * IN cellHandle - a previously opened cellHandle that corresponds
2909  * to the cell where the server lives.
2910  *
2911  * IN serverHandle - a previously open vos server handle that holds
2912  * the partition where the volume should be create.
2913  *
2914  * IN callBack - a call back function pointer that may be called to report
2915  * status information.  Can be null.
2916  *
2917  * IN partition - the integer that represents the partition that will 
2918  * house the new volume.
2919  *
2920  * IN volumeName - the name of the new volume.
2921  *
2922  * IN quota - the quota of the new volume.
2923  *
2924  * OUT volumeId - the volume id of the newly created volume.
2925  *
2926  * LOCKS
2927  * 
2928  * No locks are obtained or released by this function
2929  *
2930  * RETURN CODES
2931  *
2932  * Returns != 0 upon successful completion.
2933  */
2934
2935 int ADMINAPI vos_VolumeCreate(
2936   const void *cellHandle,
2937   const void *serverHandle,
2938   vos_MessageCallBack_t callBack,
2939   unsigned int partition,
2940   const char *volumeName,
2941   unsigned int quota,
2942   unsigned int *volumeId,
2943   afs_status_p st)
2944 {
2945     int rc = 0;
2946     afs_status_t tst = 0;
2947     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2948     file_server_p f_server = (file_server_p) serverHandle;
2949     vos_partitionEntry_t pinfo;
2950     struct nvldbentry vinfo;
2951  
2952     /*
2953      * Validate arguments
2954      */
2955
2956     if (!IsValidCellHandle(c_handle, &tst)) {
2957         goto fail_vos_VolumeCreate;
2958     }
2959
2960     if (!IsValidServerHandle(f_server, &tst)) {
2961         goto fail_vos_VolumeCreate;
2962     }
2963
2964     if (partition > VOLMAXPARTS) {
2965         tst = ADMVOSPARTITIONTOOLARGE;
2966         goto fail_vos_VolumeCreate;
2967     }
2968
2969     if (!ValidateVolumeName(volumeName, &tst)) {
2970         goto fail_vos_VolumeCreate;
2971     }
2972
2973     if (volumeId == NULL) {
2974         tst = ADMVOSVOLUMEID;
2975         goto fail_vos_VolumeCreate;
2976     }
2977
2978     /*
2979      * Check that partition is valid at the server
2980      */
2981
2982     if (!vos_PartitionGet(cellHandle, serverHandle, 0, partition,
2983                           &pinfo, &tst)) {
2984         goto fail_vos_VolumeCreate;
2985     }
2986
2987     /*
2988      * Check that the volume doesn't already exist
2989      */
2990
2991     if (VLDB_GetEntryByName(c_handle, volumeName, &vinfo, &tst)) {
2992         tst = ADMVOSVOLUMENAMEDUP;
2993         goto fail_vos_VolumeCreate;
2994     }
2995
2996     /*
2997      * Create the new volume
2998      */
2999
3000     rc = UV_CreateVolume(c_handle, f_server->serv,
3001                          partition, volumeName, quota, volumeId, &tst);
3002
3003 fail_vos_VolumeCreate:
3004
3005     if (st != NULL) {
3006         *st = tst;
3007     }
3008     return rc;
3009 }
3010
3011 /*
3012  * vos_VolumeDelete - remove a volume.
3013  *
3014  * PARAMETERS
3015  *
3016  * IN cellHandle - a previously opened cellHandle that corresponds
3017  * to the cell where the volume exists.
3018  *
3019  * IN serverHandle - a previously opened serverHandle that corresponds
3020  * to the server where the volume exists.
3021  *
3022  * IN callBack - a call back function pointer that may be called to report
3023  * status information.  Can be null.
3024  *
3025  * IN partition - the partition where the volume exists.
3026  *
3027  * IN volumeId - the volume id of the volume to be deleted.
3028  *
3029  * LOCKS
3030  * 
3031  * No locks are obtained or released by this function
3032  *
3033  * RETURN CODES
3034  *
3035  * Returns != 0 upon successful completion.
3036  */
3037
3038 int ADMINAPI vos_VolumeDelete(
3039   const void *cellHandle,
3040   const void *serverHandle,
3041   vos_MessageCallBack_t callBack,
3042   unsigned int partition,
3043   unsigned int volumeId,
3044   afs_status_p st)
3045 {
3046     int rc = 0;
3047     afs_status_t tst = 0;
3048     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
3049     file_server_p f_server = (file_server_p) serverHandle;
3050     vos_partitionEntry_t pinfo;
3051  
3052     /*
3053      * Validate arguments
3054      */
3055
3056     if (!IsValidCellHandle(c_handle, &tst)) {
3057         goto fail_vos_VolumeDelete;
3058     }
3059
3060     if (!IsValidServerHandle(f_server, &tst)) {
3061         goto fail_vos_VolumeDelete;
3062     }
3063
3064     if (partition > VOLMAXPARTS) {
3065         tst = ADMVOSPARTITIONTOOLARGE;
3066         goto fail_vos_VolumeDelete;
3067     }
3068
3069     /*
3070      * Check that partition is valid at the server
3071      */
3072
3073     if (!vos_PartitionGet(cellHandle, serverHandle, 0, 
3074                           partition, &pinfo, &tst)) {
3075         goto fail_vos_VolumeDelete;
3076     }
3077  
3078     rc = UV_DeleteVolume(c_handle, f_server->serv, partition, volumeId, &tst);
3079
3080 fail_vos_VolumeDelete:
3081
3082     if (st != NULL) {
3083         *st = tst;
3084     }
3085     return rc;
3086 }
3087
3088 /*
3089  * vos_VolumeRename - rename a volume.
3090  *
3091  * PARAMETERS
3092  *
3093  * IN cellHandle - a previously opened cellHandle that corresponds
3094  * to the cell where the volume exists.
3095  *
3096  * IN serverHandle - a previously opened serverHandle that corresponds
3097  * to the server where the vldb entry exists.  Can be null.
3098  *
3099  * IN callBack - a call back function pointer that may be called to report
3100  * status information.  Can be null.
3101  *
3102  * IN readWriteVolumeId - the volume id of the volume to be renamed.
3103  *
3104  * IN newVolumeName - the new name.
3105  *
3106  * LOCKS
3107  * 
3108  * No locks are obtained or released by this function
3109  *
3110  * RETURN CODES
3111  *
3112  * Returns != 0 upon successful completion.
3113  */
3114
3115 int ADMINAPI vos_VolumeRename(
3116   const void *cellHandle,
3117   vos_MessageCallBack_t callBack,
3118   unsigned int readWriteVolumeId,
3119   const char *newVolumeName,
3120   afs_status_p st)
3121 {
3122     int rc = 0;
3123     afs_status_t tst = 0;
3124     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
3125     struct nvldbentry entry;
3126  
3127     /*
3128      * Validate arguments
3129      */
3130
3131     if (!IsValidCellHandle(c_handle, &tst)) {
3132         goto fail_vos_VolumeRename;
3133     }
3134
3135     if ((newVolumeName == NULL) || (*newVolumeName == 0)) {
3136         tst = ADMVOSNEWVOLUMENAMENULL;
3137         goto fail_vos_VolumeRename;
3138     }
3139
3140     /*
3141      * Retrieve the entry
3142      */
3143
3144     if (!VLDB_GetEntryByID(c_handle, readWriteVolumeId, -1, &entry, &tst)) {
3145         goto fail_vos_VolumeRename;
3146     }
3147  
3148     rc = UV_RenameVolume(c_handle, &entry, newVolumeName, &tst);
3149
3150 fail_vos_VolumeRename:
3151
3152     if (st != NULL) {
3153         *st = tst;
3154     }
3155     return rc;
3156 }
3157
3158 /*
3159  * vos_VolumeDump - dump a volume
3160  *
3161  * PARAMETERS
3162  *
3163  * IN cellHandle - a previously opened cellHandle that corresponds
3164  * to the cell where the volume exists.
3165  *
3166  * IN serverHandle - a previously opened serverHandle that corresponds
3167  * to the server where the volume exists.  Can be null.
3168  *
3169  * IN callBack - a call back function pointer that may be called to report
3170  * status information.  Can be null.
3171  *
3172  * IN volumeId - the volume id of the volume to be dumped.
3173  *
3174  * IN startTime - files with modification times >= this time will be dumped.
3175  *
3176  * IN dumpFile - the file to dump the volume to.
3177  *
3178  * LOCKS
3179  * 
3180  * No locks are obtained or released by this function
3181  *
3182  * RETURN CODES
3183  *
3184  * Returns != 0 upon successful completion.
3185  */
3186
3187 int ADMINAPI vos_VolumeDump(
3188   const void *cellHandle,
3189   const void *serverHandle,
3190   vos_MessageCallBack_t callBack,
3191   unsigned int *partition,
3192   unsigned int volumeId,
3193   unsigned int startTime,
3194   const char *dumpFile,
3195   afs_status_p st)
3196 {
3197     int rc = 0;
3198     afs_status_t tst = 0;
3199     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
3200     file_server_p f_server = (file_server_p) serverHandle;
3201     afs_int32 server, part, voltype;
3202     struct nvldbentry entry;
3203  
3204     /*
3205      * Validate arguments
3206      */
3207
3208     if (!IsValidCellHandle(c_handle, &tst)) {
3209         goto fail_vos_VolumeDump;
3210     }
3211
3212     if (serverHandle != NULL) {
3213         if (!IsValidServerHandle(f_server, &tst)) {
3214             goto fail_vos_VolumeDump;
3215         }
3216     }
3217
3218     /*
3219      * You must specify both the serverHandle and the partition
3220      */
3221
3222     if (serverHandle || partition) {
3223         if (!serverHandle || !partition) {
3224             tst = ADMVOSSERVERANDPARTITION;
3225             goto fail_vos_VolumeDump;
3226         } else {
3227             if (*partition > VOLMAXPARTS) {
3228                 tst = ADMVOSPARTITIONTOOLARGE;
3229                 goto fail_vos_VolumeDump;
3230             }
3231             server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
3232             part = *partition;
3233         }
3234     } else {
3235         if (!GetVolumeInfo(c_handle, volumeId, &entry, &server,
3236                            &part, &voltype, &tst)) {
3237             goto fail_vos_VolumeDump;
3238         }
3239     }
3240
3241     if ((dumpFile == NULL) || (*dumpFile == 0)) {
3242         tst = ADMVOSDUMPFILENULL;
3243         goto fail_vos_VolumeDump;
3244     }
3245
3246     rc = UV_DumpVolume(c_handle, volumeId, server, part, startTime,
3247                        dumpFile, &tst);
3248  
3249 fail_vos_VolumeDump:
3250
3251     if (st != NULL) {
3252         *st = tst;
3253     }
3254     return rc;
3255 }
3256
3257 /*
3258  * vos_VolumeRestore - restore a volume from a dump
3259  *
3260  * PARAMETERS
3261  *
3262  * IN cellHandle - a previously opened cellHandle that corresponds
3263  * to the cell where the volume exists.
3264  *
3265  * IN serverHandle - a previously opened serverHandle that corresponds
3266  * to the server where the volume exists.
3267  *
3268  * IN callBack - a call back function pointer that may be called to report
3269  * status information.  Can be null.
3270  *
3271  * IN partition - the partition where the volume exists.
3272  *
3273  * IN volumeId - the volume id of the volume to be restored.
3274  *
3275  * IN volumeName - the volume name of the volume to be restored.
3276  *
3277  * IN dumpFile - the file from which to restore the volume.
3278  *
3279  * IN dumpType - the type of dump to perform.
3280  *
3281  * LOCKS
3282  * 
3283  * No locks are obtained or released by this function
3284  *
3285  * RETURN CODES
3286  *
3287  * Returns != 0 upon successful completion.
3288  */
3289
3290 int ADMINAPI vos_VolumeRestore(
3291   const void *cellHandle,
3292   const void *serverHandle,
3293   vos_MessageCallBack_t callBack,
3294   unsigned int partition,
3295   unsigned int *volumeId,
3296   const char *volumeName,
3297   const char *dumpFile,
3298   vos_volumeRestoreType_t dumpType,
3299   afs_status_p st)
3300 {
3301     int rc = 0;
3302     afs_status_t tst = 0;
3303     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
3304     file_server_p f_server = (file_server_p) serverHandle;
3305     struct nvldbentry entry;
3306     afs_int32 volid, server;
3307     int fd;
3308     struct stat status;
3309     int restoreflags = 0;
3310     afs_int32 Oserver, Opart, Otype;
3311     struct nvldbentry Oentry;
3312     int equal;
3313  
3314     /*
3315      * Validate arguments
3316      */
3317
3318     if (!IsValidCellHandle(c_handle, &tst)) {
3319         goto fail_vos_VolumeRestore;
3320     }
3321
3322     if (serverHandle != NULL) {
3323         if (!IsValidServerHandle(f_server, &tst)) {
3324             goto fail_vos_VolumeRestore;
3325         }
3326     }
3327
3328     /*
3329      * Must pass volumeName
3330      */
3331
3332     if ((volumeName == NULL) || (*volumeName == 0)) {
3333         tst = ADMVOSVOLUMENAMENULL;
3334         goto fail_vos_VolumeRestore;
3335     }
3336
3337     if (!ValidateVolumeName(volumeName, &tst)) {
3338         goto fail_vos_VolumeRestore;
3339     }
3340
3341     /*
3342      * If volumeId is passed, it must be a valid volume id
3343      */
3344
3345     if (volumeId != NULL) {
3346         if (!VLDB_GetEntryByID(c_handle, *volumeId, -1, &entry, &tst)) {
3347             goto fail_vos_VolumeRestore;
3348         }
3349         volid = *volumeId;
3350     } else {
3351         volid = 0;
3352     }
3353
3354     server = ntohl(rx_HostOf(rx_PeerOf(f_server->serv)));
3355
3356     if (partition > VOLMAXPARTS) {
3357         tst = ADMVOSPARTITIONTOOLARGE;
3358         goto fail_vos_VolumeRestore;
3359     }
3360
3361     /*
3362      * Check that dumpFile exists and can be accessed
3363      */
3364
3365     fd = open(dumpFile, 0);
3366     if ((fd < 0) || (fstat(fd, &status) < 0)) {
3367         close(fd);
3368         tst = ADMVOSDUMPFILEOPENFAIL;
3369         goto fail_vos_VolumeRestore;
3370     } else {
3371         close(fd);
3372     }
3373
3374     if (!VLDB_GetEntryByName(c_handle, volumeName, &entry, &tst)) {
3375         restoreflags = RV_FULLRST;
3376     } else if (Lp_GetRwIndex(c_handle, &entry, 0) == -1) {
3377         restoreflags = RV_FULLRST;
3378         if (volid == 0) {
3379             volid = entry.volumeId[RWVOL];
3380         } else if ((entry.volumeId[RWVOL] != 0) &&
3381                    (entry.volumeId[RWVOL] != volid)) {
3382             volid = entry.volumeId[RWVOL];
3383         }
3384     } else {
3385
3386         if (volid == 0) {
3387             volid = entry.volumeId[RWVOL];
3388         } else if ((entry.volumeId[RWVOL] != 0) &&
3389                    (entry.volumeId[RWVOL] != volid)) {
3390             volid = entry.volumeId[RWVOL];
3391         }
3392
3393         /*
3394          * If the vldb says the same volume exists somewhere else
3395          * the caller must specify a full restore, not an incremental
3396          */
3397
3398         if (dumpType == VOS_RESTORE_FULL) {
3399             restoreflags = RV_FULLRST;
3400         } else {
3401
3402             /*
3403              * Check to see if the volume exists where the caller said
3404              */
3405             if (!GetVolumeInfo(c_handle, volid, &Oentry, &Oserver, &Opart,
3406                                &Otype, &tst)) {
3407                 goto fail_vos_VolumeRestore;
3408             }
3409             if (!VLDB_IsSameAddrs(c_handle, Oserver, server, &equal, &tst)) {
3410                 goto fail_vos_VolumeRestore;
3411             }
3412
3413             if (!equal) {
3414                 tst = ADMVOSRESTOREVOLEXIST;
3415                 goto fail_vos_VolumeRestore;
3416             }
3417         }
3418     }
3419
3420     rc = UV_RestoreVolume(c_handle, server, partition, volid, volumeName,
3421                           restoreflags, dumpFile, &tst);
3422
3423 fail_vos_VolumeRestore:
3424
3425     if (st != NULL) {
3426         *st = tst;
3427     }
3428     return rc;
3429 }
3430
3431 /*
3432  * vos_VolumeOnline - bring a volume online.
3433  *
3434  * PARAMETERS
3435  *
3436  * IN serverHandle - a previously opened serverHandle that corresponds
3437  * to the server where the volume exists.
3438  *
3439  * IN callBack - a call back function pointer that may be called to report
3440  * status information.  Can be null.
3441  *
3442  * IN partition - the partition where the volume exists.
3443  *
3444  * IN volumeId - the volume id of the volume to be brought online.
3445  *
3446  * LOCKS
3447  * 
3448  * No locks are obtained or released by this function
3449  *
3450  * RETURN CODES
3451  *
3452  * Returns != 0 upon successful completion.
3453  */
3454
3455 int ADMINAPI vos_VolumeOnline(
3456   const void *serverHandle,
3457   vos_MessageCallBack_t callBack,
3458   unsigned int partition,
3459   unsigned int volumeId,
3460   unsigned int sleepTime,
3461   vos_volumeOnlineType_t volumeStatus,
3462   afs_status_p st)
3463 {
3464     int rc = 0;
3465     afs_status_t tst = 0;
3466     file_server_p f_server = (file_server_p) serverHandle;
3467     int up = ITOffline;
3468  
3469     /*
3470      * Validate arguments
3471      */
3472
3473     if (!IsValidServerHandle(f_server, &tst)) {
3474         goto fail_vos_VolumeOnline;
3475     }
3476
3477     if (partition > VOLMAXPARTS) {
3478         tst = ADMVOSPARTITIONIDTOOLARGE;
3479         goto fail_vos_VolumeOnline;
3480     }
3481
3482     if (volumeStatus == VOS_ONLINE_BUSY) {
3483         up = ITBusy;
3484     }
3485
3486     rc = UV_SetVolume(f_server->serv, partition, volumeId, up, 0,
3487                       sleepTime, &tst);
3488
3489 fail_vos_VolumeOnline:
3490
3491     if (st != NULL) {
3492         *st = tst;
3493     }
3494     return rc;
3495 }
3496
3497 /*
3498  * vos_VolumeOffline - take a volume offline.
3499  *
3500  * PARAMETERS
3501  *
3502  * IN serverHandle - a previously opened serverHandle that corresponds
3503  * to the server where the volume exists.
3504  *
3505  * IN callBack - a call back function pointer that may be called to report
3506  * status information.  Can be null.
3507  *
3508  * IN partition - the partition where the volume exists.
3509  *
3510  * IN volumeId - the volume id of the volume to be taken offline.
3511  *
3512  * LOCKS
3513  * 
3514  * No locks are obtained or released by this function
3515  *
3516  * RETURN CODES
3517  *
3518  * Returns != 0 upon successful completion.
3519  */
3520
3521 int ADMINAPI vos_VolumeOffline(
3522   const void *serverHandle,
3523   vos_MessageCallBack_t callBack,
3524   unsigned int partition,
3525   unsigned int volumeId,
3526   afs_status_p st)
3527 {
3528     int rc = 0;
3529     afs_status_t tst = 0;
3530     file_server_p f_server = (file_server_p) serverHandle;
3531  
3532     /*
3533      * Validate arguments
3534      */
3535
3536     if (!IsValidServerHandle(f_server, &tst)) {
3537         goto fail_vos_VolumeOffline;
3538     }
3539
3540     if (partition > VOLMAXPARTS) {
3541         tst = ADMVOSPARTITIONIDTOOLARGE;
3542         goto fail_vos_VolumeOffline;
3543     }
3544
3545     rc = UV_SetVolume(f_server->serv, partition, volumeId, ITOffline,
3546                       VTOutOfService, 0, &tst);
3547  
3548 fail_vos_VolumeOffline:
3549
3550     if (st != NULL) {
3551         *st = tst;
3552     }
3553     return rc;
3554 }
3555
3556 /*
3557  * copyvolintXInfo - copy a struct volintXInfo to a vos_volumeEntry_p.
3558  *
3559  * PARAMETERS
3560  *
3561  * IN source - the volintXInfo structure to copy.
3562  *
3563  * OUT dest - the vos_volumeEntry_t to fill
3564  *
3565  * LOCKS
3566  * 
3567  * No locks are obtained or released by this function
3568  *
3569  * RETURN CODES
3570  *
3571  * Returns != 0 upon successful completion.
3572  */
3573
3574 static int copyvolintXInfo(
3575     struct volintXInfo *source,
3576     vos_volumeEntry_p dest,
3577     afs_status_p st)
3578 {
3579     int rc = 0;
3580     afs_status_t tst = 0;
3581     int i;
3582
3583     /*
3584      * If the volume is not marked OK, all the other fields are invalid
3585      * We take the extra step of blanking out dest here to prevent the
3586      * user from seeing stale data from a previous call
3587      */
3588
3589     memset(dest, 0, sizeof(dest));
3590
3591     switch(source->status){
3592       case VOK: 
3593         dest->status = VOS_OK;
3594         break;
3595       case VSALVAGE: 
3596         dest->status = VOS_SALVAGE;
3597         break;
3598       case VNOVNODE: 
3599         dest->status = VOS_NO_VNODE;
3600         break;
3601       case VNOVOL: 
3602         dest->status = VOS_NO_VOL;
3603         break;
3604       case VVOLEXISTS: 
3605         dest->status = VOS_VOL_EXISTS;
3606         break;
3607       case VNOSERVICE: 
3608         dest->status = VOS_NO_SERVICE;
3609         break;
3610       case VOFFLINE: 
3611         dest->status = VOS_OFFLINE;
3612         break;
3613       case VONLINE: 
3614         dest->status = VOS_ONLINE;
3615         break;
3616       case VDISKFULL: 
3617         dest->status = VOS_DISK_FULL;
3618         break;
3619       case VOVERQUOTA: 
3620         dest->status = VOS_OVER_QUOTA;
3621         break;
3622       case VBUSY: 
3623         dest->status = VOS_BUSY;
3624         break;
3625       case VMOVED: 
3626         dest->status = VOS_MOVED;
3627         break;
3628     }
3629
3630     /*
3631      * Check to see if the entry is marked ok before copying all the
3632      * fields
3633      */
3634
3635     if (dest->status == VOS_OK) {
3636         strcpy(dest->name, source->name);
3637         dest->id = source->volid;
3638         if (source->type == 0) {
3639             dest->type = VOS_READ_WRITE_VOLUME;
3640         } else if (source->type == 1) {
3641             dest->type = VOS_READ_ONLY_VOLUME;
3642         } else if (source->type == 2) {
3643             dest->type = VOS_BACKUP_VOLUME;
3644         }
3645         dest->backupId = source->backupID;
3646         dest->readWriteId = source->parentID;
3647         dest->readOnlyId = source->cloneID;
3648         dest->copyCreationDate = source->copyDate;
3649         dest->creationDate = source->creationDate;
3650         dest->lastAccessDate = source->accessDate;
3651         dest->lastUpdateDate = source->updateDate;
3652         dest->lastBackupDate = source->backupDate;
3653         dest->accessesSinceMidnight = source->dayUse;
3654         dest->fileCount = source->filecount;
3655         dest->maxQuota = source->maxquota;
3656         dest->currentSize = source->size;
3657         if (source->inUse == 1) {
3658             dest->volumeDisposition = VOS_ONLINE;
3659         } else {
3660             dest->volumeDisposition = VOS_OFFLINE;
3661         }
3662
3663         for(i=0;i<VOS_VOLUME_READ_WRITE_STATS_NUMBER;i++) {
3664             dest->readStats[i] = source->stat_reads[i];
3665             dest->writeStats[i] = source->stat_writes[i];
3666         }
3667
3668         for(i=0;i<VOS_VOLUME_TIME_STATS_NUMBER;i++) {
3669             dest->fileAuthorWriteSameNetwork[i] = source->stat_fileSameAuthor[i];
3670             dest->fileAuthorWriteDifferentNetwork[i] =
3671                 source->stat_fileDiffAuthor[i];
3672             dest->dirAuthorWriteSameNetwork[i] = source->stat_dirSameAuthor[i];
3673             dest->dirAuthorWriteDifferentNetwork[i] = source->stat_dirDiffAuthor[i];
3674         }
3675     }
3676
3677     rc = 1;
3678
3679     if (st != NULL) {
3680         *st = tst;
3681     }
3682     return rc;
3683 }
3684
3685 /*
3686  * vos_VolumeGet - get information about a particular volume.
3687  *
3688  * PARAMETERS
3689  *
3690  * IN cellHandle - a previously opened cellHandle that corresponds
3691  * to the cell where the volume exists.
3692  *
3693  * IN serverHandle - a previously opened serverHandle that corresponds
3694  * to the server where the volume exists.
3695  *
3696  * IN callBack - a call back function pointer that may be called to report
3697  * status information.  Can be null.
3698  *
3699  * IN partition - the partition where the volume exists.
3700  *
3701  * IN volumeId - the volume id of the volume to be retrieved.
3702  *
3703  * OUT volumeP - upon successful completion, contains the information about the 
3704  * specified volume.
3705  *
3706  * LOCKS
3707  * 
3708  * No locks are obtained or released by this function
3709  *
3710  * RETURN CODES
3711  *
3712  * Returns != 0 upon successful completion.
3713  */
3714
3715 int ADMINAPI vos_VolumeGet(
3716   const void *cellHandle,
3717   const void *serverHandle,
3718   vos_MessageCallBack_t callBack,
3719   unsigned int partition,
3720   unsigned int volumeId,
3721   vos_volumeEntry_p volumeP,
3722   afs_status_p st)
3723 {
3724     int rc = 0;
3725     afs_status_t tst = 0;
3726     file_server_p f_server = (file_server_p) serverHandle;
3727     struct volintXInfo *info = NULL;
3728  
3729     /*
3730      * Validate arguments
3731      */
3732
3733     if (!IsValidServerHandle(f_server, &tst)) {
3734         goto fail_vos_VolumeGet;
3735     }
3736
3737     if (partition > VOLMAXPARTS) {
3738         tst = ADMVOSPARTITIONIDTOOLARGE;
3739         goto fail_vos_VolumeGet;
3740     }
3741
3742     if (volumeP == NULL) {
3743         tst = ADMVOSVOLUMEPNULL;
3744         goto fail_vos_VolumeGet;
3745     }
3746
3747     /*
3748      * Retrieve the information for the volume
3749      */
3750
3751     if (!UV_XListOneVolume(f_server->serv, partition, volumeId, &info, &tst)) {
3752         goto fail_vos_VolumeGet;
3753     }
3754
3755     /*
3756      * Copy the volume info to our structure
3757      */
3758
3759     if (!copyvolintXInfo(info, volumeP, &tst)) {
3760         goto fail_vos_VolumeGet;
3761     }
3762     rc = 1;
3763
3764 fail_vos_VolumeGet:
3765
3766     if (info != NULL) {
3767         free(info);
3768     }
3769
3770     if (st != NULL) {
3771         *st = tst;
3772     }
3773     return rc;
3774 }
3775
3776 /*
3777  * The iterator functions and data for the volume retrieval functions.
3778  */
3779
3780 typedef struct volume_get {
3781   struct volintXInfo *vollist;
3782   afs_int32 total; /* total number of volumes at this partition */
3783   afs_int32 index; /* index to the current volume */
3784   vos_volumeEntry_t entry[CACHED_ITEMS]; /* the cache of entries */
3785 } volume_get_t, *volume_get_p;
3786
3787 static int GetVolumeRPC(
3788   void *rpc_specific,
3789   int slot,
3790   int *last_item,
3791   int *last_item_contains_data,
3792   afs_status_p st)
3793 {
3794     int rc = 0;
3795     afs_status_t tst = 0;
3796     volume_get_p entry = (volume_get_p) rpc_specific;
3797
3798     /*
3799      * Copy the next entry into the cache
3800      */
3801
3802     if (!copyvolintXInfo(&entry->vollist[entry->index],
3803                          &entry->entry[slot],
3804                          &tst)) {
3805         goto fail_GetVolumeRPC;
3806     }
3807     entry->index++;
3808
3809     /*
3810      * See if we've processed all the entries
3811      */
3812
3813
3814     if (entry->index == entry->total) {
3815         *last_item = 1;
3816         *last_item_contains_data = 1;
3817     }
3818     rc = 1;
3819
3820 fail_GetVolumeRPC:
3821
3822     if (st != NULL) {
3823         *st = tst;
3824     }
3825     return rc;
3826 }
3827
3828 static int GetVolumeFromCache(
3829   void *rpc_specific,
3830   int slot,
3831   void *dest,
3832   afs_status_p st)
3833 {
3834     int rc = 0;
3835     afs_status_t tst = 0;
3836     volume_get_p entry = (volume_get_p) rpc_specific;
3837
3838     memcpy(dest, (const void *) &entry->entry[slot],
3839            sizeof(vos_volumeEntry_t));
3840     rc = 1;
3841
3842     if (st != NULL) {
3843         *st = tst;
3844     }
3845     return rc;
3846 }
3847
3848
3849 static int DestroyVolume(
3850   void *rpc_specific,
3851   afs_status_p st)
3852 {
3853     int rc = 0;
3854     afs_status_t tst = 0;
3855     volume_get_p entry = (volume_get_p) rpc_specific;
3856
3857     if (entry->vollist != NULL) {
3858         free(entry->vollist);