5ef020fd7c7a9c40d39af5d45ca6166f5843b580
[openafs.git] / src / volser / vsprocs.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID("$Header$");
14
15 #include <stdio.h>
16 #include <sys/types.h>
17 #include <sys/stat.h>
18 #ifdef  AFS_AIX_ENV
19 #include <sys/statfs.h>
20 #endif
21 #ifdef AFS_NT40_ENV
22 #include <fcntl.h>
23 #include <winsock2.h>
24 #else
25 #include <sys/file.h>
26 #include <netinet/in.h>
27 #endif
28 #include <lock.h>
29 #include <afs/voldefs.h>
30 #include <rx/xdr.h>
31 #include <rx/rx.h>
32 #include <afs/vlserver.h>
33 #include <afs/nfs.h>
34 #include <afs/auth.h>
35 #include <afs/cellconfig.h>
36 #include <afs/keys.h>
37 #include <ubik.h>
38 #include <afs/afsint.h>
39 #include "volser.h" 
40 #include "volint.h"
41 #include "lockdata.h"
42 #include <afs/com_err.h>
43 #include <rx/rxkad.h>
44 #include <afs/kautils.h>
45 #include <afs/cmd.h>
46 #include <errno.h>
47 #define ERRCODE_RANGE 8                 /* from error_table.h */
48 #define CLOCKSKEW   2                   /* not really skew, but resolution */
49
50 /* for UV_MoveVolume() recovery */
51
52 #include <afs/procmgmt.h>   /* signal(), kill(), wait(), etc. */
53 #include <setjmp.h>
54
55 afs_int32 VolumeExists(), CheckVldbRWBK(), CheckVldb();
56
57 struct ubik_client *cstruct;
58 int verbose = 0;
59 extern struct  rx_securityClass *rxnull_NewClientSecurityObject();
60 extern struct rx_connection *rx_NewConnection();
61 extern void AFSVolExecuteRequest();
62 extern struct rx_securityClass *rxnull_NewServerSecurityObject();
63 extern int VL_GetNewVolumeId();
64 extern int VL_SetLock();
65 extern int VL_ReleaseLock();
66 extern int VL_DeleteEntry();
67
68 void MapNetworkToHost();
69 void MapHostToNetwork();
70
71 struct release {
72   afs_int32 time;
73   afs_int32 vldbEntryIndex;
74 };
75
76 /*map the partition <partId> into partition name <partName>*/
77 void
78 MapPartIdIntoName(partId, partName)
79 afs_int32 partId;
80 char *partName;
81 {
82     if(partId < 26) {/* what if partId > = 26 ? */
83         strcpy(partName,"/vicep");
84         partName[6] = partId + 'a';
85         partName[7] = '\0';
86         return;
87     } else if (partId < VOLMAXPARTS) {
88         strcpy(partName,"/vicep");
89         partId -= 26;
90         partName[6] = 'a' + (partId/26);
91         partName[7] = 'a' + (partId%26);
92         partName[8] = '\0';
93         return;
94     }
95 }
96
97 yesprompt(str)
98 char *str;
99 {
100     char response, c;
101     int code;
102
103     fprintf(STDERR, "Do you want to %s? [yn](n): ", str);
104     response = c = getchar();
105     while (!(c==EOF || c=='\n')) c=getchar(); /*skip to end of line*/
106     code = (response=='y'||response=='Y');      
107     return code;
108 }
109
110
111 PrintError(msg, errcode)
112     char *msg;
113     afs_int32 errcode;
114 {
115         fprintf(STDERR,msg);
116         /*replace by a big switch statement*/
117         switch(errcode) {
118             case 0 :    
119                 break;
120             case -1     :   fprintf(STDERR,"Possible communication failure\n");
121                 break;
122             case VSALVAGE: fprintf(STDERR,"Volume needs to be salvaged\n");
123                 break;
124             case VNOVNODE:  fprintf(STDERR,"Bad vnode number quoted\n");
125                 break;
126             case VNOVOL:    fprintf(STDERR,"Volume not attached, does not exist, or not on line\n");
127                 break;
128             case VVOLEXISTS:fprintf(STDERR,"Volume already exists\n");
129                 break;
130             case VNOSERVICE:fprintf(STDERR,"Volume is not in service\n");
131                 break;
132             case VOFFLINE:  fprintf(STDERR,"Volume is off line\n");
133                 break;
134             case VONLINE:   fprintf(STDERR,"Volume is already on line\n");
135                 break;
136             case VDISKFULL: fprintf(STDERR,"Partition is full\n");
137                 break;
138             case VOVERQUOTA:fprintf(STDERR,"Volume max quota exceeded\n");
139                 break;
140             case VBUSY: fprintf(STDERR,"Volume temporarily unavailable\n");
141                 break;
142             case VMOVED:fprintf(STDERR,"Volume has moved to another server\n");
143                 break;
144             case VL_IDEXIST :  fprintf(STDERR,"VLDB: volume Id exists in the vldb\n");
145                 break;
146             case VL_IO:   fprintf(STDERR,"VLDB: a read terminated too early\n");
147                 break;
148             case VL_NAMEEXIST:   fprintf(STDERR,"VLDB: volume entry exists in the vldb\n");
149                 break;
150             case VL_CREATEFAIL:   fprintf(STDERR,"VLDB: internal creation failure\n");
151                 break;
152             case VL_NOENT:   fprintf(STDERR,"VLDB: no such entry\n");
153                 break;
154             case VL_EMPTY:   fprintf(STDERR,"VLDB: vldb database is empty\n");
155                 break;
156             case VL_ENTDELETED:   fprintf(STDERR,"VLDB: entry is deleted (soft delete)\n");
157                 break;
158             case VL_BADNAME:   fprintf(STDERR,"VLDB: volume name is illegal\n");
159                 break;
160             case VL_BADINDEX:   fprintf(STDERR,"VLDB: index was out of range\n");
161                 break;
162             case VL_BADVOLTYPE:   fprintf(STDERR,"VLDB: bad volume type\n");
163                 break;
164             case VL_BADSERVER:   fprintf(STDERR,"VLDB: illegal server number (not within limits)\n");
165                 break;
166             case VL_BADPARTITION:   fprintf(STDERR,"VLDB: bad partition number\n");
167                 break;
168             case VL_REPSFULL:   fprintf(STDERR,"VLDB: run out of space for replication sites\n");
169                 break;
170             case VL_NOREPSERVER:   fprintf(STDERR,"VLDB: no such repsite server exists\n");
171                 break;
172             case VL_DUPREPSERVER:   fprintf(STDERR,"VLDB: replication site server already exists\n");
173                 break;
174             case VL_RWNOTFOUND:   fprintf(STDERR,"VLDB: parent r/w entry not found\n");
175                 break;
176             case VL_BADREFCOUNT:   fprintf(STDERR,"VLDB: illegal reference count number\n");
177                 break;
178             case VL_SIZEEXCEEDED:   fprintf(STDERR,"VLDB: vldb size for attributes exceeded\n");
179                 break;
180             case VL_BADENTRY:   fprintf(STDERR,"VLDB: bad incoming vldb entry\n");
181                 break;
182             case VL_BADVOLIDBUMP:   fprintf(STDERR,"VLDB: illegal max volid increment\n");
183                 break;
184             case VL_IDALREADYHASHED:   fprintf(STDERR,"VLDB: (RO/BACK) Id already hashed\n");
185                 break;
186             case VL_ENTRYLOCKED:   fprintf(STDERR,"VLDB: vldb entry is already locked\n");
187                 break;
188             case VL_BADVOLOPER:   fprintf(STDERR,"VLDB: bad volume operation code\n");
189                 break;
190             case VL_BADRELLOCKTYPE:   fprintf(STDERR,"VLDB: bad release lock type\n");
191                 break;
192             case VL_RERELEASE:   fprintf(STDERR,"VLDB: status report: last release was aborted\n");
193                 break;
194             case VL_BADSERVERFLAG:      fprintf(STDERR,"VLDB: invalid replication site server flag\n");
195                 break;
196             case VL_PERM:       fprintf(STDERR,"VLDB: no permission access for call\n");
197                 break;
198             case VOLSERREAD_DUMPERROR:fprintf(STDERR,"VOLSER:  Problems encountered in reading the dump file !\n");
199                 break;
200             case VOLSERDUMPERROR:fprintf(STDERR,"VOLSER: Problems encountered in doing the dump !\n");
201                 break;
202             case VOLSERATTACH_ERROR: fprintf(STDERR,"VOLSER: Could not attach the volume\n");
203                 break;
204             case VOLSERDETACH_ERROR: fprintf(STDERR,"VOLSER: Could not detach the volume\n");
205                 break;
206             case VOLSERILLEGAL_PARTITION: fprintf(STDERR,"VOLSER: encountered illegal partition number\n");
207                 break;
208             case VOLSERBAD_ACCESS: fprintf(STDERR,"VOLSER: permission denied, not a super user\n");
209                 break;
210             case VOLSERVLDB_ERROR: fprintf(STDERR,"VOLSER: error detected in the VLDB\n");
211                 break;
212             case VOLSERBADNAME: fprintf(STDERR,"VOLSER: error in volume name\n");
213                 break;
214             case VOLSERVOLMOVED: fprintf(STDERR,"VOLSER: volume has moved\n");
215                 break;
216             case VOLSERBADOP: fprintf(STDERR,"VOLSER: illegal operation\n");
217                 break;
218             case VOLSERBADRELEASE: fprintf(STDERR,"VOLSER: release could not be completed\n");
219                 break;
220             case VOLSERVOLBUSY: fprintf(STDERR,"VOLSER: volume is busy\n");
221                 break;
222               case VOLSERNO_MEMORY: fprintf(STDERR,"VOLSER: volume server is out of memory\n");
223                 break;
224               case VOLSERNOVOL:fprintf(STDERR,"VOLSER: no such volume - location specified incorrectly or volume does not exist\n");
225                 break;
226               case VOLSERMULTIRWVOL: fprintf(STDERR,"VOLSER: multiple RW volumes with same ID, one of which should be deleted\n");
227                 break;
228               case VOLSERFAILEDOP: fprintf(STDERR,"VOLSER: not all entries were successfully processed\n");
229                 break;
230             default: 
231                 {
232
233                 afs_int32 offset;
234
235                 initialize_KA_error_table();
236                 initialize_RXK_error_table();
237                 initialize_KTC_error_table();
238                 initialize_ACFG_error_table();
239                 initialize_CMD_error_table();
240                 initialize_VL_error_table();
241                 
242                 offset = errcode & ((1<<ERRCODE_RANGE)-1);
243                 fprintf(STDERR,"%s: %s\n",error_table_name (errcode), error_message (errcode));
244                 break;
245                 }
246         }
247         return 0;
248 }
249
250
251 static struct rx_securityClass *uvclass=0;
252 static int uvindex = -1;
253 /* called by VLDBClient_Init to set the security module to be used in the RPC */
254 UV_SetSecurity(as, aindex)
255 register struct rx_securityClass *as;
256 afs_int32 aindex; {
257     uvindex = aindex;
258     uvclass = as;
259 }
260
261 /* bind to volser on <port> <aserver> */
262 /* takes server address in network order, port in host order.  dumb */
263 struct rx_connection *UV_Bind(aserver, port)
264 afs_int32 aserver, port; 
265 {
266     register struct rx_connection *tc;
267     
268     tc = rx_NewConnection(aserver, htons(port), VOLSERVICE_ID, uvclass, uvindex);
269     return tc;
270 }
271
272 /* if <okvol> is allright(indicated by beibg able to
273  * start a transaction, delete the <delvol> */
274 static afs_int32 CheckAndDeleteVolume(aconn,apart,okvol,delvol)
275 struct rx_connection *aconn;
276 afs_int32 apart,okvol,delvol;
277 {
278     afs_int32 error,code,tid,rcode;
279
280     error = 0;
281     code = 0;
282
283     if(okvol == 0) {
284         code = AFSVolTransCreate(aconn, delvol, apart, ITOffline,&tid);
285         if(!error && code) error = code;
286         code = AFSVolDeleteVolume(aconn,tid);
287         if(!error && code) error = code;
288         code = AFSVolEndTrans(aconn,tid, &rcode);
289         if(!code) code = rcode;
290         if(!error && code) error = code;
291         return error;
292     }
293     else {
294         code = AFSVolTransCreate(aconn, okvol, apart, ITOffline,&tid);
295         if(!code) {
296             code = AFSVolEndTrans(aconn,tid, &rcode);
297             if(!code) code = rcode;
298             if(!error && code) error = code;
299             code = AFSVolTransCreate(aconn, delvol, apart, ITOffline,&tid);
300             if(!error && code) error = code;
301             code = AFSVolDeleteVolume(aconn,tid);
302             if(!error && code) error = code;
303             code = AFSVolEndTrans(aconn,tid, &rcode);
304             if(!code) code = rcode;
305             if(!error && code) error = code;
306         }
307         else 
308             error = code;
309         return error;
310     }
311 }
312
313 /* called by EmuerateEntry, show vldb entry in a reasonable format */
314 void SubEnumerateEntry(entry)
315 struct nvldbentry *entry;
316 {
317     int i;
318     char pname[10];
319     int isMixed = 0;
320
321 #ifdef notdef
322     fprintf(STDOUT,"    readWriteID %-10u ",entry->volumeId[RWVOL]);
323     if(entry->flags & RW_EXISTS) fprintf(STDOUT," valid \n");else fprintf(STDOUT," invalid \n");
324     fprintf(STDOUT,"    readOnlyID  %-10u ",entry->volumeId[ROVOL]);
325     if(entry->flags & RO_EXISTS) fprintf(STDOUT," valid \n") ;else fprintf(STDOUT," invalid \n");
326     fprintf(STDOUT,"    backUpID    %-10u ",entry->volumeId[BACKVOL]);
327     if(entry->flags & BACK_EXISTS) fprintf(STDOUT," valid \n"); else fprintf(STDOUT," invalid \n");
328     if((entry->cloneId != 0) && (entry->flags & RO_EXISTS))
329         fprintf(STDOUT,"    releaseClone %-10u \n",entry->cloneId);
330 #else
331     if (entry->flags & RW_EXISTS)
332         fprintf(STDOUT,"    RWrite: %-10u",entry->volumeId[RWVOL]);
333     if (entry->flags & RO_EXISTS)
334         fprintf(STDOUT,"    ROnly: %-10u",entry->volumeId[ROVOL]);
335     if (entry->flags & BACK_EXISTS)
336         fprintf(STDOUT,"    Backup: %-10u",entry->volumeId[BACKVOL]);
337     if ((entry->cloneId != 0) && (entry->flags & RO_EXISTS))
338         fprintf(STDOUT,"    RClone: %-10u",entry->cloneId);
339     fprintf(STDOUT,"\n");
340 #endif
341     fprintf(STDOUT,"    number of sites -> %u\n",entry->nServers);
342     for(i = 0; i < entry->nServers; i++) {
343         if(entry->serverFlags[i] & NEW_REPSITE)
344             isMixed = 1;
345     }
346     for(i = 0; i < entry->nServers; i++) {
347         MapPartIdIntoName(entry->serverPartition[i],pname);
348         fprintf(STDOUT,"       server %s partition %s ",
349                 hostutil_GetNameByINet(entry->serverNumber[i]), pname);
350         if(entry->serverFlags[i] & ITSRWVOL) fprintf(STDOUT,"RW Site ") ; else fprintf(STDOUT,"RO Site ");
351         if (isMixed) {
352            if (entry->serverFlags[i] & NEW_REPSITE)
353               fprintf(STDOUT," -- New release");
354            else
355               fprintf(STDOUT," -- Old release");
356         } else {
357            if (entry->serverFlags[i] & RO_DONTUSE)
358               fprintf(STDOUT," -- Not released");
359         }
360         fprintf(STDOUT,"\n");
361     }
362     
363     return;
364     
365 }
366
367 /*enumerate the vldb entry corresponding to <entry> */
368 void EnumerateEntry(entry)
369 struct nvldbentry *entry;
370 {
371
372     fprintf(STDOUT,"\n");
373     fprintf(STDOUT,"%s \n",entry->name);
374     SubEnumerateEntry(entry);
375     return;
376 }
377
378 /* forcibly remove a volume.  Very dangerous call */
379 UV_NukeVolume(server, partid, volid)
380 afs_int32 server;
381 afs_int32 partid, volid; {
382     register struct rx_connection *tconn;
383     register afs_int32 code;
384
385     tconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
386     if (tconn) {
387         code = AFSVolNukeVolume(tconn, partid, volid);
388         rx_DestroyConnection(tconn);
389     }
390     else code = 0;
391     return code;
392 }
393
394 /* like df. Return usage of <pname> on <server> in <partition> */
395 UV_PartitionInfo(server,pname,partition)
396 afs_int32 server;
397 char *pname;
398 struct diskPartition *partition;
399 {
400     register struct rx_connection *aconn;
401     afs_int32 code;
402
403     code = 0;
404     aconn = (struct rx_connection *)0;
405     aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
406     code = AFSVolPartitionInfo(aconn,pname,partition);
407     if(code){
408         fprintf(STDERR,"Could not get information on partition %s\n",pname);
409         PrintError("",code);
410     }
411     if(aconn) rx_DestroyConnection(aconn);
412     return code;
413 }
414
415 /* old interface to create volume */
416 UV_CreateVolume(aserver, apart, aname, anewid)
417 afs_int32 apart, aserver;
418 char *aname;
419 afs_int32 *anewid; 
420 {
421 afs_int32 code;
422 code = UV_CreateVolume2(aserver, apart, aname, 5000, 0, 0, 0, 0, anewid);
423 return code;
424 }
425
426 /* create a volume, given a server, partition number, volume name --> sends
427 * back new vol id in <anewid>*/
428 UV_CreateVolume2(aserver, apart, aname, aquota, aspare1, aspare2, aspare3, aspare4, anewid)
429 afs_int32 apart, aserver;
430 afs_int32 aspare1, aspare2, aspare3, aspare4;
431 afs_int32 aquota;
432 char *aname;
433 afs_int32 *anewid; 
434 {
435
436     register struct rx_connection *aconn;
437     afs_int32 tid;
438     register afs_int32 code;
439     afs_int32 error;
440     afs_int32 rcode,vcode;
441     struct nvldbentry entry,storeEntry;/*the new vldb entry */
442     struct volintInfo tstatus;
443
444     tid = 0;
445     aconn = (struct rx_connection *)0;
446     error = 0;
447     memset(&tstatus, 0, sizeof(struct volintInfo));
448     tstatus.dayUse = -1;
449     tstatus.maxquota = aquota;
450
451     aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
452     /* next the next 3 available ids from the VLDB */
453     vcode = ubik_Call(VL_GetNewVolumeId,cstruct, 0, 3, anewid);
454     if(vcode) {
455         fprintf(STDERR,"Could not get an Id for volume %s\n",aname);
456         error = vcode;
457         goto cfail;
458     }
459     code = AFSVolCreateVolume(aconn, apart, aname, volser_RW, 0, anewid, &tid);
460     if (code) {
461         fprintf(STDERR,"Failed to create the volume %s %u \n",aname,*anewid);
462         error = code;
463         goto cfail;
464     }
465     
466     code = AFSVolSetInfo(aconn, tid, &tstatus);
467     if (code) {
468         fprintf(STDERR,"Could not change quota (error %d), continuing...\n", code);
469     }
470
471     code = AFSVolSetFlags(aconn, tid, 0); /* bring it online (mark it InService */
472     if (code) {
473         fprintf(STDERR,"Could not bring the volume %s %u online \n",aname,*anewid);
474         error = code;
475         goto cfail;
476     }
477     if(verbose) fprintf(STDOUT,"Volume %s %u created and brought online\n",aname,*anewid);
478     /* set up the vldb entry for this volume */
479     strncpy(entry.name, aname,VOLSER_OLDMAXVOLNAME);
480     entry.nServers = 1;
481     entry.serverNumber[0] = aserver;    /* this should have another 
482                                          level of indirection later */
483     entry.serverPartition[0] = apart;   /* this should also have 
484                                          another indirection level */
485     entry.flags = RW_EXISTS;/* this records that rw volume exists */
486     entry.serverFlags[0] = ITSRWVOL;    /*this rep site has rw  vol */
487     entry.volumeId[RWVOL] = *anewid;
488     entry.volumeId[ROVOL] = *anewid + 1;/* rw,ro, bk id are related in the default case */
489     entry.volumeId[BACKVOL] = *anewid + 2;
490     entry.cloneId = 0;
491     /*map into right byte order, before passing to xdr, the stuff has to be in host
492       byte order. Xdr converts it into network order */
493     MapNetworkToHost(&entry,&storeEntry);
494     /* create the vldb entry */
495     vcode = VLDB_CreateEntry(&storeEntry);
496     if(vcode) {
497         fprintf(STDERR,"Could not create a VLDB entry for the  volume %s %u\n", aname,*anewid);
498         /*destroy the created volume*/
499         if(verbose) {
500             fprintf(STDOUT,"Deleting the newly created volume %u\n",*anewid);
501         }
502         AFSVolDeleteVolume(aconn,tid);
503         error = vcode;
504         goto cfail;
505     }
506     if(verbose) fprintf(STDOUT,"Created the VLDB entry for the volume %s %u\n",aname,*anewid);
507     /* volume created, now terminate the transaction and release the connection*/
508     code = AFSVolEndTrans(aconn, tid, &rcode);/*if it crashes before this
509         the volume will come online anyway when transaction timesout , so if
510             vldb entry exists then the volume is guaranteed to exist too wrt create*/
511     tid = 0;
512     if(code){
513         fprintf(STDERR,"Failed to end the transaction on the volume %s %u\n",aname,*anewid); 
514         error = code;
515         goto cfail;
516     }
517
518     cfail:
519       if(tid)
520         {
521                 code= AFSVolEndTrans(aconn, tid, &rcode);
522                 if(code)
523                         fprintf(STDERR,"WARNING: could not end transaction\n");
524         }
525     if(aconn) rx_DestroyConnection(aconn);
526     PrintError("",error);
527     return error;
528     
529
530 }
531 /* create a volume, given a server, partition number, volume name --> sends
532 * back new vol id in <anewid>*/
533 UV_AddVLDBEntry(aserver, apart, aname, aid)
534   afs_int32 apart, aserver;
535   char *aname;
536   afs_int32 aid; 
537 {
538     register struct rx_connection *aconn;
539     afs_int32 error;
540     afs_int32 vcode;
541     struct nvldbentry entry,storeEntry;/*the new vldb entry */
542
543     aconn = (struct rx_connection *)0;
544     error = 0;
545
546     /* set up the vldb entry for this volume */
547     strncpy(entry.name, aname,VOLSER_OLDMAXVOLNAME);
548     entry.nServers = 1;
549     entry.serverNumber[0] = aserver;    /* this should have another 
550                                          level of indirection later */
551     entry.serverPartition[0] = apart;   /* this should also have 
552                                          another indirection level */
553     entry.flags = RW_EXISTS;/* this records that rw volume exists */
554     entry.serverFlags[0] = ITSRWVOL;    /*this rep site has rw  vol */
555     entry.volumeId[RWVOL] = aid;
556 #ifdef notdef
557     entry.volumeId[ROVOL] = anewid + 1;/* rw,ro, bk id are related in the default case */
558     entry.volumeId[BACKVOL] = *anewid + 2;
559 #else
560     entry.volumeId[ROVOL] = 0;
561     entry.volumeId[BACKVOL] = 0;
562 #endif
563     entry.cloneId = 0;
564     /*map into right byte order, before passing to xdr, the stuff has to be in host
565       byte order. Xdr converts it into network order */
566     MapNetworkToHost(&entry,&storeEntry);
567     /* create the vldb entry */
568     vcode = VLDB_CreateEntry(&storeEntry);
569     if(vcode) {
570         fprintf(STDERR,"Could not create a VLDB entry for the  volume %s %u\n", aname,aid);
571         error = vcode;
572         goto cfail;
573     }
574     if(verbose) fprintf(STDOUT,"Created the VLDB entry for the volume %s %u\n",aname,aid);
575
576   cfail:
577     if(aconn) rx_DestroyConnection(aconn);
578     PrintError("",error);
579     return error;
580 }
581
582 #define ERROR_EXIT(code) {error=(code); goto error_exit;}
583
584 /* Delete the volume <volid>on <aserver> <apart>
585  * the physical entry gets removed from the vldb only if the ref count 
586  * becomes zero
587  */
588 UV_DeleteVolume(aserver, apart, avolid)
589     afs_int32 aserver, apart, avolid; 
590 {
591     struct rx_connection *aconn = (struct rx_connection *)0;
592     afs_int32 ttid = 0;
593     afs_int32 code, rcode;
594     afs_int32 error = 0;
595     struct nvldbentry entry,storeEntry;
596     int islocked = 0;
597     afs_int32 avoltype = -1, vtype;
598     int notondisk = 0, notinvldb = 0;
599
600     /* Find and read bhe VLDB entry for this volume */
601     code = ubik_Call(VL_SetLock, cstruct, 0, avolid, avoltype, VLOP_DELETE);
602     if (code) {
603         if (code != VL_NOENT) {
604            fprintf(STDERR,"Could not lock VLDB entry for the volume %u\n", avolid);
605            ERROR_EXIT(code);
606         }
607         notinvldb = 1;
608     } else {
609        islocked = 1;
610
611        code = VLDB_GetEntryByID(avolid, avoltype, &entry);
612        if (code) {
613           fprintf(STDERR,"Could not fetch VLDB entry for volume %u\n",avolid);
614           ERROR_EXIT(code);
615        }
616        MapHostToNetwork(&entry);
617
618        if (verbose)
619           EnumerateEntry(&entry);
620     }
621
622     /* Whether volume is in the VLDB or not. Delete the volume on disk */
623     aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
624     code = AFSVolTransCreate(aconn, avolid, apart, ITOffline, &ttid);
625     if (code) {
626        if (code == VNOVOL) {
627           notondisk = 1;
628        } else {
629            fprintf(STDERR,"Transaction on volume %u failed\n", avolid);
630            ERROR_EXIT(code);
631        }
632     }
633     else {
634        if (verbose) {
635           fprintf(STDOUT,"Trying to delete the volume %u ...", avolid);
636           fflush(STDOUT);
637        }
638        code = AFSVolDeleteVolume(aconn, ttid);
639        if (code) {
640           fprintf(STDERR,"Could not delete the volume %u \n", avolid);
641           ERROR_EXIT(code);
642        }
643        code = AFSVolEndTrans(aconn, ttid, &rcode);
644        code = (code ? code : rcode);
645        ttid = 0;
646        if (code) {
647           fprintf(STDERR,"Could not end the transaction for the volume %u \n",avolid);
648           ERROR_EXIT(code);
649        }
650        if (verbose)
651           fprintf(STDOUT," done\n");
652     }
653
654     /* Now update the VLDB entry.
655      * But first, verify we have a VLDB entry.
656      * Whether volume is on disk or not. Delete the volume in VLDB.
657      */
658     if (notinvldb)
659        ERROR_EXIT(0);
660
661     if (avolid == entry.volumeId[BACKVOL]) {
662         /* Its a backup volume, modify the VLDB entry. Check that the
663          * backup volume is on the server/partition we asked to delete.
664          */
665         if ( !(entry.flags & BACK_EXISTS) || !Lp_Match(aserver,apart,&entry)) {
666            notinvldb = 2;         /* Not on this server and partition */
667            ERROR_EXIT(0);
668         }
669
670         if (verbose)
671            fprintf(STDOUT,"Marking the backup volume %u deleted in the VLDB\n", avolid);
672
673         entry.flags &= ~BACK_EXISTS;
674         vtype = BACKVOL;
675     }
676
677     else if (avolid == entry.volumeId[ROVOL]) {
678         /* Its a read-only volume, modify the VLDB entry. Check that the
679          * readonly volume is on the server/partition we asked to delete.
680          * If flags does not have RO_EIXSTS set, then this may mean the RO 
681          * hasn't been released (and could exist in VLDB).
682          */
683         if (!Lp_ROMatch(aserver,apart,&entry)) {
684            notinvldb = 2;            /* Not found on this server and partition */
685            ERROR_EXIT(0);
686         }
687         
688         if (verbose)
689            fprintf(STDOUT,"Marking the readonly volume %u deleted in the VLDB\n", avolid);
690
691         Lp_SetROValue(&entry, aserver, apart, 0, 0);  /* delete the site */
692         entry.nServers--;
693         if (!Lp_ROMatch(0,0,&entry))
694            entry.flags &= ~RO_EXISTS;    /* This was the last ro volume */
695         vtype = ROVOL;
696     }
697
698     else if (avolid == entry.volumeId[RWVOL]) {
699         /* It's a rw volume, delete the backup volume, modify the VLDB entry.
700          * Check that the readwrite volumes is on the server/partition we
701          * asked to delete.
702          */
703         if (!(entry.flags & RW_EXISTS) || !Lp_Match(aserver,apart,&entry)) {
704            notinvldb = 2;          /* Not found on this server and partition */
705            ERROR_EXIT(0);
706         }
707         
708         /* Delete backup if it exists */
709         code = AFSVolTransCreate(aconn, entry.volumeId[BACKVOL], apart, ITOffline, &ttid);
710         if (!code) {
711            if (verbose) {
712               fprintf(STDOUT,"Trying to delete the backup volume %u ...", entry.volumeId[BACKVOL]);
713               fflush(STDOUT);
714            }
715            code = AFSVolDeleteVolume(aconn, ttid);
716            if (code) {
717               fprintf(STDERR,"Could not delete the volume %u \n", entry.volumeId[BACKVOL]);
718               ERROR_EXIT(code);
719            }
720            code = AFSVolEndTrans(aconn, ttid, &rcode);
721            ttid = 0;
722            code = (code ? code : rcode);
723            if (code) {
724               fprintf(STDERR,"Could not end the transaction for the volume %u \n",
725                       entry.volumeId[BACKVOL]);
726               ERROR_EXIT(code);
727            }
728            if (verbose)
729               fprintf(STDOUT," done\n");
730         }
731
732         if (verbose)
733            fprintf(STDOUT,"Marking the readwrite volume %u%s deleted in the VLDB\n", 
734                    avolid, ((entry.flags & BACK_EXISTS)?", and its backup volume,":""));
735
736         Lp_SetRWValue(&entry, aserver, apart, 0L, 0L);
737         entry.nServers--;
738         entry.flags &= ~(BACK_EXISTS | RW_EXISTS);
739         vtype = RWVOL;
740
741         if (entry.flags & RO_EXISTS)
742            fprintf(STDERR,"WARNING: ReadOnly copy(s) may still exist\n");
743     }
744
745     else {
746        notinvldb = 2;         /* Not found on this server and partition */
747        ERROR_EXIT(0);
748     }
749
750     /* Either delete or replace the VLDB entry */
751     if ((entry.nServers <= 0) || !(entry.flags & (RO_EXISTS | RW_EXISTS))) {
752        if (verbose)
753           fprintf(STDOUT,"Last reference to the VLDB entry for %u - deleting entry\n", avolid);
754        code = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, vtype);
755        if (code) {
756           fprintf(STDERR,"Could not delete the VLDB entry for the volume %u \n",avolid);
757           ERROR_EXIT(code);
758        }
759     } else {
760        MapNetworkToHost(&entry, &storeEntry);
761        code = VLDB_ReplaceEntry(avolid, vtype, &storeEntry,
762                                 (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
763        if (code) {
764           fprintf(STDERR,"Could not update the VLDB entry for the volume %u \n", avolid);
765           ERROR_EXIT(code);
766        }
767     }
768     islocked = 0;
769
770   error_exit:
771     if (error) PrintError("", error);
772
773     if (notondisk && notinvldb) {
774        fprintf(STDERR,"Volume %u does not exist %s\n",
775                avolid, ((notinvldb == 2)?"on server and partition":""));
776        PrintError("", VOLSERNOVOL);
777        if (!error) error = VOLSERNOVOL;
778     }
779     else if (notondisk) {
780        fprintf(STDERR,"WARNING: Volume %u did not exist on the partition\n", avolid);
781     }
782     else if (notinvldb) {
783        fprintf(STDERR,"WARNING: Volume %u does not exist in VLDB %s\n",
784                avolid, ((notinvldb == 2)?"on server and partition":""));
785     }
786
787     if (ttid) {
788         code = AFSVolEndTrans(aconn, ttid, &rcode);
789         code = (code ? code : rcode);
790         if (code) {
791             fprintf(STDERR,"Could not end transaction on the volume %u\n", avolid);
792             PrintError("", code);
793             if (!error) error = code;
794         }
795     }
796
797     if (islocked) {
798         code = ubik_Call(VL_ReleaseLock,cstruct, 0, avolid, -1, 
799                          (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
800         if (code) {
801             fprintf(STDERR,"Could not release the lock on the VLDB entry for the volume %u \n", 
802                     avolid);
803             PrintError("", code);
804             if (!error) error = code;
805         }
806     }
807
808     if (aconn) rx_DestroyConnection(aconn);
809     return error;
810 }
811
812 /* add recovery to UV_MoveVolume */
813
814 #define TESTC   0       /* set to test recovery code, clear for production */
815
816 jmp_buf env;
817 int interrupt=0;
818
819 void sigint_handler(x)
820 {
821         if(interrupt)
822                 longjmp(env,0);
823
824         fprintf(STDOUT,
825                 "\nSIGINT handler: vos move operation in progress\n");
826         fprintf(STDOUT,
827                 "WARNING: may leave AFS storage and metadata in indeterminate state\n");
828         fprintf(STDOUT,
829                 "enter second control-c to exit\n");
830         fflush(STDOUT);
831
832         interrupt=1;
833         signal(SIGINT,sigint_handler);
834
835         return;
836 }
837
838 #define ONERR(ec, es, ep) if (ec) { fprintf(STDERR, (es), (ep)); PrintError("   ",ec); error = (ec); goto mfail; }
839
840 /* Move volume <afromvol> on <afromserver> <afrompart> to <atoserver>
841  * <atopart>. The operation is almost idempotent 
842  */
843
844 UV_MoveVolume(afromvol, afromserver, afrompart, atoserver, atopart)
845      afs_int32 afromvol; 
846      afs_int32 afromserver, atoserver;
847      afs_int32 afrompart,   atopart;
848 {
849     struct rx_connection *toconn, *fromconn ;
850     afs_int32                fromtid, totid, clonetid;
851     char                 vname[64];
852     char                 *volName = 0;
853     char                 tmpName[VOLSER_MAXVOLNAME +1];
854     afs_int32                rcode;
855     afs_int32                fromDate;
856     struct restoreCookie cookie;
857     register afs_int32       vcode, code;
858     afs_int32                newVol, volid, backupId;
859     struct volser_status tstatus;
860     struct destServer    destination;
861
862     struct nvldbentry    entry, storeEntry;
863     int                  i, islocked, pntg;
864     afs_int32                error;
865     char                 in,lf;                         /* for test code */
866     int                  same;
867
868 #ifdef  ENABLE_BUGFIX_1165
869     volEntries volumeInfo;
870     struct volintInfo *infop = 0;
871 #endif
872
873     islocked = 0;
874     fromconn = (struct rx_connection *)0;
875     toconn   = (struct rx_connection *)0;
876     fromtid  = 0;
877     totid    = 0;
878     clonetid = 0;
879     error    = 0;
880     volid    = 0;
881     pntg     = 0;
882     backupId = 0;
883     newVol   = 0;
884
885     /* support control-c processing */
886     if (setjmp(env)) goto mfail;
887     (void) signal(SIGINT,sigint_handler);
888  
889     if (TESTC)
890     {
891         fprintf(STDOUT,
892                 "\nThere are three tests points - verifies all code paths through recovery.\n");
893         fprintf(STDOUT,"First test point - operation not started.\n");
894         fprintf(STDOUT,"...test here (y, n)? ");
895         fflush(STDOUT);
896         fscanf(stdin,"%c",&in);
897         fscanf(stdin,"%c",&lf); /* toss away */
898         if (in=='y')
899         {
900             fprintf(STDOUT,"type control-c\n");
901             while(1)
902             {
903                 fprintf(stdout,".");
904                 fflush(stdout);
905                 sleep(1);
906             }
907         }
908         /* or drop through */
909     }
910
911     vcode = VLDB_GetEntryByID(afromvol, -1, &entry);
912     ONERR (vcode, "Could not fetch the entry for the volume  %u from the VLDB \n", afromvol);
913
914     if (entry.volumeId[RWVOL] != afromvol)
915     {
916         fprintf(STDERR,"Only RW volume can be moved\n");
917         exit(1);
918     }
919
920     vcode = ubik_Call(VL_SetLock, cstruct, 0,afromvol, RWVOL, VLOP_MOVE);
921     ONERR (vcode, "Could not lock entry for volume %u \n", afromvol);
922     islocked = 1;
923
924     vcode = VLDB_GetEntryByID (afromvol, RWVOL, &entry);
925     ONERR (vcode, "Could not fetch the entry for the volume  %u from the VLDB \n", afromvol);
926
927     backupId = entry.volumeId[BACKVOL];
928     MapHostToNetwork(&entry);
929
930     if ( !Lp_Match(afromserver, afrompart, &entry) )
931     {
932         /* the from server and partition do not exist in the vldb entry corresponding to volid */
933         if ( !Lp_Match(atoserver, atopart, &entry) ) 
934         {
935             /* the to server and partition do not exist in the vldb entry corresponding to volid */
936             fprintf(STDERR,"The volume %u is not on the specified site. \n", afromvol);
937             fprintf(STDERR,"The current site is :");
938             for (i=0; i<entry.nServers; i++)
939             {
940                 if (entry.serverFlags[i] == ITSRWVOL)
941                 {
942                     char pname[10];
943                     MapPartIdIntoName(entry.serverPartition[i],pname);
944                     fprintf(STDERR," server %s partition %s \n",
945                             hostutil_GetNameByINet(entry.serverNumber[i]), pname);
946                 }
947             }
948             vcode = ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
949                               (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
950             ONERR (vcode, " Could not release lock on the VLDB entry for the volume %u \n",
951                    afromvol);
952
953             return VOLSERVOLMOVED;
954         }
955
956         /* delete the volume afromvol on src_server */
957         /* from-info does not exist but to-info does =>
958          * we have already done the move, but the volume
959          * may still be existing physically on from fileserver
960          */
961         fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
962         fromtid = 0;
963         pntg = 1;
964
965         code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITOffline, &fromtid);
966         if (!code) 
967         {   /* volume exists - delete it */
968             code = AFSVolSetFlags(fromconn, fromtid, VTDeleteOnSalvage | VTOutOfService);
969             ONERR (code, "Failed to set flags on the volume %u\n", afromvol);
970
971             code = AFSVolDeleteVolume(fromconn,fromtid);
972             ONERR (code, "Failed to delete the volume %u\n", afromvol);
973             
974             code = AFSVolEndTrans(fromconn, fromtid, &rcode);
975             fromtid = 0;
976             if (!code) code = rcode;
977             ONERR (code, "Could not end the transaction for the volume %u \n", afromvol);
978         }
979
980         /*delete the backup volume now */
981         fromtid = 0;
982         code = AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline, &fromtid);
983         if (!code) 
984         {   /* backup volume exists - delete it */
985             code = AFSVolSetFlags(fromconn, fromtid, VTDeleteOnSalvage | VTOutOfService);
986             ONERR (code, "Failed to set flags on the backup volume %u\n", backupId);
987
988             code = AFSVolDeleteVolume(fromconn,fromtid);
989             ONERR (code, "Could not delete the backup volume %u\n", backupId);
990
991             code = AFSVolEndTrans(fromconn, fromtid, &rcode);
992             fromtid = 0;
993             if (!code) code = rcode;
994             ONERR (code,"Could not end the transaction for the backup volume %u \n",backupId);
995         }
996
997         fromtid = 0;
998         error = 0;
999         goto mfail;
1000     }
1001
1002     /* From-info matches the vldb info about volid,
1003      * its ok start the move operation, the backup volume 
1004      * on the old site is deleted in the process 
1005      */
1006     if (afrompart == atopart) 
1007     {
1008         same = VLDB_IsSameAddrs (afromserver, atoserver, &error);
1009         if (error) 
1010         {
1011             fprintf(STDERR, "Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n", 
1012                     afromserver, error);
1013             goto mfail;
1014         }
1015         if (same) ONERR (VOLSERVOLMOVED, 
1016                          "Warning: Moving volume %u to its home partition ignored!\n", afromvol);
1017     }
1018
1019     pntg = 1;
1020     toconn   = UV_Bind(atoserver,   AFSCONF_VOLUMEPORT); /* get connections to the servers */
1021     fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
1022     fromtid = totid = 0;        /* initialize to uncreated */
1023
1024     /* ***
1025      * clone the read/write volume locally.
1026      * ***/
1027
1028     if (verbose) fprintf(STDOUT,"Starting transaction on source volume %u ...",afromvol);
1029     fflush(STDOUT);
1030     code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
1031     ONERR (code, "Failed to create transaction on the volume %u\n", afromvol);
1032     if (verbose) fprintf(STDOUT," done\n");
1033
1034     /* Get a clone id */
1035     newVol = 0;
1036     vcode = ubik_Call (VL_GetNewVolumeId, cstruct, 0, 1, &newVol);
1037     ONERR (vcode, "Could not get an ID for the clone of volume %u from the VLDB\n", afromvol);
1038
1039     /* Do the clone. Default flags on clone are set to delete on salvage and out of service */
1040     if (verbose) fprintf (STDOUT,"Cloning source volume %u ...", afromvol);
1041     fflush(STDOUT);
1042     strcpy(vname, "move-clone-temp");
1043     code = AFSVolClone(fromconn, fromtid, 0,readonlyVolume, vname, &newVol);
1044     ONERR (code, "Failed to clone the source volume %u\n", afromvol);
1045     if (verbose) fprintf(STDOUT," done\n");
1046
1047     /* lookup the name of the volume we just cloned */
1048     volid = afromvol;
1049     code = AFSVolGetName(fromconn, fromtid, &volName);
1050     ONERR (code, "Failed to get the name of the volume %u\n", newVol);
1051
1052     if (verbose) fprintf (STDOUT,"Ending the transaction on the source volume %u ...", afromvol);
1053     fflush(STDOUT);
1054     rcode = 0;
1055     code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1056     fromtid = 0;
1057     if (!code) code = rcode;
1058     ONERR (code, "Failed to end the transaction on the source volume %u\n", afromvol);
1059     if (verbose) fprintf (STDOUT," done\n");
1060
1061     /* ***
1062      * Create the destination volume
1063      * ***/
1064
1065     if (verbose) fprintf(STDOUT, "Starting transaction on the cloned volume %u ...", newVol);
1066     fflush(STDOUT);
1067     code = AFSVolTransCreate (fromconn, newVol, afrompart, ITOffline, &clonetid);
1068     ONERR (code, "Failed to start a transaction on the cloned volume%u\n", newVol);
1069     if (verbose) fprintf(STDOUT," done\n");
1070
1071     code = AFSVolSetFlags (fromconn, clonetid, VTDeleteOnSalvage|VTOutOfService); /*redundant */
1072     ONERR (code, "Could not set falgs on the cloned volume %u\n", newVol);
1073
1074     /* remember time from which we've dumped the volume */
1075     code = AFSVolGetStatus (fromconn, clonetid, &tstatus);
1076     ONERR (code, "Failed to get the status of the cloned volume %u\n", newVol);
1077
1078     fromDate = tstatus.creationDate-CLOCKSKEW;
1079
1080 #ifdef  ENABLE_BUGFIX_1165
1081     /*
1082      * Get the internal volume state from the source volume. We'll use such info (i.e. dayUse)
1083      * to copy it to the new volume (via AFSSetInfo later on) so that when we move volumes we
1084      * don't use this information...
1085      */
1086     volumeInfo.volEntries_val = (volintInfo *)0;/*this hints the stub to allocate space*/
1087     volumeInfo.volEntries_len = 0;
1088     code = AFSVolListOneVolume(fromconn, afrompart, afromvol, &volumeInfo);
1089     ONERR (code, "Failed to get the volint Info of the cloned volume %u\n", afromvol);
1090
1091     infop = (volintInfo *) volumeInfo.volEntries_val;
1092     infop->maxquota = -1;                       /* Else it will replace the default quota */
1093 #endif
1094
1095     /* create a volume on the target machine */
1096     volid = afromvol;
1097     code = AFSVolTransCreate (toconn, volid, atopart, ITOffline, &totid);
1098     if (!code) 
1099     {  
1100       /* Delete the existing volume.
1101        * While we are deleting the volume in these steps, the transaction
1102        * we started against the cloned volume (clonetid above) will be
1103        * sitting idle. It will get cleaned up after 600 seconds
1104        */
1105         if (verbose) fprintf(STDOUT,"Deleting pre-existing volume %u on destination ...",volid);
1106         fflush(STDOUT);
1107
1108         code = AFSVolDeleteVolume(toconn, totid);
1109         ONERR (code, "Could not delete the pre-existing volume %u on destination\n", volid);
1110         
1111         code = AFSVolEndTrans(toconn, totid, &rcode);
1112         totid = 0;
1113         if (!code) code = rcode;
1114         ONERR (code, "Could not end the transaction on pre-existing volume %u on destination\n",
1115                volid);
1116
1117         if (verbose) fprintf(STDOUT," done\n");
1118     }
1119
1120     if (verbose) fprintf(STDOUT,"Creating the destination volume %u ...",volid);
1121     fflush(STDOUT);
1122     code = AFSVolCreateVolume (toconn, atopart, volName, volser_RW, volid, &volid, &totid);
1123     ONERR (code, "Failed to create the destination volume %u\n", volid);
1124     if (verbose) fprintf(STDOUT," done\n");
1125
1126     strncpy(tmpName, volName, VOLSER_OLDMAXVOLNAME);
1127     free(volName);
1128     volName = (char *) 0;
1129
1130     code = AFSVolSetFlags (toconn, totid, (VTDeleteOnSalvage | VTOutOfService));
1131     ONERR(code, "Failed to set the flags on the destination volume %u\n", volid);
1132
1133     /***
1134      * Now dump the clone to the new volume
1135      ***/
1136
1137     destination.destHost = ntohl(atoserver);
1138     destination.destPort = AFSCONF_VOLUMEPORT;
1139     destination.destSSID = 1;
1140
1141     /* Copy the clone to the new volume */
1142     if (verbose) fprintf(STDOUT, "Dumping from clone %u on source to volume %u on destination ...",
1143                          newVol, afromvol);
1144     fflush(STDOUT);
1145     strncpy(cookie.name,tmpName,VOLSER_OLDMAXVOLNAME);
1146     cookie.type   = RWVOL;
1147     cookie.parent = entry.volumeId[RWVOL];
1148     cookie.clone  = 0;
1149     code = AFSVolForward(fromconn, clonetid, 0, &destination, totid, &cookie);
1150     ONERR (code, "Failed to move data for the volume %u\n", volid);
1151     if (verbose) fprintf(STDOUT," done\n");
1152
1153     code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1154     if (!code) code = rcode;
1155     clonetid = 0;
1156     ONERR (code, "Failed to end the transaction on the cloned volume %u\n", newVol);
1157
1158     /* ***
1159      * reattach to the main-line volume, and incrementally dump it.
1160      * ***/
1161
1162     if (verbose) 
1163         fprintf(STDOUT,"Doing the incremental dump from source to destination for volume %u ... ", 
1164                 afromvol);
1165     fflush(STDOUT);
1166     
1167     code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
1168     ONERR (code, "Failed to create a transaction on the source volume %u\n", afromvol);
1169
1170     /* now do the incremental */
1171     code = AFSVolForward(fromconn, fromtid, fromDate, &destination, totid,&cookie);
1172     ONERR (code, "Failed to do the incremental dump from rw volume on old site to rw volume on newsite\n", 0);
1173     if (verbose)fprintf(STDOUT," done\n");
1174
1175     /* now adjust the flags so that the new volume becomes official */
1176     code = AFSVolSetFlags(fromconn, fromtid, VTOutOfService);
1177     ONERR (code, "Failed to set the flags to make old source volume offline\n", 0);
1178
1179     code = AFSVolSetFlags(toconn, totid, 0);
1180     ONERR (code, "Failed to set the flags to make new source volume online\n", 0);
1181
1182 #ifdef  ENABLE_BUGFIX_1165
1183     code = AFSVolSetInfo(toconn, totid, infop);
1184     ONERR (code, "Failed to set volume status on the destination volume %u\n", volid);
1185 #endif
1186
1187     /* put new volume online */
1188     code = AFSVolEndTrans(toconn, totid, &rcode);
1189     totid = 0;
1190     if (!code) code = rcode;
1191     ONERR (code, "Failed to end the transaction on the volume %u on the new site\n", afromvol);
1192
1193     Lp_SetRWValue(&entry, afromserver, afrompart, atoserver, atopart);
1194     MapNetworkToHost(&entry,&storeEntry);
1195     storeEntry.flags &= ~BACK_EXISTS;
1196
1197     if (TESTC)
1198     {
1199         fprintf(STDOUT, "Second test point - operation in progress but not complete.\n");
1200         fprintf(STDOUT,"...test here (y, n)? ");
1201         fflush(STDOUT);
1202         fscanf(stdin,"%c",&in);
1203         fscanf(stdin,"%c",&lf); /* toss away */
1204         if (in=='y')
1205         {
1206             fprintf(STDOUT,"type control-c\n");
1207             while(1)
1208             {
1209                 fprintf(stdout,".");
1210                 fflush(stdout);
1211                 sleep(1);
1212             }
1213         }
1214         /* or drop through */
1215     }
1216
1217     vcode = VLDB_ReplaceEntry (afromvol, -1, &storeEntry, 
1218                                (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1219     if (vcode) 
1220     {
1221         fprintf(STDERR," Could not release the lock on the VLDB entry for the volume %s %u \n",
1222                 storeEntry.name,afromvol);
1223         error = vcode;
1224         goto mfail;
1225     }
1226     islocked=0;
1227
1228     if (TESTC)
1229     {
1230         fprintf(STDOUT, "Third test point - operation complete but no cleanup.\n");
1231         fprintf(STDOUT,"...test here (y, n)? ");
1232         fflush(STDOUT);
1233         fscanf(stdin,"%c",&in);
1234         fscanf(stdin,"%c",&lf); /* toss away */
1235         if (in=='y')
1236         {
1237             fprintf(STDOUT,"type control-c\n");
1238             while(1)
1239             {
1240                 fprintf(stdout,".");
1241                 fflush(stdout);
1242                 sleep(1);
1243             }
1244         }
1245         /* or drop through */
1246     }
1247
1248 #ifdef notdef
1249     /* This is tricky.  File server is very stupid, and if you mark the volume
1250      * as VTOutOfService, it may mark the *good* instance (if you're moving
1251      * between partitions on the same machine) as out of service.  Since
1252      * we're cleaning this code up in DEcorum, we're just going to kludge around
1253      * it for now by removing this call. */
1254     /* already out of service, just zap it now */
1255     code = AFSVolSetFlags(fromconn, fromtid, VTDeleteOnSalvage | VTOutOfService);
1256     if (code)
1257     {
1258         fprintf(STDERR,"Failed to set the flags to make the old source volume offline\n");
1259         goto mfail;
1260     }
1261 #endif
1262     if (atoserver != afromserver) 
1263     {
1264         /* set forwarding pointer for moved volumes */
1265         code = AFSVolSetForwarding(fromconn, fromtid, atoserver);
1266         ONERR (code, "Failed to set the forwarding pointer for the volume %u\n", afromvol);
1267     }
1268
1269     if (verbose) fprintf(STDOUT,"Deleting old volume %u on source ...", afromvol);
1270     fflush(STDOUT);
1271
1272     code = AFSVolDeleteVolume(fromconn,fromtid);        /* zap original volume */
1273     ONERR (code, "Failed to delete the old volume %u on source\n", afromvol); 
1274     
1275     code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1276     fromtid = 0;
1277     if (!code) code = rcode;
1278     ONERR (code, "Failed to end the transaction on the old volume %u on the source\n", afromvol);
1279
1280     if (verbose) fprintf(STDOUT," done\n");
1281
1282     /* Delete the backup volume on the original site */
1283     code = AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline, &fromtid);
1284     if (!code) 
1285     {
1286         fprintf(STDOUT, "WARNING : Deleting the backup volume %u on the source ...",backupId);
1287         fflush(STDOUT);
1288
1289         code = AFSVolSetFlags(fromconn, fromtid, VTDeleteOnSalvage | VTOutOfService);
1290         ONERR (code, "Failed to set the flags on the backup volume on source\n", 0);
1291
1292         code = AFSVolDeleteVolume(fromconn,fromtid);
1293         ONERR (code, "Failed to delete the backup volume on source\n", 0);
1294         
1295         code = AFSVolEndTrans(fromconn,fromtid, &rcode);
1296         fromtid = 0;
1297         if (!code) code = rcode;
1298         ONERR (code, "Failed to end the transaction on the backup volume %u on source\n", 0);
1299
1300         fprintf(STDOUT," done\n");
1301     }
1302     else code = 0;              /* no backup volume? that's okay */
1303
1304     fromtid = 0;
1305     if (verbose) fprintf(STDOUT,"Starting transaction on the cloned volume %u ...",newVol);
1306     fflush(STDOUT);
1307
1308     code = AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline, &clonetid);
1309     ONERR (code, "Failed to start a transaction on the cloned volume%u\n", newVol);
1310
1311     if (verbose) fprintf(STDOUT," done\n");
1312     
1313     /* now delete the clone */
1314     if (verbose) fprintf(STDOUT,"Deleting the clone %u ...", newVol);
1315     fflush(STDOUT);
1316
1317     code = AFSVolDeleteVolume(fromconn, clonetid);
1318     ONERR (code, "Failed to delete the cloned volume %u\n", newVol);
1319     
1320     if (verbose) fprintf(STDOUT," done\n");
1321
1322     code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1323     if (!code) code = rcode;
1324     clonetid = 0;
1325     ONERR (code, "Failed to end the transaction on the cloned volume %u\n", newVol);
1326
1327     /* fall through */
1328     /* END OF MOVE */
1329
1330     if (TESTC)
1331     {
1332         fprintf(STDOUT,"Fourth test point - operation complete.\n");
1333         fprintf(STDOUT,"...test here (y, n)? ");
1334         fflush(STDOUT);
1335         fscanf(stdin,"%c",&in);
1336         fscanf(stdin,"%c",&lf); /* toss away */
1337         if (in=='y')
1338         {
1339             fprintf(STDOUT,"type control-c\n");
1340             while(1)
1341             {
1342                 fprintf(stdout,".");
1343                 fflush(stdout);
1344                 sleep(1);
1345             }
1346         }
1347         /* or drop through */
1348     }
1349
1350     /* normal cleanup code */
1351
1352     if (entry.flags & RO_EXISTS) fprintf(STDERR,"WARNING : readOnly copies still exist \n");
1353
1354     if (islocked)
1355     {
1356         vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, afromvol, -1, 
1357                           (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1358         if (vcode) 
1359         {
1360             fprintf(STDERR," Could not release the lock on the VLDB entry for the volume %u \n",
1361                     afromvol);
1362             if (!error) error = vcode;
1363         }
1364     }
1365     
1366     if (fromtid) 
1367     {
1368         code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1369         if (code || rcode)
1370         {
1371             fprintf(STDERR,"Could not end transaction on the source's clone volume %u\n", newVol);
1372             if (!error) error = (code ? code : rcode);
1373         }
1374     }
1375
1376     if (clonetid) 
1377     {
1378         code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1379         if (code || rcode) 
1380         {
1381             fprintf(STDERR,"Could not end transaction on the source's clone volume %u\n",newVol);
1382             if (!error) error = (code ? code : rcode);
1383         }
1384     }
1385
1386     if (totid) 
1387     {
1388         code = AFSVolEndTrans(toconn, totid, &rcode);
1389         if (code) 
1390         {
1391             fprintf(STDERR,"Could not end transaction on destination volume %u\n",afromvol);
1392             if (!error) error = (code ? code : rcode);
1393         }
1394     }
1395     if (volName) free(volName);
1396 #ifdef  ENABLE_BUGFIX_1165
1397     if (infop)   free(infop);
1398 #endif
1399     if (fromconn) rx_DestroyConnection(fromconn);
1400     if (toconn)   rx_DestroyConnection(toconn);
1401     PrintError("",error);
1402     return error;
1403
1404     /* come here only when the sky falls */
1405 mfail:
1406
1407     if (pntg) 
1408     {
1409         fprintf(STDOUT,"vos move: operation interrupted, cleanup in progress...\n");
1410         fprintf(STDOUT,"clear transaction contexts\n");
1411         fflush(STDOUT);
1412     }
1413
1414     /* unlock VLDB entry */
1415     if (islocked)
1416         ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
1417                   (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1418
1419     if (clonetid) AFSVolEndTrans(fromconn, clonetid, &rcode);
1420     if (totid)    AFSVolEndTrans(toconn, totid, &rcode);
1421     if (fromtid)
1422     {  /* put it on-line */
1423         AFSVolSetFlags(fromconn,fromtid,0);
1424         AFSVolEndTrans(fromconn, fromtid, &rcode);
1425     }
1426
1427     if (verbose) 
1428     {   /* get current VLDB entry */
1429         fprintf(STDOUT,"access VLDB\n");
1430         fflush(STDOUT);
1431     }
1432     vcode= VLDB_GetEntryByID (afromvol, -1, &entry);
1433     if (vcode)
1434     {
1435         fprintf(STDOUT,"FATAL: VLDB access error: abort cleanup\n");
1436         fflush(STDOUT);
1437         goto done;
1438     }
1439     MapHostToNetwork(&entry);
1440
1441     /* Delete either the volume on the source location or the target location. 
1442      * If the vldb entry still points to the source location, then we know the
1443      * volume move didn't finish so we remove the volume from the target 
1444      * location. Otherwise, we remove the volume from the source location.
1445      */
1446     if (Lp_Match(afromserver,afrompart,&entry)) {  /* didn't move - delete target volume */
1447         if (pntg) {
1448             fprintf(STDOUT,
1449                     "move incomplete - attempt cleanup of target partition - no guarantee\n");
1450             fflush(STDOUT);
1451         }
1452
1453         if (volid && toconn) {
1454             code=AFSVolTransCreate(toconn,volid,atopart, ITOffline,&totid);
1455             if (!code) {
1456                 AFSVolSetFlags(toconn,totid, VTDeleteOnSalvage | VTOutOfService);
1457                 AFSVolDeleteVolume(toconn,totid);
1458                 AFSVolEndTrans(toconn,totid,&rcode);
1459             }
1460         }
1461
1462         /* put source volume on-line */
1463         if (fromconn) {
1464             code=AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
1465             if (!code) {
1466                 AFSVolSetFlags(fromconn,fromtid,0);
1467                 AFSVolEndTrans(fromconn,fromtid,&rcode);
1468             }
1469         }
1470     }
1471     else {      /* yep, move complete */
1472         if (pntg) {
1473             fprintf(STDOUT,
1474                     "move complete - attempt cleanup of source partition - no guarantee\n");
1475             fflush(STDOUT);
1476         }
1477
1478         /* delete backup volume */
1479         if (fromconn) {
1480             code=AFSVolTransCreate (fromconn,backupId,afrompart, ITOffline,&fromtid);
1481             if (!code) {
1482                 AFSVolSetFlags(fromconn,fromtid, VTDeleteOnSalvage | VTOutOfService);
1483                 AFSVolDeleteVolume(fromconn,fromtid);
1484                 AFSVolEndTrans(fromconn,fromtid,&rcode);
1485             }
1486
1487             /* delete source volume */
1488             code=AFSVolTransCreate (fromconn, afromvol, afrompart, ITBusy, &fromtid);
1489             if (!code) {
1490                 AFSVolSetFlags(fromconn,fromtid, VTDeleteOnSalvage | VTOutOfService);
1491                 if (atoserver != afromserver)
1492                     AFSVolSetForwarding(fromconn,fromtid,atoserver);
1493                 AFSVolDeleteVolume(fromconn,fromtid);
1494                 AFSVolEndTrans(fromconn,fromtid,&rcode);
1495             }
1496         }
1497     }
1498
1499     /* common cleanup - delete local clone */
1500     if (newVol) {
1501         code = AFSVolTransCreate (fromconn, newVol, afrompart, ITOffline, &clonetid);
1502         if (!code) {
1503             AFSVolDeleteVolume(fromconn,clonetid);
1504             AFSVolEndTrans(fromconn,clonetid,&rcode);
1505         }
1506     }
1507
1508     /* unlock VLDB entry */
1509     ubik_Call (VL_ReleaseLock, cstruct, 0, afromvol, -1,
1510                (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1511
1512 done:   /* routine cleanup */
1513     if (volName)  free(volName);
1514 #ifdef  ENABLE_BUGFIX_1165
1515     if (infop)    free(infop);
1516 #endif
1517     if (fromconn) rx_DestroyConnection(fromconn);
1518     if (toconn)   rx_DestroyConnection(toconn);
1519
1520     if (pntg) {
1521         fprintf(STDOUT,"cleanup complete - user verify desired result\n");
1522         fflush(STDOUT);
1523     }
1524     exit(1);
1525 }
1526
1527 /* Make a new backup of volume <avolid> on <aserver> and <apart> 
1528  * if one already exists, update it 
1529  */
1530
1531 UV_BackupVolume(aserver, apart, avolid)
1532     afs_int32 aserver, apart, avolid;
1533 {
1534     struct rx_connection *aconn = (struct rx_connection *)0;
1535     afs_int32 ttid = 0, btid = 0;
1536     afs_int32 backupID;
1537     afs_int32 code = 0, rcode = 0;
1538     char vname[VOLSER_MAXVOLNAME +1];
1539     struct nvldbentry entry, storeEntry;
1540     afs_int32 error = 0;
1541     int vldblocked = 0, vldbmod = 0, backexists = 1;
1542
1543     aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
1544
1545     /* the calls to VLDB will succeed only if avolid is a RW volume,
1546      * since we are following the RW hash chain for searching */
1547     code = VLDB_GetEntryByID(avolid, RWVOL, &entry); 
1548     if (code) {
1549        fprintf(STDERR, "Could not fetch the entry for the volume %u from the VLDB \n", avolid);
1550        error = code; goto bfail;
1551     }
1552     MapHostToNetwork(&entry); 
1553
1554     /* These operations require the VLDB be locked since it means the VLDB
1555      * will change or the vldb is already locked.
1556      */
1557     if (!(entry.flags & BACK_EXISTS)   ||               /* backup volume doesnt exist */
1558          (entry.flags & VLOP_ALLOPERS) ||               /* vldb lock already held */
1559          (entry.volumeId[BACKVOL] == INVALID_BID)) {    /* no assigned backup volume id */
1560
1561        code = ubik_Call(VL_SetLock,cstruct, 0, avolid, RWVOL, VLOP_BACKUP);
1562        if (code) {
1563           fprintf(STDERR,"Could not lock the VLDB entry for the volume %u\n",avolid);
1564           error = code;
1565           goto bfail;
1566        }
1567        vldblocked = 1;
1568
1569        /* Reread the vldb entry */
1570        code = VLDB_GetEntryByID(avolid, RWVOL, &entry);
1571        if (code) {
1572           fprintf(STDERR,"Could not fetch the entry for the volume %u from the VLDB \n",avolid);
1573           error = code;
1574           goto bfail;
1575        }
1576        MapHostToNetwork(&entry);
1577     }
1578
1579     if (!ISNAMEVALID(entry.name)) {
1580        fprintf(STDERR, "Name of the volume %s exceeds the size limit\n", entry.name);
1581        error = VOLSERBADNAME;
1582        goto bfail;
1583     }
1584
1585     backupID = entry.volumeId[BACKVOL];
1586     if (backupID == INVALID_BID) {
1587        /* Get a backup volume id from the VLDB and update the vldb
1588         * entry with it. 
1589         */
1590        code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &backupID);
1591        if (code) {
1592           fprintf(STDERR,
1593                   "Could not allocate ID for the backup volume of  %u from the VLDB\n",
1594                   avolid);
1595           error = code;
1596           goto bfail;
1597        }
1598        entry.volumeId[BACKVOL] = backupID;
1599        vldbmod = 1;
1600     }
1601
1602     /* Test to see if the backup volume exists by trying to create
1603      * a transaction on the backup volume. We've assumed the backup exists.
1604      */
1605     code = AFSVolTransCreate(aconn, backupID, apart, ITOffline, &btid);
1606     if (code) {
1607        if (code != VNOVOL) {
1608           fprintf(STDERR,"Could not reach the backup volume %u\n", backupID);
1609           error = code;
1610           goto bfail;
1611        }
1612        backexists = 0;                 /* backup volume does not exist */
1613     }
1614     if (btid) {
1615        code = AFSVolEndTrans(aconn, btid, &rcode);
1616        btid = 0;
1617        if (code || rcode) {
1618           fprintf(STDERR,
1619                   "Could not end transaction on the previous backup volume %u\n",
1620                   backupID);
1621           error = (code ? code : rcode);
1622           goto bfail;
1623        }
1624     }
1625
1626     /* Now go ahead and try to clone the RW volume.
1627      * First start a transaction on the RW volume 
1628      */
1629     code = AFSVolTransCreate(aconn, avolid, apart, ITBusy, &ttid);
1630     if (code) {
1631        fprintf(STDERR,"Could not start a transaction on the volume %u\n",avolid);
1632        error = code;
1633        goto bfail;
1634     }
1635
1636     /* Clone or reclone the volume, depending on whether the backup 
1637      * volume exists or not
1638      */
1639     if (backexists) {
1640        if(verbose) 
1641           fprintf(STDOUT,"Re-cloning backup volume %u ...", backupID);
1642        fflush(STDOUT);
1643
1644        code = AFSVolReClone(aconn, ttid, backupID);
1645        if (code) {
1646           fprintf(STDERR,"Could not re-clone backup volume %u\n", backupID);
1647           error = code;
1648           goto bfail;
1649        }
1650     }
1651     else {
1652        if (verbose)
1653           fprintf(STDOUT,"Creating a new backup clone %u ...", backupID);
1654        fflush(STDOUT);
1655
1656        strcpy(vname, entry.name);
1657        strcat(vname,".backup");
1658
1659        code = AFSVolClone(aconn, ttid, 0,backupVolume, vname, &backupID);
1660        if (code) {
1661           fprintf(STDERR,"Failed to clone the volume %u\n",avolid);
1662           error = code;
1663           goto bfail;
1664        }
1665     }
1666
1667     /* End the transaction on the RW volume */
1668     code = AFSVolEndTrans(aconn, ttid, &rcode);
1669     ttid = 0;
1670     if (code || rcode) {
1671         fprintf(STDERR, "Failed to end the transaction on the rw volume %u\n", avolid); 
1672         error = (code ? code : rcode);
1673         goto bfail;
1674     }
1675
1676     /* Mork vldb as backup exists */
1677     if (!(entry.flags & BACK_EXISTS)) {
1678        entry.flags |= BACK_EXISTS;
1679        vldbmod = 1;
1680     }
1681
1682     /* Now go back to the backup volume and bring it on line */
1683     code = AFSVolTransCreate(aconn, backupID, apart, ITOffline, &btid);
1684     if (code) {
1685         fprintf(STDERR,"Failed to start a transaction on the backup volume %u\n",backupID); 
1686         error = code;
1687         goto bfail;
1688     }
1689
1690     code = AFSVolSetFlags(aconn, btid, 0);
1691     if (code) {
1692         fprintf(STDERR,"Could not mark the backup volume %u on line \n",backupID);
1693         error = code;
1694         goto bfail;
1695     }
1696
1697     code = AFSVolEndTrans(aconn, btid, &rcode);
1698     btid = 0;
1699     if (code || rcode) {
1700         fprintf(STDERR, "Failed to end the transaction on the backup volume %u\n", backupID);
1701         error = (code ? code : rcode);
1702         goto bfail;
1703     }
1704
1705     if (verbose)
1706         fprintf(STDOUT,"done\n");
1707
1708     /* Will update the vldb below */
1709
1710   bfail:
1711     if (ttid) {
1712        code =  AFSVolEndTrans(aconn, ttid, &rcode);
1713        if (code || rcode) {
1714           fprintf(STDERR, "Could not end transaction on the volume %u\n", avolid);
1715           if (!error)
1716              error = (code ? code : rcode);
1717        }
1718     }
1719
1720     if (btid) {
1721        code = AFSVolEndTrans(aconn, btid, &rcode);
1722        if (code || rcode) {
1723           fprintf(STDERR,"Could not end transaction the backup volume %u\n",backupID);
1724           if (!error)
1725              error = (code ? code : rcode);
1726        }
1727     }
1728
1729     /* Now update the vldb - if modified */
1730     if (vldblocked) {
1731        if (vldbmod) {
1732           MapNetworkToHost(&entry,&storeEntry);
1733           code = VLDB_ReplaceEntry(avolid, RWVOL, &storeEntry,
1734                                     (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1735           if (code) {
1736              fprintf(STDERR,"Could not update the VLDB entry for the volume %u \n",avolid);
1737              if (!error)
1738                 error = code;
1739           }
1740        }
1741        else {
1742           code = ubik_Call(VL_ReleaseLock,cstruct, 0, avolid, RWVOL, 
1743                            (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
1744           if (code) {
1745              fprintf(STDERR,"Could not unlock the VLDB entry for the volume %u \n",avolid);
1746              if (!error)
1747                 error = code;
1748           }
1749        }
1750     }
1751
1752     if (aconn)
1753        rx_DestroyConnection(aconn);
1754
1755     PrintError("",error);
1756     return error;
1757 }
1758
1759 static int DelVol (conn, vid, part, flags)
1760 struct rx_connection *conn;
1761 afs_int32 vid, part, flags;
1762 {
1763   afs_int32 acode, ccode, rcode, tid;
1764   ccode = rcode = tid = 0;
1765
1766   acode = AFSVolTransCreate(conn, vid, part, flags, &tid);
1767   if (!acode) {              /* It really was there */
1768     acode = AFSVolDeleteVolume(conn, tid);
1769     if (acode) {
1770       fprintf(STDERR, "Failed to delete volume %u.\n", vid);
1771       PrintError ("", acode);
1772     }
1773     ccode = AFSVolEndTrans(conn, tid, &rcode);
1774     if (!ccode) 
1775       ccode = rcode;
1776     if (ccode) {
1777       fprintf(STDERR, "Failed to end transaction on volume %u.\n", vid);
1778       PrintError ("", ccode);
1779     }
1780   }
1781
1782 return acode;
1783 }
1784
1785 #define ONERROR(ec, ep, es) if (ec) { fprintf(STDERR, (es), (ep)); error = (ec); goto rfail; }
1786 #define ERROREXIT(ec) { error = (ec); goto rfail; }
1787
1788 /* Get a "transaction" on this replica.  Create the volume 
1789  * if necessary.  Return the time from which a dump should
1790  * be made (0 if it's a new volume)
1791  */
1792 static int GetTrans (vldbEntryPtr, index, connPtr, transPtr, timePtr)
1793   struct nvldbentry    *vldbEntryPtr;
1794   afs_int32                index;
1795   struct rx_connection **connPtr;
1796   afs_int32                *transPtr, *timePtr;
1797 {
1798   afs_int32 volid;
1799   struct volser_status tstatus;
1800   int code, rcode, tcode;
1801   
1802   *connPtr  = (struct rx_connection *)0;
1803   *timePtr  = 0;
1804   *transPtr = 0;
1805
1806   /* get connection to the replication site */
1807   *connPtr = UV_Bind(vldbEntryPtr->serverNumber[index], AFSCONF_VOLUMEPORT);
1808   if (!*connPtr) goto fail;                                   /* server is down */
1809
1810   volid = vldbEntryPtr->volumeId[ROVOL];
1811   if (volid) 
1812     code = AFSVolTransCreate(*connPtr, volid, vldbEntryPtr->serverPartition[index], 
1813                              ITOffline, transPtr);
1814
1815   /* If the volume does not exist, create it */
1816   if (!volid || code) {
1817       char volname[64];
1818
1819       if (volid && (code != VNOVOL)){
1820           PrintError("Failed to start a transaction on the RO volume.\n",
1821                      code);
1822           goto fail;
1823       }
1824
1825       strcpy(volname, vldbEntryPtr->name);
1826       strcat(volname, ".readonly");
1827       
1828       if (verbose) {
1829           fprintf(STDOUT,"Creating new volume %u on replication site %s: ", 
1830                   volid, hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index]));
1831           fflush(STDOUT);
1832       }
1833
1834       code = AFSVolCreateVolume(*connPtr, vldbEntryPtr->serverPartition[index], 
1835                                 volname, volser_RO,
1836                                 vldbEntryPtr->volumeId[RWVOL], &volid, transPtr);
1837       if (code) {
1838           PrintError("Failed to create the ro volume: ",code);
1839           goto fail;
1840       }
1841       vldbEntryPtr->volumeId[ROVOL] = volid;
1842
1843       if (verbose) fprintf(STDOUT,"done.\n");
1844
1845       /* The following is a bit redundant, since create sets these flags by default */
1846       code = AFSVolSetFlags(*connPtr, *transPtr, VTDeleteOnSalvage | VTOutOfService);
1847       if (code) {
1848           PrintError("Failed to set flags on the ro volume: ", code);
1849           goto fail;
1850       }
1851   }
1852
1853   /* Otherwise, the transaction did succeed, so get the creation date of the
1854    * latest RO volume on the replication site 
1855    */
1856   else {
1857       if (verbose) {
1858           fprintf(STDOUT,"Updating existing ro volume %u on %s ...\n",
1859                   volid, hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index]));
1860           fflush(STDOUT);
1861       }
1862
1863       code  = AFSVolGetStatus(*connPtr, *transPtr, &tstatus);
1864       if (code) {
1865           PrintError("Failed to get status of volume on destination: ",code);
1866           goto fail;
1867       }
1868       *timePtr = tstatus.creationDate-CLOCKSKEW;
1869   }
1870   
1871   return 0;
1872
1873  fail:
1874   if (*transPtr) {
1875       tcode = AFSVolEndTrans(*connPtr, *transPtr, &rcode);
1876       *transPtr = 0;
1877       if (!tcode) tcode = rcode;
1878       if (tcode) PrintError("Could not end transaction on a ro volume: ", tcode);
1879   }
1880
1881   return code;
1882 }
1883
1884 static int SimulateForwardMultiple(fromconn, fromtid, fromdate, tr,
1885                                    flags, cookie, results)
1886 struct rx_connection *fromconn;
1887 afs_int32 fromtid, fromdate, flags;
1888 manyDests *tr;
1889 void *cookie;
1890 manyResults *results;
1891 {
1892   int i;
1893
1894   for (i=0; i<tr->manyDests_len; i++) {
1895      results->manyResults_val[i] = AFSVolForward(fromconn, fromtid,
1896                                     fromdate, &(tr->manyDests_val[i].server), 
1897                                     tr->manyDests_val[i].trans, cookie);
1898   }
1899   return 0;
1900 }
1901
1902
1903 static int rel_compar (r1, r2)
1904      struct release *r1, *r2;
1905 {
1906   return (r1->time - r2->time);
1907 }
1908
1909 /* UV_ReleaseVolume()
1910  *    Release volume <afromvol> on <afromserver> <afrompart> to all
1911  *    its RO sites (full release). Unless the previous release was
1912  *    incomplete: in which case we bring the remaining incomplete
1913  *    volumes up to date with the volumes that were released
1914  *    successfully.
1915  *    forceflag: Performs a full release.
1916  *
1917  *    Will create a clone from the RW, then dump the clone out to 
1918  *    the remaining replicas. If there is more than 1 RO sites,
1919  *    ensure that the VLDB says at least one RO is available all
1920  *    the time: Influences when we write back the VLDB entry.
1921  */
1922
1923 UV_ReleaseVolume(afromvol, afromserver, afrompart, forceflag)
1924      afs_int32 afromserver;
1925      afs_int32 afrompart;
1926      afs_int32 afromvol; 
1927      int forceflag;
1928 {
1929   char vname[64];
1930   afs_int32 code, vcode, rcode, tcode;
1931   afs_int32 cloneVolId, roVolId;
1932   struct replica *replicas=0;
1933   struct nvldbentry entry,storeEntry;
1934   int i, volcount, m, fullrelease, vldbindex;
1935   int failure;
1936   struct restoreCookie cookie;
1937   struct rx_connection **toconns=0;
1938   struct release *times=0;
1939   int nservers = 0;
1940   struct rx_connection *fromconn = (struct rx_connection *)0;
1941   afs_int32 error = 0;
1942   int islocked = 0;
1943   afs_int32 clonetid=0, onlinetid;
1944   afs_int32 fromtid=0;
1945   afs_uint32 fromdate, thisdate;
1946   int s;
1947   manyDests tr;
1948   manyResults results;
1949   int rwindex, roindex, roclone, roexists;
1950   afs_int32 rwcrdate;
1951   struct rtime {
1952     int     validtime;
1953     afs_uint32 time;
1954   } remembertime[NMAXNSERVERS];
1955   int releasecount = 0;
1956   struct volser_status volstatus;
1957
1958   memset((char *)remembertime, 0, sizeof(remembertime));
1959   memset((char *)&results, 0, sizeof(results));
1960
1961   vcode = ubik_Call(VL_SetLock, cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
1962   if (vcode != VL_RERELEASE) 
1963       ONERROR(vcode, afromvol, "Could not lock the VLDB entry for the volume %u.\n");
1964   islocked = 1;
1965
1966   /* Get the vldb entry in readable format */
1967   vcode = VLDB_GetEntryByID (afromvol, RWVOL, &entry);
1968   ONERROR(vcode, afromvol, "Could not fetch the entry for the volume %u from the VLDB.\n");
1969   MapHostToNetwork(&entry);
1970
1971   if (verbose)
1972      EnumerateEntry(&entry);
1973
1974   if (!ISNAMEVALID(entry.name))
1975     ONERROR(VOLSERBADOP, entry.name, 
1976             "Volume name %s is too long, rename before releasing.\n");
1977   if (entry.volumeId[RWVOL] != afromvol)
1978     ONERROR(VOLSERBADOP, afromvol, 
1979             "The volume %u being released is not a read-write volume.\n");
1980   if (entry.nServers <= 1)  
1981     ONERROR(VOLSERBADOP, afromvol, 
1982             "Volume %u has no replicas - release operation is meaningless!\n");
1983   if (strlen(entry.name) > (VOLSER_OLDMAXVOLNAME - 10)) 
1984     ONERROR(VOLSERBADOP, entry.name, 
1985             "RO volume name %s exceeds (VOLSER_OLDMAXVOLNAME - 10) character limit\n");
1986
1987   /* roclone is true if one of the RO volumes is on the same
1988    * partition as the RW volume. In this case, we make the RO volume
1989    * on the same partition a clone instead of a complete copy.
1990    */
1991   
1992   roindex = Lp_ROMatch(afromserver, afrompart, &entry) - 1;
1993   roclone = ((roindex == -1) ? 0 : 1);
1994   rwindex = Lp_GetRwIndex(&entry);
1995   if (rwindex < 0)
1996      ONERROR(VOLSERNOVOL, 0, "There is no RW volume \n");
1997
1998   /* Make sure we have a RO volume id to work with */
1999   if (entry.volumeId[ROVOL] == INVALID_BID) {
2000       /* need to get a new RO volume id */
2001       vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &roVolId);
2002       ONERROR(vcode, entry.name, "Cant allocate ID for RO volume of %s\n"); 
2003
2004       entry.volumeId[ROVOL] = roVolId;
2005       MapNetworkToHost(&entry, &storeEntry);
2006       vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry, 0);
2007       ONERROR(vcode, entry.name, "Could not update vldb entry for %s.\n");
2008   }
2009
2010   /* Will we be completing a previously unfinished release. -force overrides */
2011   for (fullrelease=1, i=0; (fullrelease && (i<entry.nServers)); i++) {
2012      if (entry.serverFlags[i] & NEW_REPSITE)
2013         fullrelease = 0;
2014   }
2015   if (forceflag && !fullrelease)
2016     fullrelease = 1;
2017
2018   /* Determine which volume id to use and see if it exists */
2019   cloneVolId = ((fullrelease || (entry.cloneId == 0)) ? entry.volumeId[ROVOL] : entry.cloneId);
2020   code = VolumeExists(afromserver, afrompart, cloneVolId);
2021   roexists = ((code == ENODEV) ? 0 : 1);
2022   if (!roexists && !fullrelease)
2023      fullrelease = 1;      /* Do a full release if RO clone does not exist */
2024
2025   if (verbose) {
2026      if (fullrelease) {
2027         fprintf(STDOUT,"This is a complete release of the volume %u\n", afromvol);
2028      } else {
2029         fprintf(STDOUT,"This is a completion of the previous release\n");
2030      }
2031   }
2032      
2033   fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
2034   if (!fromconn) 
2035      ONERROR(-1, afromserver, "Cannot establish connection with server 0x%x\n");
2036   
2037   if (fullrelease) {
2038      /* If the RO clone exists, then if the clone is a temporary
2039       * clone, delete it. Or if the RO clone is marked RO_DONTUSE
2040       * (it was recently added), then also delete it. We do not
2041       * want to "reclone" a temporary RO clone.
2042       */
2043      if ( roexists && 
2044          (!roclone || (entry.serverFlags[roindex] & RO_DONTUSE)) ) {
2045         code = DelVol(fromconn, cloneVolId, afrompart, ITOffline);
2046         if (code && (code != VNOVOL))
2047            ERROREXIT(code);
2048         roexists = 0;
2049      }
2050
2051      /* Mark all the ROs in the VLDB entry as RO_DONTUSE. We don't
2052       * write this entry out to the vlserver until after the first
2053       * RO volume is released (temp RO clones don't count).
2054       */
2055      for (i=0; i<entry.nServers; i++) {
2056         entry.serverFlags[i] &= ~NEW_REPSITE;
2057         entry.serverFlags[i] |=  RO_DONTUSE;
2058      }
2059      entry.serverFlags[rwindex] |=  NEW_REPSITE;
2060      entry.serverFlags[rwindex] &= ~RO_DONTUSE;
2061       
2062      /* Begin transaction on RW and mark it busy while we clone it */
2063      code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &clonetid);
2064      ONERROR(code, afromvol, "Failed to start transaction on volume %u\n");
2065
2066      /* Clone or reclone the volume */
2067      if (roexists) {
2068         if (verbose)
2069            fprintf(STDERR, "Recloning RW volume ...\n");
2070
2071         code = AFSVolReClone(fromconn, clonetid, cloneVolId);
2072         ONERROR(code, afromvol, "Failed to reclone the RW volume %u\n");
2073      } else {
2074         if (roclone) {
2075            strcpy(vname, entry.name);
2076            strcat(vname, ".readonly");
2077            if (verbose)
2078              fprintf(STDERR, "Cloning RW volume ...\n");
2079         } else {
2080            strcpy(vname, "readonly-clone-temp");
2081            if (verbose)
2082              fprintf(STDERR, "Cloning RW volume to temporary RO ...\n");
2083         }
2084         code = AFSVolClone(fromconn, clonetid, 0, readonlyVolume, vname, &cloneVolId);
2085         ONERROR(code, afromvol, "Failed to clone the RW volume %u\n");
2086      }
2087
2088      /* Get the time the RW was created for future information */
2089      code = AFSVolGetStatus(fromconn, clonetid, &volstatus);
2090      ONERROR(code, cloneVolId, "Failed to get the status of the RW volume %u\n");
2091      rwcrdate = volstatus.creationDate;
2092
2093      /* End the transaction on the RW volume */
2094      code = AFSVolEndTrans(fromconn, clonetid, &rcode);
2095      clonetid = 0;
2096      ONERROR((code?code:rcode), cloneVolId, "Failed to end cloning transaction on RW %u\n");
2097
2098      /* Remember clone volume ID in case we fail or are interrupted */
2099      entry.cloneId = cloneVolId;
2100
2101      if (roclone) {
2102         /* Bring the RO clone online - though not if it's a temporary clone */
2103         code = AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITOffline, &onlinetid);
2104         ONERROR(code, cloneVolId, "Failed to start transaction on volume %u\n");
2105
2106         tcode = AFSVolSetFlags(fromconn, onlinetid, 0);
2107
2108         code = AFSVolEndTrans(fromconn, onlinetid, &rcode);
2109         ONERROR((code?code:rcode), cloneVolId, "Failed to end transaction on RO clone %u\n");
2110
2111         ONERROR(tcode, cloneVolId, "Could not bring volume %u on line\n");
2112
2113         /* Sleep so that a client searching for an online volume won't
2114          * find the clone offline and then the next RO offline while the 
2115          * release brings the clone online and the next RO offline (race).
2116          * There is a fix in the 3.4 client that does not need this sleep
2117          * anymore, but we don't know what clients we have.
2118          */
2119         if (entry.nServers > 2)
2120            sleep(5);
2121
2122         /* Mark the RO clone in the VLDB as a good site (already released)*/
2123         entry.serverFlags[roindex] |=  NEW_REPSITE;
2124         entry.serverFlags[roindex] &= ~RO_DONTUSE;
2125         entry.flags                |=  RO_EXISTS;
2126
2127         releasecount++;
2128
2129         /* Write out the VLDB entry only if the clone is not a temporary
2130          * clone. If we did this to a temporary clone then we would end
2131          * up marking all the ROs as "old release" making the ROs
2132          * temporarily unavailable.
2133          */
2134         MapNetworkToHost(&entry, &storeEntry);
2135         vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry, 0);
2136         ONERROR(vcode, entry.name, "Could not update vldb entry for %s.\n");
2137      }
2138   }  
2139
2140   /* Now we will release from the clone to the remaining RO replicas.
2141    * The first 2 ROs (counting the non-temporary RO clone) are released
2142    * individually: releasecount. This is to reduce the race condition
2143    * of clients trying to find an on-line RO volume. The remaining ROs
2144    * are released in parallel but no more than half the number of ROs
2145    * (rounded up) at a time: nservers.
2146    */
2147
2148   strcpy(vname, entry.name);
2149   strcat(vname, ".readonly");
2150   memset(&cookie, 0, sizeof(cookie));
2151   strncpy(cookie.name, vname, VOLSER_OLDMAXVOLNAME);
2152   cookie.type   = ROVOL;
2153   cookie.parent = entry.volumeId[RWVOL];
2154   cookie.clone  = 0;
2155
2156   nservers = entry.nServers/2;           /* how many to do at once, excluding clone */
2157   replicas   = (struct replica *)        malloc (sizeof(struct replica)*nservers+1);
2158   times      = (struct release *)        malloc (sizeof(struct release)*nservers+1);
2159   toconns    = (struct rx_connection **) malloc (sizeof(struct rx_connection *)*nservers+1);
2160   results.manyResults_val = (afs_int32 *)    malloc (sizeof(afs_int32)*nservers+1);
2161   if ( !replicas || !times || !! !results.manyResults_val || !toconns ) 
2162       ONERROR(ENOMEM, 0, "Failed to create transaction on the release clone\n");
2163
2164   memset(replicas, 0, (sizeof(struct replica)*nservers+1));
2165   memset(times, 0, (sizeof(struct release)*nservers+1));
2166   memset(toconns, 0, (sizeof(struct rx_connection *)*nservers+1));
2167   memset(results.manyResults_val, 0, (sizeof(afs_int32)*nservers+1));
2168
2169   /* Create a transaction on the cloned volume */
2170   code = AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
2171   if (!fullrelease && code)
2172      ONERROR(VOLSERNOVOL, afromvol,"Old clone is inaccessible. Try vos release -f %u.\n");
2173   ONERROR(code, 0, "Failed to create transaction on the release clone\n");
2174
2175   /* For each index in the VLDB */
2176   for (vldbindex=0; vldbindex<entry.nServers; ) {
2177
2178      /* Get a transaction on the replicas. Pick replacas which have an old release. */
2179      for (volcount=0; ((volcount<nservers) && (vldbindex<entry.nServers)); vldbindex++) {
2180         /* The first two RO volumes will be released individually.
2181          * The rest are then released in parallel. This is a hack
2182          * for clients not recognizing right away when a RO volume
2183          * comes back on-line.
2184          */
2185         if ((volcount == 1) && (releasecount < 2))
2186            break;
2187
2188         if (vldbindex == roindex) continue;              /* the clone    */
2189         if ( (entry.serverFlags[vldbindex] & NEW_REPSITE) &&
2190             !(entry.serverFlags[vldbindex] & RO_DONTUSE) ) continue;
2191         if (!(entry.serverFlags[vldbindex] & ITSROVOL)) continue;  /* not a RO vol */
2192
2193
2194         /* Get a Transaction on this replica. Get a new connection if
2195          * necessary.  Create the volume if necessary.  Return the
2196          * time from which the dump should be made (0 if it's a new
2197          * volume).  Each volume might have a different time. 
2198          */
2199         replicas[volcount].server.destHost = ntohl(entry.serverNumber[vldbindex]);
2200         replicas[volcount].server.destPort = AFSCONF_VOLUMEPORT;
2201         replicas[volcount].server.destSSID = 1;
2202         times[volcount].vldbEntryIndex = vldbindex;
2203         
2204         code = GetTrans(&entry, vldbindex, &(toconns[volcount]), 
2205                         &(replicas[volcount].trans), &(times[volcount].time));
2206         if (code) continue;
2207
2208         /* Thisdate is the date from which we want to pick up all changes */
2209         if (forceflag || !fullrelease || (rwcrdate > times[volcount].time)) {
2210            /* If the forceflag is set, then we want to do a full dump.
2211             * If it's not a full release, we can't be sure that the creation
2212             *  date is good (so we also do a full dump).
2213             * If the RW volume was replaced (its creation date is newer than
2214             *  the last release), then we can't be sure what has changed (so
2215             *  we do a full dump).
2216             */
2217            thisdate = 0;
2218         } else if (remembertime[vldbindex].validtime) {
2219            /* Trans was prev ended. Use the time from the prev trans
2220             * because, prev trans may have created the volume. In which
2221             * case time[volcount].time would be now instead of 0.
2222             */
2223            thisdate  = (remembertime[vldbindex].time < times[volcount].time) ? 
2224                         remembertime[vldbindex].time : times[volcount].time;
2225         } else {
2226            thisdate = times[volcount].time;
2227         }         
2228         remembertime[vldbindex].validtime = 1;
2229         remembertime[vldbindex].time = thisdate;
2230
2231         if (volcount == 0) {
2232            fromdate = thisdate;
2233         } else {
2234            /* Include this volume if it is within 15 minutes of the earliest */
2235            if (((fromdate>thisdate)?(fromdate-thisdate):(thisdate-fromdate)) > 900) {
2236               AFSVolEndTrans(toconns[volcount], replicas[volcount].trans, &rcode);
2237               replicas[volcount].trans = 0;
2238               break;
2239            }
2240            if (thisdate < fromdate)
2241               fromdate = thisdate;
2242         }
2243         volcount++;
2244      }
2245      if (!volcount) continue;
2246
2247      if (verbose) {
2248         fprintf(STDOUT,"Starting ForwardMulti from %u to %u on %s",
2249                 cloneVolId, entry.volumeId[ROVOL], 
2250                 hostutil_GetNameByINet(entry.serverNumber[times[0].vldbEntryIndex]));
2251
2252         for (s=1; s<volcount; s++) {
2253            fprintf(STDOUT," and %s",
2254                    hostutil_GetNameByINet(entry.serverNumber[times[s].vldbEntryIndex]));
2255         }
2256
2257         if (fromdate == 0)
2258            fprintf(STDOUT," (full release)");
2259         fprintf(STDOUT,".\n");
2260         fflush(STDOUT);
2261      }
2262
2263      /* Release the ones we have collected */
2264      tr.manyDests_val = &(replicas[0]);
2265      tr.manyDests_len = results.manyResults_len = volcount;
2266      code = AFSVolForwardMultiple(fromconn, fromtid, fromdate, &tr, 0/*spare*/, &cookie, &results);
2267      if (code == RXGEN_OPCODE) {               /* RPC Interface Mismatch */
2268         code = SimulateForwardMultiple(fromconn, fromtid, fromdate, &tr, 0/*spare*/, &cookie, &results);
2269         nservers = 1;
2270      }
2271
2272      if (code) {
2273         PrintError("Release failed: ", code);
2274      } else {
2275         for (m=0; m<volcount; m++) {
2276            if (results.manyResults_val[m]) {
2277               if ((m == 0) || (results.manyResults_val[m] != ENOENT)) {
2278                  /* we retry timed out transaction. When it is
2279                   * not the first volume and the transaction wasn't found
2280                   * (assume it timed out and was garbage collected by volser).
2281                   */
2282                  PrintError("Failed to dump volume from clone to a ro site: ",
2283                             results.manyResults_val[m]);
2284               }
2285               continue;
2286            }
2287             
2288            code = AFSVolSetIdsTypes(toconns[m], replicas[m].trans, 
2289                                     vname, ROVOL, entry.volumeId[RWVOL], 0, 0);
2290            if (code) {
2291               if ((m == 0) || (code != ENOENT)) {
2292                  PrintError("Failed to set correct names and ids: ", code);
2293               }
2294               continue;
2295            }
2296
2297            /* have to clear dest. flags to ensure new vol goes online:
2298             * because the restore (forwarded) operation copied
2299             * the V_inService(=0) flag over to the destination. 
2300             */
2301            code = AFSVolSetFlags(toconns[m], replicas[m].trans, 0);
2302            if (code) {
2303               if ((m == 0) || (code != ENOENT)) {
2304                  PrintError("Failed to set flags on ro volume: ", code);
2305               }
2306               continue;
2307            }
2308
2309            entry.serverFlags[times[m].vldbEntryIndex] |=  NEW_REPSITE;
2310            entry.serverFlags[times[m].vldbEntryIndex] &= ~RO_DONTUSE;
2311            entry.flags                                |=  RO_EXISTS;
2312            releasecount++;
2313         }
2314      }   
2315
2316      /* End the transactions and destroy the connections */
2317      for (s=0; s<volcount; s++) {
2318         if (replicas[s].trans)
2319            code = AFSVolEndTrans(toconns[s], replicas[s].trans, &rcode);
2320         replicas[s].trans = 0;
2321         if (!code) code = rcode;
2322         if (code) {
2323            if ((s == 0) || (code != ENOENT)) {
2324               PrintError("Could not end transaction on a ro volume: ", code);
2325            } else {
2326               PrintError("Transaction timed out on a ro volume. Will retry.\n", 0);
2327               if (times[s].vldbEntryIndex < vldbindex)
2328                  vldbindex = times[s].vldbEntryIndex;
2329            }
2330         }
2331            
2332         if (toconns[s])
2333            rx_DestroyConnection(toconns[s]);
2334         toconns[s] = 0;
2335      }
2336    
2337      MapNetworkToHost(&entry, &storeEntry);
2338      vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry, 0);
2339      ONERROR(vcode, afromvol, " Could not update VLDB entry for volume %u\n");
2340   } /* for each index in the vldb */
2341
2342   /* End the transaction on the cloned volume */
2343   code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2344   fromtid = 0;
2345   if (!code) code = rcode;
2346   if (code)
2347      PrintError("Failed to end transaction on rw volume: ", code);
2348   
2349   /* Figure out if any volume were not released and say so */
2350   for (failure=0, i=0; i<entry.nServers; i++) {
2351      if (!(entry.serverFlags[i] & NEW_REPSITE))
2352         failure++;
2353   }
2354   if (failure) {
2355      char pname[10];
2356      fprintf(STDERR, "The volume %u could not be released to the following %d sites:\n",
2357              afromvol, failure);
2358      for (i=0; i<entry.nServers; i++) {
2359         if (!(entry.serverFlags[i] & NEW_REPSITE)) {
2360            MapPartIdIntoName(entry.serverPartition[i],pname);
2361            fprintf(STDERR,"\t%35s %s\n", 
2362                    hostutil_GetNameByINet(entry.serverNumber[i]), pname);
2363         }
2364      }
2365
2366      MapNetworkToHost(&entry,&storeEntry);
2367      vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry, LOCKREL_TIMESTAMP);
2368      ONERROR(vcode, afromvol, " Could not update VLDB entry for volume %u\n");
2369
2370      ERROREXIT(VOLSERBADRELEASE);
2371   }
2372
2373   /* All the ROs were release successfully. Remove the temporary clone */
2374   if (!roclone) {
2375       if (verbose) {
2376           fprintf(STDOUT,"Deleting the releaseClone %u ...", cloneVolId);
2377           fflush(STDOUT);
2378       }
2379       code = DelVol (fromconn, cloneVolId, afrompart, ITOffline);
2380       ONERROR (code, cloneVolId, "Failed to delete volume %u.\n");
2381       if (verbose)
2382          fprintf(STDOUT," done\n");
2383   }
2384   entry.cloneId = 0;
2385
2386   for (i=0; i<entry.nServers; i++)
2387      entry.serverFlags[i] &= ~NEW_REPSITE;
2388
2389   /* Update the VLDB */
2390   if (verbose) {
2391       fprintf(STDOUT,"updating VLDB ...");
2392       fflush(STDOUT);
2393   }
2394   MapNetworkToHost(&entry, &storeEntry);
2395   vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry,
2396                            LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
2397   ONERROR(vcode, afromvol, " Could not update VLDB entry for volume %u\n");
2398   if (verbose)
2399      fprintf(STDOUT," done\n");
2400
2401  rfail:
2402   if (clonetid) {
2403       code = AFSVolEndTrans(fromconn, clonetid, &rcode);
2404       clonetid = 0;
2405       if (code) {
2406           fprintf (STDERR,"Failed to end cloning transaction on the RW volume %u\n", afromvol);
2407           if (!error) error = code;
2408       }
2409   }
2410   if (fromtid) {
2411       code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2412       fromtid = 0;
2413       if (code) {
2414           fprintf (STDERR,"Failed to end transaction on the release clone %u\n", cloneVolId);
2415           if (!error) error = code;
2416       }
2417   }
2418   for (i=0; i<nservers; i++) {
2419       if (replicas && replicas[i].trans) {
2420           code = AFSVolEndTrans(toconns[i], replicas[i].trans, &rcode);
2421           replicas[i].trans = 0;
2422           if (code) {
2423               fprintf(STDERR,"Failed to end transaction on ro volume %u at server 0x%x\n",
2424                       entry.volumeId[ROVOL], 
2425                       hostutil_GetNameByINet(htonl(replicas[i].server.destHost)));
2426               if (!error) error = code;
2427           }
2428       }
2429       if (toconns && toconns[i]) {
2430           rx_DestroyConnection(toconns[i]);
2431           toconns[i] = 0;
2432       }
2433   }
2434   if (islocked) {
2435       vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, afromvol, RWVOL, 
2436                         LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
2437       if (vcode) {
2438           fprintf(STDERR,"Could not release lock on the VLDB entry for volume %u\n", afromvol);
2439           if (!error) error = vcode;
2440       }
2441   }
2442
2443   PrintError("", error);
2444
2445   if (fromconn)                rx_DestroyConnection(fromconn);
2446   if (results.manyResults_val) free (results.manyResults_val);
2447   if (replicas)                free (replicas);
2448   if (toconns)                 free (toconns);
2449   if (times)                   free (times);
2450   return error;
2451 }
2452
2453
2454 void dump_sig_handler(x)
2455 {
2456    fprintf(STDERR,"\nSignal handler: vos dump operation\n");
2457    longjmp(env,0);
2458 }
2459
2460 /* Dump the volume <afromvol> on <afromserver> and
2461  * <afrompart> to <afilename> starting from <fromdate>.
2462  * DumpFunction does the real work behind the scenes after
2463  * extracting parameters from the rock 
2464  */
2465 UV_DumpVolume(afromvol, afromserver, afrompart, fromdate, DumpFunction, rock)
2466    afs_int32 afromserver;
2467    afs_int32 afrompart;
2468    afs_int32 afromvol;
2469    afs_int32 fromdate;
2470    afs_int32 (*DumpFunction)();
2471    char *rock;
2472 {
2473    struct rx_connection *fromconn = (struct rx_connection *)0;
2474    struct rx_call       *fromcall = (struct rx_call *)0;
2475    afs_int32 fromtid=0, rxError=0, rcode=0;
2476    afs_int32 code, error = 0;
2477
2478    if (setjmp(env)) ERROR_EXIT(EPIPE);
2479 #ifndef AFS_NT40_ENV
2480    (void) signal(SIGPIPE, dump_sig_handler);
2481 #endif
2482    (void) signal(SIGINT,  dump_sig_handler);
2483
2484    /* get connections to the servers */
2485    fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
2486    code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
2487    if (code) {
2488       fprintf(STDERR,"Could not start transaction on the volume %u to be dumped\n", afromvol);
2489       ERROR_EXIT(code);
2490    }
2491
2492    if (verbose) {
2493       if (!fromdate)
2494         fprintf(STDERR,"Full Dump ...");
2495       else 
2496         fprintf(STDERR,"Incremental Dump (as of %.24s) ...",
2497                 ctime((time_t *)&fromdate));
2498       fflush(STDERR);
2499    }
2500
2501    fromcall = rx_NewCall(fromconn);
2502    code = StartAFSVolDump(fromcall, fromtid, fromdate);
2503    if (code) {
2504       fprintf(STDERR,"Could not start the dump process \n");
2505       ERROR_EXIT(code);
2506    }
2507    if (code = DumpFunction(fromcall, rock)) {
2508       fprintf(STDERR,"Error while dumping volume \n");
2509       ERROR_EXIT(code);
2510    }
2511
2512    if (verbose)
2513       fprintf(STDERR,"completed\n");
2514
2515  error_exit: 
2516    if (fromcall) {
2517       code = rx_EndCall(fromcall, rxError);
2518       if (code) {
2519          fprintf(STDERR,"Error in rx_EndCall\n");
2520          if (!error) error = code;
2521       } 
2522    }
2523    if (fromtid) {
2524       code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2525       if (code || rcode) {
2526          fprintf(STDERR,"Could not end transaction on the volume %u\n", afromvol);
2527          if (!error) error = (code?code:rcode);
2528       }
2529    }
2530    if (fromconn)
2531       rx_DestroyConnection(fromconn);
2532
2533    PrintError("", error);
2534    return(error);
2535 }
2536
2537
2538 /*
2539  * Restore a volume <tovolid> <tovolname> on <toserver> <topart> from
2540  * the dump file <afilename>. WriteData does all the real work
2541  * after extracting params from the rock 
2542  */
2543 UV_RestoreVolume(toserver, topart, tovolid, tovolname, flags, WriteData, rock)
2544     afs_int32 toserver, topart, tovolid;
2545     char tovolname[];
2546     int flags;
2547     afs_int32 (*WriteData)();
2548     char *rock;
2549 {
2550     struct rx_connection *toconn,*tempconn;
2551     struct rx_call *tocall;
2552     afs_int32 totid, code, rcode, vcode,terror = 0;
2553     afs_int32 rxError = 0;
2554     struct volser_status tstatus;
2555     char partName[10];
2556     afs_int32 pvolid;
2557     afs_int32 temptid;
2558     int success;
2559     struct nvldbentry entry,storeEntry;
2560     afs_int32 error;
2561     int islocked;
2562     struct restoreCookie cookie;
2563     int reuseID;
2564     afs_int32 newDate, volflag, voltype, volsertype;
2565     int index, same, errcode;
2566     char apartName[10];
2567
2568
2569     memset(&cookie, 0, sizeof(cookie));
2570     islocked  = 0;
2571     success = 0;
2572     error = 0;
2573     reuseID = 1;
2574     tocall = (struct rx_call *)0;
2575     toconn = (struct rx_connection *)0;
2576     tempconn = (struct rx_connection *)0;
2577     totid = 0;
2578     temptid = 0;
2579
2580     if (flags & RV_RDONLY) {
2581         voltype    = ROVOL;
2582         volsertype = volser_RO;
2583     } else {
2584         voltype    = RWVOL;
2585         volsertype = volser_RW;
2586     }
2587
2588     pvolid = tovolid;
2589     toconn = UV_Bind(toserver, AFSCONF_VOLUMEPORT);
2590     if(pvolid == 0) {/*alot a new id if needed */
2591         vcode = VLDB_GetEntryByName(tovolname, &entry);
2592         if(vcode == VL_NOENT) {
2593             vcode = ubik_Call(VL_GetNewVolumeId,cstruct, 0, 1, &pvolid);
2594             if(vcode) {
2595                 fprintf(STDERR,"Could not get an Id for the volume %s\n",tovolname);
2596                 error = vcode;
2597                 goto refail;
2598             }
2599             reuseID = 0;
2600         } else if (flags & RV_RDONLY) {
2601             if (entry.flags & RW_EXISTS) {
2602                 fprintf(STDERR,"Entry for ReadWrite volume %s already exists!\n",entry.name);
2603                 error = VOLSERBADOP;
2604                 goto refail;
2605             }
2606             if (!entry.volumeId[ROVOL]) {
2607                 fprintf(STDERR,"Existing entry for volume %s has no ReadOnly ID\n",tovolname);
2608                 error = VOLSERBADOP;
2609                 goto refail;
2610             }
2611             pvolid = entry.volumeId[ROVOL];
2612         } else {
2613             pvolid = entry.volumeId[RWVOL];
2614         }
2615     }/* at this point we have a volume id to use/reuse for the volume to be restored */
2616
2617     if(strlen(tovolname) > (VOLSER_OLDMAXVOLNAME - 1)) {
2618         fprintf(STDERR,"The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n",tovolname);
2619         error = VOLSERBADOP;
2620         goto refail;
2621     }
2622     MapPartIdIntoName(topart, partName);
2623     fprintf(STDOUT,"Restoring volume %s Id %u on server %s partition %s ..", tovolname,
2624             pvolid, hostutil_GetNameByINet(toserver), partName);
2625     fflush(STDOUT);
2626     code = AFSVolCreateVolume(toconn, topart, tovolname, volsertype, 0,&pvolid, &totid);
2627     if (code){
2628         if (flags & RV_FULLRST) { /* full restore: delete then create anew */
2629             if(verbose) {
2630                 fprintf(STDOUT,"Deleting the previous volume %u ...",pvolid);
2631                 fflush(STDOUT);
2632             }
2633             code = AFSVolTransCreate(toconn, pvolid, topart, ITOffline, &totid);
2634             if (code) {
2635                 fprintf(STDERR,"Failed to start transaction on %u\n",pvolid);
2636                 error = code;
2637                 goto refail;
2638             }
2639             code = AFSVolSetFlags(toconn, totid, VTDeleteOnSalvage | VTOutOfService);
2640             if (code){
2641                 fprintf(STDERR,"Could not set flags on volume %u \n",pvolid);
2642                 error = code;
2643                 goto refail;
2644             }
2645             code = AFSVolDeleteVolume(toconn,totid);
2646             if (code){
2647                 fprintf(STDERR,"Could not delete volume %u\n",pvolid); 
2648                 error = code;
2649                 goto refail;
2650             }
2651             code = AFSVolEndTrans(toconn, totid, &rcode);
2652             totid = 0;
2653             if (!code) code = rcode;
2654             if (code) {
2655                 fprintf(STDERR,"Could not end transaction on %u\n",pvolid);
2656                 error = code;
2657                 goto refail;
2658             }
2659             if (verbose) fprintf(STDOUT," done\n");
2660             code = AFSVolCreateVolume(toconn, topart, tovolname, volsertype, 0,&pvolid, &totid);
2661             if (code){
2662                 fprintf(STDERR,"Could not create new volume %u\n",pvolid);
2663                 error = code;
2664                 goto refail;}
2665         }
2666         else{
2667             
2668             code = AFSVolTransCreate(toconn, pvolid, topart, ITOffline, &totid);
2669             if (code) {
2670                 fprintf(STDERR,"Failed to start transaction on %u\n",pvolid);
2671                 error = code;
2672                 goto refail;
2673             }
2674         }
2675     }
2676     cookie.parent = pvolid;
2677     cookie.type = voltype;
2678     cookie.clone = 0;
2679     strncpy(cookie.name,tovolname,VOLSER_OLDMAXVOLNAME);
2680
2681     tocall = rx_NewCall(toconn);
2682     terror = StartAFSVolRestore(tocall,totid, 1,&cookie);
2683     if(terror) {
2684         fprintf(STDERR,"Volume restore Failed \n");
2685         error = terror;
2686         goto refail;
2687     }
2688     code = WriteData(tocall, rock);
2689     if(code) {
2690         fprintf(STDERR,"Could not transmit data\n");
2691         error = code;
2692         goto refail;
2693     }
2694     terror = rx_EndCall(tocall,rxError);
2695     tocall = (struct rx_call *) 0;
2696     if (terror) {
2697         fprintf(STDERR,"rx_EndCall Failed \n");
2698         error = terror;     
2699         goto refail;
2700     }
2701     code = AFSVolGetStatus(toconn,totid, &tstatus);
2702     if(code) {
2703         fprintf(STDERR,"Could not get status information about the volume %u\n",pvolid);
2704         error = code;
2705         goto refail;
2706     }
2707     code = AFSVolSetIdsTypes(toconn,totid, tovolname, voltype, pvolid,0,0);
2708     if(code) {
2709         fprintf(STDERR,"Could not set the right type and ID on %u\n",pvolid); 
2710         error = code;
2711         goto refail;
2712     }
2713     newDate = time(0);
2714     code = AFSVolSetDate(toconn,totid, newDate);
2715     if(code) {
2716         fprintf(STDERR,"Could not set the date on %u\n",pvolid); 
2717         error = code;
2718         goto refail;
2719     }
2720
2721     volflag = ((flags & RV_OFFLINE) ? VTOutOfService : 0); /* off or on-line */
2722     code = AFSVolSetFlags(toconn, totid, volflag);
2723     if (code){
2724         fprintf(STDERR,"Could not mark %u online\n",pvolid );
2725         error = code;
2726         goto refail;
2727     }
2728    
2729 /* It isn't handled right in refail */
2730     code = AFSVolEndTrans(toconn, totid, &rcode);
2731     totid = 0;
2732     if(!code) code = rcode;
2733     if(code) {
2734         fprintf(STDERR,"Could not end transaction on %u\n",pvolid);
2735         error = code;
2736         goto refail;
2737     }
2738
2739     success = 1;
2740     fprintf(STDOUT," done\n");
2741     fflush(STDOUT);
2742     if (success && (!reuseID || (flags & RV_FULLRST))) {
2743         /* Volume was restored on the file server, update the 
2744          * VLDB to reflect the change.
2745          */
2746         vcode = VLDB_GetEntryByID(pvolid,voltype, &entry);
2747         if(vcode && vcode != VL_NOENT && vcode != VL_ENTDELETED) {
2748             fprintf(STDERR,"Could not fetch the entry for volume number %u from VLDB \n",pvolid);
2749             error = vcode;
2750             goto refail;
2751         }
2752         if (!vcode) MapHostToNetwork(&entry);
2753         if(vcode == VL_NOENT) { /* it doesnot exist already */
2754             /*make the vldb return this indication specifically*/
2755             if (verbose) fprintf(STDOUT,"------- Creating a new VLDB entry ------- \n");
2756             strcpy(entry.name, tovolname);
2757             entry.nServers = 1;
2758             entry.serverNumber[0] = toserver;/*should be indirect */
2759             entry.serverPartition[0] = topart;
2760             entry.serverFlags[0] = (flags & RV_RDONLY) ? ITSROVOL : ITSRWVOL;
2761             entry.flags = (flags & RV_RDONLY) ? RO_EXISTS : RW_EXISTS;
2762             if (flags & RV_RDONLY)
2763                 entry.volumeId[ROVOL] = pvolid;
2764             else if(tstatus.cloneID != 0){
2765                 entry.volumeId[ROVOL] = tstatus.cloneID;/*this should come from status info on the volume if non zero */
2766             }
2767             else
2768                 entry.volumeId[ROVOL] = INVALID_BID;
2769             entry.volumeId[RWVOL] = pvolid;
2770             entry.cloneId = 0;
2771             if(tstatus.backupID != 0){
2772                 entry.volumeId[BACKVOL] = tstatus.backupID;
2773                 /*this should come from status info on the volume if non zero */
2774             }
2775             else 
2776                 entry.volumeId[BACKVOL] = INVALID_BID;
2777             MapNetworkToHost(&entry,&storeEntry);
2778             vcode = VLDB_CreateEntry(&storeEntry);
2779             if(vcode) {
2780                 fprintf(STDERR,"Could not create the VLDB entry for volume number %u  \n",pvolid);
2781                 error = vcode;
2782                 goto refail;
2783             }
2784             islocked = 0;
2785             if (verbose) EnumerateEntry(&entry);
2786         }
2787         else {  /*update the existing entry */
2788             if(verbose) {
2789                 fprintf(STDOUT,"Updating the existing VLDB entry\n");
2790                 fprintf(STDOUT,"------- Old entry -------\n");
2791                 EnumerateEntry(&entry);
2792                 fprintf(STDOUT,"------- New entry -------\n");
2793             }
2794             vcode = ubik_Call(VL_SetLock,cstruct, 0, pvolid, voltype, VLOP_RESTORE);
2795             if(vcode) {
2796                 fprintf(STDERR,"Could not lock the entry for volume number %u \n",pvolid);
2797                 error = vcode;
2798                 goto refail;
2799             }
2800             islocked = 1;
2801             strcpy(entry.name, tovolname);
2802
2803             /* Update the vlentry with the new information */
2804             if (flags & RV_RDONLY)
2805                 index = Lp_ROMatch(toserver, topart, &entry) - 1;
2806             else
2807                 index = Lp_GetRwIndex(&entry);
2808             if (index == -1) {
2809                /* Add the new site for the volume being restored */
2810                entry.serverNumber[entry.nServers]    = toserver;
2811                entry.serverPartition[entry.nServers] = topart;
2812                entry.serverFlags[entry.nServers]     =
2813                         (flags & RV_RDONLY) ? ITSROVOL : ITSRWVOL;
2814                entry.nServers++;
2815             } else {
2816                /* This volume should be deleted on the old site
2817                 * if its different from new site.
2818                 */
2819                same = VLDB_IsSameAddrs(toserver, entry.serverNumber[index], &errcode);
2820                if (errcode) {
2821                   fprintf(STDERR,"Failed to get info about server's %d address(es) from vlserver (err=%d)\n", 
2822                           toserver, errcode);
2823                }
2824                if ( (!errcode && !same) || (entry.serverPartition[index] != topart) ) {
2825                   tempconn = UV_Bind(entry.serverNumber[index], AFSCONF_VOLUMEPORT);
2826                   if (verbose) {
2827                      MapPartIdIntoName(entry.serverPartition[index], apartName);
2828                      fprintf(STDOUT,"Deleting the previous volume %u on server %s, partition %s ...",
2829                              pvolid,
2830                              hostutil_GetNameByINet(entry.serverNumber[index]), apartName);
2831                      fflush(STDOUT);
2832                   }
2833                   code = AFSVolTransCreate(tempconn, pvolid, entry.serverPartition[index], ITOffline, &temptid);
2834                   if (!code){
2835                      code = AFSVolSetFlags(tempconn, temptid, VTDeleteOnSalvage | VTOutOfService);
2836                      if(code) {
2837                         fprintf(STDERR,"Could not set flags on volume %u on the older site\n",pvolid);
2838                         error = code;
2839                         goto refail;
2840                      }
2841                      code = AFSVolDeleteVolume(tempconn,temptid);
2842                      if(code){
2843                         fprintf(STDERR,"Could not delete volume %u on the older site\n",pvolid);
2844                         error = code;
2845                         goto refail;
2846                      }
2847                      code = AFSVolEndTrans(tempconn, temptid, &rcode);
2848                      temptid = 0;
2849                      if(!code) code = rcode;
2850                      if(code){
2851                         fprintf(STDERR,"Could not end transaction on volume %u on the older site\n",pvolid);
2852                         error = code;
2853                         goto refail;
2854                      }
2855                      if(verbose) fprintf(STDOUT," done\n");
2856                      MapPartIdIntoName(entry.serverPartition[index],partName);
2857                   }
2858                }
2859                entry.serverNumber[index]    = toserver;
2860                entry.serverPartition[index] = topart;
2861             }
2862
2863             entry.flags |= (flags & RV_RDONLY) ? RO_EXISTS : RW_EXISTS;
2864             MapNetworkToHost(&entry,&storeEntry);
2865             vcode = VLDB_ReplaceEntry(pvolid,voltype, &storeEntry,LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP );
2866             if(vcode) {
2867                 fprintf(STDERR,"Could not update the entry for volume number %u  \n",pvolid);
2868                 error = vcode;
2869                 goto refail;
2870             }
2871             islocked = 0;
2872             if(verbose) EnumerateEntry(&entry);
2873         }
2874
2875
2876     }
2877     refail:
2878       if (tocall) {
2879           code = rx_EndCall(tocall, rxError);
2880           if (!error) error = code;
2881       }
2882       if(islocked) {
2883           vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, pvolid, voltype, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
2884           if(vcode) {
2885               fprintf(STDERR,"Could not release lock on the VLDB entry for the volume %u\n",pvolid);
2886               if(!error) error = vcode;
2887           }
2888       }
2889       if(totid) {
2890           code = AFSVolEndTrans(toconn, totid, &rcode);
2891           if(!code) code = rcode;
2892           if(code) {
2893               fprintf(STDERR,"Could not end transaction on the volume %u \n",pvolid);
2894               if(!error) error = code;
2895           }
2896       }
2897       if(temptid) {
2898           code = AFSVolEndTrans(toconn, temptid, &rcode);
2899           if(!code) code = rcode;
2900           if(code) {
2901               fprintf(STDERR,"Could not end transaction on the volume %u \n",pvolid);
2902               if(!error) error = code;
2903           }
2904       }
2905       if(tempconn) rx_DestroyConnection(tempconn);
2906       if(toconn) rx_DestroyConnection(toconn);
2907       PrintError("",error);
2908       return error;
2909 }
2910
2911
2912 /*unlocks the vldb entry associated with <volid> */
2913 UV_LockRelease(volid)
2914 afs_int32 volid;
2915 {
2916         
2917         
2918     afs_int32 vcode;
2919
2920     if (verbose) fprintf(STDERR,"Binding to the VLDB server\n");
2921     vcode = ubik_Call(VL_ReleaseLock,cstruct, 0,volid,-1,LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP );
2922     if(vcode) {
2923         fprintf(STDERR,"Could not unlock the entry for volume number %u in VLDB \n",volid);
2924         PrintError("",vcode);
2925         return (vcode);
2926     }
2927     if (verbose) fprintf(STDERR,"VLDB updated\n");
2928     return 0;
2929
2930 }
2931
2932 /*adds <server> and <part> as a readonly replication site for <volid>
2933 *in vldb */
2934 UV_AddSite(server, part, volid)
2935 afs_int32 server, part, volid;
2936 {
2937     int j, nro=0, islocked=0;
2938     struct nvldbentry entry,storeEntry;
2939     afs_int32 vcode, error=0;
2940     char apartName[10];
2941
2942     error = ubik_Call(VL_SetLock,cstruct, 0,volid,RWVOL, VLOP_ADDSITE);
2943     if (error) {
2944         fprintf(STDERR," Could not lock the VLDB entry for the volume %u \n", volid);
2945         goto asfail;
2946     }
2947     islocked = 1;
2948
2949     error = VLDB_GetEntryByID(volid,RWVOL, &entry);
2950     if (error) {
2951         fprintf(STDERR,"Could not fetch the VLDB entry for volume number %u  \n",volid);
2952         goto asfail;
2953
2954     }
2955     if (!ISNAMEVALID(entry.name)){
2956         fprintf(STDERR,"Volume name %s is too long, rename before adding site\n", entry.name);
2957         error = VOLSERBADOP;
2958         goto asfail;
2959     }
2960     MapHostToNetwork(&entry);
2961
2962     /* See if it's too many entries */
2963     if (entry.nServers >= NMAXNSERVERS){
2964        fprintf(STDERR,"Total number of entries will exceed %u\n", NMAXNSERVERS);
2965        error = VOLSERBADOP;
2966        goto asfail;
2967     }
2968
2969     /* See if it's on the same server */
2970     for (j=0; j < entry.nServers; j++) {
2971        if (entry.serverFlags[j] & ITSROVOL) {
2972           nro++;
2973           if (VLDB_IsSameAddrs(server, entry.serverNumber[j], &error)) {
2974              if (error) {
2975                 fprintf(STDERR,"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n", 
2976                         server, error);
2977              } else {
2978                 MapPartIdIntoName(entry.serverPartition[j], apartName);
2979                 fprintf(STDERR,"RO already exists on partition %s. Multiple ROs on a single server aren't allowed\n", apartName);  
2980                 error =  VOLSERBADOP;
2981              }
2982              goto asfail;
2983           }
2984        }
2985     }
2986
2987     /* See if it's too many RO sites - leave one for the RW */
2988     if (nro >= NMAXNSERVERS-1){
2989        fprintf(STDERR,"Total number of sites will exceed %u\n", NMAXNSERVERS-1);
2990        error = VOLSERBADOP;
2991        goto asfail;
2992     }
2993
2994     if (verbose) fprintf(STDOUT,"Adding a new site ...");
2995     fflush(STDOUT);
2996     entry.serverNumber[entry.nServers] = server;
2997     entry.serverPartition[entry.nServers] = part;
2998     entry.serverFlags[entry.nServers] = (ITSROVOL | RO_DONTUSE);
2999     entry.nServers++;
3000         
3001     MapNetworkToHost(&entry,&storeEntry);
3002     error = VLDB_ReplaceEntry(volid,RWVOL,&storeEntry,LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3003     if (error) {
3004        fprintf(STDERR,"Could not update entry for volume %u \n",volid);
3005        goto asfail;
3006     }
3007     islocked = 0;
3008     if (verbose) fprintf(STDOUT," done\n");
3009
3010   asfail:
3011     if (islocked) {
3012        vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3013        if (vcode) {
3014           fprintf(STDERR,"Could not release lock on volume entry for %u \n",volid);
3015           PrintError("", vcode);
3016        }
3017     }
3018
3019     PrintError("", error);
3020     return error;
3021 }
3022
3023 /*removes <server> <part> as read only site for <volid> from the vldb */
3024 UV_RemoveSite(server, part, volid)
3025 afs_int32 server, part, volid;
3026 {
3027     afs_int32 vcode;
3028     struct nvldbentry entry,storeEntry;
3029     int islocked;
3030
3031     vcode = ubik_Call(VL_SetLock,cstruct, 0,volid,RWVOL, VLOP_ADDSITE);
3032     if(vcode) {
3033         fprintf(STDERR," Could not lock the VLDB entry for volume %u \n", volid);
3034         PrintError("",vcode);
3035         return(vcode);
3036     }
3037     islocked = 1;
3038     vcode = VLDB_GetEntryByID(volid,RWVOL, &entry);
3039     if(vcode) {
3040         fprintf(STDERR,"Could not fetch the entry for volume number %u from VLDB \n",volid);
3041         PrintError("",vcode);
3042         return (vcode);
3043     }
3044     MapHostToNetwork(&entry);
3045     if(!Lp_ROMatch(server, part, &entry)){
3046         /*this site doesnot exist  */
3047         fprintf(STDERR,"This site is not a replication site \n");
3048         vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3049         if(vcode) {
3050             fprintf(STDERR,"Could not update entry for volume %u \n",volid);
3051             PrintError("",vcode);
3052             ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3053             return(vcode);
3054         }
3055         return VOLSERBADOP;
3056     }
3057     else { /*remove the rep site */
3058         Lp_SetROValue(&entry, server, part, 0, 0);
3059         entry.nServers--;
3060         if((entry.nServers == 1) && (entry.flags & RW_EXISTS))
3061             entry.flags &= ~RO_EXISTS;
3062         if(entry.nServers < 1) { /*this is the last ref */
3063             if(verbose) fprintf(STDOUT,"Deleting the VLDB entry for %u ...",volid);
3064             fflush(STDOUT);
3065             vcode = ubik_Call(VL_DeleteEntry,cstruct, 0,volid, ROVOL);
3066             if(vcode) {
3067                 fprintf(STDERR,"Could not delete VLDB entry for volume %u \n",volid);
3068                 PrintError("",vcode);
3069                 return(vcode);
3070             }
3071             if (verbose) fprintf(STDOUT," done\n");
3072         }
3073         MapNetworkToHost(&entry,&storeEntry);
3074         fprintf(STDOUT,"Deleting the replication site for volume %u ...",volid);
3075         fflush(STDOUT);
3076         vcode = VLDB_ReplaceEntry(volid,RWVOL,&storeEntry,LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3077         if(vcode){ 
3078             fprintf(STDERR,"Could not release lock on volume entry for %u \n",volid);
3079             PrintError("",vcode);
3080             ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3081             return(vcode);
3082         }
3083         if(verbose) fprintf(STDOUT," done\n");
3084     }
3085     return 0;
3086 }
3087
3088 /*sets <server> <part> as read/write site for <volid> in the vldb */
3089 UV_ChangeLocation(server, part, volid)
3090 afs_int32 server, part, volid;
3091 {
3092     afs_int32 vcode;
3093     struct nvldbentry entry,storeEntry;
3094     int index;
3095
3096     vcode = ubik_Call(VL_SetLock,cstruct, 0,volid,RWVOL, VLOP_ADDSITE);
3097     if(vcode) {
3098         fprintf(STDERR," Could not lock the VLDB entry for volume %u \n", volid);
3099         PrintError("",vcode);
3100         return(vcode);
3101     }
3102     vcode = VLDB_GetEntryByID(volid,RWVOL, &entry);
3103     if(vcode) {
3104         fprintf(STDERR,"Could not fetch the entry for volume number %u from VLDB \n",volid);
3105         PrintError("",vcode);
3106         return (vcode);
3107     }
3108     MapHostToNetwork(&entry);
3109     index = Lp_GetRwIndex(&entry);
3110     if (index < 0) {
3111         /* no RW site exists  */
3112         fprintf(STDERR,"No existing RW site for volume %u", volid);
3113         vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3114         if(vcode) {
3115             fprintf(STDERR,"Could not release lock on entry for volume %u \n",volid);
3116             PrintError("",vcode);
3117             return(vcode);
3118         }
3119         return VOLSERBADOP;
3120     }
3121     else { /* change the RW site */
3122         entry.serverNumber[index] = server;
3123         entry.serverPartition[index] = part;
3124         MapNetworkToHost(&entry,&storeEntry);
3125         vcode = VLDB_ReplaceEntry(volid,RWVOL,&storeEntry,LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3126         if(vcode){ 
3127             fprintf(STDERR,"Could not update entry for volume %u \n",volid);
3128             PrintError("",vcode);
3129             ubik_Call(VL_ReleaseLock,cstruct, 0, volid, RWVOL, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3130             return(vcode);
3131         }
3132         if(verbose) fprintf(STDOUT," done\n");
3133     }
3134     return 0;
3135 }
3136
3137 /*list all the partitions on <aserver> */
3138 UV_ListPartitions(aserver, ptrPartList, cntp)
3139     afs_int32 aserver;
3140     struct partList *ptrPartList;
3141     afs_int32 *cntp;
3142 {
3143     struct rx_connection *aconn;
3144     struct pIDs partIds;
3145     struct partEntries partEnts;
3146     register int i, j=0, code;
3147
3148     *cntp = 0;
3149     aconn = UV_Bind(aserver,AFSCONF_VOLUMEPORT);
3150
3151     partEnts.partEntries_len = 0;
3152     partEnts.partEntries_val = (afs_int32 *)0;
3153     code = AFSVolXListPartitions(aconn, &partEnts); /* this is available only on new servers */
3154     if (code == RXGEN_OPCODE) 
3155     {
3156         for(i = 0; i < 26; i++)                         /* try old interface */
3157             partIds.partIds[i]  = -1;
3158         code = AFSVolListPartitions(aconn, &partIds);
3159         if (!code) {
3160             for (i = 0;i < 26; i++) {
3161                 if((partIds.partIds[i]) != -1) {
3162                     ptrPartList->partId[j] = partIds.partIds[i];
3163                     ptrPartList->partFlags[j] = PARTVALID;
3164                     j++;
3165                 } else
3166                     ptrPartList->partFlags[i] = 0;
3167             }
3168             *cntp = j;
3169         }
3170     }
3171     else if (!code) 
3172     {
3173         *cntp = partEnts.partEntries_len;
3174         if (*cntp > VOLMAXPARTS) {
3175             fprintf(STDERR,"Warning: number of partitions on the server too high %d (process only %d)\n",
3176                     *cntp, VOLMAXPARTS);
3177             *cntp = VOLMAXPARTS;
3178         }
3179         for (i = 0;i < *cntp; i++) {
3180             ptrPartList->partId[i] = partEnts.partEntries_val[i];
3181             ptrPartList->partFlags[i] = PARTVALID;
3182         }
3183         free(partEnts.partEntries_val);
3184     }
3185 out:
3186     if (code)
3187         fprintf(STDERR,"Could not fetch the list of partitions from the server\n");
3188     PrintError("",code);
3189     if(aconn) rx_DestroyConnection(aconn); 
3190     return code;
3191 }
3192
3193
3194 /*zap the list of volumes specified by volPtrArray (the volCloneId field).
3195  This is used by the backup system */
3196 UV_ZapVolumeClones(aserver,apart,volPtr,arraySize)
3197 afs_int32 aserver, apart;
3198 afs_int32 arraySize;
3199 struct volDescription *volPtr;
3200 {
3201     struct rx_connection *aconn;
3202     struct volDescription *curPtr;
3203     int curPos;
3204     afs_int32 code = 0;
3205     afs_int32 rcode = 0;
3206     afs_int32 success = 1;
3207     afs_int32 tid;
3208
3209     aconn = (struct rx_connection *)0;
3210     aconn = UV_Bind(aserver,AFSCONF_VOLUMEPORT);
3211     curPos = 0;
3212     for(curPtr = volPtr; curPos < arraySize; curPtr++) {
3213         if(curPtr->volFlags & CLONEVALID) {
3214             curPtr->volFlags &= ~CLONEZAPPED;
3215             success = 1;
3216             code = AFSVolTransCreate(aconn, curPtr->volCloneId, apart, ITOffline, &tid);
3217             if(code) success = 0;
3218             else {
3219                 code = AFSVolDeleteVolume(aconn, tid);
3220                 if(code) success = 0;
3221                 code = AFSVolEndTrans(aconn, tid, &rcode);
3222                 if(code || rcode) success = 0;
3223             }
3224             if(success) curPtr->volFlags |= CLONEZAPPED;
3225             if(!success) fprintf(STDERR,"Could not zap volume %u\n",curPtr->volCloneId);
3226             if(success && verbose) fprintf(STDOUT,"Clone of %s %u deleted\n", curPtr->volName,curPtr->volCloneId);
3227             curPos++;
3228             tid = 0;
3229         }
3230     }
3231     if(aconn)rx_DestroyConnection(aconn);
3232     return 0;
3233 }
3234
3235 /*return a list of clones of the volumes specified by volPtrArray. Used by the 
3236  backup system */
3237 UV_GenerateVolumeClones(aserver,apart,volPtr,arraySize)
3238 afs_int32 aserver, apart;
3239 afs_int32 arraySize;
3240 struct volDescription *volPtr;
3241 {
3242     struct rx_connection *aconn;
3243     struct volDescription *curPtr;
3244     int curPos;
3245     afs_int32 code = 0;
3246     afs_int32 rcode = 0;
3247     afs_int32 tid;
3248     int reuseCloneId = 0;
3249     afs_int32 curCloneId = 0;
3250     char cloneName[256];/*max vol name */
3251
3252     aconn = (struct rx_connection *)0;
3253     aconn = UV_Bind(aserver,AFSCONF_VOLUMEPORT);
3254     curPos = 0;
3255     if((volPtr->volFlags & REUSECLONEID) && (volPtr->volFlags & ENTRYVALID))
3256         reuseCloneId = 1;
3257     else { /*get a bunch of id's from vldb */
3258         code = ubik_Call(VL_GetNewVolumeId,cstruct, 0, arraySize, &curCloneId);
3259         if(code) {
3260             fprintf(STDERR,"Could not get ID's for the clone from VLDB\n");
3261             PrintError("",code);
3262             return code;
3263         }
3264     }
3265
3266     for(curPtr = volPtr; curPos < arraySize; curPtr++) {
3267         if(curPtr->volFlags & ENTRYVALID) {
3268
3269             curPtr->volFlags |= CLONEVALID; 
3270             /*make a clone of curParentId and record as curPtr->volCloneId */
3271             code = AFSVolTransCreate(aconn, curPtr->volId, apart, ITOffline, &tid);
3272             if(verbose && code) fprintf(STDERR,"Clone for volume %s %u failed \n",curPtr->volName,curPtr->volId);
3273             if(code) {
3274                 curPtr->volFlags &= ~CLONEVALID; /*cant clone */
3275                 curPos++;
3276                 continue;
3277             }
3278             if(strlen(curPtr->volName) < (VOLSER_OLDMAXVOLNAME - 9) ){
3279                 strcpy(cloneName, curPtr->volName);
3280                 strcat(cloneName,"-tmpClone-");
3281             }
3282             else strcpy(cloneName,"-tmpClone");
3283             if(reuseCloneId) {
3284                 curPtr->volCloneId = curCloneId;
3285                 curCloneId++;
3286             }
3287
3288             code = AFSVolClone(aconn, tid, 0, readonlyVolume, cloneName,&(curPtr->volCloneId));
3289             if(code){
3290                 curPtr->volFlags &= ~CLONEVALID;
3291                 curPos++;
3292                 fprintf(STDERR,"Could not clone %s due to error %u\n", curPtr->volName,code);
3293                 code=AFSVolEndTrans(aconn, tid, &rcode);
3294                 if(code)
3295                         fprintf(STDERR,"WARNING: could not end transaction\n");
3296                 continue;
3297             }
3298             if(verbose) fprintf(STDOUT,"********** Cloned %s temporary %u\n",cloneName,curPtr->volCloneId);
3299             code = AFSVolEndTrans(aconn, tid, &rcode);
3300             if(code || rcode) {
3301                 curPtr->volFlags &= ~CLONEVALID; 
3302                 curPos++;
3303                 continue;
3304             }
3305
3306             curPos++;
3307         }
3308     }
3309     if (aconn) rx_DestroyConnection(aconn);
3310     return 0;
3311 }
3312
3313         
3314 /*list all the volumes on <aserver> and <apart>. If all = 1, then all the
3315 * relevant fields of the volume are also returned. This is a heavy weight operation.*/
3316 UV_ListVolumes(aserver,apart,all,resultPtr,size)
3317 afs_int32 aserver, apart;
3318 int all ;
3319 struct volintInfo **resultPtr;
3320 afs_int32 *size;
3321 {
3322     struct rx_connection *aconn;
3323     afs_int32 code = 0;
3324     volEntries volumeInfo;
3325     
3326     code = 0;
3327     *size = 0;
3328     *resultPtr = (volintInfo *)0;
3329     volumeInfo.volEntries_val = (volintInfo *)0;/*this hints the stub to allocate space*/
3330     volumeInfo.volEntries_len = 0;
3331
3332     aconn = UV_Bind(aserver,AFSCONF_VOLUMEPORT);
3333     code = AFSVolListVolumes(aconn, apart, all, &volumeInfo);
3334     if(code) {
3335         fprintf(STDERR,"Could not fetch the list of volumes from the server\n");
3336     }
3337     else{
3338         *resultPtr = volumeInfo.volEntries_val;
3339         *size = volumeInfo.volEntries_len;
3340     }
3341
3342     if(aconn) rx_DestroyConnection(aconn);
3343     PrintError("",code);
3344     return code;    
3345 }
3346
3347 /*------------------------------------------------------------------------
3348  * EXPORTED UV_XListVolumes
3349  *
3350  * Description:
3351  *      List the extended information for all the volumes on a particular
3352  *      File Server and partition.  We may either return the volume's ID
3353  *      or all of its extended information.
3354  *
3355  * Arguments:
3356  *      a_serverID         : Address of the File Server for which we want
3357  *                              extended volume info.
3358  *      a_partID           : Partition for which we want the extended
3359  *                              volume info.
3360  *      a_all              : If non-zero, fetch ALL the volume info,
3361  *                              otherwise just the volume ID.
3362  *      a_resultPP         : Ptr to the address of the area containing
3363  *                              the returned volume info.
3364  *      a_numEntsInResultP : Ptr for the value we set for the number of
3365  *                              entries returned.
3366  *
3367  * Returns:
3368  *      0 on success,
3369  *      Otherise, the return value of AFSVolXListVolumes.
3370  *
3371  * Environment:
3372  *      This routine is closely related to UV_ListVolumes, which returns
3373  *      only the standard level of detail on AFS volumes. It is a
3374  *      heavyweight operation, zipping through all the volume entries for
3375  *      a given server/partition.
3376  *
3377  * Side Effects:
3378  *      As advertised.
3379  *------------------------------------------------------------------------*/
3380
3381 UV_XListVolumes(a_serverID, a_partID, a_all, a_resultPP, a_numEntsInResultP)
3382     afs_int32 a_serverID;
3383     afs_int32 a_partID;
3384     int a_all;
3385     struct volintXInfo **a_resultPP;
3386     afs_int32 *a_numEntsInResultP;
3387
3388 { /*UV_XListVolumes*/
3389
3390     struct rx_connection *rxConnP;      /*Ptr to the Rx connection involved*/
3391     afs_int32 code;                             /*Error code to return*/
3392     volXEntries volumeXInfo;            /*Area for returned extended vol info*/
3393
3394     /*
3395      * Set up our error code and the area for returned extended volume info.
3396      * We set the val field to a null pointer as a hint for the stub to
3397      * allocate space.
3398      */
3399     code = 0;
3400     *a_numEntsInResultP = 0;
3401     *a_resultPP = (volintXInfo *)0;
3402     volumeXInfo.volXEntries_val = (volintXInfo *)0;
3403     volumeXInfo.volXEntries_len = 0;
3404
3405     /*
3406      * Bind to the Volume Server port on the File Server machine in question,
3407      * then go for it.
3408      */
3409     rxConnP = UV_Bind(a_serverID, AFSCONF_VOLUMEPORT);
3410     code = AFSVolXListVolumes(rxConnP, a_partID, a_all, &volumeXInfo);
3411     if (code)
3412         fprintf(STDERR,
3413                 "[UV_XListVolumes] Couldn't fetch volume list\n");
3414     else {
3415         /*
3416          * We got the info; pull out the pointer to where the results lie
3417          * and how many entries are there.
3418          */
3419         *a_resultPP = volumeXInfo.volXEntries_val;
3420         *a_numEntsInResultP = volumeXInfo.volXEntries_len;
3421     }
3422
3423     /*
3424      * If we got an Rx connection, throw it away.
3425      */
3426     if (rxConnP)
3427         rx_DestroyConnection(rxConnP);
3428
3429     PrintError("", code);
3430     return(code);
3431 } /*UV_XListVolumes*/
3432
3433 /* get all the information about volume <volid> on <aserver> and <apart> */
3434 UV_ListOneVolume(aserver,apart,volid,resultPtr)
3435 afs_int32 aserver, apart;
3436 afs_int32 volid;
3437 struct volintInfo **resultPtr;
3438 {
3439     struct rx_connection *aconn;
3440     afs_int32 code = 0;
3441     volEntries volumeInfo;
3442     
3443     code = 0;
3444
3445     *resultPtr = (volintInfo *)0;
3446     volumeInfo.volEntries_val = (volintInfo *)0;/*this hints the stub to allocate space*/
3447     volumeInfo.volEntries_len = 0;
3448
3449     aconn = UV_Bind(aserver,AFSCONF_VOLUMEPORT);
3450     code = AFSVolListOneVolume(aconn, apart, volid, &volumeInfo);
3451     if(code) {
3452         fprintf(STDERR,"Could not fetch the information about volume %u from the server\n",volid);
3453     }
3454     else{
3455         *resultPtr = volumeInfo.volEntries_val;
3456         
3457     }
3458
3459     if(aconn) rx_DestroyConnection(aconn);
3460     PrintError("",code);
3461     return code;    
3462 }
3463
3464 /*------------------------------------------------------------------------
3465  * EXPORTED UV_XListOneVolume
3466  *
3467  * Description:
3468  *      List the extended information for a volume on a particular File
3469  *      Server and partition.
3470  *
3471  * Arguments:
3472  *      a_serverID         : Address of the File Server for which we want
3473  *                              extended volume info.
3474  *      a_partID           : Partition for which we want the extended
3475  *                              volume info.
3476  *      a_volID            : Volume ID for which we want the info.
3477  *      a_resultPP         : Ptr to the address of the area containing
3478  *                              the returned volume info.
3479  *
3480  * Returns:
3481  *      0 on success,
3482  *      Otherise, the return value of AFSVolXListOneVolume.
3483  *
3484  * Environment:
3485  *      This routine is closely related to UV_ListOneVolume, which returns
3486  *      only the standard level of detail on the chosen AFS volume.
3487  *
3488  * Side Effects:
3489  *      As advertised.
3490  *------------------------------------------------------------------------*/
3491
3492 UV_XListOneVolume(a_serverID, a_partID, a_volID, a_resultPP)
3493     afs_int32 a_serverID;
3494     afs_int32 a_partID;
3495     afs_int32 a_volID;
3496     struct volintXInfo **a_resultPP;
3497
3498 { /*UV_XListOneVolume*/
3499     struct rx_connection *rxConnP;      /*Rx connection to Volume Server*/
3500     afs_int32 code;                             /*Error code*/
3501     volXEntries volumeXInfo;            /*Area for returned info*/
3502
3503     /*
3504      * Set up our error code, and the area we're in which we are returning
3505      * the info.  Setting the val field to a null pointer tells the stub
3506      * to allocate space for us.
3507      */
3508     code = 0;
3509     *a_resultPP = (volintXInfo *)0;
3510     volumeXInfo.volXEntries_val = (volintXInfo *)0;
3511     volumeXInfo.volXEntries_len = 0;
3512
3513     /*
3514      * Bind to the Volume Server port on the File Server machine in question,
3515      * then go for it.
3516      */
3517     rxConnP = UV_Bind(a_serverID, AFSCONF_VOLUMEPORT);
3518     code = AFSVolXListOneVolume(rxConnP, a_partID, a_volID, &volumeXInfo);
3519     if(code)
3520         fprintf(STDERR,
3521                 "[UV_XListOneVolume] Couldn't fetch the volume information\n");
3522     else
3523         /*
3524          * We got the info; pull out the pointer to where the results lie.
3525          */
3526         *a_resultPP = volumeXInfo.volXEntries_val;
3527
3528     /*
3529      * If we got an Rx connection, throw it away.
3530      */
3531     if (rxConnP)
3532         rx_DestroyConnection(rxConnP);
3533
3534     PrintError("",code);
3535     return code;    
3536 } /*UV_XListOneVolume*/
3537
3538 /* CheckVolume()
3539  *    Given a volume we read from a partition, check if it is 
3540  *    represented in the VLDB correctly.
3541  * 
3542  *    The VLDB is looked up by the RW volume id (not its name).
3543  *    The RW contains the true name of the volume (BK and RO set
3544  *       the name in the VLDB only on creation of the VLDB entry).
3545  *    We want rules strict enough that when we check all volumes
3546  *       on one partition, it does not need to be done again. IE:
3547  *       two volumes on different partitions won't constantly 
3548  *       change a VLDB entry away from what the other set.
3549  *    For RW and BK volumes, we will always check the VLDB to see 
3550  *       if the two exist on the server/partition. May seem redundant,
3551  *       but this is an easy check of the VLDB. IE: if the VLDB entry
3552  *       says the BK exists but no BK volume is there, we will detect
3553  *       this when we check the RW volume.
3554  *    VLDB entries are locked only when a change needs to be done.
3555  *    Output changed to look a lot like the "vos syncserv" otuput.
3556  */
3557 static afs_int32 CheckVolume(volumeinfo, aserver, apart, modentry, maxvolid)
3558   volintInfo *volumeinfo;
3559   afs_int32 aserver, apart;
3560   afs_int32 *modentry;
3561   afs_uint32 *maxvolid;
3562 {   
3563    int   idx, j;
3564    afs_int32 code, error = 0;
3565    struct nvldbentry entry, storeEntry;
3566    char pname[10];
3567    int pass=0, islocked=0, createentry, addvolume, modified, mod;
3568    afs_int32 rwvolid;
3569
3570    if (modentry) *modentry = 0;
3571    rwvolid = ((volumeinfo->type == RWVOL) ? volumeinfo->volid : volumeinfo->parentID);