/*!
* \brief Call this after getting back a #UNOTSYNC.
*
* \note Getting a #UNOTSYNC error code back does \b not guarantee
* that there is a sync site yet elected. However, if there is a sync
* site out there somewhere, and you're trying an operation that
* requires a sync site, ubik will return #UNOTSYNC, indicating the
* operation won't work until you find a sync site
*/
static int
try_GetSyncSite(struct ubik_client *aclient, afs_int32 apos)
{
struct rx_peer *rxp;
afs_int32 code;
int i;
afs_int32 thisHost, newHost;
struct rx_connection *tc;
short origLevel;
origLevel = aclient->initializationState;
/* get this conn */
tc = aclient->conns[apos];
if (tc && rx_ConnError(tc)) {
aclient->conns[apos] = (tc = ubik_RefreshConn(tc));
}
if (!tc) {
return -1;
}
/* now see if we can find the sync site host */
code = VOTE_GetSyncSite(tc, &newHost);
if (aclient->initializationState != origLevel) {
return -1; /* somebody did a ubik_ClientInit */
}
if (!code && newHost) {
newHost = htonl(newHost); /* convert back to network order */
/*
* position count at the appropriate slot in the client
* structure and retry. If we can't find in slot, we'll just
* continue through the whole list
*/
for (i = 0; i < MAXSERVERS; i++) {
rxp = rx_PeerOf(aclient->conns[i]);
thisHost = rx_HostOf(rxp);
if (!thisHost) {
return -1;
} else if (thisHost == newHost) {
return i; /* we were told to use this one */
}
}
}
return -1;
}
/*!
* call this instead of stub and we'll guarantee to find a host that's up.
*
* \todo In the future, we should also put in a protocol to find the sync site.
*/
afs_int32
ubik_Call(int (*aproc) (), struct ubik_client *aclient,
afs_int32 aflags, long p1, long p2, long p3, long p4,
long p5, long p6, long p7, long p8, long p9, long p10,
long p11, long p12, long p13, long p14, long p15, long p16)
{
afs_int32 rcode, code, newHost, thisHost, i, count;
int chaseCount, pass, needsync, inlist, j;
struct rx_connection *tc;
struct rx_peer *rxp;
short origLevel;
if (aflags & UBIK_CALL_NEW)
return ubik_Call_New(aproc, aclient, aflags, p1, p2, p3, p4,
p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
p16);
if (!aclient)
return UNOENT;
LOCK_UBIK_CLIENT(aclient);
restart:
origLevel = aclient->initializationState;
rcode = UNOSERVERS;
chaseCount = inlist = needsync = 0;
LOCK_UCLNT_CACHE;
for (j = 0; ((j < SYNCCOUNT) && calls_needsync[j]); j++) {
if (calls_needsync[j] == (int *)aproc) {
inlist = needsync = 1;
break;
}
}
UNLOCK_UCLNT_CACHE;
/*
* First pass, we try all servers that are up.
* Second pass, we try all servers.
*/
for (pass = 0; pass < 2; pass++) { /*p */
/* For each entry in our servers list */
for (count = 0;; count++) { /*s */
if (needsync) {
/* Need a sync site. Lets try to quickly find it */
if (aclient->syncSite) {
newHost = aclient->syncSite; /* already in network order */
aclient->syncSite = 0; /* Will reset if it works */
} else if (aclient->conns[3]) {
/* If there are fewer than four db servers in a cell,
* there's no point in making the GetSyncSite call.
* At best, it's a wash. At worst, it results in more
* RPCs than you would otherwise make.
*/
tc = aclient->conns[count];
if (tc && rx_ConnError(tc)) {
aclient->conns[count] = tc = ubik_RefreshConn(tc);
}
if (!tc)
break;
code = VOTE_GetSyncSite(tc, &newHost);
if (aclient->initializationState != origLevel)
goto restart; /* somebody did a ubik_ClientInit */
if (code)
newHost = 0;
newHost = htonl(newHost); /* convert to network order */
} else {
newHost = 0;
}
if (newHost) {
/* position count at the appropriate slot in the client
* structure and retry. If we can't find in slot, we'll
* just continue through the whole list
*/
for (i = 0; i < MAXSERVERS && aclient->conns[i]; i++) {
rxp = rx_PeerOf(aclient->conns[i]);
thisHost = rx_HostOf(rxp);
if (!thisHost)
break;
if (thisHost == newHost) {
if (chaseCount++ > 2)
break; /* avoid loop asking */
count = i; /* this index is the sync site */
break;
}
}
}
}
/*needsync */
tc = aclient->conns[count];
if (tc && rx_ConnError(tc)) {
aclient->conns[count] = tc = ubik_RefreshConn(tc);
}
if (!tc)
break;
if ((pass == 0) && (aclient->states[count] & CFLastFailed)) {
continue; /* this guy's down */
}
rcode =
(*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
p12, p13, p14, p15, p16);
if (aclient->initializationState != origLevel) {
/* somebody did a ubik_ClientInit */
if (rcode)
goto restart; /* call failed */
else
goto done; /* call suceeded */
}
if (rcode < 0) { /* network errors */
aclient->states[count] |= CFLastFailed; /* Mark serer down */
} else if (rcode == UNOTSYNC) {
needsync = 1;
} else if (rcode != UNOQUORUM) {
/* either misc ubik code, or misc appl code, or success. */
aclient->states[count] &= ~CFLastFailed; /* mark server up */
goto done; /* all done */
}
} /*s */
} /*p */
done:
if (needsync) {
if (!inlist) { /* Remember proc call that needs sync site */
LOCK_UCLNT_CACHE;
calls_needsync[synccount % SYNCCOUNT] = (int *)aproc;
synccount++;
UNLOCK_UCLNT_CACHE;
inlist = 1;
}
if (!rcode) { /* Remember the sync site - cmd successful */
rxp = rx_PeerOf(aclient->conns[count]);
aclient->syncSite = rx_HostOf(rxp);
}
}
UNLOCK_UBIK_CLIENT(aclient);
return rcode;
}
afs_int32
ubik_Call_SingleServer(int (*aproc) (), struct ubik_client *aclient,
afs_int32 aflags, char *p1, char *p2, char *p3,
char *p4, char *p5, char *p6, char *p7, char *p8,
char *p9, char *p10, char *p11, char *p12, char *p13,
char *p14, char *p15, char *p16)
{
afs_int32 code;
afs_int32 someCode, newHost, thisHost;
afs_int32 i;
afs_int32 count;
int chaseCount;
int pass;
struct rx_connection *tc;
struct rx_peer *rxp;
if ((aflags & (UF_SINGLESERVER | UF_END_SINGLESERVER)) != 0) {
if (((aflags & UF_SINGLESERVER) != 0)
&& ((uServer.ucs_flags & UF_SINGLESERVER) != 0)
) {
/* have a selected server */
tc = aclient->conns[uServer.ucs_selectedServer];
code =
(*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
p12, p13, p14, p15, p16);
if (code) {
/* error. Clean up single server state */
memset(&uServer, 0, sizeof(uServer));
}
return (code);
} else if ((aflags & UF_END_SINGLESERVER) != 0) {
memset(&uServer, 0, sizeof(uServer));
return (0);
}
}
someCode = UNOSERVERS;
chaseCount = 0;
pass = 0;
count = 0;
while (1) { /*w */
/* tc is the next conn to try */
tc = aclient->conns[count];
if (tc == 0) {
if (pass == 0) {
pass = 1; /* in pass 1, we look at down hosts, too */
count = 0;
continue;
} else
break; /* nothing left to try */
}
if (pass == 0 && (aclient->states[count] & CFLastFailed)) {
count++;
continue; /* this guy's down, try someone else first */
}
code =
(*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
p13, p14, p15, p16);
/* note that getting a UNOTSYNC error code back does *not* guarantee
* that there is a sync site yet elected. However, if there is a
* sync site out there somewhere, and you're trying an operation that
* requires a sync site, ubik will return UNOTSYNC, indicating the
* operation won't work until you find a sync site
*/
if (code == UNOTSYNC) { /*ns */
/* means that this requires a sync site to work */
someCode = code; /* remember an error, if this fails */
/* now see if we can find the sync site host */
code = VOTE_GetSyncSite(tc, &newHost);
if (code == 0 && newHost != 0) {
newHost = htonl(newHost); /* convert back to network order */
/* position count at the appropriate slot in the client
* structure and retry. If we can't find in slot, we'll just
* continue through the whole list
*/
for (i = 0; i < MAXSERVERS; i++) { /*f */
rxp = rx_PeerOf(aclient->conns[i]);
if (!(thisHost = rx_HostOf(rxp))) {
count++; /* host not found, try the next dude */
break;
}
if (thisHost == newHost) {
/* avoid asking in a loop */
if (chaseCount++ > 2)
break;
count = i; /* we were told to use this one */
break;
}
} /*f */
} else
count++; /* not directed, keep looking for a sync site */
continue;
} /*ns */
else if (code == UNOQUORUM) { /* this guy is still recovering */
someCode = code;
count++;
continue;
} else if (code < 0) { /* network errors */
someCode = code;
aclient->states[count] |= CFLastFailed;
count++;
continue;
} else {
/* ok, operation worked */
aclient->states[count] &= ~CFLastFailed;
/* either misc ubik code, or misc application code (incl success)
*/
/* if the call succeeded, setup connection state for subsequent
* calls
*/
if ((code == 0)
&& ((aflags & UF_SINGLESERVER) != 0)
) {
/* need to save state */
uServer.ucs_flags = UF_SINGLESERVER;
uServer.ucs_selectedServer = count;
}
return code;
}
} /*w */
return someCode;
}
