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