Bug Summary

File:volser/vsprocs.c
Location:line 4341, column 5
Description:Assigned value is always the same as the existing value

Annotated Source Code

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 <afs/vlserver.h>
25#include <afs/nfs.h>
26#include <afs/cellconfig.h>
27#include <afs/keys.h>
28#include <ubik.h>
29#include <afs/afsint.h>
30#include "volser.h"
31#include "volint.h"
32#include "lockdata.h"
33#include <afs/com_err.h>
34#include <rx/rxkad.h>
35#include <afs/kautils.h>
36#include <afs/cmd.h>
37#include <afs/ihandle.h>
38#ifdef AFS_NT40_ENV
39#include <afs/ntops.h>
40#endif
41#include <afs/vnode.h>
42#include <afs/volume.h>
43#define ERRCODE_RANGE8 8 /* from error_table.h */
44#define CLOCKSKEW2 2 /* not really skew, but resolution */
45#define CLOCKADJ(x)(((x) < 2) ? 0 : (x) - 2) (((x) < CLOCKSKEW2) ? 0 : (x) - CLOCKSKEW2)
46
47/* for UV_MoveVolume() recovery */
48
49#include <setjmp.h>
50
51#include "volser_internal.h"
52#include "volser_prototypes.h"
53#include "vsutils_prototypes.h"
54#include "lockprocs_prototypes.h"
55
56struct ubik_client *cstruct;
57int verbose = 0, noresolve = 0;
58
59struct release {
60 afs_uint32 crtime;
61 afs_uint32 uptime;
62 afs_int32 vldbEntryIndex;
63};
64
65/* Utility macros used by rest of this source file */
66#define EPRINT(ec, es)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, (es)); PrintError
(" ",ec); } while (0) \
67do { \
68 fprintf(STDERR__stderrp, "\n"); \
69 fprintf(STDERR__stderrp, (es)); \
70 PrintError(" ",ec); \
71} while (0)
72
73#define EPRINT1(ec, es, ep1)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, (es), (ep1)
); PrintError(" ",ec); } while (0) \
74do { \
75 fprintf(STDERR__stderrp, "\n"); \
76 fprintf(STDERR__stderrp, (es), (ep1)); \
77 PrintError(" ",ec); \
78} while (0)
79
80#define EPRINT2(ec, es, ep1, ep2)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, (es), (ep1)
, (ep2)); PrintError(" ",ec); } while (0) \
81do { \
82 fprintf(STDERR__stderrp, "\n"); \
83 fprintf(STDERR__stderrp, (es), (ep1), (ep2)); \
84 PrintError(" ",ec); \
85} while (0)
86
87#define EPRINT3(ec, es, ep1, ep2, ep3)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, (es), (ep1)
, (ep2), (ep3)); PrintError(" ",ec); } while (0) \
88do { \
89 fprintf(STDERR__stderrp, "\n"); \
90 fprintf(STDERR__stderrp, (es), (ep1), (ep2), (ep3)); \
91 PrintError(" ",ec); \
92} while (0)
93
94#define EGOTO(where, ec, es)do { if (ec) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((es))); PrintError(" ",(ec)); } while (0); error = (ec);
goto where; } } while (0) \
95do { \
96 if (ec) { \
97 EPRINT((ec),(es))do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ((es))); PrintError
(" ",(ec)); } while (0); \
98 error = (ec); \
99 goto where; \
100 } \
101} while (0)
102
103#define EGOTO1(where, ec, es, ep1)do { if (ec) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((es)), ((ep1))); PrintError(" ",(ec)); } while (0); error
= (ec); goto where; } } while (0) \
104do { \
105 if (ec) { \
106 EPRINT1((ec),(es),(ep1))do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ((es)), ((ep1
))); PrintError(" ",(ec)); } while (0); \
107 error = (ec); \
108 goto where; \
109 } \
110} while (0)
111
112#define EGOTO2(where, ec, es, ep1, ep2)do { if (ec) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((es)), ((ep1)), ((ep2))); PrintError(" ",(ec)); } while (
0); error = (ec); goto where; } } while (0) \
113do { \
114 if (ec) { \
115 EPRINT2((ec),(es),(ep1),(ep2))do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ((es)), ((ep1
)), ((ep2))); PrintError(" ",(ec)); } while (0); \
116 error = (ec); \
117 goto where; \
118 } \
119} while (0)
120
121#define EGOTO3(where, ec, es, ep1, ep2, ep3)do { if (ec) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((es)), ((ep1)), ((ep2)), ((ep3))); PrintError(" ",(ec));
} while (0); error = (ec); goto where; } } while (0) \
122do { \
123 if (ec) { \
124 EPRINT3((ec),(es),(ep1),(ep2),(ep3))do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ((es)), ((ep1
)), ((ep2)), ((ep3))); PrintError(" ",(ec)); } while (0); \
125 error = (ec); \
126 goto where; \
127 } \
128} while (0)
129
130#define VPRINT(es){ if (verbose) { fprintf(__stdoutp, (es)); fflush(__stdoutp);
} } \
131 { if (verbose) { fprintf(STDOUT__stdoutp, (es)); fflush(STDOUT__stdoutp); } }
132#define VPRINT1(es, p){ if (verbose) { fprintf(__stdoutp, (es), (p)); fflush(__stdoutp
); } } \
133 { if (verbose) { fprintf(STDOUT__stdoutp, (es), (p)); fflush(STDOUT__stdoutp); } }
134#define VPRINT2(es, p1, p2){ if (verbose) { fprintf(__stdoutp, (es), (p1), (p2)); fflush
(__stdoutp); } } \
135 { if (verbose) { fprintf(STDOUT__stdoutp, (es), (p1), (p2)); fflush(STDOUT__stdoutp); } }
136#define VPRINT3(es, p1, p2, p3){ if (verbose) { fprintf(__stdoutp, (es), (p1), (p2), (p3)); fflush
(__stdoutp); } } \
137 { if (verbose) { fprintf(STDOUT__stdoutp, (es), (p1), (p2), (p3)); fflush(STDOUT__stdoutp); } }
138#define VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } } \
139 { if (verbose) { fprintf(STDOUT__stdoutp, " done\n"); fflush(STDOUT__stdoutp); } }
140#define VEPRINT(es){ if (verbose) { fprintf(__stderrp, (es)); fflush(__stderrp);
} } \
141 { if (verbose) { fprintf(STDERR__stderrp, (es)); fflush(STDERR__stderrp); } }
142#define VEPRINT1(es, p){ if (verbose) { fprintf(__stderrp, (es), (p)); fflush(__stderrp
); } } \
143 { if (verbose) { fprintf(STDERR__stderrp, (es), (p)); fflush(STDERR__stderrp); } }
144#define VEPRINT2(es, p1, p2){ if (verbose) { fprintf(__stderrp, (es), (p1), (p2)); fflush
(__stderrp); } } \
145 { if (verbose) { fprintf(STDERR__stderrp, (es), (p1), (p2)); fflush(STDERR__stderrp); } }
146#define VEPRINT3(es, p1, p2, p3){ if (verbose) { fprintf(__stderrp, (es), (p1), (p2), (p3)); fflush
(__stderrp); } } \
147 { if (verbose) { fprintf(STDERR__stderrp, (es), (p1), (p2), (p3)); fflush(STDERR__stderrp); } }
148#define VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } } \
149 { if (verbose) { fprintf(STDERR__stderrp, " done\n"); fflush(STDERR__stderrp); } }
150
151
152
153/* getting rid of this */
154#define ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0) do { \
155 error = (code); \
156 goto error_exit; \
157} while (0)
158
159
160/* Protos for static routines */
161#if 0
162static afs_int32 CheckAndDeleteVolume(struct rx_connection *aconn,
163 afs_int32 apart, afs_uint32 okvol,
164 afs_uint32 delvol);
165#endif
166static int DelVol(struct rx_connection *conn, afs_uint32 vid, afs_int32 part,
167 afs_int32 flags);
168static int GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
169 struct rx_connection **connPtr, afs_int32 * transPtr,
170 afs_uint32 * crtimePtr, afs_uint32 * uptimePtr,
171 afs_int32 *origflags);
172static int SimulateForwardMultiple(struct rx_connection *fromconn,
173 afs_int32 fromtid, afs_int32 fromdate,
174 manyDests * tr, afs_int32 flags,
175 void *cookie, manyResults * results);
176static afs_int32 CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver,
177 afs_int32 apart, afs_int32 * modentry,
178 afs_uint32 * maxvolid, struct nvldbentry *aentry);
179static afs_int32 VolumeExists(afs_uint32 server, afs_int32 partition,
180 afs_uint32 volumeid);
181static afs_int32 CheckVldbRWBK(struct nvldbentry * entry,
182 afs_int32 * modified);
183static afs_int32 CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified);
184static afs_int32 CheckVldb(struct nvldbentry *entry, afs_int32 * modified,
185 afs_int32 *deleted);
186static void dump_sig_handler(int x);
187static int sortVolumes(const void *a, const void *b);
188
189
190/*map the partition <partId> into partition name <partName>*/
191void
192MapPartIdIntoName(afs_int32 partId, char *partName)
193{
194 if (partId < 26) { /* what if partId > = 26 ? */
195 strcpy(partName, "/vicep");
196 partName[6] = partId + 'a';
197 partName[7] = '\0';
198 return;
199 } else if (partId < VOLMAXPARTS255) {
200 strcpy(partName, "/vicep");
201 partId -= 26;
202 partName[6] = 'a' + (partId / 26);
203 partName[7] = 'a' + (partId % 26);
204 partName[8] = '\0';
205 return;
206 }
207}
208
209int
210PrintError(char *msg, afs_int32 errcode)
211{
212 fprintf(STDERR__stderrp, "%s", msg);
213 /*replace by a big switch statement */
214 switch (errcode) {
215 case 0:
216 break;
217 case -1:
218 fprintf(STDERR__stderrp, "Possible communication failure\n");
219 break;
220 case VSALVAGE101:
221 fprintf(STDERR__stderrp, "Volume needs to be salvaged\n");
222 break;
223 case VNOVNODE102:
224 fprintf(STDERR__stderrp, "Bad vnode number quoted\n");
225 break;
226 case VNOVOL103:
227 fprintf(STDERR__stderrp,
228 "Volume not attached, does not exist, or not on line\n");
229 break;
230 case VVOLEXISTS104:
231 fprintf(STDERR__stderrp, "Volume already exists\n");
232 break;
233 case VNOSERVICE105:
234 fprintf(STDERR__stderrp, "Volume is not in service\n");
235 break;
236 case VOFFLINE106:
237 fprintf(STDERR__stderrp, "Volume is off line\n");
238 break;
239 case VONLINE107:
240 fprintf(STDERR__stderrp, "Volume is already on line\n");
241 break;
242 case VDISKFULL108:
243 fprintf(STDERR__stderrp, "Partition is full\n");
244 break;
245 case VOVERQUOTA109:
246 fprintf(STDERR__stderrp, "Volume max quota exceeded\n");
247 break;
248 case VBUSY110:
249 fprintf(STDERR__stderrp, "Volume temporarily unavailable\n");
250 break;
251 case VMOVED111:
252 fprintf(STDERR__stderrp, "Volume has moved to another server\n");
253 break;
254 case VL_IDEXIST(363520L):
255 fprintf(STDERR__stderrp, "VLDB: volume Id exists in the vldb\n");
256 break;
257 case VL_IO(363521L):
258 fprintf(STDERR__stderrp, "VLDB: a read terminated too early\n");
259 break;
260 case VL_NAMEEXIST(363522L):
261 fprintf(STDERR__stderrp, "VLDB: volume entry exists in the vldb\n");
262 break;
263 case VL_CREATEFAIL(363523L):
264 fprintf(STDERR__stderrp, "VLDB: internal creation failure\n");
265 break;
266 case VL_NOENT(363524L):
267 fprintf(STDERR__stderrp, "VLDB: no such entry\n");
268 break;
269 case VL_EMPTY(363525L):
270 fprintf(STDERR__stderrp, "VLDB: vldb database is empty\n");
271 break;
272 case VL_ENTDELETED(363526L):
273 fprintf(STDERR__stderrp, "VLDB: entry is deleted (soft delete)\n");
274 break;
275 case VL_BADNAME(363527L):
276 fprintf(STDERR__stderrp, "VLDB: volume name is illegal\n");
277 break;
278 case VL_BADINDEX(363528L):
279 fprintf(STDERR__stderrp, "VLDB: index was out of range\n");
280 break;
281 case VL_BADVOLTYPE(363529L):
282 fprintf(STDERR__stderrp, "VLDB: bad volume type\n");
283 break;
284 case VL_BADSERVER(363530L):
285 fprintf(STDERR__stderrp, "VLDB: illegal server number (not within limits)\n");
286 break;
287 case VL_BADPARTITION(363531L):
288 fprintf(STDERR__stderrp, "VLDB: bad partition number\n");
289 break;
290 case VL_REPSFULL(363532L):
291 fprintf(STDERR__stderrp, "VLDB: run out of space for replication sites\n");
292 break;
293 case VL_NOREPSERVER(363533L):
294 fprintf(STDERR__stderrp, "VLDB: no such repsite server exists\n");
295 break;
296 case VL_DUPREPSERVER(363534L):
297 fprintf(STDERR__stderrp, "VLDB: replication site server already exists\n");
298 break;
299 case VL_RWNOTFOUND(363535L):
300 fprintf(STDERR__stderrp, "VLDB: parent r/w entry not found\n");
301 break;
302 case VL_BADREFCOUNT(363536L):
303 fprintf(STDERR__stderrp, "VLDB: illegal reference count number\n");
304 break;
305 case VL_SIZEEXCEEDED(363537L):
306 fprintf(STDERR__stderrp, "VLDB: vldb size for attributes exceeded\n");
307 break;
308 case VL_BADENTRY(363538L):
309 fprintf(STDERR__stderrp, "VLDB: bad incoming vldb entry\n");
310 break;
311 case VL_BADVOLIDBUMP(363539L):
312 fprintf(STDERR__stderrp, "VLDB: illegal max volid increment\n");
313 break;
314 case VL_IDALREADYHASHED(363540L):
315 fprintf(STDERR__stderrp, "VLDB: (RO/BACK) Id already hashed\n");
316 break;
317 case VL_ENTRYLOCKED(363541L):
318 fprintf(STDERR__stderrp, "VLDB: vldb entry is already locked\n");
319 break;
320 case VL_BADVOLOPER(363542L):
321 fprintf(STDERR__stderrp, "VLDB: bad volume operation code\n");
322 break;
323 case VL_BADRELLOCKTYPE(363543L):
324 fprintf(STDERR__stderrp, "VLDB: bad release lock type\n");
325 break;
326 case VL_RERELEASE(363544L):
327 fprintf(STDERR__stderrp, "VLDB: status report: last release was aborted\n");
328 break;
329 case VL_BADSERVERFLAG(363545L):
330 fprintf(STDERR__stderrp, "VLDB: invalid replication site server flag\n");
331 break;
332 case VL_PERM(363546L):
333 fprintf(STDERR__stderrp, "VLDB: no permission access for call\n");
334 break;
335 case VOLSERREAD_DUMPERROR(1492325122L):
336 fprintf(STDERR__stderrp,
337 "VOLSER: Problems encountered in reading the dump file !\n");
338 break;
339 case VOLSERDUMPERROR(1492325123L):
340 fprintf(STDERR__stderrp, "VOLSER: Problems encountered in doing the dump !\n");
341 break;
342 case VOLSERATTACH_ERROR(1492325124L):
343 fprintf(STDERR__stderrp, "VOLSER: Could not attach the volume\n");
344 break;
345 case VOLSERDETACH_ERROR(1492325126L):
346 fprintf(STDERR__stderrp, "VOLSER: Could not detach the volume\n");
347 break;
348 case VOLSERILLEGAL_PARTITION(1492325125L):
349 fprintf(STDERR__stderrp, "VOLSER: encountered illegal partition number\n");
350 break;
351 case VOLSERBAD_ACCESS(1492325127L):
352 fprintf(STDERR__stderrp, "VOLSER: permission denied, not a super user\n");
353 break;
354 case VOLSERVLDB_ERROR(1492325128L):
355 fprintf(STDERR__stderrp, "VOLSER: error detected in the VLDB\n");
356 break;
357 case VOLSERBADNAME(1492325129L):
358 fprintf(STDERR__stderrp, "VOLSER: error in volume name\n");
359 break;
360 case VOLSERVOLMOVED(1492325130L):
361 fprintf(STDERR__stderrp, "VOLSER: volume has moved\n");
362 break;
363 case VOLSERBADOP(1492325131L):
364 fprintf(STDERR__stderrp, "VOLSER: illegal operation\n");
365 break;
366 case VOLSERBADRELEASE(1492325132L):
367 fprintf(STDERR__stderrp, "VOLSER: release could not be completed\n");
368 break;
369 case VOLSERVOLBUSY(1492325133L):
370 fprintf(STDERR__stderrp, "VOLSER: volume is busy\n");
371 break;
372 case VOLSERNO_MEMORY(1492325134L):
373 fprintf(STDERR__stderrp, "VOLSER: volume server is out of memory\n");
374 break;
375 case VOLSERNOVOL(1492325135L):
376 fprintf(STDERR__stderrp,
377 "VOLSER: no such volume - location specified incorrectly or volume does not exist\n");
378 break;
379 case VOLSERMULTIRWVOL(1492325136L):
380 fprintf(STDERR__stderrp,
381 "VOLSER: multiple RW volumes with same ID, one of which should be deleted\n");
382 break;
383 case VOLSERFAILEDOP(1492325137L):
384 fprintf(STDERR__stderrp,
385 "VOLSER: not all entries were successfully processed\n");
386 break;
387 default:
388 {
389 initialize_KA_error_table();
390 initialize_RXK_error_table();
391 initialize_KTC_error_table();
392 initialize_ACFG_error_table();
393 initialize_CMD_error_table();
394 initialize_VL_error_table();
395
396 fprintf(STDERR__stderrp, "%s: %s\n", afs_error_table_name(errcode),
397 afs_error_message(errcode));
398 break;
399 }
400 }
401 return 0;
402}
403
404void init_volintInfo(struct volintInfo *vinfo) {
405 memset(vinfo, 0, sizeof(struct volintInfo));
406
407 vinfo->maxquota = -1;
408 vinfo->dayUse = -1;
409 vinfo->creationDate = -1;
410 vinfo->updateDate = -1;
411 vinfo->flags = -1;
412 vinfo->spare0 = -1;
413 vinfo->spare1 = -1;
414 vinfo->spare2 = -1;
415 vinfo->spare3 = -1;
416}
417
418static struct rx_securityClass *uvclass = 0;
419static int uvindex = -1;
420/* called by VLDBClient_Init to set the security module to be used in the RPC */
421int
422UV_SetSecurity(struct rx_securityClass *as, afs_int32 aindex)
423{
424 uvindex = aindex;
425 uvclass = as;
426 return 0;
427}
428
429/* bind to volser on <port> <aserver> */
430/* takes server address in network order, port in host order. dumb */
431struct rx_connection *
432UV_Bind(afs_uint32 aserver, afs_int32 port)
433{
434 struct rx_connection *tc;
435
436 tc = rx_NewConnection(aserver, htons(port)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t)(port
)) << 8 | ((__uint16_t)(port)) >> 8) : __bswap16_var
(port)), VOLSERVICE_ID4, uvclass,
437 uvindex);
438 return tc;
439}
440
441static int
442AFSVolCreateVolume_retry(struct rx_connection *z_conn,
443 afs_int32 partition, char *name, afs_int32 type,
444 afs_int32 parent, afs_uint32 *volid, afs_int32 *trans)
445{
446 afs_int32 code;
447 int retries = 3;
448 while (retries) {
449 code = AFSVolCreateVolume(z_conn, partition, name, type, parent,
450 volid, trans);
451 if (code != VOLSERVOLBUSY(1492325133L))
452 break;
453 retries--;
454#ifdef AFS_PTHREAD_ENV
455 sleep(3-retries);
456#else
457 IOMGR_Sleep(3-retries);
458#endif
459 }
460 return code;
461}
462
463static int
464AFSVolTransCreate_retry(struct rx_connection *z_conn,
465 afs_int32 volume, afs_int32 partition,
466 afs_int32 flags, afs_int32 * trans)
467{
468 afs_int32 code;
469 int retries = 3;
470 while (retries) {
471 code = AFSVolTransCreate(z_conn, volume, partition, flags, trans);
472 if (code != VOLSERVOLBUSY(1492325133L))
473 break;
474 retries--;
475#ifdef AFS_PTHREAD_ENV
476 sleep(3-retries);
477#else
478 IOMGR_Sleep(3-retries);
479#endif
480 }
481 return code;
482}
483
484#if 0
485/* if <okvol> is allright(indicated by beibg able to
486 * start a transaction, delete the <delvol> */
487static afs_int32
488CheckAndDeleteVolume(struct rx_connection *aconn, afs_int32 apart,
489 afs_uint32 okvol, afs_uint32 delvol)
490{
491 afs_int32 error, code, tid, rcode;
492 error = 0;
493 code = 0;
494
495 if (okvol == 0) {
496 code = AFSVolTransCreate_retry(aconn, delvol, apart, ITOffline1, &tid);
497 if (!error && code)
498 error = code;
499 code = AFSVolDeleteVolume(aconn, tid);
500 if (!error && code)
501 error = code;
502 code = AFSVolEndTrans(aconn, tid, &rcode);
503 if (!code)
504 code = rcode;
505 if (!error && code)
506 error = code;
507 return error;
508 } else {
509 code = AFSVolTransCreate_retry(aconn, okvol, apart, ITOffline1, &tid);
510 if (!code) {
511 code = AFSVolEndTrans(aconn, tid, &rcode);
512 if (!code)
513 code = rcode;
514 if (!error && code)
515 error = code;
516 code = AFSVolTransCreate_retry(aconn, delvol, apart, ITOffline1, &tid);
517 if (!error && code)
518 error = code;
519 code = AFSVolDeleteVolume(aconn, tid);
520 if (!error && code)
521 error = code;
522 code = AFSVolEndTrans(aconn, tid, &rcode);
523 if (!code)
524 code = rcode;
525 if (!error && code)
526 error = code;
527 } else
528 error = code;
529 return error;
530 }
531}
532
533#endif
534
535/* called by EmuerateEntry, show vldb entry in a reasonable format */
536void
537SubEnumerateEntry(struct nvldbentry *entry)
538{
539 int i;
540 char pname[10];
541 int isMixed = 0;
542 char hoststr[16];
543
544#ifdef notdef
545 fprintf(STDOUT__stdoutp, " readWriteID %-10u ", entry->volumeId[RWVOL0]);
546 if (entry->flags & RW_EXISTS0x1000)
547 fprintf(STDOUT__stdoutp, " valid \n");
548 else
549 fprintf(STDOUT__stdoutp, " invalid \n");
550 fprintf(STDOUT__stdoutp, " readOnlyID %-10u ", entry->volumeId[ROVOL1]);
551 if (entry->flags & RO_EXISTS0x2000)
552 fprintf(STDOUT__stdoutp, " valid \n");
553 else
554 fprintf(STDOUT__stdoutp, " invalid \n");
555 fprintf(STDOUT__stdoutp, " backUpID %-10u ", entry->volumeId[BACKVOL2]);
556 if (entry->flags & BACK_EXISTS0x4000)
557 fprintf(STDOUT__stdoutp, " valid \n");
558 else
559 fprintf(STDOUT__stdoutp, " invalid \n");
560 if ((entry->cloneId != 0) && (entry->flags & RO_EXISTS0x2000))
561 fprintf(STDOUT__stdoutp, " releaseClone %-10u \n", entry->cloneId);
562#else
563 if (entry->flags & RW_EXISTS0x1000)
564 fprintf(STDOUT__stdoutp, " RWrite: %-10u", entry->volumeId[RWVOL0]);
565 if (entry->flags & RO_EXISTS0x2000)
566 fprintf(STDOUT__stdoutp, " ROnly: %-10u", entry->volumeId[ROVOL1]);
567 if (entry->flags & BACK_EXISTS0x4000)
568 fprintf(STDOUT__stdoutp, " Backup: %-10u", entry->volumeId[BACKVOL2]);
569 if ((entry->cloneId != 0) && (entry->flags & RO_EXISTS0x2000))
570 fprintf(STDOUT__stdoutp, " RClone: %-10lu", (unsigned long)entry->cloneId);
571 fprintf(STDOUT__stdoutp, "\n");
572#endif
573 fprintf(STDOUT__stdoutp, " number of sites -> %lu\n",
574 (unsigned long)entry->nServers);
575 for (i = 0; i < entry->nServers; i++) {
576 if (entry->serverFlags[i] & NEW_REPSITE0x01)
577 isMixed = 1;
578 }
579 for (i = 0; i < entry->nServers; i++) {
580 MapPartIdIntoName(entry->serverPartition[i], pname);
581 fprintf(STDOUT__stdoutp, " server %s partition %s ",
582 noresolve ? afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
583 hostutil_GetNameByINet(entry->serverNumber[i]), pname);
584 if (entry->serverFlags[i] & ITSRWVOL0x04)
585 fprintf(STDOUT__stdoutp, "RW Site ");
586 else
587 fprintf(STDOUT__stdoutp, "RO Site ");
588 if (isMixed) {
589 if (entry->serverFlags[i] & NEW_REPSITE0x01)
590 fprintf(STDOUT__stdoutp," -- New release");
591 else
592 if (!(entry->serverFlags[i] & ITSRWVOL0x04))
593 fprintf(STDOUT__stdoutp," -- Old release");
594 } else {
595 if (entry->serverFlags[i] & RO_DONTUSE0x20)
596 fprintf(STDOUT__stdoutp, " -- Not released");
597 }
598 fprintf(STDOUT__stdoutp, "\n");
599 }
600
601 return;
602
603}
604
605/*enumerate the vldb entry corresponding to <entry> */
606void
607EnumerateEntry(struct nvldbentry *entry)
608{
609
610 fprintf(STDOUT__stdoutp, "\n");
611 fprintf(STDOUT__stdoutp, "%s \n", entry->name);
612 SubEnumerateEntry(entry);
613 return;
614}
615
616/* forcibly remove a volume. Very dangerous call */
617int
618UV_NukeVolume(afs_uint32 server, afs_int32 partid, afs_uint32 volid)
619{
620 struct rx_connection *tconn;
621 afs_int32 code;
622
623 tconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
624 if (tconn) {
625 code = AFSVolNukeVolume(tconn, partid, volid);
626 rx_DestroyConnection(tconn);
627 } else
628 code = 0;
629 return code;
630}
631
632/* like df. Return usage of <pname> on <server> in <partition> */
633int
634UV_PartitionInfo64(afs_uint32 server, char *pname,
635 struct diskPartition64 *partition)
636{
637 struct rx_connection *aconn;
638 afs_int32 code = 0;
639
640 aconn = (struct rx_connection *)0;
641 aconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
642 code = AFSVolPartitionInfo64(aconn, pname, partition);
643 if (code == RXGEN_OPCODE-455) {
644 struct diskPartition *dpp =
645 (struct diskPartition *)malloc(sizeof(struct diskPartition));
646 code = AFSVolPartitionInfo(aconn, pname, dpp);
647 if (!code) {
648 strncpy(partition->name, dpp->name, 32);
649 strncpy(partition->devName, dpp->devName, 32);
650 partition->lock_fd = dpp->lock_fd;
651 partition->free = dpp->free;
652 partition->minFree = dpp->minFree;
653 }
654 free(dpp);
655 }
656 if (code) {
657 fprintf(STDERR__stderrp, "Could not get information on partition %s\n", pname);
658 PrintError("", code);
659 }
660 if (aconn)
661 rx_DestroyConnection(aconn);
662 return code;
663}
664
665/* old interface to create volumes */
666int
667UV_CreateVolume(afs_uint32 aserver, afs_int32 apart, char *aname,
668 afs_uint32 * anewid)
669{
670 afs_int32 code;
671 *anewid = 0;
672 code = UV_CreateVolume2(aserver, apart, aname, 5000, 0, 0, 0, 0, anewid);
673 return code;
674}
675
676/* less old interface to create volumes */
677int
678UV_CreateVolume2(afs_uint32 aserver, afs_int32 apart, char *aname,
679 afs_int32 aquota, afs_int32 aspare1, afs_int32 aspare2,
680 afs_int32 aspare3, afs_int32 aspare4, afs_uint32 * anewid)
681{
682 afs_uint32 roid = 0, bkid = 0;
683 return UV_CreateVolume3(aserver, apart, aname, aquota, aspare1, aspare2,
684 aspare3, aspare4, anewid, &roid, &bkid);
685}
686
687/**
688 * Create a volume on the given server and partition
689 *
690 * @param aserver server to create volume on
691 * @param spart partition to create volume on
692 * @param aname name of new volume
693 * @param aquota quota for new volume
694 * @param anewid contains the desired volume id for the new volume. If
695 * *anewid == 0, a new id will be chosen, and will be placed
696 * in *anewid when UV_CreateVolume3 returns.
697 * @param aroid contains the desired RO volume id. If NULL, the RO id entry
698 * will be unset. If *aroid == 0, an id will be chosen, and
699 * will be placed in *anewid when UV_CreateVolume3 returns.
700 * @param abkid same as aroid, except for the BK volume id instead of the
701 * RO volume id.
702 * @return 0 on success, error code otherwise.
703 */
704int
705UV_CreateVolume3(afs_uint32 aserver, afs_int32 apart, char *aname,
706 afs_int32 aquota, afs_int32 aspare1, afs_int32 aspare2,
707 afs_int32 aspare3, afs_int32 aspare4, afs_uint32 * anewid,
708 afs_uint32 * aroid, afs_uint32 * abkid)
709{
710 struct rx_connection *aconn;
711 afs_int32 tid;
712 afs_int32 code;
713 afs_int32 error;
714 afs_int32 rcode, vcode;
715 afs_int32 lastid;
716 struct nvldbentry entry, storeEntry; /*the new vldb entry */
717 struct volintInfo tstatus;
718
719 tid = 0;
720 aconn = (struct rx_connection *)0;
721 error = 0;
722
723 init_volintInfo(&tstatus);
724 tstatus.maxquota = aquota;
725
726 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
727
728 if (aroid && *aroid) {
729 VPRINT1("Using RO volume ID %d.\n", *aroid){ if (verbose) { fprintf(__stdoutp, ("Using RO volume ID %d.\n"
), (*aroid)); fflush(__stdoutp); } };
730 }
731 if (abkid && *abkid) {
732 VPRINT1("Using BK volume ID %d.\n", *abkid){ if (verbose) { fprintf(__stdoutp, ("Using BK volume ID %d.\n"
), (*abkid)); fflush(__stdoutp); } };
733 }
734
735 if (*anewid) {
736 vcode = VLDB_GetEntryByID(*anewid, -1, &entry);
737 if (!vcode) {
738 fprintf(STDERR__stderrp, "Volume ID %d already exists\n", *anewid);
739 return VVOLEXISTS104;
740 }
741 VPRINT1("Using volume ID %d.\n", *anewid){ if (verbose) { fprintf(__stdoutp, ("Using volume ID %d.\n")
, (*anewid)); fflush(__stdoutp); } };
742 } else {
743 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, anewid);
744 EGOTO1(cfail, vcode, "Could not get an Id for volume %s\n", aname)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an Id for volume %s\n")), ((aname))); PrintError
(" ",(vcode)); } while (0); error = (vcode); goto cfail; } }
while (0);
745
746 if (aroid && *aroid == 0) {
747 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, aroid);
748 EGOTO1(cfail, vcode, "Could not get an RO Id for volume %s\n", aname)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an RO Id for volume %s\n")), ((aname))); PrintError
(" ",(vcode)); } while (0); error = (vcode); goto cfail; } }
while (0);
749 }
750
751 if (abkid && *abkid == 0) {
752 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, abkid);
753 EGOTO1(cfail, vcode, "Could not get a BK Id for volume %s\n", aname)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get a BK Id for volume %s\n")), ((aname))); PrintError
(" ",(vcode)); } while (0); error = (vcode); goto cfail; } }
while (0);
754 }
755 }
756
757 /* rw,ro, bk id are related in the default case */
758 /* If caller specified RW id, but not RO/BK ids, have them be RW+1 and RW+2 */
759 lastid = *anewid;
760 if (aroid && *aroid == 0) {
761 *aroid = ++lastid;
762 }
763 if (abkid && *abkid == 0) {
764 *abkid = ++lastid;
765 }
766
767 code =
768 AFSVolCreateVolume_retry(aconn, apart, aname, volser_RW0, 0, anewid, &tid);
769 EGOTO2(cfail, code, "Failed to create the volume %s %u \n", aname,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the volume %s %u \n")), ((aname)), ((*anewid
))); PrintError(" ",(code)); } while (0); error = (code); goto
cfail; } } while (0)
770 *anewid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the volume %s %u \n")), ((aname)), ((*anewid
))); PrintError(" ",(code)); } while (0); error = (code); goto
cfail; } } while (0);
771
772 code = AFSVolSetInfo(aconn, tid, &tstatus);
773 if (code)
774 EPRINT(code, "Could not change quota, continuing...\n")do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Could not change quota, continuing...\n"
)); PrintError(" ",code); } while (0);
775
776 code = AFSVolSetFlags(aconn, tid, 0); /* bring it online (mark it InService */
777 EGOTO2(cfail, code, "Could not bring the volume %s %u online \n", aname,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not bring the volume %s %u online \n")), ((aname))
, ((*anewid))); PrintError(" ",(code)); } while (0); error =
(code); goto cfail; } } while (0)
778 *anewid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not bring the volume %s %u online \n")), ((aname))
, ((*anewid))); PrintError(" ",(code)); } while (0); error =
(code); goto cfail; } } while (0);
779
780 VPRINT2("Volume %s %u created and brought online\n", aname, *anewid){ if (verbose) { fprintf(__stdoutp, ("Volume %s %u created and brought online\n"
), (aname), (*anewid)); fflush(__stdoutp); } };
781
782 /* set up the vldb entry for this volume */
783 strncpy(entry.name, aname, VOLSER_OLDMAXVOLNAME32);
784 entry.nServers = 1;
785 entry.serverNumber[0] = aserver; /* this should have another
786 * level of indirection later */
787 entry.serverPartition[0] = apart; /* this should also have
788 * another indirection level */
789 entry.flags = RW_EXISTS0x1000; /* this records that rw volume exists */
790 entry.serverFlags[0] = ITSRWVOL0x04; /*this rep site has rw vol */
791 entry.volumeId[RWVOL0] = *anewid;
792 entry.volumeId[ROVOL1] = aroid ? *aroid : 0;
793 entry.volumeId[BACKVOL2] = abkid ? *abkid : 0;
794 entry.cloneId = 0;
795 /*map into right byte order, before passing to xdr, the stuff has to be in host
796 * byte order. Xdr converts it into network order */
797 MapNetworkToHost(&entry, &storeEntry);
798 /* create the vldb entry */
799 vcode = VLDB_CreateEntry(&storeEntry);
800 if (vcode) {
801 fprintf(STDERR__stderrp,
802 "Could not create a VLDB entry for the volume %s %lu\n",
803 aname, (unsigned long)*anewid);
804 /*destroy the created volume */
805 VPRINT1("Deleting the newly created volume %u\n", *anewid){ if (verbose) { fprintf(__stdoutp, ("Deleting the newly created volume %u\n"
), (*anewid)); fflush(__stdoutp); } };
806 AFSVolDeleteVolume(aconn, tid);
807 error = vcode;
808 goto cfail;
809 }
810 VPRINT2("Created the VLDB entry for the volume %s %u\n", aname, *anewid){ if (verbose) { fprintf(__stdoutp, ("Created the VLDB entry for the volume %s %u\n"
), (aname), (*anewid)); fflush(__stdoutp); } };
811 /* volume created, now terminate the transaction and release the connection */
812 code = AFSVolEndTrans(aconn, tid, &rcode); /*if it crashes before this
813 * the volume will come online anyway when transaction timesout , so if
814 * vldb entry exists then the volume is guaranteed to exist too wrt create */
815 tid = 0;
816 if (code) {
817 fprintf(STDERR__stderrp,
818 "Failed to end the transaction on the volume %s %lu\n", aname,
819 (unsigned long)*anewid);
820 error = code;
821 goto cfail;
822 }
823
824 cfail:
825 if (tid) {
826 code = AFSVolEndTrans(aconn, tid, &rcode);
827 if (code)
828 fprintf(STDERR__stderrp, "WARNING: could not end transaction\n");
829 }
830 if (aconn)
831 rx_DestroyConnection(aconn);
832 PrintError("", error);
833 return error;
834}
835
836/* create a volume, given a server, partition number, volume name --> sends
837* back new vol id in <anewid>*/
838int
839UV_AddVLDBEntry(afs_uint32 aserver, afs_int32 apart, char *aname,
840 afs_uint32 aid)
841{
842 struct rx_connection *aconn;
843 afs_int32 error;
844 afs_int32 vcode;
845 struct nvldbentry entry, storeEntry; /*the new vldb entry */
846
847 aconn = (struct rx_connection *)0;
848 error = 0;
849
850 /* set up the vldb entry for this volume */
851 strncpy(entry.name, aname, VOLSER_OLDMAXVOLNAME32);
852 entry.nServers = 1;
853 entry.serverNumber[0] = aserver; /* this should have another
854 * level of indirection later */
855 entry.serverPartition[0] = apart; /* this should also have
856 * another indirection level */
857 entry.flags = RW_EXISTS0x1000; /* this records that rw volume exists */
858 entry.serverFlags[0] = ITSRWVOL0x04; /*this rep site has rw vol */
859 entry.volumeId[RWVOL0] = aid;
860#ifdef notdef
861 entry.volumeId[ROVOL1] = anewid + 1; /* rw,ro, bk id are related in the default case */
862 entry.volumeId[BACKVOL2] = *anewid + 2;
863#else
864 entry.volumeId[ROVOL1] = 0;
865 entry.volumeId[BACKVOL2] = 0;
866#endif
867 entry.cloneId = 0;
868 /*map into right byte order, before passing to xdr, the stuff has to be in host
869 * byte order. Xdr converts it into network order */
870 MapNetworkToHost(&entry, &storeEntry);
871 /* create the vldb entry */
872 vcode = VLDB_CreateEntry(&storeEntry);
873 if (vcode) {
874 fprintf(STDERR__stderrp,
875 "Could not create a VLDB entry for the volume %s %lu\n",
876 aname, (unsigned long)aid);
877 error = vcode;
878 goto cfail;
879 }
880 VPRINT2("Created the VLDB entry for the volume %s %u\n", aname, aid){ if (verbose) { fprintf(__stdoutp, ("Created the VLDB entry for the volume %s %u\n"
), (aname), (aid)); fflush(__stdoutp); } };
881
882 cfail:
883 if (aconn)
884 rx_DestroyConnection(aconn);
885 PrintError("", error);
886 return error;
887}
888
889/* Delete the volume <volid>on <aserver> <apart>
890 * the physical entry gets removed from the vldb only if the ref count
891 * becomes zero
892 */
893int
894UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
895{
896 struct rx_connection *aconn = (struct rx_connection *)0;
897 afs_int32 ttid = 0;
898 afs_int32 code, rcode;
899 afs_int32 error = 0;
900 struct nvldbentry entry, storeEntry;
901 int islocked = 0;
902 afs_int32 avoltype = -1, vtype;
903 int notondisk = 0, notinvldb = 0;
904
905 /* Find and read bhe VLDB entry for this volume */
906 code = ubik_VL_SetLock(cstruct, 0, avolid, avoltype, VLOP_DELETE0x80);
907 if (code) {
908 if (code != VL_NOENT(363524L)) {
909 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not lock VLDB entry for the volume %u\n")), ((avolid
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
910 "Could not lock VLDB entry for the volume %u\n", avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not lock VLDB entry for the volume %u\n")), ((avolid
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
911 }
912 notinvldb = 1;
913 } else {
914 islocked = 1;
915
916 code = VLDB_GetEntryByID(avolid, avoltype, &entry);
917 EGOTO1(error_exit, code, "Could not fetch VLDB entry for volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch VLDB entry for volume %u\n")), ((avolid)
)); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
918 avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch VLDB entry for volume %u\n")), ((avolid)
)); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
919 MapHostToNetwork(&entry);
920
921 if (verbose)
922 EnumerateEntry(&entry);
923 }
924
925 /* Whether volume is in the VLDB or not. Delete the volume on disk */
926 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
927 code = AFSVolTransCreate_retry(aconn, avolid, apart, ITOffline1, &ttid);
928 if (code) {
929 if (code == VNOVOL103) {
930 notondisk = 1;
931 } else {
932 EGOTO1(error_exit, code, "Transaction on volume %u failed\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Transaction on volume %u failed\n")), ((avolid))); PrintError
(" ",(code)); } while (0); error = (code); goto error_exit;
} } while (0)
933 avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Transaction on volume %u failed\n")), ((avolid))); PrintError
(" ",(code)); } while (0); error = (code); goto error_exit;
} } while (0);
934 }
935 } else {
936 VPRINT1("Trying to delete the volume %u ...", avolid){ if (verbose) { fprintf(__stdoutp, ("Trying to delete the volume %u ..."
), (avolid)); fflush(__stdoutp); } };
937
938 code = AFSVolDeleteVolume(aconn, ttid);
939 EGOTO1(error_exit, code, "Could not delete the volume %u \n", avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the volume %u \n")), ((avolid))); PrintError
(" ",(code)); } while (0); error = (code); goto error_exit;
} } while (0);
940
941 code = AFSVolEndTrans(aconn, ttid, &rcode);
942 code = (code ? code : rcode);
943 ttid = 0;
944 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the volume %u \n")), (
(avolid))); PrintError(" ",(code)); } while (0); error = (code
); goto error_exit; } } while (0)
945 "Could not end the transaction for the volume %u \n", avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the volume %u \n")), (
(avolid))); PrintError(" ",(code)); } while (0); error = (code
); goto error_exit; } } while (0);
946 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
947 }
948
949 /* Now update the VLDB entry.
950 * But first, verify we have a VLDB entry.
951 * Whether volume is on disk or not. Delete the volume in VLDB.
952 */
953 if (notinvldb)
954 ERROR_EXIT(0)do { error = (0); goto error_exit; } while (0);
955
956 if (avolid == entry.volumeId[BACKVOL2]) {
957 /* Its a backup volume, modify the VLDB entry. Check that the
958 * backup volume is on the server/partition we asked to delete.
959 */
960 if (!(entry.flags & BACK_EXISTS0x4000) || !Lp_Match(aserver, apart, &entry)) {
961 notinvldb = 2; /* Not on this server and partition */
962 ERROR_EXIT(0)do { error = (0); goto error_exit; } while (0);
963 }
964
965 VPRINT1("Marking the backup volume %u deleted in the VLDB\n", avolid){ if (verbose) { fprintf(__stdoutp, ("Marking the backup volume %u deleted in the VLDB\n"
), (avolid)); fflush(__stdoutp); } };
966
967 entry.flags &= ~BACK_EXISTS0x4000;
968 vtype = BACKVOL2;
969 }
970
971 else if (avolid == entry.volumeId[ROVOL1]) {
972 /* Its a read-only volume, modify the VLDB entry. Check that the
973 * readonly volume is on the server/partition we asked to delete.
974 * If flags does not have RO_EIXSTS set, then this may mean the RO
975 * hasn't been released (and could exist in VLDB).
976 */
977 if (!Lp_ROMatch(aserver, apart, &entry)) {
978 notinvldb = 2; /* Not found on this server and partition */
979 ERROR_EXIT(0)do { error = (0); goto error_exit; } while (0);
980 }
981
982 if (verbose)
983 fprintf(STDOUT__stdoutp,
984 "Marking the readonly volume %lu deleted in the VLDB\n",
985 (unsigned long)avolid);
986
987 Lp_SetROValue(&entry, aserver, apart, 0, 0); /* delete the site */
988 entry.nServers--;
989 if (!Lp_ROMatch(0, 0, &entry))
990 entry.flags &= ~RO_EXISTS0x2000; /* This was the last ro volume */
991 vtype = ROVOL1;
992 }
993
994 else if (avolid == entry.volumeId[RWVOL0]) {
995 /* It's a rw volume, delete the backup volume, modify the VLDB entry.
996 * Check that the readwrite volumes is on the server/partition we
997 * asked to delete.
998 */
999 if (!(entry.flags & RW_EXISTS0x1000) || !Lp_Match(aserver, apart, &entry)) {
1000 notinvldb = 2; /* Not found on this server and partition */
1001 ERROR_EXIT(0)do { error = (0); goto error_exit; } while (0);
1002 }
1003
1004 /* Delete backup if it exists */
1005 code =
1006 AFSVolTransCreate_retry(aconn, entry.volumeId[BACKVOL2], apart,
1007 ITOffline1, &ttid);
1008
1009 if (!code) {
1010 if (verbose) {
1011 fprintf(STDOUT__stdoutp, "Trying to delete the backup volume %u ...",
1012 entry.volumeId[BACKVOL2]);
1013 fflush(STDOUT__stdoutp);
1014 }
1015 code = AFSVolDeleteVolume(aconn, ttid);
1016 EGOTO1(error_exit, code, "Could not delete the volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the volume %u \n")), ((entry.volumeId[2
]))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
1017 entry.volumeId[BACKVOL])do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the volume %u \n")), ((entry.volumeId[2
]))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
1018
1019 code = AFSVolEndTrans(aconn, ttid, &rcode);
1020 ttid = 0;
1021 code = (code ? code : rcode);
1022 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the volume %u \n")), (
(entry.volumeId[2]))); PrintError(" ",(code)); } while (0);
error = (code); goto error_exit; } } while (0)
1023 "Could not end the transaction for the volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the volume %u \n")), (
(entry.volumeId[2]))); PrintError(" ",(code)); } while (0);
error = (code); goto error_exit; } } while (0)
1024 entry.volumeId[BACKVOL])do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the volume %u \n")), (
(entry.volumeId[2]))); PrintError(" ",(code)); } while (0);
error = (code); goto error_exit; } } while (0);
1025 if (verbose)
1026 fprintf(STDOUT__stdoutp, " done\n");
1027 }
1028
1029 if (verbose)
1030 fprintf(STDOUT__stdoutp,
1031 "Marking the readwrite volume %lu%s deleted in the VLDB\n",
1032 (unsigned long)avolid,
1033 ((entry.
1034 flags & BACK_EXISTS0x4000) ? ", and its backup volume," :
1035 ""));
1036
1037 Lp_SetRWValue(&entry, aserver, apart, 0L, 0L);
1038 entry.nServers--;
1039 entry.flags &= ~(BACK_EXISTS0x4000 | RW_EXISTS0x1000);
1040 vtype = RWVOL0;
1041
1042 if (entry.flags & RO_EXISTS0x2000)
1043 fprintf(STDERR__stderrp, "WARNING: ReadOnly copy(s) may still exist\n");
1044 }
1045
1046 else {
1047 notinvldb = 2; /* Not found on this server and partition */
1048 ERROR_EXIT(0)do { error = (0); goto error_exit; } while (0);
1049 }
1050
1051 /* Either delete or replace the VLDB entry */
1052 if ((entry.nServers <= 0) || !(entry.flags & (RO_EXISTS0x2000 | RW_EXISTS0x1000))) {
1053 if (verbose)
1054 fprintf(STDOUT__stdoutp,
1055 "Last reference to the VLDB entry for %lu - deleting entry\n",
1056 (unsigned long)avolid);
1057 code = ubik_VL_DeleteEntry(cstruct, 0, avolid, vtype);
1058 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0)
1059 "Could not delete the VLDB entry for the volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0)
1060 avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0);
1061 } else {
1062 MapNetworkToHost(&entry, &storeEntry);
1063 code =
1064 VLDB_ReplaceEntry(avolid, vtype, &storeEntry,
1065 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
1066 LOCKREL_TIMESTAMP1));
1067 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not update the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0)
1068 "Could not update the VLDB entry for the volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not update the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0)
1069 avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not update the VLDB entry for the volume %u \n")),
((avolid))); PrintError(" ",(code)); } while (0); error = (
code); goto error_exit; } } while (0);
1070 }
1071 islocked = 0;
1072
1073 error_exit:
1074 if (error)
1075 EPRINT(error, "\n")do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("\n")); PrintError
(" ",error); } while (0);
1076
1077 if (notondisk && notinvldb) {
1078 EPRINT2(VOLSERNOVOL, "Volume %u does not exist %s\n", avolid,do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Volume %u does not exist %s\n"
), (avolid), (((notinvldb == 2) ? "on server and partition" :
""))); PrintError(" ",(1492325135L)); } while (0)
1079 ((notinvldb == 2) ? "on server and partition" : ""))do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Volume %u does not exist %s\n"
), (avolid), (((notinvldb == 2) ? "on server and partition" :
""))); PrintError(" ",(1492325135L)); } while (0);
1080 if (!error)
1081 error = VOLSERNOVOL(1492325135L);
1082 } else if (notondisk) {
1083 fprintf(STDERR__stderrp,
1084 "WARNING: Volume %lu did not exist on the partition\n",
1085 (unsigned long)avolid);
1086 } else if (notinvldb) {
1087 fprintf(STDERR__stderrp, "WARNING: Volume %lu does not exist in VLDB %s\n",
1088 (unsigned long)avolid,
1089 ((notinvldb == 2) ? "on server and partition" : ""));
1090 }
1091
1092 if (ttid) {
1093 code = AFSVolEndTrans(aconn, ttid, &rcode);
1094 code = (code ? code : rcode);
1095 if (code) {
1096 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu\n",
1097 (unsigned long)avolid);
1098 PrintError("", code);
1099 if (!error)
1100 error = code;
1101 }
1102 }
1103
1104 if (islocked) {
1105 code =
1106 ubik_VL_ReleaseLock(cstruct, 0, avolid, -1,
1107 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
1108 LOCKREL_TIMESTAMP1));
1109 if (code) {
1110 EPRINT1(code,do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Could not release the lock on the VLDB entry for the volume %u \n"
), (avolid)); PrintError(" ",code); } while (0)
1111 "Could not release the lock on the VLDB entry for the volume %u \n",do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Could not release the lock on the VLDB entry for the volume %u \n"
), (avolid)); PrintError(" ",code); } while (0)
1112 avolid)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Could not release the lock on the VLDB entry for the volume %u \n"
), (avolid)); PrintError(" ",code); } while (0);
1113 if (!error)
1114 error = code;
1115 }
1116 }
1117
1118 if (aconn)
1119 rx_DestroyConnection(aconn);
1120 return error;
1121}
1122
1123/* add recovery to UV_MoveVolume */
1124
1125#define TESTC0 0 /* set to test recovery code, clear for production */
1126
1127jmp_buf env;
1128int interrupt = 0;
1129
1130static void *
1131do_interrupt(void * unused)
1132{
1133 if (interrupt) {
1134#if !defined(AFS_PTHREAD_ENV) && !defined(AFS_NT40_ENV)
1135 /* Avoid UNIX LWP from getting confused that our stack has suddenly
1136 * changed. This will avoid some sanity checks, but until a better way
1137 * is found, the only alternative is always crashing and burning on at
1138 * least the stack-overflow check. */
1139 lwp_cpptr->stack = NULL((void *)0);
1140#endif
1141 longjmp(env, 0);
1142 }
1143
1144 fprintf(STDOUT__stdoutp, "\nSIGINT handler: vos move operation in progress\n");
1145 fprintf(STDOUT__stdoutp,
1146 "WARNING: may leave AFS storage and metadata in indeterminate state\n");
1147 fprintf(STDOUT__stdoutp, "enter second control-c to exit\n");
1148 fflush(STDOUT__stdoutp);
1149
1150 interrupt = 1;
1151 return NULL((void *)0);
1152}
1153
1154static void
1155sigint_handler(int x)
1156{
1157#ifdef AFS_PTHREAD_ENV
1158 do_interrupt(NULL((void *)0));
1159#else
1160 IOMGR_SoftSig(do_interrupt, 0);
1161#endif
1162 (void)signal(SIGINT2, sigint_handler);
1163}
1164
1165/* Move volume <afromvol> on <afromserver> <afrompart> to <atoserver>
1166 * <atopart>. The operation is almost idempotent. The following
1167 * flags are recognized:
1168 *
1169 * RV_NOCLONE - don't use a copy clone
1170 */
1171
1172int
1173UV_MoveVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
1174 afs_uint32 atoserver, afs_int32 atopart, int flags)
1175{
1176 /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
1177 * be changing during the move */
1178 struct rx_connection * volatile toconn;
1179 struct rx_connection * volatile fromconn;
1180 afs_int32 volatile fromtid;
1181 afs_int32 volatile totid;
1182 afs_int32 volatile clonetid;
1183 afs_uint32 volatile newVol;
1184 afs_uint32 volatile volid;
1185 afs_uint32 volatile backupId;
1186 int volatile islocked;
1187 int volatile pntg;
1188
1189 char vname[64];
1190 char *volName = 0;
1191 char tmpName[VOLSER_MAXVOLNAME65 + 1];
1192 afs_int32 rcode;
1193 afs_int32 fromDate;
1194 afs_int32 tmp;
1195 afs_uint32 tmpVol;
1196 struct restoreCookie cookie;
1197 afs_int32 vcode, code;
1198 struct volser_status tstatus;
1199 struct destServer destination;
1200
1201 struct nvldbentry entry, storeEntry;
1202 int i;
1203 afs_int32 error;
1204 char in, lf; /* for test code */
1205 int same;
1206 char hoststr[16];
1207
1208#ifdef ENABLE_BUGFIX_1165
1209 volEntries volumeInfo;
1210 struct volintInfo *infop = 0;
1211#endif
1212
1213 islocked = 0;
1214 fromconn = (struct rx_connection *)0;
1215 toconn = (struct rx_connection *)0;
1216 fromtid = 0;
1217 totid = 0;
1218 clonetid = 0;
1219 error = 0;
1220 volid = 0;
1221 pntg = 0;
1222 backupId = 0;
1223 newVol = 0;
1224
1225 /* support control-c processing */
1226 if (setjmp(env))
1227 goto mfail;
1228 (void)signal(SIGINT2, sigint_handler);
1229
1230 if (TESTC0) {
1231 fprintf(STDOUT__stdoutp,
1232 "\nThere are three tests points - verifies all code paths through recovery.\n");
1233 fprintf(STDOUT__stdoutp, "First test point - operation not started.\n");
1234 fprintf(STDOUT__stdoutp, "...test here (y, n)? ");
1235 fflush(STDOUT__stdoutp);
1236 fscanf(stdin__stdinp, "%c", &in);
1237 fscanf(stdin__stdinp, "%c", &lf); /* toss away */
1238 if (in == 'y') {
1239 fprintf(STDOUT__stdoutp, "type control-c\n");
1240 while (1) {
1241 fprintf(stdout__stdoutp, ".");
1242 fflush(stdout__stdoutp);
1243 sleep(1);
1244 }
1245 }
1246 /* or drop through */
1247 }
1248
1249 vcode = VLDB_GetEntryByID(afromvol, -1, &entry);
1250 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1251 "Could not fetch the entry for the volume %u from the VLDB \n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1252 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
1253
1254 if (entry.volumeId[RWVOL0] != afromvol) {
1255 fprintf(STDERR__stderrp, "Only RW volume can be moved\n");
1256 exit(1);
1257 }
1258
1259 vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL0, VLOP_MOVE0x10);
1260 EGOTO1(mfail, vcode, "Could not lock entry for volume %u \n", afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not lock entry for volume %u \n")), ((afromvol)));
PrintError(" ",(vcode)); } while (0); error = (vcode); goto
mfail; } } while (0);
1261 islocked = 1;
1262
1263 vcode = VLDB_GetEntryByID(afromvol, RWVOL0, &entry);
1264 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1265 "Could not fetch the entry for the volume %u from the VLDB \n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1266 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
1267
1268 backupId = entry.volumeId[BACKVOL2];
1269 MapHostToNetwork(&entry);
1270
1271 if (!Lp_Match(afromserver, afrompart, &entry)) {
1272 /* the from server and partition do not exist in the vldb entry corresponding to volid */
1273 if (!Lp_Match(atoserver, atopart, &entry)) {
1274 /* the to server and partition do not exist in the vldb entry corresponding to volid */
1275 fprintf(STDERR__stderrp, "The volume %lu is not on the specified site. \n",
1276 (unsigned long)afromvol);
1277 fprintf(STDERR__stderrp, "The current site is :");
1278 for (i = 0; i < entry.nServers; i++) {
1279 if (entry.serverFlags[i] == ITSRWVOL0x04) {
1280 char pname[10];
1281 MapPartIdIntoName(entry.serverPartition[i], pname);
1282 fprintf(STDERR__stderrp, " server %s partition %s \n",
1283 noresolve ? afs_inet_ntoa_r(entry.serverNumber[i], hoststr) :
1284 hostutil_GetNameByINet(entry.serverNumber[i]),
1285 pname);
1286 }
1287 }
1288 vcode =
1289 ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
1290 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
1291 LOCKREL_TIMESTAMP1));
1292 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((" Could not release lock on the VLDB entry for the volume %u \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1293 " Could not release lock on the VLDB entry for the volume %u \n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((" Could not release lock on the VLDB entry for the volume %u \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1294 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, ((" Could not release lock on the VLDB entry for the volume %u \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
1295
1296 return VOLSERVOLMOVED(1492325130L);
1297 }
1298
1299 /* delete the volume afromvol on src_server */
1300 /* from-info does not exist but to-info does =>
1301 * we have already done the move, but the volume
1302 * may still be existing physically on from fileserver
1303 */
1304 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
1305 fromtid = 0;
1306 pntg = 1;
1307
1308 tmp = fromtid;
1309 code =
1310 AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITOffline1,
1311 &tmp);
1312 fromtid = tmp;
1313
1314 if (!code) { /* volume exists - delete it */
1315 VPRINT1("Setting flags on leftover source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Setting flags on leftover source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
1316 afromvol){ if (verbose) { fprintf(__stdoutp, ("Setting flags on leftover source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1317 code =
1318 AFSVolSetFlags(fromconn, fromtid,
1319 VTDeleteOnSalvage1 | VTOutOfService2);
1320 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set flags on the leftover source volume %u\n")
), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1321 "Failed to set flags on the leftover source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set flags on the leftover source volume %u\n")
), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1322 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set flags on the leftover source volume %u\n")
), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1323 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1324
1325 VPRINT1("Deleting leftover source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Deleting leftover source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1326 code = AFSVolDeleteVolume(fromconn, fromtid);
1327 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the leftover source volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1328 "Failed to delete the leftover source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the leftover source volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1329 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the leftover source volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1330 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1331
1332 VPRINT1("Ending transaction on leftover source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on leftover source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
1333 afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on leftover source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1334 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1335 fromtid = 0;
1336 if (!code)
1337 code = rcode;
1338 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover source volume %u \n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1339 "Could not end the transaction for the leftover source volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover source volume %u \n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1340 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover source volume %u \n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1341 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1342 }
1343
1344 /*delete the backup volume now */
1345 fromtid = 0;
1346 code =
1347 AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline1,
1348 &tmp);
1349 fromtid = tmp;
1350
1351 if (!code) { /* backup volume exists - delete it */
1352 VPRINT1("Setting flags on leftover backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Setting flags on leftover backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
1353 backupId){ if (verbose) { fprintf(__stdoutp, ("Setting flags on leftover backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
1354 code =
1355 AFSVolSetFlags(fromconn, fromtid,
1356 VTDeleteOnSalvage1 | VTOutOfService2);
1357 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set flags on the backup volume %u\n")), ((backupId
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1358 "Failed to set flags on the backup volume %u\n", backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set flags on the backup volume %u\n")), ((backupId
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1359 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1360
1361 VPRINT1("Deleting leftover backup volume %u ...", backupId){ if (verbose) { fprintf(__stdoutp, ("Deleting leftover backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
1362 code = AFSVolDeleteVolume(fromconn, fromtid);
1363 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the leftover backup volume %u\n")), ((backupId
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1364 "Could not delete the leftover backup volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the leftover backup volume %u\n")), ((backupId
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1365 backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the leftover backup volume %u\n")), ((backupId
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1366 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1367
1368 VPRINT1("Ending transaction on leftover backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on leftover backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
1369 backupId){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on leftover backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
1370 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1371 fromtid = 0;
1372 if (!code)
1373 code = rcode;
1374 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover backup volume %u\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1375 "Could not end the transaction for the leftover backup volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover backup volume %u\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1376 backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction for the leftover backup volume %u\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1377 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1378 }
1379
1380 fromtid = 0;
1381 error = 0;
1382 goto mfail;
1383 }
1384
1385 /* From-info matches the vldb info about volid,
1386 * its ok start the move operation, the backup volume
1387 * on the old site is deleted in the process
1388 */
1389 if (afrompart == atopart) {
1390 same = VLDB_IsSameAddrs(afromserver, atoserver, &error);
1391 EGOTO2(mfail, error,do { if (error) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n"
)), ((afromserver)), ((error))); PrintError(" ",(error)); }
while (0); error = (error); goto mfail; } } while (0)
1392 "Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",do { if (error) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n"
)), ((afromserver)), ((error))); PrintError(" ",(error)); }
while (0); error = (error); goto mfail; } } while (0)
1393 afromserver, error)do { if (error) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n"
)), ((afromserver)), ((error))); PrintError(" ",(error)); }
while (0); error = (error); goto mfail; } } while (0);
1394
1395 if (same) {
1396 EGOTO1(mfail, VOLSERVOLMOVED,do { if ((1492325130L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("Warning: Moving volume %u to its home partition ignored!\n"
)), ((afromvol))); PrintError(" ",((1492325130L))); } while
(0); error = ((1492325130L)); goto mfail; } } while (0)
1397 "Warning: Moving volume %u to its home partition ignored!\n",do { if ((1492325130L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("Warning: Moving volume %u to its home partition ignored!\n"
)), ((afromvol))); PrintError(" ",((1492325130L))); } while
(0); error = ((1492325130L)); goto mfail; } } while (0)
1398 afromvol)do { if ((1492325130L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("Warning: Moving volume %u to its home partition ignored!\n"
)), ((afromvol))); PrintError(" ",((1492325130L))); } while
(0); error = ((1492325130L)); goto mfail; } } while (0);
1399 }
1400 }
1401
1402 pntg = 1;
1403 toconn = UV_Bind(atoserver, AFSCONF_VOLUMEPORT7005); /* get connections to the servers */
1404 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
1405 fromtid = totid = 0; /* initialize to uncreated */
1406
1407 /* ***
1408 * clone the read/write volume locally.
1409 * ***/
1410
1411 VPRINT1("Starting transaction on source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1412 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2, &tmp);
1413 fromtid = tmp;
1414 EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1415 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1416 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1417
1418 if (!(flags & RV_NOCLONE0x080000)) {
1419 /* Get a clone id */
1420 VPRINT1("Allocating new volume id for clone of volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
1421 afromvol){ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1422 newVol = tmpVol = 0;
1423 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
1424 newVol = tmpVol;
1425 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1426 "Could not get an ID for the clone of volume %u from the VLDB\n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
1427 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
1428 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1429
1430 /* Do the clone. Default flags on clone are set to delete on salvage and out of service */
1431 VPRINT1("Cloning source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Cloning source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1432 strcpy(vname, "move-clone-temp");
1433 code =
1434 AFSVolClone(fromconn, fromtid, 0, readonlyVolume1, vname, &tmpVol);
1435 newVol = tmpVol;
1436 EGOTO1(mfail, code, "Failed to clone the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1437 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1438 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1439 }
1440
1441 /* lookup the name of the volume we just cloned */
1442 volid = afromvol;
1443 code = AFSVolGetName(fromconn, fromtid, &volName);
1444 EGOTO1(mfail, code, "Failed to get the name of the volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the name of the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1445 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the name of the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1446
1447 VPRINT1("Ending the transaction on the source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending the transaction on the source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1448 rcode = 0;
1449 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1450 fromtid = 0;
1451 if (!code)
1452 code = rcode;
1453 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1454 "Failed to end the transaction on the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1455 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1456 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1457
1458 /* ***
1459 * Create the destination volume
1460 * ***/
1461
1462 if (!(flags & RV_NOCLONE0x080000)) {
1463 /* All of this is to get the fromDate */
1464 VPRINT1("Starting transaction on the cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on the cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1465 tmp = clonetid;
1466 code =
1467 AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline1,
1468 &tmp);
1469 clonetid = tmp;
1470 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1471 "Failed to start a transaction on the cloned volume%u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1472 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1473 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1474
1475 VPRINT1("Setting flags on cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Setting flags on cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1476 code =
1477 AFSVolSetFlags(fromconn, clonetid,
1478 VTDeleteOnSalvage1 | VTOutOfService2); /*redundant */
1479 EGOTO1(mfail, code, "Could not set flags on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on the cloned volume %u\n")), ((newVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1480 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on the cloned volume %u\n")), ((newVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1481 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1482
1483 /* remember time from which we've dumped the volume */
1484 VPRINT1("Getting status of cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Getting status of cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1485 code = AFSVolGetStatus(fromconn, clonetid, &tstatus);
1486 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(newVol))); PrintError(" ",(code)); } while (0); error = (code
); goto mfail; } } while (0)
1487 "Failed to get the status of the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(newVol))); PrintError(" ",(code)); } while (0); error = (code
); goto mfail; } } while (0)
1488 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(newVol))); PrintError(" ",(code)); } while (0); error = (code
); goto mfail; } } while (0);
1489 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1490
1491 fromDate = CLOCKADJ(tstatus.creationDate)(((tstatus.creationDate) < 2) ? 0 : (tstatus.creationDate)
- 2);
1492 } else {
1493 /* With RV_NOCLONE, just do a full copy from the source */
1494 fromDate = 0;
1495 }
1496
1497
1498#ifdef ENABLE_BUGFIX_1165
1499 /*
1500 * Get the internal volume state from the source volume. We'll use such info (i.e. dayUse)
1501 * to copy it to the new volume (via AFSSetInfo later on) so that when we move volumes we
1502 * don't use this information...
1503 */
1504 volumeInfo.volEntries_val = (volintInfo *) 0; /*this hints the stub to allocate space */
1505 volumeInfo.volEntries_len = 0;
1506 code = AFSVolListOneVolume(fromconn, afrompart, afromvol, &volumeInfo);
1507 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the volint Info of the cloned volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1508 "Failed to get the volint Info of the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the volint Info of the cloned volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1509 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the volint Info of the cloned volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1510
1511 infop = (volintInfo *) volumeInfo.volEntries_val;
1512 infop->maxquota = -1; /* Else it will replace the default quota */
1513 infop->creationDate = -1; /* Else it will use the source creation date */
1514 infop->updateDate = -1; /* Else it will use the source update date */
1515#endif
1516
1517 /* create a volume on the target machine */
1518 volid = afromvol;
1519 tmp = totid;
1520 code = AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline1, &tmp);
1521 totid = tmp;
1522 if (!code) {
1523 /* Delete the existing volume.
1524 * While we are deleting the volume in these steps, the transaction
1525 * we started against the cloned volume (clonetid above) will be
1526 * sitting idle. It will get cleaned up after 600 seconds
1527 */
1528 VPRINT1("Deleting pre-existing volume %u on destination ...", volid){ if (verbose) { fprintf(__stdoutp, ("Deleting pre-existing volume %u on destination ..."
), (volid)); fflush(__stdoutp); } };
1529 code = AFSVolDeleteVolume(toconn, totid);
1530 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1531 "Could not delete the pre-existing volume %u on destination\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1532 volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1533 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1534
1535 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (volid)); fflush(__stdoutp); } }
1536 ("Ending transaction on pre-existing volume %u on destination ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (volid)); fflush(__stdoutp); } }
1537 volid){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (volid)); fflush(__stdoutp); } };
1538 code = AFSVolEndTrans(toconn, totid, &rcode);
1539 totid = 0;
1540 if (!code)
1541 code = rcode;
1542 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1543 "Could not end the transaction on pre-existing volume %u on destination\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1544 volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1545 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1546 }
1547
1548 VPRINT1("Creating the destination volume %u ...", volid){ if (verbose) { fprintf(__stdoutp, ("Creating the destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
1549 tmp = totid;
1550 tmpVol = volid;
1551 code =
1552 AFSVolCreateVolume(toconn, atopart, volName, volser_RW0, volid, &tmpVol,
1553 &tmp);
1554 totid = tmp;
1555 volid = tmpVol;
1556 EGOTO1(mfail, code, "Failed to create the destination volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the destination volume %u\n")), ((volid
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1557 volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the destination volume %u\n")), ((volid
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1558 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1559
1560 strncpy(tmpName, volName, VOLSER_OLDMAXVOLNAME32);
1561 free(volName);
1562 volName = NULL((void *)0);
1563
1564 VPRINT1("Setting volume flags on destination volume %u ...", volid){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags on destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
1565 code =
1566 AFSVolSetFlags(toconn, totid, (VTDeleteOnSalvage1 | VTOutOfService2));
1567 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the destination volume %u\n")
), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1568 "Failed to set the flags on the destination volume %u\n", volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the destination volume %u\n")
), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1569 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1570
1571 /***
1572 * Now dump the clone to the new volume
1573 ***/
1574
1575 destination.destHost = ntohl(atoserver)(__builtin_constant_p(atoserver) ? ((((__uint32_t)(atoserver)
) >> 24) | ((((__uint32_t)(atoserver)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(atoserver)) & (0xff <<
8)) << 8) | (((__uint32_t)(atoserver)) << 24)) :
__bswap32_var(atoserver));
1576 destination.destPort = AFSCONF_VOLUMEPORT7005;
1577 destination.destSSID = 1;
1578
1579 strncpy(cookie.name, tmpName, VOLSER_OLDMAXVOLNAME32);
1580 cookie.type = RWVOL0;
1581 cookie.parent = entry.volumeId[RWVOL0];
1582 cookie.clone = 0;
1583
1584 if (!(flags & RV_NOCLONE0x080000)) {
1585 /* Copy the clone to the new volume */
1586 VPRINT2("Dumping from clone %u on source to volume %u on destination ...",{ if (verbose) { fprintf(__stdoutp, ("Dumping from clone %u on source to volume %u on destination ..."
), (newVol), (afromvol)); fflush(__stdoutp); } }
1587 newVol, afromvol){ if (verbose) { fprintf(__stdoutp, ("Dumping from clone %u on source to volume %u on destination ..."
), (newVol), (afromvol)); fflush(__stdoutp); } };
1588 code =
1589 AFSVolForward(fromconn, clonetid, 0, &destination, totid,
1590 &cookie);
1591 EGOTO1(mfail, code, "Failed to move data for the volume %u\n", volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to move data for the volume %u\n")), ((volid))); PrintError
(" ",(code)); } while (0); error = (code); goto mfail; } } while
(0);
1592 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1593
1594 VPRINT1("Ending transaction on cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1595 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1596 if (!code)
1597 code = rcode;
1598 clonetid = 0;
1599 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1600 "Failed to end the transaction on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1601 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1602 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1603 }
1604
1605 /* ***
1606 * reattach to the main-line volume, and incrementally dump it.
1607 * ***/
1608
1609 VPRINT1("Starting transaction on source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1610 tmp = fromtid;
1611 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2, &tmp);
1612 fromtid = tmp;
1613 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1614 "Failed to create a transaction on the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1615 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1616 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1617
1618 /* now do the incremental */
1619 VPRINT2{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
1620 ("Doing the%s dump from source to destination for volume %u ... ",{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
1621 (flags & RV_NOCLONE) ? "" : " incremental",{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
1622 afromvol){ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } };
1623 code =
1624 AFSVolForward(fromconn, fromtid, fromDate, &destination, totid,
1625 &cookie);
1626 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from rw volume on old site to rw volume on newsite\n"
)), (((flags & 0x080000) ? "" : " incremental"))); PrintError
(" ",(code)); } while (0); error = (code); goto mfail; } } while
(0)
1627 "Failed to do the%s dump from rw volume on old site to rw volume on newsite\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from rw volume on old site to rw volume on newsite\n"
)), (((flags & 0x080000) ? "" : " incremental"))); PrintError
(" ",(code)); } while (0); error = (code); goto mfail; } } while
(0)
1628 (flags & RV_NOCLONE) ? "" : " incremental")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from rw volume on old site to rw volume on newsite\n"
)), (((flags & 0x080000) ? "" : " incremental"))); PrintError
(" ",(code)); } while (0); error = (code); goto mfail; } } while
(0);
1629 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1630
1631 /* now adjust the flags so that the new volume becomes official */
1632 VPRINT1("Setting volume flags on old source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags on old source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1633 code = AFSVolSetFlags(fromconn, fromtid, VTOutOfService2);
1634 EGOTO(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make old source volume offline\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1635 "Failed to set the flags to make old source volume offline\n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make old source volume offline\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1636 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1637
1638 VPRINT1("Setting volume flags on new source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags on new source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1639 code = AFSVolSetFlags(toconn, totid, 0);
1640 EGOTO(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make new source volume online\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1641 "Failed to set the flags to make new source volume online\n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make new source volume online\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1642 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1643
1644#ifdef ENABLE_BUGFIX_1165
1645 VPRINT1("Setting volume status on destination volume %u ...", volid){ if (verbose) { fprintf(__stdoutp, ("Setting volume status on destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
1646 code = AFSVolSetInfo(toconn, totid, infop);
1647 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set volume status on the destination volume %u\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1648 "Failed to set volume status on the destination volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set volume status on the destination volume %u\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1649 volid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set volume status on the destination volume %u\n"
)), ((volid))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1650 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1651#endif
1652
1653 /* put new volume online */
1654 VPRINT1("Ending transaction on destination volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on destination volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1655 code = AFSVolEndTrans(toconn, totid, &rcode);
1656 totid = 0;
1657 if (!code)
1658 code = rcode;
1659 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the volume %u on the new site\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1660 "Failed to end the transaction on the volume %u on the new site\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the volume %u on the new site\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1661 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the volume %u on the new site\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1662 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1663
1664 Lp_SetRWValue(&entry, afromserver, afrompart, atoserver, atopart);
1665 MapNetworkToHost(&entry, &storeEntry);
1666 storeEntry.flags &= ~BACK_EXISTS0x4000;
1667
1668 if (TESTC0) {
1669 fprintf(STDOUT__stdoutp,
1670 "Second test point - operation in progress but not complete.\n");
1671 fprintf(STDOUT__stdoutp, "...test here (y, n)? ");
1672 fflush(STDOUT__stdoutp);
1673 fscanf(stdin__stdinp, "%c", &in);
1674 fscanf(stdin__stdinp, "%c", &lf); /* toss away */
1675 if (in == 'y') {
1676 fprintf(STDOUT__stdoutp, "type control-c\n");
1677 while (1) {
1678 fprintf(stdout__stdoutp, ".");
1679 fflush(stdout__stdoutp);
1680 sleep(1);
1681 }
1682 }
1683 /* or drop through */
1684 }
1685
1686 VPRINT1("Releasing lock on VLDB entry for volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Releasing lock on VLDB entry for volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1687 vcode =
1688 VLDB_ReplaceEntry(afromvol, -1, &storeEntry,
1689 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
1690 LOCKREL_TIMESTAMP1));
1691 if (vcode) {
1692 fprintf(STDERR__stderrp,
1693 " Could not release the lock on the VLDB entry for the volume %s %lu \n",
1694 storeEntry.name, (unsigned long)afromvol);
1695 error = vcode;
1696 goto mfail;
1697 }
1698 islocked = 0;
1699 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1700
1701 if (TESTC0) {
1702 fprintf(STDOUT__stdoutp,
1703 "Third test point - operation complete but no cleanup.\n");
1704 fprintf(STDOUT__stdoutp, "...test here (y, n)? ");
1705 fflush(STDOUT__stdoutp);
1706 fscanf(stdin__stdinp, "%c", &in);
1707 fscanf(stdin__stdinp, "%c", &lf); /* toss away */
1708 if (in == 'y') {
1709 fprintf(STDOUT__stdoutp, "type control-c\n");
1710 while (1) {
1711 fprintf(stdout__stdoutp, ".");
1712 fflush(stdout__stdoutp);
1713 sleep(1);
1714 }
1715 }
1716 /* or drop through */
1717 }
1718#ifdef notdef
1719 /* This is tricky. File server is very stupid, and if you mark the volume
1720 * as VTOutOfService, it may mark the *good* instance (if you're moving
1721 * between partitions on the same machine) as out of service. Since
1722 * we're cleaning this code up in DEcorum, we're just going to kludge around
1723 * it for now by removing this call. */
1724 /* already out of service, just zap it now */
1725 code =
1726 AFSVolSetFlags(fromconn, fromtid, VTDeleteOnSalvage1 | VTOutOfService2);
1727 if (code) {
1728 fprintf(STDERR__stderrp,
1729 "Failed to set the flags to make the old source volume offline\n");
1730 goto mfail;
1731 }
1732#endif
1733 if (atoserver != afromserver) {
1734 /* set forwarding pointer for moved volumes */
1735 VPRINT1("Setting forwarding pointer for volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Setting forwarding pointer for volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1736 code = AFSVolSetForwarding(fromconn, fromtid, atoserver);
1737 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the forwarding pointer for the volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1738 "Failed to set the forwarding pointer for the volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the forwarding pointer for the volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1739 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the forwarding pointer for the volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1740 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1741 }
1742
1743 VPRINT1("Deleting old volume %u on source ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Deleting old volume %u on source ..."
), (afromvol)); fflush(__stdoutp); } };
1744 code = AFSVolDeleteVolume(fromconn, fromtid); /* zap original volume */
1745 EGOTO1(mfail, code, "Failed to delete the old volume %u on source\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the old volume %u on source\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
1746 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the old volume %u on source\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
1747 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1748
1749 VPRINT1("Ending transaction on old volume %u on the source ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on old volume %u on the source ..."
), (afromvol)); fflush(__stdoutp); } }
1750 afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on old volume %u on the source ..."
), (afromvol)); fflush(__stdoutp); } };
1751 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1752 fromtid = 0;
1753 if (!code)
1754 code = rcode;
1755 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the old volume %u on the source\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1756 "Failed to end the transaction on the old volume %u on the source\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the old volume %u on the source\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1757 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the old volume %u on the source\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1758 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1759
1760 /* Delete the backup volume on the original site */
1761 VPRINT1("Creating transaction for backup volume %u on source ...",{ if (verbose) { fprintf(__stdoutp, ("Creating transaction for backup volume %u on source ..."
), (backupId)); fflush(__stdoutp); } }
1762 backupId){ if (verbose) { fprintf(__stdoutp, ("Creating transaction for backup volume %u on source ..."
), (backupId)); fflush(__stdoutp); } };
1763 tmp = fromtid;
1764 code =
1765 AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline1, &tmp);
1766 fromtid = tmp;
1767 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1768 if (!code) {
1769 VPRINT1("Setting flags on backup volume %u on source ...", backupId){ if (verbose) { fprintf(__stdoutp, ("Setting flags on backup volume %u on source ..."
), (backupId)); fflush(__stdoutp); } };
1770 code =
1771 AFSVolSetFlags(fromconn, fromtid,
1772 VTDeleteOnSalvage1 | VTOutOfService2);
1773 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1774 "Failed to set the flags on the backup volume %u on the source\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1775 backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1776 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1777
1778 VPRINT1("Deleting the backup volume %u on the source ...", backupId){ if (verbose) { fprintf(__stdoutp, ("Deleting the backup volume %u on the source ..."
), (backupId)); fflush(__stdoutp); } };
1779 code = AFSVolDeleteVolume(fromconn, fromtid);
1780 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the backup volume %u on the source\n"))
, ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1781 "Failed to delete the backup volume %u on the source\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the backup volume %u on the source\n"))
, ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1782 backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the backup volume %u on the source\n"))
, ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1783 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1784
1785 VPRINT1("Ending transaction on backup volume %u on source ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on backup volume %u on source ..."
), (backupId)); fflush(__stdoutp); } }
1786 backupId){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on backup volume %u on source ..."
), (backupId)); fflush(__stdoutp); } };
1787 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1788 fromtid = 0;
1789 if (!code)
1790 code = rcode;
1791 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1792 "Failed to end the transaction on the backup volume %u on the source\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1793 backupId)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the backup volume %u on the source\n"
)), ((backupId))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1794 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1795 } else
1796 code = 0; /* no backup volume? that's okay */
1797
1798 fromtid = 0;
1799 if (!(flags & RV_NOCLONE0x080000)) {
1800 VPRINT1("Starting transaction on the cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on the cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1801 tmp = clonetid;
1802 code =
1803 AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline1,
1804 &tmp);
1805 clonetid = tmp;
1806 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1807 "Failed to start a transaction on the cloned volume%u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
1808 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
1809 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1810
1811 /* now delete the clone */
1812 VPRINT1("Deleting the cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Deleting the cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1813 code = AFSVolDeleteVolume(fromconn, clonetid);
1814 EGOTO1(mfail, code, "Failed to delete the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the cloned volume %u\n")), ((newVol)));
PrintError(" ",(code)); } while (0); error = (code); goto mfail
; } } while (0)
1815 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the cloned volume %u\n")), ((newVol)));
PrintError(" ",(code)); } while (0); error = (code); goto mfail
; } } while (0);
1816 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1817
1818 VPRINT1("Ending transaction on cloned volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on cloned volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1819 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1820 if (!code)
1821 code = rcode;
1822 clonetid = 0;
1823 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1824 "Failed to end the transaction on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
1825 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
1826 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1827 }
1828
1829 /* fall through */
1830 /* END OF MOVE */
1831
1832 if (TESTC0) {
1833 fprintf(STDOUT__stdoutp, "Fourth test point - operation complete.\n");
1834 fprintf(STDOUT__stdoutp, "...test here (y, n)? ");
1835 fflush(STDOUT__stdoutp);
1836 fscanf(stdin__stdinp, "%c", &in);
1837 fscanf(stdin__stdinp, "%c", &lf); /* toss away */
1838 if (in == 'y') {
1839 fprintf(STDOUT__stdoutp, "type control-c\n");
1840 while (1) {
1841 fprintf(stdout__stdoutp, ".");
1842 fflush(stdout__stdoutp);
1843 sleep(1);
1844 }
1845 }
1846 /* or drop through */
1847 }
1848
1849 /* normal cleanup code */
1850
1851 if (entry.flags & RO_EXISTS0x2000)
1852 fprintf(STDERR__stderrp, "WARNING : readOnly copies still exist \n");
1853
1854 if (islocked) {
1855 VPRINT1("Cleanup: Releasing VLDB lock on volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Releasing VLDB lock on volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1856 vcode =
1857 ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
1858 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1));
1859 if (vcode) {
1860 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
1861 fprintf(STDERR__stderrp,
1862 " Could not release the lock on the VLDB entry for the volume %lu \n",
1863 (unsigned long)afromvol);
1864 if (!error)
1865 error = vcode;
1866 }
1867 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1868 }
1869
1870 if (fromtid) {
1871 VPRINT1("Cleanup: Ending transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
1872 afromvol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1873 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
1874 if (code || rcode) {
1875 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
1876 fprintf(STDERR__stderrp,
1877 "Could not end transaction on the source volume %lu\n",
1878 (unsigned long)afromvol);
1879 if (!error)
1880 error = (code ? code : rcode);
1881 }
1882 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1883 }
1884
1885 if (clonetid) {
1886 VPRINT1("Cleanup: Ending transaction on clone volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on clone volume %u ..."
), (newVol)); fflush(__stdoutp); } };
1887 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
1888 if (code || rcode) {
1889 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
1890 fprintf(STDERR__stderrp,
1891 "Could not end transaction on the source's clone volume %lu\n",
1892 (unsigned long)newVol);
1893 if (!error)
1894 error = (code ? code : rcode);
1895 }
1896 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1897 }
1898
1899 if (totid) {
1900 VPRINT1("Cleanup: Ending transaction on destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on destination volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
1901 afromvol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on destination volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1902 code = AFSVolEndTrans(toconn, totid, &rcode);
1903 if (code) {
1904 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
1905 fprintf(STDERR__stderrp,
1906 "Could not end transaction on destination volume %lu\n",
1907 (unsigned long)afromvol);
1908 if (!error)
1909 error = (code ? code : rcode);
1910 }
1911 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1912 }
1913 if (volName)
1914 free(volName);
1915#ifdef ENABLE_BUGFIX_1165
1916 if (infop)
1917 free(infop);
1918#endif
1919 if (fromconn)
1920 rx_DestroyConnection(fromconn);
1921 if (toconn)
1922 rx_DestroyConnection(toconn);
1923 PrintError("", error);
1924 return error;
1925
1926 /* come here only when the sky falls */
1927 mfail:
1928
1929 if (pntg) {
1930 fprintf(STDOUT__stdoutp,
1931 "vos move: operation interrupted, cleanup in progress...\n");
1932 fprintf(STDOUT__stdoutp, "clear transaction contexts\n");
1933 fflush(STDOUT__stdoutp);
1934 }
1935
1936 /* unlock VLDB entry */
1937 if (islocked) {
1938 VPRINT1("Recovery: Releasing VLDB lock on volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Releasing VLDB lock on volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
1939 ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
1940 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1));
1941 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1942 islocked = 0;
1943 }
1944
1945 if (clonetid) {
1946 VPRINT("Recovery: Ending transaction on clone volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume ..."
)); fflush(__stdoutp); } };
1947 AFSVolEndTrans(fromconn, clonetid, &rcode);
1948 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1949 }
1950 if (totid) {
1951 VPRINT("Recovery: Ending transaction on destination volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on destination volume ..."
)); fflush(__stdoutp); } };
1952 AFSVolEndTrans(toconn, totid, &rcode);
1953 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1954 }
1955 if (fromtid) { /* put it on-line */
1956 VPRINT("Recovery: Setting volume flags on source volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting volume flags on source volume ..."
)); fflush(__stdoutp); } };
1957 AFSVolSetFlags(fromconn, fromtid, 0);
1958 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1959
1960 VPRINT("Recovery: Ending transaction on source volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume ..."
)); fflush(__stdoutp); } };
1961 AFSVolEndTrans(fromconn, fromtid, &rcode);
1962 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1963 }
1964
1965 VPRINT("Recovery: Accessing VLDB.\n"){ if (verbose) { fprintf(__stdoutp, ("Recovery: Accessing VLDB.\n"
)); fflush(__stdoutp); } };
1966 vcode = VLDB_GetEntryByID(afromvol, -1, &entry);
1967 if (vcode) {
1968 fprintf(STDOUT__stdoutp, "FATAL: VLDB access error: abort cleanup\n");
1969 fflush(STDOUT__stdoutp);
1970 goto done;
1971 }
1972 MapHostToNetwork(&entry);
1973
1974 /* Delete either the volume on the source location or the target location.
1975 * If the vldb entry still points to the source location, then we know the
1976 * volume move didn't finish so we remove the volume from the target
1977 * location. Otherwise, we remove the volume from the source location.
1978 */
1979 if (Lp_Match(afromserver, afrompart, &entry)) { /* didn't move - delete target volume */
1980 if (pntg) {
1981 fprintf(STDOUT__stdoutp,
1982 "move incomplete - attempt cleanup of target partition - no guarantee\n");
1983 fflush(STDOUT__stdoutp);
1984 }
1985
1986 if (volid && toconn) {
1987 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction for destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
1988 ("Recovery: Creating transaction for destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction for destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
1989 volid){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction for destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
1990 tmp = totid;
1991 code =
1992 AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline1, &tmp);
1993 totid = tmp;
1994
1995 if (!code) {
1996 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
1997
1998 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
1999 ("Recovery: Setting flags on destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
2000 volid){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
2001 AFSVolSetFlags(toconn, totid,
2002 VTDeleteOnSalvage1 | VTOutOfService2);
2003 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2004
2005 VPRINT1("Recovery: Deleting destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
2006 volid){ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
2007 AFSVolDeleteVolume(toconn, totid);
2008 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2009
2010 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
2011 ("Recovery: Ending transaction on destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on destination volume %u ..."
), (volid)); fflush(__stdoutp); } }
2012 volid){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on destination volume %u ..."
), (volid)); fflush(__stdoutp); } };
2013 AFSVolEndTrans(toconn, totid, &rcode);
2014 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2015 } else {
2016 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on destination volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2017 ("\nRecovery: Unable to start transaction on destination volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on destination volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2018 afromvol){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on destination volume %u.\n"
), (afromvol)); fflush(__stdoutp); } };
2019 }
2020 }
2021
2022 /* put source volume on-line */
2023 if (fromconn) {
2024 VPRINT1("Recovery: Creating transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2025 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2026 tmp = fromtid;
2027 code =
2028 AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2,
2029 &tmp);
2030 fromtid = tmp;
2031 if (!code) {
2032 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2033
2034 VPRINT1("Recovery: Setting flags on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2035 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2036 AFSVolSetFlags(fromconn, fromtid, 0);
2037 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2038
2039 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2040 ("Recovery: Ending transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2041 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2042 AFSVolEndTrans(fromconn, fromtid, &rcode);
2043 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2044 } else {
2045 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2046 ("\nRecovery: Unable to start transaction on source volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2047 afromvol){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } };
2048 }
2049 }
2050 } else { /* yep, move complete */
2051 if (pntg) {
2052 fprintf(STDOUT__stdoutp,
2053 "move complete - attempt cleanup of source partition - no guarantee\n");
2054 fflush(STDOUT__stdoutp);
2055 }
2056
2057 /* delete backup volume */
2058 if (fromconn) {
2059 VPRINT1("Recovery: Creating transaction on backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
2060 backupId){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
2061 tmp = fromtid;
2062 code =
2063 AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline1,
2064 &tmp);
2065 fromtid = tmp;
2066 if (!code) {
2067 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2068
2069 VPRINT1("Recovery: Setting flags on backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
2070 backupId){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
2071 AFSVolSetFlags(fromconn, fromtid,
2072 VTDeleteOnSalvage1 | VTOutOfService2);
2073 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2074
2075 VPRINT1("Recovery: Deleting backup volume %u ...", backupId){ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
2076 AFSVolDeleteVolume(fromconn, fromtid);
2077 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2078
2079 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
2080 ("Recovery: Ending transaction on backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } }
2081 backupId){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on backup volume %u ..."
), (backupId)); fflush(__stdoutp); } };
2082 AFSVolEndTrans(fromconn, fromtid, &rcode);
2083 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2084 } else {
2085 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on backup volume %u.\n"
), (backupId)); fflush(__stdoutp); } }
2086 ("\nRecovery: Unable to start transaction on backup volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on backup volume %u.\n"
), (backupId)); fflush(__stdoutp); } }
2087 backupId){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on backup volume %u.\n"
), (backupId)); fflush(__stdoutp); } };
2088 }
2089
2090 /* delete source volume */
2091 VPRINT1("Recovery: Creating transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2092 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2093 tmp = fromtid;
2094 code =
2095 AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2,
2096 &tmp);
2097 fromtid = tmp;
2098 if (!code) {
2099 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2100
2101 VPRINT1("Recovery: Setting flags on backup volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on backup volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2102 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting flags on backup volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2103 AFSVolSetFlags(fromconn, fromtid,
2104 VTDeleteOnSalvage1 | VTOutOfService2);
2105 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2106
2107 if (atoserver != afromserver) {
2108 VPRINT("Recovery: Setting volume forwarding pointer ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Setting volume forwarding pointer ..."
)); fflush(__stdoutp); } };
2109 AFSVolSetForwarding(fromconn, fromtid, atoserver);
2110 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2111 }
2112
2113 VPRINT1("Recovery: Deleting source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2114 AFSVolDeleteVolume(fromconn, fromtid);
2115 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2116
2117 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2118 ("Recovery: Ending transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2119 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2120 AFSVolEndTrans(fromconn, fromtid, &rcode);
2121 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2122 } else {
2123 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2124 ("\nRecovery: Unable to start transaction on source volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2125 afromvol){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } };
2126 }
2127 }
2128 }
2129
2130 /* common cleanup - delete local clone */
2131 if (newVol) {
2132 VPRINT1("Recovery: Creating transaction on clone volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on clone volume %u ..."
), (newVol)); fflush(__stdoutp); } }
2133 newVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on clone volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2134 tmp = clonetid;
2135 code =
2136 AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline1,
2137 &tmp);
2138 clonetid = tmp;
2139 if (!code) {
2140 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2141
2142 VPRINT1("Recovery: Deleting clone volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting clone volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2143 AFSVolDeleteVolume(fromconn, clonetid);
2144 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2145
2146 VPRINT1("Recovery: Ending transaction on clone volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume %u ..."
), (newVol)); fflush(__stdoutp); } }
2147 newVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2148 AFSVolEndTrans(fromconn, clonetid, &rcode);
2149 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2150 } else {
2151 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2152 ("\nRecovery: Unable to start transaction on source volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } }
2153 afromvol){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on source volume %u.\n"
), (afromvol)); fflush(__stdoutp); } };
2154 }
2155 }
2156
2157 /* unlock VLDB entry */
2158 if (islocked) {
2159 VPRINT1("Recovery: Releasing lock on VLDB entry for volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Releasing lock on VLDB entry for volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2160 afromvol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Releasing lock on VLDB entry for volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2161 ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
2162 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1));
2163 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2164 islocked = 0;
2165 }
2166 done: /* routine cleanup */
2167 if (volName)
2168 free(volName);
2169#ifdef ENABLE_BUGFIX_1165
2170 if (infop)
2171 free(infop);
2172#endif
2173 if (fromconn)
2174 rx_DestroyConnection(fromconn);
2175 if (toconn)
2176 rx_DestroyConnection(toconn);
2177
2178 if (pntg) {
2179 fprintf(STDOUT__stdoutp, "cleanup complete - user verify desired result\n");
2180 fflush(STDOUT__stdoutp);
2181 }
2182 exit(1);
2183}
2184
2185
2186int
2187UV_MoveVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
2188 afs_uint32 atoserver, afs_int32 atopart)
2189{
2190 return UV_MoveVolume2(afromvol, afromserver, afrompart,
2191 atoserver, atopart, 0);
2192}
2193
2194
2195/* Copy volume <afromvol> from <afromserver> <afrompart> to <atoserver>
2196 * <atopart>. The new volume is named by <atovolname>. The new volume
2197 * has ID <atovolid> if that is nonzero; otherwise a new ID is allocated
2198 * from the VLDB. the following flags are supported:
2199 *
2200 * RV_RDONLY - target volume is RO
2201 * RV_OFFLINE - leave target volume offline
2202 * RV_CPINCR - do incremental dump if target exists
2203 * RV_NOVLDB - don't create/update VLDB entry
2204 * RV_NOCLONE - don't use a copy clone
2205 */
2206int
2207UV_CopyVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
2208 char *atovolname, afs_uint32 atoserver, afs_int32 atopart,
2209 afs_uint32 atovolid, int flags)
2210{
2211 /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
2212 * be changing during the copy */
2213 int volatile pntg;
2214 afs_int32 volatile clonetid;
2215 afs_int32 volatile totid;
2216 afs_int32 volatile fromtid;
2217 struct rx_connection * volatile fromconn;
2218 struct rx_connection * volatile toconn;
2219 afs_uint32 volatile cloneVol;
2220
2221 char vname[64];
2222 afs_int32 rcode;
2223 afs_int32 fromDate, cloneFromDate;
2224 struct restoreCookie cookie;
2225 afs_int32 vcode, code;
2226 afs_uint32 newVol;
2227 afs_int32 volflag;
2228 struct volser_status tstatus;
2229 struct destServer destination;
2230 struct nvldbentry entry, newentry, storeEntry;
2231 afs_int32 error;
2232 afs_int32 tmp;
2233 afs_uint32 tmpVol;
2234
2235 fromconn = (struct rx_connection *)0;
2236 toconn = (struct rx_connection *)0;
2237 fromtid = 0;
2238 totid = 0;
2239 clonetid = 0;
2240 error = 0;
2241 pntg = 0;
2242 newVol = 0;
2243
2244 /* support control-c processing */
2245 if (setjmp(env))
2246 goto mfail;
2247 (void)signal(SIGINT2, sigint_handler);
2248
2249 vcode = VLDB_GetEntryByID(afromvol, -1, &entry);
2250 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2251 "Could not fetch the entry for the volume %u from the VLDB \n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2252 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not fetch the entry for the volume %u from the VLDB \n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
2253 MapHostToNetwork(&entry);
2254
2255 pntg = 1;
2256 toconn = UV_Bind(atoserver, AFSCONF_VOLUMEPORT7005); /* get connections to the servers */
2257 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
2258 fromtid = totid = 0; /* initialize to uncreated */
2259
2260 /* ***
2261 * clone the read/write volume locally.
2262 * ***/
2263
2264 cloneVol = 0;
2265 if (!(flags & RV_NOCLONE0x080000)) {
2266 VPRINT1("Starting transaction on source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2267 tmp = fromtid;
2268 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2,
2269 &tmp);
2270 fromtid = tmp;
2271 EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2272 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2273 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2274
2275 /* Get a clone id */
2276 VPRINT1("Allocating new volume id for clone of volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2277 afromvol){ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2278 cloneVol = 0;
2279 tmpVol = cloneVol;
2280 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
2281 cloneVol = tmpVol;
2282 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2283 "Could not get an ID for the clone of volume %u from the VLDB\n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2284 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
2285 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2286 }
2287
2288 if (atovolid) {
2289 newVol = atovolid;
2290 } else {
2291 /* Get a new volume id */
2292 VPRINT1("Allocating new volume id for copy of volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for copy of volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2293 newVol = 0;
2294 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &newVol);
2295 EGOTO1(mfail, vcode,do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the copy of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2296 "Could not get an ID for the copy of volume %u from the VLDB\n",do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the copy of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0)
2297 afromvol)do { if (vcode) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the copy of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(vcode)); } while (0); error
= (vcode); goto mfail; } } while (0);
2298 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2299 }
2300
2301 if (!(flags & RV_NOCLONE0x080000)) {
2302 /* Do the clone. Default flags on clone are set to delete on salvage and out of service */
2303 VPRINT1("Cloning source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Cloning source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2304 strcpy(vname, "copy-clone-temp");
2305 tmpVol = cloneVol;
2306 code =
2307 AFSVolClone(fromconn, fromtid, 0, readonlyVolume1, vname,
2308 &tmpVol);
2309 cloneVol = tmpVol;
2310 EGOTO1(mfail, code, "Failed to clone the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2311 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2312 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2313
2314 VPRINT1("Ending the transaction on the source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending the transaction on the source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2315 rcode = 0;
2316 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2317 fromtid = 0;
2318 if (!code)
2319 code = rcode;
2320 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2321 "Failed to end the transaction on the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2322 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2323 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2324 }
2325
2326 /* ***
2327 * Create the destination volume
2328 * ***/
2329
2330 if (!(flags & RV_NOCLONE0x080000)) {
2331 VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on the cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2332 tmp = clonetid;
2333 code =
2334 AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline1,
2335 &tmp);
2336 clonetid = tmp;
2337 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2338 "Failed to start a transaction on the cloned volume%u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2339 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2340 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2341
2342 VPRINT1("Setting flags on cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Setting flags on cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2343 code =
2344 AFSVolSetFlags(fromconn, clonetid,
2345 VTDeleteOnSalvage1 | VTOutOfService2); /*redundant */
2346 EGOTO1(mfail, code, "Could not set flags on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on the cloned volume %u\n")), ((cloneVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2347 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on the cloned volume %u\n")), ((cloneVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2348 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2349
2350 /* remember time from which we've dumped the volume */
2351 VPRINT1("Getting status of cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Getting status of cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2352 code = AFSVolGetStatus(fromconn, clonetid, &tstatus);
2353 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(cloneVol))); PrintError(" ",(code)); } while (0); error = (
code); goto mfail; } } while (0)
2354 "Failed to get the status of the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(cloneVol))); PrintError(" ",(code)); } while (0); error = (
code); goto mfail; } } while (0)
2355 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the cloned volume %u\n")), (
(cloneVol))); PrintError(" ",(code)); } while (0); error = (
code); goto mfail; } } while (0);
2356 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2357
2358 fromDate = CLOCKADJ(tstatus.creationDate)(((tstatus.creationDate) < 2) ? 0 : (tstatus.creationDate)
- 2);
2359 } else {
2360 fromDate = 0;
2361 }
2362
2363 /* create a volume on the target machine */
2364 cloneFromDate = 0;
2365 tmp = totid;
2366 code = AFSVolTransCreate_retry(toconn, newVol, atopart, ITOffline1, &tmp);
2367 totid = tmp;
2368 if (!code) {
2369 if ((flags & RV_CPINCR0x020000)) {
2370 VPRINT1("Getting status of pre-existing volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Getting status of pre-existing volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2371 code = AFSVolGetStatus(toconn, totid, &tstatus);
2372 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the pre-existing volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2373 "Failed to get the status of the pre-existing volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the pre-existing volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2374 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to get the status of the pre-existing volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2375 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2376
2377 /* Using the update date should be OK here, but add some fudge */
2378 cloneFromDate = CLOCKADJ(tstatus.updateDate)(((tstatus.updateDate) < 2) ? 0 : (tstatus.updateDate) - 2
);
2379 if ((flags & RV_NOCLONE0x080000))
2380 fromDate = cloneFromDate;
2381
2382 /* XXX We should check that the source volume's creationDate is
2383 * XXX not newer than the existing target volume, and if not,
2384 * XXX throw away the existing target and do a full dump. */
2385
2386 goto cpincr;
2387 }
2388
2389 /* Delete the existing volume.
2390 * While we are deleting the volume in these steps, the transaction
2391 * we started against the cloned volume (clonetid above) will be
2392 * sitting idle. It will get cleaned up after 600 seconds
2393 */
2394 VPRINT1("Deleting pre-existing volume %u on destination ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Deleting pre-existing volume %u on destination ..."
), (newVol)); fflush(__stdoutp); } };
2395 code = AFSVolDeleteVolume(toconn, totid);
2396 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2397 "Could not delete the pre-existing volume %u on destination\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2398 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete the pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2399 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2400
2401 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (newVol)); fflush(__stdoutp); } }
2402 ("Ending transaction on pre-existing volume %u on destination ...",{ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (newVol)); fflush(__stdoutp); } }
2403 newVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on pre-existing volume %u on destination ..."
), (newVol)); fflush(__stdoutp); } };
2404 code = AFSVolEndTrans(toconn, totid, &rcode);
2405 totid = 0;
2406 if (!code)
2407 code = rcode;
2408 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2409 "Could not end the transaction on pre-existing volume %u on destination\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2410 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end the transaction on pre-existing volume %u on destination\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2411 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2412 }
2413
2414 VPRINT1("Creating the destination volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Creating the destination volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2415 tmp = totid;
2416 code =
2417 AFSVolCreateVolume(toconn, atopart, atovolname,
2418 (flags & RV_RDONLY0x010000) ? volser_RO1 : volser_RW0,
2419 newVol, &newVol, &tmp);
2420 totid = tmp;
2421 EGOTO1(mfail, code, "Failed to create the destination volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the destination volume %u\n")), ((newVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2422 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create the destination volume %u\n")), ((newVol
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2423 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2424
2425 VPRINT1("Setting volume flags on destination volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags on destination volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2426 code =
2427 AFSVolSetFlags(toconn, totid, (VTDeleteOnSalvage1 | VTOutOfService2));
2428 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the destination volume %u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0)
2429 "Failed to set the flags on the destination volume %u\n", newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags on the destination volume %u\n")
), ((newVol))); PrintError(" ",(code)); } while (0); error =
(code); goto mfail; } } while (0);
2430 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2431
2432cpincr:
2433
2434 destination.destHost = ntohl(atoserver)(__builtin_constant_p(atoserver) ? ((((__uint32_t)(atoserver)
) >> 24) | ((((__uint32_t)(atoserver)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(atoserver)) & (0xff <<
8)) << 8) | (((__uint32_t)(atoserver)) << 24)) :
__bswap32_var(atoserver));
2435 destination.destPort = AFSCONF_VOLUMEPORT7005;
2436 destination.destSSID = 1;
2437
2438 strncpy(cookie.name, atovolname, VOLSER_OLDMAXVOLNAME32);
2439 cookie.type = (flags & RV_RDONLY0x010000) ? ROVOL1 : RWVOL0;
2440 cookie.parent = 0;
2441 cookie.clone = 0;
2442
2443 /***
2444 * Now dump the clone to the new volume
2445 ***/
2446
2447 if (!(flags & RV_NOCLONE0x080000)) {
2448 /* XXX probably should have some code here that checks to see if
2449 * XXX we are copying to same server and partition - if so, just
2450 * XXX use a clone to save disk space */
2451
2452 /* Copy the clone to the new volume */
2453 VPRINT2("Dumping from clone %u on source to volume %u on destination ...",{ if (verbose) { fprintf(__stdoutp, ("Dumping from clone %u on source to volume %u on destination ..."
), (cloneVol), (newVol)); fflush(__stdoutp); } }
2454 cloneVol, newVol){ if (verbose) { fprintf(__stdoutp, ("Dumping from clone %u on source to volume %u on destination ..."
), (cloneVol), (newVol)); fflush(__stdoutp); } };
2455 code =
2456 AFSVolForward(fromconn, clonetid, cloneFromDate, &destination,
2457 totid, &cookie);
2458 EGOTO1(mfail, code, "Failed to move data for the volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to move data for the volume %u\n")), ((newVol)));
PrintError(" ",(code)); } while (0); error = (code); goto mfail
; } } while (0)
2459 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to move data for the volume %u\n")), ((newVol)));
PrintError(" ",(code)); } while (0); error = (code); goto mfail
; } } while (0);
2460 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2461
2462 VPRINT1("Ending transaction on cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2463 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
2464 if (!code)
2465 code = rcode;
2466 clonetid = 0;
2467 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2468 "Failed to end the transaction on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2469 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2470 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2471 }
2472
2473 /* ***
2474 * reattach to the main-line volume, and incrementally dump it.
2475 * ***/
2476
2477 VPRINT1("Starting transaction on source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2478 tmp = fromtid;
2479 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2, &tmp);
2480 fromtid = tmp;
2481 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2482 "Failed to create a transaction on the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2483 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to create a transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2484 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2485
2486 /* now do the incremental */
2487 VPRINT2{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
2488 ("Doing the%s dump from source to destination for volume %u ... ",{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
2489 (flags & RV_NOCLONE) ? "" : " incremental",{ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } }
2490 afromvol){ if (verbose) { fprintf(__stdoutp, ("Doing the%s dump from source to destination for volume %u ... "
), ((flags & 0x080000) ? "" : " incremental"), (afromvol)
); fflush(__stdoutp); } };
2491 code =
2492 AFSVolForward(fromconn, fromtid, fromDate, &destination, totid,
2493 &cookie);
2494 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from old site to new site\n")), (
((flags & 0x080000) ? "" : " incremental"))); PrintError(
" ",(code)); } while (0); error = (code); goto mfail; } } while
(0)
2495 "Failed to do the%s dump from old site to new site\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from old site to new site\n")), (
((flags & 0x080000) ? "" : " incremental"))); PrintError(
" ",(code)); } while (0); error = (code); goto mfail; } } while
(0)
2496 (flags & RV_NOCLONE) ? "" : " incremental")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to do the%s dump from old site to new site\n")), (
((flags & 0x080000) ? "" : " incremental"))); PrintError(
" ",(code)); } while (0); error = (code); goto mfail; } } while
(0);
2497 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2498
2499 VPRINT1("Setting volume flags on destination volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags on destination volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2500 volflag = ((flags & RV_OFFLINE0x000002) ? VTOutOfService2 : 0); /* off or on-line */
2501 code = AFSVolSetFlags(toconn, totid, volflag);
2502 EGOTO(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make destination volume online\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2503 "Failed to set the flags to make destination volume online\n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to set the flags to make destination volume online\n"
))); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2504 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2505
2506 /* put new volume online */
2507 VPRINT1("Ending transaction on destination volume %u ...", newVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on destination volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2508 code = AFSVolEndTrans(toconn, totid, &rcode);
2509 totid = 0;
2510 if (!code)
2511 code = rcode;
2512 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the destination volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2513 "Failed to end the transaction on the destination volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the destination volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2514 newVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the destination volume %u\n"
)), ((newVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2515 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2516
2517 VPRINT1("Ending transaction on source volume %u ...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2518 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2519 fromtid = 0;
2520 if (!code)
2521 code = rcode;
2522 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2523 "Failed to end the transaction on the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2524 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the source volume %u\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2525 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2526
2527 fromtid = 0;
2528
2529 if (!(flags & RV_NOCLONE0x080000)) {
2530 VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on the cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2531 tmp = clonetid;
2532 code =
2533 AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline1,
2534 &tmp);
2535 clonetid = tmp;
2536 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2537 "Failed to start a transaction on the cloned volume%u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2538 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2539 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2540
2541 /* now delete the clone */
2542 VPRINT1("Deleting the cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Deleting the cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2543 code = AFSVolDeleteVolume(fromconn, clonetid);
2544 EGOTO1(mfail, code, "Failed to delete the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the cloned volume %u\n")), ((cloneVol))
); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0)
2545 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to delete the cloned volume %u\n")), ((cloneVol))
); PrintError(" ",(code)); } while (0); error = (code); goto
mfail; } } while (0);
2546 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2547
2548 VPRINT1("Ending transaction on cloned volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on cloned volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2549 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
2550 if (!code)
2551 code = rcode;
2552 clonetid = 0;
2553 EGOTO1(mfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2554 "Failed to end the transaction on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0)
2555 cloneVol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the cloned volume %u\n"
)), ((cloneVol))); PrintError(" ",(code)); } while (0); error
= (code); goto mfail; } } while (0);
2556 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2557 }
2558
2559 if (!(flags & RV_NOVLDB0x040000)) {
2560 /* create the vldb entry for the copied volume */
2561 strncpy(newentry.name, atovolname, VOLSER_OLDMAXVOLNAME32);
2562 newentry.nServers = 1;
2563 newentry.serverNumber[0] = atoserver;
2564 newentry.serverPartition[0] = atopart;
2565 newentry.flags = (flags & RV_RDONLY0x010000) ? RO_EXISTS0x2000 : RW_EXISTS0x1000;
2566 newentry.serverFlags[0] = (flags & RV_RDONLY0x010000) ? ITSROVOL0x02 : ITSRWVOL0x04;
2567 newentry.volumeId[RWVOL0] = newVol;
2568 newentry.volumeId[ROVOL1] = (flags & RV_RDONLY0x010000) ? newVol : 0;
2569 newentry.volumeId[BACKVOL2] = 0;
2570 newentry.cloneId = 0;
2571 /*map into right byte order, before passing to xdr, the stuff has to be in host
2572 * byte order. Xdr converts it into network order */
2573 MapNetworkToHost(&newentry, &storeEntry);
2574 /* create the vldb entry */
2575 vcode = VLDB_CreateEntry(&storeEntry);
2576 if (vcode) {
2577 fprintf(STDERR__stderrp,
2578 "Could not create a VLDB entry for the volume %s %lu\n",
2579 atovolname, (unsigned long)newVol);
2580 /*destroy the created volume */
2581 VPRINT1("Deleting the newly created volume %u\n", newVol){ if (verbose) { fprintf(__stdoutp, ("Deleting the newly created volume %u\n"
), (newVol)); fflush(__stdoutp); } };
2582 AFSVolDeleteVolume(toconn, totid);
2583 error = vcode;
2584 goto mfail;
2585 }
2586 VPRINT2("Created the VLDB entry for the volume %s %u\n", atovolname,{ if (verbose) { fprintf(__stdoutp, ("Created the VLDB entry for the volume %s %u\n"
), (atovolname), (newVol)); fflush(__stdoutp); } }
2587 newVol){ if (verbose) { fprintf(__stdoutp, ("Created the VLDB entry for the volume %s %u\n"
), (atovolname), (newVol)); fflush(__stdoutp); } };
2588 }
2589
2590 /* normal cleanup code */
2591
2592 if (fromtid) {
2593 VPRINT1("Cleanup: Ending transaction on source volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } }
2594 afromvol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on source volume %u ..."
), (afromvol)); fflush(__stdoutp); } };
2595 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
2596 if (code || rcode) {
2597 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
2598 fprintf(STDERR__stderrp,
2599 "Could not end transaction on the source volume %lu\n",
2600 (unsigned long)afromvol);
2601 if (!error)
2602 error = (code ? code : rcode);
2603 }
2604 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2605 }
2606
2607 if (clonetid) {
2608 VPRINT1("Cleanup: Ending transaction on clone volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } }
2609 cloneVol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2610 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
2611 if (code || rcode) {
2612 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
2613 fprintf(STDERR__stderrp,
2614 "Could not end transaction on the source's clone volume %lu\n",
2615 (unsigned long)cloneVol);
2616 if (!error)
2617 error = (code ? code : rcode);
2618 }
2619 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2620 }
2621
2622 if (totid) {
2623 VPRINT1("Cleanup: Ending transaction on destination volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on destination volume %u ..."
), (newVol)); fflush(__stdoutp); } }
2624 newVol){ if (verbose) { fprintf(__stdoutp, ("Cleanup: Ending transaction on destination volume %u ..."
), (newVol)); fflush(__stdoutp); } };
2625 code = AFSVolEndTrans(toconn, totid, &rcode);
2626 if (code) {
2627 VPRINT("\n"){ if (verbose) { fprintf(__stdoutp, ("\n")); fflush(__stdoutp
); } };
2628 fprintf(STDERR__stderrp,
2629 "Could not end transaction on destination volume %lu\n",
2630 (unsigned long)newVol);
2631 if (!error)
2632 error = (code ? code : rcode);
2633 }
2634 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2635 }
2636 if (fromconn)
2637 rx_DestroyConnection(fromconn);
2638 if (toconn)
2639 rx_DestroyConnection(toconn);
2640 PrintError("", error);
2641 return error;
2642
2643 /* come here only when the sky falls */
2644 mfail:
2645
2646 if (pntg) {
2647 fprintf(STDOUT__stdoutp,
2648 "vos copy: operation interrupted, cleanup in progress...\n");
2649 fprintf(STDOUT__stdoutp, "clear transaction contexts\n");
2650 fflush(STDOUT__stdoutp);
2651 }
2652
2653 if (clonetid) {
2654 VPRINT("Recovery: Ending transaction on clone volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume ..."
)); fflush(__stdoutp); } };
2655 AFSVolEndTrans(fromconn, clonetid, &rcode);
2656 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2657 }
2658 if (totid) {
2659 VPRINT("Recovery: Ending transaction on destination volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on destination volume ..."
)); fflush(__stdoutp); } };
2660 AFSVolEndTrans(toconn, totid, &rcode);
2661 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2662 }
2663 if (fromtid) { /* put it on-line */
2664 VPRINT("Recovery: Ending transaction on source volume ..."){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on source volume ..."
)); fflush(__stdoutp); } };
2665 AFSVolEndTrans(fromconn, fromtid, &rcode);
2666 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2667 }
2668
2669 VPRINT("Recovery: Accessing VLDB.\n"){ if (verbose) { fprintf(__stdoutp, ("Recovery: Accessing VLDB.\n"
)); fflush(__stdoutp); } };
2670 vcode = VLDB_GetEntryByID(afromvol, -1, &entry);
2671 if (vcode) {
2672 fprintf(STDOUT__stdoutp, "FATAL: VLDB access error: abort cleanup\n");
2673 fflush(STDOUT__stdoutp);
2674 goto done;
2675 }
2676 MapHostToNetwork(&entry);
2677
2678 /* common cleanup - delete local clone */
2679 if (cloneVol) {
2680 VPRINT1("Recovery: Creating transaction on clone volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } }
2681 cloneVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Creating transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2682 tmp = clonetid;
2683 code =
2684 AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline1,
2685 &tmp);
2686 clonetid = tmp;
2687 if (!code) {
2688 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2689
2690 VPRINT1("Recovery: Deleting clone volume %u ...", cloneVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Deleting clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2691 AFSVolDeleteVolume(fromconn, clonetid);
2692 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2693
2694 VPRINT1("Recovery: Ending transaction on clone volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } }
2695 cloneVol){ if (verbose) { fprintf(__stdoutp, ("Recovery: Ending transaction on clone volume %u ..."
), (cloneVol)); fflush(__stdoutp); } };
2696 AFSVolEndTrans(fromconn, clonetid, &rcode);
2697 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2698 } else {
2699 VPRINT1{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on clone volume %u.\n"
), (cloneVol)); fflush(__stdoutp); } }
2700 ("\nRecovery: Unable to start transaction on clone volume %u.\n",{ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on clone volume %u.\n"
), (cloneVol)); fflush(__stdoutp); } }
2701 cloneVol){ if (verbose) { fprintf(__stdoutp, ("\nRecovery: Unable to start transaction on clone volume %u.\n"
), (cloneVol)); fflush(__stdoutp); } };
2702 }
2703 }
2704
2705 done: /* routine cleanup */
2706 if (fromconn)
2707 rx_DestroyConnection(fromconn);
2708 if (toconn)
2709 rx_DestroyConnection(toconn);
2710
2711 if (pntg) {
2712 fprintf(STDOUT__stdoutp, "cleanup complete - user verify desired result\n");
2713 fflush(STDOUT__stdoutp);
2714 }
2715 exit(1);
2716}
2717
2718
2719int
2720UV_CopyVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
2721 char *atovolname, afs_uint32 atoserver, afs_int32 atopart)
2722{
2723 return UV_CopyVolume2(afromvol, afromserver, afrompart,
2724 atovolname, atoserver, atopart, 0, 0);
2725}
2726
2727
2728
2729/* Make a new backup of volume <avolid> on <aserver> and <apart>
2730 * if one already exists, update it
2731 */
2732
2733int
2734UV_BackupVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
2735{
2736 struct rx_connection *aconn = (struct rx_connection *)0;
2737 afs_int32 ttid = 0, btid = 0;
2738 afs_uint32 backupID;
2739 afs_int32 code = 0, rcode = 0;
2740 char vname[VOLSER_MAXVOLNAME65 + 1];
2741 struct nvldbentry entry, storeEntry;
2742 afs_int32 error = 0;
2743 int vldblocked = 0, vldbmod = 0, backexists = 1;
2744
2745 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
2746
2747 /* the calls to VLDB will succeed only if avolid is a RW volume,
2748 * since we are following the RW hash chain for searching */
2749 code = VLDB_GetEntryByID(avolid, RWVOL0, &entry);
2750 if (code) {
2751 fprintf(STDERR__stderrp,
2752 "Could not fetch the entry for the volume %lu from the VLDB \n",
2753 (unsigned long)avolid);
2754 error = code;
2755 goto bfail;
2756 }
2757 MapHostToNetwork(&entry);
2758
2759 /* These operations require the VLDB be locked since it means the VLDB
2760 * will change or the vldb is already locked.
2761 */
2762 if (!(entry.flags & BACK_EXISTS0x4000) || /* backup volume doesnt exist */
2763 (entry.flags & VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100)) || /* vldb lock already held */
2764 (entry.volumeId[BACKVOL2] == INVALID_BID0)) { /* no assigned backup volume id */
2765
2766 code = ubik_VL_SetLock(cstruct, 0, avolid, RWVOL0, VLOP_BACKUP0x40);
2767 if (code) {
2768 fprintf(STDERR__stderrp,
2769 "Could not lock the VLDB entry for the volume %lu\n",
2770 (unsigned long)avolid);
2771 error = code;
2772 goto bfail;
2773 }
2774 vldblocked = 1;
2775
2776 /* Reread the vldb entry */
2777 code = VLDB_GetEntryByID(avolid, RWVOL0, &entry);
2778 if (code) {
2779 fprintf(STDERR__stderrp,
2780 "Could not fetch the entry for the volume %lu from the VLDB \n",
2781 (unsigned long)avolid);
2782 error = code;
2783 goto bfail;
2784 }
2785 MapHostToNetwork(&entry);
2786 }
2787
2788 if (!ISNAMEVALID(entry.name)(strlen(entry.name) < (32 - 9))) {
2789 fprintf(STDERR__stderrp, "Name of the volume %s exceeds the size limit\n",
2790 entry.name);
2791 error = VOLSERBADNAME(1492325129L);
2792 goto bfail;
2793 }
2794
2795 backupID = entry.volumeId[BACKVOL2];
2796 if (backupID == INVALID_BID0) {
2797 /* Get a backup volume id from the VLDB and update the vldb
2798 * entry with it.
2799 */
2800 code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &backupID);
2801 if (code) {
2802 fprintf(STDERR__stderrp,
2803 "Could not allocate ID for the backup volume of %lu from the VLDB\n",
2804 (unsigned long)avolid);
2805 error = code;
2806 goto bfail;
2807 }
2808 entry.volumeId[BACKVOL2] = backupID;
2809 vldbmod = 1;
2810 }
2811
2812 /* Test to see if the backup volume exists by trying to create
2813 * a transaction on the backup volume. We've assumed the backup exists.
2814 */
2815 code = AFSVolTransCreate_retry(aconn, backupID, apart, ITOffline1, &btid);
2816 if (code) {
2817 if (code != VNOVOL103) {
2818 fprintf(STDERR__stderrp, "Could not reach the backup volume %lu\n",
2819 (unsigned long)backupID);
2820 error = code;
2821 goto bfail;
2822 }
2823 backexists = 0; /* backup volume does not exist */
2824 }
2825 if (btid) {
2826 code = AFSVolEndTrans(aconn, btid, &rcode);
2827 btid = 0;
2828 if (code || rcode) {
2829 fprintf(STDERR__stderrp,
2830 "Could not end transaction on the previous backup volume %lu\n",
2831 (unsigned long)backupID);
2832 error = (code ? code : rcode);
2833 goto bfail;
2834 }
2835 }
2836
2837 /* Now go ahead and try to clone the RW volume.
2838 * First start a transaction on the RW volume
2839 */
2840 code = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy2, &ttid);
2841 if (code) {
2842 fprintf(STDERR__stderrp, "Could not start a transaction on the volume %lu\n",
2843 (unsigned long)avolid);
2844 error = code;
2845 goto bfail;
2846 }
2847
2848 /* Clone or reclone the volume, depending on whether the backup
2849 * volume exists or not
2850 */
2851 if (backexists) {
2852 VPRINT1("Re-cloning backup volume %u ...", backupID){ if (verbose) { fprintf(__stdoutp, ("Re-cloning backup volume %u ..."
), (backupID)); fflush(__stdoutp); } };
2853
2854 code = AFSVolReClone(aconn, ttid, backupID);
2855 if (code) {
2856 fprintf(STDERR__stderrp, "Could not re-clone backup volume %lu\n",
2857 (unsigned long)backupID);
2858 error = code;
2859 goto bfail;
2860 }
2861 } else {
2862 VPRINT1("Creating a new backup clone %u ...", backupID){ if (verbose) { fprintf(__stdoutp, ("Creating a new backup clone %u ..."
), (backupID)); fflush(__stdoutp); } };
2863
2864 strcpy(vname, entry.name);
2865 strcat(vname, ".backup");
2866
2867 code = AFSVolClone(aconn, ttid, 0, backupVolume2, vname, &backupID);
2868 if (code) {
2869 fprintf(STDERR__stderrp, "Failed to clone the volume %lu\n",
2870 (unsigned long)avolid);
2871 error = code;
2872 goto bfail;
2873 }
2874 }
2875
2876 /* End the transaction on the RW volume */
2877 code = AFSVolEndTrans(aconn, ttid, &rcode);
2878 ttid = 0;
2879 if (code || rcode) {
2880 fprintf(STDERR__stderrp,
2881 "Failed to end the transaction on the rw volume %lu\n",
2882 (unsigned long)avolid);
2883 error = (code ? code : rcode);
2884 goto bfail;
2885 }
2886
2887 /* Mork vldb as backup exists */
2888 if (!(entry.flags & BACK_EXISTS0x4000)) {
2889 entry.flags |= BACK_EXISTS0x4000;
2890 vldbmod = 1;
2891 }
2892
2893 /* Now go back to the backup volume and bring it on line */
2894 code = AFSVolTransCreate_retry(aconn, backupID, apart, ITOffline1, &btid);
2895 if (code) {
2896 fprintf(STDERR__stderrp,
2897 "Failed to start a transaction on the backup volume %lu\n",
2898 (unsigned long)backupID);
2899 error = code;
2900 goto bfail;
2901 }
2902
2903 code = AFSVolSetFlags(aconn, btid, 0);
2904 if (code) {
2905 fprintf(STDERR__stderrp, "Could not mark the backup volume %lu on line \n",
2906 (unsigned long)backupID);
2907 error = code;
2908 goto bfail;
2909 }
2910
2911 code = AFSVolEndTrans(aconn, btid, &rcode);
2912 btid = 0;
2913 if (code || rcode) {
2914 fprintf(STDERR__stderrp,
2915 "Failed to end the transaction on the backup volume %lu\n",
2916 (unsigned long)backupID);
2917 error = (code ? code : rcode);
2918 goto bfail;
2919 }
2920
2921 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
2922
2923 /* Will update the vldb below */
2924
2925 bfail:
2926 if (ttid) {
2927 code = AFSVolEndTrans(aconn, ttid, &rcode);
2928 if (code || rcode) {
2929 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu\n",
2930 (unsigned long)avolid);
2931 if (!error)
2932 error = (code ? code : rcode);
2933 }
2934 }
2935
2936 if (btid) {
2937 code = AFSVolEndTrans(aconn, btid, &rcode);
2938 if (code || rcode) {
2939 fprintf(STDERR__stderrp,
2940 "Could not end transaction the backup volume %lu\n",
2941 (unsigned long)backupID);
2942 if (!error)
2943 error = (code ? code : rcode);
2944 }
2945 }
2946
2947 /* Now update the vldb - if modified */
2948 if (vldblocked) {
2949 if (vldbmod) {
2950 MapNetworkToHost(&entry, &storeEntry);
2951 code =
2952 VLDB_ReplaceEntry(avolid, RWVOL0, &storeEntry,
2953 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
2954 LOCKREL_TIMESTAMP1));
2955 if (code) {
2956 fprintf(STDERR__stderrp,
2957 "Could not update the VLDB entry for the volume %lu \n",
2958 (unsigned long)avolid);
2959 if (!error)
2960 error = code;
2961 }
2962 } else {
2963 code =
2964 ubik_VL_ReleaseLock(cstruct, 0, avolid, RWVOL0,
2965 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
2966 LOCKREL_TIMESTAMP1));
2967 if (code) {
2968 fprintf(STDERR__stderrp,
2969 "Could not unlock the VLDB entry for the volume %lu \n",
2970 (unsigned long)avolid);
2971 if (!error)
2972 error = code;
2973 }
2974 }
2975 }
2976
2977 if (aconn)
2978 rx_DestroyConnection(aconn);
2979
2980 PrintError("", error);
2981 return error;
2982}
2983
2984/* Make a new clone of volume <avolid> on <aserver> and <apart>
2985 * using volume ID <acloneid>, or a new ID allocated from the VLDB.
2986 * The new volume is named by <aname>, or by appending ".clone" to
2987 * the existing name if <aname> is NULL. The following flags are
2988 * supported:
2989 *
2990 * RV_RDONLY - target volume is RO
2991 * RV_OFFLINE - leave target volume offline
2992 */
2993
2994int
2995UV_CloneVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid,
2996 afs_uint32 acloneid, char *aname, int flags)
2997{
2998 struct rx_connection *aconn = (struct rx_connection *)0;
2999 afs_int32 ttid = 0, btid = 0;
3000 afs_int32 code = 0, rcode = 0;
3001 char vname[VOLSER_MAXVOLNAME65 + 1];
3002 afs_int32 error = 0;
3003 int backexists = 1;
3004 volEntries volumeInfo;
3005
3006 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
3007
3008 if (!aname) {
3009 volumeInfo.volEntries_val = (volintInfo *) 0;
3010 volumeInfo.volEntries_len = 0;
3011 code = AFSVolListOneVolume(aconn, apart, avolid, &volumeInfo);
3012 if (code) {
3013 fprintf(stderr__stderrp, "Could not get info for volume %lu\n",
3014 (unsigned long)avolid);
3015 error = code;
3016 goto bfail;
3017 }
3018 strncpy(vname, volumeInfo.volEntries_val[0].name,
3019 VOLSER_OLDMAXVOLNAME32 - 7);
3020 vname[VOLSER_OLDMAXVOLNAME32 - 7] = 0;
3021 strcat(vname, ".clone");
3022 aname = vname;
3023 if (volumeInfo.volEntries_val)
3024 free(volumeInfo.volEntries_val);
3025 }
3026
3027 if (!acloneid) {
3028 /* Get a clone id */
3029 VPRINT1("Allocating new volume id for clone of volume %u ...",{ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (avolid)); fflush(__stdoutp); } }
3030 avolid){ if (verbose) { fprintf(__stdoutp, ("Allocating new volume id for clone of volume %u ..."
), (avolid)); fflush(__stdoutp); } };
3031 code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &acloneid);
3032 EGOTO1(bfail, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((avolid))); PrintError(" ",(code)); } while (0); error
= (code); goto bfail; } } while (0)
3033 "Could not get an ID for the clone of volume %u from the VLDB\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((avolid))); PrintError(" ",(code)); } while (0); error
= (code); goto bfail; } } while (0)
3034 avolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((avolid))); PrintError(" ",(code)); } while (0); error
= (code); goto bfail; } } while (0);
3035 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3036 }
3037
3038 /* Test to see if the clone volume exists by trying to create
3039 * a transaction on the clone volume. We've assumed the clone exists.
3040 */
3041 /* XXX I wonder what happens if the clone has some other parent... */
3042 code = AFSVolTransCreate_retry(aconn, acloneid, apart, ITOffline1, &btid);
3043 if (code) {
3044 if (code != VNOVOL103) {
3045 fprintf(STDERR__stderrp, "Could not reach the clone volume %lu\n",
3046 (unsigned long)acloneid);
3047 error = code;
3048 goto bfail;
3049 }
3050 backexists = 0; /* backup volume does not exist */
3051 }
3052 if (btid) {
3053 code = AFSVolEndTrans(aconn, btid, &rcode);
3054 btid = 0;
3055 if (code || rcode) {
3056 fprintf(STDERR__stderrp,
3057 "Could not end transaction on the previous clone volume %lu\n",
3058 (unsigned long)acloneid);
3059 error = (code ? code : rcode);
3060 goto bfail;
3061 }
3062 }
3063
3064 /* Now go ahead and try to clone the RW volume.
3065 * First start a transaction on the RW volume
3066 */
3067 code = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy2, &ttid);
3068 if (code) {
3069 fprintf(STDERR__stderrp, "Could not start a transaction on the volume %lu\n",
3070 (unsigned long)avolid);
3071 error = code;
3072 goto bfail;
3073 }
3074
3075 /* Clone or reclone the volume, depending on whether the backup
3076 * volume exists or not
3077 */
3078 if (backexists) {
3079 VPRINT1("Re-cloning clone volume %u ...", acloneid){ if (verbose) { fprintf(__stdoutp, ("Re-cloning clone volume %u ..."
), (acloneid)); fflush(__stdoutp); } };
3080
3081 code = AFSVolReClone(aconn, ttid, acloneid);
3082 if (code) {
3083 fprintf(STDERR__stderrp, "Could not re-clone backup volume %lu\n",
3084 (unsigned long)acloneid);
3085 error = code;
3086 goto bfail;
3087 }
3088 } else {
3089 VPRINT1("Creating a new clone %u ...", acloneid){ if (verbose) { fprintf(__stdoutp, ("Creating a new clone %u ..."
), (acloneid)); fflush(__stdoutp); } };
3090
3091 code = AFSVolClone(aconn, ttid, 0,
3092 (flags & RV_RDONLY0x010000) ? readonlyVolume1 : backupVolume2,
3093 aname, &acloneid);
3094 if (code) {
3095 fprintf(STDERR__stderrp, "Failed to clone the volume %lu\n",
3096 (unsigned long)avolid);
3097 error = code;
3098 goto bfail;
3099 }
3100 }
3101
3102 /* End the transaction on the RW volume */
3103 code = AFSVolEndTrans(aconn, ttid, &rcode);
3104 ttid = 0;
3105 if (code || rcode) {
3106 fprintf(STDERR__stderrp,
3107 "Failed to end the transaction on the rw volume %lu\n",
3108 (unsigned long)avolid);
3109 error = (code ? code : rcode);
3110 goto bfail;
3111 }
3112
3113 /* Now go back to the backup volume and bring it on line */
3114 if (!(flags & RV_OFFLINE0x000002)) {
3115 code = AFSVolTransCreate_retry(aconn, acloneid, apart, ITOffline1, &btid);
3116 if (code) {
3117 fprintf(STDERR__stderrp,
3118 "Failed to start a transaction on the clone volume %lu\n",
3119 (unsigned long)acloneid);
3120 error = code;
3121 goto bfail;
3122 }
3123
3124 code = AFSVolSetFlags(aconn, btid, 0);
3125 if (code) {
3126 fprintf(STDERR__stderrp, "Could not mark the clone volume %lu on line \n",
3127 (unsigned long)acloneid);
3128 error = code;
3129 goto bfail;
3130 }
3131
3132 code = AFSVolEndTrans(aconn, btid, &rcode);
3133 btid = 0;
3134 if (code || rcode) {
3135 fprintf(STDERR__stderrp,
3136 "Failed to end the transaction on the clone volume %lu\n",
3137 (unsigned long)acloneid);
3138 error = (code ? code : rcode);
3139 goto bfail;
3140 }
3141 }
3142
3143 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3144
3145 bfail:
3146 if (ttid) {
3147 code = AFSVolEndTrans(aconn, ttid, &rcode);
3148 if (code || rcode) {
3149 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu\n",
3150 (unsigned long)avolid);
3151 if (!error)
3152 error = (code ? code : rcode);
3153 }
3154 }
3155
3156 if (btid) {
3157 code = AFSVolEndTrans(aconn, btid, &rcode);
3158 if (code || rcode) {
3159 fprintf(STDERR__stderrp,
3160 "Could not end transaction on the clone volume %lu\n",
3161 (unsigned long)acloneid);
3162 if (!error)
3163 error = (code ? code : rcode);
3164 }
3165 }
3166
3167 if (aconn)
3168 rx_DestroyConnection(aconn);
3169
3170 PrintError("", error);
3171 return error;
3172}
3173
3174static int
3175DelVol(struct rx_connection *conn, afs_uint32 vid, afs_int32 part,
3176 afs_int32 flags)
3177{
3178 afs_int32 acode, ccode, rcode, tid;
3179 ccode = rcode = tid = 0;
3180
3181 acode = AFSVolTransCreate_retry(conn, vid, part, flags, &tid);
3182 if (!acode) { /* It really was there */
3183 acode = AFSVolDeleteVolume(conn, tid);
3184 if (acode) {
3185 fprintf(STDERR__stderrp, "Failed to delete volume %lu.\n",
3186 (unsigned long)vid);
3187 PrintError("", acode);
3188 }
3189 ccode = AFSVolEndTrans(conn, tid, &rcode);
3190 if (!ccode)
3191 ccode = rcode;
3192 if (ccode) {
3193 fprintf(STDERR__stderrp, "Failed to end transaction on volume %lu.\n",
3194 (unsigned long)vid);
3195 PrintError("", ccode);
3196 }
3197 }
3198
3199 return acode;
3200}
3201
3202#define ONERROR(ec, ep, es)do { if (ec) { fprintf(__stderrp, (es), (ep)); error = (ec); goto
rfail; } } while (0) do { \
3203 if (ec) { \
3204 fprintf(STDERR__stderrp, (es), (ep)); \
3205 error = (ec); \
3206 goto rfail; \
3207 } \
3208} while (0)
3209#define ONERROR0(ec, es)do { if (ec) { fprintf(__stderrp, (es)); error = (ec); goto rfail
; } } while (0) do { \
3210 if (ec) { \
3211 fprintf(STDERR__stderrp, (es)); \
3212 error = (ec); \
3213 goto rfail; \
3214 } \
3215} while (0)
3216#define ERROREXIT(ec)do { error = (ec); goto rfail; } while (0) do { \
3217 error = (ec); \
3218 goto rfail; \
3219} while (0)
3220
3221/* Get a "transaction" on this replica. Create the volume
3222 * if necessary. Return the time from which a dump should
3223 * be made (0 if it's a new volume)
3224 */
3225static int
3226GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
3227 struct rx_connection **connPtr, afs_int32 * transPtr,
3228 afs_uint32 * crtimePtr, afs_uint32 * uptimePtr,
3229 afs_int32 *origflags)
3230{
3231 afs_uint32 volid;
3232 struct volser_status tstatus;
3233 int code = 0;
3234 int rcode, tcode;
3235 char hoststr[16];
3236
3237 *connPtr = (struct rx_connection *)0;
3238 *transPtr = 0;
3239 *crtimePtr = 0;
3240 *uptimePtr = 0;
3241
3242 /* get connection to the replication site */
3243 *connPtr = UV_Bind(vldbEntryPtr->serverNumber[index], AFSCONF_VOLUMEPORT7005);
3244 if (!*connPtr)
3245 goto fail; /* server is down */
3246
3247 volid = vldbEntryPtr->volumeId[ROVOL1];
3248 if (volid) {
3249 code =
3250 AFSVolTransCreate_retry(*connPtr, volid,
3251 vldbEntryPtr->serverPartition[index], ITOffline1,
3252 transPtr);
3253
3254 if (!code && (origflags[index] & RO_DONTUSE0x20)) {
3255 /* If RO_DONTUSE is set, this is supposed to be an entirely new
3256 * site. Don't trust any data on it, since it is possible we
3257 * have encountered some temporary volume from some other
3258 * incomplete volume operation. It is difficult to detect if
3259 * that has happened vs if this is a legit volume, so just
3260 * delete it to be safe. */
3261
3262 VPRINT1("Deleting extant RO_DONTUSE site on %s...",{ if (verbose) { fprintf(__stdoutp, ("Deleting extant RO_DONTUSE site on %s..."
), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr-> serverNumber
[index]))); fflush(__stdoutp); } }
3263 noresolve ? afs_inet_ntoa_r(vldbEntryPtr->{ if (verbose) { fprintf(__stdoutp, ("Deleting extant RO_DONTUSE site on %s..."
), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr-> serverNumber
[index]))); fflush(__stdoutp); } }
3264 serverNumber[index], hoststr) :{ if (verbose) { fprintf(__stdoutp, ("Deleting extant RO_DONTUSE site on %s..."
), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr-> serverNumber
[index]))); fflush(__stdoutp); } }
3265 hostutil_GetNameByINet(vldbEntryPtr->{ if (verbose) { fprintf(__stdoutp, ("Deleting extant RO_DONTUSE site on %s..."
), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr-> serverNumber
[index]))); fflush(__stdoutp); } }
3266 serverNumber[index])){ if (verbose) { fprintf(__stdoutp, ("Deleting extant RO_DONTUSE site on %s..."
), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr-> serverNumber
[index]))); fflush(__stdoutp); } };
3267
3268 code = AFSVolDeleteVolume(*connPtr, *transPtr);
3269 if (code) {
3270 PrintError("Failed to delete RO_DONTUSE site: ", code);
3271 goto fail;
3272 }
3273
3274 tcode = AFSVolEndTrans(*connPtr, *transPtr, &rcode);
3275 *transPtr = 0;
3276 if (!tcode) {
3277 tcode = rcode;
3278 }
3279 if (tcode) {
3280 PrintError("Failed to end transaction on RO_DONTUSE site: ",
3281 tcode);
3282 goto fail;
3283 }
3284
3285 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3286
3287 /* emulate what TransCreate would have returned, so we try to
3288 * create the volume below */
3289 code = VNOVOL103;
3290 }
3291 }
3292
3293 /* If the volume does not exist, create it */
3294 if (!volid || code) {
3295 char volname[64];
3296 char hoststr[16];
3297
3298 if (volid && (code != VNOVOL103)) {
3299 PrintError("Failed to start a transaction on the RO volume.\n",
3300 code);
3301 goto fail;
3302 }
3303
3304 strcpy(volname, vldbEntryPtr->name);
3305 strcat(volname, ".readonly");
3306
3307 if (verbose) {
3308 fprintf(STDOUT__stdoutp,
3309 "Creating new volume %lu on replication site %s: ",
3310 (unsigned long)volid,
3311 noresolve ? afs_inet_ntoa_r(vldbEntryPtr->
3312 serverNumber[index], hoststr) :
3313 hostutil_GetNameByINet(vldbEntryPtr->
3314 serverNumber[index]));
3315 fflush(STDOUT__stdoutp);
3316 }
3317
3318 code =
3319 AFSVolCreateVolume(*connPtr, vldbEntryPtr->serverPartition[index],
3320 volname, volser_RO1,
3321 vldbEntryPtr->volumeId[RWVOL0], &volid,
3322 transPtr);
3323 if (code) {
3324 PrintError("Failed to create the ro volume: ", code);
3325 goto fail;
3326 }
3327 vldbEntryPtr->volumeId[ROVOL1] = volid;
3328
3329 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3330
3331 /* The following is a bit redundant, since create sets these flags by default */
3332 code =
3333 AFSVolSetFlags(*connPtr, *transPtr,
3334 VTDeleteOnSalvage1 | VTOutOfService2);
3335 if (code) {
3336 PrintError("Failed to set flags on the ro volume: ", code);
3337 goto fail;
3338 }
3339 }
3340
3341 /* Otherwise, the transaction did succeed, so get the creation date of the
3342 * latest RO volume on the replication site
3343 */
3344 else {
3345 VPRINT2("Updating existing ro volume %u on %s ...\n", volid,{ if (verbose) { fprintf(__stdoutp, ("Updating existing ro volume %u on %s ...\n"
), (volid), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr->serverNumber
[index]))); fflush(__stdoutp); } }
3346 noresolve ? afs_inet_ntoa_r(vldbEntryPtr->{ if (verbose) { fprintf(__stdoutp, ("Updating existing ro volume %u on %s ...\n"
), (volid), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr->serverNumber
[index]))); fflush(__stdoutp); } }
3347 serverNumber[index], hoststr) :{ if (verbose) { fprintf(__stdoutp, ("Updating existing ro volume %u on %s ...\n"
), (volid), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr->serverNumber
[index]))); fflush(__stdoutp); } }
3348 hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index])){ if (verbose) { fprintf(__stdoutp, ("Updating existing ro volume %u on %s ...\n"
), (volid), (noresolve ? afs_inet_ntoa_r(vldbEntryPtr-> serverNumber
[index], hoststr) : hostutil_GetNameByINet(vldbEntryPtr->serverNumber
[index]))); fflush(__stdoutp); } };
3349
3350 code = AFSVolGetStatus(*connPtr, *transPtr, &tstatus);
3351 if (code) {
3352 PrintError("Failed to get status of volume on destination: ",
3353 code);
3354 goto fail;
3355 }
3356 *crtimePtr = CLOCKADJ(tstatus.creationDate)(((tstatus.creationDate) < 2) ? 0 : (tstatus.creationDate)
- 2);
3357 *uptimePtr = CLOCKADJ(tstatus.updateDate)(((tstatus.updateDate) < 2) ? 0 : (tstatus.updateDate) - 2
);
3358 }
3359
3360 return 0;
3361
3362 fail:
3363 if (*transPtr) {
3364 tcode = AFSVolEndTrans(*connPtr, *transPtr, &rcode);
3365 *transPtr = 0;
3366 if (!tcode)
3367 tcode = rcode;
3368 if (tcode)
3369 PrintError("Could not end transaction on a ro volume: ", tcode);
3370 }
3371
3372 return code;
3373}
3374
3375static int
3376SimulateForwardMultiple(struct rx_connection *fromconn, afs_int32 fromtid,
3377 afs_int32 fromdate, manyDests * tr, afs_int32 flags,
3378 void *cookie, manyResults * results)
3379{
3380 unsigned int i;
3381
3382 for (i = 0; i < tr->manyDests_len; i++) {
3383 results->manyResults_val[i] =
3384 AFSVolForward(fromconn, fromtid, fromdate,
3385 &(tr->manyDests_val[i].server),
3386 tr->manyDests_val[i].trans, cookie);
3387 }
3388 return 0;
3389}
3390
3391/**
3392 * Check if a trans has timed out, and recreate it if necessary.
3393 *
3394 * @param[in] aconn RX connection to the relevant server
3395 * @param[inout] atid Transaction ID to check; if we recreated the trans,
3396 * contains the new trans ID on success
3397 * @param[in] apart Partition for the transaction
3398 * @param[in] astat The status of the original transaction
3399 *
3400 * @return operation status
3401 * @retval 0 existing transaction is still valid, or we managed to recreate
3402 * the trans successfully
3403 * @retval nonzero Fatal error; bail out
3404 */
3405static int
3406CheckTrans(struct rx_connection *aconn, afs_int32 *atid, afs_int32 apart,
3407 struct volser_status *astat)
3408{
3409 struct volser_status new_status;
3410 afs_int32 code;
3411
3412 memset(&new_status, 0, sizeof(new_status));
3413 code = AFSVolGetStatus(aconn, *atid, &new_status);
3414 if (code) {
3415 if (code == ENOENT2) {
3416 *atid = 0;
3417 VPRINT1("Old transaction on cloned volume %lu timed out, "{ if (verbose) { fprintf(__stdoutp, ("Old transaction on cloned volume %lu timed out, "
"restarting transaction\n"), ((long unsigned) astat->volID
)); fflush(__stdoutp); } }
3418 "restarting transaction\n", (long unsigned) astat->volID){ if (verbose) { fprintf(__stdoutp, ("Old transaction on cloned volume %lu timed out, "
"restarting transaction\n"), ((long unsigned) astat->volID
)); fflush(__stdoutp); } };
3419 code = AFSVolTransCreate_retry(aconn, astat->volID, apart,
3420 ITBusy2, atid);
3421 if (code) {
3422 PrintError("Failed to recreate cloned RO volume transaction\n",
3423 code);
3424 return 1;
3425 }
3426
3427 memset(&new_status, 0, sizeof(new_status));
3428 code = AFSVolGetStatus(aconn, *atid, &new_status);
3429 if (code) {
3430 PrintError("Failed to get status on recreated transaction\n",
3431 code);
3432 return 1;
3433 }
3434
3435 if (memcmp(&new_status, astat, sizeof(new_status)) != 0) {
3436 PrintError("Recreated transaction on cloned RO volume, but "
3437 "the volume has changed!\n", 0);
3438 return 1;
3439 }
3440 } else {
3441 PrintError("Unable to get status of current cloned RO transaction\n",
3442 code);
3443 return 1;
3444 }
3445 } else {
3446 if (memcmp(&new_status, astat, sizeof(new_status)) != 0) {
3447 /* sanity check */
3448 PrintError("Internal error: current GetStatus does not match "
3449 "original GetStatus?\n", 0);
3450 return 1;
3451 }
3452 }
3453
3454 return 0;
3455}
3456
3457
3458/* UV_ReleaseVolume()
3459 * Release volume <afromvol> on <afromserver> <afrompart> to all
3460 * its RO sites (full release). Unless the previous release was
3461 * incomplete: in which case we bring the remaining incomplete
3462 * volumes up to date with the volumes that were released
3463 * successfully.
3464 * forceflag: Performs a full release.
3465 *
3466 * Will create a clone from the RW, then dump the clone out to
3467 * the remaining replicas. If there is more than 1 RO sites,
3468 * ensure that the VLDB says at least one RO is available all
3469 * the time: Influences when we write back the VLDB entry.
3470 */
3471
3472int
3473UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
3474 afs_int32 afrompart, int forceflag)
3475{
3476 char vname[64];
3477 afs_int32 code = 0;
3478 afs_int32 vcode, rcode, tcode;
3479 afs_uint32 cloneVolId, roVolId;
3480 struct replica *replicas = 0;
3481 struct nvldbentry entry, storeEntry;
3482 int i, volcount, m, fullrelease, vldbindex;
3483 int failure;
3484 struct restoreCookie cookie;
3485 struct rx_connection **toconns = 0;
3486 struct release *times = 0;
3487 int nservers = 0;
3488 struct rx_connection *fromconn = (struct rx_connection *)0;
3489 afs_int32 error = 0;
3490 int islocked = 0;
3491 afs_int32 clonetid = 0, onlinetid;
3492 afs_int32 fromtid = 0;
3493 afs_uint32 fromdate = 0;
3494 afs_uint32 thisdate;
3495 time_t tmv;
3496 int s;
3497 manyDests tr;
3498 manyResults results;
3499 int rwindex, roindex, roclone, roexists;
3500 afs_uint32 rwcrdate = 0;
3501 afs_uint32 clcrdate;
3502 struct rtime {
3503 int validtime;
3504 afs_uint32 uptime;
3505 } remembertime[NMAXNSERVERS13];
3506 int releasecount = 0;
3507 struct volser_status volstatus;
3508 char hoststr[16];
3509 afs_int32 origflags[NMAXNSERVERS13];
3510 struct volser_status orig_status;
3511
3512 memset(remembertime, 0, sizeof(remembertime));
3513 memset(&results, 0, sizeof(results));
3514 memset(origflags, 0, sizeof(origflags));
3515
3516 vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL0, VLOP_RELEASE0x20);
3517 if (vcode != VL_RERELEASE(363544L))
3518 ONERROR(vcode, afromvol,do { if (vcode) { fprintf(__stderrp, ("Could not lock the VLDB entry for the volume %u.\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0)
3519 "Could not lock the VLDB entry for the volume %u.\n")do { if (vcode) { fprintf(__stderrp, ("Could not lock the VLDB entry for the volume %u.\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0);
3520 islocked = 1;
3521
3522 /* Get the vldb entry in readable format */
3523 vcode = VLDB_GetEntryByID(afromvol, RWVOL0, &entry);
3524 ONERROR(vcode, afromvol,do { if (vcode) { fprintf(__stderrp, ("Could not fetch the entry for the volume %u from the VLDB.\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0)
3525 "Could not fetch the entry for the volume %u from the VLDB.\n")do { if (vcode) { fprintf(__stderrp, ("Could not fetch the entry for the volume %u from the VLDB.\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0);
3526 MapHostToNetwork(&entry);
3527
3528 if (verbose)
3529 EnumerateEntry(&entry);
3530
3531 if (!ISNAMEVALID(entry.name)(strlen(entry.name) < (32 - 9)))
3532 ONERROR(VOLSERBADOP, entry.name,do { if ((1492325131L)) { fprintf(__stderrp, ("Volume name %s is too long, rename before releasing.\n"
), (entry.name)); error = ((1492325131L)); goto rfail; } } while
(0)
3533 "Volume name %s is too long, rename before releasing.\n")do { if ((1492325131L)) { fprintf(__stderrp, ("Volume name %s is too long, rename before releasing.\n"
), (entry.name)); error = ((1492325131L)); goto rfail; } } while
(0);
3534 if (entry.volumeId[RWVOL0] != afromvol)
3535 ONERROR(VOLSERBADOP, afromvol,do { if ((1492325131L)) { fprintf(__stderrp, ("The volume %u being released is not a read-write volume.\n"
), (afromvol)); error = ((1492325131L)); goto rfail; } } while
(0)
3536 "The volume %u being released is not a read-write volume.\n")do { if ((1492325131L)) { fprintf(__stderrp, ("The volume %u being released is not a read-write volume.\n"
), (afromvol)); error = ((1492325131L)); goto rfail; } } while
(0);
3537 if (entry.nServers <= 1)
3538 ONERROR(VOLSERBADOP, afromvol,do { if ((1492325131L)) { fprintf(__stderrp, ("Volume %u has no replicas - release operation is meaningless!\n"
), (afromvol)); error = ((1492325131L)); goto rfail; } } while
(0)
3539 "Volume %u has no replicas - release operation is meaningless!\n")do { if ((1492325131L)) { fprintf(__stderrp, ("Volume %u has no replicas - release operation is meaningless!\n"
), (afromvol)); error = ((1492325131L)); goto rfail; } } while
(0);
3540 if (strlen(entry.name) > (VOLSER_OLDMAXVOLNAME32 - 10))
3541 ONERROR(VOLSERBADOP, entry.name,do { if ((1492325131L)) { fprintf(__stderrp, ("RO volume name %s exceeds (VOLSER_OLDMAXVOLNAME - 10) character limit\n"
), (entry.name)); error = ((1492325131L)); goto rfail; } } while
(0)
3542 "RO volume name %s exceeds (VOLSER_OLDMAXVOLNAME - 10) character limit\n")do { if ((1492325131L)) { fprintf(__stderrp, ("RO volume name %s exceeds (VOLSER_OLDMAXVOLNAME - 10) character limit\n"
), (entry.name)); error = ((1492325131L)); goto rfail; } } while
(0);
3543
3544 /* roclone is true if one of the RO volumes is on the same
3545 * partition as the RW volume. In this case, we make the RO volume
3546 * on the same partition a clone instead of a complete copy.
3547 */
3548
3549 roindex = Lp_ROMatch(afromserver, afrompart, &entry) - 1;
3550 roclone = ((roindex == -1) ? 0 : 1);
3551 rwindex = Lp_GetRwIndex(&entry);
3552 if (rwindex < 0)
3553 ONERROR0(VOLSERNOVOL, "There is no RW volume \n")do { if ((1492325135L)) { fprintf(__stderrp, ("There is no RW volume \n"
)); error = ((1492325135L)); goto rfail; } } while (0);
3554
3555 /* Make sure we have a RO volume id to work with */
3556 if (entry.volumeId[ROVOL1] == INVALID_BID0) {
3557 /* need to get a new RO volume id */
3558 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &roVolId);
3559 ONERROR(vcode, entry.name, "Cant allocate ID for RO volume of %s\n")do { if (vcode) { fprintf(__stderrp, ("Cant allocate ID for RO volume of %s\n"
), (entry.name)); error = (vcode); goto rfail; } } while (0);
3560
3561 entry.volumeId[ROVOL1] = roVolId;
3562 MapNetworkToHost(&entry, &storeEntry);
3563 vcode = VLDB_ReplaceEntry(afromvol, RWVOL0, &storeEntry, 0);
3564 ONERROR(vcode, entry.name, "Could not update vldb entry for %s.\n")do { if (vcode) { fprintf(__stderrp, ("Could not update vldb entry for %s.\n"
), (entry.name)); error = (vcode); goto rfail; } } while (0);
3565 }
3566
3567 /* Will we be completing a previously unfinished release. -force overrides */
3568 for (s = 0, m = 0, fullrelease=0, i=0; (i<entry.nServers); i++) {
3569 if (entry.serverFlags[i] & ITSROVOL0x02) {
3570 m++;
3571 if (entry.serverFlags[i] & NEW_REPSITE0x01) s++;
3572 }
3573 origflags[i] = entry.serverFlags[i];
3574 }
3575 if ((forceflag && !fullrelease) || (s == m) || (s == 0))
3576 fullrelease = 1;
3577
3578 /* Determine which volume id to use and see if it exists */
3579 cloneVolId =
3580 ((fullrelease
3581 || (entry.cloneId == 0)) ? entry.volumeId[ROVOL1] : entry.cloneId);
3582 code = VolumeExists(afromserver, afrompart, cloneVolId);
3583 roexists = ((code == ENODEV19) ? 0 : 1);
3584
3585 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
3586 if (!fromconn)
3587 ONERROR(-1, afromserver,do { if (-1) { fprintf(__stderrp, ("Cannot establish connection with server 0x%x\n"
), (afromserver)); error = (-1); goto rfail; } } while (0)
3588 "Cannot establish connection with server 0x%x\n")do { if (-1) { fprintf(__stderrp, ("Cannot establish connection with server 0x%x\n"
), (afromserver)); error = (-1); goto rfail; } } while (0);
3589
3590 if (!fullrelease) {
3591 if (!roexists)
3592 fullrelease = 1; /* Do a full release if RO clone does not exist */
3593 else {
3594 /* Begin transaction on RW and mark it busy while we query it */
3595 code = AFSVolTransCreate_retry(
3596 fromconn, afromvol, afrompart, ITBusy2, &fromtid
3597 );
3598 ONERROR(code, afromvol,do { if (code) { fprintf(__stderrp, ("Failed to start transaction on RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0)
3599 "Failed to start transaction on RW volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to start transaction on RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3600
3601 /* Query the creation date for the RW */
3602 code = AFSVolGetStatus(fromconn, fromtid, &volstatus);
3603 ONERROR(code, afromvol,do { if (code) { fprintf(__stderrp, ("Failed to get the status of RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0)
3604 "Failed to get the status of RW volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to get the status of RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3605 rwcrdate = volstatus.creationDate;
3606
3607 /* End transaction on RW */
3608 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
3609 fromtid = 0;
3610 ONERROR((code ? code : rcode), afromvol,do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RW volume %u\n"
), (afromvol)); error = ((code ? code : rcode)); goto rfail; }
} while (0)
3611 "Failed to end transaction on RW volume %u\n")do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RW volume %u\n"
), (afromvol)); error = ((code ? code : rcode)); goto rfail; }
} while (0);
3612
3613 /* Begin transaction on clone and mark it busy while we query it */
3614 code = AFSVolTransCreate_retry(
3615 fromconn, cloneVolId, afrompart, ITBusy2, &clonetid
3616 );
3617 ONERROR(code, cloneVolId,do { if (code) { fprintf(__stderrp, ("Failed to start transaction on RW clone %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0)
3618 "Failed to start transaction on RW clone %u\n")do { if (code) { fprintf(__stderrp, ("Failed to start transaction on RW clone %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0);
3619
3620 /* Query the creation date for the clone */
3621 code = AFSVolGetStatus(fromconn, clonetid, &volstatus);
3622 ONERROR(code, cloneVolId,do { if (code) { fprintf(__stderrp, ("Failed to get the status of RW clone %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0)
3623 "Failed to get the status of RW clone %u\n")do { if (code) { fprintf(__stderrp, ("Failed to get the status of RW clone %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0);
3624 clcrdate = volstatus.creationDate;
3625
3626 /* End transaction on clone */
3627 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
3628 clonetid = 0;
3629 ONERROR((code ? code : rcode), cloneVolId,do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RW clone %u\n"
), (cloneVolId)); error = ((code ? code : rcode)); goto rfail
; } } while (0)
3630 "Failed to end transaction on RW clone %u\n")do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RW clone %u\n"
), (cloneVolId)); error = ((code ? code : rcode)); goto rfail
; } } while (0);
3631
3632 if (rwcrdate > clcrdate)
3633 fullrelease = 2;/* Do a full release if RO clone older than RW */
3634 }
3635 }
3636
3637 if (verbose) {
3638 switch (fullrelease) {
3639 case 2:
3640 fprintf(STDOUT__stdoutp, "RW %lu changed, doing a complete release\n",
3641 (unsigned long)afromvol);
3642 break;
3643 case 1:
3644 fprintf(STDOUT__stdoutp, "This is a complete release of volume %lu\n",
3645 (unsigned long)afromvol);
3646 break;
3647 case 0:
3648 fprintf(STDOUT__stdoutp, "This is a completion of a previous release\n");
3649 break;
3650 }
3651 }
3652
3653 if (fullrelease) {
3654 /* If the RO clone exists, then if the clone is a temporary
3655 * clone, delete it. Or if the RO clone is marked RO_DONTUSE
3656 * (it was recently added), then also delete it. We do not
3657 * want to "reclone" a temporary RO clone.
3658 */
3659 if (roexists
3660 && (!roclone || (entry.serverFlags[roindex] & RO_DONTUSE0x20))) {
3661 code = DelVol(fromconn, cloneVolId, afrompart, ITOffline1);
3662 if (code && (code != VNOVOL103))
3663 ERROREXIT(code)do { error = (code); goto rfail; } while (0);
3664 roexists = 0;
3665 }
3666
3667 /* Mark all the ROs in the VLDB entry as RO_DONTUSE. We don't
3668 * write this entry out to the vlserver until after the first
3669 * RO volume is released (temp RO clones don't count).
3670 */
3671 for (i = 0; i < entry.nServers; i++) {
3672 entry.serverFlags[i] &= ~NEW_REPSITE0x01;
3673 entry.serverFlags[i] |= RO_DONTUSE0x20;
3674 }
3675 entry.serverFlags[rwindex] |= NEW_REPSITE0x01;
3676 entry.serverFlags[rwindex] &= ~RO_DONTUSE0x20;
3677
3678 /* Begin transaction on RW and mark it busy while we clone it */
3679 code =
3680 AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2,
3681 &clonetid);
3682 ONERROR(code, afromvol, "Failed to start transaction on volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to start transaction on volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3683
3684 /* Clone or reclone the volume */
3685 if (roexists) {
3686 VPRINT1("Recloning RW volume %u...", cloneVolId){ if (verbose) { fprintf(__stdoutp, ("Recloning RW volume %u..."
), (cloneVolId)); fflush(__stdoutp); } };
3687 code = AFSVolReClone(fromconn, clonetid, cloneVolId);
3688 ONERROR(code, afromvol, "Failed to reclone the RW volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to reclone the RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3689 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3690 } else {
3691 if (roclone) {
3692 strcpy(vname, entry.name);
3693 strcat(vname, ".readonly");
3694 VPRINT1("Cloning RW volume %u to permanent RO...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Cloning RW volume %u to permanent RO..."
), (afromvol)); fflush(__stdoutp); } };
3695 } else {
3696 strcpy(vname, "readonly-clone-temp");
3697 VPRINT1("Cloning RW volume %u to temporary RO...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Cloning RW volume %u to temporary RO..."
), (afromvol)); fflush(__stdoutp); } };
3698 }
3699 code =
3700 AFSVolClone(fromconn, clonetid, 0, readonlyVolume1, vname,
3701 &cloneVolId);
3702 ONERROR(code, afromvol, "Failed to clone the RW volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to clone the RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3703 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3704 }
3705
3706 /* Get the time the RW was created for future information */
3707 VPRINT1("Getting status of RW volume %u...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Getting status of RW volume %u..."
), (afromvol)); fflush(__stdoutp); } };
3708 code = AFSVolGetStatus(fromconn, clonetid, &volstatus);
3709 ONERROR(code, afromvol,do { if (code) { fprintf(__stderrp, ("Failed to get the status of the RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0)
3710 "Failed to get the status of the RW volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to get the status of the RW volume %u\n"
), (afromvol)); error = (code); goto rfail; } } while (0);
3711 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3712 rwcrdate = volstatus.creationDate;
3713
3714 /* End the transaction on the RW volume */
3715 VPRINT1("Ending cloning transaction on RW volume %u...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending cloning transaction on RW volume %u..."
), (afromvol)); fflush(__stdoutp); } };
3716 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
3717 clonetid = 0;
3718 ONERROR((code ? code : rcode), afromvol,do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end cloning transaction on RW %u\n"
), (afromvol)); error = ((code ? code : rcode)); goto rfail; }
} while (0)
3719 "Failed to end cloning transaction on RW %u\n")do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end cloning transaction on RW %u\n"
), (afromvol)); error = ((code ? code : rcode)); goto rfail; }
} while (0);
3720 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3721
3722 /* Remember clone volume ID in case we fail or are interrupted */
3723 entry.cloneId = cloneVolId;
3724
3725 if (roclone) {
3726 /* Bring the RO clone online - though not if it's a temporary clone */
3727 VPRINT1("Starting transaction on RO clone volume %u...",{ if (verbose) { fprintf(__stdoutp, ("Starting transaction on RO clone volume %u..."
), (cloneVolId)); fflush(__stdoutp); } }
3728 cloneVolId){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on RO clone volume %u..."
), (cloneVolId)); fflush(__stdoutp); } };
3729 code =
3730 AFSVolTransCreate_retry(fromconn, cloneVolId, afrompart, ITOffline1,
3731 &onlinetid);
3732 ONERROR(code, cloneVolId,do { if (code) { fprintf(__stderrp, ("Failed to start transaction on volume %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0)
3733 "Failed to start transaction on volume %u\n")do { if (code) { fprintf(__stderrp, ("Failed to start transaction on volume %u\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0);
3734 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3735
3736 VPRINT1("Setting volume flags for volume %u...", cloneVolId){ if (verbose) { fprintf(__stdoutp, ("Setting volume flags for volume %u..."
), (cloneVolId)); fflush(__stdoutp); } };
3737 tcode = AFSVolSetFlags(fromconn, onlinetid, 0);
3738 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3739
3740 VPRINT1("Ending transaction on volume %u...", cloneVolId){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on volume %u..."
), (cloneVolId)); fflush(__stdoutp); } };
3741 code = AFSVolEndTrans(fromconn, onlinetid, &rcode);
3742 ONERROR((code ? code : rcode), cloneVolId,do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RO clone %u\n"
), (cloneVolId)); error = ((code ? code : rcode)); goto rfail
; } } while (0)
3743 "Failed to end transaction on RO clone %u\n")do { if ((code ? code : rcode)) { fprintf(__stderrp, ("Failed to end transaction on RO clone %u\n"
), (cloneVolId)); error = ((code ? code : rcode)); goto rfail
; } } while (0);
3744 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3745
3746 ONERROR(tcode, cloneVolId, "Could not bring volume %u on line\n")do { if (tcode) { fprintf(__stderrp, ("Could not bring volume %u on line\n"
), (cloneVolId)); error = (tcode); goto rfail; } } while (0);
3747
3748 /* Sleep so that a client searching for an online volume won't
3749 * find the clone offline and then the next RO offline while the
3750 * release brings the clone online and the next RO offline (race).
3751 * There is a fix in the 3.4 client that does not need this sleep
3752 * anymore, but we don't know what clients we have.
3753 */
3754 if (entry.nServers > 2)
3755 sleep(5);
3756
3757 /* Mark the RO clone in the VLDB as a good site (already released) */
3758 entry.serverFlags[roindex] |= NEW_REPSITE0x01;
3759 entry.serverFlags[roindex] &= ~RO_DONTUSE0x20;
3760 entry.flags |= RO_EXISTS0x2000;
3761
3762 releasecount++;
3763
3764 /* Write out the VLDB entry only if the clone is not a temporary
3765 * clone. If we did this to a temporary clone then we would end
3766 * up marking all the ROs as "old release" making the ROs
3767 * temporarily unavailable.
3768 */
3769 MapNetworkToHost(&entry, &storeEntry);
3770 VPRINT1("Replacing VLDB entry for %s...", entry.name){ if (verbose) { fprintf(__stdoutp, ("Replacing VLDB entry for %s..."
), (entry.name)); fflush(__stdoutp); } };
3771 vcode = VLDB_ReplaceEntry(afromvol, RWVOL0, &storeEntry, 0);
3772 ONERROR(vcode, entry.name,do { if (vcode) { fprintf(__stderrp, ("Could not update vldb entry for %s.\n"
), (entry.name)); error = (vcode); goto rfail; } } while (0)
3773 "Could not update vldb entry for %s.\n")do { if (vcode) { fprintf(__stderrp, ("Could not update vldb entry for %s.\n"
), (entry.name)); error = (vcode); goto rfail; } } while (0);
3774 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3775 }
3776 }
3777
3778 /* Now we will release from the clone to the remaining RO replicas.
3779 * The first 2 ROs (counting the non-temporary RO clone) are released
3780 * individually: releasecount. This is to reduce the race condition
3781 * of clients trying to find an on-line RO volume. The remaining ROs
3782 * are released in parallel but no more than half the number of ROs
3783 * (rounded up) at a time: nservers.
3784 */
3785
3786 strcpy(vname, entry.name);
3787 strcat(vname, ".readonly");
3788 memset(&cookie, 0, sizeof(cookie));
3789 strncpy(cookie.name, vname, VOLSER_OLDMAXVOLNAME32);
3790 cookie.type = ROVOL1;
3791 cookie.parent = entry.volumeId[RWVOL0];
3792 cookie.clone = 0;
3793
3794 nservers = entry.nServers / 2; /* how many to do at once, excluding clone */
3795 replicas =
3796 (struct replica *)malloc(sizeof(struct replica) * nservers + 1);
3797 times = (struct release *)malloc(sizeof(struct release) * nservers + 1);
3798 toconns =
3799 (struct rx_connection **)malloc(sizeof(struct rx_connection *) *
3800 nservers + 1);
3801 results.manyResults_val =
3802 (afs_int32 *) malloc(sizeof(afs_int32) * nservers + 1);
3803 if (!replicas || !times || !!!results.manyResults_val || !toconns)
3804 ONERROR0(ENOMEM,do { if (12) { fprintf(__stderrp, ("Failed to create transaction on the release clone\n"
)); error = (12); goto rfail; } } while (0)
3805 "Failed to create transaction on the release clone\n")do { if (12) { fprintf(__stderrp, ("Failed to create transaction on the release clone\n"
)); error = (12); goto rfail; } } while (0);
3806
3807 memset(replicas, 0, (sizeof(struct replica) * nservers + 1));
3808 memset(times, 0, (sizeof(struct release) * nservers + 1));
3809 memset(toconns, 0, (sizeof(struct rx_connection *) * nservers + 1));
3810 memset(results.manyResults_val, 0, (sizeof(afs_int32) * nservers + 1));
3811
3812 /* Create a transaction on the cloned volume */
3813 VPRINT1("Starting transaction on cloned volume %u...", cloneVolId){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on cloned volume %u..."
), (cloneVolId)); fflush(__stdoutp); } };
3814 code =
3815 AFSVolTransCreate_retry(fromconn, cloneVolId, afrompart, ITBusy2, &fromtid);
3816 if (!code) {
3817 memset(&orig_status, 0, sizeof(orig_status));
3818 code = AFSVolGetStatus(fromconn, fromtid, &orig_status);
3819 }
3820 if (!fullrelease && code)
3821 ONERROR(VOLSERNOVOL, afromvol,do { if ((1492325135L)) { fprintf(__stderrp, ("Old clone is inaccessible. Try vos release -f %u.\n"
), (afromvol)); error = ((1492325135L)); goto rfail; } } while
(0)
3822 "Old clone is inaccessible. Try vos release -f %u.\n")do { if ((1492325135L)) { fprintf(__stderrp, ("Old clone is inaccessible. Try vos release -f %u.\n"
), (afromvol)); error = ((1492325135L)); goto rfail; } } while
(0);
3823 ONERROR0(code, "Failed to create transaction on the release clone\n")do { if (code) { fprintf(__stderrp, ("Failed to create transaction on the release clone\n"
)); error = (code); goto rfail; } } while (0);
3824 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
3825
3826 /* For each index in the VLDB */
3827 for (vldbindex = 0; vldbindex < entry.nServers;) {
3828
3829 /* Get a transaction on the replicas. Pick replacas which have an old release. */
3830 for (volcount = 0;
3831 ((volcount < nservers) && (vldbindex < entry.nServers));
3832 vldbindex++) {
3833 /* The first two RO volumes will be released individually.
3834 * The rest are then released in parallel. This is a hack
3835 * for clients not recognizing right away when a RO volume
3836 * comes back on-line.
3837 */
3838 if ((volcount == 1) && (releasecount < 2))
3839 break;
3840
3841 if (vldbindex == roindex)
3842 continue; /* the clone */
3843 if ((entry.serverFlags[vldbindex] & NEW_REPSITE0x01)
3844 && !(entry.serverFlags[vldbindex] & RO_DONTUSE0x20))
3845 continue;
3846 if (!(entry.serverFlags[vldbindex] & ITSROVOL0x02))
3847 continue; /* not a RO vol */
3848
3849
3850 /* Get a Transaction on this replica. Get a new connection if
3851 * necessary. Create the volume if necessary. Return the
3852 * time from which the dump should be made (0 if it's a new
3853 * volume). Each volume might have a different time.
3854 */
3855 replicas[volcount].server.destHost =
3856 ntohl(entry.serverNumber[vldbindex])(__builtin_constant_p(entry.serverNumber[vldbindex]) ? ((((__uint32_t
)(entry.serverNumber[vldbindex])) >> 24) | ((((__uint32_t
)(entry.serverNumber[vldbindex])) & (0xff << 16)) >>
8) | ((((__uint32_t)(entry.serverNumber[vldbindex])) & (
0xff << 8)) << 8) | (((__uint32_t)(entry.serverNumber
[vldbindex])) << 24)) : __bswap32_var(entry.serverNumber
[vldbindex]));
3857 replicas[volcount].server.destPort = AFSCONF_VOLUMEPORT7005;
3858 replicas[volcount].server.destSSID = 1;
3859 times[volcount].vldbEntryIndex = vldbindex;
3860
3861 code =
3862 GetTrans(&entry, vldbindex, &(toconns[volcount]),
3863 &(replicas[volcount].trans),
3864 &(times[volcount].crtime),
3865 &(times[volcount].uptime),
3866 origflags);
3867 if (code)
3868 continue;
3869
3870 /* Thisdate is the date from which we want to pick up all changes */
3871 if (forceflag || !fullrelease
3872 || (rwcrdate > times[volcount].crtime)) {
3873 /* If the forceflag is set, then we want to do a full dump.
3874 * If it's not a full release, we can't be sure that the creation
3875 * date is good (so we also do a full dump).
3876 * If the RW volume was replaced (its creation date is newer than
3877 * the last release), then we can't be sure what has changed (so
3878 * we do a full dump).
3879 */
3880 thisdate = 0;
3881 } else if (remembertime[vldbindex].validtime) {
3882 /* Trans was prev ended. Use the time from the prev trans
3883 * because, prev trans may have created the volume. In which
3884 * case time[volcount].time would be now instead of 0.
3885 */
3886 thisdate =
3887 (remembertime[vldbindex].uptime < times[volcount].uptime)
3888 ? remembertime[vldbindex].uptime
3889 : times[volcount].uptime;
3890 } else {
3891 thisdate = times[volcount].uptime;
3892 }
3893 remembertime[vldbindex].validtime = 1;
3894 remembertime[vldbindex].uptime = thisdate;
3895
3896 if (volcount == 0) {
3897 fromdate = thisdate;
3898 } else {
3899 /* Include this volume if it is within 15 minutes of the earliest */
3900 if (((fromdate >
3901 thisdate) ? (fromdate - thisdate) : (thisdate -
3902 fromdate)) > 900) {
3903 AFSVolEndTrans(toconns[volcount],
3904 replicas[volcount].trans, &rcode);
3905 replicas[volcount].trans = 0;
3906 break;
3907 }
3908 if (thisdate < fromdate)
3909 fromdate = thisdate;
3910 }
3911 volcount++;
3912 }
3913 if (!volcount)
3914 continue;
3915
3916 code = CheckTrans(fromconn, &fromtid, afrompart, &orig_status);
3917 if (code) {
3918 code = ENOENT2;
3919 goto rfail;
3920 }
3921
3922 if (verbose) {
3923 fprintf(STDOUT__stdoutp, "Starting ForwardMulti from %lu to %u on %s",
3924 (unsigned long)cloneVolId, entry.volumeId[ROVOL1],
3925 noresolve ? afs_inet_ntoa_r(entry.serverNumber[times[0].
3926 vldbEntryIndex], hoststr) :
3927 hostutil_GetNameByINet(entry.
3928 serverNumber[times[0].
3929 vldbEntryIndex]));
3930
3931 for (s = 1; s < volcount; s++) {
3932 fprintf(STDOUT__stdoutp, " and %s",
3933 noresolve ? afs_inet_ntoa_r(entry.serverNumber[times[s].
3934 vldbEntryIndex], hoststr) :
3935 hostutil_GetNameByINet(entry.
3936 serverNumber[times[s].
3937 vldbEntryIndex]));
3938 }
3939
3940 if (fromdate == 0)
3941 fprintf(STDOUT__stdoutp, " (full release)");
3942 else {
3943 tmv = fromdate;
3944 fprintf(STDOUT__stdoutp, " (as of %.24s)", ctime(&tmv));
3945 }
3946 fprintf(STDOUT__stdoutp, ".\n");
3947 fflush(STDOUT__stdoutp);
3948 }
3949
3950 /* Release the ones we have collected */
3951 tr.manyDests_val = &(replicas[0]);
3952 tr.manyDests_len = results.manyResults_len = volcount;
3953 code =
3954 AFSVolForwardMultiple(fromconn, fromtid, fromdate, &tr,
3955 0 /*spare */ , &cookie, &results);
3956 if (code == RXGEN_OPCODE-455) { /* RPC Interface Mismatch */
3957 code =
3958 SimulateForwardMultiple(fromconn, fromtid, fromdate, &tr,
3959 0 /*spare */ , &cookie, &results);
3960 nservers = 1;
3961 }
3962
3963 if (code) {
3964 PrintError("Release failed: ", code);
3965 } else {
3966 for (m = 0; m < volcount; m++) {
3967 if (results.manyResults_val[m]) {
3968 if ((m == 0) || (results.manyResults_val[m] != ENOENT2)) {
3969 /* we retry timed out transaction. When it is
3970 * not the first volume and the transaction wasn't found
3971 * (assume it timed out and was garbage collected by volser).
3972 */
3973 PrintError
3974 ("Failed to dump volume from clone to a ro site: ",
3975 results.manyResults_val[m]);
3976 }
3977 continue;
3978 }
3979
3980 code =
3981 AFSVolSetIdsTypes(toconns[m], replicas[m].trans, vname,
3982 ROVOL1, entry.volumeId[RWVOL0], 0, 0);
3983 if (code) {
3984 if ((m == 0) || (code != ENOENT2)) {
3985 PrintError("Failed to set correct names and ids: ",
3986 code);
3987 }
3988 continue;
3989 }
3990
3991 /* have to clear dest. flags to ensure new vol goes online:
3992 * because the restore (forwarded) operation copied
3993 * the V_inService(=0) flag over to the destination.
3994 */
3995 code = AFSVolSetFlags(toconns[m], replicas[m].trans, 0);
3996 if (code) {
3997 if ((m == 0) || (code != ENOENT2)) {
3998 PrintError("Failed to set flags on ro volume: ",
3999 code);
4000 }
4001 continue;
4002 }
4003
4004 entry.serverFlags[times[m].vldbEntryIndex] |= NEW_REPSITE0x01;
4005 entry.serverFlags[times[m].vldbEntryIndex] &= ~RO_DONTUSE0x20;
4006 entry.flags |= RO_EXISTS0x2000;
4007 releasecount++;
4008 }
4009 }
4010
4011 /* End the transactions and destroy the connections */
4012 for (s = 0; s < volcount; s++) {
4013 if (replicas[s].trans)
4014 code = AFSVolEndTrans(toconns[s], replicas[s].trans, &rcode);
4015 replicas[s].trans = 0;
4016 if (!code)
4017 code = rcode;
4018 if (code) {
4019 if ((s == 0) || (code != ENOENT2)) {
4020 PrintError("Could not end transaction on a ro volume: ",
4021 code);
4022 } else {
4023 PrintError
4024 ("Transaction timed out on a ro volume. Will retry.\n",
4025 0);
4026 if (times[s].vldbEntryIndex < vldbindex)
4027 vldbindex = times[s].vldbEntryIndex;
4028 }
4029 }
4030
4031 if (toconns[s])
4032 rx_DestroyConnection(toconns[s]);
4033 toconns[s] = 0;
4034 }
4035
4036 MapNetworkToHost(&entry, &storeEntry);
4037 vcode = VLDB_ReplaceEntry(afromvol, RWVOL0, &storeEntry, 0);
4038 ONERROR(vcode, afromvol,do { if (vcode) { fprintf(__stderrp, (" Could not update VLDB entry for volume %u\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0)
4039 " Could not update VLDB entry for volume %u\n")do { if (vcode) { fprintf(__stderrp, (" Could not update VLDB entry for volume %u\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0);
4040 } /* for each index in the vldb */
4041
4042 /* End the transaction on the cloned volume */
4043 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
4044 fromtid = 0;
4045 if (!code)
4046 code = rcode;
4047 if (code)
4048 PrintError("Failed to end transaction on rw volume: ", code);
4049
4050 /* Figure out if any volume were not released and say so */
4051 for (failure = 0, i = 0; i < entry.nServers; i++) {
4052 if (!(entry.serverFlags[i] & NEW_REPSITE0x01))
4053 failure++;
4054 }
4055 if (failure) {
4056 char pname[10];
4057 fprintf(STDERR__stderrp,
4058 "The volume %lu could not be released to the following %d sites:\n",
4059 (unsigned long)afromvol, failure);
4060 for (i = 0; i < entry.nServers; i++) {
4061 if (!(entry.serverFlags[i] & NEW_REPSITE0x01)) {
4062 MapPartIdIntoName(entry.serverPartition[i], pname);
4063 fprintf(STDERR__stderrp, "\t%35s %s\n",
4064 noresolve ? afs_inet_ntoa_r(entry.serverNumber[i], hoststr) :
4065 hostutil_GetNameByINet(entry.serverNumber[i]), pname);
4066 }
4067 }
4068
4069 MapNetworkToHost(&entry, &storeEntry);
4070 vcode =
4071 VLDB_ReplaceEntry(afromvol, RWVOL0, &storeEntry,
4072 LOCKREL_TIMESTAMP1);
4073 ONERROR(vcode, afromvol,do { if (vcode) { fprintf(__stderrp, (" Could not update VLDB entry for volume %u\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0)
4074 " Could not update VLDB entry for volume %u\n")do { if (vcode) { fprintf(__stderrp, (" Could not update VLDB entry for volume %u\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0);
4075
4076 ERROREXIT(VOLSERBADRELEASE)do { error = ((1492325132L)); goto rfail; } while (0);
4077 }
4078
4079 /* All the ROs were release successfully. Remove the temporary clone */
4080 if (!roclone) {
4081 if (verbose) {
4082 fprintf(STDOUT__stdoutp, "Deleting the releaseClone %lu ...",
4083 (unsigned long)cloneVolId);
4084 fflush(STDOUT__stdoutp);
4085 }
4086 code = DelVol(fromconn, cloneVolId, afrompart, ITOffline1);
4087 ONERROR(code, cloneVolId, "Failed to delete volume %u.\n")do { if (code) { fprintf(__stderrp, ("Failed to delete volume %u.\n"
), (cloneVolId)); error = (code); goto rfail; } } while (0);
4088 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
4089 }
4090 entry.cloneId = 0;
4091
4092 for (i = 0; i < entry.nServers; i++)
4093 entry.serverFlags[i] &= ~NEW_REPSITE0x01;
4094
4095 /* Update the VLDB */
4096 VPRINT("updating VLDB ..."){ if (verbose) { fprintf(__stdoutp, ("updating VLDB ...")); fflush
(__stdoutp); } };
4097
4098 MapNetworkToHost(&entry, &storeEntry);
4099 vcode =
4100 VLDB_ReplaceEntry(afromvol, RWVOL0, &storeEntry,
4101 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
4102 ONERROR(vcode, afromvol, " Could not update VLDB entry for volume %u\n")do { if (vcode) { fprintf(__stderrp, (" Could not update VLDB entry for volume %u\n"
), (afromvol)); error = (vcode); goto rfail; } } while (0);
4103 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
4104
4105 rfail:
4106 if (clonetid) {
4107 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
4108 clonetid = 0;
4109 if (code) {
4110 fprintf(STDERR__stderrp,
4111 "Failed to end cloning transaction on the RW volume %lu\n",
4112 (unsigned long)afromvol);
4113 if (!error)
4114 error = code;
4115 }
4116 }
4117 if (fromtid) {
4118 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
4119 fromtid = 0;
4120 if (code) {
4121 fprintf(STDERR__stderrp,
4122 "Failed to end transaction on the release clone %lu\n",
4123 (unsigned long)cloneVolId);
4124 if (!error)
4125 error = code;
4126 }
4127 }
4128 for (i = 0; i < nservers; i++) {
4129 if (replicas && replicas[i].trans) {
4130 code = AFSVolEndTrans(toconns[i], replicas[i].trans, &rcode);
4131 replicas[i].trans = 0;
4132 if (code) {
4133 fprintf(STDERR__stderrp,
4134 "Failed to end transaction on ro volume %u at server %s\n",
4135 entry.volumeId[ROVOL1],
4136 noresolve ? afs_inet_ntoa_r(htonl(replicas[i].server.(__builtin_constant_p(replicas[i].server. destHost) ? ((((__uint32_t
)(replicas[i].server. destHost)) >> 24) | ((((__uint32_t
)(replicas[i].server. destHost)) & (0xff << 16)) >>
8) | ((((__uint32_t)(replicas[i].server. destHost)) & (0xff
<< 8)) << 8) | (((__uint32_t)(replicas[i].server
. destHost)) << 24)) : __bswap32_var(replicas[i].server
. destHost))
4137 destHost)(__builtin_constant_p(replicas[i].server. destHost) ? ((((__uint32_t
)(replicas[i].server. destHost)) >> 24) | ((((__uint32_t
)(replicas[i].server. destHost)) & (0xff << 16)) >>
8) | ((((__uint32_t)(replicas[i].server. destHost)) & (0xff
<< 8)) << 8) | (((__uint32_t)(replicas[i].server
. destHost)) << 24)) : __bswap32_var(replicas[i].server
. destHost)), hoststr) :
4138 hostutil_GetNameByINet(htonl(__builtin_constant_p(replicas[i].server.destHost) ? ((((__uint32_t
)(replicas[i].server.destHost)) >> 24) | ((((__uint32_t
)(replicas[i].server.destHost)) & (0xff << 16)) >>
8) | ((((__uint32_t)(replicas[i].server.destHost)) & (0xff
<< 8)) << 8) | (((__uint32_t)(replicas[i].server
.destHost)) << 24)) : __bswap32_var(replicas[i].server.
destHost))
4139 (replicas[i].server.destHost)(__builtin_constant_p(replicas[i].server.destHost) ? ((((__uint32_t
)(replicas[i].server.destHost)) >> 24) | ((((__uint32_t
)(replicas[i].server.destHost)) & (0xff << 16)) >>
8) | ((((__uint32_t)(replicas[i].server.destHost)) & (0xff
<< 8)) << 8) | (((__uint32_t)(replicas[i].server
.destHost)) << 24)) : __bswap32_var(replicas[i].server.
destHost))));
4140 if (!error)
4141 error = code;
4142 }
4143 }
4144 if (toconns && toconns[i]) {
4145 rx_DestroyConnection(toconns[i]);
4146 toconns[i] = 0;
4147 }
4148 }
4149 if (islocked) {
4150 vcode =
4151 ubik_VL_ReleaseLock(cstruct, 0, afromvol, RWVOL0,
4152 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
4153 if (vcode) {
4154 fprintf(STDERR__stderrp,
4155 "Could not release lock on the VLDB entry for volume %lu\n",
4156 (unsigned long)afromvol);
4157 if (!error)
4158 error = vcode;
4159 }
4160 }
4161
4162 PrintError("", error);
4163
4164 if (fromconn)
4165 rx_DestroyConnection(fromconn);
4166 if (results.manyResults_val)
4167 free(results.manyResults_val);
4168 if (replicas)
4169 free(replicas);
4170 if (toconns)
4171 free(toconns);
4172 if (times)
4173 free(times);
4174 return error;
4175}
4176
4177
4178static void
4179dump_sig_handler(int x)
4180{
4181 fprintf(STDERR__stderrp, "\nSignal handler: vos dump operation\n");
4182 longjmp(env, 0);
4183}
4184
4185/* Dump the volume <afromvol> on <afromserver> and
4186 * <afrompart> to <afilename> starting from <fromdate>.
4187 * DumpFunction does the real work behind the scenes after
4188 * extracting parameters from the rock
4189 */
4190int
4191UV_DumpVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
4192 afs_int32 fromdate,
4193 afs_int32(*DumpFunction) (struct rx_call *, void *), void *rock,
4194 afs_int32 flags)
4195{
4196 /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
4197 * be changing during the dump */
4198 struct rx_call * volatile fromcall = NULL((void *)0);
4199 struct rx_connection * volatile fromconn = NULL((void *)0);
4200 afs_int32 volatile fromtid = 0;
4201
4202 afs_int32 rxError = 0, rcode = 0;
4203 afs_int32 code, error = 0;
4204 afs_int32 tmp;
4205 time_t tmv = fromdate;
4206
4207 if (setjmp(env))
4208 ERROR_EXIT(EPIPE)do { error = (32); goto error_exit; } while (0);
4209#ifndef AFS_NT40_ENV
4210 (void)signal(SIGPIPE13, dump_sig_handler);
4211#endif
4212 (void)signal(SIGINT2, dump_sig_handler);
4213
4214 if (!fromdate) {
4215 VEPRINT("Full Dump ...\n"){ if (verbose) { fprintf(__stderrp, ("Full Dump ...\n")); fflush
(__stderrp); } };
4216 } else {
4217 VEPRINT1("Incremental Dump (as of %.24s)...\n",{ if (verbose) { fprintf(__stderrp, ("Incremental Dump (as of %.24s)...\n"
), (ctime(&tmv))); fflush(__stderrp); } }
4218 ctime(&tmv)){ if (verbose) { fprintf(__stderrp, ("Incremental Dump (as of %.24s)...\n"
), (ctime(&tmv))); fflush(__stderrp); } };
4219 }
4220
4221 /* get connections to the servers */
4222 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
4223
4224 VEPRINT1("Starting transaction on volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Starting transaction on volume %u..."
), (afromvol)); fflush(__stderrp); } };
4225 tmp = fromtid;
4226 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2, &tmp);
4227 fromtid = tmp;
4228 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4229 "Could not start transaction on the volume %u to be dumped\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4230 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0);
4231 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4232
4233 fromcall = rx_NewCall(fromconn);
4234
4235 VEPRINT1("Starting volume dump on volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Starting volume dump on volume %u..."
), (afromvol)); fflush(__stderrp); } };
4236 if (flags & VOLDUMPV2_OMITDIRS1)
4237 code = StartAFSVolDumpV2(fromcall, fromtid, fromdate, flags);
4238 else
4239 code = StartAFSVolDump(fromcall, fromtid, fromdate);
4240 EGOTO(error_exit, code, "Could not start the dump process \n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start the dump process \n"))); PrintError(" "
,(code)); } while (0); error = (code); goto error_exit; } } while
(0);
4241 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4242
4243 VEPRINT1("Dumping volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Dumping volume %u..."),
(afromvol)); fflush(__stderrp); } };
4244 code = DumpFunction(fromcall, rock);
4245 if (code == RXGEN_OPCODE-455)
4246 goto error_exit;
4247 EGOTO(error_exit, code, "Error while dumping volume \n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Error while dumping volume \n"))); PrintError(" ",(code
)); } while (0); error = (code); goto error_exit; } } while (
0);
4248 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4249
4250 error_exit:
4251 if (fromcall) {
4252 code = rx_EndCall(fromcall, rxError);
4253 if (code && code != RXGEN_OPCODE-455)
4254 fprintf(STDERR__stderrp, "Error in rx_EndCall\n");
4255 if (code && !error)
4256 error = code;
4257 }
4258 if (fromtid) {
4259 VEPRINT1("Ending transaction on volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Ending transaction on volume %u..."
), (afromvol)); fflush(__stderrp); } };
4260 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
4261 if (code || rcode) {
4262 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu\n",
4263 (unsigned long)afromvol);
4264 if (!error)
4265 error = (code ? code : rcode);
4266 }
4267 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4268 }
4269 if (fromconn)
4270 rx_DestroyConnection(fromconn);
4271
4272 if (error != RXGEN_OPCODE-455)
4273 PrintError("", error);
4274 return (error);
4275}
4276
4277/* Clone the volume <afromvol> on <afromserver> and
4278 * <afrompart>, and then dump the clone volume to
4279 * <afilename> starting from <fromdate>.
4280 * DumpFunction does the real work behind the scenes after
4281 * extracting parameters from the rock
4282 */
4283int
4284UV_DumpClonedVolume(afs_uint32 afromvol, afs_uint32 afromserver,
4285 afs_int32 afrompart, afs_int32 fromdate,
4286 afs_int32(*DumpFunction) (struct rx_call *, void *),
4287 void *rock, afs_int32 flags)
4288{
4289 /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
4290 * be changing during the dump */
4291 struct rx_connection * volatile fromconn = NULL((void *)0);
4292 struct rx_call * volatile fromcall = NULL((void *)0);
4293 afs_int32 volatile clonetid = 0;
4294 afs_uint32 volatile clonevol = 0;
4295
4296 afs_int32 tmp;
4297 afs_int32 fromtid = 0, rxError = 0, rcode = 0;
4298 afs_int32 code = 0, error = 0;
4299 afs_uint32 tmpVol;
4300 char vname[64];
4301 time_t tmv = fromdate;
4302
4303 if (setjmp(env))
1
Taking false branch
4304 ERROR_EXIT(EPIPE)do { error = (32); goto error_exit; } while (0);
4305#ifndef AFS_NT40_ENV
4306 (void)signal(SIGPIPE13, dump_sig_handler);
4307#endif
4308 (void)signal(SIGINT2, dump_sig_handler);
4309
4310 if (!fromdate) {
2
Taking false branch
4311 VEPRINT("Full Dump ...\n"){ if (verbose) { fprintf(__stderrp, ("Full Dump ...\n")); fflush
(__stderrp); } };
4312 } else {
4313 VEPRINT1("Incremental Dump (as of %.24s)...\n",{ if (verbose) { fprintf(__stderrp, ("Incremental Dump (as of %.24s)...\n"
), (ctime(&tmv))); fflush(__stderrp); } }
4314 ctime(&tmv)){ if (verbose) { fprintf(__stderrp, ("Incremental Dump (as of %.24s)...\n"
), (ctime(&tmv))); fflush(__stderrp); } };
4315 }
4316
4317 /* get connections to the servers */
4318 fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
4319
4320 VEPRINT1("Starting transaction on volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Starting transaction on volume %u..."
), (afromvol)); fflush(__stderrp); } };
4321 code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy2, &fromtid);
4322 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4323 "Could not start transaction on the volume %u to be dumped\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4324 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be dumped\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0);
4325 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4326
4327 /* Get a clone id */
4328 VEPRINT1("Allocating new volume id for clone of volume %u ...", afromvol){ if (verbose) { fprintf(__stderrp, ("Allocating new volume id for clone of volume %u ..."
), (afromvol)); fflush(__stderrp); } };
4329 tmpVol = clonevol;
4330 code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
4331 clonevol = tmpVol;
4332 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4333 "Could not get an ID for the clone of volume %u from the VLDB\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4334 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get an ID for the clone of volume %u from the VLDB\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0);
4335 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4336
4337 /* Do the clone. Default flags on clone are set to delete on salvage and out of service */
4338 VEPRINT2("Cloning source volume %u to clone volume %u...", afromvol,{ if (verbose) { fprintf(__stderrp, ("Cloning source volume %u to clone volume %u..."
), (afromvol), (clonevol)); fflush(__stderrp); } }
4339 clonevol){ if (verbose) { fprintf(__stderrp, ("Cloning source volume %u to clone volume %u..."
), (afromvol), (clonevol)); fflush(__stderrp); } };
4340 strcpy(vname, "dump-clone-temp");
4341 tmpVol = clonevol;
3
Assigned value is always the same as the existing value
4342 code =
4343 AFSVolClone(fromconn, fromtid, 0, readonlyVolume1, vname, &tmpVol);
4344 clonevol = tmpVol;
4345 EGOTO1(error_exit, code, "Failed to clone the source volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
4346 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to clone the source volume %u\n")), ((afromvol)))
; PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
4347 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4348
4349 VEPRINT1("Ending the transaction on the volume %u ...", afromvol){ if (verbose) { fprintf(__stderrp, ("Ending the transaction on the volume %u ..."
), (afromvol)); fflush(__stderrp); } };
4350 rcode = 0;
4351 code = AFSVolEndTrans(fromconn, fromtid, &rcode);
4352 fromtid = 0;
4353 if (!code)
4354 code = rcode;
4355 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
4356 "Failed to end the transaction on the volume %u\n", afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to end the transaction on the volume %u\n")), ((afromvol
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
4357 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4358
4359
4360 VEPRINT1("Starting transaction on the cloned volume %u ...", clonevol){ if (verbose) { fprintf(__stderrp, ("Starting transaction on the cloned volume %u ..."
), (clonevol)); fflush(__stderrp); } };
4361 tmp = clonetid;
4362 code =
4363 AFSVolTransCreate_retry(fromconn, clonevol, afrompart, ITOffline1,
4364 &tmp);
4365 clonetid = tmp;
4366 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((clonevol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4367 "Failed to start a transaction on the cloned volume%u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((clonevol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
4368 clonevol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start a transaction on the cloned volume%u\n")
), ((clonevol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0);
4369 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4370
4371 VEPRINT1("Setting flags on cloned volume %u ...", clonevol){ if (verbose) { fprintf(__stderrp, ("Setting flags on cloned volume %u ..."
), (clonevol)); fflush(__stderrp); } };
4372 code = AFSVolSetFlags(fromconn, clonetid, VTDeleteOnSalvage1 | VTOutOfService2); /*redundant */
4373 EGOTO1(error_exit, code, "Could not set falgs on the cloned volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set falgs on the cloned volume %u\n")), ((clonevol
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0)
4374 clonevol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set falgs on the cloned volume %u\n")), ((clonevol
))); PrintError(" ",(code)); } while (0); error = (code); goto
error_exit; } } while (0);
4375 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4376
4377
4378 fromcall = rx_NewCall(fromconn);
4379
4380 VEPRINT1("Starting volume dump from cloned volume %u...", clonevol){ if (verbose) { fprintf(__stderrp, ("Starting volume dump from cloned volume %u..."
), (clonevol)); fflush(__stderrp); } };
4381 if (flags & VOLDUMPV2_OMITDIRS1)
4382 code = StartAFSVolDumpV2(fromcall, clonetid, fromdate, flags);
4383 else
4384 code = StartAFSVolDump(fromcall, clonetid, fromdate);
4385 EGOTO(error_exit, code, "Could not start the dump process \n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start the dump process \n"))); PrintError(" "
,(code)); } while (0); error = (code); goto error_exit; } } while
(0);
4386 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4387
4388 VEPRINT1("Dumping volume %u...", afromvol){ if (verbose) { fprintf(__stderrp, ("Dumping volume %u..."),
(afromvol)); fflush(__stderrp); } };
4389 code = DumpFunction(fromcall, rock);
4390 EGOTO(error_exit, code, "Error while dumping volume \n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Error while dumping volume \n"))); PrintError(" ",(code
)); } while (0); error = (code); goto error_exit; } } while (
0);
4391 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4392
4393 error_exit:
4394 /* now delete the clone */
4395 VEPRINT1("Deleting the cloned volume %u ...", clonevol){ if (verbose) { fprintf(__stderrp, ("Deleting the cloned volume %u ..."
), (clonevol)); fflush(__stderrp); } };
4396 code = AFSVolDeleteVolume(fromconn, clonetid);
4397 if (code) {
4398 fprintf(STDERR__stderrp, "Failed to delete the cloned volume %lu\n",
4399 (unsigned long)clonevol);
4400 } else {
4401 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4402 }
4403
4404 if (fromcall) {
4405 code = rx_EndCall(fromcall, rxError);
4406 if (code) {
4407 fprintf(STDERR__stderrp, "Error in rx_EndCall\n");
4408 if (!error)
4409 error = code;
4410 }
4411 }
4412 if (clonetid) {
4413 VEPRINT1("Ending transaction on cloned volume %u...", clonevol){ if (verbose) { fprintf(__stderrp, ("Ending transaction on cloned volume %u..."
), (clonevol)); fflush(__stderrp); } };
4414 code = AFSVolEndTrans(fromconn, clonetid, &rcode);
4415 if (code || rcode) {
4416 fprintf(STDERR__stderrp,
4417 "Could not end transaction on the cloned volume %lu\n",
4418 (unsigned long)clonevol);
4419 if (!error)
4420 error = (code ? code : rcode);
4421 }
4422 VEDONE{ if (verbose) { fprintf(__stderrp, " done\n"); fflush(__stderrp
); } };
4423 }
4424 if (fromconn)
4425 rx_DestroyConnection(fromconn);
4426
4427 PrintError("", error);
4428 return (error);
4429}
4430
4431
4432
4433/*
4434 * Restore a volume <tovolid> <tovolname> on <toserver> <topart> from
4435 * the dump file <afilename>. WriteData does all the real work
4436 * after extracting params from the rock
4437 */
4438int
4439UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
4440 afs_uint32 toparentid, char tovolname[], int flags,
4441 afs_int32(*WriteData) (struct rx_call *, void *),
4442 void *rock)
4443{
4444 struct rx_connection *toconn, *tempconn;
4445 struct rx_call *tocall;
4446 afs_int32 totid, code, rcode, vcode, terror = 0;
4447 afs_int32 rxError = 0;
4448 struct volser_status tstatus;
4449 struct volintInfo vinfo;
4450 char partName[10];
4451 char tovolreal[VOLSER_OLDMAXVOLNAME32];
4452 afs_uint32 pvolid;
4453 afs_int32 temptid, pparentid;
4454 int success;
4455 struct nvldbentry entry, storeEntry;
4456 afs_int32 error;
4457 int islocked;
4458 struct restoreCookie cookie;
4459 int reuseID;
4460 afs_int32 volflag, voltype, volsertype;
4461 afs_int32 oldCreateDate, oldUpdateDate, newCreateDate, newUpdateDate;
4462 int index, same, errcode;
4463 char apartName[10];
4464 char hoststr[16];
4465
4466 memset(&cookie, 0, sizeof(cookie));
4467 islocked = 0;
4468 success = 0;
4469 error = 0;
4470 reuseID = 1;
4471 tocall = (struct rx_call *)0;
4472 toconn = (struct rx_connection *)0;
4473 tempconn = (struct rx_connection *)0;
4474 totid = 0;
4475 temptid = 0;
4476
4477 if (flags & RV_RDONLY0x010000) {
4478 voltype = ROVOL1;
4479 volsertype = volser_RO1;
4480 } else {
4481 voltype = RWVOL0;
4482 volsertype = volser_RW0;
4483 }
4484
4485 pvolid = tovolid;
4486 pparentid = toparentid;
4487 toconn = UV_Bind(toserver, AFSCONF_VOLUMEPORT7005);
4488 if (pvolid == 0) { /*alot a new id if needed */
4489 vcode = VLDB_GetEntryByName(tovolname, &entry);
4490 if (vcode == VL_NOENT(363524L)) {
4491 vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &pvolid);
4492 if (vcode) {
4493 fprintf(STDERR__stderrp, "Could not get an Id for the volume %s\n",
4494 tovolname);
4495 error = vcode;
4496 goto refail;
4497 }
4498 reuseID = 0;
4499 } else if (flags & RV_RDONLY0x010000) {
4500 if (entry.flags & RW_EXISTS0x1000) {
4501 fprintf(STDERR__stderrp,
4502 "Entry for ReadWrite volume %s already exists!\n",
4503 entry.name);
4504 error = VOLSERBADOP(1492325131L);
4505 goto refail;
4506 }
4507 if (!entry.volumeId[ROVOL1]) {
4508 fprintf(STDERR__stderrp,
4509 "Existing entry for volume %s has no ReadOnly ID\n",
4510 tovolname);
4511 error = VOLSERBADOP(1492325131L);
4512 goto refail;
4513 }
4514 pvolid = entry.volumeId[ROVOL1];
4515 pparentid = entry.volumeId[RWVOL0];
4516 } else {
4517 pvolid = entry.volumeId[RWVOL0];
4518 pparentid = entry.volumeId[RWVOL0];
4519 }
4520 }
4521 if (!pparentid) pparentid = pvolid;
4522 /* at this point we have a volume id to use/reuse for the volume to be restored */
4523 strncpy(tovolreal, tovolname, VOLSER_OLDMAXVOLNAME32);
4524
4525 if (strlen(tovolname) > (VOLSER_OLDMAXVOLNAME32 - 1)) {
4526 EGOTO1(refail, VOLSERBADOP,do { if ((1492325131L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n"
)), ((tovolname))); PrintError(" ",((1492325131L))); } while
(0); error = ((1492325131L)); goto refail; } } while (0)
4527 "The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n",do { if ((1492325131L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n"
)), ((tovolname))); PrintError(" ",((1492325131L))); } while
(0); error = ((1492325131L)); goto refail; } } while (0)
4528 tovolname)do { if ((1492325131L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n"
)), ((tovolname))); PrintError(" ",((1492325131L))); } while
(0); error = ((1492325131L)); goto refail; } } while (0);
4529 } else {
4530 if ((pparentid != pvolid) && (flags & RV_RDONLY0x010000)) {
4531 if (strlen(tovolname) > (VOLSER_OLDMAXVOLNAME32 - 10)) {
4532 EGOTO1(refail, VOLSERBADOP,do { if ((1492325131L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n"
)), ((tovolname))); PrintError(" ",((1492325131L))); } while
(0); error = ((1492325131L)); goto refail; } } while (0)
4533 "The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n", tovolname)do { if ((1492325131L)) { do { fprintf(__stderrp, "\n"); fprintf
(__stderrp, (("The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n"
)), ((tovolname))); PrintError(" ",((1492325131L))); } while
(0); error = ((1492325131L)); goto refail; } } while (0);
4534 }
4535 snprintf(tovolreal, VOLSER_OLDMAXVOLNAME32, "%s.readonly", tovolname);
4536 }
4537 }
4538 MapPartIdIntoName(topart, partName);
4539 fprintf(STDOUT__stdoutp, "Restoring volume %s Id %lu on server %s partition %s ..",
4540 tovolreal, (unsigned long)pvolid,
4541 noresolve ? afs_inet_ntoa_r(toserver, hoststr) :
4542 hostutil_GetNameByINet(toserver), partName);
4543 fflush(STDOUT__stdoutp);
4544 code =
4545 AFSVolCreateVolume(toconn, topart, tovolreal, volsertype, pparentid, &pvolid,
4546 &totid);
4547 if (code) {
4548 if (flags & RV_FULLRST0x000001) { /* full restore: delete then create anew */
4549 VPRINT1("Deleting the previous volume %u ...", pvolid){ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u ..."
), (pvolid)); fflush(__stdoutp); } };
4550
4551 code =
4552 AFSVolTransCreate_retry(toconn, pvolid, topart, ITOffline1, &totid);
4553 EGOTO1(refail, code, "Failed to start transaction on %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start transaction on %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0)
4554 pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start transaction on %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4555
4556 code = AFSVolGetStatus(toconn, totid, &tstatus);
4557 EGOTO1(refail, code, "Could not get timestamp from volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get timestamp from volume %u\n")), ((pvolid)))
; PrintError(" ",(code)); } while (0); error = (code); goto
refail; } } while (0)
4558 pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get timestamp from volume %u\n")), ((pvolid)))
; PrintError(" ",(code)); } while (0); error = (code); goto
refail; } } while (0);
4559
4560 oldCreateDate = tstatus.creationDate;
4561 oldUpdateDate = tstatus.updateDate;
4562
4563 code =
4564 AFSVolSetFlags(toconn, totid,
4565 VTDeleteOnSalvage1 | VTOutOfService2);
4566 EGOTO1(refail, code, "Could not set flags on volume %u \n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on volume %u \n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0)
4567 pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not set flags on volume %u \n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4568
4569 code = AFSVolDeleteVolume(toconn, totid);
4570 EGOTO1(refail, code, "Could not delete volume %u\n", pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not delete volume %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4571
4572 code = AFSVolEndTrans(toconn, totid, &rcode);
4573 totid = 0;
4574 if (!code)
4575 code = rcode;
4576 EGOTO1(refail, code, "Could not end transaction on %u\n", pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not end transaction on %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4577
4578 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
4579
4580 code =
4581 AFSVolCreateVolume(toconn, topart, tovolreal, volsertype, pparentid,
4582 &pvolid, &totid);
4583 EGOTO1(refail, code, "Could not create new volume %u\n", pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not create new volume %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4584 } else {
4585 code =
4586 AFSVolTransCreate_retry(toconn, pvolid, topart, ITOffline1, &totid);
4587 EGOTO1(refail, code, "Failed to start transaction on %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start transaction on %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0)
4588 pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Failed to start transaction on %u\n")), ((pvolid))); PrintError
(" ",(code)); } while (0); error = (code); goto refail; } }
while (0);
4589
4590 code = AFSVolGetStatus(toconn, totid, &tstatus);
4591 EGOTO1(refail, code, "Could not get timestamp from volume %u\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get timestamp from volume %u\n")), ((pvolid)))
; PrintError(" ",(code)); } while (0); error = (code); goto
refail; } } while (0)
4592 pvolid)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not get timestamp from volume %u\n")), ((pvolid)))
; PrintError(" ",(code)); } while (0); error = (code); goto
refail; } } while (0);
4593
4594 oldCreateDate = tstatus.creationDate;
4595 oldUpdateDate = tstatus.updateDate;
4596 }
4597 } else {
4598 oldCreateDate = 0;
4599 oldUpdateDate = 0;
4600 }
4601
4602 cookie.parent = pparentid;
4603 cookie.type = voltype;
4604 cookie.clone = 0;
4605 strncpy(cookie.name, tovolreal, VOLSER_OLDMAXVOLNAME32);
4606
4607 tocall = rx_NewCall(toconn);
4608 terror = StartAFSVolRestore(tocall, totid, 1, &cookie);
4609 if (terror) {
4610 fprintf(STDERR__stderrp, "Volume restore Failed \n");
4611 error = terror;
4612 goto refail;
4613 }
4614 code = WriteData(tocall, rock);
4615 if (code) {
4616 fprintf(STDERR__stderrp, "Could not transmit data\n");
4617 error = code;
4618 goto refail;
4619 }
4620 terror = rx_EndCall(tocall, rxError);
4621 tocall = (struct rx_call *)0;
4622 if (terror) {
4623 fprintf(STDERR__stderrp, "rx_EndCall Failed \n");
4624 error = terror;
4625 goto refail;
4626 }
4627 code = AFSVolGetStatus(toconn, totid, &tstatus);
4628 if (code) {
4629 fprintf(STDERR__stderrp,
4630 "Could not get status information about the volume %lu\n",
4631 (unsigned long)pvolid);
4632 error = code;
4633 goto refail;
4634 }
4635 code = AFSVolSetIdsTypes(toconn, totid, tovolreal, voltype, pparentid, 0, 0);
4636 if (code) {
4637 fprintf(STDERR__stderrp, "Could not set the right type and ID on %lu\n",
4638 (unsigned long)pvolid);
4639 error = code;
4640 goto refail;
4641 }
4642
4643 if (flags & RV_CRDUMP0x000010)
4644 newCreateDate = tstatus.creationDate;
4645 else if (flags & RV_CRKEEP0x000020 && oldCreateDate != 0)
4646 newCreateDate = oldCreateDate;
4647 else
4648 newCreateDate = time(0);
4649 if (flags & RV_LUDUMP0x000100)
4650 newUpdateDate = tstatus.updateDate;
4651 else if (flags & RV_LUKEEP0x000200)
4652 newUpdateDate = oldUpdateDate;
4653 else
4654 newUpdateDate = time(0);
4655 code = AFSVolSetDate(toconn,totid, newCreateDate);
4656 if (code) {
4657 fprintf(STDERR__stderrp, "Could not set the 'creation' date on %u\n", pvolid);
4658 error = code;
4659 goto refail;
4660 }
4661
4662 init_volintInfo(&vinfo);
4663 vinfo.creationDate = newCreateDate;
4664 vinfo.updateDate = newUpdateDate;
4665 code = AFSVolSetInfo(toconn, totid, &vinfo);
4666 if (code) {
4667 fprintf(STDERR__stderrp, "Could not set the 'last updated' date on %u\n",
4668 pvolid);
4669 error = code;
4670 goto refail;
4671 }
4672
4673 volflag = ((flags & RV_OFFLINE0x000002) ? VTOutOfService2 : 0); /* off or on-line */
4674 code = AFSVolSetFlags(toconn, totid, volflag);
4675 if (code) {
4676 fprintf(STDERR__stderrp, "Could not mark %lu online\n", (unsigned long)pvolid);
4677 error = code;
4678 goto refail;
4679 }
4680
4681/* It isn't handled right in refail */
4682 code = AFSVolEndTrans(toconn, totid, &rcode);
4683 totid = 0;
4684 if (!code)
4685 code = rcode;
4686 if (code) {
4687 fprintf(STDERR__stderrp, "Could not end transaction on %lu\n",
4688 (unsigned long)pvolid);
4689 error = code;
4690 goto refail;
4691 }
4692
4693 success = 1;
4694 fprintf(STDOUT__stdoutp, " done\n");
4695 fflush(STDOUT__stdoutp);
4696 if (success && (!reuseID || (flags & RV_FULLRST0x000001))) {
4697 /* Volume was restored on the file server, update the
4698 * VLDB to reflect the change.
4699 */
4700 vcode = VLDB_GetEntryByID(pvolid, voltype, &entry);
4701 if (vcode && vcode != VL_NOENT(363524L) && vcode != VL_ENTDELETED(363526L)) {
4702 fprintf(STDERR__stderrp,
4703 "Could not fetch the entry for volume number %lu from VLDB \n",
4704 (unsigned long)pvolid);
4705 error = vcode;
4706 goto refail;
4707 }
4708 if (!vcode)
4709 MapHostToNetwork(&entry);
4710 if (vcode == VL_NOENT(363524L)) { /* it doesnot exist already */
4711 /*make the vldb return this indication specifically */
4712 VPRINT("------- Creating a new VLDB entry ------- \n"){ if (verbose) { fprintf(__stdoutp, ("------- Creating a new VLDB entry ------- \n"
)); fflush(__stdoutp); } };
4713 strcpy(entry.name, tovolname);
4714 entry.nServers = 1;
4715 entry.serverNumber[0] = toserver; /*should be indirect */
4716 entry.serverPartition[0] = topart;
4717 entry.serverFlags[0] = (flags & RV_RDONLY0x010000) ? ITSROVOL0x02 : ITSRWVOL0x04;
4718 entry.flags = (flags & RV_RDONLY0x010000) ? RO_EXISTS0x2000 : RW_EXISTS0x1000;
4719 if (flags & RV_RDONLY0x010000)
4720 entry.volumeId[ROVOL1] = pvolid;
4721 else if (tstatus.cloneID != 0) {
4722 entry.volumeId[ROVOL1] = tstatus.cloneID; /*this should come from status info on the volume if non zero */
4723 } else
4724 entry.volumeId[ROVOL1] = INVALID_BID0;
4725 entry.volumeId[RWVOL0] = pparentid;
4726 entry.cloneId = 0;
4727 if (tstatus.backupID != 0) {
4728 entry.volumeId[BACKVOL2] = tstatus.backupID;
4729 /*this should come from status info on the volume if non zero */
4730 } else
4731 entry.volumeId[BACKVOL2] = INVALID_BID0;
4732 MapNetworkToHost(&entry, &storeEntry);
4733 vcode = VLDB_CreateEntry(&storeEntry);
4734 if (vcode) {
4735 fprintf(STDERR__stderrp,
4736 "Could not create the VLDB entry for volume number %lu \n",
4737 (unsigned long)pvolid);
4738 error = vcode;
4739 goto refail;
4740 }
4741 islocked = 0;
4742 if (verbose)
4743 EnumerateEntry(&entry);
4744 } else { /*update the existing entry */
4745 if (verbose) {
4746 fprintf(STDOUT__stdoutp, "Updating the existing VLDB entry\n");
4747 fprintf(STDOUT__stdoutp, "------- Old entry -------\n");
4748 EnumerateEntry(&entry);
4749 fprintf(STDOUT__stdoutp, "------- New entry -------\n");
4750 }
4751 vcode =
4752 ubik_VL_SetLock(cstruct, 0, pvolid, voltype,
4753 VLOP_RESTORE0x100);
4754 if (vcode) {
4755 fprintf(STDERR__stderrp,
4756 "Could not lock the entry for volume number %lu \n",
4757 (unsigned long)pvolid);
4758 error = vcode;
4759 goto refail;
4760 }
4761 islocked = 1;
4762 strcpy(entry.name, tovolname);
4763
4764 /* Update the vlentry with the new information */
4765 if (flags & RV_RDONLY0x010000)
4766 index = Lp_ROMatch(toserver, topart, &entry) - 1;
4767 else
4768 index = Lp_GetRwIndex(&entry);
4769 if (index == -1) {
4770 /* Add the new site for the volume being restored */
4771 entry.serverNumber[entry.nServers] = toserver;
4772 entry.serverPartition[entry.nServers] = topart;
4773 entry.serverFlags[entry.nServers] =
4774 (flags & RV_RDONLY0x010000) ? ITSROVOL0x02 : ITSRWVOL0x04;
4775 entry.nServers++;
4776 } else {
4777 /* This volume should be deleted on the old site
4778 * if its different from new site.
4779 */
4780 same =
4781 VLDB_IsSameAddrs(toserver, entry.serverNumber[index],
4782 &errcode);
4783 if (errcode)
4784 EPRINT2(errcode,do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Failed to get info about server's %d address(es) from vlserver (err=%d)\n"
), (toserver), (errcode)); PrintError(" ",errcode); } while
(0)
4785 "Failed to get info about server's %d address(es) from vlserver (err=%d)\n",do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Failed to get info about server's %d address(es) from vlserver (err=%d)\n"
), (toserver), (errcode)); PrintError(" ",errcode); } while
(0)
4786 toserver, errcode)do { fprintf(__stderrp, "\n"); fprintf(__stderrp, ("Failed to get info about server's %d address(es) from vlserver (err=%d)\n"
), (toserver), (errcode)); PrintError(" ",errcode); } while
(0);
4787 if ((!errcode && !same)
4788 || (entry.serverPartition[index] != topart)) {
4789 if (flags & RV_NODEL0x100000) {
4790 VPRINT2{ if (verbose) { fprintf(__stdoutp, ("Not deleting the previous volume %u on server %s, ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index]))); fflush(__stdoutp); } }
4791 ("Not deleting the previous volume %u on server %s, ...",{ if (verbose) { fprintf(__stdoutp, ("Not deleting the previous volume %u on server %s, ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index]))); fflush(__stdoutp); } }
4792 pvolid,{ if (verbose) { fprintf(__stdoutp, ("Not deleting the previous volume %u on server %s, ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index]))); fflush(__stdoutp); } }
4793 noresolve ? afs_inet_ntoa_r(entry.serverNumber[index], hoststr) :{ if (verbose) { fprintf(__stdoutp, ("Not deleting the previous volume %u on server %s, ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index]))); fflush(__stdoutp); } }
4794 hostutil_GetNameByINet(entry.serverNumber[index])){ if (verbose) { fprintf(__stdoutp, ("Not deleting the previous volume %u on server %s, ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index]))); fflush(__stdoutp); } };
4795 } else {
4796 tempconn =
4797 UV_Bind(entry.serverNumber[index],
4798 AFSCONF_VOLUMEPORT7005);
4799
4800 MapPartIdIntoName(entry.serverPartition[index],
4801 apartName);
4802 VPRINT3{ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } }
4803 ("Deleting the previous volume %u on server %s, partition %s ...",{ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } }
4804 pvolid,{ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } }
4805 noresolve ? afs_inet_ntoa_r(entry.serverNumber[index], hoststr) :{ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } }
4806 hostutil_GetNameByINet(entry.serverNumber[index]),{ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } }
4807 apartName){ if (verbose) { fprintf(__stdoutp, ("Deleting the previous volume %u on server %s, partition %s ..."
), (pvolid), (noresolve ? afs_inet_ntoa_r(entry.serverNumber[
index], hoststr) : hostutil_GetNameByINet(entry.serverNumber[
index])), (apartName)); fflush(__stdoutp); } };
4808 code =
4809 AFSVolTransCreate_retry(tempconn, pvolid,
4810 entry.serverPartition[index],
4811 ITOffline1, &temptid);
4812 if (!code) {
4813 code =
4814 AFSVolSetFlags(tempconn, temptid,
4815 VTDeleteOnSalvage1 |
4816 VTOutOfService2);
4817 if (code) {
4818 fprintf(STDERR__stderrp,
4819 "Could not set flags on volume %lu on the older site\n",
4820 (unsigned long)pvolid);
4821 error = code;
4822 goto refail;
4823 }
4824 code = AFSVolDeleteVolume(tempconn, temptid);
4825 if (code) {
4826 fprintf(STDERR__stderrp,
4827 "Could not delete volume %lu on the older site\n",
4828 (unsigned long)pvolid);
4829 error = code;
4830 goto refail;
4831 }
4832 code = AFSVolEndTrans(tempconn, temptid, &rcode);
4833 temptid = 0;
4834 if (!code)
4835 code = rcode;
4836 if (code) {
4837 fprintf(STDERR__stderrp,
4838 "Could not end transaction on volume %lu on the older site\n",
4839 (unsigned long)pvolid);
4840 error = code;
4841 goto refail;
4842 }
4843 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
4844 MapPartIdIntoName(entry.serverPartition[index],
4845 partName);
4846 }
4847 }
4848 }
4849 entry.serverNumber[index] = toserver;
4850 entry.serverPartition[index] = topart;
4851 }
4852
4853 entry.flags |= (flags & RV_RDONLY0x010000) ? RO_EXISTS0x2000 : RW_EXISTS0x1000;
4854 MapNetworkToHost(&entry, &storeEntry);
4855 vcode =
4856 VLDB_ReplaceEntry(pvolid, voltype, &storeEntry,
4857 LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
4858 LOCKREL_TIMESTAMP1);
4859 if (vcode) {
4860 fprintf(STDERR__stderrp,
4861 "Could not update the entry for volume number %lu \n",
4862 (unsigned long)pvolid);
4863 error = vcode;
4864 goto refail;
4865 }
4866 islocked = 0;
4867 if (verbose)
4868 EnumerateEntry(&entry);
4869 }
4870
4871
4872 }
4873 refail:
4874 if (tocall) {
4875 code = rx_EndCall(tocall, rxError);
4876 if (!error)
4877 error = code;
4878 }
4879 if (islocked) {
4880 vcode =
4881 ubik_VL_ReleaseLock(cstruct, 0, pvolid, voltype,
4882 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
4883 if (vcode) {
4884 fprintf(STDERR__stderrp,
4885 "Could not release lock on the VLDB entry for the volume %lu\n",
4886 (unsigned long)pvolid);
4887 if (!error)
4888 error = vcode;
4889 }
4890 }
4891 if (totid) {
4892 code = AFSVolEndTrans(toconn, totid, &rcode);
4893 if (!code)
4894 code = rcode;
4895 if (code) {
4896 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu \n",
4897 (unsigned long)pvolid);
4898 if (!error)
4899 error = code;
4900 }
4901 }
4902 if (temptid) {
4903 code = AFSVolEndTrans(toconn, temptid, &rcode);
4904 if (!code)
4905 code = rcode;
4906 if (code) {
4907 fprintf(STDERR__stderrp, "Could not end transaction on the volume %lu \n",
4908 (unsigned long)pvolid);
4909 if (!error)
4910 error = code;
4911 }
4912 }
4913 if (tempconn)
4914 rx_DestroyConnection(tempconn);
4915 if (toconn)
4916 rx_DestroyConnection(toconn);
4917 PrintError("", error);
4918 return error;
4919}
4920
4921int
4922UV_RestoreVolume(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
4923 char tovolname[], int flags,
4924 afs_int32(*WriteData) (struct rx_call *, void *),
4925 void *rock)
4926{
4927 return UV_RestoreVolume2(toserver, topart, tovolid, 0, tovolname, flags,
4928 WriteData, rock);
4929}
4930
4931
4932/*unlocks the vldb entry associated with <volid> */
4933int
4934UV_LockRelease(afs_uint32 volid)
4935{
4936 afs_int32 vcode;
4937
4938 VPRINT("Binding to the VLDB server\n"){ if (verbose) { fprintf(__stdoutp, ("Binding to the VLDB server\n"
)); fflush(__stdoutp); } };
4939 vcode =
4940 ubik_VL_ReleaseLock(cstruct, 0, volid, -1,
4941 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
4942 if (vcode) {
4943 fprintf(STDERR__stderrp,
4944 "Could not unlock the entry for volume number %lu in VLDB \n",
4945 (unsigned long)volid);
4946 PrintError("", vcode);
4947 return (vcode);
4948 }
4949 VPRINT("VLDB updated\n"){ if (verbose) { fprintf(__stdoutp, ("VLDB updated\n")); fflush
(__stdoutp); } };
4950 return 0;
4951
4952}
4953
4954/* old interface to add rosites */
4955int
4956UV_AddSite(afs_uint32 server, afs_int32 part, afs_uint32 volid,
4957 afs_int32 valid)
4958{
4959 return UV_AddSite2(server, part, volid, 0, valid);
4960}
4961
4962/*adds <server> and <part> as a readonly replication site for <volid>
4963*in vldb */
4964int
4965UV_AddSite2(afs_uint32 server, afs_int32 part, afs_uint32 volid,
4966 afs_uint32 rovolid, afs_int32 valid)
4967{
4968 int j, nro = 0, islocked = 0;
4969 struct nvldbentry entry, storeEntry, entry2;
4970 afs_int32 vcode, error = 0;
4971 char apartName[10];
4972
4973 error = ubik_VL_SetLock(cstruct, 0, volid, RWVOL0, VLOP_ADDSITE0x80);
4974 if (error) {
4975 fprintf(STDERR__stderrp,
4976 " Could not lock the VLDB entry for the volume %lu \n",
4977 (unsigned long)volid);
4978 goto asfail;
4979 }
4980 islocked = 1;
4981
4982 error = VLDB_GetEntryByID(volid, RWVOL0, &entry);
4983 if (error) {
4984 fprintf(STDERR__stderrp,
4985 "Could not fetch the VLDB entry for volume number %lu \n",
4986 (unsigned long)volid);
4987 goto asfail;
4988
4989 }
4990 if (!ISNAMEVALID(entry.name)(strlen(entry.name) < (32 - 9))) {
4991 fprintf(STDERR__stderrp,
4992 "Volume name %s is too long, rename before adding site\n",
4993 entry.name);
4994 error = VOLSERBADOP(1492325131L);
4995 goto asfail;
4996 }
4997 MapHostToNetwork(&entry);
4998
4999 /* See if it's too many entries */
5000 if (entry.nServers >= NMAXNSERVERS13) {
5001 fprintf(STDERR__stderrp, "Total number of entries will exceed %u\n",
5002 NMAXNSERVERS13);
5003 error = VOLSERBADOP(1492325131L);
5004 goto asfail;
5005 }
5006
5007 /* See if it's on the same server */
5008 for (j = 0; j < entry.nServers; j++) {
5009 if (entry.serverFlags[j] & ITSROVOL0x02) {
5010 nro++;
5011 if (VLDB_IsSameAddrs(server, entry.serverNumber[j], &error)) {
5012 if (error) {
5013 fprintf(STDERR__stderrp,
5014 "Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",
5015 server, error);
5016 } else {
5017 MapPartIdIntoName(entry.serverPartition[j], apartName);
5018 fprintf(STDERR__stderrp,
5019 "RO already exists on partition %s. Multiple ROs on a single server aren't allowed\n",
5020 apartName);
5021 error = VOLSERBADOP(1492325131L);
5022 }
5023 goto asfail;
5024 }
5025 }
5026 }
5027
5028 /* See if it's too many RO sites - leave one for the RW */
5029 if (nro >= NMAXNSERVERS13 - 1) {
5030 fprintf(STDERR__stderrp, "Total number of sites will exceed %u\n",
5031 NMAXNSERVERS13 - 1);
5032 error = VOLSERBADOP(1492325131L);
5033 goto asfail;
5034 }
5035
5036 /* if rovolid == 0, we leave the RO volume id alone. If the volume doesn't
5037 * have an RO volid at this point (i.e. entry.volumeId[ROVOL] ==
5038 * INVALID_BID) and we leave it alone, it gets an RO volid at release-time.
5039 */
5040 if (rovolid) {
5041 if (entry.volumeId[ROVOL1] == INVALID_BID0) {
5042 vcode = VLDB_GetEntryByID(rovolid, -1, &entry2);
5043 if (!vcode) {
5044 fprintf(STDERR__stderrp, "Volume ID %d already exists\n", rovolid);
5045 return VVOLEXISTS104;
5046 }
5047 VPRINT1("Using RO volume id %d.\n", rovolid){ if (verbose) { fprintf(__stdoutp, ("Using RO volume id %d.\n"
), (rovolid)); fflush(__stdoutp); } };
5048 entry.volumeId[ROVOL1] = rovolid;
5049 } else {
5050 fprintf(STDERR__stderrp, "Ignoring given RO id %d, since volume already has RO id %d\n",
5051 rovolid, entry.volumeId[ROVOL1]);
5052 }
5053 }
5054
5055 VPRINT("Adding a new site ..."){ if (verbose) { fprintf(__stdoutp, ("Adding a new site ...")
); fflush(__stdoutp); } };
5056 entry.serverNumber[entry.nServers] = server;
5057 entry.serverPartition[entry.nServers] = part;
5058 if (!valid) {
5059 entry.serverFlags[entry.nServers] = (ITSROVOL0x02 | RO_DONTUSE0x20);
5060 } else {
5061 entry.serverFlags[entry.nServers] = (ITSROVOL0x02);
5062 }
5063 entry.nServers++;
5064
5065 MapNetworkToHost(&entry, &storeEntry);
5066 error =
5067 VLDB_ReplaceEntry(volid, RWVOL0, &storeEntry,
5068 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5069 if (error) {
5070 fprintf(STDERR__stderrp, "Could not update entry for volume %lu \n",
5071 (unsigned long)volid);
5072 goto asfail;
5073 }
5074 islocked = 0;
5075 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
5076
5077 asfail:
5078 if (islocked) {
5079 vcode =
5080 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5081 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5082 if (vcode) {
5083 fprintf(STDERR__stderrp,
5084 "Could not release lock on volume entry for %lu \n",
5085 (unsigned long)volid);
5086 PrintError("", vcode);
5087 }
5088 }
5089
5090 PrintError("", error);
5091 return error;
5092}
5093
5094/*removes <server> <part> as read only site for <volid> from the vldb */
5095int
5096UV_RemoveSite(afs_uint32 server, afs_int32 part, afs_uint32 volid)
5097{
5098 afs_int32 vcode;
5099 struct nvldbentry entry, storeEntry;
5100
5101 vcode = ubik_VL_SetLock(cstruct, 0, volid, RWVOL0, VLOP_ADDSITE0x80);
5102 if (vcode) {
5103 fprintf(STDERR__stderrp, " Could not lock the VLDB entry for volume %lu \n",
5104 (unsigned long)volid);
5105 PrintError("", vcode);
5106 return (vcode);
5107 }
5108 vcode = VLDB_GetEntryByID(volid, RWVOL0, &entry);
5109 if (vcode) {
5110 fprintf(STDERR__stderrp,
5111 "Could not fetch the entry for volume number %lu from VLDB \n",
5112 (unsigned long)volid);
5113 PrintError("", vcode);
5114 return (vcode);
5115 }
5116 MapHostToNetwork(&entry);
5117 if (!Lp_ROMatch(server, part, &entry)) {
5118 /*this site doesnot exist */
5119 fprintf(STDERR__stderrp, "This site is not a replication site \n");
5120 vcode =
5121 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5122 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5123 if (vcode) {
5124 fprintf(STDERR__stderrp, "Could not update entry for volume %lu \n",
5125 (unsigned long)volid);
5126 PrintError("", vcode);
5127 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5128 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5129 return (vcode);
5130 }
5131 return VOLSERBADOP(1492325131L);
5132 } else { /*remove the rep site */
5133 Lp_SetROValue(&entry, server, part, 0, 0);
5134 entry.nServers--;
5135 if ((entry.nServers == 1) && (entry.flags & RW_EXISTS0x1000))
5136 entry.flags &= ~RO_EXISTS0x2000;
5137 if (entry.nServers < 1) { /*this is the last ref */
5138 VPRINT1("Deleting the VLDB entry for %u ...", volid){ if (verbose) { fprintf(__stdoutp, ("Deleting the VLDB entry for %u ..."
), (volid)); fflush(__stdoutp); } };
5139 fflush(STDOUT__stdoutp);
5140 vcode = ubik_VL_DeleteEntry(cstruct, 0, volid, ROVOL1);
5141 if (vcode) {
5142 fprintf(STDERR__stderrp,
5143 "Could not delete VLDB entry for volume %lu \n",
5144 (unsigned long)volid);
5145 PrintError("", vcode);
5146 return (vcode);
5147 }
5148 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
5149 }
5150 MapNetworkToHost(&entry, &storeEntry);
5151 fprintf(STDOUT__stdoutp, "Deleting the replication site for volume %lu ...",
5152 (unsigned long)volid);
5153 fflush(STDOUT__stdoutp);
5154 vcode =
5155 VLDB_ReplaceEntry(volid, RWVOL0, &storeEntry,
5156 LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
5157 LOCKREL_TIMESTAMP1);
5158 if (vcode) {
5159 fprintf(STDERR__stderrp,
5160 "Could not release lock on volume entry for %lu \n",
5161 (unsigned long)volid);
5162 PrintError("", vcode);
5163 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5164 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5165 return (vcode);
5166 }
5167 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
5168 }
5169 return 0;
5170}
5171
5172/*sets <server> <part> as read/write site for <volid> in the vldb */
5173int
5174UV_ChangeLocation(afs_uint32 server, afs_int32 part, afs_uint32 volid)
5175{
5176 afs_int32 vcode;
5177 struct nvldbentry entry, storeEntry;
5178 int index;
5179
5180 vcode = ubik_VL_SetLock(cstruct, 0, volid, RWVOL0, VLOP_ADDSITE0x80);
5181 if (vcode) {
5182 fprintf(STDERR__stderrp, " Could not lock the VLDB entry for volume %lu \n",
5183 (unsigned long)volid);
5184 PrintError("", vcode);
5185 return (vcode);
5186 }
5187 vcode = VLDB_GetEntryByID(volid, RWVOL0, &entry);
5188 if (vcode) {
5189 fprintf(STDERR__stderrp,
5190 "Could not fetch the entry for volume number %lu from VLDB \n",
5191 (unsigned long)volid);
5192 PrintError("", vcode);
5193 return (vcode);
5194 }
5195 MapHostToNetwork(&entry);
5196 index = Lp_GetRwIndex(&entry);
5197 if (index < 0) {
5198 /* no RW site exists */
5199 fprintf(STDERR__stderrp, "No existing RW site for volume %lu",
5200 (unsigned long)volid);
5201 vcode =
5202 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5203 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5204 if (vcode) {
5205 fprintf(STDERR__stderrp,
5206 "Could not release lock on entry for volume %lu \n",
5207 (unsigned long)volid);
5208 PrintError("", vcode);
5209 return (vcode);
5210 }
5211 return VOLSERBADOP(1492325131L);
5212 } else { /* change the RW site */
5213 entry.serverNumber[index] = server;
5214 entry.serverPartition[index] = part;
5215 MapNetworkToHost(&entry, &storeEntry);
5216 vcode =
5217 VLDB_ReplaceEntry(volid, RWVOL0, &storeEntry,
5218 LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
5219 LOCKREL_TIMESTAMP1);
5220 if (vcode) {
5221 fprintf(STDERR__stderrp, "Could not update entry for volume %lu \n",
5222 (unsigned long)volid);
5223 PrintError("", vcode);
5224 ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL0,
5225 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
5226 return (vcode);
5227 }
5228 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
5229 }
5230 return 0;
5231}
5232
5233/*list all the partitions on <aserver> */
5234int
5235UV_ListPartitions(afs_uint32 aserver, struct partList *ptrPartList,
5236 afs_int32 * cntp)
5237{
5238 struct rx_connection *aconn;
5239 struct pIDs partIds;
5240 struct partEntries partEnts;
5241 int i, j = 0, code;
5242
5243 *cntp = 0;
5244 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
5245
5246 partEnts.partEntries_len = 0;
5247 partEnts.partEntries_val = NULL((void *)0);
5248 code = AFSVolXListPartitions(aconn, &partEnts); /* this is available only on new servers */
5249 if (code == RXGEN_OPCODE-455) {
5250 for (i = 0; i < 26; i++) /* try old interface */
5251 partIds.partIds[i] = -1;
5252 code = AFSVolListPartitions(aconn, &partIds);
5253 if (!code) {
5254 for (i = 0; i < 26; i++) {
5255 if ((partIds.partIds[i]) != -1) {
5256 ptrPartList->partId[j] = partIds.partIds[i];
5257 ptrPartList->partFlags[j] = PARTVALID0x01;
5258 j++;
5259 } else
5260 ptrPartList->partFlags[i] = 0;
5261 }
5262 *cntp = j;
5263 }
5264 } else if (!code) {
5265 *cntp = partEnts.partEntries_len;
5266 if (*cntp > VOLMAXPARTS255) {
5267 fprintf(STDERR__stderrp,
5268 "Warning: number of partitions on the server too high %d (process only %d)\n",
5269 *cntp, VOLMAXPARTS255);
5270 *cntp = VOLMAXPARTS255;
5271 }
5272 for (i = 0; i < *cntp; i++) {
5273 ptrPartList->partId[i] = partEnts.partEntries_val[i];
5274 ptrPartList->partFlags[i] = PARTVALID0x01;
5275 }
5276 free(partEnts.partEntries_val);
5277 }
5278
5279 /* out: */
5280 if (code)
5281 fprintf(STDERR__stderrp,
5282 "Could not fetch the list of partitions from the server\n");
5283 PrintError("", code);
5284 if (aconn)
5285 rx_DestroyConnection(aconn);
5286 return code;
5287}
5288
5289
5290/*zap the list of volumes specified by volPtrArray (the volCloneId field).
5291 This is used by the backup system */
5292int
5293UV_ZapVolumeClones(afs_uint32 aserver, afs_int32 apart,
5294 struct volDescription *volPtr, afs_int32 arraySize)
5295{
5296 struct rx_connection *aconn;
5297 struct volDescription *curPtr;
5298 int curPos;
5299 afs_int32 code = 0;
5300 afs_int32 rcode = 0;
5301 afs_int32 success = 1;
5302 afs_int32 tid;
5303
5304 aconn = (struct rx_connection *)0;
5305 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
5306 curPos = 0;
5307 for (curPtr = volPtr; curPos < arraySize; curPtr++) {
5308 if (curPtr->volFlags & CLONEVALID0x02) {
5309 curPtr->volFlags &= ~CLONEZAPPED0x04;
5310 success = 1;
5311 code =
5312 AFSVolTransCreate_retry(aconn, curPtr->volCloneId, apart, ITOffline1,
5313 &tid);
5314 if (code)
5315 success = 0;
5316 else {
5317 code = AFSVolDeleteVolume(aconn, tid);
5318 if (code)
5319 success = 0;
5320 code = AFSVolEndTrans(aconn, tid, &rcode);
5321 if (code || rcode)
5322 success = 0;
5323 }
5324 if (success)
5325 curPtr->volFlags |= CLONEZAPPED0x04;
5326 if (!success)
5327 fprintf(STDERR__stderrp, "Could not zap volume %lu\n",
5328 (unsigned long)curPtr->volCloneId);
5329 if (success)
5330 VPRINT2("Clone of %s %u deleted\n", curPtr->volName,{ if (verbose) { fprintf(__stdoutp, ("Clone of %s %u deleted\n"
), (curPtr->volName), (curPtr->volCloneId)); fflush(__stdoutp
); } }
5331 curPtr->volCloneId){ if (verbose) { fprintf(__stdoutp, ("Clone of %s %u deleted\n"
), (curPtr->volName), (curPtr->volCloneId)); fflush(__stdoutp
); } };
5332 curPos++;
5333 tid = 0;
5334 }
5335 }
5336 if (aconn)
5337 rx_DestroyConnection(aconn);
5338 return 0;
5339}
5340
5341/*return a list of clones of the volumes specified by volPtrArray. Used by the
5342 backup system */
5343int
5344UV_GenerateVolumeClones(afs_uint32 aserver, afs_int32 apart,
5345 struct volDescription *volPtr, afs_int32 arraySize)
5346{
5347 struct rx_connection *aconn;
5348 struct volDescription *curPtr;
5349 int curPos;
5350 afs_int32 code = 0;
5351 afs_int32 rcode = 0;
5352 afs_int32 tid;
5353 int reuseCloneId = 0;
5354 afs_uint32 curCloneId = 0;
5355 char cloneName[256]; /*max vol name */
5356
5357 aconn = (struct rx_connection *)0;
5358 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
5359 curPos = 0;
5360 if ((volPtr->volFlags & REUSECLONEID0x80) && (volPtr->volFlags & ENTRYVALID0x40))
5361 reuseCloneId = 1;
5362 else { /*get a bunch of id's from vldb */
5363 code =
5364 ubik_VL_GetNewVolumeId(cstruct, 0, arraySize, &curCloneId);
5365 if (code) {
5366 fprintf(STDERR__stderrp, "Could not get ID's for the clone from VLDB\n");
5367 PrintError("", code);
5368 return code;
5369 }
5370 }
5371
5372 for (curPtr = volPtr; curPos < arraySize; curPtr++) {
5373 if (curPtr->volFlags & ENTRYVALID0x40) {
5374
5375 curPtr->volFlags |= CLONEVALID0x02;
5376 /*make a clone of curParentId and record as curPtr->volCloneId */
5377 code =
5378 AFSVolTransCreate_retry(aconn, curPtr->volId, apart, ITOffline1,
5379 &tid);
5380 if (code)
5381 VPRINT2("Clone for volume %s %u failed \n", curPtr->volName,{ if (verbose) { fprintf(__stdoutp, ("Clone for volume %s %u failed \n"
), (curPtr->volName), (curPtr->volId)); fflush(__stdoutp
); } }
5382 curPtr->volId){ if (verbose) { fprintf(__stdoutp, ("Clone for volume %s %u failed \n"
), (curPtr->volName), (curPtr->volId)); fflush(__stdoutp
); } };
5383 if (code) {
5384 curPtr->volFlags &= ~CLONEVALID0x02; /*cant clone */
5385 curPos++;
5386 continue;
5387 }
5388 if (strlen(curPtr->volName) < (VOLSER_OLDMAXVOLNAME32 - 9)) {
5389 strcpy(cloneName, curPtr->volName);
5390 strcat(cloneName, "-tmpClone-");
5391 } else
5392 strcpy(cloneName, "-tmpClone");
5393 if (reuseCloneId) {
5394 curPtr->volCloneId = curCloneId;
5395 curCloneId++;
5396 }
5397
5398 code =
5399 AFSVolClone(aconn, tid, 0, readonlyVolume1, cloneName,
5400 &(curPtr->volCloneId));
5401 if (code) {
5402 curPtr->volFlags &= ~CLONEVALID0x02;
5403 curPos++;
5404 fprintf(STDERR__stderrp, "Could not clone %s due to error %lu\n",
5405 curPtr->volName, (unsigned long)code);
5406 code = AFSVolEndTrans(aconn, tid, &rcode);
5407 if (code)
5408 fprintf(STDERR__stderrp, "WARNING: could not end transaction\n");
5409 continue;
5410 }
5411 VPRINT2("********** Cloned %s temporary %u\n", cloneName,{ if (verbose) { fprintf(__stdoutp, ("********** Cloned %s temporary %u\n"
), (cloneName), (curPtr->volCloneId)); fflush(__stdoutp); }
}
5412 curPtr->volCloneId){ if (verbose) { fprintf(__stdoutp, ("********** Cloned %s temporary %u\n"
), (cloneName), (curPtr->volCloneId)); fflush(__stdoutp); }
};
5413 code = AFSVolEndTrans(aconn, tid, &rcode);
5414 if (code || rcode) {
5415 curPtr->volFlags &= ~CLONEVALID0x02;
5416 curPos++;
5417 continue;
5418 }
5419
5420 curPos++;
5421 }
5422 }
5423 if (aconn)
5424 rx_DestroyConnection(aconn);
5425 return 0;
5426}
5427
5428
5429/*list all the volumes on <aserver> and <apart>. If all = 1, then all the
5430* relevant fields of the volume are also returned. This is a heavy weight operation.*/
5431int
5432UV_ListVolumes(afs_uint32 aserver, afs_int32 apart, int all,
5433 struct volintInfo **resultPtr, afs_int32 * size)
5434{
5435 struct rx_connection *aconn;
5436 afs_int32 code = 0;
5437 volEntries volumeInfo;
5438
5439 code = 0;
5440 *size = 0;
5441 *resultPtr = (volintInfo *) 0;
5442 volumeInfo.volEntries_val = (volintInfo *) 0; /*this hints the stub to allocate space */
5443 volumeInfo.volEntries_len = 0;
5444
5445 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
5446 code = AFSVolListVolumes(aconn, apart, all, &volumeInfo);
5447 if (code) {
5448 fprintf(STDERR__stderrp,
5449 "Could not fetch the list of volumes from the server\n");
5450 } else {
5451 *resultPtr = volumeInfo.volEntries_val;
5452 *size = volumeInfo.volEntries_len;
5453 }
5454
5455 if (aconn)
5456 rx_DestroyConnection(aconn);
5457 PrintError("", code);
5458 return code;
5459}
5460
5461/*------------------------------------------------------------------------
5462 * EXPORTED UV_XListVolumes
5463 *
5464 * Description:
5465 * List the extended information for all the volumes on a particular
5466 * File Server and partition. We may either return the volume's ID
5467 * or all of its extended information.
5468 *
5469 * Arguments:
5470 * a_serverID : Address of the File Server for which we want
5471 * extended volume info.
5472 * a_partID : Partition for which we want the extended
5473 * volume info.
5474 * a_all : If non-zero, fetch ALL the volume info,
5475 * otherwise just the volume ID.
5476 * a_resultPP : Ptr to the address of the area containing
5477 * the returned volume info.
5478 * a_numEntsInResultP : Ptr for the value we set for the number of
5479 * entries returned.
5480 *
5481 * Returns:
5482 * 0 on success,
5483 * Otherise, the return value of AFSVolXListVolumes.
5484 *
5485 * Environment:
5486 * This routine is closely related to UV_ListVolumes, which returns
5487 * only the standard level of detail on AFS volumes. It is a
5488 * heavyweight operation, zipping through all the volume entries for
5489 * a given server/partition.
5490 *
5491 * Side Effects:
5492 * As advertised.
5493 *------------------------------------------------------------------------*/
5494
5495int
5496UV_XListVolumes(afs_uint32 a_serverID, afs_int32 a_partID, int a_all,
5497 struct volintXInfo **a_resultPP,
5498 afs_int32 * a_numEntsInResultP)
5499{
5500 struct rx_connection *rxConnP; /*Ptr to the Rx connection involved */
5501 afs_int32 code; /*Error code to return */
5502 volXEntries volumeXInfo; /*Area for returned extended vol info */
5503
5504 /*
5505 * Set up our error code and the area for returned extended volume info.
5506 * We set the val field to a null pointer as a hint for the stub to
5507 * allocate space.
5508 */
5509 code = 0;
5510 *a_numEntsInResultP = 0;
5511 *a_resultPP = (volintXInfo *) 0;
5512 volumeXInfo.volXEntries_val = (volintXInfo *) 0;
5513 volumeXInfo.volXEntries_len = 0;
5514
5515 /*
5516 * Bind to the Volume Server port on the File Server machine in question,
5517 * then go for it.
5518 */
5519 rxConnP = UV_Bind(a_serverID, AFSCONF_VOLUMEPORT7005);
5520 code = AFSVolXListVolumes(rxConnP, a_partID, a_all, &volumeXInfo);
5521 if (code)
5522 fprintf(STDERR__stderrp, "[UV_XListVolumes] Couldn't fetch volume list\n");
5523 else {
5524 /*
5525 * We got the info; pull out the pointer to where the results lie
5526 * and how many entries are there.
5527 */
5528 *a_resultPP = volumeXInfo.volXEntries_val;
5529 *a_numEntsInResultP = volumeXInfo.volXEntries_len;
5530 }
5531
5532 /*
5533 * If we got an Rx connection, throw it away.
5534 */
5535 if (rxConnP)
5536 rx_DestroyConnection(rxConnP);
5537
5538 PrintError("", code);
5539 return (code);
5540} /*UV_XListVolumes */
5541
5542/* get all the information about volume <volid> on <aserver> and <apart> */
5543int
5544UV_ListOneVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 volid,
5545 struct volintInfo **resultPtr)
5546{
5547 struct rx_connection *aconn;
5548 afs_int32 code = 0;
5549 volEntries volumeInfo;
5550
5551 code = 0;
5552
5553 *resultPtr = (volintInfo *) 0;
5554 volumeInfo.volEntries_val = (volintInfo *) 0; /*this hints the stub to allocate space */
5555 volumeInfo.volEntries_len = 0;
5556
5557 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
5558 code = AFSVolListOneVolume(aconn, apart, volid, &volumeInfo);
5559 if (code) {
5560 fprintf(STDERR__stderrp,
5561 "Could not fetch the information about volume %lu from the server\n",
5562 (unsigned long)volid);
5563 } else {
5564 *resultPtr = volumeInfo.volEntries_val;
5565
5566 }
5567
5568 if (aconn)
5569 rx_DestroyConnection(aconn);
5570 PrintError("", code);
5571 return code;
5572}
5573
5574/*------------------------------------------------------------------------
5575 * EXPORTED UV_XListOneVolume
5576 *
5577 * Description:
5578 * List the extended information for a volume on a particular File
5579 * Server and partition.
5580 *
5581 * Arguments:
5582 * a_serverID : Address of the File Server for which we want
5583 * extended volume info.
5584 * a_partID : Partition for which we want the extended
5585 * volume info.
5586 * a_volID : Volume ID for which we want the info.
5587 * a_resultPP : Ptr to the address of the area containing
5588 * the returned volume info.
5589 *
5590 * Returns:
5591 * 0 on success,
5592 * Otherise, the return value of AFSVolXListOneVolume.
5593 *
5594 * Environment:
5595 * This routine is closely related to UV_ListOneVolume, which returns
5596 * only the standard level of detail on the chosen AFS volume.
5597 *
5598 * Side Effects:
5599 * As advertised.
5600 *------------------------------------------------------------------------*/
5601
5602int
5603UV_XListOneVolume(afs_uint32 a_serverID, afs_int32 a_partID, afs_uint32 a_volID,
5604 struct volintXInfo **a_resultPP)
5605{
5606 struct rx_connection *rxConnP; /*Rx connection to Volume Server */
5607 afs_int32 code; /*Error code */
5608 volXEntries volumeXInfo; /*Area for returned info */
5609
5610 /*
5611 * Set up our error code, and the area we're in which we are returning
5612 * the info. Setting the val field to a null pointer tells the stub
5613 * to allocate space for us.
5614 */
5615 code = 0;
5616 *a_resultPP = (volintXInfo *) 0;
5617 volumeXInfo.volXEntries_val = (volintXInfo *) 0;
5618 volumeXInfo.volXEntries_len = 0;
5619
5620 /*
5621 * Bind to the Volume Server port on the File Server machine in question,
5622 * then go for it.
5623 */
5624 rxConnP = UV_Bind(a_serverID, AFSCONF_VOLUMEPORT7005);
5625 code = AFSVolXListOneVolume(rxConnP, a_partID, a_volID, &volumeXInfo);
5626 if (code)
5627 fprintf(STDERR__stderrp,
5628 "[UV_XListOneVolume] Couldn't fetch the volume information\n");
5629 else
5630 /*
5631 * We got the info; pull out the pointer to where the results lie.
5632 */
5633 *a_resultPP = volumeXInfo.volXEntries_val;
5634
5635 /*
5636 * If we got an Rx connection, throw it away.
5637 */
5638 if (rxConnP)
5639 rx_DestroyConnection(rxConnP);
5640
5641 PrintError("", code);
5642 return code;
5643}
5644
5645/* CheckVolume()
5646 * Given a volume we read from a partition, check if it is
5647 * represented in the VLDB correctly.
5648 *
5649 * The VLDB is looked up by the RW volume id (not its name).
5650 * The RW contains the true name of the volume (BK and RO set
5651 * the name in the VLDB only on creation of the VLDB entry).
5652 * We want rules strict enough that when we check all volumes
5653 * on one partition, it does not need to be done again. IE:
5654 * two volumes on different partitions won't constantly
5655 * change a VLDB entry away from what the other set.
5656 * For RW and BK volumes, we will always check the VLDB to see
5657 * if the two exist on the server/partition. May seem redundant,
5658 * but this is an easy check of the VLDB. IE: if the VLDB entry
5659 * says the BK exists but no BK volume is there, we will detect
5660 * this when we check the RW volume.
5661 * VLDB entries are locked only when a change needs to be done.
5662 * Output changed to look a lot like the "vos syncserv" otuput.
5663 */
5664static afs_int32
5665CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
5666 afs_int32 * modentry, afs_uint32 * maxvolid,
5667 struct nvldbentry *aentry)
5668{
5669 int idx = 0;
5670 int j;
5671 afs_int32 code, error = 0;
5672 struct nvldbentry entry, storeEntry;
5673 char pname[10];
5674 int pass = 0, createentry, addvolume, modified, mod, doit = 1;
5675 afs_uint32 rwvolid;
5676 char hoststr[16];
5677
5678 if (modentry) {
5679 if (*modentry == 1)
5680 doit = 0;
5681 *modentry = 0;
5682 }
5683 rwvolid =
5684 ((volumeinfo->type ==
5685 RWVOL0) ? volumeinfo->volid : volumeinfo->parentID);
5686
5687 retry:
5688 /* Check to see if the VLDB is ok without locking it (pass 1).
5689 * If it will change, then lock the VLDB entry, read it again,
5690 * then make the changes to it (pass 2).
5691 */
5692 if (++pass == 2) {
5693 code = ubik_VL_SetLock(cstruct, 0, rwvolid, RWVOL0, VLOP_DELETE0x80);
5694 if (code) {
5695 fprintf(STDERR__stderrp, "Could not lock VLDB entry for %lu\n",
5696 (unsigned long)rwvolid);
5697 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5698 }
5699 }
5700
5701 createentry = 0; /* Do we need to create a VLDB entry */
5702 addvolume = 0; /* Add this volume to the VLDB entry */
5703 modified = 0; /* The VLDB entry was modified */
5704
5705 if (aentry) {
5706 memcpy(&entry, aentry, sizeof(entry));
5707 } else {
5708 /* Read the entry from VLDB by its RW volume id */
5709 code = VLDB_GetEntryByID(rwvolid, RWVOL0, &entry);
5710 if (code) {
5711 if (code != VL_NOENT(363524L)) {
5712 fprintf(STDOUT__stdoutp,
5713 "Could not retreive the VLDB entry for volume %lu \n",
5714 (unsigned long)rwvolid);
5715 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5716 }
5717
5718 memset(&entry, 0, sizeof(entry));
5719 vsu_ExtractName(entry.name, volumeinfo->name); /* Store name of RW */
5720
5721 createentry = 1;
5722 } else {
5723 MapHostToNetwork(&entry);
5724 }
5725 }
5726
5727 if (verbose && (pass == 1)) {
5728 fprintf(STDOUT__stdoutp, "_______________________________\n");
5729 fprintf(STDOUT__stdoutp, "\n-- status before -- \n");
5730 if (createentry) {
5731 fprintf(STDOUT__stdoutp, "\n**does not exist**\n");
5732 } else {
5733 if ((entry.flags & RW_EXISTS0x1000) || (entry.flags & RO_EXISTS0x2000)
5734 || (entry.flags & BACK_EXISTS0x4000))
5735 EnumerateEntry(&entry);
5736 }
5737 fprintf(STDOUT__stdoutp, "\n");
5738 }
5739
5740 if (volumeinfo->type == RWVOL0) { /* RW volume exists */
5741 if (createentry) {
5742 idx = 0;
5743 entry.nServers = 1;
5744 addvolume++;
5745 } else {
5746 /* Check existence of RW and BK volumes */
5747 code = CheckVldbRWBK(&entry, &mod);
5748 if (code)
5749 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5750 if (mod)
5751 modified++;
5752
5753 idx = Lp_GetRwIndex(&entry);
5754 if (idx == -1) { /* RW index not found in the VLDB entry */
5755 idx = entry.nServers; /* put it into next index */
5756 entry.nServers++;
5757 addvolume++;
5758 } else { /* RW index found in the VLDB entry. */
5759 /* Verify if this volume's location matches where the VLDB says it is */
5760 if (!Lp_Match(aserver, apart, &entry)) {
5761 if (entry.flags & RW_EXISTS0x1000) {
5762 /* The RW volume exists elsewhere - report this one a duplicate */
5763 if (pass == 1) {
5764 MapPartIdIntoName(apart, pname);
5765 fprintf(STDERR__stderrp,
5766 "*** Warning: Orphaned RW volume %lu exists on %s %s\n",
5767 (unsigned long)rwvolid,
5768 noresolve ?
5769 afs_inet_ntoa_r(aserver, hoststr) :
5770 hostutil_GetNameByINet(aserver), pname);
5771 MapPartIdIntoName(entry.serverPartition[idx],
5772 pname);
5773 fprintf(STDERR__stderrp,
5774 " VLDB reports RW volume %lu exists on %s %s\n",
5775 (unsigned long)rwvolid,
5776 noresolve ?
5777 afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
5778 hostutil_GetNameByINet(entry.
5779 serverNumber[idx]),
5780 pname);
5781 }
5782 } else {
5783 /* The RW volume does not exist - have VLDB point to this one */
5784 addvolume++;
5785
5786 /* Check for orphaned BK volume on old partition */
5787 if (entry.flags & BACK_EXISTS0x4000) {
5788 if (pass == 1) {
5789 MapPartIdIntoName(entry.serverPartition[idx],
5790 pname);
5791 fprintf(STDERR__stderrp,
5792 "*** Warning: Orphaned BK volume %u exists on %s %s\n",
5793 entry.volumeId[BACKVOL2],
5794 noresolve ?
5795 afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
5796 hostutil_GetNameByINet(entry.
5797 serverNumber
5798 [idx]), pname);
5799 MapPartIdIntoName(apart, pname);
5800 fprintf(STDERR__stderrp,
5801 " VLDB reports its RW volume %lu exists on %s %s\n",
5802 (unsigned long)rwvolid,
5803 noresolve ?
5804 afs_inet_ntoa_r(aserver, hoststr) :
5805 hostutil_GetNameByINet(aserver),
5806 pname);
5807 }
5808 }
5809 }
5810 } else {
5811 /* Volume location matches the VLDB location */
5812 if ((volumeinfo->backupID && !entry.volumeId[BACKVOL2])
5813 || (volumeinfo->cloneID && !entry.volumeId[ROVOL1])
5814 ||
5815 (strncmp
5816 (entry.name, volumeinfo->name,
5817 VOLSER_OLDMAXVOLNAME32) != 0)) {
5818 addvolume++;
5819 }
5820 }
5821 }
5822 }
5823
5824 if (addvolume) {
5825 entry.flags |= RW_EXISTS0x1000;
5826 entry.volumeId[RWVOL0] = rwvolid;
5827 if (!entry.volumeId[BACKVOL2])
5828 entry.volumeId[BACKVOL2] = volumeinfo->backupID;
5829 if (!entry.volumeId[ROVOL1])
5830 entry.volumeId[ROVOL1] = volumeinfo->cloneID;
5831
5832 entry.serverFlags[idx] = ITSRWVOL0x04;
5833 entry.serverNumber[idx] = aserver;
5834 entry.serverPartition[idx] = apart;
5835 strncpy(entry.name, volumeinfo->name, VOLSER_OLDMAXVOLNAME32);
5836
5837 modified++;
5838
5839 /* One last check - to update BK if need to */
5840 code = CheckVldbRWBK(&entry, &mod);
5841 if (code)
5842 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5843 if (mod)
5844 modified++;
5845 }
5846 }
5847
5848 else if (volumeinfo->type == BACKVOL2) { /* A BK volume */
5849 if (createentry) {
5850 idx = 0;
5851 entry.nServers = 1;
5852 addvolume++;
5853 } else {
5854 /* Check existence of RW and BK volumes */
5855 code = CheckVldbRWBK(&entry, &mod);
5856 if (code)
5857 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5858 if (mod)
5859 modified++;
5860
5861 idx = Lp_GetRwIndex(&entry);
5862 if (idx == -1) { /* RW index not found in the VLDB entry */
5863 idx = entry.nServers; /* Put it into next index */
5864 entry.nServers++;
5865 addvolume++;
5866 } else { /* RW index found in the VLDB entry */
5867 /* Verify if this volume's location matches where the VLDB says it is */
5868 if (!Lp_Match(aserver, apart, &entry)) {
5869 /* VLDB says RW and/or BK is elsewhere - report this BK volume orphaned */
5870 if (pass == 1) {
5871 MapPartIdIntoName(apart, pname);
5872 fprintf(STDERR__stderrp,
5873 "*** Warning: Orphaned BK volume %lu exists on %s %s\n",
5874 (unsigned long)volumeinfo->volid,
5875 noresolve ?
5876 afs_inet_ntoa_r(aserver, hoststr) :
5877 hostutil_GetNameByINet(aserver), pname);
5878 MapPartIdIntoName(entry.serverPartition[idx], pname);
5879 fprintf(STDERR__stderrp,
5880 " VLDB reports its RW/BK volume %lu exists on %s %s\n",
5881 (unsigned long)rwvolid,
5882 noresolve ?
5883 afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
5884 hostutil_GetNameByINet(entry.
5885 serverNumber[idx]),
5886 pname);
5887 }
5888 } else {
5889 if (volumeinfo->volid != entry.volumeId[BACKVOL2]) {
5890 if (!(entry.flags & BACK_EXISTS0x4000)) {
5891 addvolume++;
5892 } else if (volumeinfo->volid >
5893 entry.volumeId[BACKVOL2]) {
5894 addvolume++;
5895
5896 if (pass == 1) {
5897 MapPartIdIntoName(entry.serverPartition[idx],
5898 pname);
5899 fprintf(STDERR__stderrp,
5900 "*** Warning: Orphaned BK volume %u exists on %s %s\n",
5901 entry.volumeId[BACKVOL2],
5902 noresolve ?
5903 afs_inet_ntoa_r(aserver, hoststr) :
5904 hostutil_GetNameByINet(aserver),
5905 pname);
5906 fprintf(STDERR__stderrp,
5907 " VLDB reports its BK volume ID is %lu\n",
5908 (unsigned long)volumeinfo->volid);
5909 }
5910 } else {
5911 if (pass == 1) {
5912 MapPartIdIntoName(entry.serverPartition[idx],
5913 pname);
5914 fprintf(STDERR__stderrp,
5915 "*** Warning: Orphaned BK volume %lu exists on %s %s\n",
5916 (unsigned long)volumeinfo->volid,
5917 noresolve ?
5918 afs_inet_ntoa_r(aserver, hoststr) :
5919 hostutil_GetNameByINet(aserver),
5920 pname);
5921 fprintf(STDERR__stderrp,
5922 " VLDB reports its BK volume ID is %u\n",
5923 entry.volumeId[BACKVOL2]);
5924 }
5925 }
5926 } else if (!entry.volumeId[BACKVOL2]) {
5927 addvolume++;
5928 }
5929 }
5930 }
5931 }
5932 if (addvolume) {
5933 entry.flags |= BACK_EXISTS0x4000;
5934 entry.volumeId[RWVOL0] = rwvolid;
5935 entry.volumeId[BACKVOL2] = volumeinfo->volid;
5936
5937 entry.serverNumber[idx] = aserver;
5938 entry.serverPartition[idx] = apart;
5939 entry.serverFlags[idx] = ITSBACKVOL0x08;
5940
5941 modified++;
5942 }
5943 }
5944
5945 else if (volumeinfo->type == ROVOL1) { /* A RO volume */
5946 if (volumeinfo->volid == entry.volumeId[ROVOL1]) {
5947 /* This is a quick check to see if the RO entry exists in the
5948 * VLDB so we avoid the CheckVldbRO() call (which checks if each
5949 * RO volume listed in the VLDB exists).
5950 */
5951 idx = Lp_ROMatch(aserver, apart, &entry) - 1;
5952 if (idx == -1) {
5953 idx = entry.nServers;
5954 entry.nServers++;
5955 addvolume++;
5956 } else {
5957 if (!(entry.flags & RO_EXISTS0x2000)) {
5958 addvolume++;
5959 }
5960 }
5961 } else {
5962 /* Before we correct the VLDB entry, make sure all the
5963 * ROs listed in the VLDB exist.
5964 */
5965 code = CheckVldbRO(&entry, &mod);
5966 if (code)
5967 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
5968 if (mod)
5969 modified++;
5970
5971 if (!(entry.flags & RO_EXISTS0x2000)) {
5972 /* No RO exists in the VLDB entry - add this one */
5973 idx = entry.nServers;
5974 entry.nServers++;
5975 addvolume++;
5976 } else if (volumeinfo->volid > entry.volumeId[ROVOL1]) {
5977 /* The volume headers's RO ID does not match that in the VLDB entry,
5978 * and the vol hdr's ID is greater (implies more recent). So delete
5979 * all the RO volumes listed in VLDB entry and add this volume.
5980 */
5981 for (j = 0; j < entry.nServers; j++) {
5982 if (entry.serverFlags[j] & ITSROVOL0x02) {
5983 /* Verify this volume exists and print message we are orphaning it */
5984 if (pass == 1) {
5985 MapPartIdIntoName(apart, pname);
5986 fprintf(STDERR__stderrp,
5987 "*** Warning: Orphaned RO volume %u exists on %s %s\n",
5988 entry.volumeId[ROVOL1],
5989 noresolve ?
5990 afs_inet_ntoa_r(entry.serverNumber[j], hoststr) :
5991 hostutil_GetNameByINet(entry.
5992 serverNumber[j]),
5993 pname);
5994 fprintf(STDERR__stderrp,
5995 " VLDB reports its RO volume ID is %lu\n",
5996 (unsigned long)volumeinfo->volid);
5997 }
5998
5999 Lp_SetRWValue(&entry, entry.serverNumber[idx],
6000 entry.serverPartition[idx], 0L, 0L);
6001 entry.nServers--;
6002 modified++;
6003 j--;
6004 }
6005 }
6006
6007 idx = entry.nServers;
6008 entry.nServers++;
6009 addvolume++;
6010 } else if (volumeinfo->volid < entry.volumeId[ROVOL1]) {
6011 /* The volume headers's RO ID does not match that in the VLDB entry,
6012 * and the vol hdr's ID is lower (implies its older). So orphan it.
6013 */
6014 if (pass == 1) {
6015 MapPartIdIntoName(apart, pname);
6016 fprintf(STDERR__stderrp,
6017 "*** Warning: Orphaned RO volume %lu exists on %s %s\n",
6018 (unsigned long)volumeinfo->volid,
6019 noresolve ?
6020 afs_inet_ntoa_r(aserver, hoststr) :
6021 hostutil_GetNameByINet(aserver), pname);
6022 fprintf(STDERR__stderrp,
6023 " VLDB reports its RO volume ID is %u\n",
6024 entry.volumeId[ROVOL1]);
6025 }
6026 } else {
6027 /* The RO volume ID in the volume header match that in the VLDB entry,
6028 * and there exist RO volumes in the VLDB entry. See if any of them
6029 * are this one. If not, then we add it.
6030 */
6031 idx = Lp_ROMatch(aserver, apart, &entry) - 1;
6032 if (idx == -1) {
6033 idx = entry.nServers;
6034 entry.nServers++;
6035 addvolume++;
6036 }
6037 }
6038 }
6039
6040 if (addvolume) {
6041 entry.flags |= RO_EXISTS0x2000;
6042 entry.volumeId[RWVOL0] = rwvolid;
6043 entry.volumeId[ROVOL1] = volumeinfo->volid;
6044
6045 entry.serverNumber[idx] = aserver;
6046 entry.serverPartition[idx] = apart;
6047 entry.serverFlags[idx] = ITSROVOL0x02;
6048
6049 modified++;
6050 }
6051 }
6052
6053 /* Remember largest volume id */
6054 if (entry.volumeId[ROVOL1] > *maxvolid)
6055 *maxvolid = entry.volumeId[ROVOL1];
6056 if (entry.volumeId[BACKVOL2] > *maxvolid)
6057 *maxvolid = entry.volumeId[BACKVOL2];
6058 if (entry.volumeId[RWVOL0] > *maxvolid)
6059 *maxvolid = entry.volumeId[RWVOL0];
6060
6061 if (modified && doit) {
6062 MapNetworkToHost(&entry, &storeEntry);
6063
6064 if (createentry) {
6065 code = VLDB_CreateEntry(&storeEntry);
6066 if (code) {
6067 fprintf(STDOUT__stdoutp,
6068 "Could not create a VLDB entry for the volume %lu\n",
6069 (unsigned long)rwvolid);
6070 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6071 }
6072 } else {
6073 if (pass == 1)
6074 goto retry;
6075 code =
6076 VLDB_ReplaceEntry(rwvolid, RWVOL0, &storeEntry,
6077 LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
6078 LOCKREL_TIMESTAMP1);
6079 if (code) {
6080 fprintf(STDERR__stderrp, "Could not update entry for %lu\n",
6081 (unsigned long)rwvolid);
6082 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6083 }
6084 }
6085 } else if (pass == 2) {
6086 code =
6087 ubik_VL_ReleaseLock(cstruct, 0, rwvolid, RWVOL0,
6088 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
6089 if (code) {
6090 PrintError("Could not unlock VLDB entry ", code);
6091 }
6092 }
6093
6094 if (modified && modentry) {
6095 *modentry = 1;
6096 }
6097
6098 if (aentry) {
6099 memcpy(aentry, &entry, sizeof(entry));
6100 }
6101
6102 if (verbose) {
6103 fprintf(STDOUT__stdoutp, "-- status after --\n");
6104 if (modified)
6105 EnumerateEntry(&entry);
6106 else
6107 fprintf(STDOUT__stdoutp, "\n**no change**\n");
6108 }
6109
6110 error_exit:
6111 VPRINT("\n_______________________________\n"){ if (verbose) { fprintf(__stdoutp, ("\n_______________________________\n"
)); fflush(__stdoutp); } };
6112 return (error);
6113}
6114
6115static int
6116sortVolumes(const void *a, const void *b)
6117{
6118 volintInfo *v1 = (volintInfo *) a;
6119 volintInfo *v2 = (volintInfo *) b;
6120 afs_uint32 rwvolid1, rwvolid2;
6121
6122 rwvolid1 = ((v1->type == RWVOL0) ? v1->volid : v1->parentID);
6123 rwvolid2 = ((v2->type == RWVOL0) ? v2->volid : v2->parentID);
6124
6125 if (rwvolid1 > rwvolid2)
6126 return -1; /* lower RW id goes first */
6127 if (rwvolid1 < rwvolid2)
6128 return 1;
6129
6130 if (v1->type == RWVOL0)
6131 return -1; /* RW vols go first */
6132 if (v2->type == RWVOL0)
6133 return 1;
6134
6135 if ((v1->type == BACKVOL2) && (v2->type == ROVOL1))
6136 return -1; /* BK vols next */
6137 if ((v1->type == ROVOL1) && (v2->type == BACKVOL2))
6138 return 1;
6139
6140 if (v1->volid < v2->volid)
6141 return 1; /* larger volids first */
6142 if (v1->volid > v2->volid)
6143 return -1;
6144 return 0;
6145}
6146
6147/* UV_SyncVolume()
6148 * Synchronise <aserver> <apart>(if flags = 1) <avolid>.
6149 * Synchronize an individual volume against a sever and partition.
6150 * Checks the VLDB entry (similar to syncserv) as well as checks
6151 * if the volume exists on specified servers (similar to syncvldb).
6152 */
6153int
6154UV_SyncVolume(afs_uint32 aserver, afs_int32 apart, char *avolname, int flags)
6155{
6156 struct rx_connection *aconn = 0;
6157 afs_int32 j, k, code, vcode, error = 0;
6158 afs_int32 tverbose;
6159 afs_int32 mod, modified = 0, deleted = 0;
6160 struct nvldbentry vldbentry;
6161 afs_uint32 volumeid = 0;
6162 volEntries volumeInfo;
6163 struct partList PartList;
6164 afs_int32 pcnt;
6165 afs_uint32 maxvolid = 0;
6166
6167 volumeInfo.volEntries_val = (volintInfo *) 0;
6168 volumeInfo.volEntries_len = 0;
6169
6170 /* Turn verbose logging off and do our own verbose logging */
6171 /* tverbose must be set before we call ERROR_EXIT() */
6172
6173 tverbose = verbose;
6174 if (flags & 2)
6175 tverbose = 1;
6176 verbose = 0;
6177
6178 if (!aserver && (flags & 1)) {
6179 /* fprintf(STDERR,"Partition option requires a server option\n"); */
6180 ERROR_EXIT(EINVAL)do { error = (22); goto error_exit; } while (0);
6181 }
6182
6183 /* Read the VLDB entry */
6184 vcode = VLDB_GetEntryByName(avolname, &vldbentry);
6185 if (vcode && (vcode != VL_NOENT(363524L))) {
6186 fprintf(STDERR__stderrp, "Could not access the VLDB for volume %s\n",
6187 avolname);
6188 ERROR_EXIT(vcode)do { error = (vcode); goto error_exit; } while (0);
6189 } else if (!vcode) {
6190 MapHostToNetwork(&vldbentry);
6191 }
6192
6193 if (tverbose) {
6194 fprintf(STDOUT__stdoutp, "Processing VLDB entry %s ...\n", avolname);
6195 fprintf(STDOUT__stdoutp, "_______________________________\n");
6196 fprintf(STDOUT__stdoutp, "\n-- status before -- \n");
6197 if (vcode) {
6198 fprintf(STDOUT__stdoutp, "\n**does not exist**\n");
6199 } else {
6200 if ((vldbentry.flags & RW_EXISTS0x1000) || (vldbentry.flags & RO_EXISTS0x2000)
6201 || (vldbentry.flags & BACK_EXISTS0x4000))
6202 EnumerateEntry(&vldbentry);
6203 }
6204 fprintf(STDOUT__stdoutp, "\n");
6205 }
6206
6207 /* Verify that all of the VLDB entries exist on the repective servers
6208 * and partitions (this does not require that avolname be a volume ID).
6209 * Equivalent to a syncserv.
6210 */
6211 if (!vcode) {
6212 /* Tell CheckVldb not to update if appropriate */
6213 if (flags & 2)
6214 mod = 1;
6215 else
6216 mod = 0;
6217 code = CheckVldb(&vldbentry, &mod, &deleted);
6218 if (code) {
6219 fprintf(STDERR__stderrp, "Could not process VLDB entry for volume %s\n",
6220 vldbentry.name);
6221 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6222 }
6223 if (mod)
6224 modified++;
6225 }
6226
6227 /* If aserver is given, we will search for the desired volume on it */
6228 if (aserver) {
6229 /* Generate array of partitions on the server that we will check */
6230 if (!(flags & 1)) {
6231 code = UV_ListPartitions(aserver, &PartList, &pcnt);
6232 if (code) {
6233 fprintf(STDERR__stderrp,
6234 "Could not fetch the list of partitions from the server\n");
6235 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6236 }
6237 } else {
6238 PartList.partId[0] = apart;
6239 pcnt = 1;
6240 }
6241
6242 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
6243
6244 /* If a volume ID were given, search for it on each partition */
6245 if ((volumeid = atol(avolname))) {
6246 for (j = 0; j < pcnt; j++) {
6247 code =
6248 AFSVolListOneVolume(aconn, PartList.partId[j], volumeid,
6249 &volumeInfo);
6250 if (code) {
6251 if (code != ENODEV19) {
6252 fprintf(STDERR__stderrp, "Could not query server\n");
6253 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6254 }
6255 } else {
6256 if (flags & 2)
6257 mod = 1;
6258 else
6259 mod = 0;
6260 /* Found one, sync it with VLDB entry */
6261 code =
6262 CheckVolume(volumeInfo.volEntries_val, aserver,
6263 PartList.partId[j], &mod, &maxvolid, &vldbentry);
6264 if (code)
6265 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6266 if (mod)
6267 modified++;
6268 }
6269
6270 if (volumeInfo.volEntries_val)
6271 free(volumeInfo.volEntries_val);
6272 volumeInfo.volEntries_val = (volintInfo *) 0;
6273 volumeInfo.volEntries_len = 0;
6274 }
6275 }
6276
6277 /* Check to see if the RW, BK, and RO IDs exist on any
6278 * partitions. We get the volume IDs from the VLDB.
6279 */
6280 for (j = 0; j < MAXTYPES3; j++) { /* for RW, RO, and BK IDs */
6281 if (vldbentry.volumeId[j] == 0)
6282 continue;
6283
6284 for (k = 0; k < pcnt; k++) { /* For each partition */
6285 volumeInfo.volEntries_val = (volintInfo *) 0;
6286 volumeInfo.volEntries_len = 0;
6287 code =
6288 AFSVolListOneVolume(aconn, PartList.partId[k],
6289 vldbentry.volumeId[j], &volumeInfo);
6290 if (code) {
6291 if (code != ENODEV19) {
6292 fprintf(STDERR__stderrp, "Could not query server\n");
6293 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6294 }
6295 } else {
6296 if (flags & 2)
6297 mod = 1;
6298 else
6299 mod = 0;
6300 /* Found one, sync it with VLDB entry */
6301 code =
6302 CheckVolume(volumeInfo.volEntries_val, aserver,
6303 PartList.partId[k], &mod, &maxvolid, &vldbentry);
6304 if (code)
6305 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6306 if (mod)
6307 modified++;
6308 }
6309
6310 if (volumeInfo.volEntries_val)
6311 free(volumeInfo.volEntries_val);
6312 volumeInfo.volEntries_val = (volintInfo *) 0;
6313 volumeInfo.volEntries_len = 0;
6314 }
6315 }
6316 }
6317
6318 /* if (aserver) */
6319 /* If verbose output, print a summary of what changed */
6320 if (tverbose) {
6321 fprintf(STDOUT__stdoutp, "-- status after --\n");
6322 if (deleted) {
6323 fprintf(STDOUT__stdoutp, "\n**entry deleted**\n");
6324 } else if (modified) {
6325 EnumerateEntry(&vldbentry);
6326 } else {
6327 fprintf(STDOUT__stdoutp, "\n**no change**\n");
6328 }
6329 fprintf(STDOUT__stdoutp, "\n_______________________________\n");
6330 }
6331
6332 error_exit:
6333 /* Now check if the maxvolid is larger than that stored in the VLDB */
6334 if (maxvolid) {
6335 afs_uint32 maxvldbid = 0;
6336 code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
6337 if (code) {
6338 fprintf(STDERR__stderrp,
6339 "Could not get the highest allocated volume id from the VLDB\n");
6340 if (!error)
6341 error = code;
6342 } else if (maxvolid > maxvldbid) {
6343 afs_uint32 id, nid;
6344 id = maxvolid - maxvldbid + 1;
6345 code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
6346 if (code) {
6347 fprintf(STDERR__stderrp,
6348 "Error in increasing highest allocated volume id in VLDB\n");
6349 if (!error)
6350 error = code;
6351 }
6352 }
6353 }
6354
6355 verbose = tverbose;
6356 if (verbose) {
6357 if (error)
6358 fprintf(STDOUT__stdoutp, "...error encountered");
6359 else
6360 fprintf(STDOUT__stdoutp, "...done entry\n");
6361 }
6362 if (aconn)
6363 rx_DestroyConnection(aconn);
6364 if (volumeInfo.volEntries_val)
6365 free(volumeInfo.volEntries_val);
6366
6367 PrintError("", error);
6368 return error;
6369}
6370
6371/* UV_SyncVldb()
6372 * Synchronise vldb with the file server <aserver> and,
6373 * optionally, <apart>.
6374 */
6375int
6376UV_SyncVldb(afs_uint32 aserver, afs_int32 apart, int flags, int force)
6377{
6378 struct rx_connection *aconn;
6379 afs_int32 code, error = 0;
6380 int i, pfail;
6381 unsigned int j;
6382 volEntries volumeInfo;
6383 struct partList PartList;
6384 afs_int32 pcnt;
6385 char pname[10];
6386 volintInfo *vi;
6387 afs_int32 failures = 0, modifications = 0, tentries = 0;
6388 afs_int32 modified;
6389 afs_uint32 maxvolid = 0;
6390 char hoststr[16];
6391
6392 volumeInfo.volEntries_val = (volintInfo *) 0;
6393 volumeInfo.volEntries_len = 0;
6394
6395 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
6396
6397 /* Generate array of partitions to check */
6398 if (!(flags & 1)) {
6399 code = UV_ListPartitions(aserver, &PartList, &pcnt);
6400 if (code) {
6401 fprintf(STDERR__stderrp,
6402 "Could not fetch the list of partitions from the server\n");
6403 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6404 }
6405 } else {
6406 PartList.partId[0] = apart;
6407 pcnt = 1;
6408 }
6409
6410 VPRINT("Processing volume entries ...\n"){ if (verbose) { fprintf(__stdoutp, ("Processing volume entries ...\n"
)); fflush(__stdoutp); } };
6411
6412 /* Step through the array of partitions */
6413 for (i = 0; i < pcnt; i++) {
6414 apart = PartList.partId[i];
6415 MapPartIdIntoName(apart, pname);
6416
6417 volumeInfo.volEntries_val = (volintInfo *) 0;
6418 volumeInfo.volEntries_len = 0;
6419 code = AFSVolListVolumes(aconn, apart, 1, &volumeInfo);
6420 if (code) {
6421 fprintf(STDERR__stderrp,
6422 "Could not fetch the list of volumes from the server\n");
6423 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6424 }
6425
6426 /* May want to sort the entries: RW, BK (high to low), RO (high to low) */
6427 qsort((char *)volumeInfo.volEntries_val, volumeInfo.volEntries_len,
6428 sizeof(volintInfo), sortVolumes);
6429
6430 pfail = 0;
6431 for (vi = volumeInfo.volEntries_val, j = 0;
6432 j < volumeInfo.volEntries_len; j++, vi++) {
6433 if (!vi->status)
6434 continue;
6435
6436 tentries++;
6437
6438 if (verbose) {
6439 fprintf(STDOUT__stdoutp,
6440 "Processing volume entry %d: %s (%lu) on server %s %s...\n",
6441 j + 1, vi->name, (unsigned long)vi->volid,
6442 noresolve ?
6443 afs_inet_ntoa_r(aserver, hoststr) :
6444 hostutil_GetNameByINet(aserver), pname);
6445 fflush(STDOUT__stdoutp);
6446 }
6447
6448 if (flags & 2)
6449 modified = 1;
6450 else
6451 modified = 0;
6452 code = CheckVolume(vi, aserver, apart, &modified, &maxvolid, NULL((void *)0));
6453 if (code) {
6454 PrintError("", code);
6455 failures++;
6456 pfail++;
6457 } else if (modified) {
6458 modifications++;
6459 }
6460
6461 if (verbose) {
6462 if (code) {
6463 fprintf(STDOUT__stdoutp, "...error encountered\n\n");
6464 } else {
6465 fprintf(STDOUT__stdoutp, "...done entry %d\n\n", j + 1);
6466 }
6467 }
6468 }
6469
6470 if (pfail) {
6471 fprintf(STDERR__stderrp,
6472 "Could not process entries on server %s partition %s\n",
6473 noresolve ?
6474 afs_inet_ntoa_r(aserver, hoststr) :
6475 hostutil_GetNameByINet(aserver), pname);
6476 }
6477 if (volumeInfo.volEntries_val) {
6478 free(volumeInfo.volEntries_val);
6479 volumeInfo.volEntries_val = 0;
6480 }
6481
6482 } /* thru all partitions */
6483
6484 if (flags & 2) {
6485 VPRINT3("Total entries: %u, Failed to process %d, Would change %d\n",{ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Would change %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } }
6486 tentries, failures, modifications){ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Would change %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } };
6487 } else {
6488 VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",{ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Changed %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } }
6489 tentries, failures, modifications){ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Changed %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } };
6490 }
6491
6492 error_exit:
6493 /* Now check if the maxvolid is larger than that stored in the VLDB */
6494 if (maxvolid) {
6495 afs_uint32 maxvldbid = 0;
6496 code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
6497 if (code) {
6498 fprintf(STDERR__stderrp,
6499 "Could not get the highest allocated volume id from the VLDB\n");
6500 if (!error)
6501 error = code;
6502 } else if (maxvolid > maxvldbid) {
6503 afs_uint32 id, nid;
6504 id = maxvolid - maxvldbid + 1;
6505 code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
6506 if (code) {
6507 fprintf(STDERR__stderrp,
6508 "Error in increasing highest allocated volume id in VLDB\n");
6509 if (!error)
6510 error = code;
6511 }
6512 }
6513 }
6514
6515 if (aconn)
6516 rx_DestroyConnection(aconn);
6517 if (volumeInfo.volEntries_val)
6518 free(volumeInfo.volEntries_val);
6519 PrintError("", error);
6520 return (error);
6521}
6522
6523/* VolumeExists()
6524 * Determine if a volume exists on a server and partition.
6525 * Try creating a transaction on the volume. If we can,
6526 * the volume exists, if not, then return the error code.
6527 * Some error codes mean the volume is unavailable but
6528 * still exists - so we catch these error codes.
6529 */
6530static afs_int32
6531VolumeExists(afs_uint32 server, afs_int32 partition, afs_uint32 volumeid)
6532{
6533 struct rx_connection *conn = (struct rx_connection *)0;
6534 afs_int32 code = -1;
6535 volEntries volumeInfo;
6536
6537 conn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
6538 if (conn) {
6539 volumeInfo.volEntries_val = (volintInfo *) 0;
6540 volumeInfo.volEntries_len = 0;
6541 code = AFSVolListOneVolume(conn, partition, volumeid, &volumeInfo);
6542 if (volumeInfo.volEntries_val)
6543 free(volumeInfo.volEntries_val);
6544 if (code == VOLSERILLEGAL_PARTITION(1492325125L))
6545 code = ENODEV19;
6546 rx_DestroyConnection(conn);
6547 }
6548 return code;
6549}
6550
6551/* CheckVldbRWBK()
6552 *
6553 */
6554static afs_int32
6555CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
6556{
6557 int modentry = 0;
6558 int idx;
6559 afs_int32 code, error = 0;
6560 char pname[10];
6561 char hoststr[16];
6562
6563 if (modified)
6564 *modified = 0;
6565 idx = Lp_GetRwIndex(entry);
6566
6567 /* Check to see if the RW volume exists and set the RW_EXISTS
6568 * flag accordingly.
6569 */
6570 if (idx == -1) { /* Did not find a RW entry */
6571 if (entry->flags & RW_EXISTS0x1000) { /* ... yet entry says RW exists */
6572 entry->flags &= ~RW_EXISTS0x1000; /* ... so say RW does not exist */
6573 modentry++;
6574 }
6575 } else {
6576 code =
6577 VolumeExists(entry->serverNumber[idx],
6578 entry->serverPartition[idx], entry->volumeId[RWVOL0]);
6579 if (code == 0) { /* RW volume exists */
6580 if (!(entry->flags & RW_EXISTS0x1000)) { /* ... yet entry says RW does not exist */
6581 entry->flags |= RW_EXISTS0x1000; /* ... so say RW does exist */
6582 modentry++;
6583 }
6584 } else if (code == ENODEV19) { /* RW volume does not exist */
6585 if (entry->flags & RW_EXISTS0x1000) { /* ... yet entry says RW exists */
6586 entry->flags &= ~RW_EXISTS0x1000; /* ... so say RW does not exist */
6587 modentry++;
6588 }
6589 } else {
6590 /* If VLDB says it didn't exist, then ignore error */
6591 if (entry->flags & RW_EXISTS0x1000) {
6592 MapPartIdIntoName(entry->serverPartition[idx], pname);
6593 fprintf(STDERR__stderrp,
6594 "Transaction call failed for RW volume %u on server %s %s\n",
6595 entry->volumeId[RWVOL0],
6596 noresolve ?
6597 afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
6598 hostutil_GetNameByINet(entry->serverNumber[idx]),
6599 pname);
6600 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6601 }
6602 }
6603 }
6604
6605 /* Check to see if the BK volume exists and set the BACK_EXISTS
6606 * flag accordingly. idx already ponts to the RW entry.
6607 */
6608 if (idx == -1) { /* Did not find a RW entry */
6609 if (entry->flags & BACK_EXISTS0x4000) { /* ... yet entry says BK exists */
6610 entry->flags &= ~BACK_EXISTS0x4000; /* ... so say BK does not exist */
6611 modentry++;
6612 }
6613 } else { /* Found a RW entry */
6614 code =
6615 VolumeExists(entry->serverNumber[idx],
6616 entry->serverPartition[idx],
6617 entry->volumeId[BACKVOL2]);
6618 if (code == 0) { /* BK volume exists */
6619 if (!(entry->flags & BACK_EXISTS0x4000)) { /* ... yet entry says BK does not exist */
6620 entry->flags |= BACK_EXISTS0x4000; /* ... so say BK does exist */
6621 modentry++;
6622 }
6623 } else if (code == ENODEV19) { /* BK volume does not exist */
6624 if (entry->flags & BACK_EXISTS0x4000) { /* ... yet entry says BK exists */
6625 entry->flags &= ~BACK_EXISTS0x4000; /* ... so say BK does not exist */
6626 modentry++;
6627 }
6628 } else {
6629 /* If VLDB says it didn't exist, then ignore error */
6630 if (entry->flags & BACK_EXISTS0x4000) {
6631 MapPartIdIntoName(entry->serverPartition[idx], pname);
6632 fprintf(STDERR__stderrp,
6633 "Transaction call failed for BK volume %u on server %s %s\n",
6634 entry->volumeId[BACKVOL2],
6635 noresolve ?
6636 afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
6637 hostutil_GetNameByINet(entry->serverNumber[idx]),
6638 pname);
6639 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6640 }
6641 }
6642 }
6643
6644 /* If there is an idx but the BK and RW volumes no
6645 * longer exist, then remove the RW entry.
6646 */
6647 if ((idx != -1) && !(entry->flags & RW_EXISTS0x1000)
6648 && !(entry->flags & BACK_EXISTS0x4000)) {
6649 Lp_SetRWValue(entry, entry->serverNumber[idx],
6650 entry->serverPartition[idx], 0L, 0L);
6651 entry->nServers--;
6652 modentry++;
6653 }
6654
6655 error_exit:
6656 if (modified)
6657 *modified = modentry;
6658 return (error);
6659}
6660
6661static afs_int32
6662CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified)
6663{
6664 int idx;
6665 int foundro = 0, modentry = 0;
6666 afs_int32 code, error = 0;
6667 char pname[10];
6668 char hoststr[16];
6669
6670 if (modified)
6671 *modified = 0;
6672
6673 /* Check to see if the RO volumes exist and set the RO_EXISTS
6674 * flag accordingly.
6675 */
6676 for (idx = 0; idx < entry->nServers; idx++) {
6677 if (!(entry->serverFlags[idx] & ITSROVOL0x02)) {
6678 continue; /* not a RO */
6679 }
6680
6681 code =
6682 VolumeExists(entry->serverNumber[idx],
6683 entry->serverPartition[idx], entry->volumeId[ROVOL1]);
6684 if (code == 0) { /* RO volume exists */
6685 foundro++;
6686 } else if (code == ENODEV19) { /* RW volume does not exist */
6687 Lp_SetROValue(entry, entry->serverNumber[idx],
6688 entry->serverPartition[idx], 0L, 0L);
6689 entry->nServers--;
6690 idx--;
6691 modentry++;
6692 } else {
6693 MapPartIdIntoName(entry->serverPartition[idx], pname);
6694 fprintf(STDERR__stderrp,
6695 "Transaction call failed for RO %u on server %s %s\n",
6696 entry->volumeId[ROVOL1],
6697 noresolve ?
6698 afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
6699 hostutil_GetNameByINet(entry->serverNumber[idx]), pname);
6700 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6701 }
6702 }
6703
6704 if (foundro) { /* A RO volume exists */
6705 if (!(entry->flags & RO_EXISTS0x2000)) { /* ... yet entry says RW does not exist */
6706 entry->flags |= RO_EXISTS0x2000; /* ... so say RW does exist */
6707 modentry++;
6708 }
6709 } else { /* A RO volume does not exist */
6710 if (entry->flags & RO_EXISTS0x2000) { /* ... yet entry says RO exists */
6711 entry->flags &= ~RO_EXISTS0x2000; /* ... so say RO does not exist */
6712 modentry++;
6713 }
6714 }
6715
6716 error_exit:
6717 if (modified)
6718 *modified = modentry;
6719 return (error);
6720}
6721
6722/* CheckVldb()
6723 * Ensure that <entry> matches with the info on file servers
6724 */
6725static afs_int32
6726CheckVldb(struct nvldbentry * entry, afs_int32 * modified, afs_int32 * deleted)
6727{
6728 afs_int32 code, error = 0;
6729 struct nvldbentry storeEntry;
6730 int islocked = 0, mod, modentry, delentry = 0;
6731 int pass = 0, doit=1;
6732
6733 if (modified) {
6734 if (*modified == 1)
6735 doit = 0;
6736 *modified = 0;
6737 }
6738 if (verbose) {
6739 fprintf(STDOUT__stdoutp, "_______________________________\n");
6740 fprintf(STDOUT__stdoutp, "\n-- status before -- \n");
6741 if ((entry->flags & RW_EXISTS0x1000) || (entry->flags & RO_EXISTS0x2000)
6742 || (entry->flags & BACK_EXISTS0x4000))
6743 EnumerateEntry(entry);
6744 fprintf(STDOUT__stdoutp, "\n");
6745 }
6746
6747 if (strlen(entry->name) > (VOLSER_OLDMAXVOLNAME32 - 10)) {
6748 fprintf(STDERR__stderrp, "Volume name %s exceeds limit of %d characters\n",
6749 entry->name, VOLSER_OLDMAXVOLNAME32 - 10);
6750 }
6751
6752 retry:
6753 /* Check to see if the VLDB is ok without locking it (pass 1).
6754 * If it will change, then lock the VLDB entry, read it again,
6755 * then make the changes to it (pass 2).
6756 */
6757 if (++pass == 2) {
6758 code =
6759 ubik_VL_SetLock(cstruct, 0, entry->volumeId[RWVOL0], RWVOL0,
6760 VLOP_DELETE0x80);
6761 if (code) {
6762 fprintf(STDERR__stderrp, "Could not lock VLDB entry for %u \n",
6763 entry->volumeId[RWVOL0]);
6764 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6765 }
6766 islocked = 1;
6767
6768 code = VLDB_GetEntryByID(entry->volumeId[RWVOL0], RWVOL0, entry);
6769 if (code) {
6770 fprintf(STDERR__stderrp, "Could not read VLDB entry for volume %s\n",
6771 entry->name);
6772 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6773 } else {
6774 MapHostToNetwork(entry);
6775 }
6776 }
6777
6778 modentry = 0;
6779
6780 /* Check if the RW and BK entries are ok */
6781 code = CheckVldbRWBK(entry, &mod);
6782 if (code)
6783 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6784 if (mod && (pass == 1) && doit)
6785 goto retry;
6786 if (mod)
6787 modentry++;
6788
6789 /* Check if the RO volumes entries are ok */
6790 code = CheckVldbRO(entry, &mod);
6791 if (code)
6792 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6793 if (mod && (pass == 1) && doit)
6794 goto retry;
6795 if (mod)
6796 modentry++;
6797
6798 /* The VLDB entry has been updated. If it as been modified, then
6799 * write the entry back out the the VLDB.
6800 */
6801 if (modentry && doit) {
6802 if (pass == 1)
6803 goto retry;
6804
6805 if (!(entry->flags & RW_EXISTS0x1000) && !(entry->flags & BACK_EXISTS0x4000)
6806 && !(entry->flags & RO_EXISTS0x2000) && doit) {
6807 /* The RW, BK, nor RO volumes do not exist. Delete the VLDB entry */
6808 code =
6809 ubik_VL_DeleteEntry(cstruct, 0, entry->volumeId[RWVOL0],
6810 RWVOL0);
6811 if (code) {
6812 fprintf(STDERR__stderrp,
6813 "Could not delete VLDB entry for volume %u \n",
6814 entry->volumeId[RWVOL0]);
6815 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6816 }
6817 delentry = 1;
6818 } else {
6819 /* Replace old entry with our new one */
6820 MapNetworkToHost(entry, &storeEntry);
6821 code =
6822 VLDB_ReplaceEntry(entry->volumeId[RWVOL0], RWVOL0, &storeEntry,
6823 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 |
6824 LOCKREL_TIMESTAMP1));
6825 if (code) {
6826 fprintf(STDERR__stderrp, "Could not update VLDB entry for volume %u\n",
6827 entry->volumeId[RWVOL0]);
6828 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6829 }
6830 }
6831 islocked = 0;
6832 }
6833
6834 if (modified && modentry) {
6835 *modified = 1;
6836 }
6837 if (deleted && delentry) {
6838 *deleted = 1;
6839 }
6840
6841 if (verbose) {
6842 fprintf(STDOUT__stdoutp, "-- status after --\n");
6843 if (delentry)
6844 fprintf(STDOUT__stdoutp, "\n**entry deleted**\n");
6845 else if (modentry)
6846 EnumerateEntry(entry);
6847 else
6848 fprintf(STDOUT__stdoutp, "\n**no change**\n");
6849 }
6850
6851 error_exit:
6852 VPRINT("\n_______________________________\n"){ if (verbose) { fprintf(__stdoutp, ("\n_______________________________\n"
)); fflush(__stdoutp); } };
6853
6854 if (islocked) {
6855 code =
6856 ubik_VL_ReleaseLock(cstruct, 0, entry->volumeId[RWVOL0],
6857 RWVOL0,
6858 (LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1));
6859 if (code) {
6860 fprintf(STDERR__stderrp,
6861 "Could not release lock on VLDB entry for volume %u\n",
6862 entry->volumeId[RWVOL0]);
6863 if (!error)
6864 error = code;
6865 }
6866 }
6867 return error;
6868}
6869
6870/* UV_SyncServer()
6871 * Synchronise <aserver> <apart>(if flags = 1) with the VLDB.
6872 */
6873int
6874UV_SyncServer(afs_uint32 aserver, afs_int32 apart, int flags, int force)
6875{
6876 struct rx_connection *aconn;
6877 afs_int32 code, error = 0;
6878 afs_int32 nentries, tentries = 0;
6879 struct VldbListByAttributes attributes;
6880 nbulkentries arrayEntries;
6881 afs_int32 failures = 0, modified, modifications = 0;
6882 struct nvldbentry *vlentry;
6883 afs_int32 si, nsi, j;
6884
6885 if (flags & 2)
6886 verbose = 1;
6887
6888 aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT7005);
6889
6890 /* Set up attributes to search VLDB */
6891 attributes.server = ntohl(aserver)(__builtin_constant_p(aserver) ? ((((__uint32_t)(aserver)) >>
24) | ((((__uint32_t)(aserver)) & (0xff << 16)) >>
8) | ((((__uint32_t)(aserver)) & (0xff << 8)) <<
8) | (((__uint32_t)(aserver)) << 24)) : __bswap32_var(
aserver));
6892 attributes.Mask = VLLIST_SERVER0x1;
6893 if ((flags & 1)) {
6894 attributes.partition = apart;
6895 attributes.Mask |= VLLIST_PARTITION0x2;
6896 }
6897
6898 VPRINT("Processing VLDB entries ...\n"){ if (verbose) { fprintf(__stdoutp, ("Processing VLDB entries ...\n"
)); fflush(__stdoutp); } };
6899
6900 /* While we need to collect more VLDB entries */
6901 for (si = 0; si != -1; si = nsi) {
6902 memset(&arrayEntries, 0, sizeof(arrayEntries));
6903
6904 /* Collect set of VLDB entries */
6905 code =
6906 VLDB_ListAttributesN2(&attributes, 0, si, &nentries,
6907 &arrayEntries, &nsi);
6908 if (code == RXGEN_OPCODE-455) {
6909 code = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
6910 nsi = -1;
6911 }
6912 if (code) {
6913 fprintf(STDERR__stderrp, "Could not access the VLDB for attributes\n");
6914 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
6915 }
6916 tentries += nentries;
6917
6918 for (j = 0; j < nentries; j++) {
6919 vlentry = &arrayEntries.nbulkentries_val[j];
6920 MapHostToNetwork(vlentry);
6921
6922 VPRINT1("Processing VLDB entry %d ...\n", j + 1){ if (verbose) { fprintf(__stdoutp, ("Processing VLDB entry %d ...\n"
), (j + 1)); fflush(__stdoutp); } };
6923
6924 /* Tell CheckVldb not to update if appropriate */
6925 if (flags & 2)
6926 modified = 1;
6927 else
6928 modified = 0;
6929 code = CheckVldb(vlentry, &modified, NULL((void *)0));
6930 if (code) {
6931 PrintError("", code);
6932 fprintf(STDERR__stderrp,
6933 "Could not process VLDB entry for volume %s\n",
6934 vlentry->name);
6935 failures++;
6936 } else if (modified) {
6937 modifications++;
6938 }
6939
6940 if (verbose) {
6941 if (code) {
6942 fprintf(STDOUT__stdoutp, "...error encountered\n\n");
6943 } else {
6944 fprintf(STDOUT__stdoutp, "...done entry %d\n\n", j + 1);
6945 }
6946 }
6947 }
6948
6949 if (arrayEntries.nbulkentries_val) {
6950 free(arrayEntries.nbulkentries_val);
6951 arrayEntries.nbulkentries_val = 0;
6952 }
6953 }
6954
6955 if (flags & 2) {
6956 VPRINT3("Total entries: %u, Failed to process %d, Would change %d\n",{ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Would change %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } }
6957 tentries, failures, modifications){ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Would change %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } };
6958 } else {
6959 VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",{ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Changed %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } }
6960 tentries, failures, modifications){ if (verbose) { fprintf(__stdoutp, ("Total entries: %u, Failed to process %d, Changed %d\n"
), (tentries), (failures), (modifications)); fflush(__stdoutp
); } };
6961 }
6962
6963 error_exit:
6964 if (aconn)
6965 rx_DestroyConnection(aconn);
6966 if (arrayEntries.nbulkentries_val)
6967 free(arrayEntries.nbulkentries_val);
6968
6969 if (failures)
6970 error = VOLSERFAILEDOP(1492325137L);
6971 return error;
6972}
6973
6974/*rename volume <oldname> to <newname>, changing the names of the related
6975 *readonly and backup volumes. This operation is also idempotent.
6976 *salvager is capable of recovering from rename operation stopping halfway.
6977 *to recover run syncserver on the affected machines,it will force renaming to completion. name clashes should have been detected before calling this proc */
6978int
6979UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
6980{
6981 struct nvldbentry storeEntry;
6982 afs_int32 vcode, code, rcode, error;
6983 int i, index;
6984 char nameBuffer[256];
6985 afs_int32 tid;
6986 struct rx_connection *aconn;
6987 int islocked;
6988 char hoststr[16];
6989
6990 error = 0;
6991 aconn = (struct rx_connection *)0;
6992 tid = 0;
6993 islocked = 0;
6994
6995 vcode = ubik_VL_SetLock(cstruct, 0, entry->volumeId[RWVOL0], RWVOL0, VLOP_ADDSITE0x80); /*last param is dummy */
6996 if (vcode) {
6997 fprintf(STDERR__stderrp,
6998 " Could not lock the VLDB entry for the volume %u \n",
6999 entry->volumeId[RWVOL0]);
7000 error = vcode;
7001 goto rvfail;
7002 }
7003 islocked = 1;
7004 strncpy(entry->name, newname, VOLSER_OLDMAXVOLNAME32);
7005 MapNetworkToHost(entry, &storeEntry);
7006 vcode = VLDB_ReplaceEntry(entry->volumeId[RWVOL0], RWVOL0, &storeEntry, 0);
7007 if (vcode) {
7008 fprintf(STDERR__stderrp, "Could not update VLDB entry for %u\n",
7009 entry->volumeId[RWVOL0]);
7010 error = vcode;
7011 goto rvfail;
7012 }
7013 VPRINT1("Recorded the new name %s in VLDB\n", newname){ if (verbose) { fprintf(__stdoutp, ("Recorded the new name %s in VLDB\n"
), (newname)); fflush(__stdoutp); } };
7014 /*at this stage the intent to rename is recorded in the vldb, as far as the vldb
7015 * is concerned, oldname is lost */
7016 if (entry->flags & RW_EXISTS0x1000) {
7017 index = Lp_GetRwIndex(entry);
7018 if (index == -1) { /* there is a serious discrepancy */
7019 fprintf(STDERR__stderrp,
7020 "There is a serious discrepancy in VLDB entry for volume %u\n",
7021 entry->volumeId[RWVOL0]);
7022 fprintf(STDERR__stderrp, "try building VLDB from scratch\n");
7023 error = VOLSERVLDB_ERROR(1492325128L);
7024 goto rvfail;
7025 }
7026 aconn = UV_Bind(entry->serverNumber[index], AFSCONF_VOLUMEPORT7005);
7027 code =
7028 AFSVolTransCreate_retry(aconn, entry->volumeId[RWVOL0],
7029 entry->serverPartition[index], ITOffline1, &tid);
7030 if (code) { /*volume doesnot exist */
7031 fprintf(STDERR__stderrp,
7032 "Could not start transaction on the rw volume %u\n",
7033 entry->volumeId[RWVOL0]);
7034 error = code;
7035 goto rvfail;
7036 } else { /*volume exists, process it */
7037
7038 code =
7039 AFSVolSetIdsTypes(aconn, tid, newname, RWVOL0,
7040 entry->volumeId[RWVOL0],
7041 entry->volumeId[ROVOL1],
7042 entry->volumeId[BACKVOL2]);
7043 if (!code) {
7044 VPRINT2("Renamed rw volume %s to %s\n", oldname, newname){ if (verbose) { fprintf(__stdoutp, ("Renamed rw volume %s to %s\n"
), (oldname), (newname)); fflush(__stdoutp); } };
7045 code = AFSVolEndTrans(aconn, tid, &rcode);
7046 tid = 0;
7047 if (code) {
7048 fprintf(STDERR__stderrp,
7049 "Could not end transaction on volume %s %u\n",
7050 entry->name, entry->volumeId[RWVOL0]);
7051 error = code;
7052 goto rvfail;
7053 }
7054 } else {
7055 fprintf(STDERR__stderrp, "Could not set parameters on volume %s %u\n",
7056 entry->name, entry->volumeId[RWVOL0]);
7057 error = code;
7058 goto rvfail;
7059 }
7060 }
7061 if (aconn)
7062 rx_DestroyConnection(aconn);
7063 aconn = (struct rx_connection *)0;
7064 }
7065 /*end rw volume processing */
7066 if (entry->flags & BACK_EXISTS0x4000) { /*process the backup volume */
7067 index = Lp_GetRwIndex(entry);
7068 if (index == -1) { /* there is a serious discrepancy */
7069 fprintf(STDERR__stderrp,
7070 "There is a serious discrepancy in the VLDB entry for the backup volume %u\n",
7071 entry->volumeId[BACKVOL2]);
7072 fprintf(STDERR__stderrp, "try building VLDB from scratch\n");
7073 error = VOLSERVLDB_ERROR(1492325128L);
7074 goto rvfail;
7075 }
7076 aconn = UV_Bind(entry->serverNumber[index], AFSCONF_VOLUMEPORT7005);
7077 code =
7078 AFSVolTransCreate_retry(aconn, entry->volumeId[BACKVOL2],
7079 entry->serverPartition[index], ITOffline1, &tid);
7080 if (code) { /*volume doesnot exist */
7081 fprintf(STDERR__stderrp,
7082 "Could not start transaction on the backup volume %u\n",
7083 entry->volumeId[BACKVOL2]);
7084 error = code;
7085 goto rvfail;
7086 } else { /*volume exists, process it */
7087 if (strlen(newname) > (VOLSER_OLDMAXVOLNAME32 - 8)) {
7088 fprintf(STDERR__stderrp,
7089 "Volume name %s.backup exceeds the limit of %u characters\n",
7090 newname, VOLSER_OLDMAXVOLNAME32);
7091 error = code;
7092 goto rvfail;
7093 }
7094 strcpy(nameBuffer, newname);
7095 strcat(nameBuffer, ".backup");
7096
7097 code =
7098 AFSVolSetIdsTypes(aconn, tid, nameBuffer, BACKVOL2,
7099 entry->volumeId[RWVOL0], 0, 0);
7100 if (!code) {
7101 VPRINT1("Renamed backup volume to %s \n", nameBuffer){ if (verbose) { fprintf(__stdoutp, ("Renamed backup volume to %s \n"
), (nameBuffer)); fflush(__stdoutp); } };
7102 code = AFSVolEndTrans(aconn, tid, &rcode);
7103 tid = 0;
7104 if (code) {
7105 fprintf(STDERR__stderrp,
7106 "Could not end transaction on the backup volume %u\n",
7107 entry->volumeId[BACKVOL2]);
7108 error = code;
7109 goto rvfail;
7110 }
7111 } else {
7112 fprintf(STDERR__stderrp,
7113 "Could not set parameters on the backup volume %u\n",
7114 entry->volumeId[BACKVOL2]);
7115 error = code;
7116 goto rvfail;
7117 }
7118 }
7119 } /* end backup processing */
7120 if (aconn)
7121 rx_DestroyConnection(aconn);
7122 aconn = (struct rx_connection *)0;
7123 if (entry->flags & RO_EXISTS0x2000) { /*process the ro volumes */
7124 for (i = 0; i < entry->nServers; i++) {
7125 if (entry->serverFlags[i] & ITSROVOL0x02) {
7126 aconn = UV_Bind(entry->serverNumber[i], AFSCONF_VOLUMEPORT7005);
7127 code =
7128 AFSVolTransCreate_retry(aconn, entry->volumeId[ROVOL1],
7129 entry->serverPartition[i], ITOffline1,
7130 &tid);
7131 if (code) { /*volume doesnot exist */
7132 fprintf(STDERR__stderrp,
7133 "Could not start transaction on the ro volume %u\n",
7134 entry->volumeId[ROVOL1]);
7135 error = code;
7136 goto rvfail;
7137 } else { /*volume exists, process it */
7138 strcpy(nameBuffer, newname);
7139 strcat(nameBuffer, ".readonly");
7140 if (strlen(nameBuffer) > (VOLSER_OLDMAXVOLNAME32 - 1)) {
7141 fprintf(STDERR__stderrp,
7142 "Volume name %s exceeds the limit of %u characters\n",
7143 nameBuffer, VOLSER_OLDMAXVOLNAME32);
7144 error = code;
7145 goto rvfail;
7146 }
7147 code =
7148 AFSVolSetIdsTypes(aconn, tid, nameBuffer, ROVOL1,
7149 entry->volumeId[RWVOL0], 0, 0);
7150 if (!code) {
7151 VPRINT2("Renamed RO volume %s on host %s\n",{ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } }
7152 nameBuffer,{ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } }
7153 noresolve ?{ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } }
7154 afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :{ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } }
7155 hostutil_GetNameByINet(entry->{ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } }
7156 serverNumber[i])){ if (verbose) { fprintf(__stdoutp, ("Renamed RO volume %s on host %s\n"
), (nameBuffer), (noresolve ? afs_inet_ntoa_r(entry->serverNumber
[i], hoststr) : hostutil_GetNameByINet(entry-> serverNumber
[i]))); fflush(__stdoutp); } };
7157 code = AFSVolEndTrans(aconn, tid, &rcode);
7158 tid = 0;
7159 if (code) {
7160 fprintf(STDERR__stderrp,
7161 "Could not end transaction on volume %u\n",
7162 entry->volumeId[ROVOL1]);
7163 error = code;
7164 goto rvfail;
7165 }
7166 } else {
7167 fprintf(STDERR__stderrp,
7168 "Could not set parameters on the ro volume %u\n",
7169 entry->volumeId[ROVOL1]);
7170 error = code;
7171 goto rvfail;
7172 }
7173 }
7174 if (aconn)
7175 rx_DestroyConnection(aconn);
7176 aconn = (struct rx_connection *)0;
7177 }
7178 }
7179 }
7180 rvfail:
7181 if (islocked) {
7182 vcode =
7183 ubik_VL_ReleaseLock(cstruct, 0, entry->volumeId[RWVOL0],
7184 RWVOL0,
7185 LOCKREL_OPCODE2 | LOCKREL_AFSID4 | LOCKREL_TIMESTAMP1);
7186 if (vcode) {
7187 fprintf(STDERR__stderrp,
7188 "Could not unlock the VLDB entry for the volume %s %u\n",
7189 entry->name, entry->volumeId[RWVOL0]);
7190 if (!error)
7191 error = vcode;
7192 }
7193 }
7194 if (tid) {
7195 code = AFSVolEndTrans(aconn, tid, &rcode);
7196 if (!code)
7197 code = rcode;
7198 if (code) {
7199 fprintf(STDERR__stderrp, "Failed to end transaction on a volume \n");
7200 if (!error)
7201 error = code;
7202 }
7203 }
7204 if (aconn)
7205 rx_DestroyConnection(aconn);
7206 PrintError("", error);
7207 return error;
7208
7209}
7210
7211/*report on all the active transactions on volser */
7212int
7213UV_VolserStatus(afs_uint32 server, transDebugInfo ** rpntr, afs_int32 * rcount)
7214{
7215 struct rx_connection *aconn;
7216 transDebugEntries transInfo;
7217 afs_int32 code = 0;
7218
7219 aconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
7220 transInfo.transDebugEntries_val = (transDebugInfo *) 0;
7221 transInfo.transDebugEntries_len = 0;
7222 code = AFSVolMonitor(aconn, &transInfo);
7223 if (code) {
7224 fprintf(STDERR__stderrp,
7225 "Could not access status information about the server\n");
7226 PrintError("", code);
7227 if (transInfo.transDebugEntries_val)
7228 free(transInfo.transDebugEntries_val);
7229 if (aconn)
7230 rx_DestroyConnection(aconn);
7231 return code;
7232 } else {
7233 *rcount = transInfo.transDebugEntries_len;
7234 *rpntr = transInfo.transDebugEntries_val;
7235 if (aconn)
7236 rx_DestroyConnection(aconn);
7237 return 0;
7238 }
7239
7240
7241}
7242
7243/*delete the volume without interacting with the vldb */
7244int
7245UV_VolumeZap(afs_uint32 server, afs_int32 part, afs_uint32 volid)
7246{
7247 afs_int32 rcode, ttid, error, code;
7248 struct rx_connection *aconn;
7249
7250 code = 0;
7251 error = 0;
7252 ttid = 0;
7253
7254 aconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
7255 code = AFSVolTransCreate_retry(aconn, volid, part, ITOffline1, &ttid);
7256 if (code) {
7257 fprintf(STDERR__stderrp, "Could not start transaction on volume %lu\n",
7258 (unsigned long)volid);
7259 error = code;
7260 goto zfail;
7261 }
7262 code = AFSVolDeleteVolume(aconn, ttid);
7263 if (code) {
7264 fprintf(STDERR__stderrp, "Could not delete volume %lu\n",
7265 (unsigned long)volid);
7266 error = code;
7267 goto zfail;
7268 }
7269 code = AFSVolEndTrans(aconn, ttid, &rcode);
7270 ttid = 0;
7271 if (!code)
7272 code = rcode;
7273 if (code) {
7274 fprintf(STDERR__stderrp, "Could not end transaction on volume %lu\n",
7275 (unsigned long)volid);
7276 error = code;
7277 goto zfail;
7278 }
7279 zfail:
7280 if (ttid) {
7281 code = AFSVolEndTrans(aconn, ttid, &rcode);
7282 if (!code)
7283 code = rcode;
7284 if (!error)
7285 error = code;
7286 }
7287 PrintError("", error);
7288 if (aconn)
7289 rx_DestroyConnection(aconn);
7290 return error;
7291}
7292
7293int
7294UV_SetVolume(afs_uint32 server, afs_int32 partition, afs_uint32 volid,
7295 afs_int32 transflag, afs_int32 setflag, int sleeptime)
7296{
7297 struct rx_connection *conn = 0;
7298 afs_int32 tid = 0;
7299 afs_int32 code, error = 0, rcode;
7300
7301 conn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
7302 if (!conn) {
7303 fprintf(STDERR__stderrp, "SetVolumeStatus: Bind Failed");
7304 ERROR_EXIT(-1)do { error = (-1); goto error_exit; } while (0);
7305 }
7306
7307 code = AFSVolTransCreate_retry(conn, volid, partition, transflag, &tid);
7308 if (code) {
7309 fprintf(STDERR__stderrp, "SetVolumeStatus: TransCreate Failed\n");
7310 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
7311 }
7312
7313 code = AFSVolSetFlags(conn, tid, setflag);
7314 if (code) {
7315 fprintf(STDERR__stderrp, "SetVolumeStatus: SetFlags Failed\n");
7316 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
7317 }
7318
7319 if (sleeptime) {
7320#ifdef AFS_PTHREAD_ENV
7321 sleep(sleeptime);
7322#else
7323 IOMGR_Sleep(sleeptime);
7324#endif
7325 }
7326
7327 error_exit:
7328 if (tid) {
7329 rcode = 0;
7330 code = AFSVolEndTrans(conn, tid, &rcode);
7331 if (code || rcode) {
7332 fprintf(STDERR__stderrp, "SetVolumeStatus: EndTrans Failed\n");
7333 if (!error)
7334 error = (code ? code : rcode);
7335 }
7336 }
7337
7338 if (conn)
7339 rx_DestroyConnection(conn);
7340 return (error);
7341}
7342
7343int
7344UV_SetVolumeInfo(afs_uint32 server, afs_int32 partition, afs_uint32 volid,
7345 volintInfo * infop)
7346{
7347 struct rx_connection *conn = 0;
7348 afs_int32 tid = 0;
7349 afs_int32 code, error = 0, rcode;
7350
7351 conn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);
7352 if (!conn) {
7353 fprintf(STDERR__stderrp, "SetVolumeInfo: Bind Failed");
7354 ERROR_EXIT(-1)do { error = (-1); goto error_exit; } while (0);
7355 }
7356
7357 code = AFSVolTransCreate_retry(conn, volid, partition, ITOffline1, &tid);
7358 if (code) {
7359 fprintf(STDERR__stderrp, "SetVolumeInfo: TransCreate Failed\n");
7360 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
7361 }
7362
7363 code = AFSVolSetInfo(conn, tid, infop);
7364 if (code) {
7365 fprintf(STDERR__stderrp, "SetVolumeInfo: SetInfo Failed\n");
7366 ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);
7367 }
7368
7369 error_exit:
7370 if (tid) {
7371 rcode = 0;
7372 code = AFSVolEndTrans(conn, tid, &rcode);
7373 if (code || rcode) {
7374 fprintf(STDERR__stderrp, "SetVolumeInfo: EndTrans Failed\n");
7375 if (!error)
7376 error = (code ? code : rcode);
7377 }
7378 }
7379
7380 if (conn)
7381 rx_DestroyConnection(conn);
7382 return (error);
7383}
7384
7385int
7386UV_GetSize(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
7387 afs_int32 fromdate, struct volintSize *vol_size)
7388{
7389 struct rx_connection *aconn = (struct rx_connection *)0;
7390 afs_int32 tid = 0, rcode = 0;
7391 afs_int32 code, error = 0;
7392
7393
7394 /* get connections to the servers */
7395 aconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT7005);
7396
7397 VPRINT1("Starting transaction on volume %u...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Starting transaction on volume %u..."
), (afromvol)); fflush(__stdoutp); } };
7398 code = AFSVolTransCreate_retry(aconn, afromvol, afrompart, ITBusy2, &tid);
7399 EGOTO1(error_exit, code,do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be measured\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
7400 "Could not start transaction on the volume %u to be measured\n",do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be measured\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0)
7401 afromvol)do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start transaction on the volume %u to be measured\n"
)), ((afromvol))); PrintError(" ",(code)); } while (0); error
= (code); goto error_exit; } } while (0);
7402 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
7403
7404 VPRINT1("Getting size of volume on volume %u...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Getting size of volume on volume %u..."
), (afromvol)); fflush(__stdoutp); } };
7405 code = AFSVolGetSize(aconn, tid, fromdate, vol_size);
7406 EGOTO(error_exit, code, "Could not start the measurement process \n")do { if (code) { do { fprintf(__stderrp, "\n"); fprintf(__stderrp
, (("Could not start the measurement process \n"))); PrintError
(" ",(code)); } while (0); error = (code); goto error_exit;
} } while (0);
7407 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
7408
7409 error_exit:
7410 if (tid) {
7411 VPRINT1("Ending transaction on volume %u...", afromvol){ if (verbose) { fprintf(__stdoutp, ("Ending transaction on volume %u..."
), (afromvol)); fflush(__stdoutp); } };
7412 code = AFSVolEndTrans(aconn, tid, &rcode);
7413 if (code || rcode) {
7414 fprintf(STDERR__stderrp, "Could not end transaction on the volume %u\n",
7415 afromvol);
7416 fprintf(STDERR__stderrp, "error codes: %d and %d\n", code, rcode);
7417 if (!error)
7418 error = (code ? code : rcode);
7419 }
7420 VDONE{ if (verbose) { fprintf(__stdoutp, " done\n"); fflush(__stdoutp
); } };
7421 }
7422 if (aconn)
7423 rx_DestroyConnection(aconn);
7424
7425 PrintError("", error);
7426 return (error);
7427}
7428
7429/*maps the host addresses in <old > (present in network byte order) to
7430 that in< new> (present in host byte order )*/
7431void
7432MapNetworkToHost(struct nvldbentry *old, struct nvldbentry *new)
7433{
7434 int i, count;
7435
7436 /*copy all the fields */
7437 strcpy(new->name, old->name);
7438/* new->volumeType = old->volumeType;*/
7439 new->nServers = old->nServers;
7440 count = old->nServers;
7441 if (count < NMAXNSERVERS13)
7442 count++;
7443 for (i = 0; i < count; i++) {
7444 new->serverNumber[i] = ntohl(old->serverNumber[i])(__builtin_constant_p(old->serverNumber[i]) ? ((((__uint32_t
)(old->serverNumber[i])) >> 24) | ((((__uint32_t)(old
->serverNumber[i])) & (0xff << 16)) >> 8) |
((((__uint32_t)(old->serverNumber[i])) & (0xff <<
8)) << 8) | (((__uint32_t)(old->serverNumber[i])) <<
24)) : __bswap32_var(old->serverNumber[i]));
7445 new->serverPartition[i] = old->serverPartition[i];
7446 new->serverFlags[i] = old->serverFlags[i];
7447 }
7448 new->volumeId[RWVOL0] = old->volumeId[RWVOL0];
7449 new->volumeId[ROVOL1] = old->volumeId[ROVOL1];
7450 new->volumeId[BACKVOL2] = old->volumeId[BACKVOL2];
7451 new->cloneId = old->cloneId;
7452 new->flags = old->flags;
7453}
7454
7455/*maps the host entries in <entry> which are present in host byte order to network byte order */
7456void
7457MapHostToNetwork(struct nvldbentry *entry)
7458{
7459 int i, count;
7460
7461 count = entry->nServers;
7462 if (count < NMAXNSERVERS13)
7463 count++;
7464 for (i = 0; i < count; i++) {
7465 entry->serverNumber[i] = htonl(entry->serverNumber[i])(__builtin_constant_p(entry->serverNumber[i]) ? ((((__uint32_t
)(entry->serverNumber[i])) >> 24) | ((((__uint32_t)(
entry->serverNumber[i])) & (0xff << 16)) >>
8) | ((((__uint32_t)(entry->serverNumber[i])) & (0xff
<< 8)) << 8) | (((__uint32_t)(entry->serverNumber
[i])) << 24)) : __bswap32_var(entry->serverNumber[i]
));
7466 }
7467}