#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/nfs.h> /* yuck. This is an abomination. */
#include <lwp.h>
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);
}
* FE[0] and CB[0] are not used--and not allocated */
FE = ((struct FileEntry *)(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;
FreeFE(&FE[cbstuff.nFEs]); /* This is correct */
CB = ((struct CallBack *)(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;
}
/* 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];
for (i = 0; i < ncbas; i++) {
struct host *hp;
hp = cba[i].hp;
- if (hp && xhost != hp) {
+ if (hp) {
h_Release_r(hp);
}
}
{
struct FileEntry *fe;
struct CallBack *cb, *nextcb;
- struct cbstruct cba[MAX_CB_HOSTS];
- int ncbas;
+ struct cbstruct cbaDef[MAX_CB_HOSTS], *cba = cbaDef;
+ unsigned int ncbas, cbaAlloc = MAX_CB_HOSTS;
struct AFSCBFids tf;
int hostindex;
char hoststr[16];
tf.AFSCBFids_len = 1;
tf.AFSCBFids_val = fid;
- for (; cb;) {
- for (ncbas = 0; cb && ncbas < MAX_CB_HOSTS; cb = nextcb) {
+ for (ncbas = 0; cb ; cb = nextcb) {
nextcb = itocb(cb->cnext);
if ((cb->hhead != hostindex || flag)
&& (cb->status == CB_BULK || cb->status == CB_NORMAL
} else {
if (!(thishost->hostFlags & HOSTDELETED)) {
h_Hold_r(thishost);
+ if (ncbas == cbaAlloc) { /* Need more space */
+ int curLen = cbaAlloc*sizeof(cba[0]);
+ struct cbstruct *cbaOld = (cba == cbaDef) ? NULL : cba;
+
+ /* There are logical contraints elsewhere that the number of hosts
+ (i.e. h_HTSPERBLOCK*h_MAXHOSTTABLES) remains in the realm of a signed "int".
+ cbaAlloc is defined unsigned int hence doubling below cannot overflow
+ */
+ cbaAlloc = cbaAlloc<<1; /* double */
+ cba = realloc(cbaOld, cbaAlloc * sizeof(cba[0]));
+
+ if (cbaOld == NULL) { /* realloc wouldn't have copied from cbaDef */
+ memcpy(cba, cbaDef, curLen);
+ }
+ }
cba[ncbas].hp = thishost;
cba[ncbas].thead = cb->thead;
ncbas++;
}
if (ncbas) {
- MultiBreakCallBack_r(cba, ncbas, &tf, xhost);
+ struct cbstruct *cba2;
+ int num;
- /* we need to to all these initializations again because MultiBreakCallBack may block */
- fe = FindFE(fid);
- if (!fe) {
- goto done;
- }
- cb = itocb(fe->firstcb);
- if (!cb || ((fe->ncbs == 1) && (cb->hhead == hostindex) && !flag)) {
- /* the most common case is what follows the || */
- goto done;
+ for (cba2 = cba, num = ncbas; ncbas > 0; cba2 += num, ncbas -= num) {
+ num = (ncbas > MAX_CB_HOSTS) ? MAX_CB_HOSTS : ncbas;
+ MultiBreakCallBack_r(cba2, num, &tf);
}
}
- }
+
+ if (cba != cbaDef) free(cba);
done:
H_UNLOCK;
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);
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;
}
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;
}
}
* 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 {
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 */
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 */
git://git.openafs.org / openafs.git / blobdiff