#include <afs/stds.h>
#include <roken.h>
+#include <afs/opr.h>
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
#include <rx/xdr.h>
-#include <afs/afs_assert.h>
#include <lwp.h>
#include <lock.h>
#include <afs/afsint.h>
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;
}
list = (struct host **)malloc(hostCount * sizeof(struct host *));
if (!list) {
- ViceLog(0, ("Failed malloc in h_Enumerate (list)\n"));
- osi_Panic("Failed malloc in h_Enumerate (list)\n");
- }
- flags = (int *)malloc(hostCount * sizeof(int));
- if (!flags) {
- ViceLog(0, ("Failed malloc in h_Enumerate (flags)\n"));
- osi_Panic("Failed malloc in h_Enumerate (flags)\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_Enumerate (list)\n"));
}
for (totalCount = count = 0, host = hostList;
host && totalCount < hostCount;
}
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 */
/* insert into beginning of list for this bucket */
chain = (struct h_UuidHashChain *)malloc(sizeof(struct h_UuidHashChain));
if (!chain) {
- ViceLog(0, ("Failed malloc in h_AddHostToUuidHashTable_r\n"));
- osi_Panic("Failed malloc in h_AddHostToUuidHashTable_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_AddHostToUuidHashTable_r\n"));
}
chain->hostPtr = host;
chain->next = hostUuidHashTable[index];
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 */
/* insert into beginning of list for this bucket */
chain = (struct h_AddrHashChain *)malloc(sizeof(struct h_AddrHashChain));
if (!chain) {
- ViceLog(0, ("Failed malloc in h_AddHostToAddrHashTable_r\n"));
- osi_Panic("Failed malloc in h_AddHostToAddrHashTable_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_AddHostToAddrHashTable_r\n"));
}
chain->hostPtr = host;
chain->next = hostAddrHashTable[index];
interface = (struct Interface *)
malloc(sizeof(struct Interface) + (sizeof(struct AddrPort) * number));
if (!interface) {
- ViceLog(0, ("Failed malloc in addInterfaceAddr_r\n"));
- osi_Panic("Failed malloc in addInterfaceAddr_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in addInterfaceAddr_r\n"));
}
interface->numberOfInterfaces = number + 1;
interface->uuid = host->interface->uuid;
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);
((code == 0) && (afs_uuid_equal(&interf.uuid, &nulluuid)))) {
identP = (struct Identity *)malloc(sizeof(struct Identity));
if (!identP) {
- ViceLog(0, ("Failed malloc in h_GetHost_r\n"));
- osi_Panic("Failed malloc in h_GetHost_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_GetHost_r\n"));
}
identP->valid = 0;
rx_SetSpecific(tcon, rxcon_ident_key, identP);
interfValid = 1;
identP = (struct Identity *)malloc(sizeof(struct Identity));
if (!identP) {
- ViceLog(0, ("Failed malloc in h_GetHost_r\n"));
- osi_Panic("Failed malloc in h_GetHost_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_GetHost_r\n"));
}
identP->valid = 1;
identP->uuid = interf.uuid;
}
} 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;
pident = 1;
if (!identP) {
- ViceLog(0, ("Failed malloc in h_GetHost_r\n"));
- osi_Panic("Failed malloc in h_GetHost_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_GetHost_r\n"));
}
identP->valid = 0;
if (!pident)
pident = 1;
if (!identP) {
- ViceLog(0, ("Failed malloc in h_GetHost_r\n"));
- osi_Panic("Failed malloc in h_GetHost_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_GetHost_r\n"));
}
identP->valid = 1;
interfValid = 1;
foreign = 1; /* attempt cross-cell authentication */
tname = (char *)malloc(PR_MAXNAMELEN);
if (!tname) {
- ViceLog(0, ("Failed malloc in MapName_r\n"));
- osi_Panic("Failed malloc in MapName_r\n");
+ ViceLogThenPanic(0, ("Failed malloc in MapName_r\n"));
}
strcpy(tname, aname);
tname[anamelen] = '@';
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;
lids.idlist_len = 1;
lids.idlist_val = (afs_int32 *) malloc(1 * sizeof(afs_int32));
if (!lids.idlist_val) {
- ViceLog(0, ("Failed malloc in h_UserName\n"));
- osi_Panic("Failed malloc in h_UserName\n");
+ ViceLogThenPanic(0, ("Failed malloc in h_UserName\n"));
}
lnames.namelist_len = 0;
lnames.namelist_val = (prname *) 0;
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",
+ strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y",
localtime_r(&LastCall, &tm));
snprintf(tmpStr, sizeof tmpStr, "Host %s:%d down = %d, LastCall %s\n",
afs_inet_ntoa_r(host->host, hoststr),
for (client = host->FirstClient; client; client = client->next) {
if (!client->deleted) {
expTime = client->expTime;
- strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
+ strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y",
localtime_r(&expTime, &tm));
snprintf(tmpStr, sizeof tmpStr,
" user id=%d, name=%s, sl=%s till %s\n",
}
}
H_UNLOCK;
- return flags;
+ return 0;
} /*h_PrintClient */
return;
}
now = FT_ApproxTime();
- strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
+ strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y",
localtime_r(&now, &tm));
snprintf(tmpStr, sizeof tmpStr, "List of active users at %s\n\n",
tbuffer);
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 */
return;
}
now = FT_ApproxTime();
- strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
+ strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y",
localtime_r(&now, &tm));
snprintf(tmpStr, sizeof tmpStr, "List of active hosts at %s\n\n", tbuffer);
(void)STREAM_WRITE(tmpStr, strlen(tmpStr), 1, file);
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 void h_hostToDiskEntry_r(struct host * in, struct hostDiskEntry * out);
static void h_diskEntryToHost_r(struct hostDiskEntry * in, struct host * out);
+/**
+ * Is this host busy?
+ *
+ * This is just a hint and should not be trusted; this should probably only be
+ * used by the host state serialization code when trying to detect if a host
+ * can be sanely serialized to disk or not. If this function returns 1, the
+ * host may be in an invalid state and thus should not be saved to disk.
+ */
+static int
+h_isBusy_r(struct host *host)
+{
+ struct Lock *hostLock = &host->lock;
+ int locked = 0;
+
+ LOCK_LOCK(hostLock);
+ if (hostLock->excl_locked || hostLock->readers_reading) {
+ locked = 1;
+ }
+ LOCK_UNLOCK(hostLock);
+
+ if (locked) {
+ return 1;
+ }
+
+ if ((host->hostFlags & HWHO_INPROGRESS) || !(host->hostFlags & ALTADDR)) {
+ /* We shouldn't hit this if the host wasn't locked, but just in case... */
+ return 1;
+ }
+
+ return 0;
+}
/* this procedure saves all host state to disk for fast startup */
int
}
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;
struct iovec iov[4];
int iovcnt = 2;
+ if (h_isBusy_r(host)) {
+ char hoststr[16];
+ ViceLog(1, ("Not saving host %s:%d to disk; host appears busy\n",
+ afs_inet_ntoa_r(host->host, hoststr), (int)ntohs(host->port)));
+ /* Make sure we don't try to save callbacks to disk for this host, or
+ * we'll get confused on restore */
+ DeleteAllCallBacks_r(host, 1);
+ return 0;
+ }
+
memset(&hdr, 0, sizeof(hdr));
if (state->h_hdr->index_max < host->index) {
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);
}
+ if ((hdsk.hostFlags & HWHO_INPROGRESS) || !(hdsk.hostFlags & ALTADDR)) {
+ char hoststr[16];
+ ViceLog(0, ("h_stateRestoreHost: skipping host %s:%d due to invalid flags 0x%x\n",
+ afs_inet_ntoa_r(hdsk.host, hoststr), (int)ntohs(hdsk.port),
+ (unsigned)hdsk.hostFlags));
+ bail = 0;
+ state->h_map.entries[hdsk.index].valid = FS_STATE_IDX_SKIPPED;
+ goto done;
+ }
+
+ /* for restoring state, we better be able to get a host! */
host = GetHT();
osi_Assert(host != NULL);
h_InsertList_r(host);
/* setup host id map entry */
+ state->h_map.entries[hdsk.index].valid = FS_STATE_IDX_VALID;
state->h_map.entries[hdsk.index].old_idx = hdsk.index;
state->h_map.entries[hdsk.index].new_idx = host->index;
if (old >= state->h_map.len) {
ViceLog(0, ("h_OldToNew: index %d is out of range\n", old));
ret = 1;
- } else if (state->h_map.entries[old].old_idx != old) { /* sanity check */
+ } else if (state->h_map.entries[old].valid != FS_STATE_IDX_VALID ||
+ state->h_map.entries[old].old_idx != old) { /* sanity check */
ViceLog(0, ("h_OldToNew: index %d points to an invalid host record\n", old));
ret = 1;
} else {
#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 */
malloc(sizeof(struct Interface) +
(sizeof(struct AddrPort) * (count - 1)));
if (!interface) {
- ViceLog(0, ("Failed malloc in initInterfaceAddr_r 1\n"));
- osi_Panic("Failed malloc in initInterfaceAddr_r 1\n");
+ ViceLogThenPanic(0, ("Failed malloc in initInterfaceAddr_r 1\n"));
}
interface->numberOfInterfaces = count;
} else {
interface = (struct Interface *)
malloc(sizeof(struct Interface) + (sizeof(struct AddrPort) * count));
if (!interface) {
- ViceLog(0, ("Failed malloc in initInterfaceAddr_r 2\n"));
- osi_Panic("Failed malloc in initInterfaceAddr_r 2\n");
+ ViceLogThenPanic(0, ("Failed malloc in initInterfaceAddr_r 2\n"));
}
interface->numberOfInterfaces = count + 1;
interface->interface[count].addr = myAddr;
git://git.openafs.org / openafs.git / blobdiff