#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
+#include <roken.h>
-#include <stdio.h>
-#include <stdlib.h> /* for malloc() */
-#include <time.h> /* ANSI standard location for time stuff */
-#include <string.h>
-#ifdef AFS_NT40_ENV
-#include <fcntl.h>
-#include <io.h>
-#else
-#include <sys/time.h>
+#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
-#include <unistd.h>
#endif
-#include <afs/afs_assert.h>
-
-#include <afs/stds.h>
+#include <afs/opr.h>
+#include <opr/lock.h>
#include <afs/nfs.h> /* yuck. This is an abomination. */
-#include <lwp.h>
#include <rx/rx.h>
+#include <rx/rx_queue.h>
#include <afs/afscbint.h>
#include <afs/afsutil.h>
-#include <lock.h>
#include <afs/ihandle.h>
+#include <afs/partition.h>
#include <afs/vnode.h>
#include <afs/volume.h>
#include "viced_prototypes.h"
#include "host.h"
#include "callback.h"
#ifdef AFS_DEMAND_ATTACH_FS
-#include "../tviced/serialize_state.h"
+#include "serialize_state.h"
#endif /* AFS_DEMAND_ATTACH_FS */
static int AddCallBack1_r(struct host *host, AFSFid * fid, afs_uint32 * thead,
int type, int locked);
static void MultiBreakCallBack_r(struct cbstruct cba[], int ncbas,
- struct AFSCBFids *afidp, struct host *xhost);
-static int MultiBreakVolumeCallBack_r(struct host *host, int isheld,
+ struct AFSCBFids *afidp);
+static int MultiBreakVolumeCallBack_r(struct host *host,
struct VCBParams *parms, int deletefe);
-static int MultiBreakVolumeLaterCallBack(struct host *host, int isheld,
- void *rock);
+static int MultiBreakVolumeLaterCallBack(struct host *host, void *rock);
static int GetSomeSpace_r(struct host *hostp, int locked);
static int ClearHostCallbacks_r(struct host *hp, int locked);
static int DumpCallBackState_r(void);
for (safety = 0, cbp = &fe->firstcb; *cbp && *cbp != cbi;
cbp = &itocb(*cbp)->cnext, safety++) {
if (safety > cbstuff.nblks + 10) {
- osi_Panic("CDel: Internal Error -- shutting down: wanted %d from %d, now at %d\n",
- cbi, fe->firstcb, *cbp);
- ViceLog(0,
- ("CDel: Internal Error -- shutting down: wanted %d from %d, now at %d\n",
- cbi, fe->firstcb, *cbp));
+ ViceLogThenPanic(0, ("CDel: Internal Error -- shutting down: "
+ "wanted %d from %d, now at %d\n",
+ cbi, fe->firstcb, *cbp));
DumpCallBackState_r();
ShutDownAndCore(PANIC);
}
while (*p && *p != fei)
p = &itofe(*p)->fnext;
- osi_Assert(*p);
+ opr_Assert(*p);
*p = fe->fnext;
FreeFE(fe);
return 0;
int
InitCallBack(int nblks)
{
+ opr_Assert(nblks > 0);
+
H_LOCK;
- tfirst = CBtime(FT_ApproxTime());
+ tfirst = CBtime(time(NULL));
/* N.B. The "-1", below, is because
* FE[0] and CB[0] are not used--and not allocated */
- FE = ((struct FileEntry *)(calloc(nblks, sizeof(struct FileEntry))));
+ FE = calloc(nblks, sizeof(struct FileEntry));
if (!FE) {
- ViceLog(0, ("Failed malloc in InitCallBack\n"));
- osi_Panic("Failed malloc in InitCallBack\n");
+ ViceLogThenPanic(0, ("Failed malloc in InitCallBack\n"));
}
FE--; /* FE[0] is supposed to point to junk */
cbstuff.nFEs = nblks;
while (cbstuff.nFEs)
FreeFE(&FE[cbstuff.nFEs]); /* This is correct */
- CB = ((struct CallBack *)(calloc(nblks, sizeof(struct CallBack))));
+ CB = calloc(nblks, sizeof(struct CallBack));
if (!CB) {
- ViceLog(0, ("Failed malloc in InitCallBack\n"));
- osi_Panic("Failed malloc in InitCallBack\n");
+ ViceLogThenPanic(0, ("Failed malloc in InitCallBack\n"));
}
CB--; /* CB[0] is supposed to point to junk */
cbstuff.nCBs = nblks;
int j;
struct rx_connection *cb_conn = NULL;
-#ifdef ADAPT_MTU
rx_SetConnDeadTime(ahost->callback_rxcon, 4);
rx_SetConnHardDeadTime(ahost->callback_rxcon, AFS_HARDDEADTIME);
-#endif
code = 0;
j = 0;
fe = FindFE(fid);
if (type == CB_NORMAL) {
time_out =
- TimeCeiling(FT_ApproxTime() + TimeOut(fe ? fe->ncbs : 0) +
+ TimeCeiling(time(NULL) + TimeOut(fe ? fe->ncbs : 0) +
ServerBias);
Thead = THead(CBtime(time_out));
} else if (type == CB_VOLUME) {
- time_out = TimeCeiling((60 * 120 + FT_ApproxTime()) + ServerBias);
+ time_out = TimeCeiling((60 * 120 + time(NULL)) + ServerBias);
Thead = THead(CBtime(time_out));
} else if (type == CB_BULK) {
/* bulk status can get so many callbacks all at once, and most of them
* are probably not for things that will be used for long.
*/
time_out =
- TimeCeiling(FT_ApproxTime() + ServerBias +
+ TimeCeiling(time(NULL) + ServerBias +
TimeOut(22 + (fe ? fe->ncbs : 0)));
Thead = THead(CBtime(time_out));
}
cb->cnext = 0;
cb->fhead = fetoi(fe);
cb->status = type;
+ cb->flags = 0;
HAdd(cb, host);
TAdd(cb, Thead);
}
}
/* Take an array full of hosts, all held. Break callbacks to them, and
- * release the holds once you're done, except don't release xhost. xhost
- * may be NULL. Currently only works for a single Fid in afidp array.
+ * release the holds once you're done.
+ * Currently only works for a single Fid in afidp array.
* If you want to make this work with multiple fids, you need to fix
* the error handling. One approach would be to force a reset if a
* multi-fid call fails, or you could add delayed callbacks for each
* wherever that is done. */
static void
MultiBreakCallBack_r(struct cbstruct cba[], int ncbas,
- struct AFSCBFids *afidp, struct host *xhost)
+ struct AFSCBFids *afidp)
{
int i, j;
struct rx_connection *conns[MAX_CB_HOSTS];
static struct AFSCBs tc = { 0, 0 };
int multi_to_cba_map[MAX_CB_HOSTS];
- osi_Assert(ncbas <= MAX_CB_HOSTS);
-
- /* sort cba list to avoid makecall issues */
+ opr_Assert(ncbas <= MAX_CB_HOSTS);
+
+ /*
+ * When we issue a multi_Rx callback break, we must rx_NewCall a call for
+ * each host before we do anything. If there are no call channels
+ * available on the conn, we must wait for one of the existing calls to
+ * finish. If another thread is breaking callbacks at the same time, it is
+ * possible for us to be waiting on NewCall for one of their multi_Rx
+ * CallBack calls to finish, but they are waiting on NewCall for one of
+ * our calls to finish. So we deadlock.
+ *
+ * This can be thought of as similar to obtaining multiple locks at the
+ * same time. So if we establish an ordering, the possibility of deadlock
+ * goes away. Here we provide such an ordering, by sorting our CBAs
+ * according to CompareCBA.
+ */
qsort(cba, ncbas, sizeof(struct cbstruct), CompareCBA);
/* set up conns for multi-call */
multi_to_cba_map[j] = i;
conns[j++] = thishost->callback_rxcon;
-#ifdef ADAPT_MTU
rx_SetConnDeadTime(thishost->callback_rxcon, 4);
rx_SetConnHardDeadTime(thishost->callback_rxcon, AFS_HARDDEADTIME);
-#endif
}
if (j) { /* who knows what multi would do with 0 conns? */
for (i = 0; i < ncbas; i++) {
struct host *hp;
hp = cba[i].hp;
- if (hp && xhost != hp) {
+ if (hp) {
h_Release_r(hp);
}
}
int hostindex;
char hoststr[16];
- ViceLog(7,
- ("BCB: BreakCallBack(Host %p all but %s:%d, (%u,%u,%u))\n",
- xhost, afs_inet_ntoa_r(xhost->host, hoststr), ntohs(xhost->port),
- fid->Volume, fid->Vnode, fid->Unique));
+ if (xhost)
+ ViceLog(7,
+ ("BCB: BreakCallBack(Host %p all but %s:%d, (%u,%u,%u))\n",
+ xhost, afs_inet_ntoa_r(xhost->host, hoststr), ntohs(xhost->port),
+ fid->Volume, fid->Vnode, fid->Unique));
+ else
+ ViceLog(7,
+ ("BCB: BreakCallBack(No Host, (%u,%u,%u))\n",
+ fid->Volume, fid->Vnode, fid->Unique));
H_LOCK;
cbstuff.BreakCallBacks++;
if (!fe) {
goto done;
}
- hostindex = h_htoi(xhost);
+ hostindex = xhost ? h_htoi(xhost) : 0;
cb = itocb(fe->firstcb);
if (!cb || ((fe->ncbs == 1) && (cb->hhead == hostindex) && !flag)) {
/* the most common case is what follows the || */
tf.AFSCBFids_len = 1;
tf.AFSCBFids_val = fid;
+ /* Set CBFLAG_BREAKING flag on all CBs we're looking at. We do this so we
+ * can loop through all relevant CBs while dropping H_LOCK, and not lose
+ * track of which CBs we want to look at. If we look at all CBs over and
+ * over again, we can loop indefinitely as new CBs are added. */
+ for (; cb; cb = nextcb) {
+ nextcb = itocb(cb->cnext);
+
+ if ((cb->hhead != hostindex || flag)
+ && (cb->status == CB_BULK || cb->status == CB_NORMAL
+ || cb->status == CB_VOLUME)) {
+ cb->flags |= CBFLAG_BREAKING;
+ }
+ }
+
+ cb = itocb(fe->firstcb);
+ opr_Assert(cb);
+
+ /* loop through all CBs, only looking at ones with the CBFLAG_BREAKING
+ * flag set */
for (; cb;) {
for (ncbas = 0; cb && ncbas < MAX_CB_HOSTS; cb = nextcb) {
nextcb = itocb(cb->cnext);
- if ((cb->hhead != hostindex || flag)
- && (cb->status == CB_BULK || cb->status == CB_NORMAL
- || cb->status == CB_VOLUME)) {
+ if ((cb->flags & CBFLAG_BREAKING)) {
struct host *thishost = h_itoh(cb->hhead);
+ cb->flags &= ~CBFLAG_BREAKING;
if (!thishost) {
ViceLog(0, ("BCB: BOGUS! cb->hhead is NULL!\n"));
} else if (thishost->hostFlags & VENUSDOWN) {
}
if (ncbas) {
- MultiBreakCallBack_r(cba, ncbas, &tf, xhost);
+ MultiBreakCallBack_r(cba, ncbas, &tf);
/* we need to to all these initializations again because MultiBreakCallBack may block */
fe = FindFE(fid);
return (host->hostFlags & VENUSDOWN);
}
-/*
-** isheld is 0 if the host is held in h_Enumerate
-** isheld is 1 if the host is held in BreakVolumeCallBacks
-*/
static int
-MultiBreakVolumeCallBack_r(struct host *host, int isheld,
+MultiBreakVolumeCallBack_r(struct host *host,
struct VCBParams *parms, int deletefe)
{
char hoststr[16];
if (host->hostFlags & HOSTDELETED)
- return 0; /* host is deleted, release hold */
+ return 0;
if (!(host->hostFlags & HCBREAK))
return 0; /* host is not flagged to notify */
* later */
host->hostFlags &= ~(RESETDONE|HCBREAK); /* Do InitCallBackState when host returns */
h_Unlock_r(host);
- return 0; /* parent will release hold */
+ return 0;
}
- osi_Assert(parms->ncbas <= MAX_CB_HOSTS);
+ opr_Assert(parms->ncbas <= MAX_CB_HOSTS);
/* Do not call MultiBreakCallBack on the current host structure
** because it would prematurely release the hold on the host
tf.AFSCBFids_val = parms->fid;
/* this releases all the hosts */
- MultiBreakCallBack_r(parms->cba, parms->ncbas, &tf, 0 /* xhost */ );
+ MultiBreakCallBack_r(parms->cba, parms->ncbas, &tf);
parms->ncbas = 0;
}
parms->cba[parms->ncbas].hp = host;
parms->cba[(parms->ncbas)++].thead = parms->thead;
host->hostFlags &= ~HCBREAK;
- return 1; /* parent shouldn't release hold, more work to do */
+
+ /* we have more work to do on this host, so make sure we keep a reference
+ * to it */
+ h_Hold_r(host);
+
+ return 0;
}
-/*
-** isheld is 0 if the host is held in h_Enumerate
-** isheld is 1 if the host is held in BreakVolumeCallBacks
-*/
static int
-MultiBreakVolumeLaterCallBack(struct host *host, int isheld, void *rock)
+MultiBreakVolumeLaterCallBack(struct host *host, void *rock)
{
struct VCBParams *parms = (struct VCBParams *)rock;
int retval;
H_LOCK;
- retval = MultiBreakVolumeCallBack_r(host, isheld, parms, 0);
+ retval = MultiBreakVolumeCallBack_r(host, parms, 0);
H_UNLOCK;
return retval;
}
* Now uses multi-RX for CallBack RPC in a different thread,
* only marking them here.
*/
-#ifdef AFS_PTHREAD_ENV
extern pthread_cond_t fsync_cond;
-#else
-extern char fsync_wait[];
-#endif
int
-BreakVolumeCallBacksLater(afs_uint32 volume)
+BreakVolumeCallBacksLater(VolumeId volume)
{
int hash;
afs_uint32 *feip;
struct host *host;
int found = 0;
- ViceLog(25, ("Setting later on volume %u\n", volume));
+ ViceLog(25, ("Setting later on volume %" AFS_VOLID_FMT "\n",
+ afs_printable_VolumeId_lu(volume)));
H_LOCK;
for (hash = 0; hash < FEHASH_SIZE; hash++) {
for (feip = &HashTable[hash]; (fe = itofe(*feip)) != NULL; ) {
}
ViceLog(25, ("Fsync thread wakeup\n"));
-#ifdef AFS_PTHREAD_ENV
FSYNC_LOCK;
- CV_BROADCAST(&fsync_cond);
+ opr_cv_broadcast(&fsync_cond);
FSYNC_UNLOCK;
-#else
- LWP_NoYieldSignal(fsync_wait);
-#endif
return 0;
}
/* Ugly, but used to avoid left side casting */
struct object *tmpfe;
ViceLog(125,
- ("Unchaining for %u:%u:%u\n", fe->vnode, fe->unique,
- fe->volid));
+ ("Unchaining for %u:%u:%" AFS_VOLID_FMT "\n", fe->vnode,
+ fe->unique, afs_printable_VolumeId_lu(fe->volid)));
fid.Volume = fe->volid;
*feip = fe->fnext;
fe->status &= ~FE_LATER; /* not strictly needed */
/* leave flag for MultiBreakVolumeCallBack to clear */
} else {
ViceLog(125,
- ("Found host %p (%s:%d) non-DELAYED cb for %u:%u:%u\n",
+ ("Found host %p (%s:%d) non-DELAYED cb for %u:%u:%" AFS_VOLID_FMT "\n",
host, afs_inet_ntoa_r(host->host, hoststr),
- ntohs(host->port), fe->vnode, fe->unique, fe->volid));
+ ntohs(host->port), fe->vnode, fe->unique,
+ afs_printable_VolumeId_lu(fe->volid)));
}
}
myfe = fe;
tf.AFSCBFids_len = 1;
tf.AFSCBFids_val = &fid;
- MultiBreakCallBack_r(henumParms.cba, henumParms.ncbas, &tf, 0);
+ MultiBreakCallBack_r(henumParms.cba, henumParms.ncbas, &tf);
henumParms.ncbas = 0;
}
}
int
CleanupTimedOutCallBacks_r(void)
{
- afs_uint32 now = CBtime(FT_ApproxTime());
+ afs_uint32 now = CBtime(time(NULL));
afs_uint32 *thead;
struct CallBack *cb;
int ntimedout = 0;
cb = itocb(cbi);
cbi = cb->tnext;
ViceLog(8,
- ("CCB: deleting timed out call back %x (%s:%d), (%u,%u,%u)\n",
+ ("CCB: deleting timed out call back %x (%s:%d), (%" AFS_VOLID_FMT ",%u,%u)\n",
h_itoh(cb->hhead)->host,
afs_inet_ntoa_r(h_itoh(cb->hhead)->host, hoststr),
- h_itoh(cb->hhead)->port, itofe(cb->fhead)->volid,
+ h_itoh(cb->hhead)->port,
+ afs_printable_VolumeId_lu(itofe(cb->fhead)->volid),
itofe(cb->fhead)->vnode, itofe(cb->fhead)->unique));
HDel(cb);
CDel(cb, 1);
* theory not give these to us anyway, but be paranoid.
*/
static int
-lih0_r(struct host *host, int flags, void *rock)
+lih0_r(struct host *host, void *rock)
{
struct lih_params *params = (struct lih_params *)rock;
h_Hold_r(host);
params->lih = host;
}
- return flags;
+ return 0;
}
/* same as lih0_r, except we do not prevent held hosts from being selected. */
static int
-lih1_r(struct host *host, int flags, void *rock)
+lih1_r(struct host *host, void *rock)
{
struct lih_params *params = (struct lih_params *)rock;
h_Hold_r(host);
params->lih = host;
}
- return flags;
+ return 0;
}
/* This could be upgraded to get more space each time */
struct lih_params params;
int i = 0;
+ if (cbstuff.GotSomeSpaces == 0) {
+ /* only log this once; if GSS is getting called constantly, that's not
+ * good but don't make things worse by spamming the log. */
+ ViceLog(0, ("We have run out of callback space; forcing callback revocation. "
+ "This suggests the fileserver is configured with insufficient "
+ "callbacks; you probably want to increase the -cb fileserver "
+ "parameter (current setting: %u). The fileserver will continue "
+ "to operate, but this may indicate a severe performance problem\n",
+ cbstuff.nblks));
+ ViceLog(0, ("This message is logged at most once; for more information "
+ "see the OpenAFS documentation and fileserver xstat collection 3\n"));
+ }
+
cbstuff.GotSomeSpaces++;
ViceLog(5,
("GSS: First looking for timed out call backs via CleanupCallBacks\n"));
for (idx = 0; idx < niovecs; idx++) {
cbdsk = (struct CBDiskEntry *) iov[idx].iov_base;
+
+ if (cbdsk->cb.hhead < state->h_map.len &&
+ state->h_map.entries[cbdsk->cb.hhead].valid == FS_STATE_IDX_SKIPPED) {
+ continue;
+ }
+
if ((cb = GetCB()) == NULL) {
ViceLog(0, ("cb_stateRestoreCBs: ran out of free CallBack structures\n"));
ret = 1;
ret = 1;
goto done;
}
+ state->fe_map.entries[in->index].valid = FS_STATE_IDX_VALID;
state->fe_map.entries[in->index].old_idx = in->index;
state->fe_map.entries[in->index].new_idx = fetoi(out);
ret = 1;
goto done;
}
+ state->cb_map.entries[in->index].valid = FS_STATE_IDX_VALID;
state->cb_map.entries[in->index].old_idx = in->index;
state->cb_map.entries[in->index].new_idx = cbtoi(out);
if (old >= state->fe_map.len) {
ViceLog(0, ("fe_OldToNew: index %d is out of range\n", old));
ret = 1;
- } else if (state->fe_map.entries[old].old_idx != old) { /* sanity check */
+ } else if (state->fe_map.entries[old].valid != FS_STATE_IDX_VALID ||
+ state->fe_map.entries[old].old_idx != old) { /* sanity check */
ViceLog(0, ("fe_OldToNew: index %d points to an invalid FileEntry record\n", old));
ret = 1;
} else {
if (old >= state->cb_map.len) {
ViceLog(0, ("cb_OldToNew: index %d is out of range\n", old));
ret = 1;
- } else if (state->cb_map.entries[old].old_idx != old) { /* sanity check */
+ } else if (state->cb_map.entries[old].valid != FS_STATE_IDX_VALID ||
+ state->cb_map.entries[old].old_idx != old) { /* sanity check */
ViceLog(0, ("cb_OldToNew: index %d points to an invalid CallBack record\n", old));
ret = 1;
} else {
}
#endif /* AFS_DEMAND_ATTACH_FS */
+#define DumpBytes(fd,buf,req) if (write(fd, buf, req) < 0) {} /* don't care */
+
static int
DumpCallBackState_r(void)
{
int fd, oflag;
- afs_uint32 magic = MAGICV2, now = (afs_int32) FT_ApproxTime(), freelisthead;
+ afs_uint32 magic = MAGICV2, now = (afs_int32) time(NULL), freelisthead;
oflag = O_WRONLY | O_CREAT | O_TRUNC;
#ifdef AFS_NT40_ENV
AFSDIR_SERVER_CBKDUMP_FILEPATH));
return 0;
}
- (void)write(fd, &magic, sizeof(magic));
- (void)write(fd, &now, sizeof(now));
- (void)write(fd, &cbstuff, sizeof(cbstuff));
- (void)write(fd, TimeOuts, sizeof(TimeOuts));
- (void)write(fd, timeout, sizeof(timeout));
- (void)write(fd, &tfirst, sizeof(tfirst));
+ /*
+ * Collect but ignoring the return value of write(2) here,
+ * to avoid compiler warnings on some platforms.
+ */
+ DumpBytes(fd, &magic, sizeof(magic));
+ DumpBytes(fd, &now, sizeof(now));
+ DumpBytes(fd, &cbstuff, sizeof(cbstuff));
+ DumpBytes(fd, TimeOuts, sizeof(TimeOuts));
+ DumpBytes(fd, timeout, sizeof(timeout));
+ DumpBytes(fd, &tfirst, sizeof(tfirst));
freelisthead = cbtoi((struct CallBack *)CBfree);
- (void)write(fd, &freelisthead, sizeof(freelisthead)); /* This is a pointer */
+ DumpBytes(fd, &freelisthead, sizeof(freelisthead)); /* This is a pointer */
freelisthead = fetoi((struct FileEntry *)FEfree);
- (void)write(fd, &freelisthead, sizeof(freelisthead)); /* This is a pointer */
- (void)write(fd, HashTable, sizeof(HashTable));
- (void)write(fd, &CB[1], sizeof(CB[1]) * cbstuff.nblks); /* CB stuff */
- (void)write(fd, &FE[1], sizeof(FE[1]) * cbstuff.nblks); /* FE stuff */
+ DumpBytes(fd, &freelisthead, sizeof(freelisthead)); /* This is a pointer */
+ DumpBytes(fd, HashTable, sizeof(HashTable));
+ DumpBytes(fd, &CB[1], sizeof(CB[1]) * cbstuff.nblks); /* CB stuff */
+ DumpBytes(fd, &FE[1], sizeof(FE[1]) * cbstuff.nblks); /* FE stuff */
close(fd);
return 0;
#ifdef INTERPRET_DUMP
+static void
+ReadBytes(int fd, void *buf, size_t req)
+{
+ ssize_t count;
+
+ count = read(fd, buf, req);
+ if (count < 0) {
+ perror("read");
+ exit(-1);
+ } else if (count != req) {
+ fprintf(stderr, "read: premature EOF (expected %lu, got %lu)\n",
+ (unsigned long)req, (unsigned long)count);
+ exit(-1);
+ }
+}
+
/* This is only compiled in for the callback analyzer program */
/* Returns the time of the dump */
time_t
fprintf(stderr, "Couldn't read dump file %s\n", file);
exit(1);
}
- read(fd, &magic, sizeof(magic));
+ ReadBytes(fd, &magic, sizeof(magic));
if (magic == MAGICV2) {
timebits = 32;
} else {
}
}
if (timebits == 64) {
- read(fd, &now64, sizeof(afs_int64));
+ ReadBytes(fd, &now64, sizeof(afs_int64));
now = (afs_int32) now64;
} else
- read(fd, &now, sizeof(afs_int32));
+ ReadBytes(fd, &now, sizeof(afs_int32));
- read(fd, &cbstuff, sizeof(cbstuff));
- read(fd, TimeOuts, sizeof(TimeOuts));
- read(fd, timeout, sizeof(timeout));
- read(fd, &tfirst, sizeof(tfirst));
- read(fd, &freelisthead, sizeof(freelisthead));
+ ReadBytes(fd, &cbstuff, sizeof(cbstuff));
+ ReadBytes(fd, TimeOuts, sizeof(TimeOuts));
+ ReadBytes(fd, timeout, sizeof(timeout));
+ ReadBytes(fd, &tfirst, sizeof(tfirst));
+ ReadBytes(fd, &freelisthead, sizeof(freelisthead));
CB = ((struct CallBack
*)(calloc(cbstuff.nblks, sizeof(struct CallBack)))) - 1;
FE = ((struct FileEntry
*)(calloc(cbstuff.nblks, sizeof(struct FileEntry)))) - 1;
CBfree = (struct CallBack *)itocb(freelisthead);
- read(fd, &freelisthead, sizeof(freelisthead));
+ ReadBytes(fd, &freelisthead, sizeof(freelisthead));
FEfree = (struct FileEntry *)itofe(freelisthead);
- read(fd, HashTable, sizeof(HashTable));
- read(fd, &CB[1], sizeof(CB[1]) * cbstuff.nblks); /* CB stuff */
- read(fd, &FE[1], sizeof(FE[1]) * cbstuff.nblks); /* FE stuff */
+ ReadBytes(fd, HashTable, sizeof(HashTable));
+ ReadBytes(fd, &CB[1], sizeof(CB[1]) * cbstuff.nblks); /* CB stuff */
+ ReadBytes(fd, &FE[1], sizeof(FE[1]) * cbstuff.nblks); /* FE stuff */
if (close(fd)) {
perror("Error reading dumpfile");
exit(1);
if (fe == NULL)
return;
- printf("vol=%u vn=%u cbs=%d hi=%d st=%d fest=%d, exp in %lu secs at %s",
- fe->volid, fe->vnode, fe->ncbs, cb->hhead, cb->status, fe->status,
- expires - now, ctime(&expires));
+ printf("vol=%" AFS_VOLID_FMT " vn=%u cbs=%d hi=%d st=%d fest=%d, exp in %lu secs at %s",
+ afs_printable_VolumeId_lu(fe->volid), fe->vnode, fe->ncbs,
+ cb->hhead, cb->status, fe->status, expires - now, ctime(&expires));
}
#endif
interfaces = calloc(i, sizeof(struct AddrPort));
conns = calloc(i, sizeof(struct rx_connection *));
if (!interfaces || !conns) {
- ViceLog(0,
- ("Failed malloc in MultiBreakCallBackAlternateAddress_r\n"));
- osi_Panic("Failed malloc in MultiBreakCallBackAlternateAddress_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in "
+ "MultiBreakCallBackAlternateAddress_r\n"));
}
/* initialize alternate rx connections */
j++;
}
- osi_Assert(j); /* at least one alternate address */
+ opr_Assert(j); /* at least one alternate address */
ViceLog(125,
("Starting multibreakcall back on all addr for host %p (%s:%d)\n",
host, afs_inet_ntoa_r(host->host, hoststr), ntohs(host->port)));
if (host->callback_rxcon)
rx_DestroyConnection(host->callback_rxcon);
host->callback_rxcon = conns[multi_i];
- h_DeleteHostFromAddrHashTable_r(host->host, host->port, host);
+ /* add then remove */
+ addInterfaceAddr_r(host, interfaces[multi_i].addr,
+ interfaces[multi_i].port);
+ removeInterfaceAddr_r(host, host->host, host->port);
host->host = interfaces[multi_i].addr;
host->port = interfaces[multi_i].port;
- h_AddHostToAddrHashTable_r(host->host, host->port, host);
connSuccess = conns[multi_i];
rx_SetConnDeadTime(host->callback_rxcon, 50);
rx_SetConnHardDeadTime(host->callback_rxcon, AFS_HARDDEADTIME);
interfaces = calloc(i, sizeof(struct AddrPort));
conns = calloc(i, sizeof(struct rx_connection *));
if (!interfaces || !conns) {
- ViceLog(0, ("Failed malloc in MultiProbeAlternateAddress_r\n"));
- osi_Panic("Failed malloc in MultiProbeAlternateAddress_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in "
+ "MultiProbeAlternateAddress_r\n"));
}
/* initialize alternate rx connections */
j++;
}
- osi_Assert(j); /* at least one alternate address */
+ opr_Assert(j); /* at least one alternate address */
ViceLog(125,
("Starting multiprobe on all addr for host %p (%s:%d)\n",
host, afs_inet_ntoa_r(host->host, hoststr),
if (host->callback_rxcon)
rx_DestroyConnection(host->callback_rxcon);
host->callback_rxcon = conns[multi_i];
- h_DeleteHostFromAddrHashTable_r(host->host, host->port, host);
+ /* add then remove */
+ addInterfaceAddr_r(host, interfaces[multi_i].addr,
+ interfaces[multi_i].port);
+ removeInterfaceAddr_r(host, host->host, host->port);
host->host = interfaces[multi_i].addr;
host->port = interfaces[multi_i].port;
- h_AddHostToAddrHashTable_r(host->host, host->port, host);
connSuccess = conns[multi_i];
rx_SetConnDeadTime(host->callback_rxcon, 50);
rx_SetConnHardDeadTime(host->callback_rxcon, AFS_HARDDEADTIME);
git://git.openafs.org / openafs.git / blobdiff