unsigned long main_Mod2(void *parm)
{
long i;
for(i=0; i<OSI_MOD2LOOPS; i++) {
osi_Log0(main_logp, "mod2");
lock_ObtainMutex(&main_aMutex);
lock_ObtainWrite(&main_bRWLock);
a += 3;
Sleep(0);
b -= 3;
osi_assert(a+b == 100);
Sleep(0);
lock_ReleaseWrite(&main_bRWLock);
Sleep(0);
lock_ReleaseMutex(&main_aMutex);
Sleep(0);
m2Loops = i;
osi_Log4(main_logp, "mod2 done, %d %d %d %d", m2Loops, 2, 3, 4);
}
lock_ObtainWrite(&main_doneRWLock);
done++;
Sleep(0);
lock_ReleaseWrite(&main_doneRWLock);
return 0;
}
unsigned long main_Mod1(void *parm)
{
long i;
for(i=0; i<OSI_MOD1LOOPS; i++) {
lock_ObtainMutex(&main_aMutex);
osi_Log0(main_logp, "mod1");
lock_ObtainWrite(&main_bRWLock);
a -= 52;
Sleep(0);
b += 52;
osi_assert(a+b == 100);
Sleep(0);
lock_ReleaseWrite(&main_bRWLock);
Sleep(0);
lock_ReleaseMutex(&main_aMutex);
Sleep(0);
m1Loops = i;
osi_Log1(main_logp, "mod1 done, %d", m1Loops);
}
lock_ObtainWrite(&main_doneRWLock);
done++;
Sleep(0);
lock_ReleaseWrite(&main_doneRWLock);
return 0;
}
unsigned long main_Scan2(unsigned long parm)
{
while (1) {
osi_Log0(main_logp, "scan2");
/* check to see if we're done */
lock_ObtainRead(&main_doneRWLock);
lock_AssertAny(&main_doneRWLock);
if (done >= 2) break;
lock_ReleaseRead(&main_doneRWLock);
/* check state for consistency without locks */
if (a+b != 100) s2Events++;
/* and record that we went around again */
s2Loops++;
/* give others a chance */
Sleep(0);
osi_Log3(main_logp, "scan2 done %d %d %d", s2Loops, 2, 3);
}
lock_ReleaseRead(&main_doneRWLock);
lock_ObtainWrite(&main_doneRWLock);
lock_AssertAny(&main_doneRWLock);
done++;
lock_ReleaseWrite(&main_doneRWLock);
return 0;
}
unsigned long main_Scan1(unsigned long parm)
{
while (1) {
osi_Log0(main_logp, "scan1");
/* check to see if we're done */
lock_ObtainRead(&main_doneRWLock);
lock_AssertRead(&main_doneRWLock);
if (done >= 2) break;
lock_ReleaseRead(&main_doneRWLock);
/* check state for consistency */
lock_ObtainMutex(&main_aMutex);
lock_AssertMutex(&main_aMutex);
Sleep(0);
lock_ObtainRead(&main_bRWLock);
Sleep(0);
osi_assert(a+b == 100);
lock_ReleaseRead(&main_bRWLock);
Sleep(0);
lock_ReleaseMutex(&main_aMutex);
/* get a read lock here to test people getting stuck on RW lock alone */
lock_ObtainRead(&main_bRWLock);
Sleep(0);
lock_ReleaseRead(&main_bRWLock);
s1Loops++;
osi_Log2(main_logp, "scan1 done %d %d", s1Loops, 2);
}
lock_ReleaseRead(&main_doneRWLock);
lock_ObtainWrite(&main_doneRWLock);
lock_AssertWrite(&main_doneRWLock);
done++;
lock_ReleaseWrite(&main_doneRWLock);
return 0;
}
/* periodic check daemon */
void cm_Daemon(long parm)
{
time_t now;
time_t lastLockCheck;
time_t lastVolCheck;
time_t lastCBExpirationCheck;
time_t lastVolCBRenewalCheck;
time_t lastDownServerCheck;
time_t lastUpServerCheck;
time_t lastTokenCacheCheck;
time_t lastBusyVolCheck;
time_t lastPerformanceCheck;
time_t lastServerRankCheck;
char thostName[200];
unsigned long code;
struct hostent *thp;
HMODULE hHookDll;
char * name = "cm_Daemon_ShutdownEvent";
int configureFirewall = IsWindowsFirewallPresent();
int bAddrChangeCheck = 0;
cm_Daemon_ShutdownEvent = thrd_CreateEvent(NULL, FALSE, FALSE, name);
if ( GetLastError() == ERROR_ALREADY_EXISTS )
afsi_log("Event Object Already Exists: %s", name);
if (!configureFirewall) {
afsi_log("No Windows Firewall detected");
}
if (cm_freelanceEnabled && cm_freelanceImportCellServDB)
cm_FreelanceImportCellServDB();
/* ping all file servers, up or down, with unauthenticated connection,
* to find out whether we have all our callbacks from the server still.
* Also, ping down VLDBs.
*/
/*
* Seed the random number generator with our own address, so that
* clients starting at the same time don't all do vol checks at the
* same time.
*/
gethostname(thostName, sizeof(thostName));
thp = gethostbyname(thostName);
if (thp == NULL) /* In djgpp, gethostname returns the netbios
name of the machine. gethostbyname will fail
looking this up if it differs from DNS name. */
code = 0;
else
memcpy(&code, thp->h_addr_list[0], 4);
srand(ntohl(code));
cm_DaemonCheckInit();
now = osi_Time();
lastVolCheck = now - cm_daemonCheckVolInterval/2 + (rand() % cm_daemonCheckVolInterval);
lastCBExpirationCheck = now - cm_daemonCheckCBInterval/2 + (rand() % cm_daemonCheckCBInterval);
if (cm_daemonCheckVolCBInterval)
lastVolCBRenewalCheck = now - cm_daemonCheckVolCBInterval/2 + (rand() % cm_daemonCheckVolCBInterval);
lastLockCheck = now - cm_daemonCheckLockInterval/2 + (rand() % cm_daemonCheckLockInterval);
lastDownServerCheck = now - cm_daemonCheckDownInterval/2 + (rand() % cm_daemonCheckDownInterval);
lastUpServerCheck = now - cm_daemonCheckUpInterval/2 + (rand() % cm_daemonCheckUpInterval);
lastTokenCacheCheck = now - cm_daemonTokenCheckInterval/2 + (rand() % cm_daemonTokenCheckInterval);
lastBusyVolCheck = now - cm_daemonCheckOfflineVolInterval/2 * (rand() % cm_daemonCheckOfflineVolInterval);
if (cm_daemonPerformanceTuningInterval)
lastPerformanceCheck = now - cm_daemonPerformanceTuningInterval/2 * (rand() % cm_daemonPerformanceTuningInterval);
lastServerRankCheck = now - cm_daemonRankServerInterval/2 * (rand() % cm_daemonRankServerInterval);
while (daemon_ShutdownFlag == 0) {
if (powerStateSuspended) {
Sleep(1000);
continue;
}
/* check to see if the listener threads halted due to network
* disconnect or other issues. If so, attempt to restart them.
*/
smb_RestartListeners(0);
if (daemon_ShutdownFlag == 1)
break;
if (configureFirewall) {
/* Open Microsoft Firewall to allow in port 7001 */
switch (icf_CheckAndAddAFSPorts(AFS_PORTSET_CLIENT)) {
case 0:
afsi_log("Windows Firewall Configuration succeeded");
configureFirewall = 0;
break;
case 1:
afsi_log("Invalid Windows Firewall Port Set");
break;
case 2:
afsi_log("Unable to open Windows Firewall Profile");
break;
case 3:
afsi_log("Unable to create/modify Windows Firewall Port entries");
break;
default:
afsi_log("Unknown Windows Firewall Configuration error");
}
}
/* find out what time it is */
now = osi_Time();
/* Determine whether an address change took place that we need to respond to */
if (bAddrChangeCheck)
bAddrChangeCheck = 0;
if (lastIPAddrChange != 0 && lastIPAddrChange + 2500 < now) {
bAddrChangeCheck = 1;
lastIPAddrChange = 0;
}
/* check down servers */
if ((bAddrChangeCheck || now > lastDownServerCheck + cm_daemonCheckDownInterval) &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastDownServerCheck = now;
osi_Log0(afsd_logp, "cm_Daemon CheckDownServers");
cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS, NULL);
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (bAddrChangeCheck &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0)
cm_ForceNewConnectionsAllServers();
/* check up servers */
if ((bAddrChangeCheck || now > lastUpServerCheck + cm_daemonCheckUpInterval) &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastUpServerCheck = now;
osi_Log0(afsd_logp, "cm_Daemon CheckUpServers");
cm_CheckServers(CM_FLAG_CHECKUPSERVERS, NULL);
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (bAddrChangeCheck &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
smb_CheckVCs();
cm_VolStatus_Network_Addr_Change();
}
if (now > lastVolCheck + cm_daemonCheckVolInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastVolCheck = now;
cm_RefreshVolumes();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
/* Rank all up servers */
if ((now > lastServerRankCheck + cm_daemonRankServerInterval) &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastServerRankCheck = now;
osi_Log0(afsd_logp, "cm_Daemon RankServer");
cm_RankUpServers();
if(daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (cm_daemonCheckVolCBInterval &&
now > lastVolCBRenewalCheck + cm_daemonCheckVolCBInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastVolCBRenewalCheck = now;
cm_VolumeRenewROCallbacks();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if ((bAddrChangeCheck || now > lastBusyVolCheck + cm_daemonCheckOfflineVolInterval) &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastVolCheck = now;
cm_CheckOfflineVolumes();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (now > lastCBExpirationCheck + cm_daemonCheckCBInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastCBExpirationCheck = now;
cm_CheckCBExpiration();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (now > lastLockCheck + cm_daemonCheckLockInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastLockCheck = now;
cm_CheckLocks();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
if (now > lastTokenCacheCheck + cm_daemonTokenCheckInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastTokenCacheCheck = now;
cm_CheckTokenCache(now);
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
/* allow an exit to be called prior to stopping the service */
hHookDll = cm_LoadAfsdHookLib();
if (hHookDll)
{
BOOL hookRc = TRUE;
AfsdDaemonHook daemonHook = ( AfsdDaemonHook ) GetProcAddress(hHookDll, AFSD_DAEMON_HOOK);
if (daemonHook)
{
hookRc = daemonHook();
}
FreeLibrary(hHookDll);
hHookDll = NULL;
if (hookRc == FALSE)
{
SetEvent(WaitToTerminate);
}
if (daemon_ShutdownFlag == 1) {
break;
}
now = osi_Time();
}
if (cm_daemonPerformanceTuningInterval &&
now > lastPerformanceCheck + cm_daemonPerformanceTuningInterval &&
daemon_ShutdownFlag == 0 &&
powerStateSuspended == 0) {
lastPerformanceCheck = now;
cm_PerformanceTuningCheck();
if (daemon_ShutdownFlag == 1)
break;
now = osi_Time();
}
thrd_Sleep(10000); /* sleep 10 seconds */
}
thrd_SetEvent(cm_Daemon_ShutdownEvent);
}
afs_int32
smb_RPCNmpipeTransact(smb_fid_t *fidp, smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
{
smb_tran2Packet_t *outp = NULL;
struct smb_rpc *rpcp;
afs_int32 code = 0;
cm_user_t * userp = NULL;
smb_user_t * uidp = NULL;
int len;
osi_Log0(smb_logp, "smb_RPCNmpipeTransact() begin");
uidp = smb_FindUID(vcp, p->uid, 0);
if (!uidp)
return CM_ERROR_BADSMB;
userp = smb_GetUserFromUID(uidp);
osi_assertx(userp != NULL, "null cm_user_t");
if (uidp && uidp->unp) {
osi_Log3(afsd_logp, "RPC Transact uid %d user %x name %S",
uidp->userID, userp,
osi_LogSaveClientString(afsd_logp, uidp->unp->name));
} else {
if (uidp)
osi_Log2(afsd_logp, "RPC Transact uid %d user %x no name",
uidp->userID, userp);
else
osi_Log1(afsd_logp, "RPC Transact no uid user %x no name",
userp);
}
lock_ObtainMutex(&fidp->mx);
rpcp = fidp->rpcp;
code = smb_RPC_BeginOp(rpcp);
if (code) {
osi_Log0(smb_logp, "Can't begin RPC op. Aborting");
lock_ReleaseMutex(&fidp->mx);
smb_ReleaseUID(uidp);
cm_ReleaseUser(userp);
return code;
}
osi_assertx((fidp->flags & SMB_FID_RPC), "FID wasn't setup for RPC");
osi_assertx(fidp->rpcp, "smb_rpc_t not associated with RPC FID");
lock_ReleaseMutex(&fidp->mx);
code = smb_RPC_PrepareWrite(rpcp);
if (code)
goto done;
code = smb_RPC_WritePacket(rpcp, p->datap, p->totalData, userp);
if (code)
goto done;
code = smb_RPC_PrepareRead(rpcp);
if (code)
goto done;
len = smb_RPC_ReadPacketLength(rpcp, p->maxReturnData);
outp = smb_GetTran2ResponsePacket(vcp, p, op, 0, len);
if (len > 0) {
code = smb_RPC_ReadPacket(rpcp, outp->datap, len);
if (code == CM_ERROR_RPC_MOREDATA) {
outp->error_code = CM_ERROR_RPC_MOREDATA;
}
}
if (code == 0 || code == CM_ERROR_RPC_MOREDATA)
smb_SendTran2Packet(vcp, outp, op);
smb_FreeTran2Packet(outp);
done:
smb_RPC_EndOp(rpcp);
osi_Log1(smb_logp, "smb_RPCNmpipeTransact() end code=%d", code);
if (uidp)
smb_ReleaseUID(uidp);
if (userp)
cm_ReleaseUser(userp);
return code;
}
