if (HTBlocks == h_MAXHOSTTABLES) {
ViceLog(0, ("h_MAXHOSTTABLES reached\n"));
- ShutDownAndCore(PANIC);
+ return;
}
block = (struct HTBlock *)malloc(sizeof(struct HTBlock));
if (HTFree == NULL)
GetHTBlock();
- osi_Assert(HTFree != NULL);
+ if (HTFree == NULL)
+ return NULL;
entry = HTFree;
HTFree = entry->next;
HTs++;
*/
#define DEF_ROPCONS 2115
-struct host *
+static struct host *
h_Alloc_r(struct rx_connection *r_con)
{
struct servent *serverentry;
#endif /* FS_STATS_DETAILED */
host = GetHT();
+ if (!host)
+ return NULL;
host->host = rxr_HostOf(r_con);
host->port = rxr_PortOf(r_con);
rx_NewConnection(host->host, host->port, 1, sc, 0);
rx_SetConnDeadTime(host->callback_rxcon, 50);
rx_SetConnHardDeadTime(host->callback_rxcon, AFS_HARDDEADTIME);
+ rx_SetConnSecondsUntilNatPing(host->callback_rxcon, 20);
}
/* h_Lookup_r
-/* h_Enumerate: Calls (*proc)(host, held, param) for at least each host in the
+/* h_Enumerate: Calls (*proc)(host, param) for at least each host in the
* system at the start of the enumeration (perhaps more). Hosts may be deleted
* (have delete flag set); ditto for clients. refCount is always incremented
- * before (*proc) is called. The param flags is passed to (*proc) as the
- * param flags, permitting (*proc) to stop the enumeration (BAIL).
- *
- * Needed? Why not always h_Hold_r and h_Release_r in (*proc), or even -never-
- * h_Hold_r or h_Release_r in (*proc)?
+ * before (*proc) is called.
*
- * **The proc should return 0 if the host should be released, 1 if it should
- * be held after enumeration.
+ * The return value of the proc is a set of flags. The proc should set
+ * H_ENUMERATE_BAIL(foo) if the enumeration of hosts should be stopped early.
*/
void
-h_Enumerate(int (*proc) (struct host*, int, void *), void *param)
+h_Enumerate(int (*proc) (struct host*, void *), void *param)
{
struct host *host, **list;
- int *flags;
int i, count;
int totalCount;
if (!list) {
ViceLogThenPanic(0, ("Failed malloc in h_Enumerate (list)\n"));
}
- flags = (int *)malloc(hostCount * sizeof(int));
- if (!flags) {
- ViceLogThenPanic(0, ("Failed malloc in h_Enumerate (flags)\n"));
- }
for (totalCount = count = 0, host = hostList;
host && totalCount < hostCount;
host = host->next, totalCount++) {
}
H_UNLOCK;
for (i = 0; i < count; i++) {
- flags[i] = (*proc) (list[i], flags[i], param);
+ int flags;
+ flags = (*proc) (list[i], param);
H_LOCK;
h_Release_r(list[i]);
H_UNLOCK;
/* bail out of the enumeration early */
- if (H_ENUMERATE_ISSET_BAIL(flags[i]))
+ if (H_ENUMERATE_ISSET_BAIL(flags)) {
break;
+ } else if (flags) {
+ ViceLog(0, ("h_Enumerate got back invalid return value %d\n", flags));
+ ShutDownAndCore(PANIC);
+ }
+ }
+ if (i < count-1) {
+ /* we bailed out of enumerating hosts early; we still have holds on
+ * some of the hosts in 'list', so release them */
+ i++;
+ H_LOCK;
+ for ( ; i < count; i++) {
+ h_Release_r(list[i]);
+ }
+ H_UNLOCK;
}
free((void *)list);
- free((void *)flags);
} /* h_Enumerate */
/* h_Enumerate_r (revised):
- * Calls (*proc)(host, flags, param) for each host in hostList, starting
+ * Calls (*proc)(host, param) for each host in hostList, starting
* at enumstart. Called only under H_LOCK. Hosts may be deleted (have
* delete flag set); ditto for clients. refCount is always incremented
- * before (*proc) is called. The param flags is passed to (*proc) as the
- * param flags, permitting (*proc) to stop the enumeration (BAIL).
- *
- * Needed? Why not always h_Hold_r and h_Release_r in (*proc), or even -never-
- * h_Hold_r or h_Release_r in (*proc)?
+ * before (*proc) is called.
*
* @note Assumes that hostList is only prepended to, that a host is never
* inserted into the middle. Otherwise this would not be guaranteed to
* terminate.
*
- * **The proc should return 0 if the host should be released, 1 if it should
- * be held after enumeration.
+ * The return value of the proc is a set of flags. The proc should set
+ * H_ENUMERATE_BAIL(foo) if the enumeration of hosts should be stopped early.
*/
void
-h_Enumerate_r(int (*proc) (struct host *, int, void *),
+h_Enumerate_r(int (*proc) (struct host *, void *),
struct host *enumstart, void *param)
{
struct host *host, *next;
- int flags = 0;
- int nflags = 0;
int count;
int origHostCount;
* h_Release_r */
origHostCount = hostCount;
- for (count = 0, host = enumstart; host && count < origHostCount; host = next, flags = nflags, count++) {
+ for (count = 0, host = enumstart; host && count < origHostCount; host = next, count++) {
next = host->next;
/* find the next non-deleted host */
ShutDownAndCore(PANIC);
}
}
- if (next && !H_ENUMERATE_ISSET_BAIL(flags))
+ if (next)
h_Hold_r(next);
if (!(host->hostFlags & HOSTDELETED)) {
- flags = (*proc) (host, flags, param);
+ int flags;
+ flags = (*proc) (host, param);
if (H_ENUMERATE_ISSET_BAIL(flags)) {
h_Release_r(host); /* this might free up the host */
+ if (next) {
+ h_Release_r(next);
+ }
break;
+ } else if (flags) {
+ ViceLog(0, ("h_Enumerate_r got back invalid return value %d\n", flags));
+ ShutDownAndCore(PANIC);
}
}
h_Release_r(host); /* this might free up the host */
rxconn = NULL;
}
- if (!sc)
- sc = rxnull_NewClientSecurityObject();
- host->callback_rxcon =
- rx_NewConnection(host->host, host->port, 1, sc, 0);
- rx_SetConnDeadTime(host->callback_rxcon, 50);
- rx_SetConnHardDeadTime(host->callback_rxcon, AFS_HARDDEADTIME);
+ h_SetupCallbackConn_r(host);
}
} else {
/* not the primary addr/port, just invalidate it */
cb_in = rx_NewConnection(haddr, hport, 1, sc, 0);
rx_SetConnDeadTime(cb_in, 50);
rx_SetConnHardDeadTime(cb_in, AFS_HARDDEADTIME);
+ rx_SetConnSecondsUntilNatPing(cb_in, 20);
code =
RXAFSCB_TellMeAboutYourself(cb_in, &interf, &caps);
}
} else {
host = h_Alloc_r(tcon); /* returned held and locked */
+ if (!host)
+ goto gethost_out;
h_gethostcps_r(host, FT_ApproxTime());
if (!(host->Console & 1)) {
int pident = 0;
client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
if (client && client->sid == rxr_CidOf(tcon)
&& client->VenusEpoch == rxr_GetEpoch(tcon)
- && !(client->host->hostFlags & HOSTDELETED)) {
+ && !(client->host->hostFlags & HOSTDELETED)
+ && !client->deleted) {
client->refCount++;
h_Hold_r(client->host);
- if (!client->deleted && client->prfail != 2) {
+ if (client->prfail != 2) {
/* Could add shared lock on client here */
/* note that we don't have to lock entry in this path to
* ensure CPS is initialized, since we don't call rx_SetSpecific
created = 0;
}
oldClient->refCount++;
+
+ h_Hold_r(oldClient->host);
+ h_Release_r(client->host);
+
H_UNLOCK;
ObtainWriteLock(&oldClient->lock);
H_LOCK;
client = oldClient;
+ host = oldClient->host;
} else {
- ViceLog(0, ("FindClient: deleted client %p(%x) already had "
- "conn %p (host %s:%d), stolen by client %p(%x)\n",
- oldClient, oldClient->sid, tcon,
- afs_inet_ntoa_r(rxr_HostOf(tcon), hoststr),
- ntohs(rxr_PortOf(tcon)),
- client, client->sid));
+ ViceLog(0, ("FindClient: deleted client %p(%x ref %d host %p href "
+ "%d) already had conn %p (host %s:%d, cid %x), stolen "
+ "by client %p(%x, ref %d host %p href %d)\n",
+ oldClient, oldClient->sid, oldClient->refCount,
+ oldClient->host, oldClient->host->refCount, tcon,
+ afs_inet_ntoa_r(rxr_HostOf(tcon), hoststr),
+ ntohs(rxr_PortOf(tcon)), rxr_CidOf(tcon),
+ client, client->sid, client->refCount,
+ client->host, client->host->refCount));
/* rx_SetSpecific will be done immediately below */
}
}
H_UNLOCK;
return VICETOKENDEAD;
}
+ if (client->deleted) {
+ ViceLog(0, ("GetClient: got deleted client, connection will appear "
+ "anonymous; tcon %p cid %x client %p ref %d host %p "
+ "(%s:%d) href %d ViceId %d\n",
+ tcon, rxr_CidOf(tcon), client, client->refCount,
+ client->host,
+ afs_inet_ntoa_r(client->host->host, hoststr),
+ (int)ntohs(client->host->port), client->host->refCount,
+ (int)client->ViceId));
+ }
client->refCount++;
*cp = client;
static int
-h_PrintClient(struct host *host, int flags, void *rock)
+h_PrintClient(struct host *host, void *rock)
{
StreamHandle_t *file = (StreamHandle_t *)rock;
struct client *client;
LastCall = host->LastCall;
if (host->hostFlags & HOSTDELETED) {
H_UNLOCK;
- return flags;
+ return 0;
}
strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
localtime_r(&LastCall, &tm));
}
}
H_UNLOCK;
- return flags;
+ return 0;
} /*h_PrintClient */
static int
-h_DumpHost(struct host *host, int flags, void *rock)
+h_DumpHost(struct host *host, void *rock)
{
StreamHandle_t *file = (StreamHandle_t *)rock;
(void)STREAM_WRITE(tmpStr, strlen(tmpStr), 1, file);
H_UNLOCK;
- return flags;
+ return 0;
} /*h_DumpHost */
static int h_stateFillHeader(struct host_state_header * hdr);
static int h_stateCheckHeader(struct host_state_header * hdr);
static int h_stateAllocMap(struct fs_dump_state * state);
-static int h_stateSaveHost(struct host * host, int flags, void *rock);
+static int h_stateSaveHost(struct host * host, void *rock);
static int h_stateRestoreHost(struct fs_dump_state * state);
-static int h_stateRestoreIndex(struct host * h, int flags, void *rock);
-static int h_stateVerifyHost(struct host * h, int flags, void *rock);
+static int h_stateRestoreIndex(struct host * h, void *rock);
+static int h_stateVerifyHost(struct host * h, void *rock);
static int h_stateVerifyAddrHash(struct fs_dump_state * state, struct host * h,
afs_uint32 addr, afs_uint16 port, int valid);
static int h_stateVerifyUuidHash(struct fs_dump_state * state, struct host * h);
}
static int
-h_stateRestoreIndex(struct host * h, int flags, void *rock)
+h_stateRestoreIndex(struct host * h, void *rock)
{
struct fs_dump_state *state = (struct fs_dump_state *)rock;
if (cb_OldToNew(state, h->cblist, &h->cblist)) {
- return H_ENUMERATE_BAIL(flags);
+ return H_ENUMERATE_BAIL(0);
}
- return flags;
+ return 0;
}
int
}
static int
-h_stateVerifyHost(struct host * h, int flags, void* rock)
+h_stateVerifyHost(struct host * h, void* rock)
{
struct fs_dump_state *state = (struct fs_dump_state *)rock;
int i;
if (h == NULL) {
ViceLog(0, ("h_stateVerifyHost: error: NULL host pointer in linked list\n"));
- return H_ENUMERATE_BAIL(flags);
+ return H_ENUMERATE_BAIL(0);
}
if (h->interface) {
state->bail = 1;
}
- return flags;
+ return 0;
}
/**
/* function called by h_Enumerate to save a host to disk */
static int
-h_stateSaveHost(struct host * host, int flags, void* rock)
+h_stateSaveHost(struct host * host, void* rock)
{
struct fs_dump_state *state = (struct fs_dump_state *) rock;
int if_len=0, hcps_len=0;
if (hcps)
free(hcps);
if (state->bail) {
- return H_ENUMERATE_BAIL(flags);
+ return H_ENUMERATE_BAIL(0);
}
- return flags;
+ return 0;
}
/* restores a host from disk */
osi_Assert(hcps != NULL);
}
+ /* for restoring state, we better be able to get a host! */
host = GetHT();
osi_Assert(host != NULL);
#endif
int
-CheckHost_r(struct host *host, int flags, void *dummy)
+CheckHost_r(struct host *host, void *dummy)
{
struct client *client;
struct rx_connection *cb_conn = NULL;
FS_STATE_RDLOCK;
if (fs_state.mode == FS_MODE_SHUTDOWN) {
FS_STATE_UNLOCK;
- return H_ENUMERATE_BAIL(flags);
+ return H_ENUMERATE_BAIL(0);
}
FS_STATE_UNLOCK;
#endif
}
h_Unlock_r(host);
}
- return flags;
+ return 0;
} /*CheckHost_r */
git://git.openafs.org / openafs.git / blobdiff