add-volupdate-counter-20051015
[openafs.git] / src / volser / volprocs.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
14     ("$Header$");
15
16 #include <stdio.h>
17 #include <sys/types.h>
18 #include <errno.h>
19 #ifdef AFS_NT40_ENV
20 #include <fcntl.h>
21 #include <winsock2.h>
22 #else
23 #include <sys/file.h>
24 #include <netinet/in.h>
25 #include <unistd.h>
26 #endif
27
28 #ifdef HAVE_STRING_H
29 #include <string.h>
30 #else
31 #ifdef HAVE_STRINGS_H
32 #include <strings.h>
33 #endif
34 #endif
35
36 #include <dirent.h>
37 #include <sys/stat.h>
38 #include <rx/xdr.h>
39 #include <rx/rx.h>
40 #include <rx/rxkad.h>
41 #include <afs/afsint.h>
42 #include <signal.h>
43 #ifdef AFS_PTHREAD_ENV
44 #include <assert.h>
45 #else /* AFS_PTHREAD_ENV */
46 #include <afs/assert.h>
47 #endif /* AFS_PTHREAD_ENV */
48 #include <afs/prs_fs.h>
49 #include <afs/nfs.h>
50 #include <lwp.h>
51 #include <lock.h>
52 #include <afs/auth.h>
53 #include <afs/cellconfig.h>
54 #include <afs/keys.h>
55 #include <ubik.h>
56 #include <afs/ihandle.h>
57 #ifdef AFS_NT40_ENV
58 #include <afs/ntops.h>
59 #endif
60 #include <afs/vnode.h>
61 #include <afs/volume.h>
62 #include <afs/partition.h>
63 #include "vol.h"
64 #include <afs/fssync.h>
65 #include <afs/acl.h>
66 #include "afs/audit.h"
67 #include <afs/dir.h>
68
69 #include "volser.h"
70 #include "volint.h"
71
72 #include "volser_prototypes.h"
73
74 extern int DoLogging;
75 extern struct volser_trans *FindTrans(), *NewTrans(), *TransList();
76 extern struct afsconf_dir *tdir;
77
78 /* Needed by Irix. Leave, or include a header */
79 extern char *volutil_PartitionName();
80
81 extern void LogError(afs_int32 errcode);
82
83 /* Forward declarations */
84 static int GetPartName(afs_int32 partid, char *pname);
85
86 #define OneDay (24*60*60)
87
88 #ifdef AFS_NT40_ENV
89 #define ENOTCONN 134
90 #endif
91
92 afs_int32 localTid = 1;
93 afs_int32 VolPartitionInfo(), VolNukeVolume(), VolCreateVolume(),
94 VolDeleteVolume(), VolClone();
95 afs_int32 VolReClone(), VolTransCreate(), VolGetNthVolume(), VolGetFlags(),
96 VolForward(), VolDump();
97 afs_int32 VolRestore(), VolEndTrans(), VolSetForwarding(), VolGetStatus(),
98 VolSetInfo(), VolGetName();
99 afs_int32 VolListPartitions(), VolListOneVolume(),
100 VolXListOneVolume(), VolXListVolumes();
101 afs_int32 VolListVolumes(), XVolListPartitions(), VolMonitor(),
102 VolSetIdsTypes(), VolSetDate(), VolSetFlags();
103
104 /* this call unlocks all of the partition locks we've set */
105 int 
106 VPFullUnlock()
107 {
108     register struct DiskPartition *tp;
109     for (tp = DiskPartitionList; tp; tp = tp->next) {
110         if (tp->lock_fd != -1) {
111             close(tp->lock_fd); /* releases flock held on this partition */
112             tp->lock_fd = -1;
113         }
114     }
115     return 0;
116 }
117
118 /* get partition id from a name */
119 afs_int32
120 PartitionID(char *aname)
121 {
122     register char tc;
123     register int code = 0;
124     char ascii[3];
125
126     tc = *aname;
127     if (tc == 0)
128         return -1;              /* unknown */
129
130     /* otherwise check for vicepa or /vicepa, or just plain "a" */
131     ascii[2] = 0;
132     if (!strncmp(aname, "/vicep", 6)) {
133         strncpy(ascii, aname + 6, 2);
134     } else
135         return -1;              /* bad partition name */
136     /* now partitions are named /vicepa ... /vicepz, /vicepaa, /vicepab, .../vicepzz, and are numbered
137      * from 0.  Do the appropriate conversion */
138     if (ascii[1] == 0) {
139         /* one char name, 0..25 */
140         if (ascii[0] < 'a' || ascii[0] > 'z')
141             return -1;          /* wrongo */
142         return ascii[0] - 'a';
143     } else {
144         /* two char name, 26 .. <whatever> */
145         if (ascii[0] < 'a' || ascii[0] > 'z')
146             return -1;          /* wrongo */
147         if (ascii[1] < 'a' || ascii[1] > 'z')
148             return -1;          /* just as bad */
149         code = (ascii[0] - 'a') * 26 + (ascii[1] - 'a') + 26;
150         if (code > VOLMAXPARTS)
151             return -1;
152         return code;
153     }
154 }
155
156 static int
157 ConvertVolume(afs_int32 avol, char *aname, afs_int32 asize)
158 {
159     if (asize < 18)
160         return -1;
161     /* It's better using the Generic VFORMAT since otherwise we have to make changes to too many places... The 14 char limitation in names hits us again in AIX; print in field of 9 digits (still 10 for the rest), right justified with 0 padding */
162     (void)afs_snprintf(aname, asize, VFORMAT, (unsigned long)avol);
163     return 0;
164 }
165
166 static int
167 ConvertPartition(int apartno, char *aname, int asize)
168 {
169     if (asize < 10)
170         return E2BIG;
171     if (apartno < 0)
172         return EINVAL;
173     strcpy(aname, "/vicep");
174     if (apartno < 26) {
175         aname[6] = 'a' + apartno;
176         aname[7] = 0;
177     } else {
178         apartno -= 26;
179         aname[6] = 'a' + (apartno / 26);
180         aname[7] = 'a' + (apartno % 26);
181         aname[8] = 0;
182     }
183     return 0;
184 }
185
186 /* the only attach function that takes a partition is "...ByName", so we use it */
187 struct Volume *
188 XAttachVolume(afs_int32 *error, afs_int32 avolid, afs_int32 apartid, int amode)
189 {
190     char pbuf[30], vbuf[20];
191     register struct Volume *tv;
192
193     if (ConvertPartition(apartid, pbuf, sizeof(pbuf))) {
194         *error = EINVAL;
195         return NULL;
196     }
197     if (ConvertVolume(avolid, vbuf, sizeof(vbuf))) {
198         *error = EINVAL;
199         return NULL;
200     }
201     tv = VAttachVolumeByName(error, pbuf, vbuf, amode);
202     return tv;
203 }
204
205 /* Adapted from the file server; create a root directory for this volume */
206 static int
207 ViceCreateRoot(Volume *vp)
208 {
209     DirHandle dir;
210     struct acl_accessList *ACL;
211     ViceFid did;
212     Inode inodeNumber, nearInode;
213     char buf[SIZEOF_LARGEDISKVNODE];
214     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
215     struct VnodeClassInfo *vcp = &VnodeClassInfo[vLarge];
216     IHandle_t *h;
217     FdHandle_t *fdP;
218     int code;
219     afs_fsize_t length;
220
221     memset(vnode, 0, SIZEOF_LARGEDISKVNODE);
222
223     V_pref(vp, nearInode);
224     inodeNumber =
225         IH_CREATE(V_linkHandle(vp), V_device(vp),
226                   VPartitionPath(V_partition(vp)), nearInode, V_parentId(vp),
227                   1, 1, 0);
228     assert(VALID_INO(inodeNumber));
229
230     SetSalvageDirHandle(&dir, V_parentId(vp), vp->device, inodeNumber);
231     did.Volume = V_id(vp);
232     did.Vnode = (VnodeId) 1;
233     did.Unique = 1;
234
235     assert(!(MakeDir(&dir, &did, &did)));
236     DFlush();                   /* flush all modified dir buffers out */
237     DZap(&dir);                 /* Remove all buffers for this dir */
238     length = Length(&dir);      /* Remember size of this directory */
239
240     FidZap(&dir);               /* Done with the dir handle obtained via SetSalvageDirHandle() */
241
242     /* build a single entry ACL that gives all rights to system:administrators */
243     /* this section of code assumes that access list format is not going to
244      * change
245      */
246     ACL = VVnodeDiskACL(vnode);
247     ACL->size = sizeof(struct acl_accessList);
248     ACL->version = ACL_ACLVERSION;
249     ACL->total = 1;
250     ACL->positive = 1;
251     ACL->negative = 0;
252     ACL->entries[0].id = -204;  /* this assumes System:administrators is group -204 */
253     ACL->entries[0].rights =
254         PRSFS_READ | PRSFS_WRITE | PRSFS_INSERT | PRSFS_LOOKUP | PRSFS_DELETE
255         | PRSFS_LOCK | PRSFS_ADMINISTER;
256
257     vnode->type = vDirectory;
258     vnode->cloned = 0;
259     vnode->modeBits = 0777;
260     vnode->linkCount = 2;
261     VNDISK_SET_LEN(vnode, length);
262     vnode->uniquifier = 1;
263     V_uniquifier(vp) = vnode->uniquifier + 1;
264     vnode->dataVersion = 1;
265     VNDISK_SET_INO(vnode, inodeNumber);
266     vnode->unixModifyTime = vnode->serverModifyTime = V_creationDate(vp);
267     vnode->author = 0;
268     vnode->owner = 0;
269     vnode->parent = 0;
270     vnode->vnodeMagic = vcp->magic;
271
272     IH_INIT(h, vp->device, V_parentId(vp),
273             vp->vnodeIndex[vLarge].handle->ih_ino);
274     fdP = IH_OPEN(h);
275     assert(fdP != NULL);
276     code = FDH_SEEK(fdP, vnodeIndexOffset(vcp, 1), SEEK_SET);
277     assert(code >= 0);
278     code = FDH_WRITE(fdP, vnode, SIZEOF_LARGEDISKVNODE);
279     assert(code == SIZEOF_LARGEDISKVNODE);
280     FDH_REALLYCLOSE(fdP);
281     IH_RELEASE(h);
282     VNDISK_GET_LEN(length, vnode);
283     V_diskused(vp) = nBlocks(length);
284
285     return 1;
286 }
287
288 afs_int32
289 SAFSVolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition 
290                      *partition)
291 {
292     afs_int32 code;
293
294     code = VolPartitionInfo(acid, pname, partition);
295     osi_auditU(acid, VS_ParInfEvent, code, AUD_STR, pname, AUD_END);
296     return code;
297 }
298
299 afs_int32
300 VolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition 
301                  *partition)
302 {
303     register struct DiskPartition *dp;
304
305 /*
306     if (!afsconf_SuperUser(tdir, acid, caller)) return VOLSERBAD_ACCESS;
307 */
308     VResetDiskUsage();
309     dp = VGetPartition(pname, 0);
310     if (dp) {
311         strncpy(partition->name, dp->name, 32);
312         strncpy(partition->devName, dp->devName, 32);
313         partition->lock_fd = dp->lock_fd;
314         partition->free = dp->free;
315         partition->minFree = dp->totalUsable;
316         return 0;
317     } else
318         return VOLSERILLEGAL_PARTITION;
319 }
320
321 /* obliterate a volume completely, and slowly. */
322 afs_int32
323 SAFSVolNukeVolume(struct rx_call *acid, afs_int32 apartID, afs_int32 avolID)
324 {
325     afs_int32 code;
326
327     code = VolNukeVolume(acid, apartID, avolID);
328     osi_auditU(acid, VS_NukVolEvent, code, AUD_LONG, avolID, AUD_END);
329     return code;
330 }
331
332 afs_int32
333 VolNukeVolume(struct rx_call *acid, afs_int32 apartID, afs_int32 avolID)
334 {
335     register char *tp;
336     char partName[50];
337     afs_int32 error;
338     register afs_int32 code;
339     struct Volume *tvp;
340     char caller[MAXKTCNAMELEN];
341
342     /* check for access */
343     if (!afsconf_SuperUser(tdir, acid, caller))
344         return VOLSERBAD_ACCESS;
345     if (DoLogging)
346         Log("%s is executing VolNukeVolume %u\n", caller, avolID);
347
348     tp = volutil_PartitionName(apartID);
349     if (!tp)
350         return VOLSERNOVOL;
351     strcpy(partName, tp);       /* remember it for later */
352     /* we first try to attach the volume in update mode, so that the file
353      * server doesn't try to use it (and abort) while (or after) we delete it.
354      * If we don't get the volume, that's fine, too.  We just won't put it back.
355      */
356     tvp = XAttachVolume(&error, avolID, apartID, V_VOLUPD);
357     code = nuke(partName, avolID);
358     if (tvp)
359         VDetachVolume(&error, tvp);
360     return code;
361 }
362
363 /* create a new volume, with name aname, on the specified partition (1..n)
364  * and of type atype (readwriteVolume, readonlyVolume, backupVolume).
365  * As input, if *avolid is 0, we allocate a new volume id, otherwise we use *avolid
366  * for the volume id (useful for things like volume restore).
367  * Return the new volume id in *avolid.
368  */
369 afs_int32
370 SAFSVolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname, 
371                     afs_int32 atype, afs_int32 aparent, afs_int32 *avolid, 
372                     afs_int32 *atrans)
373 {
374     afs_int32 code;
375
376     code =
377         VolCreateVolume(acid, apart, aname, atype, aparent, avolid, atrans);
378     osi_auditU(acid, VS_CrVolEvent, code, AUD_LONG, *atrans, AUD_LONG,
379                *avolid, AUD_STR, aname, AUD_LONG, atype, AUD_LONG, aparent,
380                AUD_END);
381     return code;
382 }
383
384 afs_int32
385 VolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname, 
386                     afs_int32 atype, afs_int32 aparent, afs_int32 *avolid, 
387                     afs_int32 *atrans)
388 {
389     afs_int32 error;
390     register Volume *vp;
391     afs_int32 junk;             /* discardable error code */
392     register afs_int32 volumeID, doCreateRoot = 1;
393     register struct volser_trans *tt;
394     char ppath[30];
395     char caller[MAXKTCNAMELEN];
396
397     if (strlen(aname) > 31)
398         return VOLSERBADNAME;
399     if (!afsconf_SuperUser(tdir, acid, caller))
400         return VOLSERBAD_ACCESS;
401     if (DoLogging)
402         Log("%s is executing CreateVolume '%s'\n", caller, aname);
403     if ((error = ConvertPartition(apart, ppath, sizeof(ppath))))
404         return error;           /*a standard unix error */
405     if (atype != readwriteVolume && atype != readonlyVolume
406         && atype != backupVolume)
407         return EINVAL;
408     if ((volumeID = *avolid) == 0) {
409
410         Log("1 Volser: CreateVolume: missing volume number; %s volume not created\n", aname);
411         return E2BIG;
412
413     }
414     if ((aparent == volumeID) && (atype == readwriteVolume)) {
415         doCreateRoot = 0;
416     }
417     if (aparent == 0)
418         aparent = volumeID;
419     tt = NewTrans(volumeID, apart);
420     if (!tt) {
421         Log("1 createvolume: failed to create trans\n");
422         return VOLSERVOLBUSY;   /* volume already busy! */
423     }
424     vp = VCreateVolume(&error, ppath, volumeID, aparent);
425     if (error) {
426         Log("1 Volser: CreateVolume: Unable to create the volume; aborted, error code %u\n", error);
427         LogError(error);
428         DeleteTrans(tt, 1);
429         return EIO;
430     }
431     V_uniquifier(vp) = 1;
432     V_creationDate(vp) = V_copyDate(vp);
433     V_inService(vp) = V_blessed(vp) = 1;
434     V_type(vp) = atype;
435     AssignVolumeName(&V_disk(vp), aname, 0);
436     if (doCreateRoot)
437         ViceCreateRoot(vp);
438     V_destroyMe(vp) = DESTROY_ME;
439     V_inService(vp) = 0;
440     V_maxquota(vp) = 5000;      /* set a quota of 5000 at init time */
441     VUpdateVolume(&error, vp);
442     if (error) {
443         Log("1 Volser: create UpdateVolume failed, code %d\n", error);
444         LogError(error);
445         DeleteTrans(tt, 1);
446         VDetachVolume(&junk, vp);       /* rather return the real error code */
447         return error;
448     }
449     tt->volume = vp;
450     *atrans = tt->tid;
451     strcpy(tt->lastProcName, "CreateVolume");
452     tt->rxCallPtr = acid;
453     Log("1 Volser: CreateVolume: volume %u (%s) created\n", volumeID, aname);
454     tt->rxCallPtr = (struct rx_call *)0;
455     if (TRELE(tt))
456         return VOLSERTRELE_ERROR;
457     return 0;
458 }
459
460 /* delete the volume associated with this transaction */
461 afs_int32
462 SAFSVolDeleteVolume(struct rx_call *acid, afs_int32 atrans)
463 {
464     afs_int32 code;
465
466     code = VolDeleteVolume(acid, atrans);
467     osi_auditU(acid, VS_DelVolEvent, code, AUD_LONG, atrans, AUD_END);
468     return code;
469 }
470
471 afs_int32
472 VolDeleteVolume(struct rx_call *acid, afs_int32 atrans)
473 {
474     register struct volser_trans *tt;
475     afs_int32 error;
476     char caller[MAXKTCNAMELEN];
477
478     if (!afsconf_SuperUser(tdir, acid, caller))
479         return VOLSERBAD_ACCESS;
480     tt = FindTrans(atrans);
481     if (!tt)
482         return ENOENT;
483     if (tt->vflags & VTDeleted) {
484         Log("1 Volser: Delete: volume %u already deleted \n", tt->volid);
485         TRELE(tt);
486         return ENOENT;
487     }
488     if (DoLogging)
489         Log("%s is executing Delete Volume %u\n", caller, tt->volid);
490     strcpy(tt->lastProcName, "DeleteVolume");
491     tt->rxCallPtr = acid;
492     VPurgeVolume(&error, tt->volume);   /* don't check error code, it is not set! */
493     tt->vflags |= VTDeleted;    /* so we know not to do anything else to it */
494     tt->rxCallPtr = (struct rx_call *)0;
495     if (TRELE(tt))
496         return VOLSERTRELE_ERROR;
497
498     Log("1 Volser: Delete: volume %u deleted \n", tt->volid);
499     return 0;                   /* vpurgevolume doesn't set an error code */
500 }
501
502 /* make a clone of the volume associated with atrans, possibly giving it a new
503  * number (allocate a new number if *newNumber==0, otherwise use *newNumber
504  * for the clone's id).  The new clone is given the name newName.  Finally, due to
505  * efficiency considerations, if purgeId is non-zero, we purge that volume when doing
506  * the clone operation.  This may be useful when making new backup volumes, for instance
507  * since the net result of a clone and a purge generally leaves many inode ref counts
508  * the same, while doing them separately would result in far more iincs and idecs being
509  * peformed (and they are slow operations).
510  */
511 /* for efficiency reasons, sometimes faster to piggyback a purge here */
512 afs_int32
513 SAFSVolClone(struct rx_call *acid, afs_int32 atrans, afs_int32 purgeId, 
514              afs_int32 newType, char *newName, afs_int32 *newNumber)
515 {
516     afs_int32 code;
517
518     code = VolClone(acid, atrans, purgeId, newType, newName, newNumber);
519     osi_auditU(acid, VS_CloneEvent, code, AUD_LONG, atrans, AUD_LONG, purgeId,
520                AUD_STR, newName, AUD_LONG, newType, AUD_LONG, *newNumber,
521                AUD_END);
522     return code;
523 }
524
525 afs_int32
526 VolClone(struct rx_call *acid, afs_int32 atrans, afs_int32 purgeId, 
527              afs_int32 newType, char *newName, afs_int32 *newNumber)
528 {
529     VolumeId newId;
530     register struct Volume *originalvp, *purgevp, *newvp;
531     Error error, code;
532     register struct volser_trans *tt, *ttc;
533     char caller[MAXKTCNAMELEN];
534
535     if (strlen(newName) > 31)
536         return VOLSERBADNAME;
537     if (!afsconf_SuperUser(tdir, acid, caller))
538         return VOLSERBAD_ACCESS;        /*not a super user */
539     if (DoLogging)
540         Log("%s is executing Clone Volume new name=%s\n", caller, newName);
541     error = 0;
542     originalvp = (Volume *) 0;
543     purgevp = (Volume *) 0;
544     newvp = (Volume *) 0;
545     tt = ttc = (struct volser_trans *)0;
546
547     if (!newNumber || !*newNumber) {
548         Log("1 Volser: Clone: missing volume number for the clone; aborted\n");
549         goto fail;
550     }
551     newId = *newNumber;
552
553     if (newType != readonlyVolume && newType != backupVolume)
554         return EINVAL;
555     tt = FindTrans(atrans);
556     if (!tt)
557         return ENOENT;
558     if (tt->vflags & VTDeleted) {
559         Log("1 Volser: Clone: volume %u has been deleted \n", tt->volid);
560         TRELE(tt);
561         return ENOENT;
562     }
563     ttc = NewTrans(newId, tt->partition);
564     if (!ttc) {                 /* someone is messing with the clone already */
565         TRELE(tt);
566         return VBUSY;
567     }
568     strcpy(tt->lastProcName, "Clone");
569     tt->rxCallPtr = acid;
570
571
572     if (purgeId) {
573         purgevp = VAttachVolume(&error, purgeId, V_VOLUPD);
574         if (error) {
575             Log("1 Volser: Clone: Could not attach 'purge' volume %u; clone aborted\n", purgeId);
576             goto fail;
577         }
578     } else {
579         purgevp = NULL;
580     }
581     originalvp = tt->volume;
582     if ((V_type(originalvp) == backupVolume)
583         || (V_type(originalvp) == readonlyVolume)) {
584         Log("1 Volser: Clone: The volume to be cloned must be a read/write; aborted\n");
585         error = EROFS;
586         goto fail;
587     }
588     if ((V_destroyMe(originalvp) == DESTROY_ME) || !V_inService(originalvp)) {
589         Log("1 Volser: Clone: Volume %d is offline and cannot be cloned\n",
590             V_id(originalvp));
591         error = VOFFLINE;
592         goto fail;
593     }
594     if (purgevp) {
595         if (originalvp->device != purgevp->device) {
596             Log("1 Volser: Clone: Volumes %u and %u are on different devices\n", tt->volid, purgeId);
597             error = EXDEV;
598             goto fail;
599         }
600         if (V_type(purgevp) != readonlyVolume) {
601             Log("1 Volser: Clone: The \"purge\" volume must be a read only volume; aborted\n");
602             error = EINVAL;
603             goto fail;
604         }
605         if (V_type(originalvp) == readonlyVolume
606             && V_parentId(originalvp) != V_parentId(purgevp)) {
607             Log("1 Volser: Clone: Volume %u and volume %u were not cloned from the same parent volume; aborted\n", tt->volid, purgeId);
608             error = EXDEV;
609             goto fail;
610         }
611         if (V_type(originalvp) == readwriteVolume
612             && tt->volid != V_parentId(purgevp)) {
613             Log("1 Volser: Clone: Volume %u was not originally cloned from volume %u; aborted\n", purgeId, tt->volid);
614             error = EXDEV;
615             goto fail;
616         }
617     }
618
619     error = 0;
620
621     newvp =
622         VCreateVolume(&error, originalvp->partition->name, newId,
623                       V_parentId(originalvp));
624     if (error) {
625         Log("1 Volser: Clone: Couldn't create new volume; clone aborted\n");
626         newvp = (Volume *) 0;
627         goto fail;
628     }
629     if (newType == readonlyVolume)
630         V_cloneId(originalvp) = newId;
631     Log("1 Volser: Clone: Cloning volume %u to new volume %u\n", tt->volid,
632         newId);
633     if (purgevp)
634         Log("1 Volser: Clone: Purging old read only volume %u\n", purgeId);
635     CloneVolume(&error, originalvp, newvp, purgevp);
636     purgevp = NULL;             /* clone releases it, maybe even if error */
637     if (error) {
638         Log("1 Volser: Clone: clone operation failed with code %u\n", error);
639         LogError(error);
640         goto fail;
641     }
642     if (newType == readonlyVolume) {
643         AssignVolumeName(&V_disk(newvp), V_name(originalvp), ".readonly");
644         V_type(newvp) = readonlyVolume;
645     } else if (newType == backupVolume) {
646         AssignVolumeName(&V_disk(newvp), V_name(originalvp), ".backup");
647         V_type(newvp) = backupVolume;
648         V_backupId(originalvp) = newId;
649     }
650     strcpy(newvp->header->diskstuff.name, newName);
651     V_creationDate(newvp) = V_copyDate(newvp);
652     ClearVolumeStats(&V_disk(newvp));
653     V_destroyMe(newvp) = DESTROY_ME;
654     V_inService(newvp) = 0;
655     if (newType == backupVolume) {
656         V_backupDate(originalvp) = V_copyDate(newvp);
657         V_backupDate(newvp) = V_copyDate(newvp);
658     }
659     V_inUse(newvp) = 0;
660     VUpdateVolume(&error, newvp);
661     if (error) {
662         Log("1 Volser: Clone: VUpdate failed code %u\n", error);
663         LogError(error);
664         goto fail;
665     }
666     VDetachVolume(&error, newvp);       /* allow file server to get it's hands on it */
667     newvp = NULL;
668     VUpdateVolume(&error, originalvp);
669     if (error) {
670         Log("1 Volser: Clone: original update %u\n", error);
671         LogError(error);
672         goto fail;
673     }
674     tt->rxCallPtr = (struct rx_call *)0;
675     if (TRELE(tt)) {
676         tt = (struct volser_trans *)0;
677         error = VOLSERTRELE_ERROR;
678         goto fail;
679     }
680     DeleteTrans(ttc, 1);
681     return 0;
682
683   fail:
684     if (purgevp)
685         VDetachVolume(&code, purgevp);
686     if (newvp)
687         VDetachVolume(&code, newvp);
688     if (tt) {
689         tt->rxCallPtr = (struct rx_call *)0;
690         TRELE(tt);
691     }
692     if (ttc)
693         DeleteTrans(ttc, 1);
694     return error;
695 }
696
697 /* reclone this volume into the specified id */
698 afs_int32
699 SAFSVolReClone(struct rx_call *acid, afs_int32 atrans, afs_int32 cloneId)
700 {
701     afs_int32 code;
702
703     code = VolReClone(acid, atrans, cloneId);
704     osi_auditU(acid, VS_ReCloneEvent, code, AUD_LONG, atrans, AUD_LONG,
705                cloneId, AUD_END);
706     return code;
707 }
708
709 afs_int32
710 VolReClone(struct rx_call *acid, afs_int32 atrans, afs_int32 cloneId)
711 {
712     register struct Volume *originalvp, *clonevp;
713     Error error, code;
714     afs_int32 newType;
715     register struct volser_trans *tt, *ttc;
716     char caller[MAXKTCNAMELEN];
717
718     /*not a super user */
719     if (!afsconf_SuperUser(tdir, acid, caller))
720         return VOLSERBAD_ACCESS;
721     if (DoLogging)
722         Log("%s is executing Reclone Volume %u\n", caller, cloneId);
723     error = 0;
724     clonevp = originalvp = (Volume *) 0;
725     tt = (struct volser_trans *)0;
726
727     tt = FindTrans(atrans);
728     if (!tt)
729         return ENOENT;
730     if (tt->vflags & VTDeleted) {
731         Log("1 Volser: VolReClone: volume %u has been deleted \n", tt->volid);
732         TRELE(tt);
733         return ENOENT;
734     }
735     ttc = NewTrans(cloneId, tt->partition);
736     if (!ttc) {                 /* someone is messing with the clone already */
737         TRELE(tt);
738         return VBUSY;
739     }
740     strcpy(tt->lastProcName, "ReClone");
741     tt->rxCallPtr = acid;
742
743     originalvp = tt->volume;
744     if ((V_type(originalvp) == backupVolume)
745         || (V_type(originalvp) == readonlyVolume)) {
746         Log("1 Volser: Clone: The volume to be cloned must be a read/write; aborted\n");
747         error = EROFS;
748         goto fail;
749     }
750     if ((V_destroyMe(originalvp) == DESTROY_ME) || !V_inService(originalvp)) {
751         Log("1 Volser: Clone: Volume %d is offline and cannot be cloned\n",
752             V_id(originalvp));
753         error = VOFFLINE;
754         goto fail;
755     }
756
757     clonevp = VAttachVolume(&error, cloneId, V_VOLUPD);
758     if (error) {
759         Log("1 Volser: can't attach clone %d\n", cloneId);
760         goto fail;
761     }
762
763     newType = V_type(clonevp);  /* type of the new volume */
764
765     if (originalvp->device != clonevp->device) {
766         Log("1 Volser: Clone: Volumes %u and %u are on different devices\n",
767             tt->volid, cloneId);
768         error = EXDEV;
769         goto fail;
770     }
771     if (V_type(clonevp) != readonlyVolume && V_type(clonevp) != backupVolume) {
772         Log("1 Volser: Clone: The \"recloned\" volume must be a read only volume; aborted\n");
773         error = EINVAL;
774         goto fail;
775     }
776     if (V_type(originalvp) == readonlyVolume
777         && V_parentId(originalvp) != V_parentId(clonevp)) {
778         Log("1 Volser: Clone: Volume %u and volume %u were not cloned from the same parent volume; aborted\n", tt->volid, cloneId);
779         error = EXDEV;
780         goto fail;
781     }
782     if (V_type(originalvp) == readwriteVolume
783         && tt->volid != V_parentId(clonevp)) {
784         Log("1 Volser: Clone: Volume %u was not originally cloned from volume %u; aborted\n", cloneId, tt->volid);
785         error = EXDEV;
786         goto fail;
787     }
788
789     error = 0;
790     Log("1 Volser: Clone: Recloning volume %u to volume %u\n", tt->volid,
791         cloneId);
792     CloneVolume(&error, originalvp, clonevp, clonevp);
793     if (error) {
794         Log("1 Volser: Clone: reclone operation failed with code %d\n",
795             error);
796         LogError(error);
797         goto fail;
798     }
799
800     /* fix up volume name and type, CloneVolume just propagated RW's */
801     if (newType == readonlyVolume) {
802         AssignVolumeName(&V_disk(clonevp), V_name(originalvp), ".readonly");
803         V_type(clonevp) = readonlyVolume;
804     } else if (newType == backupVolume) {
805         AssignVolumeName(&V_disk(clonevp), V_name(originalvp), ".backup");
806         V_type(clonevp) = backupVolume;
807         V_backupId(originalvp) = cloneId;
808     }
809     /* don't do strcpy onto diskstuff.name, it's still OK from 1st clone */
810
811     /* pretend recloned volume is a totally new instance */
812     V_copyDate(clonevp) = time(0);
813     V_creationDate(clonevp) = V_copyDate(clonevp);
814     ClearVolumeStats(&V_disk(clonevp));
815     V_destroyMe(clonevp) = 0;
816     V_inService(clonevp) = 0;
817     if (newType == backupVolume) {
818         V_backupDate(originalvp) = V_copyDate(clonevp);
819         V_backupDate(clonevp) = V_copyDate(clonevp);
820     }
821     V_inUse(clonevp) = 0;
822     VUpdateVolume(&error, clonevp);
823     if (error) {
824         Log("1 Volser: Clone: VUpdate failed code %u\n", error);
825         LogError(error);
826         goto fail;
827     }
828     VDetachVolume(&error, clonevp);     /* allow file server to get it's hands on it */
829     clonevp = NULL;
830     VUpdateVolume(&error, originalvp);
831     if (error) {
832         Log("1 Volser: Clone: original update %u\n", error);
833         LogError(error);
834         goto fail;
835     }
836     tt->rxCallPtr = (struct rx_call *)0;
837     if (TRELE(tt)) {
838         tt = (struct volser_trans *)0;
839         error = VOLSERTRELE_ERROR;
840         goto fail;
841     }
842
843     DeleteTrans(ttc, 1);
844
845     {
846         struct DiskPartition *tpartp = originalvp->partition;
847         FSYNC_askfs(cloneId, tpartp->name, FSYNC_RESTOREVOLUME, 0);
848     }
849     return 0;
850
851   fail:
852     if (clonevp)
853         VDetachVolume(&code, clonevp);
854     if (tt) {
855         tt->rxCallPtr = (struct rx_call *)0;
856         TRELE(tt);
857     }
858     if (ttc)
859         DeleteTrans(ttc, 1);
860     return error;
861 }
862
863 /* create a new transaction, associated with volume and partition.  Type of
864  * volume transaction is spec'd by iflags.  New trans id is returned in ttid.
865  * See volser.h for definition of iflags (the constants are named IT*).
866  */
867 afs_int32
868 SAFSVolTransCreate(struct rx_call *acid, afs_int32 volume, afs_int32 partition,
869                    afs_int32 iflags, afs_int32 *ttid)
870 {
871     afs_int32 code;
872
873     code = VolTransCreate(acid, volume, partition, iflags, ttid);
874     osi_auditU(acid, VS_TransCrEvent, code, AUD_LONG, *ttid, AUD_LONG, volume,
875                AUD_END);
876     return code;
877 }
878
879 afs_int32
880 VolTransCreate(struct rx_call *acid, afs_int32 volume, afs_int32 partition,
881                    afs_int32 iflags, afs_int32 *ttid)
882 {
883     register struct volser_trans *tt;
884     register Volume *tv;
885     afs_int32 error, code;
886     afs_int32 mode;
887     char caller[MAXKTCNAMELEN];
888
889     if (!afsconf_SuperUser(tdir, acid, caller))
890         return VOLSERBAD_ACCESS;        /*not a super user */
891     if (iflags & ITCreate)
892         mode = V_SECRETLY;
893     else if (iflags & ITBusy)
894         mode = V_CLONE;
895     else if (iflags & ITReadOnly)
896         mode = V_READONLY;
897     else if (iflags & ITOffline)
898         mode = V_VOLUPD;
899     else {
900         Log("1 Volser: TransCreate: Could not create trans, error %u\n",
901             EINVAL);
902         LogError(EINVAL);
903         return EINVAL;
904     }
905     tt = NewTrans(volume, partition);
906     if (!tt) {
907         /* can't create a transaction? put the volume back */
908         Log("1 transcreate: can't create transaction\n");
909         return VOLSERVOLBUSY;
910     }
911     tv = XAttachVolume(&error, volume, partition, mode);
912     if (error) {
913         /* give up */
914         if (tv)
915             VDetachVolume(&code, tv);
916         DeleteTrans(tt, 1);
917         return error;
918     }
919     tt->volume = tv;
920     *ttid = tt->tid;
921     tt->iflags = iflags;
922     tt->vflags = 0;
923     strcpy(tt->lastProcName, "TransCreate");
924     if (TRELE(tt))
925         return VOLSERTRELE_ERROR;
926
927     return 0;
928 }
929
930 /* using aindex as a 0-based index, return the aindex'th volume on this server
931  * Both the volume number and partition number (one-based) are returned.
932  */
933 afs_int32
934 SAFSVolGetNthVolume(struct rx_call *acid, afs_int32 aindex, afs_int32 *avolume,
935                     afs_int32 *apart)
936 {
937     afs_int32 code;
938
939     code = VolGetNthVolume(acid, aindex, avolume, apart);
940     osi_auditU(acid, VS_GetNVolEvent, code, AUD_LONG, *avolume, AUD_END);
941     return code;
942 }
943
944 afs_int32
945 VolGetNthVolume(struct rx_call *acid, afs_int32 aindex, afs_int32 *avolume,
946                     afs_int32 *apart)
947 {
948     Log("1 Volser: GetNthVolume: Not yet implemented\n");
949     return VOLSERNO_OP;
950 }
951
952 /* return the volume flags (VT* constants in volser.h) associated with this
953  * transaction.
954  */
955 afs_int32
956 SAFSVolGetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 *aflags)
957 {
958     afs_int32 code;
959
960     code = VolGetFlags(acid, atid, aflags);
961     osi_auditU(acid, VS_GetFlgsEvent, code, AUD_LONG, atid, AUD_END);
962     return code;
963 }
964
965 afs_int32
966 VolGetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 *aflags)
967 {
968     register struct volser_trans *tt;
969
970     tt = FindTrans(atid);
971     if (!tt)
972         return ENOENT;
973     if (tt->vflags & VTDeleted) {
974         Log("1 Volser: VolGetFlags: volume %u has been deleted \n",
975             tt->volid);
976         TRELE(tt);
977         return ENOENT;
978     }
979     strcpy(tt->lastProcName, "GetFlags");
980     tt->rxCallPtr = acid;
981     *aflags = tt->vflags;
982     tt->rxCallPtr = (struct rx_call *)0;
983     if (TRELE(tt))
984         return VOLSERTRELE_ERROR;
985
986     return 0;
987 }
988
989 /* Change the volume flags (VT* constants in volser.h) associated with this
990  * transaction.  Effects take place immediately on volume, although volume
991  * remains attached as usual by the transaction.
992  */
993 afs_int32
994 SAFSVolSetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 aflags)
995 {
996     afs_int32 code;
997
998     code = VolSetFlags(acid, atid, aflags);
999     osi_auditU(acid, VS_SetFlgsEvent, code, AUD_LONG, atid, AUD_LONG, aflags,
1000                AUD_END);
1001     return code;
1002 }
1003
1004 afs_int32
1005 VolSetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 aflags)
1006 {
1007     register struct volser_trans *tt;
1008     register struct Volume *vp;
1009     afs_int32 error;
1010     char caller[MAXKTCNAMELEN];
1011
1012     if (!afsconf_SuperUser(tdir, acid, caller))
1013         return VOLSERBAD_ACCESS;        /*not a super user */
1014     /* find the trans */
1015     tt = FindTrans(atid);
1016     if (!tt)
1017         return ENOENT;
1018     if (tt->vflags & VTDeleted) {
1019         Log("1 Volser: VolSetFlags: volume %u has been deleted \n",
1020             tt->volid);
1021         TRELE(tt);
1022         return ENOENT;
1023     }
1024     strcpy(tt->lastProcName, "SetFlags");
1025     tt->rxCallPtr = acid;
1026     vp = tt->volume;            /* pull volume out of transaction */
1027
1028     /* check if we're allowed to make any updates */
1029     if (tt->iflags & ITReadOnly) {
1030         TRELE(tt);
1031         return EROFS;
1032     }
1033
1034     /* handle delete-on-salvage flag */
1035     if (aflags & VTDeleteOnSalvage) {
1036         V_destroyMe(tt->volume) = DESTROY_ME;
1037     } else {
1038         V_destroyMe(tt->volume) = 0;
1039     }
1040
1041     if (aflags & VTOutOfService) {
1042         V_inService(vp) = 0;
1043     } else {
1044         V_inService(vp) = 1;
1045     }
1046     VUpdateVolume(&error, vp);
1047     tt->vflags = aflags;
1048     tt->rxCallPtr = (struct rx_call *)0;
1049     if (TRELE(tt) && !error)
1050         return VOLSERTRELE_ERROR;
1051
1052     return error;
1053 }
1054
1055 /* dumpS the volume associated with a particular transaction from a particular
1056  * date.  Send the dump to a different transaction (destTrans) on the server
1057  * specified by the destServer structure.
1058  */
1059 afs_int32
1060 SAFSVolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
1061                struct destServer *destination, afs_int32 destTrans, 
1062                struct restoreCookie *cookie)
1063 {
1064     afs_int32 code;
1065
1066     code =
1067         VolForward(acid, fromTrans, fromDate, destination, destTrans, cookie);
1068     osi_auditU(acid, VS_ForwardEvent, code, AUD_LONG, fromTrans, AUD_HOST,
1069                destination->destHost, AUD_LONG, destTrans, AUD_END);
1070     return code;
1071 }
1072
1073 afs_int32
1074 VolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
1075                struct destServer *destination, afs_int32 destTrans, 
1076                struct restoreCookie *cookie)
1077 {
1078     register struct volser_trans *tt;
1079     register afs_int32 code;
1080     register struct rx_connection *tcon;
1081     struct rx_call *tcall;
1082     register struct Volume *vp;
1083     struct rx_securityClass *securityObject;
1084     afs_int32 securityIndex;
1085     char caller[MAXKTCNAMELEN];
1086
1087     if (!afsconf_SuperUser(tdir, acid, caller))
1088         return VOLSERBAD_ACCESS;        /*not a super user */
1089     /* initialize things */
1090     tcon = (struct rx_connection *)0;
1091     tt = (struct volser_trans *)0;
1092
1093     /* find the local transaction */
1094     tt = FindTrans(fromTrans);
1095     if (!tt)
1096         return ENOENT;
1097     if (tt->vflags & VTDeleted) {
1098         Log("1 Volser: VolForward: volume %u has been deleted \n", tt->volid);
1099         TRELE(tt);
1100         return ENOENT;
1101     }
1102     vp = tt->volume;
1103     strcpy(tt->lastProcName, "Forward");
1104
1105     /* get auth info for the this connection (uses afs from ticket file) */
1106     code = afsconf_ClientAuth(tdir, &securityObject, &securityIndex);
1107     if (code) {
1108         TRELE(tt);
1109         return code;
1110     }
1111
1112     /* make an rpc connection to the other server */
1113     tcon =
1114         rx_NewConnection(htonl(destination->destHost),
1115                          htons(destination->destPort), VOLSERVICE_ID,
1116                          securityObject, securityIndex);
1117     if (!tcon) {
1118         tt->rxCallPtr = (struct rx_call *)0;
1119         TRELE(tt);
1120         return ENOTCONN;
1121     }
1122     tcall = rx_NewCall(tcon);
1123     tt->rxCallPtr = tcall;
1124     /* start restore going.  fromdate == 0 --> doing an incremental dump/restore */
1125     code = StartAFSVolRestore(tcall, destTrans, (fromDate ? 1 : 0), cookie);
1126     if (code) {
1127         goto fail;
1128     }
1129
1130     /* these next calls implictly call rx_Write when writing out data */
1131     code = DumpVolume(tcall, vp, fromDate, 0);  /* last field = don't dump all dirs */
1132     if (code)
1133         goto fail;
1134     EndAFSVolRestore(tcall);    /* probably doesn't do much */
1135     tt->rxCallPtr = (struct rx_call *)0;
1136     code = rx_EndCall(tcall, 0);
1137     rx_DestroyConnection(tcon); /* done with the connection */
1138     tcon = NULL;
1139     if (code)
1140         goto fail;
1141     if (TRELE(tt))
1142         return VOLSERTRELE_ERROR;
1143
1144     return 0;
1145
1146   fail:
1147     if (tcon) {
1148         (void)rx_EndCall(tcall, 0);
1149         rx_DestroyConnection(tcon);
1150     }
1151     if (tt) {
1152         tt->rxCallPtr = (struct rx_call *)0;
1153         TRELE(tt);
1154     }
1155     return code;
1156 }
1157
1158 /* Start a dump and send it to multiple places simultaneously.
1159  * If this returns an error (eg, return ENOENT), it means that
1160  * none of the releases worked.  If this returns 0, that means 
1161  * that one or more of the releases worked, and the caller has
1162  * to examine the results array to see which one(s).
1163  * This will only do EITHER incremental or full, not both, so it's
1164  * the caller's responsibility to be sure that all the destinations
1165  * need just an incremental (and from the same time), if that's 
1166  * what we're doing. 
1167  */
1168 afs_int32
1169 SAFSVolForwardMultiple(struct rx_call *acid, afs_int32 fromTrans, afs_int32 
1170                        fromDate, manyDests *destinations, afs_int32 spare,
1171                        struct restoreCookie *cookie, manyResults *results)
1172 {
1173     afs_int32 securityIndex;
1174     struct rx_securityClass *securityObject;
1175     char caller[MAXKTCNAMELEN];
1176     struct volser_trans *tt;
1177     afs_int32 ec, code, *codes;
1178     struct rx_connection **tcons;
1179     struct rx_call **tcalls;
1180     struct Volume *vp;
1181     int i, is_incremental;
1182
1183     if (results)
1184         memset(results, 0, sizeof(manyResults));
1185
1186     if (!afsconf_SuperUser(tdir, acid, caller))
1187         return VOLSERBAD_ACCESS;        /*not a super user */
1188     tt = FindTrans(fromTrans);
1189     if (!tt)
1190         return ENOENT;
1191     if (tt->vflags & VTDeleted) {
1192         Log("1 Volser: VolForward: volume %u has been deleted \n", tt->volid);
1193         TRELE(tt);
1194         return ENOENT;
1195     }
1196     vp = tt->volume;
1197     strcpy(tt->lastProcName, "ForwardMulti");
1198
1199     /* (fromDate == 0) ==> incremental dump */
1200     is_incremental = (fromDate ? 1 : 0);
1201
1202     i = results->manyResults_len = destinations->manyDests_len;
1203     results->manyResults_val = codes =
1204         (afs_int32 *) malloc(i * sizeof(afs_int32));
1205     tcons =
1206         (struct rx_connection **)malloc(i * sizeof(struct rx_connection *));
1207     tcalls = (struct rx_call **)malloc(i * sizeof(struct rx_call *));
1208
1209     /* get auth info for this connection (uses afs from ticket file) */
1210     code = afsconf_ClientAuth(tdir, &securityObject, &securityIndex);
1211     if (code) {
1212         goto fail;              /* in order to audit each failure */
1213     }
1214
1215     /* make connections to all the other servers */
1216     for (i = 0; i < destinations->manyDests_len; i++) {
1217         struct replica *dest = &(destinations->manyDests_val[i]);
1218         tcons[i] =
1219             rx_NewConnection(htonl(dest->server.destHost),
1220                              htons(dest->server.destPort), VOLSERVICE_ID,
1221                              securityObject, securityIndex);
1222         if (!tcons[i]) {
1223             codes[i] = ENOTCONN;
1224         } else {
1225             if (!(tcalls[i] = rx_NewCall(tcons[i])))
1226                 codes[i] = ENOTCONN;
1227             else {
1228                 codes[i] =
1229                     StartAFSVolRestore(tcalls[i], dest->trans, is_incremental,
1230                                        cookie);
1231                 if (codes[i]) {
1232                     (void)rx_EndCall(tcalls[i], 0);
1233                     tcalls[i] = 0;
1234                     rx_DestroyConnection(tcons[i]);
1235                     tcons[i] = 0;
1236                 }
1237             }
1238         }
1239     }
1240
1241     /* these next calls implictly call rx_Write when writing out data */
1242     code = DumpVolMulti(tcalls, i, vp, fromDate, 0, codes);
1243
1244
1245   fail:
1246     for (i--; i >= 0; i--) {
1247         struct replica *dest = &(destinations->manyDests_val[i]);
1248
1249         if (!code && tcalls[i] && !codes[i]) {
1250             EndAFSVolRestore(tcalls[i]);
1251         }
1252         if (tcalls[i]) {
1253             ec = rx_EndCall(tcalls[i], 0);
1254             if (!codes[i])
1255                 codes[i] = ec;
1256         }
1257         if (tcons[i]) {
1258             rx_DestroyConnection(tcons[i]);     /* done with the connection */
1259         }
1260
1261         osi_auditU(acid, VS_ForwardEvent, (code ? code : codes[i]), AUD_LONG,
1262                    fromTrans, AUD_HOST, dest->server.destHost, AUD_LONG,
1263                    dest->trans, AUD_END);
1264     }
1265     free(tcons);
1266     free(tcalls);
1267
1268     if (tt) {
1269         tt->rxCallPtr = (struct rx_call *)0;
1270         if (TRELE(tt) && !code) /* return the first code if it's set */
1271             return VOLSERTRELE_ERROR;
1272     }
1273
1274     return code;
1275 }
1276
1277 afs_int32
1278 SAFSVolDump(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate)
1279 {
1280     afs_int32 code;
1281
1282     code = VolDump(acid, fromTrans, fromDate);
1283     osi_auditU(acid, VS_DumpEvent, code, AUD_LONG, fromTrans, AUD_END);
1284     return code;
1285 }
1286
1287 afs_int32
1288 VolDump(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate)
1289 {
1290     int code = 0;
1291     register struct volser_trans *tt;
1292     char caller[MAXKTCNAMELEN];
1293
1294     if (!afsconf_SuperUser(tdir, acid, caller))
1295         return VOLSERBAD_ACCESS;        /*not a super user */
1296     tt = FindTrans(fromTrans);
1297     if (!tt)
1298         return ENOENT;
1299     if (tt->vflags & VTDeleted) {
1300         Log("1 Volser: VolDump: volume %u has been deleted \n", tt->volid);
1301         TRELE(tt);
1302         return ENOENT;
1303     }
1304     strcpy(tt->lastProcName, "Dump");
1305     tt->rxCallPtr = acid;
1306     code = DumpVolume(acid, tt->volume, fromDate, 1);   /* squirt out the volume's data, too */
1307     if (code) {
1308         tt->rxCallPtr = (struct rx_call *)0;
1309         TRELE(tt);
1310         return code;
1311     }
1312     tt->rxCallPtr = (struct rx_call *)0;
1313
1314     if (TRELE(tt))
1315         return VOLSERTRELE_ERROR;
1316
1317     return 0;
1318 }
1319
1320 /* 
1321  * Ha!  No more helper process!
1322  */
1323 afs_int32
1324 SAFSVolRestore(struct rx_call *acid, afs_int32 atrans, afs_int32 aflags, 
1325                struct restoreCookie *cookie)
1326 {
1327     afs_int32 code;
1328
1329     code = VolRestore(acid, atrans, aflags, cookie);
1330     osi_auditU(acid, VS_RestoreEvent, code, AUD_LONG, atrans, AUD_END);
1331     return code;
1332 }
1333
1334 afs_int32
1335 VolRestore(struct rx_call *acid, afs_int32 atrans, afs_int32 aflags, 
1336                struct restoreCookie *cookie)
1337 {
1338     register struct volser_trans *tt;
1339     register afs_int32 code, tcode;
1340     char caller[MAXKTCNAMELEN];
1341
1342     if (!afsconf_SuperUser(tdir, acid, caller))
1343         return VOLSERBAD_ACCESS;        /*not a super user */
1344     tt = FindTrans(atrans);
1345     if (!tt)
1346         return ENOENT;
1347     if (tt->vflags & VTDeleted) {
1348         Log("1 Volser: VolRestore: volume %u has been deleted \n", tt->volid);
1349         TRELE(tt);
1350         return ENOENT;
1351     }
1352     strcpy(tt->lastProcName, "Restore");
1353     tt->rxCallPtr = acid;
1354
1355     DFlushVolume(V_parentId(tt->volume)); /* Ensure dir buffers get dropped */
1356
1357     code = RestoreVolume(acid, tt->volume, (aflags & 1), cookie);       /* last is incrementalp */
1358     FSYNC_askfs(tt->volid, NULL, FSYNC_RESTOREVOLUME, 0l);      /*break call backs on the
1359                                                                  * restored volume */
1360     tt->rxCallPtr = (struct rx_call *)0;
1361     tcode = TRELE(tt);
1362
1363     return (code ? code : tcode);
1364 }
1365
1366 /* end a transaction, returning the transaction's final error code in rcode */
1367 afs_int32
1368 SAFSVolEndTrans(struct rx_call *acid, afs_int32 destTrans, afs_int32 *rcode)
1369 {
1370     afs_int32 code;
1371
1372     code = VolEndTrans(acid, destTrans, rcode);
1373     osi_auditU(acid, VS_EndTrnEvent, code, AUD_LONG, destTrans, AUD_END);
1374     return code;
1375 }
1376
1377 afs_int32
1378 VolEndTrans(struct rx_call *acid, afs_int32 destTrans, afs_int32 *rcode)
1379 {
1380     register struct volser_trans *tt;
1381     char caller[MAXKTCNAMELEN];
1382
1383     if (!afsconf_SuperUser(tdir, acid, caller))
1384         return VOLSERBAD_ACCESS;        /*not a super user */
1385     tt = FindTrans(destTrans);
1386     if (!tt) {
1387         return ENOENT;
1388     }
1389     *rcode = tt->returnCode;
1390     DeleteTrans(tt, 1);         /* this does an implicit TRELE */
1391
1392     return 0;
1393 }
1394
1395 afs_int32
1396 SAFSVolSetForwarding(struct rx_call *acid, afs_int32 atid, afs_int32 anewsite)
1397 {
1398     afs_int32 code;
1399
1400     code = VolSetForwarding(acid, atid, anewsite);
1401     osi_auditU(acid, VS_SetForwEvent, code, AUD_LONG, atid, AUD_HOST,
1402                anewsite, AUD_END);
1403     return code;
1404 }
1405
1406 afs_int32
1407 VolSetForwarding(struct rx_call *acid, afs_int32 atid, afs_int32 anewsite)
1408 {
1409     register struct volser_trans *tt;
1410     char caller[MAXKTCNAMELEN];
1411
1412     if (!afsconf_SuperUser(tdir, acid, caller))
1413         return VOLSERBAD_ACCESS;        /*not a super user */
1414     tt = FindTrans(atid);
1415     if (!tt)
1416         return ENOENT;
1417     if (tt->vflags & VTDeleted) {
1418         Log("1 Volser: VolSetForwarding: volume %u has been deleted \n",
1419             tt->volid);
1420         TRELE(tt);
1421         return ENOENT;
1422     }
1423     strcpy(tt->lastProcName, "SetForwarding");
1424     tt->rxCallPtr = acid;
1425     FSYNC_askfs(tt->volid, NULL, FSYNC_MOVEVOLUME, anewsite);
1426     tt->rxCallPtr = (struct rx_call *)0;
1427     if (TRELE(tt))
1428         return VOLSERTRELE_ERROR;
1429
1430     return 0;
1431 }
1432
1433 afs_int32
1434 SAFSVolGetStatus(struct rx_call *acid, afs_int32 atrans, 
1435                  register struct volser_status *astatus)
1436 {
1437     afs_int32 code;
1438
1439     code = VolGetStatus(acid, atrans, astatus);
1440     osi_auditU(acid, VS_GetStatEvent, code, AUD_LONG, atrans, AUD_END);
1441     return code;
1442 }
1443
1444 afs_int32
1445 VolGetStatus(struct rx_call *acid, afs_int32 atrans, 
1446                  register struct volser_status *astatus)
1447 {
1448     register struct Volume *tv;
1449     register struct VolumeDiskData *td;
1450     struct volser_trans *tt;
1451
1452
1453     tt = FindTrans(atrans);
1454     if (!tt)
1455         return ENOENT;
1456     if (tt->vflags & VTDeleted) {
1457         Log("1 Volser: VolGetStatus: volume %u has been deleted \n",
1458             tt->volid);
1459         TRELE(tt);
1460         return ENOENT;
1461     }
1462     strcpy(tt->lastProcName, "GetStatus");
1463     tt->rxCallPtr = acid;
1464     tv = tt->volume;
1465     if (!tv) {
1466         tt->rxCallPtr = (struct rx_call *)0;
1467         TRELE(tt);
1468         return ENOENT;
1469     }
1470
1471     td = &tv->header->diskstuff;
1472     astatus->volID = td->id;
1473     astatus->nextUnique = td->uniquifier;
1474     astatus->type = td->type;
1475     astatus->parentID = td->parentId;
1476     astatus->cloneID = td->cloneId;
1477     astatus->backupID = td->backupId;
1478     astatus->restoredFromID = td->restoredFromId;
1479     astatus->maxQuota = td->maxquota;
1480     astatus->minQuota = td->minquota;
1481     astatus->owner = td->owner;
1482     astatus->creationDate = td->creationDate;
1483     astatus->accessDate = td->accessDate;
1484     astatus->updateDate = td->updateDate;
1485     astatus->expirationDate = td->expirationDate;
1486     astatus->backupDate = td->backupDate;
1487     astatus->copyDate = td->copyDate;
1488     tt->rxCallPtr = (struct rx_call *)0;
1489     if (TRELE(tt))
1490         return VOLSERTRELE_ERROR;
1491
1492     return 0;
1493 }
1494
1495 afs_int32
1496 SAFSVolSetInfo(struct rx_call *acid, afs_int32 atrans, 
1497                register struct volintInfo *astatus)
1498 {
1499     afs_int32 code;
1500
1501     code = VolSetInfo(acid, atrans, astatus);
1502     osi_auditU(acid, VS_SetInfoEvent, code, AUD_LONG, atrans, AUD_END);
1503     return code;
1504 }
1505
1506 afs_int32
1507 VolSetInfo(struct rx_call *acid, afs_int32 atrans, 
1508                register struct volintInfo *astatus)
1509 {
1510     register struct Volume *tv;
1511     register struct VolumeDiskData *td;
1512     struct volser_trans *tt;
1513     char caller[MAXKTCNAMELEN];
1514     afs_int32 error;
1515
1516     if (!afsconf_SuperUser(tdir, acid, caller))
1517         return VOLSERBAD_ACCESS;        /*not a super user */
1518     tt = FindTrans(atrans);
1519     if (!tt)
1520         return ENOENT;
1521     if (tt->vflags & VTDeleted) {
1522         Log("1 Volser: VolSetInfo: volume %u has been deleted \n", tt->volid);
1523         TRELE(tt);
1524         return ENOENT;
1525     }
1526     strcpy(tt->lastProcName, "SetStatus");
1527     tt->rxCallPtr = acid;
1528     tv = tt->volume;
1529     if (!tv) {
1530         tt->rxCallPtr = (struct rx_call *)0;
1531         TRELE(tt);
1532         return ENOENT;
1533     }
1534
1535     td = &tv->header->diskstuff;
1536     /*
1537      * Add more fields as necessary
1538      */
1539     if (astatus->maxquota != -1)
1540         td->maxquota = astatus->maxquota;
1541     if (astatus->dayUse != -1)
1542         td->dayUse = astatus->dayUse;
1543     if (astatus->creationDate != -1)
1544         td->creationDate = astatus->creationDate;
1545     if (astatus->updateDate != -1)
1546         td->updateDate = astatus->updateDate;
1547     if (astatus->spare2 != -1)
1548         td->volUpdateCounter = (unsigned int)astatus->spare2;
1549     VUpdateVolume(&error, tv);
1550     tt->rxCallPtr = (struct rx_call *)0;
1551     if (TRELE(tt))
1552         return VOLSERTRELE_ERROR;
1553     return 0;
1554 }
1555
1556
1557 afs_int32
1558 SAFSVolGetName(struct rx_call *acid, afs_int32 atrans, char **aname)
1559 {
1560     afs_int32 code;
1561
1562     code = VolGetName(acid, atrans, aname);
1563     osi_auditU(acid, VS_GetNameEvent, code, AUD_LONG, atrans, AUD_END);
1564     return code;
1565 }
1566
1567 afs_int32
1568 VolGetName(struct rx_call *acid, afs_int32 atrans, char **aname)
1569 {
1570     register struct Volume *tv;
1571     register struct VolumeDiskData *td;
1572     struct volser_trans *tt;
1573     register int len;
1574
1575     *aname = NULL;
1576     tt = FindTrans(atrans);
1577     if (!tt)
1578         return ENOENT;
1579     if (tt->vflags & VTDeleted) {
1580         Log("1 Volser: VolGetName: volume %u has been deleted \n", tt->volid);
1581         TRELE(tt);
1582         return ENOENT;
1583     }
1584     strcpy(tt->lastProcName, "GetName");
1585     tt->rxCallPtr = acid;
1586     tv = tt->volume;
1587     if (!tv) {
1588         tt->rxCallPtr = (struct rx_call *)0;
1589         TRELE(tt);
1590         return ENOENT;
1591     }
1592
1593     td = &tv->header->diskstuff;
1594     len = strlen(td->name) + 1; /* don't forget the null */
1595     if (len >= SIZE) {
1596         tt->rxCallPtr = (struct rx_call *)0;
1597         TRELE(tt);
1598         return E2BIG;
1599     }
1600     *aname = (char *)malloc(len);
1601     strcpy(*aname, td->name);
1602     tt->rxCallPtr = (struct rx_call *)0;
1603     if (TRELE(tt))
1604         return VOLSERTRELE_ERROR;
1605
1606     return 0;
1607 }
1608
1609 /*this is a handshake to indicate that the next call will be SAFSVolRestore
1610  * - a noop now !*/
1611 afs_int32
1612 SAFSVolSignalRestore(struct rx_call *acid, char volname[], int volType, 
1613                      afs_int32 parentId, afs_int32 cloneId)
1614 {
1615     return 0;
1616 }
1617
1618
1619 /*return a list of all partitions on the server. The non mounted
1620  *partitions are returned as -1 in the corresponding slot in partIds*/
1621 afs_int32
1622 SAFSVolListPartitions(struct rx_call *acid, struct pIDs *partIds)
1623 {
1624     afs_int32 code;
1625
1626     code = VolListPartitions(acid, partIds);
1627     osi_auditU(acid, VS_ListParEvent, code, AUD_END);
1628     return code;
1629 }
1630
1631 afs_int32
1632 VolListPartitions(struct rx_call *acid, struct pIDs *partIds)
1633 {
1634     char namehead[9];
1635     char i;
1636
1637     strcpy(namehead, "/vicep"); /*7 including null terminator */
1638
1639     /* Just return attached partitions. */
1640     namehead[7] = '\0';
1641     for (i = 0; i < 26; i++) {
1642         namehead[6] = i + 'a';
1643         if (VGetPartition(namehead, 0))
1644             partIds->partIds[i] = VGetPartition(namehead, 0) ? i : -1;
1645     }
1646
1647     return 0;
1648 }
1649
1650 /*return a list of all partitions on the server. The non mounted
1651  *partitions are returned as -1 in the corresponding slot in partIds*/
1652 afs_int32
1653 SAFSVolXListPartitions(struct rx_call *acid, struct partEntries *pEntries)
1654 {
1655     afs_int32 code;
1656
1657     code = XVolListPartitions(acid, pEntries);
1658     osi_auditU(acid, VS_ListParEvent, code, AUD_END);
1659     return code;
1660 }
1661
1662 afs_int32
1663 XVolListPartitions(struct rx_call *acid, struct partEntries *pEntries)
1664 {
1665     struct stat rbuf, pbuf;
1666     char namehead[9];
1667     struct partList partList;
1668     struct DiskPartition *dp;
1669     int i, j = 0, k;
1670
1671     strcpy(namehead, "/vicep"); /*7 including null terminator */
1672
1673     /* Only report attached partitions */
1674     for (i = 0; i < VOLMAXPARTS; i++) {
1675         if (i < 26) {
1676             namehead[6] = i + 'a';
1677             namehead[7] = '\0';
1678         } else {
1679             k = i - 26;
1680             namehead[6] = 'a' + (k / 26);
1681             namehead[7] = 'a' + (k % 26);
1682             namehead[8] = '\0';
1683         }
1684         dp = VGetPartition(namehead, 0);
1685         if (dp)
1686             partList.partId[j++] = i;
1687     }
1688     pEntries->partEntries_val = (afs_int32 *) malloc(j * sizeof(int));
1689     memcpy((char *)pEntries->partEntries_val, (char *)&partList,
1690            j * sizeof(int));
1691     pEntries->partEntries_len = j;
1692     return 0;
1693
1694 }
1695
1696 /*extract the volume id from string vname. Its of the form " V0*<id>.vol  "*/
1697 afs_int32
1698 ExtractVolId(char vname[])
1699 {
1700     int i;
1701     char name[VOLSER_MAXVOLNAME + 1];
1702
1703     strcpy(name, vname);
1704     i = 0;
1705     while (name[i] == 'V' || name[i] == '0')
1706         i++;
1707
1708     name[11] = '\0';            /* smash the "." */
1709     return (atol(&name[i]));
1710 }
1711
1712 /*return the name of the next volume header in the directory associated with dirp and dp.
1713 *the volume id is  returned in volid, and volume header name is returned in volname*/
1714 int
1715 GetNextVol(DIR * dirp, char *volname, afs_int32 * volid)
1716 {
1717     struct dirent *dp;
1718
1719     dp = readdir(dirp);         /*read next entry in the directory */
1720     if (dp) {
1721         if ((dp->d_name[0] == 'V') && !strcmp(&(dp->d_name[11]), VHDREXT)) {
1722             *volid = ExtractVolId(dp->d_name);
1723             strcpy(volname, dp->d_name);
1724             return 0;           /*return the name of the file representing a volume */
1725         } else {
1726             strcpy(volname, "");
1727             return 0;           /*volname doesnot represent a volume */
1728         }
1729     } else {
1730         strcpy(volname, "EOD");
1731         return 0;               /*end of directory */
1732     }
1733
1734 }
1735
1736 /*return the header information about the <volid> */
1737 afs_int32
1738 SAFSVolListOneVolume(struct rx_call *acid, afs_int32 partid, afs_int32 
1739                      volumeId, volEntries *volumeInfo)
1740 {
1741     afs_int32 code;
1742
1743     code = VolListOneVolume(acid, partid, volumeId, volumeInfo);
1744     osi_auditU(acid, VS_Lst1VolEvent, code, AUD_LONG, volumeId, AUD_END);
1745     return code;
1746 }
1747
1748 afs_int32
1749 VolListOneVolume(struct rx_call *acid, afs_int32 partid, afs_int32 
1750                      volumeId, volEntries *volumeInfo)
1751 {
1752     volintInfo *pntr;
1753     register struct Volume *tv;
1754     struct DiskPartition *partP;
1755     struct volser_trans *ttc;
1756     char pname[9], volname[20];
1757     afs_int32 error = 0;
1758     DIR *dirp;
1759     afs_int32 volid;
1760     int found = 0;
1761     unsigned int now;
1762
1763     volumeInfo->volEntries_val = (volintInfo *) malloc(sizeof(volintInfo));
1764     pntr = volumeInfo->volEntries_val;
1765     volumeInfo->volEntries_len = 1;
1766     if (GetPartName(partid, pname))
1767         return VOLSERILLEGAL_PARTITION;
1768     if (!(partP = VGetPartition(pname, 0)))
1769         return VOLSERILLEGAL_PARTITION;
1770     dirp = opendir(VPartitionPath(partP));
1771     if (dirp == NULL)
1772         return VOLSERILLEGAL_PARTITION;
1773     strcpy(volname, "");
1774     ttc = (struct volser_trans *)0;
1775     tv = (Volume *) 0;          /* volume not attached */
1776
1777     while (strcmp(volname, "EOD") && !found) {  /*while there are more volumes in the partition */
1778
1779         if (!strcmp(volname, "")) {     /* its not a volume, fetch next file */
1780             GetNextVol(dirp, volname, &volid);
1781             continue;           /*back to while loop */
1782         }
1783
1784         if (volid == volumeId) {        /*copy other things too */
1785             found = 1;
1786 #ifndef AFS_PTHREAD_ENV
1787             IOMGR_Poll();       /*make sure that the client doesnot time out */
1788 #endif
1789             ttc = NewTrans(volid, partid);
1790             if (!ttc) {
1791                 pntr->status = VBUSY;
1792                 pntr->volid = volid;
1793                 goto drop;
1794             }
1795             tv = VAttachVolumeByName(&error, pname, volname, V_PEEK);
1796             if (error) {
1797                 pntr->status = 0;       /*things are messed up */
1798                 strcpy(pntr->name, volname);
1799                 pntr->volid = volid;
1800                 Log("1 Volser: ListVolumes: Could not attach volume %u (%s:%s), error=%d\n", volid, pname, volname, error);
1801                 goto drop;
1802             }
1803             if (tv->header->diskstuff.destroyMe == DESTROY_ME) {
1804                 /*this volume will be salvaged */
1805                 pntr->status = 0;
1806                 strcpy(pntr->name, volname);
1807                 pntr->volid = volid;
1808                 Log("1 Volser: ListVolumes: Volume %u (%s) will be destroyed on next salvage\n", volid, volname);
1809                 goto drop;
1810             }
1811
1812             if (tv->header->diskstuff.needsSalvaged) {
1813                 /*this volume will be salvaged */
1814                 pntr->status = 0;
1815                 strcpy(pntr->name, volname);
1816                 pntr->volid = volid;
1817                 Log("1 Volser: ListVolumes: Volume %u (%s) needs to be salvaged\n", volid, volname);
1818                 goto drop;
1819             }
1820
1821             /*read in the relevant info */
1822             pntr->status = VOK; /*its ok */
1823             pntr->volid = tv->header->diskstuff.id;
1824             strcpy(pntr->name, tv->header->diskstuff.name);
1825             pntr->type = tv->header->diskstuff.type;    /*if ro volume */
1826             pntr->cloneID = tv->header->diskstuff.cloneId;      /*if rw volume */
1827             pntr->backupID = tv->header->diskstuff.backupId;
1828             pntr->parentID = tv->header->diskstuff.parentId;
1829             pntr->copyDate = tv->header->diskstuff.copyDate;
1830             pntr->inUse = tv->header->diskstuff.inUse;
1831             pntr->size = tv->header->diskstuff.diskused;
1832             pntr->needsSalvaged = tv->header->diskstuff.needsSalvaged;
1833             pntr->destroyMe = tv->header->diskstuff.destroyMe;
1834             pntr->maxquota = tv->header->diskstuff.maxquota;
1835             pntr->filecount = tv->header->diskstuff.filecount;
1836             now = FT_ApproxTime();
1837             if (now - tv->header->diskstuff.dayUseDate > OneDay)
1838                 pntr->dayUse = 0;
1839             else
1840                 pntr->dayUse = tv->header->diskstuff.dayUse;
1841             pntr->creationDate = tv->header->diskstuff.creationDate;
1842             pntr->accessDate = tv->header->diskstuff.accessDate;
1843             pntr->updateDate = tv->header->diskstuff.updateDate;
1844             pntr->backupDate = tv->header->diskstuff.backupDate;
1845             pntr->spare0 = tv->header->diskstuff.minquota;
1846             pntr->spare1 =
1847                 (long)tv->header->diskstuff.weekUse[0] +
1848                 (long)tv->header->diskstuff.weekUse[1] +
1849                 (long)tv->header->diskstuff.weekUse[2] +
1850                 (long)tv->header->diskstuff.weekUse[3] +
1851                 (long)tv->header->diskstuff.weekUse[4] +
1852                 (long)tv->header->diskstuff.weekUse[5] +
1853                 (long)tv->header->diskstuff.weekUse[6];
1854             pntr->spare2 = V_volUpCounter(tv);
1855             pntr->flags = pntr->spare3 = (long)0;
1856             VDetachVolume(&error, tv);  /*free the volume */
1857             tv = (Volume *) 0;
1858             if (error) {
1859                 pntr->status = 0;       /*things are messed up */
1860                 strcpy(pntr->name, volname);
1861                 Log("1 Volser: ListVolumes: Could not detach volume %s\n",
1862                     volname);
1863                 goto drop;
1864             }
1865         }
1866         GetNextVol(dirp, volname, &volid);
1867     }
1868   drop:
1869     if (tv) {
1870         VDetachVolume(&error, tv);
1871         tv = (Volume *) 0;
1872     }
1873     if (ttc) {
1874         DeleteTrans(ttc, 1);
1875         ttc = (struct volser_trans *)0;
1876     }
1877
1878     closedir(dirp);
1879     if (found)
1880         return 0;
1881     else
1882         return ENODEV;
1883 }
1884
1885 /*------------------------------------------------------------------------
1886  * EXPORTED SAFSVolXListOneVolume
1887  *
1888  * Description:
1889  *      Returns extended info on volume a_volID on partition a_partID.
1890  *
1891  * Arguments:
1892  *      a_rxCidP       : Pointer to the Rx call we're performing.
1893  *      a_partID       : Partition for which we want the extended list.
1894  *      a_volID        : Volume ID we wish to know about.
1895  *      a_volumeXInfoP : Ptr to the extended info blob.
1896  *
1897  * Returns:
1898  *      0                       Successful operation
1899  *      VOLSERILLEGAL_PARTITION if we got a bogus partition ID
1900  *
1901  * Environment:
1902  *      Nothing interesting.
1903  *
1904  * Side Effects:
1905  *      As advertised.
1906  *------------------------------------------------------------------------*/
1907
1908 afs_int32
1909 SAFSVolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID, 
1910                       afs_int32 a_volID, volXEntries *a_volumeXInfoP)
1911 {
1912     afs_int32 code;
1913
1914     code = VolXListOneVolume(a_rxCidP, a_partID, a_volID, a_volumeXInfoP);
1915     osi_auditU(a_rxCidP, VS_XLst1VlEvent, code, AUD_LONG, a_volID, AUD_END);
1916     return code;
1917 }
1918
1919 afs_int32
1920 VolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID, 
1921                       afs_int32 a_volID, volXEntries *a_volumeXInfoP)
1922 {                               /*SAFSVolXListOneVolume */
1923
1924     volintXInfo *xInfoP;        /*Ptr to the extended vol info */
1925     register struct Volume *tv; /*Volume ptr */
1926     struct volser_trans *ttc;   /*Volume transaction ptr */
1927     struct DiskPartition *partP;        /*Ptr to partition */
1928     char pname[9], volname[20]; /*Partition, volume names */
1929     afs_int32 error;            /*Error code */
1930     afs_int32 code;             /*Return code */
1931     DIR *dirp;                  /*Partition directory ptr */
1932     afs_int32 currVolID;        /*Current volume ID */
1933     int found = 0;              /*Did we find the volume we need? */
1934     struct VolumeDiskData *volDiskDataP;        /*Ptr to on-disk volume data */
1935     int numStatBytes;           /*Num stat bytes to copy per volume */
1936     unsigned int now;
1937
1938     /*
1939      * Set up our pointers for action, marking our structure to hold exactly
1940      * one entry.  Also, assume we'll fail in our quest.
1941      */
1942     a_volumeXInfoP->volXEntries_val =
1943         (volintXInfo *) malloc(sizeof(volintXInfo));
1944     xInfoP = a_volumeXInfoP->volXEntries_val;
1945     a_volumeXInfoP->volXEntries_len = 1;
1946     code = ENODEV;
1947
1948     /*
1949      * If the partition name we've been given is bad, bogue out.
1950      */
1951     if (GetPartName(a_partID, pname))
1952         return (VOLSERILLEGAL_PARTITION);
1953
1954     /*
1955      * Open the directory representing the given AFS parttion.  If we can't
1956      * do that, we lose.
1957      */
1958     if (!(partP = VGetPartition(pname, 0)))
1959         return VOLSERILLEGAL_PARTITION;
1960     dirp = opendir(VPartitionPath(partP));
1961     if (dirp == NULL)
1962         return (VOLSERILLEGAL_PARTITION);
1963
1964     /*
1965      * Sweep through the partition directory, looking for the desired entry.
1966      * First, of course, figure out how many stat bytes to copy out of each
1967      * volume.
1968      */
1969     numStatBytes =
1970         4 * ((2 * VOLINT_STATS_NUM_RWINFO_FIELDS) +
1971              (4 * VOLINT_STATS_NUM_TIME_FIELDS));
1972     strcpy(volname, "");
1973     ttc = (struct volser_trans *)0;     /*No transaction yet */
1974     tv = (Volume *) 0;          /*Volume not yet attached */
1975
1976     while (strcmp(volname, "EOD") && !found) {
1977         /*
1978          * If this is not a volume, move on to the next entry in the
1979          * partition's directory.
1980          */
1981         if (!strcmp(volname, "")) {
1982             GetNextVol(dirp, volname, &currVolID);
1983             continue;
1984         }
1985
1986         if (currVolID == a_volID) {
1987             /*
1988              * We found the volume entry we're interested.  Pull out the
1989              * extended information, remembering to poll (so that the client
1990              * doesn't time out) and to set up a transaction on the volume.
1991              */
1992             found = 1;
1993 #ifndef AFS_PTHREAD_ENV
1994             IOMGR_Poll();
1995 #endif
1996             ttc = NewTrans(currVolID, a_partID);
1997             if (!ttc) {
1998                 /*
1999                  * Couldn't get a transaction on this volume; let our caller
2000                  * know it's busy.
2001                  */
2002                 xInfoP->status = VBUSY;
2003                 xInfoP->volid = currVolID;
2004                 goto drop;
2005             }
2006
2007             /*
2008              * Attach the volume, give up on the volume if we can't.
2009              */
2010             tv = VAttachVolumeByName(&error, pname, volname, V_PEEK);
2011             if (error) {
2012                 xInfoP->status = 0;     /*things are messed up */
2013                 strcpy(xInfoP->name, volname);
2014                 xInfoP->volid = currVolID;
2015                 Log("1 Volser: XListOneVolume: Could not attach volume %u\n",
2016                     currVolID);
2017                 goto drop;
2018             }
2019
2020             /*
2021              * Also bag out on this volume if it's been marked as needing a
2022              * salvage or to-be-destroyed.
2023              */
2024             volDiskDataP = &(tv->header->diskstuff);
2025             if (volDiskDataP->destroyMe == DESTROY_ME) {
2026                 xInfoP->status = 0;
2027                 strcpy(xInfoP->name, volname);
2028                 xInfoP->volid = currVolID;
2029                 Log("1 Volser: XListOneVolume: Volume %u will be destroyed on next salvage\n", currVolID);
2030                 goto drop;
2031             }
2032
2033             if (volDiskDataP->needsSalvaged) {
2034                 xInfoP->status = 0;
2035                 strcpy(xInfoP->name, volname);
2036                 xInfoP->volid = currVolID;
2037                 Log("1 Volser: XListOneVolume: Volume %u needs to be salvaged\n", currVolID);
2038                 goto drop;
2039             }
2040
2041             /*
2042              * Pull out the desired info and stuff it into the area we'll be
2043              * returning to our caller.
2044              */
2045             strcpy(xInfoP->name, volDiskDataP->name);
2046             xInfoP->volid = volDiskDataP->id;
2047             xInfoP->type = volDiskDataP->type;
2048             xInfoP->backupID = volDiskDataP->backupId;
2049             xInfoP->parentID = volDiskDataP->parentId;
2050             xInfoP->cloneID = volDiskDataP->cloneId;
2051             xInfoP->status = VOK;
2052             xInfoP->copyDate = volDiskDataP->copyDate;
2053             xInfoP->inUse = volDiskDataP->inUse;
2054             xInfoP->creationDate = volDiskDataP->creationDate;
2055             xInfoP->accessDate = volDiskDataP->accessDate;
2056             xInfoP->updateDate = volDiskDataP->updateDate;
2057             xInfoP->backupDate = volDiskDataP->backupDate;
2058             now = FT_ApproxTime();
2059             if (now - volDiskDataP->dayUseDate > OneDay)
2060                 xInfoP->dayUse = 0;
2061             else
2062                 xInfoP->dayUse = volDiskDataP->dayUse;
2063             xInfoP->filecount = volDiskDataP->filecount;
2064             xInfoP->maxquota = volDiskDataP->maxquota;
2065             xInfoP->size = volDiskDataP->diskused;
2066
2067             /*
2068              * Copy out the stat fields in a single operation.
2069              */
2070             memcpy((char *)&(xInfoP->stat_reads[0]),
2071                    (char *)&(volDiskDataP->stat_reads[0]), numStatBytes);
2072
2073             /*
2074              * We're done copying.  Detach the volume and iterate (at this
2075              * point, since we found our volume, we'll then drop out of the
2076              * loop).
2077              */
2078             VDetachVolume(&error, tv);
2079             tv = (Volume *) 0;
2080             if (error) {
2081                 xInfoP->status = 0;
2082                 strcpy(xInfoP->name, volname);
2083                 Log("1 Volser: XListOneVolumes Couldn't detach volume %s\n",
2084                     volname);
2085                 goto drop;
2086             }
2087
2088             /*
2089              * At this point, we're golden.
2090              */
2091             code = 0;
2092         }                       /*Found desired volume */
2093         GetNextVol(dirp, volname, &currVolID);
2094     }
2095
2096     /*
2097      * Drop the transaction we have for this volume.
2098      */
2099   drop:
2100     if (tv) {
2101         VDetachVolume(&error, tv);
2102         tv = (Volume *) 0;
2103     }
2104     if (ttc) {
2105         DeleteTrans(ttc, 1);
2106         ttc = (struct volser_trans *)0;
2107     }
2108
2109     /*
2110      * Clean up before going to dinner: close the partition directory,
2111      * return the proper value.
2112      */
2113     closedir(dirp);
2114     return (code);
2115
2116 }                               /*SAFSVolXListOneVolume */
2117
2118 /*returns all the volumes on partition partid. If flags = 1 then all the 
2119 * relevant info about the volumes  is also returned */
2120 afs_int32
2121 SAFSVolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags, 
2122                    volEntries *volumeInfo)
2123 {
2124     afs_int32 code;
2125
2126     code = VolListVolumes(acid, partid, flags, volumeInfo);
2127     osi_auditU(acid, VS_ListVolEvent, code, AUD_END);
2128     return code;
2129 }
2130
2131 afs_int32
2132 VolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags, 
2133                    volEntries *volumeInfo)
2134 {
2135     volintInfo *pntr;
2136     register struct Volume *tv;
2137     struct DiskPartition *partP;
2138     struct volser_trans *ttc;
2139     afs_int32 allocSize = 1000; /*to be changed to a larger figure */
2140     char pname[9], volname[20];
2141     afs_int32 error = 0;
2142     DIR *dirp;
2143     afs_int32 volid;
2144     unsigned int now;
2145
2146     volumeInfo->volEntries_val =
2147         (volintInfo *) malloc(allocSize * sizeof(volintInfo));
2148     pntr = volumeInfo->volEntries_val;
2149     volumeInfo->volEntries_len = 0;
2150     if (GetPartName(partid, pname))
2151         return VOLSERILLEGAL_PARTITION;
2152     if (!(partP = VGetPartition(pname, 0)))
2153         return VOLSERILLEGAL_PARTITION;
2154     dirp = opendir(VPartitionPath(partP));
2155     if (dirp == NULL)
2156         return VOLSERILLEGAL_PARTITION;
2157     strcpy(volname, "");
2158     while (strcmp(volname, "EOD")) {    /*while there are more partitions in the partition */
2159         ttc = (struct volser_trans *)0; /* new one for each pass */
2160         tv = (Volume *) 0;      /* volume not attached */
2161
2162         if (!strcmp(volname, "")) {     /* its not a volume, fetch next file */
2163             GetNextVol(dirp, volname, &volid);
2164             continue;           /*back to while loop */
2165         }
2166
2167         if (flags) {            /*copy other things too */
2168 #ifndef AFS_PTHREAD_ENV
2169             IOMGR_Poll();       /*make sure that the client doesnot time out */
2170 #endif
2171             ttc = NewTrans(volid, partid);
2172             if (!ttc) {
2173                 pntr->status = VBUSY;
2174                 pntr->volid = volid;
2175                 goto drop;
2176             }
2177             tv = VAttachVolumeByName(&error, pname, volname, V_PEEK);
2178             if (error) {
2179                 pntr->status = 0;       /*things are messed up */
2180                 strcpy(pntr->name, volname);
2181                 pntr->volid = volid;
2182                 Log("1 Volser: ListVolumes: Could not attach volume %u (%s) error=%d\n", volid, volname, error);
2183                 goto drop;
2184             }
2185             if (tv->header->diskstuff.needsSalvaged) {
2186                 /*this volume will be salvaged */
2187                 pntr->status = 0;
2188                 strcpy(pntr->name, volname);
2189                 pntr->volid = volid;
2190                 Log("1 Volser: ListVolumes: Volume %u (%s) needs to be salvaged\n", volid, volname);
2191                 goto drop;
2192             }
2193
2194             if (tv->header->diskstuff.destroyMe == DESTROY_ME) {
2195                 /*this volume will be salvaged */
2196                 goto drop2;
2197             }
2198             /*read in the relevant info */
2199             pntr->status = VOK; /*its ok */
2200             pntr->volid = tv->header->diskstuff.id;
2201             strcpy(pntr->name, tv->header->diskstuff.name);
2202             pntr->type = tv->header->diskstuff.type;    /*if ro volume */
2203             pntr->cloneID = tv->header->diskstuff.cloneId;      /*if rw volume */
2204             pntr->backupID = tv->header->diskstuff.backupId;
2205             pntr->parentID = tv->header->diskstuff.parentId;
2206             pntr->copyDate = tv->header->diskstuff.copyDate;
2207             pntr->inUse = tv->header->diskstuff.inUse;
2208             pntr->size = tv->header->diskstuff.diskused;
2209             pntr->needsSalvaged = tv->header->diskstuff.needsSalvaged;
2210             pntr->maxquota = tv->header->diskstuff.maxquota;
2211             pntr->filecount = tv->header->diskstuff.filecount;
2212             now = FT_ApproxTime();
2213             if (now - tv->header->diskstuff.dayUseDate > OneDay)
2214                 pntr->dayUse = 0;
2215             else
2216                 pntr->dayUse = tv->header->diskstuff.dayUse;
2217             pntr->creationDate = tv->header->diskstuff.creationDate;
2218             pntr->accessDate = tv->header->diskstuff.accessDate;
2219             pntr->updateDate = tv->header->diskstuff.updateDate;
2220             pntr->backupDate = tv->header->diskstuff.backupDate;
2221             pntr->spare0 = tv->header->diskstuff.minquota;
2222             pntr->spare1 =
2223                 (long)tv->header->diskstuff.weekUse[0] +
2224                 (long)tv->header->diskstuff.weekUse[1] +
2225                 (long)tv->header->diskstuff.weekUse[2] +
2226                 (long)tv->header->diskstuff.weekUse[3] +
2227                 (long)tv->header->diskstuff.weekUse[4] +
2228                 (long)tv->header->diskstuff.weekUse[5] +
2229                 (long)tv->header->diskstuff.weekUse[6];
2230             pntr->spare2 = V_volUpCounter(tv);
2231             pntr->flags = pntr->spare3 = (long)0;
2232             VDetachVolume(&error, tv);  /*free the volume */
2233             tv = (Volume *) 0;
2234             if (error) {
2235                 pntr->status = 0;       /*things are messed up */
2236                 strcpy(pntr->name, volname);
2237                 Log("1 Volser: ListVolumes: Could not detach volume %s\n",
2238                     volname);
2239                 goto drop;
2240             }
2241         } else {
2242             pntr->volid = volid;
2243             /*just volids are needed */
2244         }
2245
2246       drop:
2247         if (ttc) {
2248             DeleteTrans(ttc, 1);
2249             ttc = (struct volser_trans *)0;
2250         }
2251         pntr++;
2252         volumeInfo->volEntries_len += 1;
2253         if ((allocSize - volumeInfo->volEntries_len) < 5) {
2254             /*running out of space, allocate more space */
2255             allocSize = (allocSize * 3) / 2;
2256             pntr =
2257                 (volintInfo *) realloc((char *)volumeInfo->volEntries_val,
2258                                        allocSize * sizeof(volintInfo));
2259             if (pntr == NULL) {
2260                 if (tv) {
2261                     VDetachVolume(&error, tv);
2262                     tv = (Volume *) 0;
2263                 }
2264                 if (ttc) {
2265                     DeleteTrans(ttc, 1);
2266                     ttc = (struct volser_trans *)0;
2267                 }
2268                 closedir(dirp);
2269                 return VOLSERNO_MEMORY;
2270             }
2271             volumeInfo->volEntries_val = pntr;  /* point to new block */
2272             /* set pntr to the right position */
2273             pntr = volumeInfo->volEntries_val + volumeInfo->volEntries_len;
2274
2275         }
2276
2277       drop2:
2278         if (tv) {
2279             VDetachVolume(&error, tv);
2280             tv = (Volume *) 0;
2281         }
2282         if (ttc) {
2283             DeleteTrans(ttc, 1);
2284             ttc = (struct volser_trans *)0;
2285         }
2286         GetNextVol(dirp, volname, &volid);
2287
2288     }
2289     closedir(dirp);
2290     if (ttc)
2291         DeleteTrans(ttc, 1);
2292
2293     return 0;
2294 }
2295
2296 /*------------------------------------------------------------------------
2297  * EXPORTED SAFSVolXListVolumes
2298  *
2299  * Description:
2300  *      Returns all the volumes on partition a_partID.  If a_flags
2301  *      is set to 1, then all the relevant extended volume information
2302  *      is also returned.
2303  *
2304  * Arguments:
2305  *      a_rxCidP       : Pointer to the Rx call we're performing.
2306  *      a_partID       : Partition for which we want the extended list.
2307  *      a_flags        : Various flags.
2308  *      a_volumeXInfoP : Ptr to the extended info blob.
2309  *
2310  * Returns:
2311  *      0                       Successful operation
2312  *      VOLSERILLEGAL_PARTITION if we got a bogus partition ID
2313  *      VOLSERNO_MEMORY         if we ran out of memory allocating
2314  *                              our return blob
2315  *
2316  * Environment:
2317  *      Nothing interesting.
2318  *
2319  * Side Effects:
2320  *      As advertised.
2321  *------------------------------------------------------------------------*/
2322
2323 afs_int32
2324 SAFSVolXListVolumes(struct rx_call *a_rxCidP, afs_int32 a_partID,
2325                     afs_int32 a_flags, volXEntries *a_volumeXInfoP)
2326 {
2327     afs_int32 code;
2328
2329     code = VolXListVolumes(a_rxCidP, a_partID, a_flags, a_volumeXInfoP);
2330     osi_auditU(a_rxCidP, VS_XLstVolEvent, code, AUD_END);
2331     return code;
2332 }
2333
2334 afs_int32
2335 VolXListVolumes(struct rx_call *a_rxCidP, afs_int32 a_partID,
2336                     afs_int32 a_flags, volXEntries *a_volumeXInfoP)
2337 {                               /*SAFSVolXListVolumes */
2338
2339     volintXInfo *xInfoP;        /*Ptr to the extended vol info */
2340     register struct Volume *tv; /*Volume ptr */
2341     struct DiskPartition *partP;        /*Ptr to partition */
2342     struct volser_trans *ttc;   /*Volume transaction ptr */
2343     afs_int32 allocSize = 1000; /*To be changed to a larger figure */
2344     char pname[9], volname[20]; /*Partition, volume names */
2345     afs_int32 error = 0;        /*Return code */
2346     DIR *dirp;                  /*Partition directory ptr */
2347     afs_int32 volid;            /*Current volume ID */
2348     struct VolumeDiskData *volDiskDataP;        /*Ptr to on-disk volume data */
2349     int numStatBytes;           /*Num stat bytes to copy per volume */
2350     unsigned int now;
2351
2352     /*
2353      * Allocate a large array of extended volume info structures, then
2354      * set it up for action.
2355      */
2356     a_volumeXInfoP->volXEntries_val =
2357         (volintXInfo *) malloc(allocSize * sizeof(volintXInfo));
2358     xInfoP = a_volumeXInfoP->volXEntries_val;
2359     a_volumeXInfoP->volXEntries_len = 0;
2360
2361     /*
2362      * If the partition name we've been given is bad, bogue out.
2363      */
2364     if (GetPartName(a_partID, pname))
2365         return (VOLSERILLEGAL_PARTITION);
2366
2367     /*
2368      * Open the directory representing the given AFS parttion.  If we can't
2369      * do that, we lose.
2370      */
2371     if (!(partP = VGetPartition(pname, 0)))
2372         return VOLSERILLEGAL_PARTITION;
2373     dirp = opendir(VPartitionPath(partP));
2374     if (dirp == NULL)
2375         return (VOLSERILLEGAL_PARTITION);
2376
2377     /*
2378      * Sweep through the partition directory, acting on each entry.  First,
2379      * of course, figure out how many stat bytes to copy out of each volume.
2380      */
2381     numStatBytes =
2382         4 * ((2 * VOLINT_STATS_NUM_RWINFO_FIELDS) +
2383              (4 * VOLINT_STATS_NUM_TIME_FIELDS));
2384     strcpy(volname, "");
2385     while (strcmp(volname, "EOD")) {
2386         ttc = (struct volser_trans *)0; /*New one for each pass */
2387         tv = (Volume *) 0;      /*Volume not yet attached */
2388
2389         /*
2390          * If this is not a volume, move on to the next entry in the
2391          * partition's directory.
2392          */
2393         if (!strcmp(volname, "")) {
2394             GetNextVol(dirp, volname, &volid);
2395             continue;
2396         }
2397
2398         if (a_flags) {
2399             /*
2400              * Full info about the volume desired.  Poll to make sure the
2401              * client doesn't time out, then start up a new transaction.
2402              */
2403 #ifndef AFS_PTHREAD_ENV
2404             IOMGR_Poll();
2405 #endif
2406             ttc = NewTrans(volid, a_partID);
2407             if (!ttc) {
2408                 /*
2409                  * Couldn't get a transaction on this volume; let our caller
2410                  * know it's busy.
2411                  */
2412                 xInfoP->status = VBUSY;
2413                 xInfoP->volid = volid;
2414                 goto drop;
2415             }
2416
2417             /*
2418              * Attach the volume, give up on this volume if we can't.
2419              */
2420             tv = VAttachVolumeByName(&error, pname, volname, V_PEEK);
2421             if (error) {
2422                 xInfoP->status = 0;     /*things are messed up */
2423                 strcpy(xInfoP->name, volname);
2424                 xInfoP->volid = volid;
2425                 Log("1 Volser: XListVolumes: Could not attach volume %u\n",
2426                     volid);
2427                 goto drop;
2428             }
2429
2430             /*
2431              * Also bag out on this volume if it's been marked as needing a
2432              * salvage or to-be-destroyed.
2433              */
2434             volDiskDataP = &(tv->header->diskstuff);
2435             if (volDiskDataP->needsSalvaged) {
2436                 xInfoP->status = 0;
2437                 strcpy(xInfoP->name, volname);
2438                 xInfoP->volid = volid;
2439                 Log("1 Volser: XListVolumes: Volume %u needs to be salvaged\n", volid);
2440                 goto drop;
2441             }
2442
2443             if (volDiskDataP->destroyMe == DESTROY_ME)
2444                 goto drop2;
2445
2446             /*
2447              * Pull out the desired info and stuff it into the area we'll be
2448              * returning to our caller.
2449              */
2450             strcpy(xInfoP->name, volDiskDataP->name);
2451             xInfoP->volid = volDiskDataP->id;
2452             xInfoP->type = volDiskDataP->type;
2453             xInfoP->backupID = volDiskDataP->backupId;
2454             xInfoP->parentID = volDiskDataP->parentId;
2455             xInfoP->cloneID = volDiskDataP->cloneId;
2456             xInfoP->status = VOK;
2457             xInfoP->copyDate = volDiskDataP->copyDate;
2458             xInfoP->inUse = volDiskDataP->inUse;
2459             xInfoP->creationDate = volDiskDataP->creationDate;
2460             xInfoP->accessDate = volDiskDataP->accessDate;
2461             xInfoP->updateDate = volDiskDataP->updateDate;
2462             xInfoP->backupDate = volDiskDataP->backupDate;
2463             now = FT_ApproxTime();
2464             if (now - volDiskDataP->dayUseDate > OneDay)
2465                 xInfoP->dayUse = 0;
2466             else
2467                 xInfoP->dayUse = volDiskDataP->dayUse;
2468             xInfoP->filecount = volDiskDataP->filecount;
2469             xInfoP->maxquota = volDiskDataP->maxquota;
2470             xInfoP->size = volDiskDataP->diskused;
2471
2472             /*
2473              * Copy out the stat fields in a single operation.
2474              */
2475             memcpy((char *)&(xInfoP->stat_reads[0]),
2476                    (char *)&(volDiskDataP->stat_reads[0]), numStatBytes);
2477
2478             /*
2479              * We're done copying.  Detach the volume and iterate.
2480              */
2481             VDetachVolume(&error, tv);
2482             tv = (Volume *) 0;
2483             if (error) {
2484                 xInfoP->status = 0;
2485                 strcpy(xInfoP->name, volname);
2486                 Log("1 Volser: XListVolumes: Could not detach volume %s\n",
2487                     volname);
2488                 goto drop;
2489             }
2490         } /*Full contents desired */
2491         else
2492             /*
2493              * Just volume IDs are needed.
2494              */
2495             xInfoP->volid = volid;
2496
2497       drop:
2498         /*
2499          * Drop the transaction we have for this volume.
2500          */
2501         if (ttc) {
2502             DeleteTrans(ttc, 1);
2503             ttc = (struct volser_trans *)0;
2504         }
2505
2506         /*
2507          * Bump the pointer in the data area we're building, along with
2508          * the count of the number of entries it contains.
2509          */
2510         xInfoP++;
2511         (a_volumeXInfoP->volXEntries_len)++;
2512         if ((allocSize - a_volumeXInfoP->volXEntries_len) < 5) {
2513             /*
2514              * We're running out of space in the area we've built.  Grow it.
2515              */
2516             allocSize = (allocSize * 3) / 2;
2517             xInfoP = (volintXInfo *)
2518                 realloc((char *)a_volumeXInfoP->volXEntries_val,
2519                         (allocSize * sizeof(volintXInfo)));
2520             if (xInfoP == NULL) {
2521                 /*
2522                  * Bummer, no memory. Bag it, tell our caller what went wrong.
2523                  */
2524                 if (tv) {
2525                     VDetachVolume(&error, tv);
2526                     tv = (Volume *) 0;
2527                 }
2528                 if (ttc) {
2529                     DeleteTrans(ttc, 1);
2530                     ttc = (struct volser_trans *)0;
2531                 }
2532                 closedir(dirp);
2533                 return (VOLSERNO_MEMORY);
2534             }
2535
2536             /*
2537              * Memory reallocation worked.  Correct our pointers so they
2538              * now point to the new block and the current open position within
2539              * the new block.
2540              */
2541             a_volumeXInfoP->volXEntries_val = xInfoP;
2542             xInfoP =
2543                 a_volumeXInfoP->volXEntries_val +
2544                 a_volumeXInfoP->volXEntries_len;
2545         }
2546         /*Need more space */
2547       drop2:
2548         /*
2549          * Detach our current volume and the transaction on it, then move on
2550          * to the next volume in the partition directory.
2551          */
2552         if (tv) {
2553             VDetachVolume(&error, tv);
2554             tv = (Volume *) 0;
2555         }
2556         if (ttc) {
2557             DeleteTrans(ttc, 1);
2558             ttc = (struct volser_trans *)0;
2559         }
2560         GetNextVol(dirp, volname, &volid);
2561     }                           /*Sweep through the partition directory */
2562
2563     /*
2564      * We've examined all entries in the partition directory.  Close it,
2565      * delete our transaction (if any), and go home happy.
2566      */
2567     closedir(dirp);
2568     if (ttc)
2569         DeleteTrans(ttc, 1);
2570     return (0);
2571
2572 }                               /*SAFSVolXListVolumes */
2573
2574 /*this call is used to monitor the status of volser for debugging purposes.
2575  *information about all the active transactions is returned in transInfo*/
2576 afs_int32
2577 SAFSVolMonitor(struct rx_call *acid, transDebugEntries *transInfo)
2578 {
2579     afs_int32 code;
2580
2581     code = VolMonitor(acid, transInfo);
2582     osi_auditU(acid, VS_MonitorEvent, code, AUD_END);
2583     return code;
2584 }
2585
2586 afs_int32
2587 VolMonitor(struct rx_call *acid, transDebugEntries *transInfo)
2588 {
2589     transDebugInfo *pntr;
2590     afs_int32 allocSize = 50;
2591     struct volser_trans *tt, *allTrans;
2592
2593     transInfo->transDebugEntries_val =
2594         (transDebugInfo *) malloc(allocSize * sizeof(transDebugInfo));
2595     pntr = transInfo->transDebugEntries_val;
2596     transInfo->transDebugEntries_len = 0;
2597     allTrans = TransList();
2598     if (allTrans == (struct volser_trans *)0)
2599         return 0;               /*no active transactions */
2600     for (tt = allTrans; tt; tt = tt->next) {    /*copy relevant info into pntr */
2601         pntr->tid = tt->tid;
2602         pntr->time = tt->time;
2603         pntr->creationTime = tt->creationTime;
2604         pntr->returnCode = tt->returnCode;
2605         pntr->volid = tt->volid;
2606         pntr->partition = tt->partition;
2607         pntr->iflags = tt->iflags;
2608         pntr->vflags = tt->vflags;
2609         pntr->tflags = tt->tflags;
2610         strcpy(pntr->lastProcName, tt->lastProcName);
2611         pntr->callValid = 0;
2612         if (tt->rxCallPtr) {    /*record call related info */
2613             pntr->callValid = 1;
2614             pntr->readNext = tt->rxCallPtr->rnext;
2615             pntr->transmitNext = tt->rxCallPtr->tnext;
2616             pntr->lastSendTime = tt->rxCallPtr->lastSendTime;
2617             pntr->lastReceiveTime = tt->rxCallPtr->lastReceiveTime;
2618         }
2619         pntr++;
2620         transInfo->transDebugEntries_len += 1;
2621         if ((allocSize - transInfo->transDebugEntries_len) < 5) {       /*alloc some more space */
2622             allocSize = (allocSize * 3) / 2;
2623             pntr =
2624                 (transDebugInfo *) realloc((char *)transInfo->
2625                                            transDebugEntries_val,
2626                                            allocSize *
2627                                            sizeof(transDebugInfo));
2628             transInfo->transDebugEntries_val = pntr;
2629             pntr =
2630                 transInfo->transDebugEntries_val +
2631                 transInfo->transDebugEntries_len;
2632             /*set pntr to right position */
2633         }
2634
2635     }
2636
2637     return 0;
2638 }
2639
2640 afs_int32
2641 SAFSVolSetIdsTypes(struct rx_call *acid, afs_int32 atid, char name[], afs_int32 type, afs_int32 pId, afs_int32 cloneId, afs_int32 backupId)
2642 {
2643     afs_int32 code;
2644
2645     code = VolSetIdsTypes(acid, atid, name, type, pId, cloneId, backupId);
2646     osi_auditU(acid, VS_SetIdTyEvent, code, AUD_LONG, atid, AUD_STR, name,
2647                AUD_LONG, type, AUD_LONG, pId, AUD_LONG, cloneId, AUD_LONG,
2648                backupId, AUD_END);
2649     return code;
2650 }
2651
2652 afs_int32
2653 VolSetIdsTypes(struct rx_call *acid, afs_int32 atid, char name[], afs_int32 type, afs_int32 pId, afs_int32 cloneId, afs_int32 backupId)
2654 {
2655     struct Volume *tv;
2656     afs_int32 error = 0;
2657     register struct volser_trans *tt;
2658     char caller[MAXKTCNAMELEN];
2659
2660     if (strlen(name) > 31)
2661         return VOLSERBADNAME;
2662     if (!afsconf_SuperUser(tdir, acid, caller))
2663         return VOLSERBAD_ACCESS;        /*not a super user */
2664     /* find the trans */
2665     tt = FindTrans(atid);
2666     if (!tt)
2667         return ENOENT;
2668     if (tt->vflags & VTDeleted) {
2669         Log("1 Volser: VolSetIds: volume %u has been deleted \n", tt->volid);
2670         TRELE(tt);
2671         return ENOENT;
2672     }
2673     strcpy(tt->lastProcName, "SetIdsTypes");
2674     tt->rxCallPtr = acid;
2675     tv = tt->volume;
2676
2677     V_type(tv) = type;
2678     V_backupId(tv) = backupId;
2679     V_cloneId(tv) = cloneId;
2680     V_parentId(tv) = pId;
2681     strcpy((&V_disk(tv))->name, name);
2682     VUpdateVolume(&error, tv);
2683     if (error) {
2684         Log("1 Volser: SetIdsTypes: VUpdate failed code %d\n", error);
2685         LogError(error);
2686         goto fail;
2687     }
2688     tt->rxCallPtr = (struct rx_call *)0;
2689     if (TRELE(tt) && !error)
2690         return VOLSERTRELE_ERROR;
2691
2692     return error;
2693   fail:
2694     tt->rxCallPtr = (struct rx_call *)0;
2695     if (TRELE(tt) && !error)
2696         return VOLSERTRELE_ERROR;
2697     return error;
2698 }
2699
2700 afs_int32
2701 SAFSVolSetDate(struct rx_call *acid, afs_int32 atid, afs_int32 cdate)
2702 {
2703     afs_int32 code;
2704
2705     code = VolSetDate(acid, atid, cdate);
2706     osi_auditU(acid, VS_SetDateEvent, code, AUD_LONG, atid, AUD_LONG, cdate,
2707                AUD_END);
2708     return code;
2709 }
2710
2711 afs_int32
2712 VolSetDate(struct rx_call *acid, afs_int32 atid, afs_int32 cdate)
2713 {
2714     struct Volume *tv;
2715     afs_int32 error = 0;
2716     register struct volser_trans *tt;
2717     char caller[MAXKTCNAMELEN];
2718
2719     if (!afsconf_SuperUser(tdir, acid, caller))
2720         return VOLSERBAD_ACCESS;        /*not a super user */
2721     /* find the trans */
2722     tt = FindTrans(atid);
2723     if (!tt)
2724         return ENOENT;
2725     if (tt->vflags & VTDeleted) {
2726         Log("1 Volser: VolSetDate: volume %u has been deleted \n", tt->volid);
2727         TRELE(tt);
2728         return ENOENT;
2729     }
2730     strcpy(tt->lastProcName, "SetDate");
2731     tt->rxCallPtr = acid;
2732     tv = tt->volume;
2733
2734     V_creationDate(tv) = cdate;
2735     VUpdateVolume(&error, tv);
2736     if (error) {
2737         Log("1 Volser: SetDate: VUpdate failed code %d\n", error);
2738         LogError(error);
2739         goto fail;
2740     }
2741     tt->rxCallPtr = (struct rx_call *)0;
2742     if (TRELE(tt) && !error)
2743         return VOLSERTRELE_ERROR;
2744
2745     return error;
2746   fail:
2747     tt->rxCallPtr = (struct rx_call *)0;
2748     if (TRELE(tt) && !error)
2749         return VOLSERTRELE_ERROR;
2750     return error;
2751 }
2752
2753 #ifdef AFS_NAMEI_ENV
2754 /* 
2755  * Inode number format  (from namei_ops.c): 
2756  * low 26 bits - vnode number - all 1's if volume special file.
2757  * next 3 bits - tag
2758  * next 3 bits spare (0's)
2759  * high 32 bits - uniquifier (regular) or type if spare
2760  */
2761 #define NAMEI_VNODEMASK    0x003ffffff
2762 #define NAMEI_TAGMASK      0x7
2763 #define NAMEI_TAGSHIFT     26
2764 #define NAMEI_UNIQMASK     0xffffffff
2765 #define NAMEI_UNIQSHIFT    32
2766 #define NAMEI_INODESPECIAL ((Inode)NAMEI_VNODEMASK)
2767 #define NAMEI_VNODESPECIAL NAMEI_VNODEMASK
2768 #endif /* AFS_NAMEI_ENV */
2769
2770 afs_int32
2771 SAFSVolConvertROtoRWvolume(struct rx_call *acid, afs_int32 partId,
2772                            afs_int32 volumeId)
2773 {
2774 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
2775     DIR *dirp;
2776     char pname[16];
2777     char volname[20];
2778     afs_int32 error = 0;
2779     afs_int32 volid;
2780     int found = 0;
2781     char caller[MAXKTCNAMELEN];
2782     char headername[16];
2783     char opath[256];
2784     char npath[256];
2785     struct VolumeDiskHeader h;
2786     int fd;
2787     IHandle_t *ih;
2788     Inode ino;
2789     struct DiskPartition *dp;
2790
2791     if (!afsconf_SuperUser(tdir, acid, caller))
2792         return VOLSERBAD_ACCESS;        /*not a super user */
2793     if (GetPartName(partId, pname))
2794         return VOLSERILLEGAL_PARTITION;
2795     dirp = opendir(pname);
2796     if (dirp == NULL)
2797         return VOLSERILLEGAL_PARTITION;
2798     strcpy(volname, "");
2799
2800     while (strcmp(volname, "EOD") && !found) {  /*while there are more volumes in the partition */
2801         GetNextVol(dirp, volname, &volid);
2802         if (strcmp(volname, "")) {      /* its a volume */
2803             if (volid == volumeId)
2804                 found = 1;
2805         }
2806     }
2807     if (!found)
2808         return ENOENT;
2809     (void)afs_snprintf(headername, sizeof headername, VFORMAT, volumeId);
2810     (void)afs_snprintf(opath, sizeof opath, "%s/%s", pname, headername);
2811     fd = open(opath, O_RDONLY);
2812     if (fd < 0) {
2813         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't open header for RO-volume %lu.\n", volumeId);
2814         return ENOENT;
2815     }
2816     if (read(fd, &h, sizeof(h)) != sizeof(h)) {
2817         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't read header for RO-volume %lu.\n", volumeId);
2818         close(fd);
2819         return EIO;
2820     }
2821     close(fd);
2822     FSYNC_askfs(volumeId, pname, FSYNC_RESTOREVOLUME, 0);
2823
2824     for (dp = DiskPartitionList; dp && strcmp(dp->name, pname);
2825          dp = dp->next);
2826     if (!dp) {
2827         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't find DiskPartition for %s\n", pname);
2828         return EIO;
2829     }
2830     ino = namei_MakeSpecIno(h.parent, VI_LINKTABLE);
2831     IH_INIT(ih, dp->device, h.parent, ino);
2832
2833     error = namei_ConvertROtoRWvolume(ih, volumeId);
2834     if (error)
2835         return error;
2836     h.id = h.parent;
2837     h.volumeInfo_hi = h.id;
2838     h.smallVnodeIndex_hi = h.id;
2839     h.largeVnodeIndex_hi = h.id;
2840     h.linkTable_hi = h.id;
2841     (void)afs_snprintf(headername, sizeof headername, VFORMAT, h.id);
2842     (void)afs_snprintf(npath, sizeof npath, "%s/%s", pname, headername);
2843     fd = open(npath, O_CREAT | O_EXCL | O_RDWR, 0644);
2844     if (fd < 0) {
2845         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't create header for RW-volume %lu.\n", h.id);
2846         return EIO;
2847     }
2848     if (write(fd, &h, sizeof(h)) != sizeof(h)) {
2849         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't write header for RW-volume %lu.\n", h.id);
2850         close(fd);
2851         return EIO;
2852     }
2853     close(fd);
2854     if (unlink(opath) < 0) {
2855         Log("1 SAFS_VolConvertROtoRWvolume: Couldn't unlink RO header, error = %d\n", error);
2856     }
2857     FSYNC_askfs(volumeId, pname, FSYNC_DONE, 0);
2858     FSYNC_askfs(h.id, pname, FSYNC_ON, 0);
2859     return 0;
2860 #else /* AFS_NAMEI_ENV */
2861     return EINVAL;
2862 #endif /* AFS_NAMEI_ENV */
2863 }
2864
2865 afs_int32
2866 SAFSVolGetSize(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
2867                register struct volintSize *size)
2868 {
2869     int code = 0;
2870     register struct volser_trans *tt;
2871     char caller[MAXKTCNAMELEN];
2872
2873     if (!afsconf_SuperUser(tdir, acid, caller))
2874         return VOLSERBAD_ACCESS;        /*not a super user */
2875     tt = FindTrans(fromTrans);
2876     if (!tt)
2877         return ENOENT;
2878     if (tt->vflags & VTDeleted) {
2879         TRELE(tt);
2880         return ENOENT;
2881     }
2882     strcpy(tt->lastProcName, "GetSize");
2883     tt->rxCallPtr = acid;
2884     code = SizeDumpVolume(acid, tt->volume, fromDate, 1, size); /* measure volume's data */
2885     tt->rxCallPtr = (struct rx_call *)0;
2886     if (TRELE(tt))
2887         return VOLSERTRELE_ERROR;
2888
2889 /*    osi_auditU(acid, VS_DumpEvent, code, AUD_LONG, fromTrans, AUD_END);  */
2890     return code;
2891 }
2892
2893 /* GetPartName - map partid (a decimal number) into pname (a string)
2894  * Since for NT we actually want to return the drive name, we map through the
2895  * partition struct.
2896  */
2897 static int
2898 GetPartName(afs_int32 partid, char *pname)
2899 {
2900     if (partid < 0)
2901         return -1;
2902     if (partid < 26) {
2903         strcpy(pname, "/vicep");
2904         pname[6] = 'a' + partid;
2905         pname[7] = '\0';
2906         return 0;
2907     } else if (partid < VOLMAXPARTS) {
2908         strcpy(pname, "/vicep");
2909         partid -= 26;
2910         pname[6] = 'a' + (partid / 26);
2911         pname[7] = 'a' + (partid % 26);
2912         pname[8] = '\0';
2913         return 0;
2914     } else
2915         return -1;
2916 }