able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/wlbs/driver/load.c

3953 lines
134 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright(c) 1998,99 Microsoft Corporation
Module Name:
load.c
Abstract:
Windows Load Balancing Service (WLBS)
Driver - load balancing algorithm
Author:
bbain
ToDo:
Kernel mode queue mgt
Fail safe mode (single server for everything)
--*/
#ifdef KERNEL_MODE
#include <ntddk.h>
#include "log.h"
#include "univ.h"
#include "main.h" // added for multiple nic
static ULONG log_module_id = LOG_MODULE_LOAD;
#else
#include <stdlib.h>
#include <windows.h>
#endif
#include <stdio.h>
#include "wlbsparm.h"
#include "params.h"
#include "wlbsiocl.h"
#include "wlbsip.h"
#include "load.h"
//
// For WPP Event Tracing
//
#include "trace.h" // for event tracing
#include "load.tmh" // for event tracing
#ifndef KERNEL_MODE
#define UNIV_PRINT(s) { printf s ; printf ("\n"); }
#define Univ_ulong_to_str(x, y, z) (y)
#define LOG_MSG(c,s)
#define LOG_MSG1(c,s,d1)
#define LOG_MSG2(c,s,d1,d2)
#define LOG_MSG3(c,s,d1,d2,d3)
#define LOG_MSG4(c,s,d1,d2,d3,d4)
#else
#define malloc(s) ExAllocatePoolWithTag (NonPagedPool, s, UNIV_POOL_TAG)
#define free(s) ExFreePool (s)
#endif
//extern CVY_PARAMS univ_params;
//#define univ_params ( * (lp -> params))
void Bin_state_print(PBIN_STATE bp, ULONG my_host_id);
void Load_conn_kill(PLOAD_CTXT lp, PBIN_STATE bp); /* v1.32B */
// static WCHAR buf [256]; /* string buffer (V1.1.2) */
/* CONSTANTS */
#if 0 /* v2.06 */
#define BIN_ALL_ONES ((MAP_T)-1) /* bin map state for 64 ones (v2.04) */
#endif
#define BIN_ALL_ONES ((MAP_T)(0xFFFFFFFFFFFFFFF)) /* bin map state for 60 ones (v2.04) */
/* FUNCTIONS */
/* Byte offset of a field in a structure of the specified type: */
#define CVY_FIELD_OFFSET(type, field) ((LONG_PTR)&(((type *)0)->field))
/*
* Address of the base of the structure given its type, field name, and the
* address of a field or field offset within the structure:
*/
#define STRUCT_PTR(address, type, field) ((type *)( \
(PCHAR)(address) - \
(PCHAR)CVY_FIELD_OFFSET(type, field)))
/*
* Function: Load_teaming_consistency_notify
* Description: This function is called to notify a team in which this adapter
* might be participating whether the teaming configuration in the
* heartbeats is consistent or not. Inconsistent configuration
* results in the entire team being marked inactive - meaning that
* no adapter in the team will handle any traffic, except to the DIP.
* Parameters: member - a pointer to the team membership information for this adapter.
* consistent - a boolean indicating the polarity of teaming consistency.
* Returns: Nothing.
* Author: shouse, 3.29.01
* Notes: In order to check to see whether or not this adapter is part of a team,
* we need to look into the team member information for this adapter. This
* access should be locked, but for performance reasons, we will only lock
* and check for sure if we "think" we're part of a team. Worst case is that
* we are in the process of joining a team and we missed this check - no
* matter, we'll notify them when/if we see this again.
*/
VOID Load_teaming_consistency_notify (IN PBDA_MEMBER member, IN BOOL consistent) {
/* Make sure that the membership information points to something. */
ASSERT(member);
/* We can check without locking to keep the common case minimally expensive. If we do think
we're part of a team, then we'll grab the lock and make sure. If our first indication is
that we're not part of a team, then just bail out and if we actually are part of a team,
we'll be through here again later to notify our team if necessary. */
if (!member->active) return;
NdisAcquireSpinLock(&univ_bda_teaming_lock);
/* If we are an active member of a BDA team, then notify our team of our state. */
if (member->active) {
/* Assert that the team actually points to something. */
ASSERT(member->bda_team);
/* Assert that the member ID is valid. */
ASSERT(member->member_id <= CVY_BDA_MAXIMUM_MEMBER_ID);
if (consistent) {
UNIV_PRINT(("Load_teaming_consistency_notify: Consistent configuration detected."));
/* Mark this member as consistent. */
member->bda_team->consistency_map |= (1 << member->member_id);
} else {
UNIV_PRINT(("Load_teaming_consistency_notify: Inconsistent configuration detected."));
/* Mark this member as inconsistent. */
member->bda_team->consistency_map &= ~(1 << member->member_id);
/* Inactivate the team. */
member->bda_team->active = FALSE;
}
}
NdisReleaseSpinLock(&univ_bda_teaming_lock);
}
/*
* Function: Load_teaming_consistency_check
* Description: This function is used to check our teaming configuration against the
* teaming configuration received in a remote heartbeat. It does little
* more than check the equality of two DWORDS, however, if this is our
* first notification of bad configuration, it prints a few debug state-
* ments as well.
* Parameters: bAlreadyKnown - a boolean indication of whether or not we have already detected bad configuration.
* If the misconfiguration is already known, no additional logging is done.
* member - a pointer to the team member structure for this adapter.
* myConfig - a DWORD containing the teaming "code" for me.
* theirCofnig - a DWORD containing the teaming "code" received in the heartbeat from them.
* Returns: BOOLEAN (as ULONG) - TRUE means the configuration is consistent, FALSE indicates that it is not.
* Author: shouse, 3.29.01
* Notes: In order to check to see whether or not this adapter is part of a team,
* we need to look into the team member information for this adapter. This
* access should be locked, but for performance reasons, we will only lock
* and check for sure if we "think" we're part of a team. Worst case is that
* we are in the process of joining a team and we missed this check - no
* matter, we'll check again on the next heartbeat.
*/
ULONG Load_teaming_consistency_check (IN BOOLEAN bAlreadyKnown, IN PBDA_MEMBER member, IN ULONG myConfig, IN ULONG theirConfig) {
/* We can check without locking to keep the common case minimally expensive. If we do think
we're part of a team, then we'll grab the lock and make sure. If our first indication is
that we're not part of a team, then just bail out and if we actually are part of a team,
we'll be through here again later to check the consistency. */
if (!member->active) return TRUE;
NdisAcquireSpinLock(&univ_bda_teaming_lock);
/* If we are part of a BDA team, check the BDA teaming configuration consistency. */
if (member->active) {
NdisReleaseSpinLock(&univ_bda_teaming_lock);
/* If the bi-directional affinity teaming configurations don't match, do something about it. */
if (myConfig != theirConfig) {
if (!bAlreadyKnown) {
UNIV_PRINT(("Bad teaming configuration detected: Mine=0x%08x, Theirs=0x%08x", myConfig, theirConfig));
/* Report whether or not the teaming active flags are consistent. */
if ((myConfig & CVY_BDA_TEAMING_CODE_ACTIVE_MASK) != (theirConfig & CVY_BDA_TEAMING_CODE_ACTIVE_MASK)) {
UNIV_PRINT(("Teaming active flags do not match: Mine=%d, Theirs=%d",
(myConfig & CVY_BDA_TEAMING_CODE_ACTIVE_MASK) >> CVY_BDA_TEAMING_CODE_ACTIVE_OFFSET,
(theirConfig & CVY_BDA_TEAMING_CODE_ACTIVE_MASK) >> CVY_BDA_TEAMING_CODE_ACTIVE_OFFSET));
}
/* Report whether or not the master flags are consistent. */
if ((myConfig & CVY_BDA_TEAMING_CODE_MASTER_MASK) != (theirConfig & CVY_BDA_TEAMING_CODE_MASTER_MASK)) {
UNIV_PRINT(("Master/slave settings do not match: Mine=%d, Theirs=%d",
(myConfig & CVY_BDA_TEAMING_CODE_MASTER_MASK) >> CVY_BDA_TEAMING_CODE_MASTER_OFFSET,
(theirConfig & CVY_BDA_TEAMING_CODE_MASTER_MASK) >> CVY_BDA_TEAMING_CODE_MASTER_OFFSET));
}
/* Report whether or not the reverse hashing flags are consistent. */
if ((myConfig & CVY_BDA_TEAMING_CODE_HASHING_MASK) != (theirConfig & CVY_BDA_TEAMING_CODE_HASHING_MASK)) {
UNIV_PRINT(("Reverse hashing flags do not match: Mine=%d, Theirs=%d",
(myConfig & CVY_BDA_TEAMING_CODE_HASHING_MASK) >> CVY_BDA_TEAMING_CODE_HASHING_OFFSET,
(theirConfig & CVY_BDA_TEAMING_CODE_HASHING_MASK) >> CVY_BDA_TEAMING_CODE_HASHING_OFFSET));
}
/* Report whether or not the number of team members is consistent. */
if ((myConfig & CVY_BDA_TEAMING_CODE_NUM_MEMBERS_MASK) != (theirConfig & CVY_BDA_TEAMING_CODE_NUM_MEMBERS_MASK)) {
UNIV_PRINT(("Numbers of team members do not match: Mine=%d, Theirs=%d",
(myConfig & CVY_BDA_TEAMING_CODE_NUM_MEMBERS_MASK) >> CVY_BDA_TEAMING_CODE_NUM_MEMBERS_OFFSET,
(theirConfig & CVY_BDA_TEAMING_CODE_NUM_MEMBERS_MASK) >> CVY_BDA_TEAMING_CODE_NUM_MEMBERS_OFFSET));
}
/* Report whether or not the team membership lists are consistent. */
if ((myConfig & CVY_BDA_TEAMING_CODE_MEMBERS_MASK) != (theirConfig & CVY_BDA_TEAMING_CODE_MEMBERS_MASK)) {
UNIV_PRINT(("Participating members lists do not match: Mine=0x%04x, Theirs=0x%04x",
(myConfig & CVY_BDA_TEAMING_CODE_MEMBERS_MASK) >> CVY_BDA_TEAMING_CODE_MEMBERS_OFFSET,
(theirConfig & CVY_BDA_TEAMING_CODE_MEMBERS_MASK) >> CVY_BDA_TEAMING_CODE_MEMBERS_OFFSET));
}
}
return FALSE;
}
return TRUE;
}
NdisReleaseSpinLock(&univ_bda_teaming_lock);
return TRUE;
}
/*
* Function: Load_teaming_code_create
* Description: This function pieces together the ULONG code that represents the configuration
* of bi-directional affinity teaming on this adapter. If the adapter is not part
* of a team, then the code is zero.
* Parameters: code - a pointer to a ULONG that will receive the 32-bit code word.
* member - a pointer to the team member structure for this adapter.
* Returns: Nothing.
* Author: shouse, 3.29.01
* Notes: In order to check to see whether or not this adapter is part of a team,
* we need to look into the team member information for this adapter. This
* access should be locked, but for performance reasons, we will only lock
* and check for sure if we "think" we're part of a team. Worst case is that
* we are in the process of joining a team and we missed this check - no
* matter, we'll be through here the next time er send a heartbeat anyway.
*/
VOID Load_teaming_code_create (OUT PULONG code, IN PBDA_MEMBER member) {
/* Assert that the code actually points to something. */
ASSERT(code);
/* Assert that the membership information actually points to something. */
ASSERT(member);
/* Reset the code. */
*code = 0;
/* We can check without locking to keep the common case minimally expensive. If we do think
we're part of a team, then we'll grab the lock and make sure. If our first indication is
that we're not part of a team, then just bail out and if we actually are part of a team,
we'll be through here again later to generate the code next time we send a heartbeat. */
if (!member->active) return;
NdisAcquireSpinLock(&univ_bda_teaming_lock);
/* If we are in a team, fill in the team configuration information. */
if (member->active) {
/* Assert that the team actually points to something. */
ASSERT(member->bda_team);
/* Add configuration information for teaming at each timeout. */
CVY_BDA_TEAMING_CODE_CREATE(*code,
member->active,
member->master,
member->reverse_hash,
member->bda_team->membership_count,
member->bda_team->membership_fingerprint);
}
NdisReleaseSpinLock(&univ_bda_teaming_lock);
}
/*
* Function: Load_add_reference
* Description: This function adds a reference to the load module of a given adapter.
* Parameters: pLoad - a pointer to the load module to reference.
* Returns: ULONG - The incremented value.
* Author: shouse, 3.29.01
* Notes:
*/
ULONG Load_add_reference (IN PLOAD_CTXT pLoad) {
/* Assert that the load pointer actually points to something. */
ASSERT(pLoad);
/* Increment the reference count. */
return NdisInterlockedIncrement(&pLoad->ref_count);
}
/*
* Function: Load_release_reference
* Description: This function releases a reference on the load module of a given adapter.
* Parameters: pLoad - a pointer to the load module to dereference.
* Returns: ULONG - The decremented value.
* Author: shouse, 3.29.01
* Notes:
*/
ULONG Load_release_reference (IN PLOAD_CTXT pLoad) {
/* Assert that the load pointer actually points to something. */
ASSERT(pLoad);
/* Decrement the reference count. */
return NdisInterlockedDecrement(&pLoad->ref_count);
}
/*
* Function: Load_get_reference_count
* Description: This function returns the current reference count on a given adapter.
* Parameters: pLoad - a pointer to the load module to check.
* Returns: ULONG - The current reference count.
* Author: shouse, 3.29.01
* Notes:
*/
ULONG Load_get_reference_count (IN PLOAD_CTXT pLoad) {
/* Assert that the load pointer actually points to something. */
ASSERT(pLoad);
/* Return the reference count. */
return pLoad->ref_count;
}
/* Hash routine is based on a public-domain Tiny Encryption Algorithm (TEA) by
David Wheeler and Roger Needham at the Computer Laboratory of Cambridge
University. For reference, please consult
http://vader.brad.ac.uk/tea/tea.shtml */
ULONG Map (
ULONG v1,
ULONG v2) /* v2.06: removed range parameter */
{
ULONG y = v1,
z = v2,
sum = 0;
const ULONG a = 0x67; //key [0];
const ULONG b = 0xdf; //key [1];
const ULONG c = 0x40; //key [2];
const ULONG d = 0xd3; //key [3];
const ULONG delta = 0x9E3779B9;
//
// Unroll the loop to improve performance
//
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
sum += delta;
y += (z << 4) + a ^ z + sum ^ (z >> 5) + b;
z += (y << 4) + c ^ y + sum ^ (y >> 5) + d;
return y ^ z;
} /* end Map */
BOOLEAN Bin_targ_map_get(
PLOAD_CTXT lp,
PBIN_STATE binp, /* ptr. to bin state */
ULONG my_host_id,
PMAP_T pmap) /* ptr. to target map */
/*
Get target map for this host
returns BOOLEAN:
TRUE => valid target map is returned via pmap
FALSE => error occurred; no target map returned
*/
{
ULONG remsz, /* remainder size */
loadsz, /* size of a load partition */
first_bit; /* first bit position of load partition */
MAP_T targ_map; /* bit map of load bins for this host */
ULONG tot_load = 0; /* total of load perecentages */
ULONG * pload_list; /* ptr. to list of load balance perecntages */
WCHAR num [20];
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
pload_list = binp->load_amt;
if (binp->mode == CVY_SINGLE)
{
ULONG max_pri; /* highest priority */
ULONG i;
first_bit = 0;
/* compute max priority */
max_pri = CVY_MAX_HOSTS + 1;
for (i=0; i<CVY_MAX_HOSTS; i++)
{
tot_load += pload_list[i]; /* v2.1 */
if (pload_list[i] != 0)
{
//
// If another host has the same priority as this host, do not converge
//
if (i!= my_host_id && pload_list[i] == pload_list[my_host_id])
{
if (!(lp->dup_sspri))
{
UNIV_PRINT(("Host %d: duplicate single svr priorities detected", my_host_id));
Univ_ulong_to_str (pload_list[my_host_id], num, 10);
LOG_MSG(MSG_ERROR_SINGLE_DUP, num);
lp->dup_sspri = TRUE;
}
/* 1.03: return error, which inhibits convergence; note that
rule will be automatically reinstated when duplicate server
priorities are eliminated */
return FALSE;
}
if ( pload_list[i] <= max_pri )
{
max_pri = pload_list[i];
}
}
}
binp->tot_load = tot_load; /* v2.1 */
/* now determine if we are the highest priority host */
if (pload_list[my_host_id] == max_pri)
{
loadsz = CVY_MAXBINS;
targ_map = BIN_ALL_ONES; /* v2.05 */
}
else
{
loadsz = 0;
targ_map = 0; /* v2.05 */
}
}
else /* load balanced */
{
ULONG i, j;
ULONG partsz[CVY_MAX_HOSTS+1];
/* new partition size per host */
ULONG cur_partsz[CVY_MAX_HOSTS+1];
/* current partition size per host (v2.05) */
ULONG cur_host[CVY_MAXBINS];
/* current host for each bin (v2.05) */
ULONG tot_partsz; /* sum of partition sizes */
ULONG donor; /* current donor host (v2.05) */
ULONG cur_nbins; /* current # bins (v2.05) */
/* setup current partition sizes and bin to host mapping from current map (v2.05) */
cur_nbins = 0;
for (j=0; j<CVY_MAXBINS; j++)
cur_host[j] = CVY_MAX_HOSTS; /* all bins are initially orphans */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
ULONG count = 0L;
MAP_T cmap = binp->cur_map[i];
tot_load += pload_list[i]; /* folded into this loop v2.1 */
for (j=0; j<CVY_MAXBINS && cmap != ((MAP_T)0); j++)
{
/* if host i has bin j and it's not a duplicate, set up the mapping */
if ((cmap & ((MAP_T)0x1)) != ((MAP_T)0) && cur_host[j] == CVY_MAX_HOSTS)
{
count++;
cur_host[j] = i;
}
cmap >>= 1;
}
cur_partsz[i] = count;
cur_nbins += count;
}
if (cur_nbins > CVY_MAXBINS)
{
UNIV_PRINT(("Bin_targ_map_get: error - too many bins found"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
cur_nbins = CVY_MAXBINS;
}
/* if there are orphan bins, give them to pseudo-host CVY_MAX_HOSTS for now (v2.05) */
if (cur_nbins < CVY_MAXBINS)
cur_partsz[CVY_MAX_HOSTS] = CVY_MAXBINS - cur_nbins;
else
cur_partsz[CVY_MAX_HOSTS] = 0;
/* compute total load */
binp->tot_load = tot_load; /* v2.06 */
/* now compute tentative partition sizes and remainder after initially
dividing up partitions among hosts */
tot_partsz = 0;
first_bit = 0;
for (i=0; i<CVY_MAX_HOSTS; i++)
{
if (tot_load > 0)
partsz[i] = CVY_MAXBINS * pload_list[i] / tot_load;
else
partsz[i] = 0;
tot_partsz += partsz[i];
}
remsz = CVY_MAXBINS - tot_partsz;
/* check for zero total load */
if (tot_partsz == 0)
{
* pmap = 0;
return TRUE;
}
/* first dole out remainder bits to hosts that currently have bins (this
minimizes the number of bins that have to move) v2.05 */
if (remsz > 0)
{
for (i=0; i<CVY_MAX_HOSTS && remsz > 0; i++)
if (cur_partsz[i] > 0 && pload_list[i] > 0)
{
partsz[i]++;
remsz--;
}
}
/* now dole out remainder bits to hosts that currently have no bins (to maintain
the target load balance) v2.05 */
if (remsz > 0)
{
for (i=0; i<CVY_MAX_HOSTS && remsz > 0; i++)
if (cur_partsz[i] == 0 && pload_list[i] > 0)
{
partsz[i]++;
remsz--;
}
}
/* now dole out remainder bits among non-zero partitions round robin */
i = 0;
while (remsz > 0)
{
if (pload_list[i] > 0)
{
partsz[i]++;
remsz--;
}
i++;
if (i == CVY_MAX_HOSTS)
i = 0;
}
/* reallocate bins to target hosts to match new partition sizes (v2.05) */
donor = 0;
partsz[CVY_MAX_HOSTS] = 0; /* pseudo-host needs no bins */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
ULONG rcvrsz; /* current receiver's target partition */
ULONG donorsz; /* current donor's target partition size */
/* find and give this host some bins */
rcvrsz = partsz[i];
while (rcvrsz > cur_partsz[i])
{
/* find a host with too many bins */
for (; donor < CVY_MAX_HOSTS; donor++)
if (partsz[donor] < cur_partsz[donor])
break;
/* if donor is pseudo-host and it's out of bins, give it more bins
to keep algorithm from looping; this should never happen */
if (donor >= CVY_MAX_HOSTS && cur_partsz[donor] == 0)
{
UNIV_PRINT(("Bin_targ_map_get: error - no donor bins"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
cur_partsz[donor] = CVY_MAXBINS;
}
/* now find the donor's bins and give them to the target host */
donorsz = partsz[donor]; /* donor's target bin count */
for (j=0; j<CVY_MAXBINS; j++)
{
if (cur_host[j] == donor)
{
cur_host[j] = i;
cur_partsz[donor]--;
cur_partsz[i]++;
/* if this donor has no more to give, go find the next donor;
if this receiver needs no more, go on to next receiver */
if (donorsz == cur_partsz[donor] || rcvrsz == cur_partsz[i])
break;
}
}
/* if no bin was found, log a fatal error and exit */
if (j == CVY_MAXBINS)
{
UNIV_PRINT(("Bin_targ_map_get: error - no bin found"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
break;
}
}
}
/* finally, compute bit mask for this host (v2.05) */
targ_map = 0;
for (j=0; j<CVY_MAXBINS; j++)
{
if (cur_host[j] == CVY_MAX_HOSTS)
{
UNIV_PRINT(("Bin_targ_map_get: error - incomplete mapping"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
cur_host[j] = 0;
}
if (cur_host[j] == my_host_id)
targ_map |= ((MAP_T)1) << j;
}
}
* pmap = targ_map;
return TRUE;
} /* end Bin_targ_map_get */
BOOLEAN Bin_map_check(
ULONG tot_load, /* total load percentage (v2.06) */
PMAP_T pbin_map) /* bin map for all hosts */
{
MAP_T tot_map, /* total map for all hosts */
ovr_map, /* overlap map between hosts */
exp_tot_map; /* expected total map */
ULONG i;
/* compute expected total map (2.04) */
if (tot_load == 0) /* v2.06 */
return TRUE;
else
exp_tot_map = BIN_ALL_ONES;
/* compute total map and overlap map */
tot_map = ovr_map = 0;
for (i=0; i<CVY_MAX_HOSTS; i++)
{
ovr_map |= (pbin_map[i] & tot_map);
tot_map |= pbin_map[i];
}
if (tot_map == exp_tot_map && ovr_map == 0)
return TRUE;
else
return FALSE;
} /* end Bin_map_check */
BOOLEAN Bin_map_covering(
ULONG tot_load, /* total load percentage (v2.06) */
PMAP_T pbin_map) /* bin map for all hosts */
{
MAP_T tot_map, /* total map for all hosts */
exp_tot_map; /* expected total map */
ULONG i;
/* compute expected total map (v2.04) */
if (tot_load == 0) /* v2.06 */
return TRUE;
else
exp_tot_map = BIN_ALL_ONES;
/* compute total map and overlap map */
tot_map = 0;
for (i=0; i<CVY_MAX_HOSTS; i++)
{
tot_map |= pbin_map[i];
}
if (tot_map == exp_tot_map)
return TRUE;
else
return FALSE;
} /* end Bin_map_covering */
void Bin_state_init(
PLOAD_CTXT lp,
PBIN_STATE binp, /* ptr. to bin state */
ULONG index, /* index of bin state */
ULONG my_host_id,
ULONG mode,
ULONG prot,
BOOLEAN equal_bal, /* TRUE => balance equally across hosts */
USHORT affinity,
ULONG load_amt) /* this host's load percentage if unequal */
/*
Initialize bin state for a port group
*/
{
ULONG i; /* loop variable */
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
if ((equal_bal && mode == CVY_SINGLE) ||
(mode == CVY_SINGLE && load_amt > CVY_MAX_HOSTS) ||
index >= CVY_MAXBINS)
{
UNIV_ASSERT(FALSE); // This should never happen
}
binp->code = CVY_BINCODE; /* (bbain 8/19/99) */
binp->equal_bal = equal_bal;
binp->affinity = affinity;
binp->index = index;
binp->compatible = TRUE;
binp->mode = mode;
binp->prot = prot;
/* initialize target and new load maps */
binp->targ_map = 0;
binp->all_idle_map = BIN_ALL_ONES;
binp->cmap = 0; /* v2.1 */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
binp->new_map[i] = 0;
binp->cur_map[i] = 0;
binp->chk_map[i] = 0;
binp->idle_map[i] = BIN_ALL_ONES;
}
/* initialize load percentages for all hosts */
if (equal_bal)
{
load_amt = CVY_EQUAL_LOAD;
}
binp->tot_load = load_amt;
for (i=0; i<CVY_MAX_HOSTS; i++)
{
if (i == my_host_id)
{
binp->orig_load_amt =
binp->load_amt[i] = load_amt;
}
else
binp->load_amt[i] = 0;
}
/* initialize requesting state to no requests active and all bins local or none */
binp->snd_bins = 0;
binp->rcv_bins = 0;
binp->rdy_bins = 0;
binp->idle_bins = BIN_ALL_ONES; /* we are initially idle */
/* perform first initialization only once (v2.06) */
if (!(binp->initialized))
{
binp->tconn = 0;
for (i=0; i<CVY_MAXBINS; i++)
{
binp->nconn[i] = 0;
}
Queue_init(&(binp->connq));
binp->initialized = TRUE;
}
} /* end Bin_state_init */
BOOLEAN Bin_converge(
PLOAD_CTXT lp,
PBIN_STATE binp, /* ptr. to bin state */
ULONG my_host_id)
/*
Explicitly attempt to converge new port group state
returns BOOL:
TRUE => all hosts have consistent new state for converging
FALSE => parameter error or inconsistent convergence state
*/
{
MAP_T orphan_map; /* map of orphans that this host will now own */
ULONG i;
/* determine new target load map; 1.03: return in error if no map generated */
if (!Bin_targ_map_get(lp, binp, my_host_id, &(binp->targ_map)))
return FALSE;
/* compute map of all currently orphan bins; note that all duplicates are
considered to be orphans */
orphan_map = 0;
for (i=0; i<CVY_MAX_HOSTS; i++)
orphan_map |= binp->cur_map[i];
orphan_map = ~orphan_map;
/* update our new map to include all current bins and orphans that are in the
target set */
binp->new_map[my_host_id] = binp->cmap | /* v2.1 */
(binp->targ_map & orphan_map); /* 1.03 */
/* check that new load maps are consistent and covering */
return Bin_map_check(binp->tot_load, binp->new_map); /* v2.06 */
} /* end Bin_converge */
void Bin_converge_commit(
PLOAD_CTXT lp,
PBIN_STATE binp, /* ptr. to bin state */
ULONG my_host_id)
/*
Commit to new port group state
*/
{
ULONG i;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
/* check that new load maps are consistent and covering */
if (!(Bin_map_check(binp->tot_load, binp->new_map))) /* v2.06 */
{
if (!(lp->bad_map))
{
UNIV_PRINT(("Bin_converge_commit: bad new map"));
LOG_MSG1(MSG_ERROR_INTERNAL, MSG_NONE, (ULONG_PTR)binp->new_map);
lp->bad_map = TRUE;
}
}
/* commit to new current maps */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
binp->chk_map[i] =
binp->cur_map[i] = binp->new_map[i];
}
/* setup new send/rcv bins, and new ready to ship bins; note that ready to
ship bins are cleared from the current map */
binp->rdy_bins = binp->cur_map[my_host_id] & ~(binp->targ_map); /* 1.03 */
binp->cur_map[my_host_id] &= ~(binp->rdy_bins);
binp->rcv_bins = binp->targ_map & ~(binp->cur_map[my_host_id]);
binp->cmap = binp->cur_map[my_host_id]; /* v2.1 */
#if 0
/* simulation output generator (2.05) */
{
ULONG lcount = 0L;
ULONG ncount = 0L;
MAP_T bins = binp->rdy_bins;
for (i=0; i<CVY_MAXBINS && bins != 0; i++, bins >>= 1)
if ((bins & ((MAP_T)0x1)) != ((MAP_T)0))
lcount++;
bins = binp->targ_map;
for (i=0; i<CVY_MAXBINS && bins != 0; i++, bins >>= 1)
if ((bins & ((MAP_T)0x1)) != ((MAP_T)0))
ncount++;
printf("Connverge at host %d pg %d: losing %d, will have %d bins\n", my_host_id, binp->index,
lcount, ncount);
}
#endif
} /* end Bin_converge_commit */
BOOLEAN Bin_host_update(
PLOAD_CTXT lp,
PBIN_STATE binp, /* ptr. to bin state */
ULONG my_host_id, /* my host's id MINUS one */
BOOLEAN converging, /* TRUE => we are converging now */
BOOLEAN rem_converging, /* TRUE => remote host is converging */
ULONG rem_host, /* remote host's id MINUS one */
MAP_T cur_map, /* remote host's current map or 0 if host died */
MAP_T new_map, /* remote host's new map if converging */
MAP_T idle_map, /* remote host's idle map */
MAP_T rdy_bins, /* bins that host is ready to send; ignored
if converging to prevent bin transfers */
ULONG pkt_count, /* remote host's packet count */
ULONG load_amt) /* remote host's load percentage */
/*
Update hosts's state for a port group
returns BOOL:
TRUE => if not converging, normal return
otherwise, all hosts have consistent state for converging
FALSE => parameter error or inconsistent convergence state
function:
Updates hosts's state for a port group and attempts to converge new states if
in convergence mode. Called when a ping message is received or when a host
is considered to have died. Handles case of newly discovered hosts. Can be
called multiple times with the same information.
*/
{
ULONG i;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
if (rem_host >= CVY_MAX_HOSTS || rem_host == my_host_id)
{
UNIV_PRINT(("Bin_host_update: parameter error"));
LOG_MSG2(MSG_ERROR_INTERNAL, MSG_NONE, rem_host+1, my_host_id+1);
return FALSE;
}
UNIV_ASSERT(binp->code == CVY_BINCODE); /* (bbain 8/19/99) */
#if 0 /* v2.06 */
/* update current load balance information */
if (binp->equal_bal && load_amt > 0)
{
load_amt = CVY_EQUAL_LOAD;
}
#endif
/* change load percentage if load changed */
if (load_amt != binp->load_amt[rem_host])
{
#if 0 /* v2.06 */
binp->tot_load += (load_amt - binp->load_amt[rem_host]);
#endif
binp->load_amt[rem_host] = load_amt;
}
/* check for non-overlapping maps */
if ((binp->cmap & cur_map) != 0) /* v2.1 */
{
/* if we have received fewer packets than the other host or have a higher host id,
remove duplicates from current map; this uses a heuristic that a newly joining
host that was subnetted probably did not receive packets; we are trying to avoid
having two hosts answer to the same client while minimizing disruption of service
(v1.32B) */
if (lp->send_msg.pkt_count < pkt_count ||
(lp->send_msg.pkt_count == pkt_count && rem_host < my_host_id))
{
MAP_T dup_map;
dup_map = binp->cmap & cur_map; /* v2.1 */
binp->cur_map[my_host_id] &= ~dup_map;
binp->cmap = binp->cur_map[my_host_id]; /* v2.1 */
Load_conn_kill(lp, binp);
}
if (!converging && !rem_converging)
{
if (!(lp->overlap_maps))
{
UNIV_PRINT(("Host %d: two hosts with overlapping maps detected %d.", my_host_id, binp->index));
LOG_MSG2(MSG_WARN_OVERLAP, MSG_NONE, my_host_id+1, binp->index);
lp->overlap_maps = TRUE;
}
/* force convergence if in normal operations */
return FALSE;
}
}
/* now update remote host's current map */
binp->cur_map[rem_host] = cur_map;
/* update idle map and calculate new global idle map if it's changed */
if (binp->idle_map[rem_host] != idle_map)
{
MAP_T saved_map = binp->all_idle_map;
MAP_T new_idle_map = BIN_ALL_ONES;
MAP_T tmp_map;
binp->idle_map[rem_host] = idle_map;
/* compute new idle map for all other hosts */
for (i=0; i<CVY_MAX_HOSTS; i++)
if (i != my_host_id)
new_idle_map &= binp->idle_map[i];
binp->all_idle_map = new_idle_map;
/* see which locally owned bins have gone idle in all other hosts */
tmp_map = new_idle_map & (~saved_map) & binp->cmap; /* v2.1 */
if (tmp_map != 0)
{
UNIV_PRINT(("Host %d pg %d: detected new all idle %08x for local bins",
my_host_id, binp->index, tmp_map));
}
tmp_map = saved_map & (~new_idle_map) & binp->cmap; /* v2.1 */
if (tmp_map != 0)
{
UNIV_PRINT(("Host %d pg %d: detected new non-idle %08x for local bins",
my_host_id, binp->index, tmp_map));
}
}
/* 1.03: eliminated else clause */
/* if we are not converging AND other host not converging, exchange bins;
convergence must now be complete for both hosts */
if (!converging)
{
if (!rem_converging) { /* 1.03: reorganized code to exchange bins only when both
hosts are not converging to avoid using stale bins */
MAP_T new_bins; /* incoming bins from the remote host */
/* check to see if remote host has received some bins from us */
binp->rdy_bins &= (~cur_map);
/* check to see if we can receive some bins */
new_bins = binp->rcv_bins & rdy_bins;
if (new_bins != 0)
{
if ((binp->cmap & new_bins) != 0) /* v2.1 */
{
if (!(lp->err_rcving_bins))
{
UNIV_PRINT(("Bin_host_update: receiving bins already own"));
LOG_MSG2(MSG_ERROR_INTERNAL, MSG_NONE, binp->cur_map[my_host_id], new_bins);
lp->err_rcving_bins = TRUE;
}
}
binp->cur_map[my_host_id] |= new_bins;
binp->rcv_bins &= ~new_bins;
binp->cmap = binp->cur_map[my_host_id]; /* v2.1 */
UNIV_PRINT(("====== host %d pg %d: received %08x ; cur now %08x",
my_host_id, binp->index, new_bins, binp->cur_map[my_host_id]));
}
/* do consistency check that all bins are covered */
binp->chk_map[rem_host] = cur_map | rdy_bins;
binp->chk_map[my_host_id] = binp->cmap | binp->rdy_bins; /* v2.1 */
if (!Bin_map_covering(binp->tot_load, binp->chk_map)) /* v2.06 */
{
if (!(lp->err_orphans))
{
#if 0
UNIV_PRINT(("Host %d: orphan bins detected", my_host_id));
LOG_MSG1(MSG_ERROR_INTERNAL, MSG_NONE, my_host_id+1);
#endif
lp->err_orphans = TRUE;
}
}
}
return TRUE;
}
/* otherwise, store proposed new load map and try to converge current host data */
else
{
binp->chk_map[rem_host] =
binp->new_map[rem_host] = new_map;
return Bin_converge(lp, binp, my_host_id);
}
} /* end Bin_host_update */
void Bin_state_print(
PBIN_STATE binp, /* ptr. to bin state */
ULONG my_host_id)
{
#if 0
ULONG i;
#endif
UNIV_PRINT(("hst %d binp %x: maps: targ %x cur %x new %x; eq %d mode %d amt %d tot %d; bins: snd %x rcv %x rdy %x",
my_host_id, binp, binp->targ_map, binp->cur_map[my_host_id], binp->new_map[my_host_id],
binp->equal_bal, binp->mode, binp->load_amt[my_host_id],
binp->tot_load, binp->snd_bins, binp->rcv_bins, binp->rdy_bins));
#if 0
for (i=0; i<CVY_MAX_HOSTS; i++)
{
UNIV_PRINT(("host %d: cur map %x new %x load_amt %d", i+1, binp->cur_map[i],
binp->new_map[i], binp->load_amt[i]));
}
for (i=0; i<CVY_MAXBINS; i++)
{
UNIV_PRINT(("bin %d: req_host %d bin_state %d nconn %d", i, binp->req_host[i],
binp->bin_state[i], binp->nconn[i]));
}
#endif
} /* end Bin_state_print */
void Load_conn_kill(
PLOAD_CTXT lp,
PBIN_STATE bp)
/*
Kill all connections in a port group (v1.32B)
*/
{
PCONN_ENTRY ep; /* ptr. to connection entry */
PCONN_DESCR dp; /* ptr. to connection descriptor */
QUEUE * qp; /* ptr. to bin's connection queue */
QUEUE * dqp; /* ptr. to dirty queue */
QUEUE * fqp; /* ptr. to free queue */
LONG count[CVY_MAXBINS];
/* count of cleaned up connections per bin for checking */
ULONG i;
BOOLEAN err_bin; /* bin id error detected */
BOOLEAN err_count; /* connection count error detected */
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
err_bin =
err_count = FALSE;
qp = &(bp->connq);
dqp = &(lp->conn_dirtyq);
fqp = &(lp->conn_freeq);
for (i=0; i<CVY_MAXBINS; i++)
count[i] = 0;
#ifdef TRACE_DIRTY
DbgPrint ("marking connections as dirty");
#endif
/* remove connections from bin queue and either make dirty or cleanup */
ep = (PCONN_ENTRY)Queue_deq(qp);
while (ep != NULL)
{
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/19/99) */
if (ep->bin >= CVY_MAXBINS)
{
if (!err_bin)
{
UNIV_PRINT(("Load_conn_kill: bad bin id"));
LOG_MSG2(MSG_ERROR_INTERNAL, MSG_NONE, ep->bin, CVY_MAXBINS);
err_bin = TRUE;
}
}
else
{
count[ep->bin]++;
}
/* make connection and bin dirty if we don't have a zero timeout period so that they
will not be handled by TCP/IP anymore; this avoids allowing TCP/IP's now stale
connection state from handling packets for newer connections should traffic be
directed to this host in the future */
if (lp->cln_timeout > 0)
{
ep->dirty = TRUE;
Queue_enq(dqp, &(ep->blink));
lp->dirty_bin[ep->bin] = TRUE;
lp->cln_waiting = TRUE;
}
/* otherwise, just cleanup the connection */
else
{
CVY_CONN_CLEAR(ep); /* v2.06 */
Link_unlink(&(ep->rlink)); /* V2.1.5 */
/* if entry is not in the hash table, free the descriptor */
if (ep->alloc)
{
dp = STRUCT_PTR(ep, CONN_DESCR, entry);
UNIV_ASSERT (dp->code == CVY_DESCCODE); /* (bbain 8/19/99) */
Link_unlink(&(dp->link));
Queue_enq(fqp, &(dp->link));
}
}
ep = (PCONN_ENTRY)Queue_deq(qp);
}
/* now make bins idle */
for (i=0; i<CVY_MAXBINS; i++)
{
if (bp->nconn[i] != count[i])
{
if (!err_count)
{
UNIV_PRINT(("Load_conn_kill: bad connection count %d %d bin %d", bp->nconn[i], (LONG)count[i], i));
/* KXF 2.1.1 - removed after tripped up at MSFT a few times */
#if 0
LOG_MSG3(MSG_ERROR_INTERNAL, MSG_NONE, bp->nconn[i], (LONG)count[i], i);
#endif
err_count = TRUE;
}
}
bp->nconn[i] = 0;
}
lp->nconn -= bp->tconn; /* v2.1 */
if (lp->nconn < 0)
lp->nconn = 0;
bp->tconn = 0; /* v2.06 */
bp->idle_bins = BIN_ALL_ONES;
/* if we at least one connection is dirty, restart cleanup timeout period */
if (lp->cln_waiting)
{
#ifdef TRACE_DIRTY
DbgPrint ("setting cleanup timeout");
#endif
lp->cur_time = 0;
}
else
{
#ifdef TRACE_DIRTY
DbgPrint ("no dirty connections found");
#endif
}
} /* end Load_conn_kill */
void Load_conn_cleanup(
PLOAD_CTXT lp)
/*
Clean up all dirty connections (v1.32B)
*/
{
PCONN_ENTRY ep; /* ptr. to connection entry */
PCONN_DESCR dp; /* ptr. to connection descriptor */
QUEUE * fqp; /* ptr. to free queue */
QUEUE * dqp; /* ptr. to dirty queue */
BOOLEAN err_bin; /* bin id error detected */
ULONG i;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
err_bin = FALSE;
dqp = &(lp->conn_dirtyq);
fqp = &(lp->conn_freeq);
#ifdef TRACE_DIRTY
DbgPrint ("cleaning up dirty connections");
#endif
/* dequeue and clean up all connections on dirty connection queue */
ep = (PCONN_ENTRY)Queue_deq(dqp);
while (ep != NULL)
{
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/19/99) */
if (ep->bin >= CVY_MAXBINS)
{
if (!err_bin)
{
UNIV_PRINT(("Load_conn_cleanup: bad bin id"));
LOG_MSG2(MSG_ERROR_INTERNAL, MSG_NONE, ep->bin, CVY_MAXBINS);
err_bin = TRUE;
}
}
CVY_CONN_CLEAR(ep);
ep->dirty = FALSE;
Link_unlink(&(ep->rlink)); /* V2.1.5 */
/* if entry is not in the hash table, free the descriptor */
if (ep->alloc)
{
dp = STRUCT_PTR(ep, CONN_DESCR, entry);
UNIV_ASSERT (dp->code == CVY_DESCCODE); /* (bbain 8/19/99) */
Link_unlink(&(dp->link));
Queue_enq(fqp, &(dp->link));
}
ep = (PCONN_ENTRY)Queue_deq(dqp);
}
/* clear all dirty bin flags */
for (i=0; i<CVY_MAXBINS; i++)
lp->dirty_bin[i] = FALSE;
} /* end Load_conn_cleanup */
void Load_stop(
PLOAD_CTXT lp)
{
ULONG i;
IRQLEVEL irql;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
if (!(lp->active))
return;
LOCK_ENTER(&(lp->lock), &irql);
/* make connections for all rules dirty so they will not be handled */
for (i=0; i<lp->send_msg.nrules; i++)
{
PBIN_STATE bp; /* ptr. to bin state */
bp = &(lp->pg_state[i]);
UNIV_ASSERT(bp->code == CVY_BINCODE); /* (bbain 8/21/99) */
Load_conn_kill(lp, bp); /* (v1.32B) */
/* advertise that we are not handling any load in case a ping is sent out */
lp->send_msg.cur_map[i] = 0;
lp->send_msg.new_map[i] = 0;
lp->send_msg.idle_map[i] = BIN_ALL_ONES;
lp->send_msg.rdy_bins[i] = 0;
lp->send_msg.load_amt[i] = 0;
}
lp->send_msg.state = HST_CVG; /* force convergence (v2.1) */
/* go inactive until restarted */
lp->active = FALSE;
lp->nconn = 0; /* v2.1 */
LOCK_EXIT(&(lp->lock), irql);
} /* end Load_stop */
void Load_start( /* (v1.32B) */
PLOAD_CTXT lp)
{
ULONG i;
BOOLEAN ret;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
WCHAR me[20];
if (!(lp->initialized))
Load_init(lp, & ctxtp -> params);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
if (lp->active)
return;
lp->my_host_id =(* (lp->params)).host_priority - 1;
lp->ping_map =
lp->host_map = 1 << lp->my_host_id;
lp->last_hmap = 0; /* bbain RTM RC1 6/23/99 */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
lp->nmissed_pings[i] = 0;
}
lp->min_missed_pings = (* (lp->params)).alive_tolerance;
lp->cln_timeout = (* (lp->params)).cleanup_delay;
lp->def_timeout = (* (lp->params)).alive_period;
lp->stable_map = 0;
lp->consistent = TRUE;
/* Intiialize the bad teaming configuration detected flag. */
lp->bad_team_config = FALSE;
lp->dup_hosts = FALSE;
lp->dup_sspri = FALSE;
lp->bad_map = FALSE;
lp->overlap_maps = FALSE;
lp->err_rcving_bins = FALSE;
lp->err_orphans = FALSE;
lp->bad_num_rules = FALSE;
lp->alloc_inhibited = FALSE;
lp->alloc_failed = FALSE;
lp->bad_defrule = FALSE;
lp->scale_client = (BOOLEAN)(* (lp->params)).scale_client;
lp->my_stable_ct = 0;
lp->all_stable_ct = 0;
lp->min_stable_ct = lp->min_missed_pings;
lp->dscr_per_alloc = (* (lp->params)).dscr_per_alloc;
lp->max_dscr_allocs = (* (lp->params)).max_dscr_allocs;
lp->pkt_count = 0; /* 1.32B */
/* initialize port group bin states; add a default rule at the end */
if ((* (lp->params)).num_rules >= (CVY_MAX_RULES - 1))
{
UNIV_PRINT(("Load_start: too many rules; using max possible."));
lp->send_msg.nrules = (USHORT)CVY_MAX_RULES;
}
else
lp->send_msg.nrules = (USHORT)((* (lp->params)).num_rules) + 1;
for (i=0; i<lp->send_msg.nrules; i++)
{
PBIN_STATE bp; /* ptr. to bin state */
PCVY_RULE rp; /* ptr. to rules array */
bp = &(lp->pg_state[i]);
rp = &((* (lp->params)).port_rules[i]);
if (i == (((ULONG)lp->send_msg.nrules) - 1))
/* initialize bin state for default rule to single server with
host priority */
Bin_state_init(lp, bp, i, lp->my_host_id, CVY_SINGLE, CVY_TCP_UDP,
FALSE, (USHORT)0, (* (lp->params)).host_priority);
else if (rp->mode == CVY_SINGLE)
Bin_state_init(lp, bp, i, lp->my_host_id, rp->mode, rp->protocol,
FALSE, (USHORT)0, rp->mode_data.single.priority);
else if (rp->mode == CVY_MULTI)
Bin_state_init(lp, bp, i, lp->my_host_id, rp->mode, rp->protocol,
(BOOLEAN)(rp->mode_data.multi.equal_load),
rp->mode_data.multi.affinity,
(rp->mode_data.multi.equal_load ?
CVY_EQUAL_LOAD : rp->mode_data.multi.load));
/* handle CVY_NEVER mode as multi-server. the check for
those modes is done before attempting to hash to the bin in
Load_packet_check and Load_conn_advise so bin distribution plays
no role in the behavior, but simply allows the rule to be valid
across all of the operational servers */
else
Bin_state_init(lp, bp, i, lp->my_host_id, rp->mode, rp->protocol,
TRUE, (USHORT)0, CVY_EQUAL_LOAD);
ret = Bin_converge(lp, bp, lp->my_host_id);
if (!ret)
{
UNIV_PRINT(("Load_start: initial convergence inconsistent"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
}
/* export current port group state to send msg */
if (i == (((ULONG)(lp->send_msg.nrules)) - 1))
lp->send_msg.rcode[i]= 0;
else
lp->send_msg.rcode[i]= rp->code;
lp->send_msg.cur_map[i] = bp->cmap; /* v2.1 */
lp->send_msg.new_map[i] = bp->new_map[lp->my_host_id];
lp->send_msg.idle_map[i] = bp->idle_bins;
lp->send_msg.rdy_bins[i] = bp->rdy_bins;
lp->send_msg.load_amt[i] = bp->load_amt[lp->my_host_id];
/* ###### for keynote - ramkrish */
lp->send_msg.pg_rsvd1[i] = (ULONG)bp->all_idle_map;
}
/* initialize send msg */
lp->send_msg.host_id = (USHORT)(lp->my_host_id);
lp->send_msg.master_id = (USHORT)(lp->my_host_id);
lp->send_msg.hcode = lp->params->install_date;
lp->send_msg.pkt_count = lp->pkt_count; /* 1.32B */
Univ_ulong_to_str (lp->my_host_id+1, me, 10);
/* Tracking convergence - Starting convergence because this host is joining the cluster. */
LOG_MSGS(MSG_INFO_CONVERGING_NEW_MEMBER, me, me);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is joining the cluster.", lp->my_host_id+1, lp->my_host_id+1);
/* Tracking convergence - Starting convergence. */
lp->send_msg.state = HST_CVG;
/* activate module */
lp->active = TRUE;
} /* end Load_start */
void Load_init(
PLOAD_CTXT lp,
PCVY_PARAMS params)
{
ULONG i;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
TRACE_INFO("-> Load_init: lp=0x%p, param=0x%p", lp, params);
LOCK_INIT(&(lp->lock));
if (!(lp->initialized))
{
lp->code = CVY_LOADCODE; /* (bbain 8/19/99) */
/* initialize hashed connection descriptors and queues */
for (i=0; i<CVY_MAX_CHASH; i++)
{
PCONN_ENTRY ep;
ep = &(lp->hashed_conn[i]);
ep->code = CVY_ENTRCODE; /* (bbain 8/19/99) */
ep->alloc = FALSE;
ep->dirty = FALSE; /* v1.32B */
CVY_CONN_CLEAR(ep);
Link_init(&(ep->blink));
Link_init(&(ep->rlink)); /* V2.1.5 */
Queue_init(&(lp->connq[i]));
}
/* initialize connection free and dirty queues; free descriptors */
Queue_init(&(lp->conn_freeq));
Queue_init(&(lp->conn_dirtyq)); /* v1.32B */
Queue_init(&(lp->conn_rcvryq)); /* V2.1.5 */
for (i=0; i<CVY_INIT_QCONN; i++)
{
lp->conn_descr[i].code = CVY_DESCCODE; /* (bbain 8/19/99) */
Link_init(&(lp->conn_descr[i].link));
lp->conn_descr[i].entry.code = CVY_ENTRCODE; /* (bbain 8/21/99) */
lp->conn_descr[i].entry.alloc = TRUE;
lp->conn_descr[i].entry.dirty = FALSE; /* v1.32B */
CVY_CONN_CLEAR(&(lp->conn_descr[i].entry));
Link_init(&(lp->conn_descr[i].entry.blink));
Link_init(&(lp->conn_descr[i].entry.rlink)); /* V2.1.5 */
Queue_enq(&(lp->conn_freeq), &(lp->conn_descr[i].link));
}
/* (v1.32B) */
for (i=0; i<CVY_MAXBINS; i++)
lp->dirty_bin[i] = FALSE;
lp->cln_waiting = FALSE;
lp->def_timeout =
lp->cur_timeout = params -> alive_period;
lp->nqalloc = 0;
lp->nconn = 0; /* v2.1 */
lp->active = FALSE;
lp->initialized = TRUE;
/* clear list of descriptor queue allocations (bbain 2/25/99) */
for (i=0; i<CVY_MAX_MAX_DSCR_ALLOCS; i++)
lp->qalloc_list[i] = (PCONN_DESCR)NULL;
lp -> params = params;
}
else
{
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
}
/* Initialize the reference count on this load module. */
lp->ref_count = 0;
/* don't start module (v1.32B) */
TRACE_INFO("<- Load_init");
} /* end Load_init */
void Load_cleanup( /* (bbain 2/25/99) */
PLOAD_CTXT lp)
{
ULONG i;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
/* free all descriptor queue allocations */
if (lp->nqalloc > CVY_MAX_MAX_DSCR_ALLOCS)
lp->nqalloc = CVY_MAX_MAX_DSCR_ALLOCS;
for (i=0; i<lp->nqalloc; i++)
if (lp->qalloc_list[i] != (PCONN_DESCR)NULL)
free((PVOID)(lp->qalloc_list[i]));
} /* end Load_cleanup */
void Load_convergence_start(
PLOAD_CTXT lp)
{
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
lp->consistent = TRUE; /* 1.03 */
/* setup initial convergence state */
lp->send_msg.state = HST_CVG;
lp->stable_map = 0;
lp->my_stable_ct = 0;
lp->all_stable_ct = 0;
lp->send_msg.master_id = (USHORT)(lp->my_host_id);
} /* end Load_convergence_start */
void Load_msg_rcv(
PLOAD_CTXT lp,
PPING_MSG pmsg) /* ptr. to ping message */
{
ULONG i;
BOOLEAN consistent;
ULONG my_host;
ULONG rem_host;
ULONG saved_map; /* saved host map */
PPING_MSG sendp; /* ptr. to my send message */
IRQLEVEL irql;
WCHAR me[20];
WCHAR them[20];
ULONG map;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
/* Used for tracking convergence and event logging. */
BOOLEAN bInconsistentMaster = FALSE;
BOOLEAN bInconsistentTeaming = FALSE;
BOOLEAN bInconsistentPortRules = FALSE;
UNIV_ASSERT(lp->code == CVY_LOADCODE);
TRACE_HB("Recv HB from host %d", (ULONG) pmsg->host_id + 1);
if (!(lp->active))
return;
my_host = lp->my_host_id;
rem_host = (ULONG) pmsg->host_id;
Univ_ulong_to_str (my_host+1, me, 10);
Univ_ulong_to_str (rem_host+1, them, 10);
sendp = &(lp->send_msg);
if (rem_host >= CVY_MAX_HOSTS)
return;
LOCK_ENTER(&(lp->lock), &irql);
/* filter out packets broadcast by this host */
if(rem_host == my_host)
{
/* if this packet was really from another host, we have duplicate host ids */
if (sendp->hcode != pmsg->hcode)
{
if (!(lp->dup_hosts))
{
UNIV_PRINT(("Duplicate host ids detected."));
LOG_MSG(MSG_ERROR_HOST_ID, me);
lp->dup_hosts = TRUE;
}
/* Tracking convergence - Starting convergence because duplicate host IDs were detected in the cluster. */
if (sendp->state == HST_NORMAL) {
LOG_MSGS(MSG_INFO_CONVERGING_DUPLICATE_HOST_ID, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is configured with the same host ID.", my_host+1, rem_host+1);
}
/* Tracking convergence - Starting convergence. */
Load_convergence_start(lp);
}
/* just update ping and host maps for us */
lp->ping_map |= (1 << my_host);
lp->host_map |= (1 << my_host);
LOCK_EXIT(&(lp->lock), irql);
return;
}
if (sendp->nrules != pmsg->nrules)
{
if (!(lp->bad_num_rules))
{
UNIV_PRINT(("Host %d: Hosts have diff # rules.", my_host));
LOG_MSG2(MSG_ERROR_RULES_MISMATCH, them, sendp->nrules, pmsg->nrules);
lp->bad_num_rules = TRUE;
}
/* Tracking convergence - Starting convergence because the number of port rules on this host and the remote host do not match. */
if (sendp->state == HST_NORMAL) {
LOG_MSGS(MSG_INFO_CONVERGING_NUM_RULES, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is configured with a conflicting number of port rules.", my_host+1, rem_host+1);
}
/* Tracking convergence - Starting convergence. */
Load_convergence_start(lp);
/* just update ping and host maps for remote host (bbain 2/17/99) */
lp->ping_map |= (1 << rem_host);
lp->host_map |= (1 << rem_host);
LOCK_EXIT(&(lp->lock), irql);
return;
}
/* update mastership and see if consistent */
if (rem_host < sendp->master_id)
sendp->master_id = (USHORT)rem_host;
consistent = sendp->master_id == pmsg->master_id; /* 1.03 */
/* For the purposes of logging the reason for convergence, note this inconsistency. */
if (!consistent) bInconsistentMaster = TRUE;
/* update ping and host maps to include remote host */
lp->ping_map |= (1 << rem_host);
saved_map = lp->host_map;
lp->host_map |= (1 << rem_host);
/* handle host convergence */
if (sendp->state != HST_NORMAL)
{
/* if master, update stable map for remote host */
if (sendp->master_id == my_host)
{
if (pmsg->state == HST_STABLE)
{
lp->stable_map |= (1 << rem_host);
}
else
{
lp->stable_map &= ~(1 << rem_host);
lp->all_stable_ct = 0;
}
}
/* otherwise, update state if have global stable convergence and the current
master has signalled completion by returning to the normal state; note
that we must do this prior to updating port group states */
else if (rem_host == sendp->master_id && pmsg->state == HST_NORMAL)
{
if (sendp->state == HST_STABLE)
{
sendp->state = HST_NORMAL;
/* Notify our BDA team that this cluster is consistently configured.
If we are not part of a BDA team, this call is essentially a no-op. */
Load_teaming_consistency_notify(&ctxtp->bda_teaming, TRUE);
/* Reset the bad teaming configuration detected flag if we are converged. */
lp->bad_team_config = FALSE;
lp->dup_hosts = FALSE;
lp->dup_sspri = FALSE;
lp->bad_map = FALSE;
lp->overlap_maps = FALSE;
lp->err_rcving_bins = FALSE;
lp->err_orphans = FALSE;
lp->bad_num_rules = FALSE;
lp->pkt_count = 0; /* v1.32B */
for (i=0; i<sendp->nrules; i++)
{
PBIN_STATE bp;
bp = &(lp->pg_state[i]);
bp->compatible = TRUE; /* 1.03 */
Bin_converge_commit(lp, bp, my_host);
UNIV_PRINT(("Host %d pg %d: new cur map %x idle %x all %x",
my_host, i, bp->cur_map[my_host], bp->idle_bins,
bp->all_idle_map));
#if 0 /* 1.03: only update ping message in Load_timeout to avoid locking send */
/* export current port group state */
sendp->cur_map[i] = bp->cmap; /* v2.1 */
sendp->new_map[i] = bp->new_map[my_host];
sendp->idle_map[i] = bp->idle_bins;
sendp->rdy_bins[i] = bp->rdy_bins;
sendp->load_amt[i] = bp->load_amt[my_host];
#endif
}
#if 0
sendp->pkt_count = lp->pkt_count; /* 1.32B */
#endif
UNIV_PRINT(("Host %d: converged as slave", my_host));
/* log convergence completion if host map changed (bbain RTM RC1 6/23/99) */
Load_hosts_query (lp, TRUE, & map);
lp->last_hmap = lp->host_map;
}
else
{
/* Tracking convergence - Starting convergence because the DEFAULT host prematurely ended convergence. In this case, we
are guaranteed to already be in the HST_CVG state, and because this message can be misleading in some circumstances,
we do not log an event. For instance, due to timing issues, when a host joins a cluster he can receive a HST_NORMAL
heartbeat from the DEFAULT host while it is still in the HST_CVG state simply because that heartbeat left the DEFAULT
host before it received our first heartbeat, which initiated convergence. */
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d, the DEFAULT host, prematurely terminated convergence.", my_host+1, rem_host+1);
/* Tracking convergence - Starting convergence. */
Load_convergence_start(lp);
}
}
}
/* Compare the teaming configuration of this host with the remote host. If the
two are inconsitent and we are part of a team, we will initiate convergence. */
if (!Load_teaming_consistency_check(lp->bad_team_config, &ctxtp->bda_teaming, sendp->teaming, pmsg->teaming)) {
/* Only log an event if the teaming configuration was, but is now not, consistent. */
if (!lp->bad_team_config) {
/* Note that we saw this. */
lp->bad_team_config = TRUE;
/* Log the event. */
LOG_MSG(MSG_ERROR_BDA_BAD_TEAM_CONFIG, them);
}
/* Notify the team that this cluster is NOT consistently configured. */
Load_teaming_consistency_notify(&ctxtp->bda_teaming, FALSE);
/* Mark the heartbeats inconsistent to force and retain convergence. */
consistent = FALSE;
/* For the purposes of logging the reason for convergence, note this inconsistency. */
bInconsistentTeaming = TRUE;
}
/* update port group state */
for (i=0; i<sendp->nrules; i++)
{
BOOLEAN ret;
PBIN_STATE bp;
bp = &lp->pg_state[i];
/* if rule codes don't match, print message and handle incompatibility (1.03: note
that we previously marked rule invalid, which would stop processing) */
if (sendp->rcode[i] != pmsg->rcode[i])
{
/* 1.03: if rule was peviously compatible, print message */
if (bp->compatible)
{
PCVY_RULE rp;
UNIV_PRINT(("Host %d pg %d: rule codes do not match.", lp->my_host_id, i));
/* bbain 8/27/99 */
LOG_MSG4(MSG_ERROR_RULES_MISMATCH, them, rem_host, i, sendp->rcode[i], pmsg->rcode[i]);
/* Get the port rule information for this rule. */
rp = &lp->params->port_rules[i];
/* Check to see if this is an issue with a win2k host in a cluster utilizing virtual clusters. */
if ((rp->virtual_ip_addr != CVY_ALL_VIP_NUMERIC_VALUE) && ((sendp->rcode[i] ^ ~rp->virtual_ip_addr) == pmsg->rcode[i])) {
UNIV_PRINT((" ** A Windows 2000 or NT4 host MAY be participating in a cluster utilizing virtual cluster support."));
LOG_MSG(MSG_WARN_VIRTUAL_CLUSTERS, MSG_NONE);
}
bp->compatible = FALSE;
}
/* 1.03: mark rule inconsistent to force and continue convergence */
consistent = FALSE;
/* For the purposes of logging the reason for convergence, note this inconsistency. */
bInconsistentPortRules = TRUE;
/* don't update bin state */
continue;
}
ret = Bin_host_update(lp, bp, my_host, (BOOLEAN)(sendp->state != HST_NORMAL),
(BOOLEAN)(pmsg->state != HST_NORMAL),
rem_host, pmsg->cur_map[i], pmsg->new_map[i],
pmsg->idle_map[i], pmsg->rdy_bins[i],
pmsg->pkt_count, pmsg->load_amt[i]);
#if 0 /* 1.03: only update ping message in Load_timeout to avoid locking send */
/* export current port group state */
sendp->cur_map[i] = bp->cmap; /* v2.1 */
sendp->new_map[i] = bp->new_map[my_host];
sendp->idle_map[i] = bp->idle_bins;
sendp->rdy_bins[i] = bp->rdy_bins;
sendp->load_amt[i] = bp->load_amt[my_host];
#endif
if (!ret)
consistent = FALSE;
}
/* update our consistency state */
lp->consistent = consistent;
/* if we are in normal operation and we discover a new host or a host goes into
convergence or we discover an inconsistency, go into convergence */
if (sendp->state == HST_NORMAL)
{
if (lp->host_map != saved_map || pmsg->state == HST_CVG || !consistent)
{
/* If a host has joined the cluster, or if inconsistent teaming configuration or port
rules were detected, then we need to log an event. However, we segregate the
inconsistent master host flag because it is set by the initiating host in MANY
occasions, so we want to log the most specific reason(s) for convergence if
possible and only report the inconsistent master detection only if nothing more
specific can be deduced. */
if (lp->host_map != saved_map || bInconsistentTeaming || bInconsistentPortRules) {
/* If the host maps are different, then we know that the host from which we received
this packet is joining the cluster because the ONLY operation on the host map in
this function is to ADD a remote host to our map. Otherwise, if the map has not
changed, then an inconsistent configuration got us into the branch. */
if (lp->host_map != saved_map) {
/* Tracking convergence - Starting convergence because another host is joining the cluster. */
LOG_MSGS(MSG_INFO_CONVERGING_NEW_MEMBER, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is joining the cluster.", my_host+1, rem_host+1);
} else if (bInconsistentTeaming || bInconsistentPortRules) {
/* Tracking convergence - Starting convergence because inconsistent configuration was detected. */
LOG_MSGS(MSG_INFO_CONVERGING_BAD_CONFIG, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d has conflicting configuration.", my_host+1, rem_host+1);
}
/* If we have nothing better to report, report convergence for an unspecific reason. */
} else if (bInconsistentMaster || pmsg->state == HST_CVG) {
/* Tracking convergence - Starting convergence for unknown reasons. */
LOG_MSGS(MSG_INFO_CONVERGING_UNKNOWN, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is converging for an unknown reason.", my_host+1, rem_host+1);
}
/* Tracking convergence - Starting convergence. */
Load_convergence_start(lp);
}
}
/* otherwise, if we are in convergence and we see an inconsistency, just restart
our local convergence */
else
{
/* update our consistency state; if we didn't see consistent information,
restart this host's convergence */
if (!consistent)
{
/* Tracking convergence - Starting convergence because inconsistent configuration was detected.
This keeps hosts in a state of convergence when hosts are inconsistently configured. However,
since the cluster is already in a state of convergece (HST_CVG or HST_STABLE), don't log an
event, which may confuse a user. */
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d has conflicting configuration.", my_host+1, rem_host+1);
/* Tracking convergence - Starting convergence. */
sendp->state = HST_CVG;
lp->my_stable_ct = 0;
lp->stable_map &= ~(1 << my_host);
lp->all_stable_ct = 0;
}
}
LOCK_EXIT(&(lp->lock), irql);
} /* end Load_msg_rcv */
PPING_MSG Load_snd_msg_get(
PLOAD_CTXT lp)
{
return &(lp->send_msg);
} /* end Load_snd_msg_get */
BOOLEAN Load_timeout(
PLOAD_CTXT lp,
PULONG new_timeout,
PBOOLEAN pconverging,
PULONG pnconn)
/*
Note: we only update ping message in this function since we know that upper level code
sends out ping messages after calling this routine. We cannot be sure that Load_msg_rcv
is sequentialized with sending a message, (1.03)
Upper level code locks this routine wrt Load_msg_rcv, Load_packet_check, and
Load_conn_advise. (1.03)
*/
{
ULONG missed_pings;
ULONG my_host;
ULONG i;
PPING_MSG sendp; /* ptr. to my send message */
IRQLEVEL irql;
ULONG map; /* returned host map from query */
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
LOCK_ENTER(&(lp->lock), &irql);
/* check for cleanup timeout (v1.32B) */
if (lp->cln_waiting)
{
lp->cur_time += lp->cur_timeout;
if (lp->cur_time >= lp->cln_timeout)
{
Load_conn_cleanup(lp);
lp->cln_waiting = FALSE;
}
}
/* return if not active */
if (!(lp->active))
{
if (new_timeout != NULL)
* new_timeout = lp->cur_timeout = lp->def_timeout;
if (pnconn != NULL) /* v2.1 */
* pnconn = lp->nconn;
if (pconverging != NULL)
* pconverging = FALSE;
LOCK_EXIT(&(lp->lock), irql);
return FALSE;
}
my_host = lp->my_host_id;
sendp = &(lp->send_msg);
/* compute which hosts missed pings and reset ping map */
missed_pings = lp->host_map & (~lp->ping_map);
#ifdef NO_CLEANUP
lp->ping_map = 1 << my_host;
#else
lp->ping_map = 0;
#endif
/* check whether any host is dead, including ourselves */
for (i=0; i<CVY_MAX_HOSTS; i++)
{
/* if we have a missed ping for this host, increment count */
if ((missed_pings & 0x1) == 1)
{
lp->nmissed_pings[i]++;
/* if we missed too many pings, declare host dead and force convergence */
if (lp->nmissed_pings[i] == lp->min_missed_pings)
{
ULONG j;
BOOLEAN ret;
WCHAR me[20];
WCHAR them[20];
if (i == my_host)
{
UNIV_PRINT(("Host %d: missed too many pings; this host declared offline", i));
/* reset our packet count since we are likely not to be receiving
packets from others now; this will make us less favored to
handle duplicate bins later (v1.32B) */
lp->pkt_count = 0;
}
lp->host_map &= ~(1<<i);
for (j=0; j<sendp->nrules; j++)
{
PBIN_STATE bp;
bp = &(lp->pg_state[j]);
UNIV_ASSERT(bp->code == CVY_BINCODE); /* (bbain 8/19/99) */
if (i == my_host)
{
ULONG k;
/* cleanup connections and restore maps to clean state */
Load_conn_kill(lp, bp);
bp->targ_map = 0;
bp->all_idle_map = BIN_ALL_ONES;
bp->cmap = 0; /* v2.1 */
bp->compatible = TRUE; /* v1.03 */
for (k=0; k<CVY_MAX_HOSTS; k++)
{
bp->new_map[k] = 0;
bp->cur_map[k] = 0;
bp->chk_map[k] = 0;
bp->idle_map[k] = BIN_ALL_ONES;
if (k != i)
bp->load_amt[k] = 0;
}
bp->snd_bins =
bp->rcv_bins =
bp->rdy_bins = 0;
bp->idle_bins = BIN_ALL_ONES;
/* compute initial new map for convergence as only host in cluster
(v 1.3.2B) */
ret = Bin_converge(lp, bp, lp->my_host_id);
if (!ret)
{
UNIV_PRINT(("Load_timeout: initial convergence inconsistent"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
}
}
else
{
ret = Bin_host_update(lp, bp, my_host, TRUE, TRUE,
i, 0, 0, BIN_ALL_ONES, 0, 0, 0);
}
}
lp->nmissed_pings[i] = 0;
/* If a host has dropped out of the cluster, then log an event. However, we don't
log an event when we drop out because the only way for us to drop out of our own
cluster is if we are stopping anyway, or if we have lost network connectivity.
Logging such events may be misleading, so we won't bother. */
if (i != my_host) {
Univ_ulong_to_str (my_host+1, me, 10);
Univ_ulong_to_str (i+1, them, 10);
/* Tracking convergence - Starting convergence because a member has fallen out of the cluster. */
LOG_MSGS(MSG_INFO_CONVERGING_MEMBER_LOST, me, them);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d is leaving the cluster.", my_host+1, i+1);
}
/* Tracking convergence - Starting convergence. */
Load_convergence_start(lp);
}
}
/* otherwise reset missed ping count */
else
lp->nmissed_pings[i] = 0;
missed_pings >>= 1;
}
/* handle convergence */
if (sendp->state != HST_NORMAL)
{
/* check whether we have been consistent and have received our own pings
for a sufficient period to move to a stable state and announce it to
other hosts */
if (sendp->state == HST_CVG)
{
if (lp->consistent && ((lp->host_map & (1 << my_host)) != 0))
{
lp->my_stable_ct++;
if (lp->my_stable_ct >= lp->min_stable_ct)
{
sendp->state = HST_STABLE;
lp->stable_map |= (1 << my_host);
}
}
else
lp->my_stable_ct = lp->all_stable_ct = 0; /* wlb B3RC1 */
}
/* otherwise, see if we are the master and everybody's been stable for
a sufficient period for us to terminate convergence */
else if (sendp->state == HST_STABLE &&
my_host == sendp->master_id &&
lp->stable_map == lp->host_map)
{
lp->all_stable_ct++;
if (lp->all_stable_ct >= lp->min_stable_ct)
{
sendp->state = HST_NORMAL;
/* Notify our BDA team that this cluster is consistently configured.
If we are not part of BDA team, this call is essentially a no-op. */
Load_teaming_consistency_notify(&ctxtp->bda_teaming, TRUE);
/* Reset the bad teaming configuration detected flag if we are converged. */
lp->bad_team_config = FALSE;
lp->dup_hosts = FALSE;
lp->dup_sspri = FALSE;
lp->bad_map = FALSE;
lp->overlap_maps = FALSE;
lp->err_rcving_bins = FALSE;
lp->err_orphans = FALSE;
lp->bad_num_rules = FALSE;
lp->pkt_count = 0; /* v1.32B */
for (i=0; i<sendp->nrules; i++)
{
PBIN_STATE bp;
BOOLEAN ret;
bp = &(lp->pg_state[i]);
bp->compatible = TRUE; /* 1.03 */
/* explicitly converge to new map in case we're the only host (v2.06) */
ret = Bin_converge(lp, bp, lp->my_host_id);
if (!ret)
{
UNIV_PRINT(("Load_timeout: final convergence inconsistent"));
LOG_MSG(MSG_ERROR_INTERNAL, MSG_NONE);
}
Bin_converge_commit(lp, bp, my_host);
UNIV_PRINT(("Host %d pg %d: new cur map %x idle %x all %x",
my_host, i, bp->cur_map[my_host], bp->idle_bins,
bp->all_idle_map));
}
UNIV_PRINT(("+++ Host %d: converged as master +++", my_host));
/* log convergence completion if host map changed (bbain RTM RC1 6/23/99) */
Load_hosts_query (lp, TRUE, & map);
lp->last_hmap = lp->host_map;
}
}
}
/* 1.03: update ping message */
for (i=0; i<sendp->nrules; i++)
{
PBIN_STATE bp;
bp = &(lp->pg_state[i]);
/* export current port group state to ping message */
sendp->cur_map[i] = bp->cmap; /* v2.1 */
sendp->new_map[i] = bp->new_map[my_host];
sendp->idle_map[i] = bp->idle_bins;
sendp->rdy_bins[i] = bp->rdy_bins;
sendp->load_amt[i] = bp->load_amt[my_host];
/* ###### for keynote - ramkrish */
sendp->pg_rsvd1[i] = (ULONG)bp->all_idle_map;
}
sendp->pkt_count = lp->pkt_count; /* 1.32B */
/* Add configuration information for teaming at each timeout. */
Load_teaming_code_create(&lp->send_msg.teaming, &ctxtp->bda_teaming);
/* request fast timeout if converging */
if (new_timeout != NULL) /* 1.03 */
{
if (sendp->state != HST_NORMAL)
* new_timeout = lp->cur_timeout = lp->def_timeout / 2;
else
* new_timeout = lp->cur_timeout = lp->def_timeout;
}
if (pnconn != NULL) /* v2.1 */
* pnconn = lp->nconn;
if (pconverging != NULL)
* pconverging = (sendp->state != HST_NORMAL);
LOCK_EXIT(&(lp->lock), irql);
return ((lp->host_map) != 0);
} /* end Load_timeout */
PBIN_STATE Load_pg_lookup(
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
BOOLEAN is_tcp)
{
PCVY_RULE rp; /* ptr. to rules array */
PBIN_STATE bp; /* ptr. to bin state */
ULONG i;
ULONG nurules; /* # user defined rules */
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
rp = (* (lp->params)).port_rules;
nurules = (* (lp->params)).num_rules;
/* check for invalid port value (bbain RC1 6/14/99) */
UNIV_ASSERT(svr_port <= CVY_MAX_PORT);
/* find server port rule */
for (i=0; i<nurules; i++)
{
/* For virtual clusters: If the server IP address matches the VIP for the port rule,
or if the VIP for the port rule is "ALL VIPs", and if the port lies in the range
for this rule, and if the protocol matches, this is the rule. Notice that this
give priority to rules for specific VIPs over those for "ALL VIPs", which means
that this code RELIES on the port rules being sorted by VIP/port where the "ALL
VIP" ports rules are at the end of the port rule list. */
if ((svr_ipaddr == rp->virtual_ip_addr || CVY_ALL_VIP_NUMERIC_VALUE == rp->virtual_ip_addr) &&
(svr_port >= rp->start_port && svr_port <= rp->end_port) &&
((is_tcp && rp->protocol != CVY_UDP) || (!is_tcp && rp->protocol != CVY_TCP)))
break;
else
rp++;
}
/* use default rule if port not found or rule is invalid */
bp = &(lp->pg_state[i]);
UNIV_ASSERT(bp->code == CVY_BINCODE); /* (bbain 8/19/99) */
return bp;
} /* end Load_pg_lookup */
BOOLEAN Load_packet_check(
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
ULONG client_ipaddr,
ULONG client_port,
USHORT protocol,
BOOLEAN limit_map_fn)
{
PBIN_STATE bp; /* ptr. to bin state */
ULONG id; /* hash index for the connection */
ULONG bin; /* bin index */
QUEUE * qp; /* ptr. to connection queue */
IRQLEVEL irql;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
BOOLEAN is_tcp_pkt = (protocol == TCPIP_PROTOCOL_TCP);
BOOLEAN is_session_pkt;
is_session_pkt = is_tcp_pkt;
if (NLB_IPSEC_SESSION_SUPPORT_ENABLED() && (protocol == TCPIP_PROTOCOL_IPSEC1))
{
is_session_pkt = TRUE;
}
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
if (! lp -> active)
return FALSE;
lp->pkt_count++; /* increment count of pkts handled (v1.32B) */
bp = Load_pg_lookup(lp, svr_ipaddr, svr_port, is_tcp_pkt);
/* V2.2 make sure that Load_pg_lookup properly handled protocol specific rules */
UNIV_ASSERT ((is_tcp_pkt && bp->prot != CVY_UDP) || (!is_tcp_pkt && bp->prot != CVY_TCP));
/* handle CVY_NEVER mode immediately */
if (bp->mode == CVY_NEVER)
return FALSE;
/* lookup connection entry in hash table */
if (limit_map_fn) {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, MAP_FN_PARAMETER);
} else {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, ((svr_port << 16) + client_port));
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, svr_ipaddr);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, svr_ipaddr);
}
/* now hash client address to bin id */
bin = id % CVY_MAXBINS;
LOCK_ENTER(&(lp->lock), &irql);
/* check bin for residency and all other hosts now idle on their bins; in this
case and if we do not have dirty connections, we must be able to handle the packet */
if (((bp->cmap & (((MAP_T) 1) << bin)) != 0) && /* v2.1 */
(!is_session_pkt || (((bp->all_idle_map & (((MAP_T) 1) << bin)) != 0) && (!(lp->cln_waiting))))) /* v1.32B */
{
/* note that we may have missed a connection, but it could also be a stale
packet so we can't start tracking the connection now */
#ifdef TRACE_LOAD
DbgPrint("Host %d: check 1 accepts pkt; rule %d bin %d nconn %d %s port %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin], is_tcp_pkt ? "TCP" : "UDP", svr_port);
#endif
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
/* otherwise, if we have an active connection for this bin or if we have dirty
connections for this bin and the bin is resident, check for a match */
else if (bp->nconn[bin] > 0 || (lp->cln_waiting && lp->dirty_bin[bin] && ((bp->cmap & (((MAP_T) 1) << bin)) != 0)))
{
PCONN_ENTRY ep; /* ptr. to connection entry */
PCONN_DESCR dp; /* ptr. to connection descriptor */
/* now hash client address to conn. hash table index */
id = id % CVY_MAX_CHASH;
ep = &(lp->hashed_conn[id]);
qp = &(lp->connq[id]);
/* look for a connection match */
if (CVY_CONN_MATCH(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
/* if connection was dirty, just block the packet since TCP/IP may have stale
connection state for a previous connection from another host (v1.32B) */
if (ep->dirty)
{
LOCK_EXIT(&(lp->lock), irql);
#ifdef TRACE_DIRTY
DbgPrint ("blocking dirty connection from %d to %d\n", client_port, svr_port);
#endif
return FALSE;
}
#ifdef TRACE_LOAD
DbgPrint("Host %d: check 2 accepts pkt; rule %d bin %d nconn %d %s port %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin], is_tcp_pkt ? "TCP" : "UDP", svr_port);
#endif
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
else
{
for (dp = (PCONN_DESCR)Queue_front(qp); dp != NULL;
dp = (PCONN_DESCR)Queue_next(qp, &(dp->link)))
{
if (CVY_CONN_MATCH(&(dp->entry), svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
/* if connection was dirty, just block the packet since TCP/IP may have
stale connection state for a previous connection from another host
(v1.32B) */
if (dp->entry.dirty)
{
LOCK_EXIT(&(lp->lock), irql);
#ifdef TRACE_DIRTY
DbgPrint ("blocking dirty connection from %d to %d\n", client_port, svr_port);
#endif
return FALSE;
}
#ifdef TRACE_LOAD
DbgPrint("Host %d: check 3 accepts pkt; rule %d bin %d nconn %d %s port %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin], is_tcp_pkt ? "TCP" : "UDP", svr_port);
#endif
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
}
}
}
LOCK_EXIT(&(lp->lock), irql);
return FALSE;
} /* end Load_packet_check */
BOOLEAN Load_conn_advise(
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
ULONG client_ipaddr,
ULONG client_port,
USHORT protocol,
ULONG conn_status,
BOOLEAN limit_map_fn)
{
BOOLEAN match, /* TRUE => we have a record of this connection */
hit; /* TRUE => we have a hash entry hit */
ULONG id; /* hash index for the connection */
ULONG bin; /* bin index */
PBIN_STATE bp; /* ptr. to bin state */
PCONN_ENTRY ep; /* ptr. to connection entry */
PCONN_DESCR dp; /* ptr. to connection descriptor */
QUEUE * qp; /* ptr. to connection queue */
IRQLEVEL irql;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
BOOLEAN is_tcp_pkt = (protocol == TCPIP_PROTOCOL_TCP);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
if (!lp -> active)
return FALSE;
lp->pkt_count++; /* increment count of pkts handled (v1.32B) */
/* increment bin count */
bp = Load_pg_lookup(lp, svr_ipaddr, svr_port, is_tcp_pkt);
/* handle CVY_NEVER immediately */
if (bp->mode == CVY_NEVER)
return FALSE;
/* This function is no longer for TCP only. */
if (!NLB_SESSION_SUPPORT_ENABLED())
{
/* This should never happen with session support disabled anyway - Load_pg_lookup() will
NEVER return a UDP only rule when the is_tcp_pkt is TRUE, so this isn't necessary. */
if (bp->prot == CVY_UDP)
return TRUE;
}
/* lookup connection entry in hash table */
if (limit_map_fn) {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, MAP_FN_PARAMETER);
} else {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, ((svr_port << 16) + client_port));
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, svr_ipaddr);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, svr_ipaddr);
}
/* now hash client address to bin id and conn. hash table index */
bin = id % CVY_MAXBINS;
id = id % CVY_MAX_CHASH;
/* if this connection is not in our current map and it is not a connection
down notification for a non-idle bin, just filter it out */
if ((bp->cmap & (((MAP_T) 1) << bin)) == 0 && /* v2.1 */
(!((conn_status == CVY_CONN_DOWN || conn_status == CVY_CONN_RESET) && bp->nconn[bin] > 0)))
return FALSE;
ep = &(lp->hashed_conn[id]);
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/21/99) */
qp = &(lp->connq[id]);
match = hit = FALSE;
LOCK_ENTER(&(lp->lock), &irql);
if (CVY_CONN_MATCH(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
hit =
match = TRUE;
}
else
{
for (dp = (PCONN_DESCR)Queue_front(qp); dp != NULL;
dp = (PCONN_DESCR)Queue_next(qp, &(dp->link)))
{
if (CVY_CONN_MATCH(&(dp->entry), svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
match = TRUE;
UNIV_ASSERT (dp->code == CVY_DESCCODE); /* (bbain 8/19/99) */
ep = &(dp->entry); /* v 2.06 */
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/21/99) */
/* release connection descriptor if taking down connection */
if (conn_status == CVY_CONN_DOWN || conn_status == CVY_CONN_RESET)
{
/* if connection was dirty, just block the packet since TCP/IP may have
stale connection state for a previous connection from another host
(v1.32B) */
if (ep->dirty)
{
LOCK_EXIT(&(lp->lock), irql);
#ifdef TRACE_DIRTY
DbgPrint ("blocking dirty FIN from %d to %d\n", client_port, svr_port);
#endif
return FALSE;
}
/* ###### fin count added for keynote - ramkrish. */
/* if first fin, then only increment the count and return TRUE */
if (conn_status == CVY_CONN_DOWN && ep->fin_count == 0 && is_tcp_pkt)
{
ep->fin_count++;
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
Link_unlink(&(dp->entry.blink));
Link_unlink(&(dp->entry.rlink)); /* V2.1.5 */
Link_unlink(&(dp->link));
Queue_enq(&(lp->conn_freeq), &(dp->link));
}
break;
}
}
}
/* if we see a new connection, handle it */
if (conn_status == CVY_CONN_UP)
{
/* if we don't have a connection match, setup a new connection entry */
if (!match)
{
/* if hash entry table is not available, setup and enqueue a new entry */
if (CVY_CONN_IN_USE(ep))
{
dp = (PCONN_DESCR)Queue_deq(&(lp->conn_freeq));
if (dp == NULL)
{
/* allocate new queue descriptors if allowed */
if (lp->nqalloc < lp->max_dscr_allocs)
{
UNIV_PRINT(("Load_conn_advise: %d/%d allocating %d descriptors", lp->nqalloc, lp->max_dscr_allocs, lp->dscr_per_alloc));
lp->qalloc_list[lp->nqalloc] = /* (bbain 2/25/99) */
dp = (PCONN_DESCR)malloc((lp->dscr_per_alloc) * sizeof(CONN_DESCR));
if (dp != NULL)
{
ULONG i;
PCONN_DESCR tp;
QUEUE * fqp;
lp->nqalloc++;
/* initialize and link up descriptors; save first descriptor
for our use */
dp->code = CVY_DESCCODE; /* (bbain 8/19/99) */
Link_init(&(dp->link));
ep = &(dp->entry); /* (bbain 8/21/99) */
ep->code = CVY_ENTRCODE; /* (bbain 8/19/99) */
ep->alloc = TRUE;
ep->dirty = FALSE; /* v1.32B */
CVY_CONN_CLEAR(&(dp->entry));
Link_init(&(dp->entry.blink));
Link_init(&(dp->entry.rlink)); /* V2.1.5 */
tp = dp + 1;
fqp = &(lp->conn_freeq);
for (i=1; i<lp->dscr_per_alloc; i++)
{
tp->code = CVY_DESCCODE; /* (bbain 8/19/99) */
Link_init(&(tp->link));
tp->entry.code = CVY_ENTRCODE; /* (bbain 8/19/99) */
tp->entry.alloc = TRUE;
tp->entry.dirty = FALSE; /* v1.32B */
CVY_CONN_CLEAR(&(tp->entry));
Link_init(&(tp->entry.blink));
Link_init(&(tp->entry.rlink)); /* V2.1.5 */
Queue_enq(fqp, &(tp->link));
tp++;
}
}
else
{
if (!(lp->alloc_failed))
{
UNIV_PRINT(("Load_conn_advise: error allocating conn descrs"));
LOG_MSG(MSG_ERROR_MEMORY, MSG_NONE);
lp->alloc_failed = TRUE;
}
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
}
else
{
/* V2.1.5 - if reached allocation limit - start taking
connection descriptors from the recover queue since
they are likely to be stale and very old */
PBIN_STATE rbp;
LINK * rlp;
#ifdef TRACE_RCVRY
DbgPrint ("Host %d: taking connection from recovery queue\n", lp->my_host_id);
#endif
rlp = (LINK *)Queue_deq(&(lp->conn_rcvryq));
UNIV_ASSERT (rlp != NULL);
/* this should not happen at all but protect anyway */
if (rlp == NULL)
{
if (!(lp->alloc_inhibited))
{
UNIV_PRINT(("Host %d: cannot allocate conn descriptors.", lp->my_host_id));
LOG_MSG(MSG_WARN_DESCRIPTORS, CVY_NAME_MAX_DSCR_ALLOCS);
lp->alloc_inhibited = TRUE;
}
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
ep = STRUCT_PTR(rlp, CONN_ENTRY, rlink);
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/19/99) */
/* fixed for nt4/sp5 */
if (ep->alloc)
{
/* unlink allocated descriptors from the hash table
queue if necessary and set dp so that code below
will put it back in the right hash queue */
dp = STRUCT_PTR(ep, CONN_DESCR, entry);
UNIV_ASSERT (dp->code == CVY_DESCCODE); /* (bbain 8/19/99) */
Link_unlink(&(dp->link));
}
else
{
dp = NULL; /* (bbain 8/21/99) */
}
/* dirty connections are not counted */
if (! ep->dirty)
{
/* find out which port group we are on so we can clean
up its counters */
rbp = Load_pg_lookup(lp, ep->svr_ipaddr, ep->svr_port, is_tcp_pkt);
/* correct bad (negative) bin count */
if (lp->nconn <= 0)
lp->nconn = 0;
else
lp->nconn--;
if (rbp->nconn[ep->bin] <= 0)
rbp->nconn[ep->bin] = 0;
else
{
rbp->nconn[ep->bin]--;
}
if (rbp->tconn <= 0)
rbp->tconn = 0;
else
rbp->tconn--;
if (rbp->nconn[ep->bin] == 0)
{
rbp->idle_bins |= (((MAP_T) 1) << ep->bin);
}
}
Link_unlink(&(ep->blink));
CVY_CONN_CLEAR(ep);
ep->dirty = FALSE;
}
}
/* else dp is not NULL, so setup entry pointer */
else
{
ep = &(dp->entry);
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/21/99) */
}
/* enqueue descriptor in hash table unless it's already a hash table entry
(V2.1.5 recovered connection might be in hash table, so make
sure we do not end up queueing it) */
if (dp != NULL)
{
UNIV_ASSERT (dp->code == CVY_DESCCODE); /* (bbain 8/19/99) */
/* enqueue new queue descriptor and setup entry pointer */
Queue_enq(qp, &(dp->link));
}
}
/* setup new entry */
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/21/99) */
CVY_CONN_SET(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol);
ep->bin = (UCHAR)bin;
/* ###### fin count added for keynote - ramkrish */
/* initialize the fin count to 0 for a new connection */
ep->fin_count = 0;
/* enqueue entry into port group queue */
Queue_enq(&(bp->connq), &(ep->blink));
/* V2.1.5 add entry to the tail of connection recovery queue */
Queue_enq(&(lp->conn_rcvryq), &(ep->rlink));
/* increment # connections and mark bin not idle if necessary */
lp->nconn++; /* v2.1 */
bp->tconn++;
bp->nconn[bin]++;
if (bp->nconn[bin] == 1)
bp->idle_bins &= ~(((MAP_T) 1) << bin);
#ifdef TRACE_LOAD
DbgPrint("Host %d: advise starts conn; rule %d bin %d nconn %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin]);
#endif
}
/* otherwise, we have a match; clean up conn entry if dirty since we have a
new connection, although TCP/IP will likely reject it if it has stale state
from another connection (v1.32B) */
else
{
if (ep->dirty)
{
#ifdef TRACE_DIRTY
DbgPrint ("converting dirty SYN from %d to %d\n", client_port, svr_port);
#endif
UNIV_ASSERT (ep->code == CVY_ENTRCODE); /* (bbain 8/21/99) */
ep->dirty = FALSE;
/* ###### initialize fin count for this new connection added for keynote - ramkrish */
/* ###### since we are reusing a dirty connection desc for a new conn., it needs to be reset */
ep->fin_count = 0;
UNIV_ASSERT (ep->bin == (USHORT)bin);
/* unlink and enqueue entry into port group queue */
Link_unlink(&(ep->blink));
Queue_enq(&(bp->connq), &(ep->blink));
/* increment # connections and mark bin not idle if necessary */
lp->nconn++; /* v2.1 */
bp->tconn++;
bp->nconn[bin]++;
if (bp->nconn[bin] == 1)
bp->idle_bins &= ~(((MAP_T) 1) << bin);
}
}
}
/* otherwise, if a known connection is going down, remove our connection entry */
/* ###### check for reset addded for keynote - ramkrish */
else if ((conn_status == CVY_CONN_DOWN || conn_status == CVY_CONN_RESET) && match)
{
/* if connection was dirty, just block the packet since TCP/IP may have stale
connection state for a previous connection from another host (v1.32B) */
if (ep->dirty)
{
LOCK_EXIT(&(lp->lock), irql);
#ifdef TRACE_DIRTY
DbgPrint ("blocking dirty FIN from %d to %d\n", client_port, svr_port);
#endif
return FALSE;
}
/* ###### fin count added for keynote - ramkrish */
/* if this is the first fin, then simply increment the fincount and return */
if (conn_status == CVY_CONN_DOWN && ep->fin_count == 0 && is_tcp_pkt)
{
ep->fin_count++;
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
}
/* clear hash table entry if we had a hit; enqueued entry was already freed */
if (hit)
{
CVY_CONN_CLEAR(ep);
/* ###### clear fin count for keynote - ramkrish */
ep->fin_count = 0;
Link_unlink(&(ep->rlink)); /* V2.1.5 */
Link_unlink(&(ep->blink));
}
/* decrement # connections and mark bin idle if necessary */
#if 0
if (bp->nconn[bin] <= 0)
DbgPrint("WLBS: Load_conn_advise: count was zero %d %d\n", bin, bp->nconn[bin]);
#endif
UNIV_ASSERT(bp->nconn[bin] > 0 && bp->tconn > 0 && lp->nconn > 0);
if (lp->nconn <= 0) /* v2.1 */
lp->nconn = 0;
else
lp->nconn--;
if (bp->nconn[bin] <= 0) /* correct bad (negative) bin count */
bp->nconn[bin] = 0;
else
bp->nconn[bin]--;
if (bp->tconn <= 0)
bp->tconn = 0;
else
bp->tconn--;
if (bp->nconn[bin] == 0)
{
bp->idle_bins |= (((MAP_T) 1) << bin);
}
#ifdef TRACE_LOAD
DbgPrint("Host %d: advise removes conn; rule %d bin %d nconn %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin]);
#endif
}
else
{
LOCK_EXIT(&(lp->lock), irql);
return FALSE;
}
LOCK_EXIT(&(lp->lock), irql);
return TRUE;
} /* end Load_conn_advise */
/*
* Function: Load_create_dscr
* Desctription:
* Parameters:
* Returns:
* Author: shouse, 5.18.01
* Notes:
*/
BOOLEAN Load_create_dscr(
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
ULONG client_ipaddr,
ULONG client_port,
USHORT protocol,
BOOLEAN limit_map_fn)
{
BOOLEAN match = FALSE; /* TRUE => we have a record of this connection. */
ULONG id; /* Hash index for the connection. */
ULONG bin; /* Bin index. */
PBIN_STATE bp; /* Pointer to bin state. */
PCONN_ENTRY ep; /* Pointer to connection entry. */
PCONN_DESCR dp; /* Pointer to connection descriptor. */
QUEUE * qp; /* Pointer to connection queue. */
PMAIN_CTXT ctxtp = CONTAINING_RECORD(lp, MAIN_CTXT, load);
BOOLEAN is_tcp_pkt = (protocol == TCPIP_PROTOCOL_TCP);
UNIV_ASSERT(lp->code == CVY_LOADCODE);
if (!lp->active)
return FALSE;
/* Increment count of packets handled. */
lp->pkt_count++;
/* Find the port rule for this connection. */
bp = Load_pg_lookup(lp, svr_ipaddr, svr_port, is_tcp_pkt);
/* Hash. */
if (limit_map_fn) {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, MAP_FN_PARAMETER);
} else {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, ((svr_port << 16) + client_port));
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, svr_ipaddr);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, svr_ipaddr);
}
/* Hash client address to bin id and connection hash table index. */
bin = id % CVY_MAXBINS;
id = id % CVY_MAX_CHASH;
/* Get a pointer to the connection entry for this hash ID. */
ep = &(lp->hashed_conn[id]);
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
/* Get a pointer to the conneciton queue. */
qp = &(lp->connq[id]);
if (CVY_CONN_MATCH(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
/* Note that we found a match for this tuple. */
match = TRUE;
} else {
for (dp = (PCONN_DESCR)Queue_front(qp); dp != NULL; dp = (PCONN_DESCR)Queue_next(qp, &(dp->link))) {
if (CVY_CONN_MATCH(&(dp->entry), svr_ipaddr, svr_port, client_ipaddr, client_port, protocol))
{
/* Note that we found a match for this tuple. */
match = TRUE;
UNIV_ASSERT (dp->code == CVY_DESCCODE);
/* Get a pointer to the connection entry. */
ep = &(dp->entry);
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
break;
}
}
}
/* If we don't have a connection match, setup a new connection entry. */
if (!match) {
/* If hash entry table is not available, setup and enqueue a new entry. */
if (CVY_CONN_IN_USE(ep)) {
/* Get a pointer to a free descriptor. */
dp = (PCONN_DESCR)Queue_deq(&(lp->conn_freeq));
if (dp == NULL) {
/* Allocate new queue descriptors if allowed. */
if (lp->nqalloc < lp->max_dscr_allocs) {
UNIV_PRINT(("Load_create_dscr: %d/%d allocating %d descriptors", lp->nqalloc, lp->max_dscr_allocs, lp->dscr_per_alloc));
dp = lp->qalloc_list[lp->nqalloc] = (PCONN_DESCR)malloc((lp->dscr_per_alloc) * sizeof(CONN_DESCR));
if (dp != NULL) {
ULONG i;
PCONN_DESCR tp;
QUEUE * fqp;
/* Increment the counter for number of allocations. */
lp->nqalloc++;
/* Initialize and link up descriptors; save first descriptor for our use. */
dp->code = CVY_DESCCODE;
Link_init(&(dp->link));
/* Initialize the connection entry. */
ep = &(dp->entry);
ep->code = CVY_ENTRCODE;
ep->alloc = TRUE;
ep->dirty = FALSE;
/* Mark this entry unused. */
CVY_CONN_CLEAR(&(dp->entry));
Link_init(&(dp->entry.blink));
Link_init(&(dp->entry.rlink));
tp = dp + 1;
fqp = &(lp->conn_freeq);
/* Initialize all descriptors and tack them on the free queue. */
for (i = 1; i < lp->dscr_per_alloc; i++, tp++) {
/* Initialize the descriptor. */
tp->code = CVY_DESCCODE;
Link_init(&(tp->link));
/* Initialize the connection entry. */
tp->entry.code = CVY_ENTRCODE;
tp->entry.alloc = TRUE;
tp->entry.dirty = FALSE;
/* Mark this entry unused. */
CVY_CONN_CLEAR(&(tp->entry));
Link_init(&(tp->entry.blink));
Link_init(&(tp->entry.rlink));
/* Queue the descriptor onto the free queue. */
Queue_enq(fqp, &(tp->link));
}
} else {
/* Allocation failed, log a message and bail out. */
if (!(lp->alloc_failed)) {
UNIV_PRINT(("Load_conn_advise: error allocating conn descrs"));
LOG_MSG(MSG_ERROR_MEMORY, MSG_NONE);
lp->alloc_failed = TRUE;
}
return FALSE;
}
} else {
/* If we have reached the allocation limit, start taking connection descriptors
from the recover queue since they are likely to be stale and very old. */
PBIN_STATE rbp;
LINK * rlp;
#ifdef TRACE_RCVRY
DbgPrint ("Host %d: taking connection from recovery queue\n", lp->my_host_id);
#endif
/* Dequeue a descriptor from the recovery queue. */
rlp = (LINK *)Queue_deq(&(lp->conn_rcvryq));
UNIV_ASSERT (rlp != NULL);
/* This should not happen at all but protect anyway. */
if (rlp == NULL) {
/* Unable to get a descriptor, log a message and bail out. */
if (!(lp->alloc_inhibited)) {
UNIV_PRINT(("Host %d: cannot allocate conn descriptors.", lp->my_host_id));
LOG_MSG(MSG_WARN_DESCRIPTORS, CVY_NAME_MAX_DSCR_ALLOCS);
lp->alloc_inhibited = TRUE;
}
return FALSE;
}
/* Grab a pointer to the connection entry. */
ep = STRUCT_PTR(rlp, CONN_ENTRY, rlink);
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
if (ep->alloc) {
/* Unlink allocated descriptors from the hash table queue if necessary
and set dp so that code below will put it back in the right hash queue. */
dp = STRUCT_PTR(ep, CONN_DESCR, entry);
UNIV_ASSERT (dp->code == CVY_DESCCODE);
Link_unlink(&(dp->link));
} else {
dp = NULL;
}
/* Dirty connections are not counted, so we don't need to update these counters. */
if (! ep->dirty) {
/* Find out which port group we are on so we can clean up its counters. */
rbp = Load_pg_lookup(lp, ep->svr_ipaddr, ep->svr_port, is_tcp_pkt);
if (lp->nconn <= 0)
lp->nconn = 0;
else
lp->nconn--;
if (rbp->nconn[ep->bin] <= 0)
rbp->nconn[ep->bin] = 0;
else
rbp->nconn[ep->bin]--;
if (rbp->tconn <= 0)
rbp->tconn = 0;
else
rbp->tconn--;
if (rbp->nconn[ep->bin] == 0)
rbp->idle_bins |= (((MAP_T) 1) << ep->bin);
}
Link_unlink(&(ep->blink));
/* Mark the descriptor as unused. */
CVY_CONN_CLEAR(ep);
/* Makr the descriptor as clean. */
ep->dirty = FALSE;
}
} else {
/* There was a free descriptor, so setup the connection entry pointer. */
ep = &(dp->entry);
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
}
/* Enqueue descriptor in hash table unless it's already a hash table entry (a recovered
connection might be in hash table, so make sure we do not end up queueing it) */
if (dp != NULL) {
UNIV_ASSERT (dp->code == CVY_DESCCODE);
Queue_enq(qp, &(dp->link));
}
}
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
/* Setup a new entry. */
CVY_CONN_SET(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol);
ep->bin = (UCHAR)bin;
/* Initialize the fin count to 0 for a new connection. */
ep->fin_count = 0;
/* Enqueue entry into port group queue. */
Queue_enq(&(bp->connq), &(ep->blink));
/* Add entry to the tail of connection recovery queue. */
Queue_enq(&(lp->conn_rcvryq), &(ep->rlink));
/* Increment number of connections and mark bin not idle if necessary. */
lp->nconn++;
bp->tconn++;
bp->nconn[bin]++;
if (bp->nconn[bin] == 1) bp->idle_bins &= ~(((MAP_T) 1) << bin);
#ifdef TRACE_LOAD
DbgPrint("Host %d: advise starts conn; rule %d bin %d nconn %d\n",
lp->my_host_id, bp->index, bin, bp->nconn[bin]);
#endif
} else {
/* We have a match. Clean up connection entry if it's dirty since we have a new connection,
although TCP/IP will likely reject it if it has stale state from another connection. */
if (ep->dirty) {
#ifdef TRACE_DIRTY
DbgPrint ("converting dirty SYN from %d to %d\n", client_port, svr_port);
#endif
UNIV_ASSERT (ep->code == CVY_ENTRCODE);
ep->dirty = FALSE;
ep->fin_count = 0;
UNIV_ASSERT (ep->bin == (USHORT)bin);
/* Unlink and enqueue entry into port group queue. */
Link_unlink(&(ep->blink));
Queue_enq(&(bp->connq), &(ep->blink));
/* Increment # connections and mark bin not idle if necessary. */
lp->nconn++;
bp->tconn++;
bp->nconn[bin]++;
if (bp->nconn[bin] == 1) bp->idle_bins &= ~(((MAP_T) 1) << bin);
}
}
return TRUE;
}
ULONG Load_port_change(
PLOAD_CTXT lp,
ULONG ipaddr,
ULONG port,
ULONG cmd,
ULONG value)
{
PCVY_RULE rp; /* Pointer to configured port rules. */
PBIN_STATE bp; /* Pointer to load module port rule state. */
ULONG nrules; /* Number of rules. */
ULONG i;
ULONG ret = IOCTL_CVY_NOT_FOUND;
PMAIN_CTXT ctxtp = CONTAINING_RECORD(lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE);
if (! lp->active)
return IOCTL_CVY_NOT_FOUND;
rp = (* (lp->params)).port_rules;
/* If we are draining whole cluster, include DEFAULT rule; Otherwise, just
include the user-defined rules (the DEFAULT rule is the last rule). */
if (cmd == IOCTL_CVY_CLUSTER_DRAIN || cmd == IOCTL_CVY_CLUSTER_PLUG)
nrules = (* (lp->params)).num_rules + 1;
else
nrules = (* (lp->params)).num_rules;
for (i=0; i<nrules; i++, rp++)
{
/* If the virtual IP address is IOCTL_ALL_VIPS (0x00000000), then we are applying this
change to all port rules for port X, regardless of VIP. If the virtual IP address is
to be applied to a particular VIP, then we apply only to port rules whose VIP matches.
Similarly, if the change is to apply to an "ALL VIP" rule, then we also apply when the
VIP matches because the caller uses CVY_ALL_VIP_NUMERIC_VALUE (0xffffffff) as the
virtual IP address, which is the same value stored in the port rule state. */
if ((ipaddr == IOCTL_ALL_VIPS || ipaddr == rp->virtual_ip_addr) &&
(port == IOCTL_ALL_PORTS || (port >= rp->start_port && port <= rp->end_port)))
{
bp = &(lp->pg_state[i]);
UNIV_ASSERT(bp->code == CVY_BINCODE); /* (bbain 8/19/99) */
/* If enabling a port rule, set the load amount to original value;
If disabling a port rule, set the load amount to zero;
Otherwise, set the load amount it to the specified amount. */
if (cmd == IOCTL_CVY_PORT_ON || cmd == IOCTL_CVY_CLUSTER_PLUG)
{
if (bp->load_amt[lp->my_host_id] == bp->orig_load_amt)
{
/* If we are the first port rule to match, then set the
return value to "Already"; Otherwise, we don't want to
overwrite some other port rule's return value of "OK"
in the case of ALL_VIPS or ALL_PORTS. */
if (ret == IOCTL_CVY_NOT_FOUND) ret = IOCTL_CVY_ALREADY;
continue;
}
/* Restore the original load amount. */
bp->load_amt[lp->my_host_id] = bp->orig_load_amt;
ret = IOCTL_CVY_OK;
}
else if (cmd == IOCTL_CVY_PORT_OFF)
{
if (bp->load_amt[lp->my_host_id] == 0)
{
/* If we are the first port rule to match, then set the
return value to "Already"; Otherwise, we don't want to
overwrite some other port rule's return value of "OK"
in the case of ALL_VIPS or ALL_PORTS. */
if (ret == IOCTL_CVY_NOT_FOUND) ret = IOCTL_CVY_ALREADY;
continue;
}
bp->load_amt[lp->my_host_id] = 0;
/* Immediately stop handling all traffic on the port group. */
bp->cmap = 0;
bp->cur_map[lp->my_host_id] = 0;
Load_conn_kill(lp, bp);
ret = IOCTL_CVY_OK;
}
else if (cmd == IOCTL_CVY_PORT_DRAIN || cmd == IOCTL_CVY_CLUSTER_DRAIN)
{
if (bp->load_amt[lp->my_host_id] == 0)
{
/* If we are the first port rule to match, then set the
return value to "Already"; Otherwise, we don't want to
overwrite some other port rule's return value of "OK"
in the case of ALL_VIPS or ALL_PORTS. */
if (ret == IOCTL_CVY_NOT_FOUND) ret = IOCTL_CVY_ALREADY;
continue;
}
/* Set load weight to zero, but continue to handle existing connections. */
bp->load_amt[lp->my_host_id] = 0;
ret = IOCTL_CVY_OK;
}
else
{
UNIV_ASSERT(cmd == IOCTL_CVY_PORT_SET);
if (bp->load_amt[lp->my_host_id] == value)
{
/* If we are the first port rule to match, then set the
return value to "Already"; Otherwise, we don't want to
overwrite some other port rule's return value of "OK"
in the case of ALL_VIPS or ALL_PORTS. */
if (ret == IOCTL_CVY_NOT_FOUND) ret = IOCTL_CVY_ALREADY;
continue;
}
/* Set the load weight for this port rule. */
bp->orig_load_amt = value;
bp->load_amt[lp->my_host_id] = value;
ret = IOCTL_CVY_OK;
}
if (port != IOCTL_ALL_PORTS && ipaddr != IOCTL_ALL_VIPS) break;
}
}
/* If the cluster isn't already converging, then initiate convergence if the load weight of a port rule has been modified. */
if (lp->send_msg.state != HST_CVG && ret == IOCTL_CVY_OK) {
WCHAR me[20];
Univ_ulong_to_str (lp->my_host_id+1, me, 10);
/* Tracking convergence - Starting convergence because our port rule configuration has changed. */
LOG_MSGS(MSG_INFO_CONVERGING_NEW_RULES, me, me);
TRACE_CONVERGENCE("Initiating convergence on host %d. Reason: Host %d has changed its port rule configuration.", lp->my_host_id+1, lp->my_host_id+1);
/* Tracking convergence. */
Load_convergence_start(lp);
}
return ret;
} /* end Load_port_change */
ULONG Load_hosts_query(
PLOAD_CTXT lp,
BOOLEAN internal,
PULONG host_map)
{
WCHAR buf1 [256];
WCHAR buf2 [256];
PWCHAR ptr1 = buf1;
PWCHAR ptr2 = buf2;
WCHAR num [20]; /* v2.1 */
WCHAR msk [33];
ULONG i, j, k;
PMAIN_CTXT ctxtp = CONTAINING_RECORD (lp, MAIN_CTXT, load);
UNIV_ASSERT(lp->code == CVY_LOADCODE); /* (bbain 8/19/99) */
buf1 [0] = 0;
buf2 [0] = 0;
msk [0] = 0;
num [0] = 0;
for (i = 0, j = 0; i < 16; i++)
{
if (lp -> host_map & (1 << i))
{
ptr1 = Univ_ulong_to_str (i + 1, ptr1, 10);
* ptr1 = L',';
ptr1 ++;
j ++;
msk [i] = L'1';
}
else
msk [i] = L'0';
}
for (i = 16, k = 0; i < 32; i++)
{
if (lp -> host_map & (1 << i))
{
ptr2 = Univ_ulong_to_str (i + 1, ptr2, 10);
* ptr2 = L',';
ptr2 ++;
k ++;
msk [i] = L'1';
}
else
msk [i] = L'0';
}
if (k)
{
ptr2 --;
// * ptr2 = L'.';
// ptr2 ++;
}
else if (j)
{
ptr1 --;
// * ptr1 = L'.';
// ptr1 ++;
}
* ptr1 = 0;
* ptr2 = 0;
* host_map = lp->host_map;
Univ_ulong_to_str ((* (lp->params)) . host_priority, num, 10); /* v2.1 */
if (lp->send_msg.state != HST_NORMAL)
{
UNIV_PRINT (("current host map is %08x and converging", lp->host_map));
if (internal) /* 1.03 */
{
LOG_MSGS3 (MSG_INFO_CONVERGING, num, buf1, buf2);
}
return IOCTL_CVY_CONVERGING;
}
/* if this host has the bins for the deafult rule, it is the default host (v2.1) */
else if (lp->pg_state[(* (lp->params)).num_rules].cmap != 0)
{
UNIV_PRINT (("current host map is %08x and converged as DEFAULT", lp->host_map));
if (internal) /* 1.03 */
{
LOG_MSGS3(MSG_INFO_MASTER, num, buf1, buf2);
}
return IOCTL_CVY_MASTER;
}
else
{
UNIV_PRINT (("current host map is %08x and converged (NON-DEFAULT)", lp->host_map));
if (internal) /* 1.03 */
{
LOG_MSGS3(MSG_INFO_SLAVE, num, buf1, buf2);
}
return IOCTL_CVY_SLAVE;
}
} /* end Load_hosts_query */
/*
* Function: Load_query_packet_filter
* Desctription:
* Parameters:
* Returns:
* Author: shouse, 5.18.01
* Notes:
*/
VOID Load_query_packet_filter (
PIOCTL_QUERY_STATE_PACKET_FILTER pQuery,
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
ULONG client_ipaddr,
ULONG client_port,
USHORT protocol,
BOOLEAN limit_map_fn)
{
PBIN_STATE bp;
ULONG id;
ULONG bin;
QUEUE * qp;
/* This variable is used for port rule lookup and since the port rules only cover
UDP and TCP, we categorize as TCP and non-TCP, meaning that any protocol that's
not TCP will be treated like UDP for the sake of port rule lookup. */
BOOLEAN is_tcp_pkt = (protocol == TCPIP_PROTOCOL_TCP);
/* Further, some protocols are treated with "session" semantics, while others are
not. For TCP, this "session" is currently a single TCP connection, which is
tracked from SYN to FIN using a connection descriptor. IPSec "sessions" are
also tracked using descriptors, so even though its treated like UDP for port
rule lookup, its treated with the session semantics resembling TCP. Therefore,
by default the determination of a session packet is initially the same as the
determination of a TCP packet. */
BOOLEAN is_session_pkt = is_tcp_pkt;
/* If we have enabled IPSec session tracking, then if the protocol is IPSec, this
packet should also be treated as part of an existing session. */
if (NLB_IPSEC_SESSION_SUPPORT_ENABLED() && (protocol == TCPIP_PROTOCOL_IPSEC1)) is_session_pkt = TRUE;
UNIV_ASSERT(lp->code == CVY_LOADCODE);
/* If the load module has been "turned off", then we drop the packet. */
if (!lp->active) {
pQuery->Results.Accept = NLB_REJECT_LOAD_MODULE_INACTIVE;
return;
}
/* Find the port rule for this server IP address / port pair. */
bp = Load_pg_lookup(lp, svr_ipaddr, svr_port, is_tcp_pkt);
UNIV_ASSERT ((is_tcp_pkt && bp->prot != CVY_UDP) || (!is_tcp_pkt && bp->prot != CVY_TCP));
/* If the matching port rule is configured as "disabled", which means to drop any
packets that match the rule, then we drop the packet. */
if (bp->mode == CVY_NEVER) {
pQuery->Results.Accept = NLB_REJECT_PORT_RULE_DISABLED;
return;
}
/* Apply the NLB hashing algorithm on the client identification. If for reasons
such as BDA teaming, we have chosen to limit the map function, we hard code the
second parameter, rather than use some of the server identification in an
effort to make the processing of this packet agnostic to the server identity.
The hashing parameters also, of course, depend on the configured afffinity
settings for the retrieved port rule. */
if (limit_map_fn) {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, MAP_FN_PARAMETER);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, MAP_FN_PARAMETER);
} else {
if (bp->affinity == CVY_AFFINITY_NONE)
id = Map(client_ipaddr, ((svr_port << 16) + client_port));
else if (bp->affinity == CVY_AFFINITY_SINGLE)
id = Map(client_ipaddr, svr_ipaddr);
else
id = Map(client_ipaddr & TCPIP_CLASSC_MASK, svr_ipaddr);
}
/* Find the applicable "bucket" by a modulo operation on the number of bins, 60. */
bin = id % CVY_MAXBINS;
/* At this point, we can begin providing the requestee some actual information about
the state of the load module to better inform them as to why the decision we return
them was actually made. Here will provide some appropriate information about the
port rule we are operating on, including the "bucket" ID, the current "bucket"
ownership map and the number of connections active on this "bucket". */
pQuery->Results.HashInfo.Valid = TRUE;
pQuery->Results.HashInfo.Bin = bin;
pQuery->Results.HashInfo.CurrentMap = bp->cmap;
pQuery->Results.HashInfo.AllIdleMap = bp->all_idle_map;
pQuery->Results.HashInfo.ActiveConnections = bp->nconn[bin];
/* check bin for residency and all other hosts now idle on their bins; in this
case and if we do not have dirty connections, we must be able to handle the packet */
/* If we currently own the "bucket" to which this connection maps and either NLB provides
no session support for this protocol, or all other hosts have no exisitng connections
on this "bucket" and we have no dirty connections, then we can safely take the packet
with no regard to the connection (session) descriptors. */
if (((bp->cmap & (((MAP_T) 1) << bin)) != 0) && (!is_session_pkt || (((bp->all_idle_map & (((MAP_T) 1) << bin)) != 0) && (!(lp->cln_waiting))))) {
pQuery->Results.Accept = NLB_ACCEPT_UNCONDITIONAL_OWNERSHIP;
return;
/* Otherwise, if there are active connections on this "bucket" or if we own the
"bucket" and there are dirty connections on it, then we'll walk our descriptor
lists to determine whether or not we should take the packet or not. */
} else if (bp->nconn[bin] > 0 || (lp->cln_waiting && lp->dirty_bin[bin] && ((bp->cmap & (((MAP_T) 1) << bin)) != 0))) {
PCONN_ENTRY ep;
PCONN_DESCR dp;
/* Calculate our index into the descriptor hash table by a modulo operation on the
length of the static descriptor array, 4096. */
id = id % CVY_MAX_CHASH;
/* Grab a pointer to the descriptor in our spot in the hash table. */
ep = &(lp->hashed_conn[id]);
/* Grab a pointer to our assigned queue of descriptors - our second level hashing. */
qp = &(lp->connq[id]);
/* First look for a match in the first-level hashing array. */
if (CVY_CONN_MATCH(ep, svr_ipaddr, svr_port, client_ipaddr, client_port, protocol)) {
/* If we find a match in the static hash table, fill in some descriptor
information for the user, including whether or not the descriptor was
allocated or static (static is this case) and the observed FIN count. */
pQuery->Results.DescriptorInfo.Valid = TRUE;
pQuery->Results.DescriptorInfo.Alloc = ep->alloc;
pQuery->Results.DescriptorInfo.Dirty = ep->dirty;
pQuery->Results.DescriptorInfo.FinCount = ep->fin_count;
/* If the connection is dirty, we do not take the packet because TCP may
have stale information for this descriptor. */
if (ep->dirty) {
pQuery->Results.Accept = NLB_REJECT_CONNECTION_DIRTY;
return;
}
/* If the connection is not dirty, we'll take the packet, as it belongs
to an existing connection that we are servicing on this host. */
pQuery->Results.Accept = NLB_ACCEPT_FOUND_MATCHING_DESCRIPTOR;
return;
/* Otherwise, we have to walk the second-level hashing linked list of connection
(session) descriptors looking for a match. */
} else {
/* Walk the queue until we reach the end or find what we're looking for. */
for (dp = (PCONN_DESCR)Queue_front(qp); dp != NULL; dp = (PCONN_DESCR)Queue_next(qp, &(dp->link))) {
if (CVY_CONN_MATCH(&(dp->entry), svr_ipaddr, svr_port, client_ipaddr, client_port, protocol)) {
/* If we find a match in the static hash table, fill in some descriptor
information for the user, including whether or not the descriptor was
allocated or static (allocated is this case) and the observed FIN count. */
pQuery->Results.DescriptorInfo.Valid = TRUE;
pQuery->Results.DescriptorInfo.Alloc = dp->entry.alloc;
pQuery->Results.DescriptorInfo.Dirty = dp->entry.dirty;
pQuery->Results.DescriptorInfo.FinCount = dp->entry.fin_count;
/* If the connection is dirty, we do not take the packet because TCP may
have stale information for this descriptor. */
if (dp->entry.dirty) {
pQuery->Results.Accept = NLB_REJECT_CONNECTION_DIRTY;
return;
}
/* If the connection is not dirty, we'll take the packet, as it belongs
to an existing connection that we are servicing on this host. */
pQuery->Results.Accept = NLB_ACCEPT_FOUND_MATCHING_DESCRIPTOR;
return;
}
}
}
}
/* If we get all the way down here, then we aren't going to accept the packet
because we do not own the "bucket" to which the packet maps and we have no
existing connection (session) state to allow us to service the packet. */
pQuery->Results.Accept = NLB_REJECT_OWNED_ELSEWHERE;
return;
}
#if defined (SBH)
/*
* Function: Load_packet_filter
* Desctription:
* Parameters:
* Returns:
* Author: shouse, 5.18.01
* Notes:
*/
BOOLEAN Load_packet_filter (
PLOAD_CTXT lp,
ULONG svr_ipaddr,
ULONG svr_port,
ULONG client_ipaddr,
ULONG client_port,
USHORT protocol,
ULONG conn_status,
BOOLEAN limit_map_fn)
{
BIN_LOOKUP();
HASH();
switch (conn_status) {
case CVY_CONN_CREATE:
CREATE_DSCR();
break;
case CVY_CONN_UP:
CREATE_DSCR();
break;
case CVY_CONN_DOWN:
case CVY_CONN_RESET:
REMOVE_DSCR();
break;
case CVY_CONN_DATA:
// protocol dependent.
CHECK_HASH();
SEARCH_QUEUE();
break;
}
}
#endif
Reference in a new issue Copy permalink