Bug Summary

File:budb/procs.c
Location:line 678, column 2
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/* TBD
11 * ht_lookupEntry - tape ids
12 * Truncate Tape - tape id's
13 * usetape - tape id's
14 */
15
16#include <afsconfig.h>
17#include <afs/param.h>
18
19#include <roken.h>
20
21#include <afs/stds.h>
22#include <afs/bubasics.h>
23#include <lock.h>
24#include <ubik.h>
25#include <lwp.h>
26#include <rx/xdr.h>
27#include <rx/rx.h>
28#include <rx/rxkad.h>
29#include <afs/cellconfig.h>
30#include <afs/auth.h>
31#include <afs/audit.h>
32#include <afs/afsutil.h>
33
34#include "budb.h"
35#include "budb_errs.h"
36#include "database.h"
37#include "budb_internal.h"
38#include "error_macros.h"
39#include "globals.h"
40
41#undef min
42#undef max
43
44
45extern struct ubik_dbase *BU_dbase;
46extern struct afsconf_dir *BU_conf; /* for getting cell info */
47
48afs_int32 AddVolume(struct rx_call *, struct budb_volumeEntry *);
49afs_int32 AddVolumes(struct rx_call *, struct budb_volumeList *);
50afs_int32 CreateDump(struct rx_call *, struct budb_dumpEntry *);
51afs_int32 DoDeleteDump(struct rx_call *, dumpIdafs_uint32, Dateafs_uint32, Dateafs_uint32, budb_dumpsList *);
52afs_int32 DoDeleteTape(struct rx_call *, struct budb_tapeEntry *);
53afs_int32 ListDumps(struct rx_call *, afs_int32, afs_int32, Dateafs_uint32, Dateafs_uint32,
54 budb_dumpsList *, budb_dumpsList *);
55afs_int32 DeleteVDP(struct rx_call *, char *, char *, afs_int32);
56afs_int32 FindClone(struct rx_call *, afs_int32, char *, afs_int32 *);
57afs_int32 FindDump(struct rx_call *, char *, afs_int32,
58 struct budb_dumpEntry *);
59afs_int32 FindLatestDump(struct rx_call *, char *, char *,
60 struct budb_dumpEntry *);
61afs_int32 FinishDump(struct rx_call *, struct budb_dumpEntry *);
62afs_int32 FinishTape(struct rx_call *, struct budb_tapeEntry *);
63afs_int32 GetDumps(struct rx_call *, afs_int32, afs_int32, char *,
64 afs_int32, afs_int32, afs_int32, afs_int32 *,
65 afs_int32 *, budb_dumpList *);
66afs_int32 getExpiration(struct ubik_trans *ut, struct tape *);
67afs_int32 makeAppended(struct ubik_trans *ut, afs_int32, afs_int32,
68 afs_int32);
69afs_int32 MakeDumpAppended(struct rx_call *, afs_int32, afs_int32,
70 afs_int32);
71afs_int32 FindLastTape(struct rx_call *, afs_int32, struct budb_dumpEntry *,
72 struct budb_tapeEntry *, struct budb_volumeEntry *);
73afs_int32 GetTapes(struct rx_call *, afs_int32, afs_int32, char *, afs_int32,
74 afs_int32, afs_int32, afs_int32 *, afs_int32 *,
75 budb_tapeList *);
76afs_int32 GetVolumes(struct rx_call *, afs_int32, afs_int32, char *,
77 afs_int32, afs_int32, afs_int32, afs_int32 *,
78 afs_int32 *, budb_volumeList *);
79afs_int32 UseTape(struct rx_call *, struct budb_tapeEntry *, int *);
80afs_int32 T_DumpHashTable(struct rx_call *, int, char *);
81afs_int32 T_GetVersion(struct rx_call *, int *);
82afs_int32 T_DumpDatabase(struct rx_call *, char *);
83
84int volFragsDump(struct ubik_trans *, FILE *, dbadr);
85
86/* Text block management */
87
88struct memTextBlock {
89 struct memTextBlock *mtb_next; /* next in chain */
90 afs_int32 mtb_nbytes; /* # of bytes in this block */
91 struct blockHeader mtb_blkHeader; /* in memory header */
92 dbadr mtb_addr; /* disk address of block */
93};
94
95typedef struct memTextBlock memTextBlockT;
96typedef memTextBlockT *memTextBlockP;
97
98/* These variable are for returning debugging info about the state of the
99 server. If they get trashed during multi-threaded operation it doesn't
100 matter. */
101
102/* This is global so COUNT_REQ in krb_udp.c can refer to it. */
103char *lastOperation; /* name of last operation */
104static Dateafs_uint32 lastTrans; /* time of last transaction */
105
106/* procsInited is sort of a lock: during a transaction only one process runs
107 while procsInited is false. */
108
109static int procsInited = 0;
110
111/* This variable is protected by the procsInited flag. */
112
113static int (*rebuildDatabase) (struct ubik_trans *);
114
115/* AwaitInitialization
116 * Wait unitl budb has initialized (InitProcs). If it hasn't
117 * within 5 seconds, then return no quorum.
118 */
119afs_int32
120AwaitInitialization(void)
121{
122 afs_int32 start = 0;
123
124 while (!procsInited) {
125 if (!start)
126 start = time(0);
127 else if (time(0) - start > 5)
128 return UNOQUORUM(5376L);
129#ifdef AFS_PTHREAD_ENV
130 sleep(1);
131#else
132 IOMGR_Sleep(1);
133#endif
134 }
135 return 0;
136}
137
138/* tailCompPtr
139 * name is a pathname style name, determine trailing name and return
140 * pointer to it
141 */
142
143char *
144tailCompPtr(char *pathNamePtr)
145{
146 char *ptr;
147 ptr = strrchr(pathNamePtr, '/');
148 if (ptr == 0) {
149 /* this should never happen */
150 LogError(0, "tailCompPtr: could not find / in name(%s)\n",
151 pathNamePtr);
152 return (pathNamePtr);
153 } else
154 ptr++; /* skip the / */
155 return (ptr);
156}
157
158/* callPermitted
159 * Check to see if the caller is a SuperUser.
160 * exit:
161 * 0 - no
162 * 1 - yes
163 */
164
165int
166callPermitted(struct rx_call *call)
167{
168 int permitted = 0;
169 struct afsconf_dir *acdir;
170
171 acdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATHgetDirPath(AFSDIR_SERVER_ETC_DIRPATH_ID));
172 if (!acdir)
173 return 0;
174
175 if (afsconf_SuperUser(acdir, call, NULL((void *)0)))
176 permitted = 1;
177
178 if (acdir)
179 afsconf_Close(acdir);
180 return (permitted);
181}
182
183/* InitRPC
184 * This is called by every RPC interface to create a Ubik transaction
185 * and read the database header into core
186 * entry:
187 * ut
188 * lock
189 * this_op
190 * notes:
191 * sets a lock on byte 1 of the database. Looks like it enforces
192 * single threading by use of the lock.
193 */
194
195afs_int32
196InitRPC(struct ubik_trans **ut,
197 int lock, /* indicate read/write transaction */
198 int this_op) /* opcode of RCP, for COUNT_ABO */
199{
200 int code;
201 float wait = 0.91; /* start waiting for 1 second */
202
203 start:
204 /* wait for server initialization to finish if this is not InitProcs calling */
205 if (this_op)
206 if ((code = AwaitInitialization()))
207 return code;
208
209 for (code = UNOQUORUM(5376L); code == UNOQUORUM(5376L);) {
210 code =
211 ubik_BeginTrans(BU_dbase,
212 ((lock ==
213 LOCKREAD1) ? UBIK_READTRANS0 : UBIK_WRITETRANS1),
214 ut);
215 if (code == UNOQUORUM(5376L)) { /* no quorum elected */
216 if (wait < 1)
217 Log("Waiting for quorum election\n");
218 if (wait < 15.0)
219 wait *= 1.1;
220#ifdef AFS_PTHREAD_ENV
221 sleep((int)wait);
222#else
223 IOMGR_Sleep((int)wait);
224#endif
225 }
226 }
227 if (code)
228 return code;
229 if (wait > 1)
230 Log("Have established quorum\n");
231
232 /* set lock at posiion 1, for 1 byte of type lock */
233 if ((code = ubik_SetLock(*ut, 1, 1, lock))) {
234 ubik_AbortTrans(*ut);
235 return code;
236 }
237
238 /* check that dbase is initialized and setup cheader */
239 if (lock == LOCKREAD1) {
240 /* init but don't fix because this is read only */
241 if ((code = CheckInit(*ut, 0))) {
242 ubik_AbortTrans(*ut);
243 if ((code = InitRPC(ut, LOCKWRITE2, 0))) { /* Now fix the database */
244 LogError(code, "InitRPC: InitRPC failed\n");
245 return code;
246 }
247 if ((code = ubik_EndTrans(*ut))) {
248 LogError(code, "InitRPC: ubik_EndTrans failed\n");
249 return code;
250 }
251 goto start; /* now redo the read transaction */
252 }
253 } else {
254 if ((code = CheckInit(*ut, rebuildDatabase))) {
255 ubik_AbortTrans(*ut);
256 return code;
257 }
258 }
259 lastTrans = time(0);
260 return 0;
261}
262
263/* This is called to initialize a newly created database */
264static int
265initialize_database(struct ubik_trans *ut)
266{
267 return 0;
268}
269
270static int noAuthenticationRequired; /* global state */
271static int recheckNoAuth; /* global state */
272
273afs_int32
274InitProcs(void)
275{
276 struct ubik_trans *ut;
277 afs_int32 code = 0;
278
279 procsInited = 0;
280
281 if ((globalConfPtr->myHost == 0) || (BU_conf == 0))
282 ERROR(BUDB_INTERNALERROR)do { code = (156303895L); goto error_exit; } while (0);
283
284 recheckNoAuth = 1;
285
286 if (globalConfPtr->debugFlags & DF_NOAUTH0x1)
287 noAuthenticationRequired = 1;
288
289 if (globalConfPtr->debugFlags & DF_RECHECKNOAUTH0x2)
290 recheckNoAuth = 0;
291
292 if (recheckNoAuth)
293 noAuthenticationRequired = afsconf_GetNoAuthFlag(BU_conf);
294
295 if (noAuthenticationRequired)
296 LogError(0, "Running server with security disabled\n");
297
298 InitDB();
299
300 rebuildDatabase = initialize_database;
301
302 if ((code = InitRPC(&ut, LOCKREAD1, 0))) {
303 LogError(code, "InitProcs: InitRPC failed\n");
304 return code;
305 }
306 code = ubik_EndTrans(ut);
307 if (code) {
308 LogError(code, "InitProcs: ubik_EndTrans failed\n");
309 return code;
310 }
311
312 rebuildDatabase = 0; /* only do this during init */
313 procsInited = 1;
314
315 error_exit:
316 return (code);
317}
318
319struct returnList {
320 int nElements; /* number in list */
321 int allocSize; /* number of elements allocated */
322 dbadr *elements; /* array of addresses */
323};
324
325static void
326InitReturnList(struct returnList *list)
327{
328 list->nElements = 0;
329 list->allocSize = 0;
330 list->elements = (dbadr *) 0;
331}
332
333static void
334FreeReturnList(struct returnList *list)
335{
336 if (list->elements)
337 free(list->elements);
338 list->elements = (dbadr *) 0;
339 list->nElements = 0;
340}
341
342/* As entries are collected, they are added to a return list. Once all
343 * entries have been collected, it is then placed in the return buffer
344 * with SendReturnList(). The first *to_skipP are not recorded.
345 */
346static afs_int32
347AddToReturnList(struct returnList *list, dbadr a, afs_int32 *to_skipP)
348{
349 char *tmp;
350 afs_int32 size;
351
352 if (a == 0)
353 return 0;
354 if (*to_skipP > 0) {
355 (*to_skipP)--;
356 return 0;
357 }
358
359 /* Up to 5 plus a maximum so SendReturnList() knows if we
360 * need to come back for more.
361 */
362 if (list->nElements >= BUDB_MAX_RETURN_LIST1000 + 5)
363 return BUDB_LIST2BIG(156303885L);
364
365 if (list->nElements >= list->allocSize) {
366 if (list->elements == 0) {
367 size = 10;
368 tmp = (char *)malloc(sizeof(dbadr) * size);
369 } else {
370 size = list->allocSize + 10;
371 tmp = (char *)realloc(list->elements, sizeof(dbadr) * size);
372 }
373 if (!tmp)
374 return BUDB_NOMEM(156303901L);
375 list->elements = (dbadr *) tmp;
376 list->allocSize = size;
377 }
378
379 list->elements[list->nElements] = a;
380 list->nElements++;
381 return 0;
382}
383
384afs_int32
385FillVolEntry(struct ubik_trans *ut, dbadr va, void *rock)
386{
387 struct budb_volumeEntry *vol = (struct budb_volumeEntry *) rock;
388 struct dump d;
389 struct tape t;
390 struct volInfo vi;
391 struct volFragment vf;
392
393 if (dbread(ut, va, &vf, sizeof(vf)))
394 return BUDB_IO(156303892L); /* The volFrag */
395 if (dbread(ut, ntohl(vf.vol)(__builtin_constant_p(vf.vol) ? ((((__uint32_t)(vf.vol)) >>
24) | ((((__uint32_t)(vf.vol)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vf.vol)) & (0xff << 8)) <<
8) | (((__uint32_t)(vf.vol)) << 24)) : __bswap32_var(vf
.vol)), &vi, sizeof(vi)))
396 return BUDB_IO(156303892L); /* The volInfo */
397 if (dbread(ut, ntohl(vf.tape)(__builtin_constant_p(vf.tape) ? ((((__uint32_t)(vf.tape)) >>
24) | ((((__uint32_t)(vf.tape)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vf.tape)) & (0xff << 8)) <<
8) | (((__uint32_t)(vf.tape)) << 24)) : __bswap32_var(
vf.tape)), &t, sizeof(t)))
398 return BUDB_IO(156303892L); /* The tape */
399 if (dbread(ut, ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)), &d, sizeof(d)))
400 return BUDB_IO(156303892L); /* The dump */
401
402 strcpy(vol->name, vi.name);
403 strcpy(vol->server, vi.server);
404 strcpy(vol->tape, t.name);
405 vol->tapeSeq = ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq));
406 vol->dump = ntohl(d.id)(__builtin_constant_p(d.id) ? ((((__uint32_t)(d.id)) >>
24) | ((((__uint32_t)(d.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.id)) << 24)) : __bswap32_var(d.id
));
407 vol->position = ntohl(vf.position)(__builtin_constant_p(vf.position) ? ((((__uint32_t)(vf.position
)) >> 24) | ((((__uint32_t)(vf.position)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vf.position)) & (0xff
<< 8)) << 8) | (((__uint32_t)(vf.position)) <<
24)) : __bswap32_var(vf.position));
408 vol->clone = ntohl(vf.clone)(__builtin_constant_p(vf.clone) ? ((((__uint32_t)(vf.clone)) >>
24) | ((((__uint32_t)(vf.clone)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vf.clone)) & (0xff << 8)) <<
8) | (((__uint32_t)(vf.clone)) << 24)) : __bswap32_var
(vf.clone));
409 vol->incTime = ntohl(vf.incTime)(__builtin_constant_p(vf.incTime) ? ((((__uint32_t)(vf.incTime
)) >> 24) | ((((__uint32_t)(vf.incTime)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vf.incTime)) & (0xff <<
8)) << 8) | (((__uint32_t)(vf.incTime)) << 24)) :
__bswap32_var(vf.incTime));
410 vol->nBytes = ntohl(vf.nBytes)(__builtin_constant_p(vf.nBytes) ? ((((__uint32_t)(vf.nBytes)
) >> 24) | ((((__uint32_t)(vf.nBytes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vf.nBytes)) & (0xff <<
8)) << 8) | (((__uint32_t)(vf.nBytes)) << 24)) :
__bswap32_var(vf.nBytes));
411 vol->startByte = ntohl(vf.startByte)(__builtin_constant_p(vf.startByte) ? ((((__uint32_t)(vf.startByte
)) >> 24) | ((((__uint32_t)(vf.startByte)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vf.startByte)) & (0xff
<< 8)) << 8) | (((__uint32_t)(vf.startByte)) <<
24)) : __bswap32_var(vf.startByte));
412 vol->flags = (ntohs(vf.flags)(__builtin_constant_p(vf.flags) ? (__uint16_t)(((__uint16_t)(
vf.flags)) << 8 | ((__uint16_t)(vf.flags)) >> 8) :
__bswap16_var(vf.flags)) & VOLFRAGMENTFLAGS0xffff); /* low 16 bits here */
413 vol->flags |= (ntohl(vi.flags)(__builtin_constant_p(vi.flags) ? ((((__uint32_t)(vi.flags)) >>
24) | ((((__uint32_t)(vi.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vi.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.flags)) << 24)) : __bswap32_var
(vi.flags)) & VOLINFOFLAGS0xffff0000); /* high 16 bits here */
414 vol->seq = ntohs(vf.sequence)(__builtin_constant_p(vf.sequence) ? (__uint16_t)(((__uint16_t
)(vf.sequence)) << 8 | ((__uint16_t)(vf.sequence)) >>
8) : __bswap16_var(vf.sequence));
415 vol->id = ntohl(vi.id)(__builtin_constant_p(vi.id) ? ((((__uint32_t)(vi.id)) >>
24) | ((((__uint32_t)(vi.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vi.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.id)) << 24)) : __bswap32_var(vi
.id));
416 vol->partition = ntohl(vi.partition)(__builtin_constant_p(vi.partition) ? ((((__uint32_t)(vi.partition
)) >> 24) | ((((__uint32_t)(vi.partition)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vi.partition)) & (0xff
<< 8)) << 8) | (((__uint32_t)(vi.partition)) <<
24)) : __bswap32_var(vi.partition));
417
418 return 0;
419}
420
421afs_int32
422FillDumpEntry(struct ubik_trans *ut, dbadr da, void *rock)
423{
424 struct budb_dumpEntry *dump = (struct budb_dumpEntry *)rock;
425 struct dump d, ad;
426
427 if (dbread(ut, da, &d, sizeof(d)))
428 return BUDB_IO(156303892L);
429 dump->id = ntohl(d.id)(__builtin_constant_p(d.id) ? ((((__uint32_t)(d.id)) >>
24) | ((((__uint32_t)(d.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.id)) << 24)) : __bswap32_var(d.id
));
430 dump->flags = ntohl(d.flags)(__builtin_constant_p(d.flags) ? ((((__uint32_t)(d.flags)) >>
24) | ((((__uint32_t)(d.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.flags)) << 24)) : __bswap32_var(
d.flags));
431 dump->created = ntohl(d.created)(__builtin_constant_p(d.created) ? ((((__uint32_t)(d.created)
) >> 24) | ((((__uint32_t)(d.created)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.created)) & (0xff <<
8)) << 8) | (((__uint32_t)(d.created)) << 24)) :
__bswap32_var(d.created));
432 strncpy(dump->name, d.dumpName, sizeof(dump->name));
433 strncpy(dump->dumpPath, d.dumpPath, sizeof(dump->dumpPath));
434 strncpy(dump->volumeSetName, d.volumeSet, sizeof(dump->volumeSetName));
435
436 dump->parent = ntohl(d.parent)(__builtin_constant_p(d.parent) ? ((((__uint32_t)(d.parent)) >>
24) | ((((__uint32_t)(d.parent)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.parent)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.parent)) << 24)) : __bswap32_var
(d.parent));
437 dump->level = ntohl(d.level)(__builtin_constant_p(d.level) ? ((((__uint32_t)(d.level)) >>
24) | ((((__uint32_t)(d.level)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.level)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.level)) << 24)) : __bswap32_var(
d.level));
438 dump->nVolumes = ntohl(d.nVolumes)(__builtin_constant_p(d.nVolumes) ? ((((__uint32_t)(d.nVolumes
)) >> 24) | ((((__uint32_t)(d.nVolumes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.nVolumes)) & (0xff <<
8)) << 8) | (((__uint32_t)(d.nVolumes)) << 24)) :
__bswap32_var(d.nVolumes));
439
440 tapeSet_ntoh(&d.tapes, &dump->tapes);
441
442 if (strlen(d.dumper.name) < sizeof(dump->dumper.name))
443 strcpy(dump->dumper.name, d.dumper.name);
444 if (strlen(d.dumper.instance) < sizeof(dump->dumper.instance))
445 strcpy(dump->dumper.instance, d.dumper.instance);
446 if (strlen(d.dumper.cell) < sizeof(dump->dumper.cell))
447 strcpy(dump->dumper.cell, d.dumper.cell);
448
449 /* Get the initial dumpid and the appended dump id */
450 dump->initialDumpID = ntohl(d.initialDumpID)(__builtin_constant_p(d.initialDumpID) ? ((((__uint32_t)(d.initialDumpID
)) >> 24) | ((((__uint32_t)(d.initialDumpID)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(d.initialDumpID)
) & (0xff << 8)) << 8) | (((__uint32_t)(d.initialDumpID
)) << 24)) : __bswap32_var(d.initialDumpID));
451 if (d.appendedDumpChain) {
452 if (dbread(ut, ntohl(d.appendedDumpChain)(__builtin_constant_p(d.appendedDumpChain) ? ((((__uint32_t)(
d.appendedDumpChain)) >> 24) | ((((__uint32_t)(d.appendedDumpChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
appendedDumpChain)) & (0xff << 8)) << 8) | ((
(__uint32_t)(d.appendedDumpChain)) << 24)) : __bswap32_var
(d.appendedDumpChain)), &ad, sizeof(ad)))
453 return BUDB_IO(156303892L);
454 dump->appendedDumpID = ntohl(ad.id)(__builtin_constant_p(ad.id) ? ((((__uint32_t)(ad.id)) >>
24) | ((((__uint32_t)(ad.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(ad.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(ad.id)) << 24)) : __bswap32_var(ad
.id));
455 } else
456 dump->appendedDumpID = 0;
457
458 /* printf("dump name %s, parent %d, level %d\n",
459 * d.dumpName, ntohl(d.parent), ntohl(d.level)); */
460
461 return 0;
462}
463
464afs_int32
465FillTapeEntry(struct ubik_trans *ut, dbadr ta, void *rock)
466{
467 struct budb_tapeEntry *tape=(struct budb_tapeEntry *) rock;
468 struct tape t;
469 struct dump d;
470 afs_int32 code;
471
472 if (dbread(ut, ta, &t, sizeof(t)))
473 return BUDB_IO(156303892L);
474
475 /* Get the tape's expiration date */
476 if ((code = getExpiration(ut, &t)))
477 return (code);
478
479 strcpy(tape->name, t.name);
480 tape->flags = ntohl(t.flags)(__builtin_constant_p(t.flags) ? ((((__uint32_t)(t.flags)) >>
24) | ((((__uint32_t)(t.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.flags)) << 24)) : __bswap32_var(
t.flags));
481 tape->written = ntohl(t.written)(__builtin_constant_p(t.written) ? ((((__uint32_t)(t.written)
) >> 24) | ((((__uint32_t)(t.written)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.written)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.written)) << 24)) :
__bswap32_var(t.written));
482 tape->expires = ntohl(t.expires)(__builtin_constant_p(t.expires) ? ((((__uint32_t)(t.expires)
) >> 24) | ((((__uint32_t)(t.expires)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.expires)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.expires)) << 24)) :
__bswap32_var(t.expires));
483 tape->nMBytes = ntohl(t.nMBytes)(__builtin_constant_p(t.nMBytes) ? ((((__uint32_t)(t.nMBytes)
) >> 24) | ((((__uint32_t)(t.nMBytes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nMBytes)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nMBytes)) << 24)) :
__bswap32_var(t.nMBytes));
484 tape->nBytes = ntohl(t.nBytes)(__builtin_constant_p(t.nBytes) ? ((((__uint32_t)(t.nBytes)) >>
24) | ((((__uint32_t)(t.nBytes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nBytes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nBytes)) << 24)) : __bswap32_var
(t.nBytes));
485 tape->nFiles = ntohl(t.nFiles)(__builtin_constant_p(t.nFiles) ? ((((__uint32_t)(t.nFiles)) >>
24) | ((((__uint32_t)(t.nFiles)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nFiles)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nFiles)) << 24)) : __bswap32_var
(t.nFiles));
486 tape->nVolumes = ntohl(t.nVolumes)(__builtin_constant_p(t.nVolumes) ? ((((__uint32_t)(t.nVolumes
)) >> 24) | ((((__uint32_t)(t.nVolumes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nVolumes)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nVolumes)) << 24)) :
__bswap32_var(t.nVolumes));
487 tape->seq = ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq));
488 tape->labelpos = ntohl(t.labelpos)(__builtin_constant_p(t.labelpos) ? ((((__uint32_t)(t.labelpos
)) >> 24) | ((((__uint32_t)(t.labelpos)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.labelpos)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.labelpos)) << 24)) :
__bswap32_var(t.labelpos));
489 tape->useCount = ntohl(t.useCount)(__builtin_constant_p(t.useCount) ? ((((__uint32_t)(t.useCount
)) >> 24) | ((((__uint32_t)(t.useCount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.useCount)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.useCount)) << 24)) :
__bswap32_var(t.useCount));
490 tape->useKBytes = ntohl(t.useKBytes)(__builtin_constant_p(t.useKBytes) ? ((((__uint32_t)(t.useKBytes
)) >> 24) | ((((__uint32_t)(t.useKBytes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.useKBytes)) & (0xff
<< 8)) << 8) | (((__uint32_t)(t.useKBytes)) <<
24)) : __bswap32_var(t.useKBytes));
491
492 if (dbread(ut, ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)), &d, sizeof(d)))
493 return BUDB_IO(156303892L);
494 tape->dump = ntohl(d.id)(__builtin_constant_p(d.id) ? ((((__uint32_t)(d.id)) >>
24) | ((((__uint32_t)(d.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.id)) << 24)) : __bswap32_var(d.id
));
495 return 0;
496}
497
498#define returnList_tbudb_dumpList * budb_dumpList *
499
500/* SendReturnList
501 * A list of elements of size e_size is in list, collected
502 * with AddToReturnList(). We will move this to a correspoding
503 * return list, eList, via FillProc(). nextInodeP tells us
504 * if there are more and how many to skip on the next request.
505 */
506static afs_int32
507SendReturnList(struct ubik_trans *ut,
508 struct returnList *list, /* list of elements to return */
509 afs_int32(*FillProc) (struct ubik_trans *, dbadr da,
510 void *),
511 /* proc to fill entry */
512 int e_size, /* size of each element */
513 afs_int32 index, /* index from previous call */
514 afs_int32 *nextIndexP, /* if more elements are available */
515 afs_int32 *dbTimeP, /* time of last db update */
516 budb_dumpList *eList) /* rxgen list structure (e.g.) */
517{
518 afs_int32 code;
519 int to_return;
520 int i;
521 char *e;
522
523 *nextIndexP = -1;
524 *dbTimeP = ntohl(db.h.lastUpdate)(__builtin_constant_p(db.h.lastUpdate) ? ((((__uint32_t)(db.h
.lastUpdate)) >> 24) | ((((__uint32_t)(db.h.lastUpdate)
) & (0xff << 16)) >> 8) | ((((__uint32_t)(db.
h.lastUpdate)) & (0xff << 8)) << 8) | (((__uint32_t
)(db.h.lastUpdate)) << 24)) : __bswap32_var(db.h.lastUpdate
));
525
526 /* Calculate how many to return. Don't let if go over
527 * BUDB_MAX_RETURN_LIST nor the size of our return list.
528 */
529 to_return = list->nElements;
530 if (to_return > BUDB_MAX_RETURN_LIST1000)
531 to_return = BUDB_MAX_RETURN_LIST1000;
532 if (eList->budb_dumpList_len && (to_return > eList->budb_dumpList_len))
533 to_return = eList->budb_dumpList_len;
534
535 /* Allocate space for the return values if needed and zero it */
536 if (eList->budb_dumpList_val == 0) {
537 eList->budb_dumpList_val =
538 (struct budb_dumpEntry *)malloc(e_size * to_return);
539 if (!eList->budb_dumpList_val)
540 return (BUDB_NOMEM(156303901L));
541 }
542 memset(eList->budb_dumpList_val, 0, e_size * to_return);
543 eList->budb_dumpList_len = to_return;
544
545 e = (char *)(eList->budb_dumpList_val);
546 for (i = 0; i < to_return; i++, e += e_size) {
547 code = (*FillProc) (ut, list->elements[i], (budb_dumpEntry *) e);
548 if (code)
549 return code;
550 }
551
552 if (list->nElements > i)
553 *nextIndexP = index + i;
554 return 0;
555}
556
557/* Come here to delete a volInfo structure. */
558
559static afs_int32
560DeleteVolInfo(struct ubik_trans *ut, dbadr via, struct volInfo *vi)
561{
562 afs_int32 code;
563 dbadr hvia;
564 struct volInfo hvi;
565
566 if (vi->firstFragment)
567 return 0; /* still some frags, don't free yet */
568 if (vi->sameNameHead == 0) { /* this is the head */
569 if (vi->sameNameChain)
570 return 0; /* empty head, some non-heads left */
571
572 code = ht_HashOut(ut, &db.volName, via, vi);
573 if (code)
574 return code;
575 code = FreeStructure(ut, volInfo_BLOCK2, via);
576 return code;
577 }
578 hvia = ntohl(vi->sameNameHead)(__builtin_constant_p(vi->sameNameHead) ? ((((__uint32_t)(
vi->sameNameHead)) >> 24) | ((((__uint32_t)(vi->sameNameHead
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vi
->sameNameHead)) & (0xff << 8)) << 8) | ((
(__uint32_t)(vi->sameNameHead)) << 24)) : __bswap32_var
(vi->sameNameHead));
579 if (dbread(ut, hvia, &hvi, sizeof(hvi)))
580 return BUDB_IO(156303892L);
581 code =
582 RemoveFromList(ut, hvia, &hvi, &hvi.sameNameChain, via, vi,
583 &vi->sameNameChain);
584 if (code == -1)
585 return BUDB_DATABASEINCONSISTENT(156303894L);
586 if (code == 0)
587 code = FreeStructure(ut, volInfo_BLOCK2, via);
588 return code;
589}
590
591/* Detach a volume fragment from its volInfo structure. Its tape chain is
592 already freed. This routine frees the structure and the caller must not
593 write it out. */
594
595static afs_int32
596DeleteVolFragment(struct ubik_trans *ut, dbadr va, struct volFragment *v)
597{
598 afs_int32 code;
599 struct volInfo vi;
600 dbadr via;
601
602 via = ntohl(v->vol)(__builtin_constant_p(v->vol) ? ((((__uint32_t)(v->vol)
) >> 24) | ((((__uint32_t)(v->vol)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(v->vol)) & (0xff <<
8)) << 8) | (((__uint32_t)(v->vol)) << 24)) :
__bswap32_var(v->vol));
603 if (dbread(ut, via, &vi, sizeof(vi)))
604 return BUDB_IO(156303892L);
605 code =
606 RemoveFromList(ut, via, &vi, &vi.firstFragment, va, v,
607 &v->sameNameChain);
608 if (code == -1)
609 return BUDB_DATABASEINCONSISTENT(156303894L);
610 if (code)
611 return code;
612 if (vi.firstFragment == 0)
613 if ((code = DeleteVolInfo(ut, via, &vi)))
614 return code;
615 if ((code = FreeStructure(ut, volFragment_BLOCK1, va)))
616 return code;
617
618 /* decrement frag counter */
619 code =
620 set_word_addr(ut, via, &vi, &vi.nFrags, htonl(ntohl(vi.nFrags) - 1))dbwrite ((ut), (via)+((char *)(&vi.nFrags) - (char *)(&
vi)), (*(afs_int32 *)(&vi.nFrags) = ((__builtin_constant_p
((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t)(vi.nFrags
)) >> 24) | ((((__uint32_t)(vi.nFrags)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vi.nFrags)) & (0xff <<
8)) << 8) | (((__uint32_t)(vi.nFrags)) << 24)) :
__bswap32_var(vi.nFrags)) - 1) ? ((((__uint32_t)((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) - 1)) >> 24) | ((((__uint32_t)((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) - 1)) & (0xff << 16)) >> 8) | ((
((__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) - 1)) & (0xff
<< 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) - 1)) << 24)) : __bswap32_var((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) - 1))), (char *)(&vi.nFrags)), sizeof(afs_int32
));
621 if (code)
622 return code;
623 return 0;
624}
625
626/* DeleteTape - by freeing all its volumes and removing it from its dump chain.
627 * The caller will remove it from the hash table if necessary. The caller is
628 * also responsible for writing the tape out if necessary. */
629
630static afs_int32
631DeleteTape(struct ubik_trans *ut, dbadr ta, struct tape *t)
632{
633 afs_int32 code;
634 struct dump d;
635 dbadr da;
636
637 da = ntohl(t->dump)(__builtin_constant_p(t->dump) ? ((((__uint32_t)(t->dump
)) >> 24) | ((((__uint32_t)(t->dump)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t->dump)) & (0xff <<
8)) << 8) | (((__uint32_t)(t->dump)) << 24)) :
__bswap32_var(t->dump));
638 if (da == 0)
639 return BUDB_DATABASEINCONSISTENT(156303894L);
640 if (dbread(ut, da, &d, sizeof(d)))
641 return BUDB_IO(156303892L);
642 if (d.firstTape == 0)
643 return BUDB_DATABASEINCONSISTENT(156303894L);
644
645 code = RemoveFromList(ut, da, &d, &d.firstTape, ta, t, &t->nextTape);
646 if (code == -1)
647 return BUDB_DATABASEINCONSISTENT(156303894L);
648 if (code)
649 return code;
650
651 /* Since the tape should have been truncated there should never be any
652 * volumes in the tape. */
653 if (t->firstVol || t->nVolumes)
654 return BUDB_DATABASEINCONSISTENT(156303894L);
655
656 return 0;
657}
658
659static afs_int32
660DeleteDump(struct ubik_trans *ut, dbadr da, struct dump *d)
661{
662 afs_int32 code = 0;
663
664 code = ht_HashOut(ut, &db.dumpIden, da, d);
665 if (code)
1
Taking false branch
666 ERROR(code)do { code = code; goto error_exit; } while (0);
667
668 code = ht_HashOut(ut, &db.dumpName, da, d);
669 if (code)
2
Taking false branch
670 ERROR(code)do { code = code; goto error_exit; } while (0);
671
672 /* Since the tape should have been truncated this should never happen. */
673 if (d->firstTape || d->nVolumes)
3
Taking false branch
674 ERROR(BUDB_DATABASEINCONSISTENT)do { code = (156303894L); goto error_exit; } while (0);
675
676 code = FreeStructure(ut, dump_BLOCK4, da);
677 if (code)
4
Taking true branch
678 ERROR(code)do { code = code; goto error_exit; } while (0);
5
Within the expansion of the macro 'ERROR':
a
Assigned value is always the same as the existing value
679
680 error_exit:
681 return code;
682}
683
684/*
685 * VolInfoMatch()
686 *
687 * This is called with a volumeEntry and a volInfo structure and compares
688 * them. It returns non-zero if they are equal. It is used by GetVolInfo to
689 * search volInfo structures once it has the head volInfo structure from the
690 * volName hash table.
691 *
692 * When called from GetVolInfo the name compare is redundant.
693 * Always AND the flags with VOLINFOFLAGS for backwards compatability (3.3).
694 */
695
696static int
697VolInfoMatch(struct budb_volumeEntry *vol, struct volInfo *vi)
698{
699 return ((strcmp(vol->name, vi->name) == 0) && /* same volume name */
700 (vol->id == ntohl(vi->id)(__builtin_constant_p(vi->id) ? ((((__uint32_t)(vi->id)
) >> 24) | ((((__uint32_t)(vi->id)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(vi->id)) & (0xff <<
8)) << 8) | (((__uint32_t)(vi->id)) << 24)) :
__bswap32_var(vi->id))) && /* same volume id */
701 ((vol->flags & VOLINFOFLAGS0xffff0000) == (ntohl(vi->flags)(__builtin_constant_p(vi->flags) ? ((((__uint32_t)(vi->
flags)) >> 24) | ((((__uint32_t)(vi->flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(vi->flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(vi->
flags)) << 24)) : __bswap32_var(vi->flags)) & VOLINFOFLAGS0xffff0000)) && /* same flags */
702 (vol->partition == ntohl(vi->partition)(__builtin_constant_p(vi->partition) ? ((((__uint32_t)(vi->
partition)) >> 24) | ((((__uint32_t)(vi->partition))
& (0xff << 16)) >> 8) | ((((__uint32_t)(vi->
partition)) & (0xff << 8)) << 8) | (((__uint32_t
)(vi->partition)) << 24)) : __bswap32_var(vi->partition
))) && /* same partition (N/A) */
703 (strcmp(vol->server, vi->server) == 0)); /* same server (N/A) */
704}
705
706/*
707 * GetVolInfo()
708 * This routine takes a volumeEntry structure from an RPC interface and
709 * returns the corresponding volInfo structure, creating it if necessary.
710 *
711 * The caller must write the entry out.
712 */
713
714static afs_int32
715GetVolInfo(struct ubik_trans *ut, struct budb_volumeEntry *volP, dbadr *viaP,
716 struct volInfo *viP)
717{
718 dbadr hvia, via;
719 struct volInfo hvi;
720 afs_int32 eval, code = 0;
721
722 eval = ht_LookupEntry(ut, &db.volName, volP->name, &via, viP);
723 if (eval)
724 ERROR(eval)do { code = eval; goto error_exit; } while (0);
725
726 if (!via) {
727 /* allocate a new volinfo structure */
728 eval = AllocStructure(ut, volInfo_BLOCK2, 0, &via, viP);
729 if (eval)
730 ERROR(eval)do { code = eval; goto error_exit; } while (0);
731
732 strcpy(viP->name, volP->name);
733 strcpy(viP->server, volP->server);
734 viP->sameNameHead = 0; /* The head of same name chain */
735 viP->sameNameChain = 0; /* Same name chain is empty */
736 viP->firstFragment = 0;
737 viP->nFrags = 0;
738 viP->id = htonl(volP->id)(__builtin_constant_p(volP->id) ? ((((__uint32_t)(volP->
id)) >> 24) | ((((__uint32_t)(volP->id)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(volP->id)) &
(0xff << 8)) << 8) | (((__uint32_t)(volP->id)
) << 24)) : __bswap32_var(volP->id));
739 viP->partition = htonl(volP->partition)(__builtin_constant_p(volP->partition) ? ((((__uint32_t)(volP
->partition)) >> 24) | ((((__uint32_t)(volP->partition
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(volP
->partition)) & (0xff << 8)) << 8) | (((__uint32_t
)(volP->partition)) << 24)) : __bswap32_var(volP->
partition));
740 viP->flags = htonl(volP->flags & VOLINFOFLAGS)(__builtin_constant_p(volP->flags & 0xffff0000) ? ((((
__uint32_t)(volP->flags & 0xffff0000)) >> 24) | (
(((__uint32_t)(volP->flags & 0xffff0000)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(volP->flags & 0xffff0000
)) & (0xff << 8)) << 8) | (((__uint32_t)(volP
->flags & 0xffff0000)) << 24)) : __bswap32_var(volP
->flags & 0xffff0000));
741
742 /* Chain onto volname hash table */
743 eval = ht_HashIn(ut, &db.volName, via, viP);
744 if (eval)
745 ERROR(eval)do { code = eval; goto error_exit; } while (0);
746
747 LogDebug(4, "volume Info for %s placed at %d\n", volP->name, via);
748 }
749
750 else if (!VolInfoMatch(volP, viP)) { /* Not the head volinfo struct */
751 hvia = via; /* remember the head volinfo struct */
752 memcpy(&hvi, viP, sizeof(hvi));
753
754 /* Search the same name chain for the correct volinfo structure */
755 for (via = ntohl(viP->sameNameChain)(__builtin_constant_p(viP->sameNameChain) ? ((((__uint32_t
)(viP->sameNameChain)) >> 24) | ((((__uint32_t)(viP->
sameNameChain)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(viP->sameNameChain)) & (0xff << 8)) << 8
) | (((__uint32_t)(viP->sameNameChain)) << 24)) : __bswap32_var
(viP->sameNameChain)); via;
756 via = ntohl(viP->sameNameChain)(__builtin_constant_p(viP->sameNameChain) ? ((((__uint32_t
)(viP->sameNameChain)) >> 24) | ((((__uint32_t)(viP->
sameNameChain)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(viP->sameNameChain)) & (0xff << 8)) << 8
) | (((__uint32_t)(viP->sameNameChain)) << 24)) : __bswap32_var
(viP->sameNameChain))) {
757 eval = dbread(ut, via, viP, sizeof(*viP));
758 if (eval)
759 ERROR(eval)do { code = eval; goto error_exit; } while (0);
760
761 if (VolInfoMatch(volP, viP))
762 break; /* found the one */
763 }
764
765 /* if the correct volinfo struct isn't found, create one */
766 if (!via) {
767 eval = AllocStructure(ut, volInfo_BLOCK2, 0, &via, viP);
768 if (eval)
769 ERROR(eval)do { code = eval; goto error_exit; } while (0);
770
771 strcpy(viP->name, volP->name);
772 strcpy(viP->server, volP->server);
773 viP->nameHashChain = 0; /* not in hash table */
774 viP->sameNameHead = htonl(hvia)(__builtin_constant_p(hvia) ? ((((__uint32_t)(hvia)) >>
24) | ((((__uint32_t)(hvia)) & (0xff << 16)) >>
8) | ((((__uint32_t)(hvia)) & (0xff << 8)) <<
8) | (((__uint32_t)(hvia)) << 24)) : __bswap32_var(hvia
)); /* chain to head of sameNameChain */
775 viP->sameNameChain = hvi.sameNameChain;
776 viP->firstFragment = 0;
777 viP->nFrags = 0;
778 viP->id = htonl(volP->id)(__builtin_constant_p(volP->id) ? ((((__uint32_t)(volP->
id)) >> 24) | ((((__uint32_t)(volP->id)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(volP->id)) &
(0xff << 8)) << 8) | (((__uint32_t)(volP->id)
) << 24)) : __bswap32_var(volP->id));
779 viP->partition = htonl(volP->partition)(__builtin_constant_p(volP->partition) ? ((((__uint32_t)(volP
->partition)) >> 24) | ((((__uint32_t)(volP->partition
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(volP
->partition)) & (0xff << 8)) << 8) | (((__uint32_t
)(volP->partition)) << 24)) : __bswap32_var(volP->
partition));
780 viP->flags = htonl(volP->flags & VOLINFOFLAGS)(__builtin_constant_p(volP->flags & 0xffff0000) ? ((((
__uint32_t)(volP->flags & 0xffff0000)) >> 24) | (
(((__uint32_t)(volP->flags & 0xffff0000)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(volP->flags & 0xffff0000
)) & (0xff << 8)) << 8) | (((__uint32_t)(volP
->flags & 0xffff0000)) << 24)) : __bswap32_var(volP
->flags & 0xffff0000));
781
782 /* write the head entry's sameNameChain link */
783 eval =
784 set_word_addr(ut, hvia, &hvi, &hvi.sameNameChain, htonl(via))dbwrite ((ut), (hvia)+((char *)(&hvi.sameNameChain) - (char
*)(&hvi)), (*(afs_int32 *)(&hvi.sameNameChain) = ((__builtin_constant_p
(via) ? ((((__uint32_t)(via)) >> 24) | ((((__uint32_t)(
via)) & (0xff << 16)) >> 8) | ((((__uint32_t)
(via)) & (0xff << 8)) << 8) | (((__uint32_t)(
via)) << 24)) : __bswap32_var(via))), (char *)(&hvi
.sameNameChain)), sizeof(afs_int32));
785 if (eval)
786 ERROR(eval)do { code = eval; goto error_exit; } while (0);
787 }
788 }
789
790 *viaP = via;
791
792 error_exit:
793 return code;
794}
795
796/* deletesomevolumesfromtape
797 * Deletes a specified number of volumes from a tape. The tape
798 * and dump are modified to reflect the smaller number of volumes.
799 * The transaction is not terminated, it is up to the caller to
800 * finish the transaction and start a new one (if desired).
801 * entry:
802 * maxvolumestodelete - don't delete more than this many volumes
803 */
804
805afs_int32
806deleteSomeVolumesFromTape(struct ubik_trans *ut, dbadr tapeAddr,
807 struct tape *tapePtr, int maxVolumesToDelete)
808{
809 dbadr volFragAddr, nextVolFragAddr, dumpAddr;
810 struct volFragment volFrag;
811 struct dump dump;
812 int volumesDeleted = 0;
813 afs_int32 eval, code = 0;
814
815 if (!tapePtr)
816 ERROR(0)do { code = 0; goto error_exit; } while (0);
817
818 for (volFragAddr = ntohl(tapePtr->firstVol)(__builtin_constant_p(tapePtr->firstVol) ? ((((__uint32_t)
(tapePtr->firstVol)) >> 24) | ((((__uint32_t)(tapePtr
->firstVol)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tapePtr->firstVol)) & (0xff << 8)) << 8)
| (((__uint32_t)(tapePtr->firstVol)) << 24)) : __bswap32_var
(tapePtr->firstVol));
819 (volFragAddr && (maxVolumesToDelete > 0));
820 volFragAddr = nextVolFragAddr) {
821 eval = dbread(ut, volFragAddr, &volFrag, sizeof(volFrag));
822 if (eval)
823 ERROR(eval)do { code = eval; goto error_exit; } while (0);
824
825 nextVolFragAddr = ntohl(volFrag.sameTapeChain)(__builtin_constant_p(volFrag.sameTapeChain) ? ((((__uint32_t
)(volFrag.sameTapeChain)) >> 24) | ((((__uint32_t)(volFrag
.sameTapeChain)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(volFrag.sameTapeChain)) & (0xff << 8)) <<
8) | (((__uint32_t)(volFrag.sameTapeChain)) << 24)) : __bswap32_var
(volFrag.sameTapeChain));
826
827 eval = DeleteVolFragment(ut, volFragAddr, &volFrag);
828 if (eval)
829 ERROR(eval)do { code = eval; goto error_exit; } while (0);
830
831 maxVolumesToDelete--;
832 volumesDeleted++;
833 }
834
835 /* reset the volume fragment pointer in the tape */
836 tapePtr->firstVol = htonl(volFragAddr)(__builtin_constant_p(volFragAddr) ? ((((__uint32_t)(volFragAddr
)) >> 24) | ((((__uint32_t)(volFragAddr)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(volFragAddr)) & (0xff
<< 8)) << 8) | (((__uint32_t)(volFragAddr)) <<
24)) : __bswap32_var(volFragAddr));
837
838 /* diminish the tape's volume count */
839 tapePtr->nVolumes = htonl(ntohl(tapePtr->nVolumes) - volumesDeleted)(__builtin_constant_p((__builtin_constant_p(tapePtr->nVolumes
) ? ((((__uint32_t)(tapePtr->nVolumes)) >> 24) | (((
(__uint32_t)(tapePtr->nVolumes)) & (0xff << 16))
>> 8) | ((((__uint32_t)(tapePtr->nVolumes)) & (
0xff << 8)) << 8) | (((__uint32_t)(tapePtr->nVolumes
)) << 24)) : __bswap32_var(tapePtr->nVolumes)) - volumesDeleted
) ? ((((__uint32_t)((__builtin_constant_p(tapePtr->nVolumes
) ? ((((__uint32_t)(tapePtr->nVolumes)) >> 24) | (((
(__uint32_t)(tapePtr->nVolumes)) & (0xff << 16))
>> 8) | ((((__uint32_t)(tapePtr->nVolumes)) & (
0xff << 8)) << 8) | (((__uint32_t)(tapePtr->nVolumes
)) << 24)) : __bswap32_var(tapePtr->nVolumes)) - volumesDeleted
)) >> 24) | ((((__uint32_t)((__builtin_constant_p(tapePtr
->nVolumes) ? ((((__uint32_t)(tapePtr->nVolumes)) >>
24) | ((((__uint32_t)(tapePtr->nVolumes)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tapePtr->nVolumes)) &
(0xff << 8)) << 8) | (((__uint32_t)(tapePtr->
nVolumes)) << 24)) : __bswap32_var(tapePtr->nVolumes
)) - volumesDeleted)) & (0xff << 16)) >> 8) |
((((__uint32_t)((__builtin_constant_p(tapePtr->nVolumes) ?
((((__uint32_t)(tapePtr->nVolumes)) >> 24) | ((((__uint32_t
)(tapePtr->nVolumes)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(tapePtr->nVolumes)) & (0xff <<
8)) << 8) | (((__uint32_t)(tapePtr->nVolumes)) <<
24)) : __bswap32_var(tapePtr->nVolumes)) - volumesDeleted
)) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(tapePtr->nVolumes) ? ((((__uint32_t)(tapePtr->nVolumes
)) >> 24) | ((((__uint32_t)(tapePtr->nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(tapePtr->
nVolumes)) & (0xff << 8)) << 8) | (((__uint32_t
)(tapePtr->nVolumes)) << 24)) : __bswap32_var(tapePtr
->nVolumes)) - volumesDeleted)) << 24)) : __bswap32_var
((__builtin_constant_p(tapePtr->nVolumes) ? ((((__uint32_t
)(tapePtr->nVolumes)) >> 24) | ((((__uint32_t)(tapePtr
->nVolumes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tapePtr->nVolumes)) & (0xff << 8)) << 8)
| (((__uint32_t)(tapePtr->nVolumes)) << 24)) : __bswap32_var
(tapePtr->nVolumes)) - volumesDeleted));
840
841 eval = dbwrite(ut, tapeAddr, tapePtr, sizeof(*tapePtr));
842 if (eval)
843 ERROR(eval)do { code = eval; goto error_exit; } while (0);
844
845 /* diminish the dump's volume count */
846 dumpAddr = ntohl(tapePtr->dump)(__builtin_constant_p(tapePtr->dump) ? ((((__uint32_t)(tapePtr
->dump)) >> 24) | ((((__uint32_t)(tapePtr->dump))
& (0xff << 16)) >> 8) | ((((__uint32_t)(tapePtr
->dump)) & (0xff << 8)) << 8) | (((__uint32_t
)(tapePtr->dump)) << 24)) : __bswap32_var(tapePtr->
dump));
847 eval = dbread(ut, dumpAddr, &dump, sizeof(dump));
848 if (eval)
849 ERROR(eval)do { code = eval; goto error_exit; } while (0);
850
851 dump.nVolumes = htonl(ntohl(dump.nVolumes) - volumesDeleted)(__builtin_constant_p((__builtin_constant_p(dump.nVolumes) ? (
(((__uint32_t)(dump.nVolumes)) >> 24) | ((((__uint32_t)
(dump.nVolumes)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(dump.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.nVolumes)) << 24)) : __bswap32_var
(dump.nVolumes)) - volumesDeleted) ? ((((__uint32_t)((__builtin_constant_p
(dump.nVolumes) ? ((((__uint32_t)(dump.nVolumes)) >> 24
) | ((((__uint32_t)(dump.nVolumes)) & (0xff << 16))
>> 8) | ((((__uint32_t)(dump.nVolumes)) & (0xff <<
8)) << 8) | (((__uint32_t)(dump.nVolumes)) << 24
)) : __bswap32_var(dump.nVolumes)) - volumesDeleted)) >>
24) | ((((__uint32_t)((__builtin_constant_p(dump.nVolumes) ?
((((__uint32_t)(dump.nVolumes)) >> 24) | ((((__uint32_t
)(dump.nVolumes)) & (0xff << 16)) >> 8) | (((
(__uint32_t)(dump.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.nVolumes)) << 24)) : __bswap32_var
(dump.nVolumes)) - volumesDeleted)) & (0xff << 16))
>> 8) | ((((__uint32_t)((__builtin_constant_p(dump.nVolumes
) ? ((((__uint32_t)(dump.nVolumes)) >> 24) | ((((__uint32_t
)(dump.nVolumes)) & (0xff << 16)) >> 8) | (((
(__uint32_t)(dump.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.nVolumes)) << 24)) : __bswap32_var
(dump.nVolumes)) - volumesDeleted)) & (0xff << 8)) <<
8) | (((__uint32_t)((__builtin_constant_p(dump.nVolumes) ? (
(((__uint32_t)(dump.nVolumes)) >> 24) | ((((__uint32_t)
(dump.nVolumes)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(dump.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.nVolumes)) << 24)) : __bswap32_var
(dump.nVolumes)) - volumesDeleted)) << 24)) : __bswap32_var
((__builtin_constant_p(dump.nVolumes) ? ((((__uint32_t)(dump.
nVolumes)) >> 24) | ((((__uint32_t)(dump.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(dump
.nVolumes)) << 24)) : __bswap32_var(dump.nVolumes)) - volumesDeleted
));
852 eval = dbwrite(ut, dumpAddr, &dump, sizeof(dump));
853 if (eval)
854 ERROR(eval)do { code = eval; goto error_exit; } while (0);
855
856 error_exit:
857 return (code);
858}
859
860/* deleteDump
861 * deletes a dump in stages, by repeatedly deleting a small number of
862 * volumes from the dump until none are left. The dump is then deleted.
863 *
864 * In the case where multiple calls are made to delete the same
865 * dump, the operation will succeed but contention for structures
866 * will result in someone getting back an error.
867 *
868 * entry:
869 * id - id of dump to delete
870 */
871
872afs_int32
873deleteDump(struct rx_call *call, dumpIdafs_uint32 id, budb_dumpsList *dumps)
874{
875 struct ubik_trans *ut;
876 dbadr dumpAddr, tapeAddr, appendedDump;
877 struct dump dump;
878 struct tape tape;
879 dumpIdafs_uint32 dumpid;
880 afs_int32 eval, code = 0;
881 int partialDel = 0;
882
883 /* iterate until the dump is truly deleted */
884
885 dumpid = id;
886 while (dumpid) {
887 partialDel = 0;
888 while (1) {
889 eval = InitRPC(&ut, LOCKWRITE2, 1);
890 if (eval)
891 ERROR(eval)do { code = eval; goto error_exit; } while (0); /* can't start transaction */
892
893 eval =
894 ht_LookupEntry(ut, &db.dumpIden, &dumpid, &dumpAddr, &dump);
895 if (eval)
896 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
897 if (!dumpAddr)
898 ABORT(BUDB_NOENT)do { code = (156303877L); goto abort_exit; } while (0); /* can't find dump */
899
900 if ((dumpid == id) && (dump.initialDumpID)) /* can't be an appended dump */
901 ABORT(BUDB_NOTINITIALDUMP)do { code = (156303902L); goto abort_exit; } while (0);
902
903 tapeAddr = ntohl(dump.firstTape)(__builtin_constant_p(dump.firstTape) ? ((((__uint32_t)(dump.
firstTape)) >> 24) | ((((__uint32_t)(dump.firstTape)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump.firstTape
)) & (0xff << 8)) << 8) | (((__uint32_t)(dump
.firstTape)) << 24)) : __bswap32_var(dump.firstTape));
904 if (tapeAddr == 0)
905 break;
906
907 /* there is a tape to delete */
908 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
909 if (eval)
910 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
911
912 if (ntohl(tape.nVolumes)(__builtin_constant_p(tape.nVolumes) ? ((((__uint32_t)(tape.nVolumes
)) >> 24) | ((((__uint32_t)(tape.nVolumes)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.nVolumes)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.nVolumes
)) << 24)) : __bswap32_var(tape.nVolumes))) {
913 /* tape is not empty */
914 eval = deleteSomeVolumesFromTape(ut, tapeAddr, &tape, 10);
915 if (eval)
916 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
917 }
918
919 if (ntohl(tape.nVolumes)(__builtin_constant_p(tape.nVolumes) ? ((((__uint32_t)(tape.nVolumes
)) >> 24) | ((((__uint32_t)(tape.nVolumes)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.nVolumes)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.nVolumes
)) << 24)) : __bswap32_var(tape.nVolumes)) == 0) {
920 /* tape is now empty, delete it */
921 eval = DeleteTape(ut, tapeAddr, &tape);
922 if (eval)
923 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
924 eval = ht_HashOut(ut, &db.tapeName, tapeAddr, &tape);
925 if (eval)
926 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
927 eval = FreeStructure(ut, tape_BLOCK3, tapeAddr);
928 if (eval)
929 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
930 }
931
932 eval = ubik_EndTrans(ut);
933 if (eval)
934 ERROR(eval)do { code = eval; goto error_exit; } while (0);
935 partialDel = 1;
936 } /* next deletion portion */
937
938 /* Record the dump just deleted */
939 if (dumps && (dumps->budb_dumpsList_len < BUDB_MAX_RETURN_LIST1000)) {
940 if (dumps->budb_dumpsList_len == 0)
941 dumps->budb_dumpsList_val =
942 (afs_int32 *) malloc(sizeof(afs_int32));
943 else
944 dumps->budb_dumpsList_val =
945 (afs_int32 *) realloc(dumps->budb_dumpsList_val,
946 (dumps->budb_dumpsList_len +
947 1) * sizeof(afs_int32));
948
949 if (!dumps->budb_dumpsList_val)
950 ABORT(BUDB_NOMEM)do { code = (156303901L); goto abort_exit; } while (0);
951
952 dumps->budb_dumpsList_val[dumps->budb_dumpsList_len] = dumpid;
953 dumps->budb_dumpsList_len++;
954 }
955
956 appendedDump = ntohl(dump.appendedDumpChain)(__builtin_constant_p(dump.appendedDumpChain) ? ((((__uint32_t
)(dump.appendedDumpChain)) >> 24) | ((((__uint32_t)(dump
.appendedDumpChain)) & (0xff << 16)) >> 8) | (
(((__uint32_t)(dump.appendedDumpChain)) & (0xff << 8
)) << 8) | (((__uint32_t)(dump.appendedDumpChain)) <<
24)) : __bswap32_var(dump.appendedDumpChain));
957
958 /* finally done. No more tapes left in the dump. Delete the dump itself */
959 eval = DeleteDump(ut, dumpAddr, &dump);
960 if (eval)
961 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
962
963 /* Now delete the appended dump too */
964 if (appendedDump) {
965 eval = dbread(ut, appendedDump, &dump, sizeof(dump));
966 if (eval)
967 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
968
969 dumpid = ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id));
970 } else
971 dumpid = 0;
972
973 eval = ubik_EndTrans(ut);
974 if (eval)
975 ERROR(eval)do { code = eval; goto error_exit; } while (0);
976
977 Log("Delete dump %s (DumpID %u), path %s\n", dump.dumpName,
978 ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)), dump.dumpPath);
979 }
980
981 error_exit:
982 if (code && partialDel) {
983 Log("Delete dump %s (DumpID %u), path %s - INCOMPLETE (code = %u)\n",
984 dump.dumpName, ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)), dump.dumpPath, code);
985 }
986 return (code);
987
988 abort_exit:
989 ubik_AbortTrans(ut);
990 goto error_exit;
991}
992
993/* --------------
994 * dump selection routines - used by BUDB_GetDumps
995 * --------------
996 */
997
998/* most recent dump selection */
999
1000struct chosenDump {
1001 struct chosenDump *next;
1002 dbadr addr;
1003 afs_uint32 date;
1004};
1005
1006struct wantDumpRock {
1007 int maxDumps; /* max wanted */
1008 int ndumps; /* actual in chain */
1009 struct chosenDump *chain;
1010};
1011
1012
1013int
1014wantDump(dbadr dumpAddr, void *dumpParam, void *dumpListPtrParam)
1015{
1016 struct dump *dumpPtr;
1017 struct wantDumpRock *rockPtr;
1018
1019 dumpPtr = (struct dump *)dumpParam;
1020 rockPtr = (struct wantDumpRock *)dumpListPtrParam;
1021
1022 /* if we don't have our full complement, just add another */
1023 if (rockPtr->ndumps < rockPtr->maxDumps)
1024 return (1);
1025
1026 /* got the number we need, select based on date */
1027 if ((afs_uint32) ntohl(dumpPtr->created)(__builtin_constant_p(dumpPtr->created) ? ((((__uint32_t)(
dumpPtr->created)) >> 24) | ((((__uint32_t)(dumpPtr->
created)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(dumpPtr->created)) & (0xff << 8)) << 8) |
(((__uint32_t)(dumpPtr->created)) << 24)) : __bswap32_var
(dumpPtr->created)) > rockPtr->chain->date)
1028 return (1);
1029
1030 return (0);
1031}
1032
1033int
1034rememberDump(dbadr dumpAddr, void *dumpParam, void *dumpListPtrParam)
1035{
1036 struct dump *dumpPtr;
1037 struct wantDumpRock *rockPtr;
1038 struct chosenDump *ptr, *deletedPtr, **nextPtr;
1039
1040 dumpPtr = (struct dump *)dumpParam;
1041 rockPtr = (struct wantDumpRock *)dumpListPtrParam;
1042
1043 ptr = (struct chosenDump *)malloc(sizeof(*ptr));
1044 if (!ptr)
1045 return (0);
1046 memset(ptr, 0, sizeof(*ptr));
1047 ptr->addr = dumpAddr;
1048 ptr->date = (afs_uint32) ntohl(dumpPtr->created)(__builtin_constant_p(dumpPtr->created) ? ((((__uint32_t)(
dumpPtr->created)) >> 24) | ((((__uint32_t)(dumpPtr->
created)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(dumpPtr->created)) & (0xff << 8)) << 8) |
(((__uint32_t)(dumpPtr->created)) << 24)) : __bswap32_var
(dumpPtr->created));
1049
1050 /* Don't overflow the max */
1051 while (rockPtr->ndumps >= rockPtr->maxDumps) {
1052 /* have to drop one */
1053 deletedPtr = rockPtr->chain;
1054 rockPtr->chain = deletedPtr->next;
1055 free(deletedPtr);
1056 rockPtr->ndumps--;
1057 }
1058
1059 /* now insert in the right place */
1060 for (nextPtr = &rockPtr->chain; *nextPtr; nextPtr = &((*nextPtr)->next)) {
1061 if (ptr->date < (*nextPtr)->date)
1062 break;
1063 }
1064 ptr->next = *nextPtr;
1065 *nextPtr = ptr;
1066 rockPtr->ndumps++;
1067
1068 return (0);
1069}
1070
1071
1072/* ---------------------------------------------
1073 * general interface routines - alphabetic
1074 * ---------------------------------------------
1075 */
1076
1077afs_int32
1078SBUDB_AddVolume(struct rx_call *call, struct budb_volumeEntry *vol)
1079{
1080 afs_int32 code;
1081
1082 code = AddVolume(call, vol);
1083 osi_auditU(call, BUDB_AddVolEvent"AFS_BUDB_AddVol", code, AUD_LONG5, (vol ? vol->id : 0),
1084 AUD_END0);
1085 return code;
1086}
1087
1088afs_int32
1089AddVolume(struct rx_call *call, struct budb_volumeEntry *vol)
1090{
1091 struct ubik_trans *ut;
1092 dbadr da, ta, via, va;
1093 struct dump d;
1094 struct tape t;
1095 struct volInfo vi;
1096 struct volFragment v;
1097 afs_uint32 bytes;
1098 afs_int32 eval, code = 0;
1099
1100 if (!callPermitted(call))
1101 return BUDB_NOTPERMITTED(156303880L);
1102
1103 if ((strlen(vol->name) >= sizeof(vi.name))
1104 || (strlen(vol->server) >= sizeof(vi.server))
1105 || (strlen(vol->tape) >= sizeof(t.name)))
1106 return BUDB_BADARGUMENT(156303882L);
1107
1108 eval = InitRPC(&ut, LOCKWRITE2, 1);
1109 if (eval)
1110 return eval;
1111
1112 /* Find the dump in dumpid hash table */
1113 eval = ht_LookupEntry(ut, &db.dumpIden, &vol->dump, &da, &d);
1114 if (eval)
1115 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1116 if (!da)
1117 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
1118
1119 /* search for the right tape in the dump */
1120 for (ta = ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape)); ta; ta = ntohl(t.nextTape)(__builtin_constant_p(t.nextTape) ? ((((__uint32_t)(t.nextTape
)) >> 24) | ((((__uint32_t)(t.nextTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nextTape)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nextTape)) << 24)) :
__bswap32_var(t.nextTape))) {
1121 /* read the tape entry */
1122 eval = dbread(ut, ta, &t, sizeof(t));
1123 if (eval)
1124 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1125
1126 /* Check if the right tape name */
1127 if (strcmp(t.name, vol->tape) == 0)
1128 break;
1129 }
1130 if (!ta)
1131 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
1132
1133 if ((t.dump != htonl(da)(__builtin_constant_p(da) ? ((((__uint32_t)(da)) >> 24)
| ((((__uint32_t)(da)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(da)) & (0xff << 8)) << 8) |
(((__uint32_t)(da)) << 24)) : __bswap32_var(da))) || /* tape must belong to dump */
1134 ((ntohl(t.flags)(__builtin_constant_p(t.flags) ? ((((__uint32_t)(t.flags)) >>
24) | ((((__uint32_t)(t.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.flags)) << 24)) : __bswap32_var(
t.flags)) & BUDB_TAPE_BEINGWRITTEN(1<<2)) == 0) || /* tape must be being written */
1135 ((ntohl(d.flags)(__builtin_constant_p(d.flags) ? ((((__uint32_t)(d.flags)) >>
24) | ((((__uint32_t)(d.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.flags)) << 24)) : __bswap32_var(
d.flags)) & BUDB_DUMP_INPROGRESS(1<<2)) == 0)) /* dump must be in progress */
1136 ABORT(BUDB_BADPROTOCOL)do { code = (156303883L); goto abort_exit; } while (0);
1137
1138 /* find or create a volume info structure */
1139 eval = GetVolInfo(ut, vol, &via, &vi);
1140 if (eval)
1141 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1142
1143 /* Create a volume fragment */
1144 eval = AllocStructure(ut, volFragment_BLOCK1, 0, &va, &v);
1145 if (eval)
1146 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1147
1148 v.vol = htonl(via)(__builtin_constant_p(via) ? ((((__uint32_t)(via)) >> 24
) | ((((__uint32_t)(via)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(via)) & (0xff << 8)) << 8
) | (((__uint32_t)(via)) << 24)) : __bswap32_var(via)); /* vol frag points to vol info */
1149 v.sameNameChain = vi.firstFragment; /* vol frag is chained to vol info */
1150 vi.firstFragment = htonl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
1151 vi.nFrags = htonl(ntohl(vi.nFrags) + 1)(__builtin_constant_p((__builtin_constant_p(vi.nFrags) ? ((((
__uint32_t)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vi
.nFrags)) & (0xff << 8)) << 8) | (((__uint32_t
)(vi.nFrags)) << 24)) : __bswap32_var(vi.nFrags)) + 1) ?
((((__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) + 1)) & (0xff << 8)) << 8) | (((
__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1));
1152
1153 eval = dbwrite(ut, via, &vi, sizeof(vi)); /* write the vol info struct */
1154 if (eval)
1155 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1156
1157 v.tape = htonl(ta)(__builtin_constant_p(ta) ? ((((__uint32_t)(ta)) >> 24)
| ((((__uint32_t)(ta)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(ta)) & (0xff << 8)) << 8) |
(((__uint32_t)(ta)) << 24)) : __bswap32_var(ta)); /* vol frag points to tape */
1158 v.sameTapeChain = t.firstVol; /* vol frag is chained to tape info */
1159 t.firstVol = htonl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
1160 t.nVolumes = htonl(ntohl(t.nVolumes) + 1)(__builtin_constant_p((__builtin_constant_p(t.nVolumes) ? (((
(__uint32_t)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(t.
nVolumes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nVolumes)) << 24)) : __bswap32_var(t.nVolumes)) + 1
) ? ((((__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(t.nVolumes) ? ((((__uint32_t)(t.nVolumes)) >> 24) | ((
((__uint32_t)(t.nVolumes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nVolumes)) << 24)) : __bswap32_var
(t.nVolumes)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1));
1161 bytes = ntohl(t.nBytes)(__builtin_constant_p(t.nBytes) ? ((((__uint32_t)(t.nBytes)) >>
24) | ((((__uint32_t)(t.nBytes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nBytes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nBytes)) << 24)) : __bswap32_var
(t.nBytes)) + vol->nBytes; /* update bytes on tape */
1162 t.nMBytes = htonl(ntohl(t.nMBytes) + bytes / (1024 * 1024))(__builtin_constant_p((__builtin_constant_p(t.nMBytes) ? ((((
__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t)(t.nMBytes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(t.
nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024)) ? ((((__uint32_t)((__builtin_constant_p(t.nMBytes
) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024))) >> 24) | ((((__uint32_t)((__builtin_constant_p
(t.nMBytes) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((
__uint32_t)(t.nMBytes)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(t.nMBytes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nMBytes)) << 24)) : __bswap32_var
(t.nMBytes)) + bytes / (1024 * 1024))) & (0xff << 16
)) >> 8) | ((((__uint32_t)((__builtin_constant_p(t.nMBytes
) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024))) & (0xff << 8)) << 8) | (((
__uint32_t)((__builtin_constant_p(t.nMBytes) ? ((((__uint32_t
)(t.nMBytes)) >> 24) | ((((__uint32_t)(t.nMBytes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nMBytes)
) & (0xff << 8)) << 8) | (((__uint32_t)(t.nMBytes
)) << 24)) : __bswap32_var(t.nMBytes)) + bytes / (1024 *
1024))) << 24)) : __bswap32_var((__builtin_constant_p(
t.nMBytes) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024)));
1163 t.nBytes = htonl(bytes % (1024 * 1024))(__builtin_constant_p(bytes % (1024 * 1024)) ? ((((__uint32_t
)(bytes % (1024 * 1024))) >> 24) | ((((__uint32_t)(bytes
% (1024 * 1024))) & (0xff << 16)) >> 8) | ((
((__uint32_t)(bytes % (1024 * 1024))) & (0xff << 8)
) << 8) | (((__uint32_t)(bytes % (1024 * 1024))) <<
24)) : __bswap32_var(bytes % (1024 * 1024)));
1164
1165 eval = dbwrite(ut, ta, &t, sizeof(t)); /* write the tape structure */
1166 if (eval)
1167 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1168
1169 d.nVolumes = htonl(ntohl(d.nVolumes) + 1)(__builtin_constant_p((__builtin_constant_p(d.nVolumes) ? (((
(__uint32_t)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
nVolumes)) & (0xff << 8)) << 8) | (((__uint32_t
)(d.nVolumes)) << 24)) : __bswap32_var(d.nVolumes)) + 1
) ? ((((__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(d.nVolumes) ? ((((__uint32_t)(d.nVolumes)) >> 24) | ((
((__uint32_t)(d.nVolumes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.nVolumes)) << 24)) : __bswap32_var
(d.nVolumes)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)); /* one more volume on dump */
1170
1171 eval = dbwrite(ut, da, &d, sizeof(d)); /* write out the dump structure */
1172 if (eval)
1173 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1174
1175 v.position = htonl(vol->position)(__builtin_constant_p(vol->position) ? ((((__uint32_t)(vol
->position)) >> 24) | ((((__uint32_t)(vol->position
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vol
->position)) & (0xff << 8)) << 8) | (((__uint32_t
)(vol->position)) << 24)) : __bswap32_var(vol->position
)); /* vol frag info */
1176 v.clone = htonl(vol->clone)(__builtin_constant_p(vol->clone) ? ((((__uint32_t)(vol->
clone)) >> 24) | ((((__uint32_t)(vol->clone)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(vol->clone
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
clone)) << 24)) : __bswap32_var(vol->clone));
1177 v.incTime = htonl(vol->incTime)(__builtin_constant_p(vol->incTime) ? ((((__uint32_t)(vol->
incTime)) >> 24) | ((((__uint32_t)(vol->incTime)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vol->incTime
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
incTime)) << 24)) : __bswap32_var(vol->incTime));
1178 v.startByte = htonl(vol->startByte)(__builtin_constant_p(vol->startByte) ? ((((__uint32_t)(vol
->startByte)) >> 24) | ((((__uint32_t)(vol->startByte
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vol
->startByte)) & (0xff << 8)) << 8) | (((__uint32_t
)(vol->startByte)) << 24)) : __bswap32_var(vol->startByte
));
1179 v.nBytes = htonl(vol->nBytes)(__builtin_constant_p(vol->nBytes) ? ((((__uint32_t)(vol->
nBytes)) >> 24) | ((((__uint32_t)(vol->nBytes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vol->nBytes
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
nBytes)) << 24)) : __bswap32_var(vol->nBytes));
1180 v.flags = htons(vol->flags & VOLFRAGMENTFLAGS)(__builtin_constant_p(vol->flags & 0xffff) ? (__uint16_t
)(((__uint16_t)(vol->flags & 0xffff)) << 8 | ((__uint16_t
)(vol->flags & 0xffff)) >> 8) : __bswap16_var(vol
->flags & 0xffff));
1181 v.sequence = htons(vol->seq)(__builtin_constant_p(vol->seq) ? (__uint16_t)(((__uint16_t
)(vol->seq)) << 8 | ((__uint16_t)(vol->seq)) >>
8) : __bswap16_var(vol->seq));
1182
1183 eval = dbwrite(ut, va, &v, sizeof(v)); /* write out the vol frag struct */
1184 if (eval)
1185 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1186
1187 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
1188 if (eval)
1189 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1190
1191 LogDebug(4, "added volume %s at %d\n", vol->name, va);
1192
1193 code = ubik_EndTrans(ut);
1194 return code;
1195
1196 abort_exit:
1197 ubik_AbortTrans(ut);
1198 return code;
1199}
1200
1201
1202afs_int32
1203SBUDB_AddVolumes(struct rx_call *call, struct budb_volumeList *vols)
1204{
1205 afs_int32 code;
1206
1207 code = AddVolumes(call, vols);
1208 osi_auditU(call, BUDB_AddVolEvent"AFS_BUDB_AddVol", code, AUD_LONG5, 0, AUD_END0);
1209 return code;
1210}
1211
1212afs_int32
1213AddVolumes(struct rx_call *call, struct budb_volumeList *vols)
1214{
1215 struct budb_volumeEntry *vol, *vol1;
1216 struct ubik_trans *ut;
1217 dbadr da, ta, via, va;
1218 struct dump d;
1219 struct tape t;
1220 struct volInfo vi;
1221 struct volFragment v;
1222 afs_uint32 bytes;
1223 afs_int32 eval, e, code = 0;
1224
1225 if (!callPermitted(call))
1226 return BUDB_NOTPERMITTED(156303880L);
1227
1228 if (!vols || (vols->budb_volumeList_len <= 0)
1229 || !vols->budb_volumeList_val)
1230 return BUDB_BADARGUMENT(156303882L);
1231
1232 /* The first volume in the list of volumes to add */
1233 vol1 = (struct budb_volumeEntry *)vols->budb_volumeList_val;
1234
1235 eval = InitRPC(&ut, LOCKWRITE2, 1);
1236 if (eval)
1237 return eval;
1238
1239 /* Find the dump in dumpid hash table */
1240 eval = ht_LookupEntry(ut, &db.dumpIden, &vol1->dump, &da, &d);
1241 if (eval)
1242 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1243 if (!da)
1244 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
1245
1246 /* search for the right tape in the dump */
1247 for (ta = ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape)); ta; ta = ntohl(t.nextTape)(__builtin_constant_p(t.nextTape) ? ((((__uint32_t)(t.nextTape
)) >> 24) | ((((__uint32_t)(t.nextTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nextTape)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nextTape)) << 24)) :
__bswap32_var(t.nextTape))) {
1248 /* read the tape entry */
1249 eval = dbread(ut, ta, &t, sizeof(t));
1250 if (eval)
1251 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1252
1253 /* Check if the right tape name */
1254 if (strcmp(t.name, vol1->tape) == 0)
1255 break;
1256 }
1257 if (!ta)
1258 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
1259
1260 if ((t.dump != htonl(da)(__builtin_constant_p(da) ? ((((__uint32_t)(da)) >> 24)
| ((((__uint32_t)(da)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(da)) & (0xff << 8)) << 8) |
(((__uint32_t)(da)) << 24)) : __bswap32_var(da))) || /* tape must belong to dump */
1261 ((ntohl(t.flags)(__builtin_constant_p(t.flags) ? ((((__uint32_t)(t.flags)) >>
24) | ((((__uint32_t)(t.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.flags)) << 24)) : __bswap32_var(
t.flags)) & BUDB_TAPE_BEINGWRITTEN(1<<2)) == 0) || /* tape must be being written */
1262 ((ntohl(d.flags)(__builtin_constant_p(d.flags) ? ((((__uint32_t)(d.flags)) >>
24) | ((((__uint32_t)(d.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.flags)) << 24)) : __bswap32_var(
d.flags)) & BUDB_DUMP_INPROGRESS(1<<2)) == 0)) /* dump must be in progress */
1263 ABORT(BUDB_BADPROTOCOL)do { code = (156303883L); goto abort_exit; } while (0);
1264
1265 for (vol = vol1, e = 0; e < vols->budb_volumeList_len; vol++, e++) {
1266 /*v */
1267 if ((strlen(vol->name) >= sizeof(vi.name)) || (strcmp(vol->name, "") == 0) || /* no null volnames */
1268 (strlen(vol->server) >= sizeof(vi.server))
1269 || (strlen(vol->tape) >= sizeof(t.name))
1270 || (strcmp(vol->tape, vol1->tape) != 0)) {
1271 Log("Volume '%s' %u, tape '%s', dumpID %u is an invalid entry - not added\n", vol->name, vol->id, vol->tape, vol->dump);
1272 continue;
1273 }
1274
1275 /* find or create a volume info structure */
1276 eval = GetVolInfo(ut, vol, &via, &vi);
1277 if (eval)
1278 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1279 if (*(afs_int32 *) (&vi) == 0) {
1280 Log("Volume '%s', tape '%s', dumpID %u is an invalid entry - aborted\n", vol->name, vol->tape, vol->dump);
1281 ABORT(BUDB_BADARGUMENT)do { code = (156303882L); goto abort_exit; } while (0);
1282 }
1283
1284 /* Create a volume fragment */
1285 eval = AllocStructure(ut, volFragment_BLOCK1, 0, &va, &v);
1286 if (eval)
1287 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1288
1289 v.vol = htonl(via)(__builtin_constant_p(via) ? ((((__uint32_t)(via)) >> 24
) | ((((__uint32_t)(via)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(via)) & (0xff << 8)) << 8
) | (((__uint32_t)(via)) << 24)) : __bswap32_var(via)); /* vol frag points to vol info */
1290 v.sameNameChain = vi.firstFragment; /* vol frag is chained to vol info */
1291 vi.firstFragment = htonl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
1292 vi.nFrags = htonl(ntohl(vi.nFrags) + 1)(__builtin_constant_p((__builtin_constant_p(vi.nFrags) ? ((((
__uint32_t)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vi
.nFrags)) & (0xff << 8)) << 8) | (((__uint32_t
)(vi.nFrags)) << 24)) : __bswap32_var(vi.nFrags)) + 1) ?
((((__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(vi.nFrags) ? ((((__uint32_t)(vi.nFrags)) >> 24) | ((((
__uint32_t)(vi.nFrags)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(vi.nFrags)) & (0xff << 8)) <<
8) | (((__uint32_t)(vi.nFrags)) << 24)) : __bswap32_var
(vi.nFrags)) + 1)) & (0xff << 8)) << 8) | (((
__uint32_t)((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(vi.nFrags) ? ((((__uint32_t
)(vi.nFrags)) >> 24) | ((((__uint32_t)(vi.nFrags)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vi.nFrags)
) & (0xff << 8)) << 8) | (((__uint32_t)(vi.nFrags
)) << 24)) : __bswap32_var(vi.nFrags)) + 1));
1293 eval = dbwrite(ut, via, &vi, sizeof(vi)); /* write the vol info struct */
1294 if (eval)
1295 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1296
1297 v.tape = htonl(ta)(__builtin_constant_p(ta) ? ((((__uint32_t)(ta)) >> 24)
| ((((__uint32_t)(ta)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(ta)) & (0xff << 8)) << 8) |
(((__uint32_t)(ta)) << 24)) : __bswap32_var(ta)); /* vol frag points to tape */
1298 v.sameTapeChain = t.firstVol; /* vol frag is chained to tape info */
1299 t.firstVol = htonl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
1300 t.nVolumes = htonl(ntohl(t.nVolumes) + 1)(__builtin_constant_p((__builtin_constant_p(t.nVolumes) ? (((
(__uint32_t)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(t.
nVolumes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nVolumes)) << 24)) : __bswap32_var(t.nVolumes)) + 1
) ? ((((__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(t.nVolumes) ? ((((__uint32_t)(t.nVolumes)) >> 24) | ((
((__uint32_t)(t.nVolumes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nVolumes)) << 24)) : __bswap32_var
(t.nVolumes)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(t.nVolumes) ? ((((__uint32_t
)(t.nVolumes)) >> 24) | ((((__uint32_t)(t.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(t.nVolumes
)) << 24)) : __bswap32_var(t.nVolumes)) + 1));
1301 bytes = ntohl(t.nBytes)(__builtin_constant_p(t.nBytes) ? ((((__uint32_t)(t.nBytes)) >>
24) | ((((__uint32_t)(t.nBytes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.nBytes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nBytes)) << 24)) : __bswap32_var
(t.nBytes)) + vol->nBytes; /* update bytes on tape */
1302 t.nMBytes = htonl(ntohl(t.nMBytes) + bytes / (1024 * 1024))(__builtin_constant_p((__builtin_constant_p(t.nMBytes) ? ((((
__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t)(t.nMBytes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(t.
nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024)) ? ((((__uint32_t)((__builtin_constant_p(t.nMBytes
) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024))) >> 24) | ((((__uint32_t)((__builtin_constant_p
(t.nMBytes) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((
__uint32_t)(t.nMBytes)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(t.nMBytes)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.nMBytes)) << 24)) : __bswap32_var
(t.nMBytes)) + bytes / (1024 * 1024))) & (0xff << 16
)) >> 8) | ((((__uint32_t)((__builtin_constant_p(t.nMBytes
) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024))) & (0xff << 8)) << 8) | (((
__uint32_t)((__builtin_constant_p(t.nMBytes) ? ((((__uint32_t
)(t.nMBytes)) >> 24) | ((((__uint32_t)(t.nMBytes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(t.nMBytes)
) & (0xff << 8)) << 8) | (((__uint32_t)(t.nMBytes
)) << 24)) : __bswap32_var(t.nMBytes)) + bytes / (1024 *
1024))) << 24)) : __bswap32_var((__builtin_constant_p(
t.nMBytes) ? ((((__uint32_t)(t.nMBytes)) >> 24) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(t.nMBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(t.nMBytes)) << 24)) : __bswap32_var(t.nMBytes)) + bytes
/ (1024 * 1024)));
1303 t.nBytes = htonl(bytes % (1024 * 1024))(__builtin_constant_p(bytes % (1024 * 1024)) ? ((((__uint32_t
)(bytes % (1024 * 1024))) >> 24) | ((((__uint32_t)(bytes
% (1024 * 1024))) & (0xff << 16)) >> 8) | ((
((__uint32_t)(bytes % (1024 * 1024))) & (0xff << 8)
) << 8) | (((__uint32_t)(bytes % (1024 * 1024))) <<
24)) : __bswap32_var(bytes % (1024 * 1024)));
1304
1305 d.nVolumes = htonl(ntohl(d.nVolumes) + 1)(__builtin_constant_p((__builtin_constant_p(d.nVolumes) ? (((
(__uint32_t)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
nVolumes)) & (0xff << 8)) << 8) | (((__uint32_t
)(d.nVolumes)) << 24)) : __bswap32_var(d.nVolumes)) + 1
) ? ((((__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) >> 24
) | ((((__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)((__builtin_constant_p
(d.nVolumes) ? ((((__uint32_t)(d.nVolumes)) >> 24) | ((
((__uint32_t)(d.nVolumes)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.nVolumes)) << 24)) : __bswap32_var
(d.nVolumes)) + 1)) & (0xff << 8)) << 8) | ((
(__uint32_t)((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)) << 24
)) : __bswap32_var((__builtin_constant_p(d.nVolumes) ? ((((__uint32_t
)(d.nVolumes)) >> 24) | ((((__uint32_t)(d.nVolumes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(d.nVolumes
)) & (0xff << 8)) << 8) | (((__uint32_t)(d.nVolumes
)) << 24)) : __bswap32_var(d.nVolumes)) + 1)); /* one more volume on dump */
1306
1307 v.position = htonl(vol->position)(__builtin_constant_p(vol->position) ? ((((__uint32_t)(vol
->position)) >> 24) | ((((__uint32_t)(vol->position
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vol
->position)) & (0xff << 8)) << 8) | (((__uint32_t
)(vol->position)) << 24)) : __bswap32_var(vol->position
)); /* vol frag info */
1308 v.clone = htonl(vol->clone)(__builtin_constant_p(vol->clone) ? ((((__uint32_t)(vol->
clone)) >> 24) | ((((__uint32_t)(vol->clone)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(vol->clone
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
clone)) << 24)) : __bswap32_var(vol->clone));
1309 v.incTime = htonl(vol->incTime)(__builtin_constant_p(vol->incTime) ? ((((__uint32_t)(vol->
incTime)) >> 24) | ((((__uint32_t)(vol->incTime)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vol->incTime
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
incTime)) << 24)) : __bswap32_var(vol->incTime));
1310 v.startByte = htonl(vol->startByte)(__builtin_constant_p(vol->startByte) ? ((((__uint32_t)(vol
->startByte)) >> 24) | ((((__uint32_t)(vol->startByte
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vol
->startByte)) & (0xff << 8)) << 8) | (((__uint32_t
)(vol->startByte)) << 24)) : __bswap32_var(vol->startByte
));
1311 v.nBytes = htonl(vol->nBytes)(__builtin_constant_p(vol->nBytes) ? ((((__uint32_t)(vol->
nBytes)) >> 24) | ((((__uint32_t)(vol->nBytes)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(vol->nBytes
)) & (0xff << 8)) << 8) | (((__uint32_t)(vol->
nBytes)) << 24)) : __bswap32_var(vol->nBytes));
1312 v.flags = htons(vol->flags & VOLFRAGMENTFLAGS)(__builtin_constant_p(vol->flags & 0xffff) ? (__uint16_t
)(((__uint16_t)(vol->flags & 0xffff)) << 8 | ((__uint16_t
)(vol->flags & 0xffff)) >> 8) : __bswap16_var(vol
->flags & 0xffff));
1313 v.sequence = htons(vol->seq)(__builtin_constant_p(vol->seq) ? (__uint16_t)(((__uint16_t
)(vol->seq)) << 8 | ((__uint16_t)(vol->seq)) >>
8) : __bswap16_var(vol->seq));
1314
1315 eval = dbwrite(ut, va, &v, sizeof(v)); /* write out the vol frag struct */
1316 if (eval)
1317 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1318
1319 LogDebug(4, "added volume %s at %d\n", vol->name, va);
1320 } /*v */
1321
1322 eval = dbwrite(ut, ta, &t, sizeof(t)); /* write the tape structure */
1323 if (eval)
1324 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1325
1326 eval = dbwrite(ut, da, &d, sizeof(d)); /* write out the dump structure */
1327 if (eval)
1328 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1329
1330 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
1331 if (eval)
1332 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1333
1334 code = ubik_EndTrans(ut);
1335 return code;
1336
1337 abort_exit:
1338 ubik_AbortTrans(ut);
1339 return code;
1340}
1341
1342
1343/* BUDB_CreateDump
1344 * records the existence of a dump in the database. This creates only
1345 * the dump record, to which one must attach tape and volume records.
1346 * TBD
1347 * 1) record the volume set
1348 */
1349
1350afs_int32
1351SBUDB_CreateDump(struct rx_call *call, struct budb_dumpEntry *dump)
1352{
1353 afs_int32 code;
1354
1355 code = CreateDump(call, dump);
1356 osi_auditU(call, BUDB_CrDmpEvent"AFS_BUDB_CrDmp", code, AUD_DATE6, (dump ? dump->id : 0),
1357 AUD_END0);
1358 if (dump && !code) {
1359 Log("Create dump %s (DumpID %u), path %s\n", dump->name, dump->id,
1360 dump->dumpPath);
1361 }
1362 return code;
1363}
1364
1365afs_int32
1366CreateDump(struct rx_call *call, struct budb_dumpEntry *dump)
1367{
1368 struct ubik_trans *ut;
1369 dbadr findDumpAddr, da;
1370 struct dump findDump, d;
1371 afs_int32 eval, code = 0;
1372
1373 rxkad_level level;
1374 afs_int32 kvno;
1375 Dateafs_uint32 expiration; /* checked by Security Module */
1376 struct ktc_principal principal;
1377
1378 if (!callPermitted(call))
1379 return BUDB_NOTPERMITTED(156303880L);
1380
1381 if (strlen(dump->name) >= sizeof(d.dumpName))
1382 return BUDB_BADARGUMENT(156303882L);
1383
1384 eval = InitRPC(&ut, LOCKWRITE2, 1);
1385 if (eval)
1386 return eval;
1387
1388 eval =
1389 rxkad_GetServerInfo(rx_ConnectionOf(call)((call)->conn), &level, &expiration,
1390 principal.name, principal.instance,
1391 principal.cell, &kvno);
1392
1393 if (eval) {
1394 if (eval != RXKADNOAUTH(19270405L))
1395 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1396
1397 strcpy(principal.name, "");
1398 strcpy(principal.instance, "");
1399 strcpy(principal.cell, "");
1400 expiration = 0;
1401 } else {
1402 /* authenticated. Take user supplied principal information */
1403 if (strcmp(dump->dumper.name, "") != 0)
1404 strncpy(principal.name, dump->dumper.name,
1405 sizeof(principal.name));
1406
1407 if (strcmp(dump->dumper.instance, "") != 0)
1408 strncpy(principal.instance, dump->dumper.instance,
1409 sizeof(principal.instance));
1410
1411 if (strcmp(dump->dumper.cell, "") != 0)
1412 strncpy(principal.cell, dump->dumper.cell,
1413 sizeof(principal.cell));
1414 }
1415
1416 /* dump id's are time stamps */
1417 if (!dump->id) {
1418 while (1) { /* allocate a unique dump id *//*w */
1419 dump->id = time(0);
1420
1421 /* ensure it is unique - seach for dumpid in hash table */
1422 eval =
1423 ht_LookupEntry(ut, &db.dumpIden, &dump->id, &findDumpAddr,
1424 &findDump);
1425 if (eval)
1426 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1427
1428 if (!findDumpAddr) { /* dumpid not in use */
1429 /* update the last dump id allocated */
1430 eval = set_header_word(ut, lastDumpId, htonl(dump->id))dbwrite ((ut), ((char *)&(db.h.lastDumpId) - (char *)&
db.h), ((db.h.lastDumpId = ((__builtin_constant_p(dump->id
) ? ((((__uint32_t)(dump->id)) >> 24) | ((((__uint32_t
)(dump->id)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(dump->id)) & (0xff << 8)) << 8) | (((__uint32_t
)(dump->id)) << 24)) : __bswap32_var(dump->id))))
, (char *)&(db.h.lastDumpId)), sizeof(afs_int32));
1431 if (eval)
1432 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1433 break;
1434 }
1435
1436 /* dump id is in use - wait a while */
1437#ifdef AFS_PTHREAD_ENV
1438 sleep(1);
1439#else
1440 IOMGR_Sleep(1);
1441#endif
1442 } /*w */
1443 } else {
1444 /* dump id supplied (e.g. for database restore) */
1445 eval =
1446 ht_LookupEntry(ut, &db.dumpIden, &dump->id, &findDumpAddr,
1447 &findDump);
1448 if (eval)
1449 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1450
1451 /* Dump id must not already exist */
1452 if (findDumpAddr)
1453 ABORT(BUDB_DUMPIDEXISTS)do { code = (156303872L); goto abort_exit; } while (0);
1454 }
1455
1456 /* Allocate a dump structure */
1457 memset(&d, 0, sizeof(d));
1458 eval = AllocStructure(ut, dump_BLOCK4, 0, &da, &d);
1459 if (eval)
1460 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1461
1462 strcpy(d.dumpName, dump->name); /* volset.dumpname */
1463 strcpy(d.dumpPath, dump->dumpPath); /* dump node path */
1464 strcpy(d.volumeSet, dump->volumeSetName); /* volume set */
1465 d.id = htonl(dump->id)(__builtin_constant_p(dump->id) ? ((((__uint32_t)(dump->
id)) >> 24) | ((((__uint32_t)(dump->id)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(dump->id)) &
(0xff << 8)) << 8) | (((__uint32_t)(dump->id)
) << 24)) : __bswap32_var(dump->id));
1466 d.parent = htonl(dump->parent)(__builtin_constant_p(dump->parent) ? ((((__uint32_t)(dump
->parent)) >> 24) | ((((__uint32_t)(dump->parent)
) & (0xff << 16)) >> 8) | ((((__uint32_t)(dump
->parent)) & (0xff << 8)) << 8) | (((__uint32_t
)(dump->parent)) << 24)) : __bswap32_var(dump->parent
)); /* parent id */
1467 d.level = htonl(dump->level)(__builtin_constant_p(dump->level) ? ((((__uint32_t)(dump->
level)) >> 24) | ((((__uint32_t)(dump->level)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump->level
)) & (0xff << 8)) << 8) | (((__uint32_t)(dump
->level)) << 24)) : __bswap32_var(dump->level));
1468
1469 LogDebug(4, "dump name %s, parent %d level %d\n", dump->name,
1470 dump->parent, dump->level);
1471
1472 /* if creation time specified, use that. Else use the dumpid time */
1473 if (dump->created == 0)
1474 dump->created = dump->id;
1475 d.created = htonl(dump->created)(__builtin_constant_p(dump->created) ? ((((__uint32_t)(dump
->created)) >> 24) | ((((__uint32_t)(dump->created
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(dump
->created)) & (0xff << 8)) << 8) | (((__uint32_t
)(dump->created)) << 24)) : __bswap32_var(dump->created
));
1476
1477 principal = d.dumper;
1478 tapeSet_hton(&dump->tapes, &d.tapes);
1479
1480 d.flags = htonl(dump->flags | BUDB_DUMP_INPROGRESS)(__builtin_constant_p(dump->flags | (1<<2)) ? ((((__uint32_t
)(dump->flags | (1<<2))) >> 24) | ((((__uint32_t
)(dump->flags | (1<<2))) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump->flags | (1<<2))) & (
0xff << 8)) << 8) | (((__uint32_t)(dump->flags
| (1<<2))) << 24)) : __bswap32_var(dump->flags
| (1<<2)));
1481
1482 eval = ht_HashIn(ut, &db.dumpName, da, &d); /* Into dump name hash table */
1483 if (eval)
1484 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1485
1486 eval = ht_HashIn(ut, &db.dumpIden, da, &d); /* Into dumpid hash table */
1487 if (eval)
1488 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1489
1490 eval = dbwrite(ut, da, (char *)&d, sizeof(d)); /* Write the dump structure */
1491 if (eval)
1492 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1493
1494 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
1495 if (eval)
1496 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1497
1498 /* If to append this dump, then append it - will write the appended dump */
1499 eval = makeAppended(ut, dump->id, dump->initialDumpID, dump->tapes.b);
1500 if (eval)
1501 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1502
1503 code = ubik_EndTrans(ut);
1504 LogDebug(5, "made dump %s, path %s\n", d.dumpName, d.dumpPath);
1505 return code;
1506
1507 abort_exit:
1508 ubik_AbortTrans(ut);
1509 return code;
1510}
1511
1512afs_int32
1513SBUDB_DeleteDump(struct rx_call *call, dumpIdafs_uint32 id, Dateafs_uint32 fromTime, Dateafs_uint32 toTime,
1514 budb_dumpsList *dumps)
1515{
1516 afs_int32 code;
1517
1518 code = DoDeleteDump(call, id, fromTime, toTime, dumps);
1519 osi_auditU(call, BUDB_DelDmpEvent"AFS_BUDB_DelDmp", code, AUD_DATE6, id, AUD_END0);
1520 return code;
1521}
1522
1523#define MAXOFFS30 30
1524
1525afs_int32
1526DoDeleteDump(struct rx_call *call, dumpIdafs_uint32 id, Dateafs_uint32 fromTime, Dateafs_uint32 toTime,
1527 budb_dumpsList *dumps)
1528{
1529 afs_int32 code = 0;
1530
1531 if (!callPermitted(call))
1532 return BUDB_NOTPERMITTED(156303880L);
1533
1534 if (id)
1535 code = deleteDump(call, id, dumps);
1536 return (code);
1537}
1538
1539afs_int32
1540SBUDB_ListDumps(struct rx_call *call, afs_int32 sflags, char *name,
1541 afs_int32 groupid, Dateafs_uint32 fromTime, Dateafs_uint32 toTime,
1542 budb_dumpsList *dumps, budb_dumpsList *flags)
1543{
1544 afs_int32 code;
1545
1546 code = ListDumps(call, sflags, groupid, fromTime, toTime, dumps, flags);
1547 osi_auditU(call, BUDB_LstDmpEvent"AFS_BUDB_LstDmp", code, AUD_LONG5, flags, AUD_END0);
1548 return code;
1549}
1550
1551afs_int32
1552ListDumps(struct rx_call *call, afs_int32 sflags, afs_int32 groupid,
1553 Dateafs_uint32 fromTime, Dateafs_uint32 toTime, budb_dumpsList *dumps,
1554 budb_dumpsList *flags)
1555{
1556 struct ubik_trans *ut;
1557 struct memoryHashTable *mht;
1558 struct dump diskDump, appDiskDump;
1559 dbadr dbAddr, dbAppAddr;
1560
1561 afs_int32 eval, code = 0;
1562 int old, hash, length, entrySize, count = 0;
1563
1564 if (!callPermitted(call))
1565 return BUDB_NOTPERMITTED(156303880L);
1566
1567 eval = InitRPC(&ut, LOCKREAD1, 1);
1568 if (eval)
1569 return (eval);
1570
1571 /* Search the database */
1572 mht = ht_GetType(HT_dumpIden_FUNCTION1, &entrySize);
1573 if (!mht)
1574 return (BUDB_BADARGUMENT(156303882L));
1575
1576 for (old = 0; old <= 1; old++) { /*o *//* old and new hash tables */
1577 length = (old ? mht->oldLength : mht->length);
1578 if (length == 0)
1579 continue;
1580
1581 for (hash = 0; hash < length; hash++) { /*h *//* for each hash bucket */
1582 for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr; dbAddr = ntohl(diskDump.idHashChain)(__builtin_constant_p(diskDump.idHashChain) ? ((((__uint32_t)
(diskDump.idHashChain)) >> 24) | ((((__uint32_t)(diskDump
.idHashChain)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskDump.idHashChain)) & (0xff << 8)) << 8)
| (((__uint32_t)(diskDump.idHashChain)) << 24)) : __bswap32_var
(diskDump.idHashChain))) { /*d */
1583
1584 /* read the entry */
1585 eval = dbread(ut, dbAddr, &diskDump, sizeof(diskDump));
1586 if (eval)
1587 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1588
1589 /* Skip appended dumps */
1590 if (ntohl(diskDump.initialDumpID)(__builtin_constant_p(diskDump.initialDumpID) ? ((((__uint32_t
)(diskDump.initialDumpID)) >> 24) | ((((__uint32_t)(diskDump
.initialDumpID)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(diskDump.initialDumpID)) & (0xff << 8))
<< 8) | (((__uint32_t)(diskDump.initialDumpID)) <<
24)) : __bswap32_var(diskDump.initialDumpID)) != 0) {
1591 continue;
1592 }
1593
1594 /* Skip dumps with different goup id */
1595 if ((sflags & BUDB_OP_GROUPID(0x02))
1596 && (ntohl(diskDump.tapes.id)(__builtin_constant_p(diskDump.tapes.id) ? ((((__uint32_t)(diskDump
.tapes.id)) >> 24) | ((((__uint32_t)(diskDump.tapes.id)
) & (0xff << 16)) >> 8) | ((((__uint32_t)(diskDump
.tapes.id)) & (0xff << 8)) << 8) | (((__uint32_t
)(diskDump.tapes.id)) << 24)) : __bswap32_var(diskDump.
tapes.id)) != groupid)) {
1597 continue; /*nope */
1598 }
1599
1600 /* Look at this dump to see if it meets the criteria for listing */
1601 if (sflags & BUDB_OP_DATES(0x01)) {
1602 /* This and each appended dump should be in time */
1603 for (dbAppAddr = dbAddr; dbAppAddr;
1604 dbAppAddr = ntohl(appDiskDump.appendedDumpChain)(__builtin_constant_p(appDiskDump.appendedDumpChain) ? ((((__uint32_t
)(appDiskDump.appendedDumpChain)) >> 24) | ((((__uint32_t
)(appDiskDump.appendedDumpChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(appDiskDump.appendedDumpChain)) & (
0xff << 8)) << 8) | (((__uint32_t)(appDiskDump.appendedDumpChain
)) << 24)) : __bswap32_var(appDiskDump.appendedDumpChain
))) {
1605 eval =
1606 dbread(ut, dbAppAddr, &appDiskDump,
1607 sizeof(appDiskDump));
1608 if (eval)
1609 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1610
1611 if ((ntohl(appDiskDump.id)(__builtin_constant_p(appDiskDump.id) ? ((((__uint32_t)(appDiskDump
.id)) >> 24) | ((((__uint32_t)(appDiskDump.id)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(appDiskDump.
id)) & (0xff << 8)) << 8) | (((__uint32_t)(appDiskDump
.id)) << 24)) : __bswap32_var(appDiskDump.id)) < fromTime)
1612 || (ntohl(appDiskDump.id)(__builtin_constant_p(appDiskDump.id) ? ((((__uint32_t)(appDiskDump
.id)) >> 24) | ((((__uint32_t)(appDiskDump.id)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(appDiskDump.
id)) & (0xff << 8)) << 8) | (((__uint32_t)(appDiskDump
.id)) << 24)) : __bswap32_var(appDiskDump.id)) > toTime))
1613 break; /*nope */
1614 }
1615 if (dbAppAddr)
1616 continue; /*nope */
1617 }
1618
1619 /* Add it and each of its appended dump to our list to return */
1620 for (dbAppAddr = dbAddr; dbAppAddr;
1621 dbAppAddr = ntohl(appDiskDump.appendedDumpChain)(__builtin_constant_p(appDiskDump.appendedDumpChain) ? ((((__uint32_t
)(appDiskDump.appendedDumpChain)) >> 24) | ((((__uint32_t
)(appDiskDump.appendedDumpChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(appDiskDump.appendedDumpChain)) & (
0xff << 8)) << 8) | (((__uint32_t)(appDiskDump.appendedDumpChain
)) << 24)) : __bswap32_var(appDiskDump.appendedDumpChain
))) {
1622 eval =
1623 dbread(ut, dbAppAddr, &appDiskDump,
1624 sizeof(appDiskDump));
1625 if (eval)
1626 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1627
1628 /* Make sure we have space to list it */
1629 if (dumps->budb_dumpsList_len >= count) {
1630 count += 10;
1631 if (count == 10) {
1632 dumps->budb_dumpsList_val =
1633 (afs_int32 *) malloc(count *
1634 sizeof(afs_int32));
1635 flags->budb_dumpsList_val =
1636 (afs_int32 *) malloc(count *
1637 sizeof(afs_int32));
1638 } else {
1639 dumps->budb_dumpsList_val =
1640 (afs_int32 *) realloc(dumps->
1641 budb_dumpsList_val,
1642 count *
1643 sizeof(afs_int32));
1644 flags->budb_dumpsList_val =
1645 (afs_int32 *) realloc(flags->
1646 budb_dumpsList_val,
1647 count *
1648 sizeof(afs_int32));
1649 }
1650 if (!dumps->budb_dumpsList_val
1651 || !dumps->budb_dumpsList_val)
1652 ABORT(BUDB_NOMEM)do { code = (156303901L); goto abort_exit; } while (0);
1653 }
1654
1655 /* Add it to our list */
1656 dumps->budb_dumpsList_val[dumps->budb_dumpsList_len] =
1657 ntohl(appDiskDump.id)(__builtin_constant_p(appDiskDump.id) ? ((((__uint32_t)(appDiskDump
.id)) >> 24) | ((((__uint32_t)(appDiskDump.id)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(appDiskDump.
id)) & (0xff << 8)) << 8) | (((__uint32_t)(appDiskDump
.id)) << 24)) : __bswap32_var(appDiskDump.id));
1658 flags->budb_dumpsList_val[flags->budb_dumpsList_len] = 0;
1659 if (ntohl(appDiskDump.initialDumpID)(__builtin_constant_p(appDiskDump.initialDumpID) ? ((((__uint32_t
)(appDiskDump.initialDumpID)) >> 24) | ((((__uint32_t)(
appDiskDump.initialDumpID)) & (0xff << 16)) >>
8) | ((((__uint32_t)(appDiskDump.initialDumpID)) & (0xff
<< 8)) << 8) | (((__uint32_t)(appDiskDump.initialDumpID
)) << 24)) : __bswap32_var(appDiskDump.initialDumpID)) != 0) {
1660 flags->budb_dumpsList_val[flags->
1661 budb_dumpsList_len] |=
1662 BUDB_OP_APPDUMP(0x01);
1663 }
1664 if (strcmp(appDiskDump.dumpName, DUMP_TAPE_NAME"Ubik_db_dump") == 0) {
1665 flags->budb_dumpsList_val[flags->
1666 budb_dumpsList_len] |=
1667 BUDB_OP_DBDUMP(0x02);
1668 }
1669 dumps->budb_dumpsList_len++;
1670 flags->budb_dumpsList_len++;
1671 }
1672 } /*d */
1673 } /*h */
1674 } /*o */
1675
1676 code = ubik_EndTrans(ut);
1677 return (code);
1678
1679 abort_exit:
1680 ubik_AbortTrans(ut);
1681 return (code);
1682}
1683
1684afs_int32
1685SBUDB_DeleteTape(struct rx_call *call,
1686 struct budb_tapeEntry *tape) /* tape info */
1687{
1688 afs_int32 code;
1689
1690 code = DoDeleteTape(call, tape);
1691 osi_auditU(call, BUDB_DelTpeEvent"AFS_BUDB_DelTpe", code, AUD_DATE6,
1692 (tape ? tape->dump : 0), AUD_END0);
1693 return code;
1694}
1695
1696afs_int32
1697DoDeleteTape(struct rx_call *call,
1698 struct budb_tapeEntry *tape) /* tape info */
1699{
1700 struct ubik_trans *ut;
1701 struct tape t;
1702 dbadr a;
1703 afs_int32 eval, code;
1704
1705 if (!callPermitted(call))
1706 return BUDB_NOTPERMITTED(156303880L);
1707
1708 eval = InitRPC(&ut, LOCKWRITE2, 1);
1709 if (eval)
1710 return eval;
1711
1712 eval = ht_LookupEntry(ut, &db.tapeName, tape->name, &a, &t);
1713 if (eval)
1714 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1715
1716 eval = DeleteTape(ut, a, &t);
1717 if (eval)
1718 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1719
1720 eval = FreeStructure(ut, tape_BLOCK3, a);
1721 if (eval)
1722 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1723
1724 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
1725 if (eval)
1726 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1727
1728 code = ubik_EndTrans(ut);
1729 return code;
1730
1731 abort_exit:
1732 ubik_AbortTrans(ut);
1733 return code;
1734}
1735
1736/* BUDB_DeleteVDP
1737 * Deletes old information from the database for a particular dump path
1738 * and volumset. This supercedes the old policy implemented in
1739 * UseTape, which simply matched on the volumeset.dump. Consequently
1740 * it was unable to handle name re-use.
1741 * entry:
1742 * dsname - dumpset name, i.e. volumeset.dumpname
1743 * dumpPath - full path of dump node
1744 * curDumpID - current dump in progress - so that is may be excluded
1745 * exit:
1746 * 0 - ok
1747 * n - some error. May or may not have deleted information.
1748 */
1749
1750afs_int32
1751SBUDB_DeleteVDP(struct rx_call *call, char *dsname, char *dumpPath,
1752 afs_int32 curDumpId)
1753{
1754 afs_int32 code;
1755
1756 code = DeleteVDP(call, dsname, dumpPath, curDumpId);
1757 osi_auditU(call, BUDB_DelVDPEvent"AFS_BUDB_DelVDP", code, AUD_STR1, dsname, AUD_END0);
1758 return code;
1759}
1760
1761afs_int32
1762DeleteVDP(struct rx_call *call, char *dsname, char *dumpPath,
1763 afs_int32 curDumpId)
1764{
1765 struct dump dump;
1766 dbadr dumpAddr;
1767
1768 struct ubik_trans *ut;
1769 afs_int32 eval, code = 0;
1770
1771 if (!callPermitted(call))
1772 return BUDB_NOTPERMITTED(156303880L);
1773
1774 while (1) {
1775 eval = InitRPC(&ut, LOCKREAD1, 1);
1776 if (eval)
1777 return (eval);
1778
1779 eval = ht_LookupEntry(ut, &db.dumpName, dsname, &dumpAddr, &dump);
1780 if (eval)
1781 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1782
1783 while (dumpAddr != 0) { /*wd */
1784 if ((strcmp(dump.dumpName, dsname) == 0)
1785 && (strcmp(dump.dumpPath, dumpPath) == 0)
1786 && (ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)) != curDumpId)) {
1787 eval = ubik_EndTrans(ut);
1788 if (eval)
1789 return (eval);
1790
1791 eval = deleteDump(call, ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)), 0);
1792 if (eval)
1793 return (eval);
1794
1795 /* start the traversal over since the various chains may
1796 * have changed
1797 */
1798 break;
1799 }
1800
1801 dumpAddr = ntohl(dump.nameHashChain)(__builtin_constant_p(dump.nameHashChain) ? ((((__uint32_t)(dump
.nameHashChain)) >> 24) | ((((__uint32_t)(dump.nameHashChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(dump
.nameHashChain)) & (0xff << 8)) << 8) | (((__uint32_t
)(dump.nameHashChain)) << 24)) : __bswap32_var(dump.nameHashChain
));
1802 if (dumpAddr) {
1803 eval = dbread(ut, dumpAddr, &dump, sizeof(dump));
1804 if (eval)
1805 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1806 }
1807 } /*wd */
1808
1809 /* check if all the dumps have been examined - can terminate */
1810 if (!dumpAddr) {
1811 eval = ubik_EndTrans(ut);
1812 return (eval);
1813 }
1814 }
1815
1816 abort_exit:
1817 ubik_AbortTrans(ut);
1818 return (code);
1819}
1820
1821/* BUDB_FindClone
1822 * notes:
1823 * Given a volume name, and a dumpID, find the volume in that dump and
1824 * return the clone date of the volume (this is the clone date of the
1825 * volume at the time it was dumped).
1826 *
1827 * Hashes on the volume name and traverses the fragments. Will need to read
1828 * the volumes tape entry to determine if it belongs to the dump. If the
1829 * volume is not found in the dump, then look for it in its parent dump.
1830 */
1831
1832afs_int32
1833SBUDB_FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1834 afs_int32 *clonetime)
1835{
1836 afs_int32 code;
1837
1838 code = FindClone(call, dumpID, volName, clonetime);
1839 osi_auditU(call, BUDB_FndClnEvent"AFS_BUDB_FndCln", code, AUD_STR1, volName, AUD_END0);
1840 return code;
1841}
1842
1843afs_int32
1844FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1845 afs_int32 *clonetime)
1846{
1847 struct ubik_trans *ut;
1848 dbadr da, hvia, via, vfa;
1849 struct dump d;
1850 struct tape t;
1851 struct volFragment vf;
1852 struct volInfo vi;
1853 int rvi; /* read the volInfo struct */
1854 afs_int32 eval, code = 0;
1855
1856 if (!callPermitted(call))
1857 return BUDB_NOTPERMITTED(156303880L);
1858
1859 eval = InitRPC(&ut, LOCKREAD1, 1);
1860 if (eval)
1861 return (eval);
1862
1863 *clonetime = 0;
1864
1865 /* Search for the volume by name */
1866 eval = ht_LookupEntry(ut, &db.volName, volName, &hvia, &vi);
1867 if (eval)
1868 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1869 if (!hvia)
1870 ABORT(BUDB_NOVOLUMENAME)do { code = (156303876L); goto abort_exit; } while (0);
1871 rvi = 0;
1872
1873 /* Follw the dump levels up */
1874 for (; dumpID; dumpID = ntohl(d.parent)(__builtin_constant_p(d.parent) ? ((((__uint32_t)(d.parent)) >>
24) | ((((__uint32_t)(d.parent)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.parent)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.parent)) << 24)) : __bswap32_var
(d.parent))) { /*d */
1875 /* Get the dump entry */
1876 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &da, &d);
1877 if (eval)
1878 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1879 if (!da)
1880 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
1881
1882 /* seach all the volInfo entries on the sameNameChain */
1883 for (via = hvia; via; via = ntohl(vi.sameNameChain)(__builtin_constant_p(vi.sameNameChain) ? ((((__uint32_t)(vi.
sameNameChain)) >> 24) | ((((__uint32_t)(vi.sameNameChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vi
.sameNameChain)) & (0xff << 8)) << 8) | (((__uint32_t
)(vi.sameNameChain)) << 24)) : __bswap32_var(vi.sameNameChain
))) { /*via */
1884 if (rvi) { /* Read the volInfo entry - except first time */
1885 eval = dbread(ut, via, &vi, sizeof(vi));
1886 if (eval)
1887 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1888 }
1889 rvi = 1;
1890
1891 /* search all the volFrag entries on the volFrag */
1892 for (vfa = ntohl(vi.firstFragment)(__builtin_constant_p(vi.firstFragment) ? ((((__uint32_t)(vi.
firstFragment)) >> 24) | ((((__uint32_t)(vi.firstFragment
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vi
.firstFragment)) & (0xff << 8)) << 8) | (((__uint32_t
)(vi.firstFragment)) << 24)) : __bswap32_var(vi.firstFragment
)); vfa; vfa = ntohl(vf.sameNameChain)(__builtin_constant_p(vf.sameNameChain) ? ((((__uint32_t)(vf.
sameNameChain)) >> 24) | ((((__uint32_t)(vf.sameNameChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vf
.sameNameChain)) & (0xff << 8)) << 8) | (((__uint32_t
)(vf.sameNameChain)) << 24)) : __bswap32_var(vf.sameNameChain
))) { /*vfa */
1893 eval = dbread(ut, vfa, &vf, sizeof(vf)); /* Read the volFrag entry */
1894 if (eval)
1895 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1896
1897 eval = dbread(ut, ntohl(vf.tape)(__builtin_constant_p(vf.tape) ? ((((__uint32_t)(vf.tape)) >>
24) | ((((__uint32_t)(vf.tape)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vf.tape)) & (0xff << 8)) <<
8) | (((__uint32_t)(vf.tape)) << 24)) : __bswap32_var(
vf.tape)), &t, sizeof(t)); /* Read the tape */
1898 if (eval)
1899 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1900
1901 /* Now check to see if this fragment belongs to the dump we have */
1902 if (ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)) == da) {
1903 *clonetime = ntohl(vf.clone)(__builtin_constant_p(vf.clone) ? ((((__uint32_t)(vf.clone)) >>
24) | ((((__uint32_t)(vf.clone)) & (0xff << 16)) >>
8) | ((((__uint32_t)(vf.clone)) & (0xff << 8)) <<
8) | (((__uint32_t)(vf.clone)) << 24)) : __bswap32_var
(vf.clone)); /* return the clone */
1904 ERROR(0)do { code = 0; goto error_exit; } while (0);
1905 }
1906 } /*vfa */
1907 } /*via */
1908 } /*d */
1909
1910 error_exit:
1911 code = ubik_EndTrans(ut);
1912 return (code);
1913
1914 abort_exit:
1915 ubik_EndTrans(ut);
1916 return (code);
1917}
1918
1919#ifdef notdef
1920/*
1921 * Searches each tape and each volume in the dump until the volume is found.
1922 * If the volume is not in the dump, then we search it's parent dump.
1923 *
1924 * Re-write to do lookups by volume name.
1925 */
1926afs_int32
1927FindClone(struct rx_call *call, afs_int32 dumpID, char *volName,
1928 afs_int32 *clonetime)
1929{
1930 struct ubik_trans *ut;
1931 dbadr diskAddr, tapeAddr, volFragmentAddr;
1932 struct dump dump;
1933 struct tape tape;
1934 struct volFragment volFragment;
1935 struct volInfo volInfo;
1936 afs_int32 eval, code = 0;
1937
1938 if (!callPermitted(call))
1939 return BUDB_NOTPERMITTED(156303880L);
1940
1941 eval = InitRPC(&ut, LOCKREAD1, 1);
1942 if (eval)
1943 return (eval);
1944
1945 *clonetime = 0;
1946
1947 for (; dumpID; dumpID = ntohl(dump.parent)(__builtin_constant_p(dump.parent) ? ((((__uint32_t)(dump.parent
)) >> 24) | ((((__uint32_t)(dump.parent)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(dump.parent)) & (0xff
<< 8)) << 8) | (((__uint32_t)(dump.parent)) <<
24)) : __bswap32_var(dump.parent))) { /*d */
1948 /* Get the dump entry */
1949 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &diskAddr, &dump);
1950 if (eval)
1951 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1952 if (!diskAddr)
1953 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
1954
1955 /* just to be sure */
1956 if (ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)) != dumpID) {
1957 LogDebug(4, "BUDB_FindClone: requested %d, found %d\n", dumpID,
1958 ntohl(dump.id)(__builtin_constant_p(dump.id) ? ((((__uint32_t)(dump.id)) >>
24) | ((((__uint32_t)(dump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(dump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(dump.id)) << 24)) : __bswap32_var(
dump.id)));
1959 ABORT(BUDB_INTERNALERROR)do { code = (156303895L); goto abort_exit; } while (0);
1960 }
1961
1962 /* search all the tapes in this dump */
1963 for (tapeAddr = ntohl(dump.firstTape)(__builtin_constant_p(dump.firstTape) ? ((((__uint32_t)(dump.
firstTape)) >> 24) | ((((__uint32_t)(dump.firstTape)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump.firstTape
)) & (0xff << 8)) << 8) | (((__uint32_t)(dump
.firstTape)) << 24)) : __bswap32_var(dump.firstTape)); tapeAddr; tapeAddr = ntohl(tape.nextTape)(__builtin_constant_p(tape.nextTape) ? ((((__uint32_t)(tape.nextTape
)) >> 24) | ((((__uint32_t)(tape.nextTape)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.nextTape)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.nextTape
)) << 24)) : __bswap32_var(tape.nextTape))) { /*t */
1964 /* Get the tape entry */
1965 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
1966 if (eval)
1967 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1968
1969 /* search all the volume fragments on this tape */
1970 for (volFragmentAddr = ntohl(tape.firstVol)(__builtin_constant_p(tape.firstVol) ? ((((__uint32_t)(tape.firstVol
)) >> 24) | ((((__uint32_t)(tape.firstVol)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.firstVol)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.firstVol
)) << 24)) : __bswap32_var(tape.firstVol)); volFragmentAddr; volFragmentAddr = ntohl(volFragment.sameTapeChain)(__builtin_constant_p(volFragment.sameTapeChain) ? ((((__uint32_t
)(volFragment.sameTapeChain)) >> 24) | ((((__uint32_t)(
volFragment.sameTapeChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(volFragment.sameTapeChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(volFragment.sameTapeChain
)) << 24)) : __bswap32_var(volFragment.sameTapeChain))) { /*vf */
1971 /* Get the volume fragment entry */
1972 eval =
1973 dbread(ut, volFragmentAddr, &volFragment,
1974 sizeof(volFragment));
1975 if (eval)
1976 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1977
1978 /* Get the volume info entry */
1979 eval =
1980 dbread(ut, ntohl(volFragment.vol)(__builtin_constant_p(volFragment.vol) ? ((((__uint32_t)(volFragment
.vol)) >> 24) | ((((__uint32_t)(volFragment.vol)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(volFragment
.vol)) & (0xff << 8)) << 8) | (((__uint32_t)(
volFragment.vol)) << 24)) : __bswap32_var(volFragment.vol
)), &volInfo,
1981 sizeof(volInfo));
1982 if (eval)
1983 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
1984
1985 /* check if this volume is the one we want */
1986 if (strcmp(volInfo.name, volName) == 0) {
1987 *clonetime = ntohl(volFragment.clone)(__builtin_constant_p(volFragment.clone) ? ((((__uint32_t)(volFragment
.clone)) >> 24) | ((((__uint32_t)(volFragment.clone)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(volFragment
.clone)) & (0xff << 8)) << 8) | (((__uint32_t
)(volFragment.clone)) << 24)) : __bswap32_var(volFragment
.clone));
1988 ERROR(0)do { code = 0; goto error_exit; } while (0);
1989 }
1990 } /*vf */
1991 } /*t */
1992 } /*d */
1993
1994 error_exit:
1995 code = ubik_EndTrans(ut);
1996 return (code);
1997
1998 abort_exit:
1999 ubik_EndTrans(ut);
2000 return (code);
2001}
2002#endif
2003
2004/* BUDB_FindDump
2005 * Find latest volume dump before adate.
2006 * Used by restore code when restoring a user requested volume(s)
2007 * entry:
2008 * volumeName - name of volume to match on
2009 * beforeDate - look for dumps older than this date
2010 * exit:
2011 * deptr - descriptor of most recent dump
2012 */
2013
2014afs_int32
2015SBUDB_FindDump(struct rx_call *call, char *volumeName, afs_int32 beforeDate,
2016 struct budb_dumpEntry *deptr)
2017{
2018 afs_int32 code;
2019
2020 code = FindDump(call, volumeName, beforeDate, deptr);
2021 osi_auditU(call, BUDB_FndDmpEvent"AFS_BUDB_FndDmp", code, AUD_STR1, volumeName, AUD_END0);
2022 return code;
2023}
2024
2025afs_int32
2026FindDump(struct rx_call *call, char *volumeName, afs_int32 beforeDate,
2027 struct budb_dumpEntry *deptr)
2028{
2029 struct ubik_trans *ut;
2030 dbadr volInfoAddr, volFragmentAddr;
2031 struct tape tape;
2032 struct volInfo volInfo;
2033 struct volFragment volFragment;
2034
2035 dbadr selectedDumpAddr = 0;
2036 afs_int32 selectedDate = 0;
2037 afs_int32 volCloned;
2038 int rvoli;
2039 afs_int32 eval, code = 0;
2040
2041 if (!callPermitted(call))
2042 return BUDB_NOTPERMITTED(156303880L);
2043
2044 eval = InitRPC(&ut, LOCKREAD1, 1);
2045 if (eval)
2046 return eval;
2047
2048 /* Find volinfo struct for volume name in hash table */
2049 eval =
2050 ht_LookupEntry(ut, &db.volName, volumeName, &volInfoAddr, &volInfo);
2051 if (eval)
2052 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2053 if (!volInfoAddr)
2054 ABORT(BUDB_NOVOLUMENAME)do { code = (156303876L); goto abort_exit; } while (0);
2055
2056 /* Step through all the volinfo structures on the same name chain.
2057 * No need to read the first - we read it above.
2058 */
2059 for (rvoli = 0; volInfoAddr;
2060 rvoli = 1, volInfoAddr = ntohl(volInfo.sameNameChain)(__builtin_constant_p(volInfo.sameNameChain) ? ((((__uint32_t
)(volInfo.sameNameChain)) >> 24) | ((((__uint32_t)(volInfo
.sameNameChain)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(volInfo.sameNameChain)) & (0xff << 8)) <<
8) | (((__uint32_t)(volInfo.sameNameChain)) << 24)) : __bswap32_var
(volInfo.sameNameChain))) {
2061 if (rvoli) { /* read the volinfo structure */
2062 eval = dbread(ut, volInfoAddr, &volInfo, sizeof(volInfo));
2063 if (eval)
2064 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2065 }
2066
2067 /* step through the volfrag structures */
2068 for (volFragmentAddr = ntohl(volInfo.firstFragment)(__builtin_constant_p(volInfo.firstFragment) ? ((((__uint32_t
)(volInfo.firstFragment)) >> 24) | ((((__uint32_t)(volInfo
.firstFragment)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(volInfo.firstFragment)) & (0xff << 8)) <<
8) | (((__uint32_t)(volInfo.firstFragment)) << 24)) : __bswap32_var
(volInfo.firstFragment)); volFragmentAddr;
2069 volFragmentAddr = ntohl(volFragment.sameNameChain)(__builtin_constant_p(volFragment.sameNameChain) ? ((((__uint32_t
)(volFragment.sameNameChain)) >> 24) | ((((__uint32_t)(
volFragment.sameNameChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(volFragment.sameNameChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(volFragment.sameNameChain
)) << 24)) : __bswap32_var(volFragment.sameNameChain))) {
2070 /* read the volfrag struct */
2071 eval =
2072 dbread(ut, volFragmentAddr, &volFragment,
2073 sizeof(volFragment));
2074 if (eval)
2075 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2076
2077 volCloned = ntohl(volFragment.clone)(__builtin_constant_p(volFragment.clone) ? ((((__uint32_t)(volFragment
.clone)) >> 24) | ((((__uint32_t)(volFragment.clone)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(volFragment
.clone)) & (0xff << 8)) << 8) | (((__uint32_t
)(volFragment.clone)) << 24)) : __bswap32_var(volFragment
.clone));
2078
2079 /* now we can examine the date for most recent dump */
2080 if ((volCloned > selectedDate) && (volCloned < beforeDate)) {
2081 /* from the volfrag struct, read the tape struct */
2082 eval =
2083 dbread(ut, ntohl(volFragment.tape)(__builtin_constant_p(volFragment.tape) ? ((((__uint32_t)(volFragment
.tape)) >> 24) | ((((__uint32_t)(volFragment.tape)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(volFragment
.tape)) & (0xff << 8)) << 8) | (((__uint32_t)
(volFragment.tape)) << 24)) : __bswap32_var(volFragment
.tape)), &tape, sizeof(tape));
2084 if (eval)
2085 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2086
2087 selectedDate = volCloned;
2088 selectedDumpAddr = ntohl(tape.dump)(__builtin_constant_p(tape.dump) ? ((((__uint32_t)(tape.dump)
) >> 24) | ((((__uint32_t)(tape.dump)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tape.dump)) & (0xff <<
8)) << 8) | (((__uint32_t)(tape.dump)) << 24)) :
__bswap32_var(tape.dump));
2089 }
2090 }
2091 }
2092
2093 if (!selectedDumpAddr)
2094 ABORT(BUDB_NOENT)do { code = (156303877L); goto abort_exit; } while (0);
2095
2096 eval = FillDumpEntry(ut, selectedDumpAddr, deptr);
2097 if (eval)
2098 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2099
2100 code = ubik_EndTrans(ut);
2101 return (code);
2102
2103 abort_exit:
2104 ubik_EndTrans(ut);
2105 return (code);
2106}
2107
2108/* BUDB_FindLatestDump
2109 * Find the latest dump of volumeset vsname with dump name dname.
2110 * entry:
2111 * vsname - volumeset name
2112 * dname - dumpname
2113 */
2114
2115afs_int32
2116SBUDB_FindLatestDump(struct rx_call *call, char *vsname, char *dumpPath,
2117 struct budb_dumpEntry *dumpentry)
2118{
2119 afs_int32 code;
2120
2121 code = FindLatestDump(call, vsname, dumpPath, dumpentry);
2122 osi_auditU(call, BUDB_FndLaDEvent"AFS_BUDB_FndLaD", code, AUD_STR1, vsname, AUD_END0);
2123 return code;
2124}
2125
2126afs_int32
2127FindLatestDump(struct rx_call *call, char *vsname, char *dumpPath,
2128 struct budb_dumpEntry *dumpentry)
2129{
2130 struct ubik_trans *ut;
2131 dbadr curdbaddr, retdbaddr, firstdbaddr;
2132 struct dump d;
2133 Dateafs_uint32 latest;
2134 char dumpName[BU_MAXNAMELEN32 + 2];
2135 afs_int32 eval, code = 0;
2136
2137 if (!callPermitted(call))
2138 return BUDB_NOTPERMITTED(156303880L);
2139
2140 eval = InitRPC(&ut, LOCKREAD1, 1);
2141 if (eval)
2142 return (eval);
2143
2144 if ((strcmp(vsname, "") == 0) && (strcmp(dumpPath, "") == 0)) {
2145 /* Construct a database dump name */
2146 strcpy(dumpName, DUMP_TAPE_NAME"Ubik_db_dump");
2147 } else if (strchr(dumpPath, '/') == 0) {
2148 int level, old, length, hash;
2149 struct dump hostDump, diskDump;
2150 struct memoryHashTable *mht;
2151 int entrySize;
2152 dbadr dbAddr;
2153 afs_uint32 bestDumpId = 0;
2154
2155 level = atoi(dumpPath);
2156 if (level < 0) {
2157 ABORT(BUDB_BADARGUMENT)do { code = (156303882L); goto abort_exit; } while (0);
2158 }
2159
2160 /* Brute force search of all the dumps in the database - yuck! */
2161
2162 retdbaddr = 0;
2163 mht = ht_GetType(HT_dumpIden_FUNCTION1, &entrySize);
2164 if (!mht)
2165 ABORT(BUDB_BADARGUMENT)do { code = (156303882L); goto abort_exit; } while (0);
2166
2167 for (old = 0; old <= 1; old++) { /*fo */
2168 length = (old ? mht->oldLength : mht->length);
2169 if (!length)
2170 continue;
2171
2172 for (hash = 0; hash < length; hash++) {
2173 /*f */
2174 for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr;
2175 dbAddr = hostDump.idHashChain) {
2176 /*w */
2177 eval = dbread(ut, dbAddr, &diskDump, sizeof(diskDump));
2178 if (eval)
2179 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2180 dump_ntoh(&diskDump, &hostDump);
2181
2182 if ((strcmp(hostDump.volumeSet, vsname) == 0) && /* the volumeset */
2183 (hostDump.level == level) && /* same level */
2184 (hostDump.id > bestDumpId)) { /* more recent */
2185 bestDumpId = hostDump.id;
2186 retdbaddr = dbAddr;
2187 }
2188 } /*w */
2189 } /*f */
2190 } /*fo */
2191 if (!retdbaddr)
2192 ABORT(BUDB_NODUMPNAME)do { code = (156303874L); goto abort_exit; } while (0);
2193
2194 goto finished;
2195 } else {
2196 /* construct the name of the dump */
2197 if ((strlen(vsname) + strlen(tailCompPtr(dumpPath))) > BU_MAXNAMELEN32)
2198 ABORT(BUDB_NODUMPNAME)do { code = (156303874L); goto abort_exit; } while (0);
2199
2200 strcpy(dumpName, vsname);
2201 strcat(dumpName, ".");
2202 strcat(dumpName, tailCompPtr(dumpPath));
2203 }
2204
2205 LogDebug(5, "lookup on :%s:\n", dumpName);
2206
2207 /* Lookup on dumpname in hash table */
2208 eval = ht_LookupEntry(ut, &db.dumpName, dumpName, &firstdbaddr, &d);
2209 if (eval)
2210 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2211
2212 latest = 0;
2213 retdbaddr = 0;
2214
2215 /* folow remaining dumps in hash chain, looking for most latest dump */
2216 for (curdbaddr = firstdbaddr; curdbaddr;
2217 curdbaddr = ntohl(d.nameHashChain)(__builtin_constant_p(d.nameHashChain) ? ((((__uint32_t)(d.nameHashChain
)) >> 24) | ((((__uint32_t)(d.nameHashChain)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(d.nameHashChain)
) & (0xff << 8)) << 8) | (((__uint32_t)(d.nameHashChain
)) << 24)) : __bswap32_var(d.nameHashChain))) {
2218 if (curdbaddr != firstdbaddr) {
2219 eval = dbread(ut, curdbaddr, &d, sizeof(d));
2220 if (eval)
2221 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2222 }
2223
2224 if ((strcmp(d.dumpPath, dumpPath) == 0) && /* Same dumppath */
2225 (strcmp(d.dumpName, dumpName) == 0) && /* Same dumpname */
2226 (ntohl(d.created)(__builtin_constant_p(d.created) ? ((((__uint32_t)(d.created)
) >> 24) | ((((__uint32_t)(d.created)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.created)) & (0xff <<
8)) << 8) | (((__uint32_t)(d.created)) << 24)) :
__bswap32_var(d.created)) > latest)) { /* most recent */
2227 latest = ntohl(d.created)(__builtin_constant_p(d.created) ? ((((__uint32_t)(d.created)
) >> 24) | ((((__uint32_t)(d.created)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.created)) & (0xff <<
8)) << 8) | (((__uint32_t)(d.created)) << 24)) :
__bswap32_var(d.created));
2228 retdbaddr = curdbaddr;
2229 }
2230 }
2231 if (!retdbaddr)
2232 ABORT(BUDB_NODUMPNAME)do { code = (156303874L); goto abort_exit; } while (0);
2233
2234 finished:
2235 /* return the dump found */
2236 FillDumpEntry(ut, retdbaddr, dumpentry);
2237
2238 code = ubik_EndTrans(ut);
2239 return (code);
2240
2241 abort_exit:
2242 ubik_AbortTrans(ut);
2243 return (code);
2244}
2245
2246
2247afs_int32
2248SBUDB_FinishDump(struct rx_call *call, struct budb_dumpEntry *dump)
2249{
2250 afs_int32 code;
2251
2252 code = FinishDump(call, dump);
2253 osi_auditU(call, BUDB_FinDmpEvent"AFS_BUDB_FinDmp", code, AUD_DATE6, (dump ? dump->id : 0),
2254 AUD_END0);
2255 return code;
2256}
2257
2258afs_int32
2259FinishDump(struct rx_call *call, struct budb_dumpEntry *dump)
2260{
2261 struct ubik_trans *ut;
2262 dbadr a;
2263 struct dump d;
2264 afs_int32 eval, code = 0;
2265
2266 if (!callPermitted(call))
2267 return BUDB_NOTPERMITTED(156303880L);
2268
2269 eval = InitRPC(&ut, LOCKWRITE2, 1);
2270 if (eval)
2271 return eval;
2272
2273 eval = ht_LookupEntry(ut, &db.dumpIden, &dump->id, &a, &d);
2274 if (eval)
2275 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2276 if (!a)
2277 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
2278
2279 if ((ntohl(d.flags)(__builtin_constant_p(d.flags) ? ((((__uint32_t)(d.flags)) >>
24) | ((((__uint32_t)(d.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.flags)) << 24)) : __bswap32_var(
d.flags)) & BUDB_DUMP_INPROGRESS(1<<2)) == 0)
2280 ABORT(BUDB_DUMPNOTINUSE)do { code = (156303903L); goto abort_exit; } while (0);
2281
2282 d.flags = htonl(dump->flags & ~BUDB_DUMP_INPROGRESS)(__builtin_constant_p(dump->flags & ~(1<<2)) ? (
(((__uint32_t)(dump->flags & ~(1<<2))) >> 24
) | ((((__uint32_t)(dump->flags & ~(1<<2))) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump->flags
& ~(1<<2))) & (0xff << 8)) << 8) |
(((__uint32_t)(dump->flags & ~(1<<2))) <<
24)) : __bswap32_var(dump->flags & ~(1<<2)));
2283
2284 /* if creation time specified set it */
2285 if (dump->created)
2286 d.created = htonl(dump->created)(__builtin_constant_p(dump->created) ? ((((__uint32_t)(dump
->created)) >> 24) | ((((__uint32_t)(dump->created
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(dump
->created)) & (0xff << 8)) << 8) | (((__uint32_t
)(dump->created)) << 24)) : __bswap32_var(dump->created
));
2287 dump->created = ntohl(d.created)(__builtin_constant_p(d.created) ? ((((__uint32_t)(d.created)
) >> 24) | ((((__uint32_t)(d.created)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.created)) & (0xff <<
8)) << 8) | (((__uint32_t)(d.created)) << 24)) :
__bswap32_var(d.created));
2288
2289 /* Write the dump entry out */
2290 eval = dbwrite(ut, a, &d, sizeof(d));
2291 if (eval)
2292 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2293
2294 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
2295 if (eval)
2296 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2297
2298 code = ubik_EndTrans(ut);
2299 return code;
2300
2301 abort_exit:
2302 ubik_AbortTrans(ut);
2303 return code;
2304}
2305
2306afs_int32
2307SBUDB_FinishTape(struct rx_call *call, struct budb_tapeEntry *tape)
2308{
2309 afs_int32 code;
2310
2311 code = FinishTape(call, tape);
2312 osi_auditU(call, BUDB_FinTpeEvent"AFS_BUDB_FinTpe", code, AUD_DATE6,
2313 (tape ? tape->dump : 0), AUD_END0);
2314 return code;
2315}
2316
2317afs_int32
2318FinishTape(struct rx_call *call, struct budb_tapeEntry *tape)
2319{
2320 struct ubik_trans *ut;
2321 dbadr a;
2322 struct tape t;
2323 struct dump d;
2324 afs_int32 eval, code = 0;
2325
2326 if (!callPermitted(call))
2327 return BUDB_NOTPERMITTED(156303880L);
2328
2329 eval = InitRPC(&ut, LOCKWRITE2, 1);
2330 if (eval)
2331 return eval;
2332
2333 /* find the tape struct in the tapename hash chain */
2334 eval = ht_LookupEntry(ut, &db.tapeName, tape->name, &a, &t);
2335 if (eval)
2336 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2337 if (!a)
2338 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
2339
2340 /* Read the dump structure */
2341 eval = dbread(ut, ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)), &d, sizeof(d));
2342 if (eval)
2343 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2344
2345 /* search for the right tape on the rest of the chain */
2346 while (ntohl(d.id)(__builtin_constant_p(d.id) ? ((((__uint32_t)(d.id)) >>
24) | ((((__uint32_t)(d.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.id)) << 24)) : __bswap32_var(d.id
)) != tape->dump) {
2347 a = ntohl(t.nameHashChain)(__builtin_constant_p(t.nameHashChain) ? ((((__uint32_t)(t.nameHashChain
)) >> 24) | ((((__uint32_t)(t.nameHashChain)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(t.nameHashChain)
) & (0xff << 8)) << 8) | (((__uint32_t)(t.nameHashChain
)) << 24)) : __bswap32_var(t.nameHashChain));
2348 if (!a)
2349 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
2350
2351 eval = dbread(ut, a, &t, sizeof(t));
2352 if (eval)
2353 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2354
2355 eval = dbread(ut, ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)), &d, sizeof(d));
2356 if (eval)
2357 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2358 }
2359
2360 if ((ntohl(t.flags)(__builtin_constant_p(t.flags) ? ((((__uint32_t)(t.flags)) >>
24) | ((((__uint32_t)(t.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.flags)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.flags)) << 24)) : __bswap32_var(
t.flags)) & BUDB_TAPE_BEINGWRITTEN(1<<2)) == 0)
2361 ABORT(BUDB_TAPENOTINUSE)do { code = (156303878L); goto abort_exit; } while (0);
2362
2363 /* t.nBytes = htonl(tape->nBytes); */
2364 t.nFiles = htonl(tape->nFiles)(__builtin_constant_p(tape->nFiles) ? ((((__uint32_t)(tape
->nFiles)) >> 24) | ((((__uint32_t)(tape->nFiles)
) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->nFiles)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->nFiles)) << 24)) : __bswap32_var(tape->nFiles
));
2365 t.useKBytes = htonl(tape->useKBytes)(__builtin_constant_p(tape->useKBytes) ? ((((__uint32_t)(tape
->useKBytes)) >> 24) | ((((__uint32_t)(tape->useKBytes
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->useKBytes)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->useKBytes)) << 24)) : __bswap32_var(tape->
useKBytes));
2366 t.flags = htonl(tape->flags & ~BUDB_TAPE_BEINGWRITTEN)(__builtin_constant_p(tape->flags & ~(1<<2)) ? (
(((__uint32_t)(tape->flags & ~(1<<2))) >> 24
) | ((((__uint32_t)(tape->flags & ~(1<<2))) &
(0xff << 16)) >> 8) | ((((__uint32_t)(tape->flags
& ~(1<<2))) & (0xff << 8)) << 8) |
(((__uint32_t)(tape->flags & ~(1<<2))) <<
24)) : __bswap32_var(tape->flags & ~(1<<2)));
2367
2368 eval = dbwrite(ut, a, &t, sizeof(t));
2369 if (eval)
2370 ABORT(BUDB_IO)do { code = (156303892L); goto abort_exit; } while (0);
2371
2372 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
2373 if (eval)
2374 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2375
2376 code = ubik_EndTrans(ut);
2377 return code;
2378
2379 abort_exit:
2380 ubik_AbortTrans(ut);
2381 return code;
2382}
2383
2384/* BUDB_GetDumps
2385 * return a set of dumps that match the specified criteria
2386 * entry:
2387 * call - rx call
2388 * majorVersion - version of interface structures. Permits compatibility
2389 * checks to be made
2390 * flags - for search and select operations. Broken down into flags
2391 * for name, start point, end point and time.
2392 * name - name to search for. Interpretation based on flags
2393 * end
2394 * index
2395 * nextIndexP
2396 * dbTimeP
2397 * exit:
2398 * nextIndexP
2399 * dbTimeP - time at which the database was last modified. Up to
2400 * caller (client) to take appropriate action if database
2401 * modified between successive calls
2402 * dumps - list of matching dumps
2403 * notes:
2404 * currently supported are:
2405 * BUDB_OP_DUMPNAME
2406 * BUDB_OP_DUMPID
2407 */
2408
2409afs_int32
2410SBUDB_GetDumps(struct rx_call *call,
2411 afs_int32 majorVersion, /* version of interface structures */
2412 afs_int32 flags, /* search & select controls */
2413 char *name, /* s&s parameters */
2414 afs_int32 start,
2415 afs_int32 end,
2416 afs_int32 index, /* start index of returned entries */
2417 afs_int32 *nextIndexP, /* output index for next call */
2418 afs_int32 *dbTimeP,
2419 budb_dumpList *dumps) /* pointer to buffer */
2420{
2421 afs_int32 code;
2422
2423 code =
2424 GetDumps(call, majorVersion, flags, name, start, end, index,
2425 nextIndexP, dbTimeP, dumps);
2426 osi_auditU(call, BUDB_GetDmpEvent"AFS_BUDB_GetDmp", code, AUD_END0);
2427 return code;
2428}
2429
2430afs_int32
2431GetDumps(struct rx_call *call,
2432 afs_int32 majorVersion, /* version of interface structures */
2433 afs_int32 flags, /* search & select controls */
2434 char *name, /* s&s parameters */
2435 afs_int32 start,
2436 afs_int32 end,
2437 afs_int32 index, /* start index of returned entries */
2438 afs_int32 *nextIndexP, /* output index for next call */
2439 afs_int32 *dbTimeP,
2440 budb_dumpList *dumps) /* pointer to buffer */
2441{
2442 struct ubik_trans *ut;
2443 dbadr da;
2444 struct dump d;
2445 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
2446 afs_int32 eval, code = 0;
2447 afs_int32 toskip;
2448 struct returnList list;
2449
2450 /* Don't check permissions when we look up a specific dump id */
2451 if (((flags & BUDB_OP_STARTS(0x7<<3)) != BUDB_OP_DUMPID(2<<3)) && !callPermitted(call))
2452 return BUDB_NOTPERMITTED(156303880L);
2453
2454 if (majorVersion != BUDB_MAJORVERSION2)
2455 return BUDB_OLDINTERFACE(156303891L);
2456 if (index < 0)
2457 return BUDB_ENDOFLIST(156303886L);
2458
2459 eval = InitRPC(&ut, LOCKREAD1, 1);
2460 if (eval)
2461 return eval;
2462
2463 nameFlags = flags & BUDB_OP_NAMES(0x7);
2464 startFlags = flags & BUDB_OP_STARTS(0x7<<3);
2465 endFlags = flags & BUDB_OP_ENDS(0x7<<6);
2466 timeFlags = flags & BUDB_OP_TIMES(0x3<<9);
2467
2468 InitReturnList(&list);
2469 toskip = index;
2470
2471 if (nameFlags == BUDB_OP_DUMPNAME(1<<0)) {
2472 /* not yet implemented */
2473 if (startFlags || endFlags || timeFlags)
2474 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2475
2476 eval = ht_LookupEntry(ut, &db.dumpName, name, &da, &d);
2477 if (eval)
2478 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2479 if (!da)
2480 ABORT(BUDB_NODUMPNAME)do { code = (156303874L); goto abort_exit; } while (0);
2481
2482 while (1) {
2483 if (strcmp(d.dumpName, name) == 0) {
2484 eval = AddToReturnList(&list, da, &toskip);
2485 if (eval == BUDB_LIST2BIG(156303885L))
2486 break;
2487 if (eval)
2488 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2489 }
2490
2491 da = ntohl(d.nameHashChain)(__builtin_constant_p(d.nameHashChain) ? ((((__uint32_t)(d.nameHashChain
)) >> 24) | ((((__uint32_t)(d.nameHashChain)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(d.nameHashChain)
) & (0xff << 8)) << 8) | (((__uint32_t)(d.nameHashChain
)) << 24)) : __bswap32_var(d.nameHashChain)); /* get next dump w/ name */
2492 if (!da)
2493 break;
2494
2495 eval = dbread(ut, da, &d, sizeof(d));
2496 if (eval)
2497 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2498 }
2499 } else if (nameFlags == BUDB_OP_VOLUMENAME(2<<0)) {
2500#ifdef PA
2501 struct volInfo vi;
2502
2503 LogError(0, "NYI, BUDB_OP_VOLUMENAME\n");
2504 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2505
2506
2507 if (startFlags != BUDB_OP_STARTTIME(1<<3))
2508 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2509
2510 /* lookup a dump by volumename and time stamp. Find the most recent
2511 * dump of the specified volumename, that occured before the supplied
2512 * time
2513 */
2514
2515 /* get us a volInfo for name */
2516 eval = ht_LookupEntry(ut, &db.volName, name, &da, &vi);
2517 if (eval)
2518 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2519
2520 while (1) {
2521 /* now iterate over all the entries of this name */
2522 for (va = vi.firstFragment; va != 0; va = v.sameNameChain) {
2523 va = ntohl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
2524 eval = dbread(ut, va, &v, sizeof(v));
2525 if (eval)
2526 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2527
2528 if date
2529 on fragment > date ignore it - too recent;
2530
2531 if (date on fragment < date && date on fragment > bestfound)
2532 bestfound = date on fragment;
2533
2534 } /* for va */
2535
2536 da = vi.sameNameChain;
2537 if (da == 0)
2538 break;
2539 da = ntohl(da)(__builtin_constant_p(da) ? ((((__uint32_t)(da)) >> 24)
| ((((__uint32_t)(da)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(da)) & (0xff << 8)) << 8) |
(((__uint32_t)(da)) << 24)) : __bswap32_var(da));
2540 eval = dbread(ut, da, &vi, sizeof(vi));
2541 if (eval)
2542 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2543 }
2544
2545/*
2546 if nothing found
2547 return error
2548
2549 from saved volfragment address, compute dump.
2550 otherwise, return dump found
2551*/
2552
2553#endif /* PA */
2554
2555 } else if (startFlags == BUDB_OP_DUMPID(2<<3)) {
2556 if (endFlags || timeFlags)
2557 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2558 if (nameFlags)
2559 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0); /* NYI */
2560
2561 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &da, &d);
2562 if (eval)
2563 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2564 if (!da)
2565 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
2566
2567 eval = AddToReturnList(&list, da, &toskip);
2568 if (eval)
2569 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2570 } else if (endFlags == BUDB_OP_NPREVIOUS(2<<6)) {
2571 struct wantDumpRock rock;
2572 struct chosenDump *ptr, *nextPtr;
2573
2574 /* no other flags should be set */
2575
2576 /* end specifies how many dumps */
2577 if (!end)
2578 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2579
2580 memset(&rock, 0, sizeof(rock));
2581 rock.maxDumps = end;
2582
2583 scanHashTable(ut, &db.dumpName, wantDump, rememberDump,
2584 (char *)&rock);
2585
2586 for (ptr = rock.chain; ptr; ptr = nextPtr) {
2587 nextPtr = ptr->next;
2588 AddToReturnList(&list, ptr->addr, &toskip); /* ignore error for free */
2589 free(ptr);
2590 }
2591 } else {
2592 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2593 }
2594
2595 eval =
2596 SendReturnList(ut, &list, FillDumpEntry,
2597 sizeof(struct budb_dumpEntry), index, nextIndexP,
2598 dbTimeP, (returnList_tbudb_dumpList *) dumps);
2599 if (eval)
2600 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2601
2602 FreeReturnList(&list);
2603 code = ubik_EndTrans(ut);
2604 return code;
2605
2606 abort_exit:
2607 FreeReturnList(&list);
2608 ubik_AbortTrans(ut);
2609 return code;
2610}
2611
2612/*
2613 * Get the expiration of a tape. Since the dump could have appended dumps,
2614 * we should use the most recent expiration date. Put the most recent
2615 * expiration tape into the given tape structure.
2616 */
2617afs_int32
2618getExpiration(struct ubik_trans *ut, struct tape *tapePtr)
2619{
2620 dbadr ad;
2621 struct dump d;
2622 struct tape t;
2623 afs_int32 initDump;
2624 afs_int32 eval, code = 0;
2625
2626 if (!tapePtr)
2627 ERROR(0)do { code = 0; goto error_exit; } while (0);
2628
2629 /* Get the dump for this tape */
2630 ad = ntohl(tapePtr->dump)(__builtin_constant_p(tapePtr->dump) ? ((((__uint32_t)(tapePtr
->dump)) >> 24) | ((((__uint32_t)(tapePtr->dump))
& (0xff << 16)) >> 8) | ((((__uint32_t)(tapePtr
->dump)) & (0xff << 8)) << 8) | (((__uint32_t
)(tapePtr->dump)) << 24)) : __bswap32_var(tapePtr->
dump));
2631 eval = dbread(ut, ad, &d, sizeof(d));
2632 if (eval)
2633 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2634
2635 /* If not an initial dump, get the initial dump */
2636 if (d.initialDumpID) {
2637 initDump = ntohl(d.initialDumpID)(__builtin_constant_p(d.initialDumpID) ? ((((__uint32_t)(d.initialDumpID
)) >> 24) | ((((__uint32_t)(d.initialDumpID)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(d.initialDumpID)
) & (0xff << 8)) << 8) | (((__uint32_t)(d.initialDumpID
)) << 24)) : __bswap32_var(d.initialDumpID));
2638 eval = ht_LookupEntry(ut, &db.dumpIden, &initDump, &ad, &d);
2639 if (eval)
2640 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2641 }
2642
2643 /* Cycle through the dumps and appended dumps */
2644 while (ad) {
2645 /* Get the first tape in this dump. No need to check the rest of the tapes */
2646 /* for this dump since they will all have the same expiration date */
2647 eval = dbread(ut, ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape)), &t, sizeof(t));
2648 if (eval)
2649 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2650
2651 /* Take the greater of the expiration dates */
2652 if (ntohl(tapePtr->expires)(__builtin_constant_p(tapePtr->expires) ? ((((__uint32_t)(
tapePtr->expires)) >> 24) | ((((__uint32_t)(tapePtr->
expires)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tapePtr->expires)) & (0xff << 8)) << 8) |
(((__uint32_t)(tapePtr->expires)) << 24)) : __bswap32_var
(tapePtr->expires)) < ntohl(t.expires)(__builtin_constant_p(t.expires) ? ((((__uint32_t)(t.expires)
) >> 24) | ((((__uint32_t)(t.expires)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.expires)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.expires)) << 24)) :
__bswap32_var(t.expires)))
2653 tapePtr->expires = t.expires;
2654
2655 /* Step to and read the next appended dump */
2656 if ((ad = ntohl(d.appendedDumpChain)(__builtin_constant_p(d.appendedDumpChain) ? ((((__uint32_t)(
d.appendedDumpChain)) >> 24) | ((((__uint32_t)(d.appendedDumpChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
appendedDumpChain)) & (0xff << 8)) << 8) | ((
(__uint32_t)(d.appendedDumpChain)) << 24)) : __bswap32_var
(d.appendedDumpChain)))) {
2657 eval = dbread(ut, ad, &d, sizeof(d));
2658 if (eval)
2659 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2660 }
2661 }
2662
2663 error_exit:
2664 return (code);
2665}
2666
2667/* Mark the following dump as appended to another, intial dump */
2668afs_int32
2669makeAppended(struct ubik_trans *ut, afs_int32 appendedDumpID,
2670 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2671{
2672 dbadr ada, da, lastDumpAddr;
2673 struct dump ad, d;
2674 afs_int32 eval, code = 0;
2675
2676 if (!initialDumpID)
2677 ERROR(0)do { code = 0; goto error_exit; } while (0);
2678 if (appendedDumpID == initialDumpID)
2679 ERROR(BUDB_INTERNALERROR)do { code = (156303895L); goto error_exit; } while (0);
2680
2681 /* If there is an initial dump, append this dump to it */
2682 /* Find the appended dump via its id */
2683 eval = ht_LookupEntry(ut, &db.dumpIden, &appendedDumpID, &ada, &ad);
2684 if (eval)
2685 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2686
2687 /* If the dump is already marked as appended,
2688 * then we have an internal error.
2689 */
2690 if (ad.initialDumpID) {
2691 if (ntohl(ad.initialDumpID)(__builtin_constant_p(ad.initialDumpID) ? ((((__uint32_t)(ad.
initialDumpID)) >> 24) | ((((__uint32_t)(ad.initialDumpID
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ad
.initialDumpID)) & (0xff << 8)) << 8) | (((__uint32_t
)(ad.initialDumpID)) << 24)) : __bswap32_var(ad.initialDumpID
)) != initialDumpID)
2692 ERROR(BUDB_INTERNALERROR)do { code = (156303895L); goto error_exit; } while (0);
2693 }
2694
2695 /* Update the appended dump to point to the initial dump */
2696 ad.initialDumpID = htonl(initialDumpID)(__builtin_constant_p(initialDumpID) ? ((((__uint32_t)(initialDumpID
)) >> 24) | ((((__uint32_t)(initialDumpID)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(initialDumpID)) &
(0xff << 8)) << 8) | (((__uint32_t)(initialDumpID
)) << 24)) : __bswap32_var(initialDumpID));
2697 ad.tapes.b = htonl(startTapeSeq)(__builtin_constant_p(startTapeSeq) ? ((((__uint32_t)(startTapeSeq
)) >> 24) | ((((__uint32_t)(startTapeSeq)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(startTapeSeq)) & (0xff
<< 8)) << 8) | (((__uint32_t)(startTapeSeq)) <<
24)) : __bswap32_var(startTapeSeq));
2698
2699 /* find the initial dump via its id */
2700 eval = ht_LookupEntry(ut, &db.dumpIden, &initialDumpID, &da, &d);
2701 if (eval)
2702 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2703
2704 /* Update the appended dump's tape format with that of the initial */
2705 strcpy(ad.tapes.format, d.tapes.format);
2706
2707 /* starting with the initial dump step through its appended dumps till
2708 * we reach the last appended dump.
2709 */
2710 lastDumpAddr = da;
2711 while (d.appendedDumpChain) {
2712 lastDumpAddr = ntohl(d.appendedDumpChain)(__builtin_constant_p(d.appendedDumpChain) ? ((((__uint32_t)(
d.appendedDumpChain)) >> 24) | ((((__uint32_t)(d.appendedDumpChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
appendedDumpChain)) & (0xff << 8)) << 8) | ((
(__uint32_t)(d.appendedDumpChain)) << 24)) : __bswap32_var
(d.appendedDumpChain));
2713 if (lastDumpAddr == ada)
2714 ERROR(0)do { code = 0; goto error_exit; } while (0); /* Already appended */
2715 eval = dbread(ut, lastDumpAddr, &d, sizeof(d));
2716 if (eval)
2717 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2718 }
2719
2720 /* Update the last dump to point to our new appended dump.
2721 * The appended dump is the last one in the dump chain.
2722 */
2723 d.appendedDumpChain = htonl(ada)(__builtin_constant_p(ada) ? ((((__uint32_t)(ada)) >> 24
) | ((((__uint32_t)(ada)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(ada)) & (0xff << 8)) << 8
) | (((__uint32_t)(ada)) << 24)) : __bswap32_var(ada));
2724 ad.appendedDumpChain = 0;
2725
2726 /* Write the appended dump and the initial dump */
2727 eval = dbwrite(ut, ada, (char *)&ad, sizeof(ad));
2728 if (eval)
2729 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2730
2731 eval = dbwrite(ut, lastDumpAddr, (char *)&d, sizeof(d));
2732 if (eval)
2733 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2734
2735 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
2736 if (eval)
2737 ERROR(eval)do { code = eval; goto error_exit; } while (0);
2738
2739 error_exit:
2740 return (code);
2741}
2742
2743afs_int32
2744SBUDB_MakeDumpAppended(struct rx_call *call, afs_int32 appendedDumpID,
2745 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2746{
2747 afs_int32 code;
2748
2749 code =
2750 MakeDumpAppended(call, appendedDumpID, initialDumpID, startTapeSeq);
2751 osi_auditU(call, BUDB_AppDmpEvent"AFS_BUDB_AppDmp", code, AUD_LONG5, appendedDumpID,
2752 AUD_END0);
2753 return code;
2754}
2755
2756afs_int32
2757MakeDumpAppended(struct rx_call *call, afs_int32 appendedDumpID,
2758 afs_int32 initialDumpID, afs_int32 startTapeSeq)
2759{
2760 struct ubik_trans *ut;
2761 afs_int32 eval, code = 0;
2762
2763 if (!callPermitted(call))
2764 return BUDB_NOTPERMITTED(156303880L);
2765
2766 eval = InitRPC(&ut, LOCKWRITE2, 1);
2767 if (eval)
2768 return (eval);
2769
2770 eval = makeAppended(ut, appendedDumpID, initialDumpID, startTapeSeq);
2771 if (eval)
2772 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2773
2774 code = ubik_EndTrans(ut);
2775 return (code);
2776
2777 abort_exit:
2778 ubik_AbortTrans(ut);
2779 return (code);
2780}
2781
2782/* Find the last tape of a dump-set. This includes any appended dumps */
2783afs_int32
2784SBUDB_FindLastTape(struct rx_call *call, afs_int32 dumpID,
2785 struct budb_dumpEntry *dumpEntry,
2786 struct budb_tapeEntry *tapeEntry,
2787 struct budb_volumeEntry *volEntry)
2788{
2789 afs_int32 code;
2790
2791 code = FindLastTape(call, dumpID, dumpEntry, tapeEntry, volEntry);
2792 osi_auditU(call, BUDB_FndLTpeEvent"AFS_BUDB_FnLTpe", code, AUD_LONG5, dumpID, AUD_END0);
2793 return code;
2794}
2795
2796afs_int32
2797FindLastTape(struct rx_call *call, afs_int32 dumpID,
2798 struct budb_dumpEntry *dumpEntry,
2799 struct budb_tapeEntry *tapeEntry,
2800 struct budb_volumeEntry *volEntry)
2801{
2802 struct ubik_trans *ut;
2803 struct dump d;
2804 dbadr lastDump;
2805 struct tape t;
2806 dbadr lastTape, thisTape;
2807 afs_int32 lastTapeSeq;
2808 struct volFragment vf;
2809 dbadr lastVol, thisVol;
2810 afs_int32 lastVolPos;
2811 afs_int32 eval, code = 0;
2812
2813 if (!callPermitted(call))
2814 return BUDB_NOTPERMITTED(156303880L);
2815
2816 if (!dumpID)
2817 return (BUDB_BADARGUMENT(156303882L));
2818
2819 eval = InitRPC(&ut, LOCKREAD1, 1);
2820 if (eval)
2821 return (eval);
2822
2823 /* find and read its initial dump via its id */
2824 eval = ht_LookupEntry(ut, &db.dumpIden, &dumpID, &lastDump, &d);
2825 if (eval)
2826 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2827 if (!lastDump)
2828 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
2829
2830 /* Follow the append dumps link chain until we reach the last dump */
2831 while (d.appendedDumpChain) {
2832 lastDump = ntohl(d.appendedDumpChain)(__builtin_constant_p(d.appendedDumpChain) ? ((((__uint32_t)(
d.appendedDumpChain)) >> 24) | ((((__uint32_t)(d.appendedDumpChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(d.
appendedDumpChain)) & (0xff << 8)) << 8) | ((
(__uint32_t)(d.appendedDumpChain)) << 24)) : __bswap32_var
(d.appendedDumpChain));
2833 eval = dbread(ut, lastDump, &d, sizeof(d));
2834 if (eval)
2835 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2836 }
2837
2838 /* We now have the last dump of the last appended dump */
2839 /* Copy this into our return structure */
2840 eval = FillDumpEntry(ut, lastDump, dumpEntry);
2841 if (eval)
2842 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2843
2844 /* Fail if the last dump has no tapes */
2845 if (!d.firstTape)
2846 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
2847
2848 /* Follow the tapes in this dump until we reach the last tape */
2849 eval = dbread(ut, ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape)), &t, sizeof(t));
2850 if (eval)
2851 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2852
2853 lastTape = ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape));
2854 lastTapeSeq = ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq));
2855 lastVol = ntohl(t.firstVol)(__builtin_constant_p(t.firstVol) ? ((((__uint32_t)(t.firstVol
)) >> 24) | ((((__uint32_t)(t.firstVol)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.firstVol)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.firstVol)) << 24)) :
__bswap32_var(t.firstVol));
2856
2857 while (t.nextTape) {
2858 thisTape = ntohl(t.nextTape)(__builtin_constant_p(t.nextTape) ? ((((__uint32_t)(t.nextTape
)) >> 24) | ((((__uint32_t)(t.nextTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nextTape)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nextTape)) << 24)) :
__bswap32_var(t.nextTape));
2859 eval = dbread(ut, thisTape, &t, sizeof(t));
2860 if (eval)
2861 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2862
2863 if (ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq)) > lastTapeSeq) {
2864 lastTape = thisTape;
2865 lastTapeSeq = ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq));
2866 lastVol = ntohl(t.firstVol)(__builtin_constant_p(t.firstVol) ? ((((__uint32_t)(t.firstVol
)) >> 24) | ((((__uint32_t)(t.firstVol)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.firstVol)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.firstVol)) << 24)) :
__bswap32_var(t.firstVol));
2867 }
2868 }
2869
2870 /* We now have the last tape of the last appended dump */
2871 /* Copy this into our return structure */
2872 eval = FillTapeEntry(ut, lastTape, tapeEntry);
2873 if (eval)
2874 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2875
2876 /* Zero volume entry if the last tape has no volumes */
2877 if (!lastVol) {
2878 memset(volEntry, 0, sizeof(*volEntry));
2879 } else {
2880 /* Follow the volumes until we reach the last volume */
2881 eval = dbread(ut, lastVol, &vf, sizeof(vf));
2882 if (eval)
2883 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2884
2885 lastVolPos = vf.position;
2886
2887 while (vf.sameTapeChain) {
2888 thisVol = ntohl(vf.sameTapeChain)(__builtin_constant_p(vf.sameTapeChain) ? ((((__uint32_t)(vf.
sameTapeChain)) >> 24) | ((((__uint32_t)(vf.sameTapeChain
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(vf
.sameTapeChain)) & (0xff << 8)) << 8) | (((__uint32_t
)(vf.sameTapeChain)) << 24)) : __bswap32_var(vf.sameTapeChain
));
2889 eval = dbread(ut, thisVol, &vf, sizeof(vf));
2890 if (eval)
2891 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2892
2893 if (vf.position > lastVolPos) {
2894 lastVol = thisVol;
2895 lastVolPos = vf.position;
2896 }
2897 }
2898
2899 /* We now have the last volume of this tape */
2900 /* Copy this into our return structure */
2901 eval = FillVolEntry(ut, lastVol, volEntry);
2902 if (eval)
2903 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2904 }
2905
2906 eval = ubik_EndTrans(ut);
2907 if (!code)
2908 code = eval;
2909 return (code);
2910
2911 abort_exit:
2912 ubik_AbortTrans(ut);
2913 return (code);
2914}
2915
2916
2917afs_int32
2918SBUDB_GetTapes(struct rx_call *call,
2919 afs_int32 majorVersion, /* version of interface structures */
2920 afs_int32 flags, /* search & select controls */
2921 char *name, /* s&s parameters */
2922 afs_int32 start,
2923 afs_int32 end, /* reserved: MBZ */
2924 afs_int32 index, /* start index of returned entries */
2925 afs_int32 *nextIndexP, /* output index for next call */
2926 afs_int32 *dbTimeP,
2927 budb_tapeList *tapes) /* pointer to buffer */
2928{
2929 afs_int32 code;
2930
2931 code =
2932 GetTapes(call, majorVersion, flags, name, start, end, index,
2933 nextIndexP, dbTimeP, tapes);
2934 osi_auditU(call, BUDB_GetTpeEvent"AFS_BUDB_GetTpe", code, AUD_END0);
2935 return code;
2936}
2937
2938afs_int32
2939GetTapes(struct rx_call *call,
2940 afs_int32 majorVersion, /* version of interface structures */
2941 afs_int32 flags, /* search & select controls */
2942 char *name, /* s&s parameters */
2943 afs_int32 start,
2944 afs_int32 end, /* reserved: MBZ */
2945 afs_int32 index, /* start index of returned entries */
2946 afs_int32 *nextIndexP, /* output index for next call */
2947 afs_int32 *dbTimeP,
2948 budb_tapeList *tapes) /* pointer to buffer */
2949{
2950 struct ubik_trans *ut;
2951 dbadr da, ta;
2952 struct dump d;
2953 struct tape t;
2954 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
2955 struct returnList list;
2956 afs_int32 eval, code = 0;
2957 afs_int32 toskip;
2958
2959 if (!callPermitted(call))
2960 return BUDB_NOTPERMITTED(156303880L);
2961
2962 if (majorVersion != BUDB_MAJORVERSION2)
2963 return BUDB_OLDINTERFACE(156303891L);
2964
2965 if (index < 0)
2966 return BUDB_ENDOFLIST(156303886L);
2967
2968 eval = InitRPC(&ut, LOCKREAD1, 1);
2969 if (eval)
2970 return eval;
2971
2972 nameFlags = flags & BUDB_OP_NAMES(0x7);
2973 startFlags = flags & BUDB_OP_STARTS(0x7<<3);
2974 endFlags = flags & BUDB_OP_ENDS(0x7<<6);
2975 timeFlags = flags & BUDB_OP_TIMES(0x3<<9);
2976
2977 InitReturnList(&list);
2978 toskip = index;
2979
2980 if (nameFlags == BUDB_OP_TAPENAME(3<<0)) { /*it */
2981 eval = ht_LookupEntry(ut, &db.tapeName, name, &ta, &t);
2982 if (eval)
2983 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2984 if (!ta)
2985 ABORT(BUDB_NOTAPENAME)do { code = (156303875L); goto abort_exit; } while (0);
2986
2987 /* NYI */
2988 if ((startFlags & ~BUDB_OP_DUMPID(2<<3)) || endFlags || timeFlags)
2989 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
2990
2991 /* follow the hash chain to the end */
2992 while (ta) { /*w */
2993 if (startFlags & BUDB_OP_DUMPID(2<<3)) {
2994 /* read in the dump */
2995 eval = dbread(ut, ntohl(t.dump)(__builtin_constant_p(t.dump) ? ((((__uint32_t)(t.dump)) >>
24) | ((((__uint32_t)(t.dump)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.dump)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.dump)) << 24)) : __bswap32_var(t
.dump)), &d, sizeof(d));
2996 if (eval)
2997 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
2998
2999 /* check if both name and dump id match */
3000 if ((strcmp(name, t.name) == 0) && (ntohl(d.id)(__builtin_constant_p(d.id) ? ((((__uint32_t)(d.id)) >>
24) | ((((__uint32_t)(d.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(d.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(d.id)) << 24)) : __bswap32_var(d.id
)) == start)) {
3001 eval = AddToReturnList(&list, ta, &toskip);
3002 if (eval && (eval != BUDB_LIST2BIG(156303885L)))
3003 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3004 break;
3005 }
3006 } else {
3007 /* Add to return list and continue search */
3008 if (strcmp(name, t.name) == 0) {
3009 eval = AddToReturnList(&list, ta, &toskip);
3010 if (eval == BUDB_LIST2BIG(156303885L))
3011 break;
3012 if (eval)
3013 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3014 }
3015 }
3016
3017 ta = ntohl(t.nameHashChain)(__builtin_constant_p(t.nameHashChain) ? ((((__uint32_t)(t.nameHashChain
)) >> 24) | ((((__uint32_t)(t.nameHashChain)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(t.nameHashChain)
) & (0xff << 8)) << 8) | (((__uint32_t)(t.nameHashChain
)) << 24)) : __bswap32_var(t.nameHashChain));
3018 if (ta)
3019 dbread(ut, ta, &t, sizeof(t));
3020 } /*w */
3021 } /*it */
3022 else if (nameFlags == BUDB_OP_TAPESEQ(4<<0)) {
3023 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &da, &d);
3024 if (eval)
3025 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3026 if (!da)
3027 ABORT(BUDB_NODUMPNAME)do { code = (156303874L); goto abort_exit; } while (0);
3028
3029 /* search for the right tape */
3030 ta = ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape));
3031 for (ta = ntohl(d.firstTape)(__builtin_constant_p(d.firstTape) ? ((((__uint32_t)(d.firstTape
)) >> 24) | ((((__uint32_t)(d.firstTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(d.firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(d.firstTape)) <<
24)) : __bswap32_var(d.firstTape)); ta; ta = ntohl(t.nextTape)(__builtin_constant_p(t.nextTape) ? ((((__uint32_t)(t.nextTape
)) >> 24) | ((((__uint32_t)(t.nextTape)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(t.nextTape)) & (0xff <<
8)) << 8) | (((__uint32_t)(t.nextTape)) << 24)) :
__bswap32_var(t.nextTape))) {
3032 eval = dbread(ut, ta, &t, sizeof(t));
3033 if (eval)
3034 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3035
3036 if (ntohl(t.seq)(__builtin_constant_p(t.seq) ? ((((__uint32_t)(t.seq)) >>
24) | ((((__uint32_t)(t.seq)) & (0xff << 16)) >>
8) | ((((__uint32_t)(t.seq)) & (0xff << 8)) <<
8) | (((__uint32_t)(t.seq)) << 24)) : __bswap32_var(t.
seq)) == end) {
3037 eval = AddToReturnList(&list, ta, &toskip);
3038 if (eval && (eval != BUDB_LIST2BIG(156303885L)))
3039 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3040 break;
3041 }
3042 }
3043 } else {
3044 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
3045 }
3046
3047 eval =
3048 SendReturnList(ut, &list, FillTapeEntry,
3049 sizeof(struct budb_tapeEntry), index, nextIndexP,
3050 dbTimeP, (returnList_tbudb_dumpList *) tapes);
3051 if (eval)
3052 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3053
3054 FreeReturnList(&list);
3055 code = ubik_EndTrans(ut);
3056 return code;
3057
3058 abort_exit:
3059 FreeReturnList(&list);
3060 ubik_AbortTrans(ut);
3061 return (code);
3062}
3063
3064/* BUDB_GetVolumes
3065 * get a set of volumes according to the specified criteria.
3066 * See BUDB_GetDumps for general information on parameters
3067 * Currently supports:
3068 * 1) volume match - returns volumes based on volume name only.
3069 * 2) flags = BUDB_OP_DUMPID in which case name is a volume name
3070 * and start is a dumpid. Returns all volumes of the specified
3071 * name on the selected dumpid.
3072 */
3073
3074afs_int32
3075SBUDB_GetVolumes(struct rx_call *call,
3076 afs_int32 majorVersion, /* version of interface structures */
3077 afs_int32 flags, /* search & select controls */
3078 char *name, /* - parameters for search */
3079 afs_int32 start, /* - usage depends which BUDP_OP */
3080 afs_int32 end, /* - bits are set */
3081 afs_int32 index, /* start index of returned entries */
3082 afs_int32 *nextIndexP, /* output index for next call */
3083 afs_int32 *dbTimeP,
3084 budb_volumeList *volumes) /* pointer to buffer */
3085{
3086 afs_int32 code;
3087
3088 code =
3089 GetVolumes(call, majorVersion, flags, name, start, end, index,
3090 nextIndexP, dbTimeP, volumes);
3091 osi_auditU(call, BUDB_GetVolEvent"AFS_BUDB_GetVol", code, AUD_END0);
3092 return code;
3093}
3094
3095afs_int32
3096GetVolumes(struct rx_call *call,
3097 afs_int32 majorVersion, /* version of interface structures */
3098 afs_int32 flags, /* search & select controls */
3099 char *name, /* - parameters for search */
3100 afs_int32 start, /* - usage depends which BUDP_OP_* */
3101 afs_int32 end, /* - bits are set */
3102 afs_int32 index, /* start index of returned entries */
3103 afs_int32 *nextIndexP, /* output index for next call */
3104 afs_int32 *dbTimeP,
3105 budb_volumeList *volumes) /* pointer to buffer */
3106{
3107 struct ubik_trans *ut;
3108 dbadr via;
3109 struct volInfo vi;
3110 afs_int32 nameFlags, startFlags, endFlags, timeFlags;
3111 afs_int32 eval, code = 0;
3112 struct returnList vollist;
3113 afs_int32 toskip;
3114
3115 /* Don't check permissions when we look up a specific volume name */
3116 if (((flags & BUDB_OP_NAMES(0x7)) != BUDB_OP_VOLUMENAME(2<<0))
3117 && !callPermitted(call))
3118 return BUDB_NOTPERMITTED(156303880L);
3119
3120 if (majorVersion != BUDB_MAJORVERSION2)
3121 return BUDB_OLDINTERFACE(156303891L);
3122 if (index < 0)
3123 return BUDB_ENDOFLIST(156303886L);
3124
3125 eval = InitRPC(&ut, LOCKREAD1, 1);
3126 if (eval)
3127 return eval;
3128
3129 nameFlags = flags & BUDB_OP_NAMES(0x7);
3130 startFlags = flags & BUDB_OP_STARTS(0x7<<3);
3131 endFlags = flags & BUDB_OP_ENDS(0x7<<6);
3132 timeFlags = flags & BUDB_OP_TIMES(0x3<<9);
3133
3134 InitReturnList(&vollist);
3135 toskip = index;
3136
3137 /* lookup a the volume (specified by name) in the dump (specified by id) */
3138 if (nameFlags == BUDB_OP_VOLUMENAME(2<<0)) {
3139 /* dumpid permissible, all others off */
3140 if (((startFlags & ~BUDB_OP_DUMPID(2<<3)) != 0) || endFlags || timeFlags)
3141 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
3142
3143 /* returns ptr to volinfo of requested name */
3144 eval = ht_LookupEntry(ut, &db.volName, name, &via, &vi);
3145 if (eval)
3146 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3147 if (!via)
3148 ABORT(BUDB_NOVOLUMENAME)do { code = (156303876L); goto abort_exit; } while (0);
3149
3150 /* Iterate over all volume fragments with this name */
3151 while (1) {
3152 struct volFragment v;
3153 afs_int32 va;
3154
3155 /* traverse all the volume fragments for this volume info structure */
3156 for (va = vi.firstFragment; va; va = v.sameNameChain) {
3157 va = ntohl(va)(__builtin_constant_p(va) ? ((((__uint32_t)(va)) >> 24)
| ((((__uint32_t)(va)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(va)) & (0xff << 8)) << 8) |
(((__uint32_t)(va)) << 24)) : __bswap32_var(va));
3158 eval = dbread(ut, va, &v, sizeof(v));
3159 if (eval)
3160 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3161
3162 if (startFlags & BUDB_OP_DUMPID(2<<3)) {
3163 struct tape atape;
3164 struct dump adump;
3165
3166 /* get the dump id for this fragment */
3167 eval = dbread(ut, ntohl(v.tape)(__builtin_constant_p(v.tape) ? ((((__uint32_t)(v.tape)) >>
24) | ((((__uint32_t)(v.tape)) & (0xff << 16)) >>
8) | ((((__uint32_t)(v.tape)) & (0xff << 8)) <<
8) | (((__uint32_t)(v.tape)) << 24)) : __bswap32_var(v
.tape)), &atape, sizeof(atape));
3168 if (eval)
3169 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3170
3171 eval =
3172 dbread(ut, ntohl(atape.dump)(__builtin_constant_p(atape.dump) ? ((((__uint32_t)(atape.dump
)) >> 24) | ((((__uint32_t)(atape.dump)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(atape.dump)) & (0xff <<
8)) << 8) | (((__uint32_t)(atape.dump)) << 24)) :
__bswap32_var(atape.dump)), &adump, sizeof(adump));
3173 if (eval)
3174 ABORT(BUDB_IO)do { code = (156303892L); goto abort_exit; } while (0);
3175
3176 /* dump id does not match */
3177 if (ntohl(adump.id)(__builtin_constant_p(adump.id) ? ((((__uint32_t)(adump.id)) >>
24) | ((((__uint32_t)(adump.id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(adump.id)) & (0xff << 8)) <<
8) | (((__uint32_t)(adump.id)) << 24)) : __bswap32_var
(adump.id)) != start)
3178 continue;
3179 }
3180
3181 eval = AddToReturnList(&vollist, va, &toskip);
3182 if (eval == BUDB_LIST2BIG(156303885L))
3183 break;
3184 if (eval)
3185 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3186 }
3187 if (eval == BUDB_LIST2BIG(156303885L))
3188 break;
3189
3190 via = vi.sameNameChain;
3191 if (via == 0)
3192 break;
3193 via = ntohl(via)(__builtin_constant_p(via) ? ((((__uint32_t)(via)) >> 24
) | ((((__uint32_t)(via)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(via)) & (0xff << 8)) << 8
) | (((__uint32_t)(via)) << 24)) : __bswap32_var(via));
3194
3195 eval = dbread(ut, via, &vi, sizeof(vi));
3196 if (eval)
3197 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3198 }
3199 } else if (((nameFlags == 0) || (nameFlags == BUDB_OP_TAPENAME(3<<0)))
3200 && (startFlags == BUDB_OP_DUMPID(2<<3))) {
3201 struct dump dump;
3202 dbadr dumpAddr;
3203 struct tape tape;
3204 dbadr tapeAddr;
3205 struct volFragment volFrag;
3206 dbadr volFragAddr;
3207
3208 /* lookup all volumes for a specified dump id */
3209
3210 /* no other flags should be set */
3211 if (endFlags || timeFlags)
3212 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
3213
3214 /* find the dump */
3215 eval = ht_LookupEntry(ut, &db.dumpIden, &start, &dumpAddr, &dump);
3216 if (eval)
3217 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3218
3219 /* traverse all the tapes */
3220 for (tapeAddr = ntohl(dump.firstTape)(__builtin_constant_p(dump.firstTape) ? ((((__uint32_t)(dump.
firstTape)) >> 24) | ((((__uint32_t)(dump.firstTape)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(dump.firstTape
)) & (0xff << 8)) << 8) | (((__uint32_t)(dump
.firstTape)) << 24)) : __bswap32_var(dump.firstTape)); tapeAddr; tapeAddr = ntohl(tape.nextTape)(__builtin_constant_p(tape.nextTape) ? ((((__uint32_t)(tape.nextTape
)) >> 24) | ((((__uint32_t)(tape.nextTape)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.nextTape)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.nextTape
)) << 24)) : __bswap32_var(tape.nextTape))) { /*w */
3221 eval = dbread(ut, tapeAddr, &tape, sizeof(tape));
3222 if (eval)
3223 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3224
3225 if ((nameFlags != BUDB_OP_TAPENAME(3<<0))
3226 || ((nameFlags == BUDB_OP_TAPENAME(3<<0))
3227 && (strcmp(tape.name, name) == 0))) {
3228 /* now return all the volumes */
3229 for (volFragAddr = ntohl(tape.firstVol)(__builtin_constant_p(tape.firstVol) ? ((((__uint32_t)(tape.firstVol
)) >> 24) | ((((__uint32_t)(tape.firstVol)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape.firstVol)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape.firstVol
)) << 24)) : __bswap32_var(tape.firstVol)); volFragAddr;
3230 volFragAddr = ntohl(volFrag.sameTapeChain)(__builtin_constant_p(volFrag.sameTapeChain) ? ((((__uint32_t
)(volFrag.sameTapeChain)) >> 24) | ((((__uint32_t)(volFrag
.sameTapeChain)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(volFrag.sameTapeChain)) & (0xff << 8)) <<
8) | (((__uint32_t)(volFrag.sameTapeChain)) << 24)) : __bswap32_var
(volFrag.sameTapeChain))) {
3231 eval = dbread(ut, volFragAddr, &volFrag, sizeof(volFrag));
3232 if (eval)
3233 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3234
3235 eval = AddToReturnList(&vollist, volFragAddr, &toskip);
3236 if (eval == BUDB_LIST2BIG(156303885L))
3237 break;
3238 if (eval)
3239 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3240 }
3241 }
3242 if (eval == BUDB_LIST2BIG(156303885L))
3243 break;
3244 } /*w */
3245 } else {
3246 ABORT(BUDB_BADFLAGS)do { code = (156303884L); goto abort_exit; } while (0);
3247 }
3248
3249 eval =
3250 SendReturnList(ut, &vollist, FillVolEntry,
3251 sizeof(struct budb_volumeEntry), index, nextIndexP,
3252 dbTimeP, (returnList_tbudb_dumpList *) volumes);
3253 if (eval)
3254 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3255
3256 /* error_exit: */
3257 FreeReturnList(&vollist);
3258 code = ubik_EndTrans(ut);
3259 return code;
3260
3261 abort_exit:
3262 FreeReturnList(&vollist);
3263 ubik_AbortTrans(ut);
3264 return code;
3265}
3266
3267afs_int32
3268SBUDB_UseTape(struct rx_call *call,
3269 struct budb_tapeEntry *tape, /* tape info */
3270 afs_int32 *new) /* set if tape is new */
3271{
3272 afs_int32 code;
3273
3274 code = UseTape(call, tape, new);
3275 osi_auditU(call, BUDB_UseTpeEvent"AFS_BUDB_UseTpe", code, AUD_DATE6,
3276 (tape ? tape->dump : 0), AUD_END0);
3277 return code;
3278}
3279
3280afs_int32
3281UseTape(struct rx_call *call,
3282 struct budb_tapeEntry *tape, /* tape info */
3283 int *new) /* set if tape is new */
3284{
3285 struct ubik_trans *ut;
3286 dbadr da, a;
3287 struct dump d;
3288 struct tape t;
3289 afs_int32 eval, code;
3290
3291 if (!callPermitted(call))
3292 return BUDB_NOTPERMITTED(156303880L);
3293
3294 if (strlen(tape->name) >= sizeof(t.name))
3295 return BUDB_BADARGUMENT(156303882L);
3296
3297 eval = InitRPC(&ut, LOCKWRITE2, 1);
3298 if (eval)
3299 return eval;
3300
3301 *new = 0;
3302
3303 memset(&t, 0, sizeof(t));
3304 eval = AllocStructure(ut, tape_BLOCK3, 0, &a, &t);
3305 if (eval)
3306 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3307
3308 strcpy(t.name, tape->name);
3309
3310 eval = ht_HashIn(ut, &db.tapeName, a, &t);
3311 if (eval)
3312 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3313
3314 *new = 1;
3315
3316 /* Since deleting a tape may change the dump (if its the same one), read in
3317 * the dump after the call to DeleteTape. */
3318
3319 eval = ht_LookupEntry(ut, &db.dumpIden, &tape->dump, &da, &d);
3320 if (eval)
3321 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3322 if (!da)
3323 ABORT(BUDB_NODUMPID)do { code = (156303873L); goto abort_exit; } while (0);
3324
3325 if (!tape->written)
3326 tape->written = time(0); /* fill in tape struct */
3327 t.written = htonl(tape->written)(__builtin_constant_p(tape->written) ? ((((__uint32_t)(tape
->written)) >> 24) | ((((__uint32_t)(tape->written
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->written)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->written)) << 24)) : __bswap32_var(tape->written
));
3328 t.expires = htonl(tape->expires)(__builtin_constant_p(tape->expires) ? ((((__uint32_t)(tape
->expires)) >> 24) | ((((__uint32_t)(tape->expires
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->expires)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->expires)) << 24)) : __bswap32_var(tape->expires
));
3329 t.dump = htonl(da)(__builtin_constant_p(da) ? ((((__uint32_t)(da)) >> 24)
| ((((__uint32_t)(da)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(da)) & (0xff << 8)) << 8) |
(((__uint32_t)(da)) << 24)) : __bswap32_var(da));
3330 t.seq = htonl(tape->seq)(__builtin_constant_p(tape->seq) ? ((((__uint32_t)(tape->
seq)) >> 24) | ((((__uint32_t)(tape->seq)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape->seq)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape->seq
)) << 24)) : __bswap32_var(tape->seq));
3331 t.useCount = htonl(tape->useCount)(__builtin_constant_p(tape->useCount) ? ((((__uint32_t)(tape
->useCount)) >> 24) | ((((__uint32_t)(tape->useCount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->useCount)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->useCount)) << 24)) : __bswap32_var(tape->
useCount));
3332 t.labelpos = htonl(tape->labelpos)(__builtin_constant_p(tape->labelpos) ? ((((__uint32_t)(tape
->labelpos)) >> 24) | ((((__uint32_t)(tape->labelpos
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(tape
->labelpos)) & (0xff << 8)) << 8) | (((__uint32_t
)(tape->labelpos)) << 24)) : __bswap32_var(tape->
labelpos));
3333 t.useKBytes = 0;
3334 t.flags = htonl(tape->flags | BUDB_TAPE_BEINGWRITTEN)(__builtin_constant_p(tape->flags | (1<<2)) ? ((((__uint32_t
)(tape->flags | (1<<2))) >> 24) | ((((__uint32_t
)(tape->flags | (1<<2))) & (0xff << 16)) >>
8) | ((((__uint32_t)(tape->flags | (1<<2))) & (
0xff << 8)) << 8) | (((__uint32_t)(tape->flags
| (1<<2))) << 24)) : __bswap32_var(tape->flags
| (1<<2)));
3335
3336 t.nextTape = d.firstTape; /* Chain the tape to the dump */
3337 d.firstTape = htonl(a)(__builtin_constant_p(a) ? ((((__uint32_t)(a)) >> 24) |
((((__uint32_t)(a)) & (0xff << 16)) >> 8) | (
(((__uint32_t)(a)) & (0xff << 8)) << 8) | (((
__uint32_t)(a)) << 24)) : __bswap32_var(a));
3338
3339 if (tape->seq >= ntohl(d.tapes.maxTapes)(__builtin_constant_p(d.tapes.maxTapes) ? ((((__uint32_t)(d.tapes
.maxTapes)) >> 24) | ((((__uint32_t)(d.tapes.maxTapes))
& (0xff << 16)) >> 8) | ((((__uint32_t)(d.tapes
.maxTapes)) & (0xff << 8)) << 8) | (((__uint32_t
)(d.tapes.maxTapes)) << 24)) : __bswap32_var(d.tapes.maxTapes
))) /* inc # tapes in the dump */
3340 d.tapes.maxTapes = htonl(tape->seq)(__builtin_constant_p(tape->seq) ? ((((__uint32_t)(tape->
seq)) >> 24) | ((((__uint32_t)(tape->seq)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(tape->seq)) &
(0xff << 8)) << 8) | (((__uint32_t)(tape->seq
)) << 24)) : __bswap32_var(tape->seq));
3341
3342 eval = dbwrite(ut, a, &t, sizeof(t)); /* write tape struct */
3343 if (eval)
3344 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3345
3346 eval = dbwrite(ut, da, &d, sizeof(d)); /* write the dump struct */
3347 if (eval)
3348 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3349
3350 eval = set_header_word(ut, lastUpdate, htonl(time(0)))dbwrite ((ut), ((char *)&(db.h.lastUpdate) - (char *)&
db.h), ((db.h.lastUpdate = ((__builtin_constant_p(time(0)) ? (
(((__uint32_t)(time(0))) >> 24) | ((((__uint32_t)(time(
0))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
time(0))) & (0xff << 8)) << 8) | (((__uint32_t
)(time(0))) << 24)) : __bswap32_var(time(0))))), (char *
)&(db.h.lastUpdate)), sizeof(afs_int32));
3351 if (eval)
3352 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3353
3354 LogDebug(5, "added tape %s\n", tape->name);
3355
3356 code = ubik_EndTrans(ut);
3357 return code;
3358
3359 abort_exit:
3360 ubik_AbortTrans(ut);
3361 return code;
3362
3363}
3364
3365
3366/* ---------------------------------------------
3367 * debug interface routines
3368 * ---------------------------------------------
3369 */
3370
3371afs_int32
3372SBUDB_T_DumpHashTable(struct rx_call *call, afs_int32 type, char *filename)
3373{
3374 afs_int32 code;
3375
3376 code = T_DumpHashTable(call, type, filename);
3377 osi_auditU(call, BUDB_TDmpHaEvent"AFS_BUDB_TDmpHa", code, AUD_STR1, filename, AUD_END0);
3378 return code;
3379}
3380
3381afs_int32
3382T_DumpHashTable(struct rx_call *call, int type, char *filename)
3383{
3384 struct ubik_trans *ut;
3385 struct memoryHashTable *mht;
3386 int ent;
3387 afs_int32 eval, code = 0;
3388 char path[64];
3389 FILE *DUMP;
3390
3391 int length;
3392 afs_uint32 hash;
3393 dbadr a, first_a;
3394 char e[sizeof(struct block)]; /* unnecessarily conservative */
3395 struct dump e_dump;
3396 struct tape e_tape;
3397 struct volInfo e_volinfo;
3398 int e_size;
3399 int old;
3400
3401 if (!callPermitted(call))
3402 return BUDB_NOTPERMITTED(156303880L);
3403
3404 if (strlen(filename) >= sizeof(path) - 5)
3405 return BUDB_BADARGUMENT(156303882L);
3406
3407 eval = InitRPC(&ut, LOCKWRITE2, 1);
3408 if (eval)
3409 return eval;
3410
3411 if ((mht = ht_GetType(type, &e_size)) == 0)
3412 return BUDB_BADARGUMENT(156303882L);
3413
3414 sprintf(path, "%s/%s", gettmpdir(), filename);
3415
3416 DUMP = fopen(path, "w");
3417 if (!DUMP)
3418 ABORT(BUDB_BADARGUMENT)do { code = (156303882L); goto abort_exit; } while (0);
3419
3420 ent = 0;
3421 for (old = 0;; old++) {
3422 length = (old ? mht->oldLength : mht->length);
3423 if (length)
3424 fprintf(DUMP, "Dumping %sHash Table:\n", (old ? "Old " : ""));
3425
3426 for (hash = 0; hash < length; hash++) {
3427 a = ht_LookupBucket(ut, mht, hash, old);
3428 first_a = a;
3429 while (a) {
3430 eval = dbread(ut, a, e, e_size);
3431 if (eval)
3432 ABORT(eval)do { code = eval; goto abort_exit; } while (0);
3433
3434 ent++;
3435 if (a == first_a)
3436 fprintf(DUMP, " in bucket %d at %d is ", hash, a);
3437 else
3438 fprintf(DUMP, " at %d is ", a);
3439 switch (type) {
3440 case HT_dumpIden_FUNCTION1:
3441 memcpy(&e_dump, e, sizeof(e_dump));
3442 fprintf(DUMP, "%d\n", ntohl(e_dump.id)(__builtin_constant_p(e_dump.id) ? ((((__uint32_t)(e_dump.id)
) >> 24) | ((((__uint32_t)(e_dump.id)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(e_dump.id)) & (0xff <<
8)) << 8) | (((__uint32_t)(e_dump.id)) << 24)) :
__bswap32_var(e_dump.id)));
3443 break;
3444 case HT_dumpName_FUNCTION2:
3445 memcpy(&e_dump, e, sizeof(e_dump));
3446 fprintf(DUMP, "%s\n", e_dump.dumpName);
3447 break;
3448 case HT_tapeName_FUNCTION3:
3449 memcpy(&e_tape, e, sizeof(e_tape));
3450 fprintf(DUMP, "%s\n", e_tape.name);
3451 break;
3452 case HT_volName_FUNCTION4:
3453 memcpy(&e_volinfo, e, sizeof(e_volinfo));
3454 fprintf(DUMP, "%s\n", e_volinfo.name);
3455 break;
3456 }
3457 if ((ht_HashEntry(mht, e) % length) != hash)
3458 ABORT(BUDB_DATABASEINCONSISTENT)do { code = (156303894L); goto abort_exit; } while (0);
3459 a = ntohl(*(dbadr *) (e + mht->threadOffset))(__builtin_constant_p(*(dbadr *) (e + mht->threadOffset)) ?
((((__uint32_t)(*(dbadr *) (e + mht->threadOffset))) >>
24) | ((((__uint32_t)(*(dbadr *) (e + mht->threadOffset))
) & (0xff << 16)) >> 8) | ((((__uint32_t)(*(dbadr
*) (e + mht->threadOffset))) & (0xff << 8)) <<
8) | (((__uint32_t)(*(dbadr *) (e + mht->threadOffset))) <<
24)) : __bswap32_var(*(dbadr *) (e + mht->threadOffset)));
3460 }
3461 }
3462 if (old)
3463 break;
3464 }
3465
3466 fprintf(DUMP, "%d entries found\n", ent);
3467 if (ntohl(mht->ht->entries)(__builtin_constant_p(mht->ht->entries) ? ((((__uint32_t
)(mht->ht->entries)) >> 24) | ((((__uint32_t)(mht
->ht->entries)) & (0xff << 16)) >> 8) |
((((__uint32_t)(mht->ht->entries)) & (0xff <<
8)) << 8) | (((__uint32_t)(mht->ht->entries)) <<
24)) : __bswap32_var(mht->ht->entries)) != ent)
3468 ABORT(BUDB_DATABASEINCONSISTENT)do { code = (156303894L); goto abort_exit; } while (0);
3469
3470 code = ubik_EndTrans(ut);
3471 if (DUMP)
3472 fclose(DUMP);
3473 return code;
3474
3475 abort_exit:
3476 ubik_AbortTrans(ut);
3477 if (DUMP)
3478 fclose(DUMP);
3479 return code;
3480}
3481
3482afs_int32
3483SBUDB_T_GetVersion(struct rx_call *call, afs_int32 *majorVersion)
3484{
3485 afs_int32 code;
3486
3487 code = T_GetVersion(call, majorVersion);
3488 osi_auditU(call, BUDB_TGetVrEvent"AFS_BUDB_TGetVr", code, AUD_END0);
3489 return code;
3490}
3491
3492afs_int32
3493T_GetVersion(struct rx_call *call, int *majorVersion)
3494{
3495 struct ubik_trans *ut;
3496 afs_int32 code;
3497
3498 code = InitRPC(&ut, LOCKREAD1, 0);
3499 if (code)
3500 return (code);
3501
3502 *majorVersion = BUDB_MAJORVERSION2;
3503
3504 code = ubik_EndTrans(ut);
3505 return (code);
3506}
3507
3508/* BUDB_T_DumpDatabase
3509 * dump as much of the database as possible int /tmp/<filename>
3510 */
3511
3512afs_int32
3513SBUDB_T_DumpDatabase(struct rx_call *call, char *filename)
3514{
3515 afs_int32 code;
3516
3517 code = T_DumpDatabase(call, filename);
3518 osi_auditU(call, BUDB_TDmpDBEvent"AFS_BUDB_TDmpDB", code, AUD_STR1, filename, AUD_END0);
3519 return code;
3520}
3521
3522afs_int32
3523T_DumpDatabase(struct rx_call *call, char *filename)
3524{
3525 FILE *dumpfid;
3526 int entrySize;
3527 struct ubik_trans *ut;
3528 char *path = 0;
3529 dbadr dbAddr;
3530 int type, old, length, hash;
3531 struct memoryHashTable *mht;
3532 afs_int32 eval, code = 0;
3533
3534 if (!callPermitted(call))
3535 return BUDB_NOTPERMITTED(156303880L);
3536
3537 path = (char *)malloc(strlen(gettmpdir()) + 1 + strlen(filename) + 1);
3538 if (!path)
3539 return (BUDB_INTERNALERROR(156303895L));
3540
3541 sprintf(path, "%s/%s", gettmpdir(), filename);
3542
3543 dumpfid = fopen(path, "w");
3544 if (!dumpfid)
3545 return (BUDB_BADARGUMENT(156303882L));
3546
3547 eval = InitRPC(&ut, LOCKWRITE2, 1);
3548 if (eval)
3549 return (eval);
3550
3551 /* dump all items in the database */
3552 for (type = 1; type <= HT_MAX_FUNCTION4; type++) { /*ft */
3553 mht = ht_GetType(type, &entrySize);
3554 if (!mht)
3555 ERROR(BUDB_BADARGUMENT)do { code = (156303882L); goto error_exit; } while (0);
3556
3557 for (old = 0; old <= 1; old++) { /*fo */
3558 length = (old ? mht->oldLength : mht->length);
3559 if (!length)
3560 continue;
3561
3562 fprintf(dumpfid, "Dumping %s Hash Table:\n", (old ? "Old " : ""));
3563
3564 for (hash = 0; hash < length; hash++) { /*f */
3565 dbAddr = ht_LookupBucket(ut, mht, hash, old);
3566
3567 while (dbAddr) { /*w */
3568 switch (type) { /*s */
3569 case HT_dumpIden_FUNCTION1:
3570 {
3571 struct dump hostDump, diskDump;
3572
3573 eval =
3574 cdbread(ut, dump_BLOCK4, dbAddr, &diskDump,
3575 sizeof(diskDump));
3576 if (eval)
3577 ERROR(eval)do { code = eval; goto error_exit; } while (0);
3578
3579 fprintf(dumpfid,
3580 "\ndumpId hash %d, entry at %u\n",
3581 hash, dbAddr);
3582 fprintf(dumpfid,
3583 "----------------------------\n");
3584 dump_ntoh(&diskDump, &hostDump);
3585 printDump(dumpfid, &hostDump);
3586 dbAddr = hostDump.idHashChain;
3587 }
3588 break;
3589
3590 case HT_dumpName_FUNCTION2:
3591 {
3592 struct dump hostDump, diskDump;
3593
3594 eval =
3595 cdbread(ut, dump_BLOCK4, dbAddr, &diskDump,
3596 sizeof(diskDump));
3597 if (eval)
3598 ERROR(eval)do { code = eval; goto error_exit; } while (0);
3599
3600 fprintf(dumpfid,
3601 "\ndumpname hash %d, entry at %u\n",
3602 hash, dbAddr);
3603 fprintf(dumpfid,
3604 "----------------------------\n");
3605 dump_ntoh(&diskDump, &hostDump);
3606 printDump(dumpfid, &hostDump);
3607 dbAddr = hostDump.nameHashChain;
3608 }
3609 break;
3610
3611 case HT_tapeName_FUNCTION3:
3612 {
3613 struct tape hostTape, diskTape;
3614
3615 eval =
3616 cdbread(ut, tape_BLOCK3, dbAddr, &diskTape,
3617 sizeof(diskTape));
3618 if (eval)
3619 ERROR(eval)do { code = eval; goto error_exit; } while (0);
3620
3621 fprintf(dumpfid,
3622 "\ntapename hash %d, entry at %u\n",
3623 hash, dbAddr);
3624 fprintf(dumpfid,
3625 "----------------------------\n");
3626 tape_ntoh(&diskTape, &hostTape);
3627 printTape(dumpfid, &hostTape);
3628 dbAddr = hostTape.nameHashChain;
3629 }
3630 break;
3631
3632 case HT_volName_FUNCTION4:
3633 {
3634 struct volInfo hostVolInfo, diskVolInfo;
3635
3636 eval =
3637 cdbread(ut, volInfo_BLOCK2, dbAddr,
3638 &diskVolInfo, sizeof(diskVolInfo));
3639 if (eval)
3640 ERROR(eval)do { code = eval; goto error_exit; } while (0);
3641
3642 fprintf(dumpfid,
3643 "\nvolname hash %d, entry at %u\n",
3644 hash, dbAddr);
3645 fprintf(dumpfid,
3646 "----------------------------\n");
3647 volInfo_ntoh(&diskVolInfo, &hostVolInfo);
3648 printVolInfo(dumpfid, &hostVolInfo);
3649 dbAddr = hostVolInfo.nameHashChain;
3650
3651 volFragsDump(ut, dumpfid,
3652 hostVolInfo.firstFragment);
3653 }
3654 break;
3655
3656 default:
3657 fprintf(dumpfid, "unknown type %d\n", type);
3658 break;
3659
3660 } /*s */
3661 } /*w */
3662 } /*f */
3663 } /*fo */
3664 } /*ft */
3665
3666 error_exit:
3667 code = ubik_EndTrans(ut); /* is this safe if no ut started ? */
3668 if (dumpfid)
3669 fclose(dumpfid);
3670 if (path)
3671 free(path);
3672 return (code);
3673}
3674
3675int
3676volFragsDump(struct ubik_trans *ut, FILE *dumpfid, dbadr dbAddr)
3677{
3678 struct volFragment hostVolFragment, diskVolFragment;
3679 afs_int32 code;
3680
3681 while (dbAddr) {
3682 code =
3683 cdbread(ut, volFragment_BLOCK1, dbAddr, &diskVolFragment,
3684 sizeof(diskVolFragment));
3685 if (code) { /* don't be fussy about errors */
3686 fprintf(dumpfid, "volFragsDump: Error reading database\n");
3687 return (0);
3688 }
3689
3690 fprintf(dumpfid, "\nvolfragment entry at %u\n", dbAddr);
3691 fprintf(dumpfid, "----------------------------\n");
3692 volFragment_ntoh(&diskVolFragment, &hostVolFragment);
3693 printVolFragment(dumpfid, &hostVolFragment);
3694 dbAddr = hostVolFragment.sameNameChain;
3695 }
3696 return (0);
3697}
3698
3699#ifdef notdef
3700/* utilities - network to host conversion
3701 * currently used for debug only
3702 */
3703
3704void
3705volFragmentDiskToHost(struct volFragment *diskVfPtr,
3706 struct volFragment *hostVfPtr)
3707{
3708 hostVfPtr->vol = ntohl(diskVfPtr->vol)(__builtin_constant_p(diskVfPtr->vol) ? ((((__uint32_t)(diskVfPtr
->vol)) >> 24) | ((((__uint32_t)(diskVfPtr->vol))
& (0xff << 16)) >> 8) | ((((__uint32_t)(diskVfPtr
->vol)) & (0xff << 8)) << 8) | (((__uint32_t
)(diskVfPtr->vol)) << 24)) : __bswap32_var(diskVfPtr
->vol));
3709 hostVfPtr->sameNameChain = ntohl(diskVfPtr->sameNameChain)(__builtin_constant_p(diskVfPtr->sameNameChain) ? ((((__uint32_t
)(diskVfPtr->sameNameChain)) >> 24) | ((((__uint32_t
)(diskVfPtr->sameNameChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskVfPtr->sameNameChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskVfPtr->sameNameChain
)) << 24)) : __bswap32_var(diskVfPtr->sameNameChain)
);
3710 hostVfPtr->tape = ntohl(diskVfPtr->tape)(__builtin_constant_p(diskVfPtr->tape) ? ((((__uint32_t)(diskVfPtr
->tape)) >> 24) | ((((__uint32_t)(diskVfPtr->tape
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(diskVfPtr
->tape)) & (0xff << 8)) << 8) | (((__uint32_t
)(diskVfPtr->tape)) << 24)) : __bswap32_var(diskVfPtr
->tape));
3711 hostVfPtr->sameTapeChain = ntohl(diskVfPtr->sameTapeChain)(__builtin_constant_p(diskVfPtr->sameTapeChain) ? ((((__uint32_t
)(diskVfPtr->sameTapeChain)) >> 24) | ((((__uint32_t
)(diskVfPtr->sameTapeChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskVfPtr->sameTapeChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskVfPtr->sameTapeChain
)) << 24)) : __bswap32_var(diskVfPtr->sameTapeChain)
);
3712 hostVfPtr->position = ntohl(diskVfPtr->position)(__builtin_constant_p(diskVfPtr->position) ? ((((__uint32_t
)(diskVfPtr->position)) >> 24) | ((((__uint32_t)(diskVfPtr
->position)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskVfPtr->position)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskVfPtr->position)) << 24)) : __bswap32_var
(diskVfPtr->position));
3713 hostVfPtr->clone = ntohl(diskVfPtr->clone)(__builtin_constant_p(diskVfPtr->clone) ? ((((__uint32_t)(
diskVfPtr->clone)) >> 24) | ((((__uint32_t)(diskVfPtr
->clone)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskVfPtr->clone)) & (0xff << 8)) << 8) |
(((__uint32_t)(diskVfPtr->clone)) << 24)) : __bswap32_var
(diskVfPtr->clone));
3714 hostVfPtr->incTime = ntohl(diskVfPtr->incTime)(__builtin_constant_p(diskVfPtr->incTime) ? ((((__uint32_t
)(diskVfPtr->incTime)) >> 24) | ((((__uint32_t)(diskVfPtr
->incTime)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskVfPtr->incTime)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskVfPtr->incTime)) << 24)) : __bswap32_var
(diskVfPtr->incTime));
3715 hostVfPtr->startByte = ntohl(diskVfPtr->startByte)(__builtin_constant_p(diskVfPtr->startByte) ? ((((__uint32_t
)(diskVfPtr->startByte)) >> 24) | ((((__uint32_t)(diskVfPtr
->startByte)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(diskVfPtr->startByte)) & (0xff << 8)
) << 8) | (((__uint32_t)(diskVfPtr->startByte)) <<
24)) : __bswap32_var(diskVfPtr->startByte));
3716 hostVfPtr->nBytes = ntohl(diskVfPtr->nBytes)(__builtin_constant_p(diskVfPtr->nBytes) ? ((((__uint32_t)
(diskVfPtr->nBytes)) >> 24) | ((((__uint32_t)(diskVfPtr
->nBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskVfPtr->nBytes)) & (0xff << 8)) << 8)
| (((__uint32_t)(diskVfPtr->nBytes)) << 24)) : __bswap32_var
(diskVfPtr->nBytes));
3717 hostVfPtr->flags = ntohs(diskVfPtr->flags)(__builtin_constant_p(diskVfPtr->flags) ? (__uint16_t)(((__uint16_t
)(diskVfPtr->flags)) << 8 | ((__uint16_t)(diskVfPtr->
flags)) >> 8) : __bswap16_var(diskVfPtr->flags));
3718 hostVfPtr->sequence = ntohs(diskVfPtr->sequence)(__builtin_constant_p(diskVfPtr->sequence) ? (__uint16_t)(
((__uint16_t)(diskVfPtr->sequence)) << 8 | ((__uint16_t
)(diskVfPtr->sequence)) >> 8) : __bswap16_var(diskVfPtr
->sequence));
3719}
3720
3721void
3722volInfoDiskToHost(struct volInfo *diskViPtr, struct volInfo *hostViPtr)
3723{
3724 strcpy(hostViPtr->name, diskViPtr->name);
3725 hostViPtr->nameHashChain = ntohl(diskViPtr->nameHashChain)(__builtin_constant_p(diskViPtr->nameHashChain) ? ((((__uint32_t
)(diskViPtr->nameHashChain)) >> 24) | ((((__uint32_t
)(diskViPtr->nameHashChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskViPtr->nameHashChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskViPtr->nameHashChain
)) << 24)) : __bswap32_var(diskViPtr->nameHashChain)
);
3726 hostViPtr->id = ntohl(diskViPtr->id)(__builtin_constant_p(diskViPtr->id) ? ((((__uint32_t)(diskViPtr
->id)) >> 24) | ((((__uint32_t)(diskViPtr->id)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(diskViPtr->
id)) & (0xff << 8)) << 8) | (((__uint32_t)(diskViPtr
->id)) << 24)) : __bswap32_var(diskViPtr->id));
3727 strcpy(hostViPtr->server, diskViPtr->server);
3728 hostViPtr->partition = ntohl(diskViPtr->partition)(__builtin_constant_p(diskViPtr->partition) ? ((((__uint32_t
)(diskViPtr->partition)) >> 24) | ((((__uint32_t)(diskViPtr
->partition)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(diskViPtr->partition)) & (0xff << 8)
) << 8) | (((__uint32_t)(diskViPtr->partition)) <<
24)) : __bswap32_var(diskViPtr->partition));
3729 hostViPtr->flags = ntohl(diskViPtr->flags)(__builtin_constant_p(diskViPtr->flags) ? ((((__uint32_t)(
diskViPtr->flags)) >> 24) | ((((__uint32_t)(diskViPtr
->flags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskViPtr->flags)) & (0xff << 8)) << 8) |
(((__uint32_t)(diskViPtr->flags)) << 24)) : __bswap32_var
(diskViPtr->flags));
3730 hostViPtr->sameNameHead = ntohl(diskViPtr->sameNameHead)(__builtin_constant_p(diskViPtr->sameNameHead) ? ((((__uint32_t
)(diskViPtr->sameNameHead)) >> 24) | ((((__uint32_t)
(diskViPtr->sameNameHead)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskViPtr->sameNameHead)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskViPtr->sameNameHead
)) << 24)) : __bswap32_var(diskViPtr->sameNameHead));
3731 hostViPtr->sameNameChain = ntohl(diskViPtr->sameNameChain)(__builtin_constant_p(diskViPtr->sameNameChain) ? ((((__uint32_t
)(diskViPtr->sameNameChain)) >> 24) | ((((__uint32_t
)(diskViPtr->sameNameChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskViPtr->sameNameChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskViPtr->sameNameChain
)) << 24)) : __bswap32_var(diskViPtr->sameNameChain)
);
3732 hostViPtr->firstFragment = ntohl(diskViPtr->firstFragment)(__builtin_constant_p(diskViPtr->firstFragment) ? ((((__uint32_t
)(diskViPtr->firstFragment)) >> 24) | ((((__uint32_t
)(diskViPtr->firstFragment)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskViPtr->firstFragment)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskViPtr->firstFragment
)) << 24)) : __bswap32_var(diskViPtr->firstFragment)
);
3733 hostViPtr->nFrags = ntohl(diskViPtr->nFrags)(__builtin_constant_p(diskViPtr->nFrags) ? ((((__uint32_t)
(diskViPtr->nFrags)) >> 24) | ((((__uint32_t)(diskViPtr
->nFrags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskViPtr->nFrags)) & (0xff << 8)) << 8)
| (((__uint32_t)(diskViPtr->nFrags)) << 24)) : __bswap32_var
(diskViPtr->nFrags));
3734}
3735
3736void
3737tapeDiskToHost(struct tape *diskTapePtr, struct tape *hostTapePtr)
3738{
3739 strcpy(hostTapePtr->name, diskTapePtr->name);
3740 hostTapePtr->nameHashChain = ntohl(diskTapePtr->nameHashChain)(__builtin_constant_p(diskTapePtr->nameHashChain) ? ((((__uint32_t
)(diskTapePtr->nameHashChain)) >> 24) | ((((__uint32_t
)(diskTapePtr->nameHashChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskTapePtr->nameHashChain)) & (
0xff << 8)) << 8) | (((__uint32_t)(diskTapePtr->
nameHashChain)) << 24)) : __bswap32_var(diskTapePtr->
nameHashChain));
3741 hostTapePtr->flags = ntohl(diskTapePtr->flags)(__builtin_constant_p(diskTapePtr->flags) ? ((((__uint32_t
)(diskTapePtr->flags)) >> 24) | ((((__uint32_t)(diskTapePtr
->flags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->flags)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskTapePtr->flags)) << 24)) : __bswap32_var
(diskTapePtr->flags));
3742
3743 /* tape id conversion here */
3744 hostTapePtr->written = ntohl(diskTapePtr->written)(__builtin_constant_p(diskTapePtr->written) ? ((((__uint32_t
)(diskTapePtr->written)) >> 24) | ((((__uint32_t)(diskTapePtr
->written)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->written)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskTapePtr->written)) << 24)) :
__bswap32_var(diskTapePtr->written));
3745 hostTapePtr->nBytes = ntohl(diskTapePtr->nBytes)(__builtin_constant_p(diskTapePtr->nBytes) ? ((((__uint32_t
)(diskTapePtr->nBytes)) >> 24) | ((((__uint32_t)(diskTapePtr
->nBytes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->nBytes)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskTapePtr->nBytes)) << 24)) : __bswap32_var
(diskTapePtr->nBytes));
3746 hostTapePtr->nFiles = ntohl(diskTapePtr->nFiles)(__builtin_constant_p(diskTapePtr->nFiles) ? ((((__uint32_t
)(diskTapePtr->nFiles)) >> 24) | ((((__uint32_t)(diskTapePtr
->nFiles)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->nFiles)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskTapePtr->nFiles)) << 24)) : __bswap32_var
(diskTapePtr->nFiles));
3747 hostTapePtr->nVolumes = ntohl(diskTapePtr->nVolumes)(__builtin_constant_p(diskTapePtr->nVolumes) ? ((((__uint32_t
)(diskTapePtr->nVolumes)) >> 24) | ((((__uint32_t)(diskTapePtr
->nVolumes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskTapePtr->nVolumes)) << 24))
: __bswap32_var(diskTapePtr->nVolumes));
3748 hostTapePtr->seq = ntohl(diskTapePtr->seq)(__builtin_constant_p(diskTapePtr->seq) ? ((((__uint32_t)(
diskTapePtr->seq)) >> 24) | ((((__uint32_t)(diskTapePtr
->seq)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->seq)) & (0xff << 8)) << 8) |
(((__uint32_t)(diskTapePtr->seq)) << 24)) : __bswap32_var
(diskTapePtr->seq));
3749 hostTapePtr->dump = ntohl(diskTapePtr->dump)(__builtin_constant_p(diskTapePtr->dump) ? ((((__uint32_t)
(diskTapePtr->dump)) >> 24) | ((((__uint32_t)(diskTapePtr
->dump)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->dump)) & (0xff << 8)) << 8)
| (((__uint32_t)(diskTapePtr->dump)) << 24)) : __bswap32_var
(diskTapePtr->dump));
3750 hostTapePtr->nextTape = ntohl(diskTapePtr->nextTape)(__builtin_constant_p(diskTapePtr->nextTape) ? ((((__uint32_t
)(diskTapePtr->nextTape)) >> 24) | ((((__uint32_t)(diskTapePtr
->nextTape)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->nextTape)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskTapePtr->nextTape)) << 24))
: __bswap32_var(diskTapePtr->nextTape));
3751 hostTapePtr->firstVol = ntohl(diskTapePtr->firstVol)(__builtin_constant_p(diskTapePtr->firstVol) ? ((((__uint32_t
)(diskTapePtr->firstVol)) >> 24) | ((((__uint32_t)(diskTapePtr
->firstVol)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->firstVol)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskTapePtr->firstVol)) << 24))
: __bswap32_var(diskTapePtr->firstVol));
3752 hostTapePtr->useCount = ntohl(diskTapePtr->useCount)(__builtin_constant_p(diskTapePtr->useCount) ? ((((__uint32_t
)(diskTapePtr->useCount)) >> 24) | ((((__uint32_t)(diskTapePtr
->useCount)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskTapePtr->useCount)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskTapePtr->useCount)) << 24))
: __bswap32_var(diskTapePtr->useCount));
3753}
3754
3755void
3756dumpDiskToHost(struct dump *diskDumpPtr, struct dump *hostDumpPtr)
3757{
3758 hostDumpPtr->id = ntohl(diskDumpPtr->id)(__builtin_constant_p(diskDumpPtr->id) ? ((((__uint32_t)(diskDumpPtr
->id)) >> 24) | ((((__uint32_t)(diskDumpPtr->id))
& (0xff << 16)) >> 8) | ((((__uint32_t)(diskDumpPtr
->id)) & (0xff << 8)) << 8) | (((__uint32_t
)(diskDumpPtr->id)) << 24)) : __bswap32_var(diskDumpPtr
->id));
3759 hostDumpPtr->idHashChain = ntohl(diskDumpPtr->idHashChain)(__builtin_constant_p(diskDumpPtr->idHashChain) ? ((((__uint32_t
)(diskDumpPtr->idHashChain)) >> 24) | ((((__uint32_t
)(diskDumpPtr->idHashChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskDumpPtr->idHashChain)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskDumpPtr->idHashChain
)) << 24)) : __bswap32_var(diskDumpPtr->idHashChain)
);
3760 strcpy(hostDumpPtr->dumpName, diskDumpPtr->dumpName);
3761 strcpy(hostDumpPtr->dumpPath, diskDumpPtr->dumpPath);
3762 strcpy(hostDumpPtr->volumeSet, diskDumpPtr->volumeSet);
3763 hostDumpPtr->nameHashChain = ntohl(diskDumpPtr->nameHashChain)(__builtin_constant_p(diskDumpPtr->nameHashChain) ? ((((__uint32_t
)(diskDumpPtr->nameHashChain)) >> 24) | ((((__uint32_t
)(diskDumpPtr->nameHashChain)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskDumpPtr->nameHashChain)) & (
0xff << 8)) << 8) | (((__uint32_t)(diskDumpPtr->
nameHashChain)) << 24)) : __bswap32_var(diskDumpPtr->
nameHashChain));
3764 hostDumpPtr->flags = ntohl(diskDumpPtr->flags)(__builtin_constant_p(diskDumpPtr->flags) ? ((((__uint32_t
)(diskDumpPtr->flags)) >> 24) | ((((__uint32_t)(diskDumpPtr
->flags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskDumpPtr->flags)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskDumpPtr->flags)) << 24)) : __bswap32_var
(diskDumpPtr->flags));
3765 hostDumpPtr->parent = ntohl(diskDumpPtr->parent)(__builtin_constant_p(diskDumpPtr->parent) ? ((((__uint32_t
)(diskDumpPtr->parent)) >> 24) | ((((__uint32_t)(diskDumpPtr
->parent)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskDumpPtr->parent)) & (0xff << 8)) << 8
) | (((__uint32_t)(diskDumpPtr->parent)) << 24)) : __bswap32_var
(diskDumpPtr->parent));
3766 hostDumpPtr->created = ntohl(diskDumpPtr->created)(__builtin_constant_p(diskDumpPtr->created) ? ((((__uint32_t
)(diskDumpPtr->created)) >> 24) | ((((__uint32_t)(diskDumpPtr
->created)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskDumpPtr->created)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskDumpPtr->created)) << 24)) :
__bswap32_var(diskDumpPtr->created));
3767/* hostDumpPtr->incTime = ntohl(diskDumpPtr->incTime); */
3768 hostDumpPtr->nVolumes = ntohl(diskDumpPtr->nVolumes)(__builtin_constant_p(diskDumpPtr->nVolumes) ? ((((__uint32_t
)(diskDumpPtr->nVolumes)) >> 24) | ((((__uint32_t)(diskDumpPtr
->nVolumes)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(diskDumpPtr->nVolumes)) & (0xff << 8)) <<
8) | (((__uint32_t)(diskDumpPtr->nVolumes)) << 24))
: __bswap32_var(diskDumpPtr->nVolumes));
3769
3770 /* tapeset conversion here */
3771
3772 hostDumpPtr->firstTape = ntohl(diskDumpPtr->firstTape)(__builtin_constant_p(diskDumpPtr->firstTape) ? ((((__uint32_t
)(diskDumpPtr->firstTape)) >> 24) | ((((__uint32_t)(
diskDumpPtr->firstTape)) & (0xff << 16)) >>
8) | ((((__uint32_t)(diskDumpPtr->firstTape)) & (0xff
<< 8)) << 8) | (((__uint32_t)(diskDumpPtr->firstTape
)) << 24)) : __bswap32_var(diskDumpPtr->firstTape));
3773
3774 /* principal conversion here */
3775}
3776
3777#endif /* notdef */
3778
3779int
3780checkHash(struct ubik_trans *ut, int hashType)
3781{
3782 struct memoryHashTable *mhtPtr;
3783 int entrySize, hashTableLength;
3784 int bucket;
3785 int old;
3786 afs_int32 code = 0;
3787
3788 mhtPtr = ht_GetType(hashType, &entrySize);
3789 if (mhtPtr == 0)
3790 ERROR(-1)do { code = -1; goto error_exit; } while (0);
3791
3792 for (old = 0; old < 1; old++) {
3793 LogDebug(5, "\nold = %d\n", old);
3794 printMemoryHashTable(stdout__stdoutp, mhtPtr);
3795 LogDebug(5, "\n");
3796 hashTableLength = (old ? mhtPtr->oldLength : mhtPtr->length);
3797
3798 for (bucket = 0; bucket < hashTableLength; bucket++) {
3799 dbadr entryAddr;
3800
3801 entryAddr = ht_LookupBucket(ut, mhtPtr, bucket, old);
3802 while (entryAddr != 0) {
3803 LogDebug(6, "bucket %d has disk addr %d\n", bucket,
3804 entryAddr);
3805 switch (hashType) {
3806 case HT_dumpIden_FUNCTION1:
3807 {
3808 struct dump diskDump, hostDump;
3809
3810 code = dbread(ut, entryAddr, &diskDump, entrySize);
3811 if (code)
3812 ERROR(-1)do { code = -1; goto error_exit; } while (0);
3813
3814 dump_ntoh(&diskDump, &hostDump);
3815 printDump(stdout__stdoutp, &hostDump);
3816 entryAddr = hostDump.idHashChain;
3817 }
3818 break;
3819
3820 case HT_dumpName_FUNCTION2:
3821 break;
3822
3823 case HT_tapeName_FUNCTION3:
3824 break;
3825
3826 case HT_volName_FUNCTION4:
3827 {
3828 struct volInfo diskVolInfo, hostVolInfo;
3829
3830 code = dbread(ut, entryAddr, &diskVolInfo, entrySize);
3831 if (code)
3832 ERROR(-1)do { code = -1; goto error_exit; } while (0);
3833
3834 volInfo_ntoh(&diskVolInfo, &hostVolInfo);
3835 printVolInfo(stdout__stdoutp, &hostVolInfo);
3836 entryAddr = hostVolInfo.nameHashChain;
3837 break;
3838 }
3839 }
3840 }
3841 }
3842 }
3843 error_exit:
3844 return (code);
3845}