/* must be called with sleep bucket locked. * Frees the structure if it has a 0 reference count (and removes it * from the hash bucket). Otherwise, we simply mark the item * for deleting when the ref count hits zero. */ void osi_FreeSleepInfo(osi_sleepInfo_t *sp) { LONG_PTR idx; if (sp->refCount > 0) { TlsSetValue(osi_SleepSlot, NULL); /* don't reuse me */ _InterlockedOr(&sp->states, OSI_SLEEPINFO_DELETED); return; } /* remove from hash if still there */ if (sp->states & OSI_SLEEPINFO_INHASH) { idx = osi_SLEEPHASH(sp->value); osi_QRemoveHT((osi_queue_t **) &osi_sleepers[idx], (osi_queue_t **) &osi_sleepersEnd[idx], &sp->q); _InterlockedAnd(&sp->states, ~OSI_SLEEPINFO_INHASH); } if (sp->states & OSI_SLEEPINFO_DELETED) { EnterCriticalSection(&osi_sleepInfoAllocCS); sp->q.nextp = (osi_queue_t *) osi_sleepInfoFreeListp; osi_sleepInfoFreeListp = sp; _InterlockedAnd(&sp->states, ~OSI_SLEEPINFO_DELETED); InterlockedIncrement(&osi_sleepInfoCount); LeaveCriticalSection(&osi_sleepInfoAllocCS); } }
VOID BtrReleaseSpinLock( IN PBTR_SPINLOCK Lock ) { Lock->ThreadId = 0; _InterlockedAnd((volatile LONG *)&Lock->Acquired, 0); }
void ResumeFromSuspension() { // This is meant to be called from the main thread only. assert(g_SuspensionRequested && SuspensionCompleted()); _InterlockedAnd(&g_SuspensionRequested, 0); if (!SetEvent(g_hResumeFromSuspension)) { exit(GetLastError()); } }
unsigned Atomic::AND(unsigned value) { #if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS) return __sync_fetch_and_and(&_value, value); #elif defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED) return _InterlockedAnd(&_value, value); #elif defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC) return OSAtomicAnd32((uint32_t)value, (uint32_t *)&_value); #else # error This implementation should happen inline in the include file #endif }
/* utility function to atomically (with respect to WakeSched) * release an atomic counter spin lock and sleep on an * address (value). * Called with no locks held. */ void osi_SleepSpin(LONG_PTR sleepValue, CRITICAL_SECTION *releasep) { int code; osi_sleepInfo_t *sp; CRITICAL_SECTION *csp; sp = TlsGetValue(osi_SleepSlot); if (sp == NULL) { sp = osi_AllocSleepInfo(); TlsSetValue(osi_SleepSlot, sp); } else { _InterlockedAnd(&sp->states, 0); } sp->waitFor = 0; sp->value = sleepValue; sp->tidp = NULL; sp->idx = osi_SLEEPHASH(sleepValue); csp = &osi_critSec[sp->idx]; EnterCriticalSection(csp); osi_QAddT((osi_queue_t **) &osi_sleepers[sp->idx], (osi_queue_t **) &osi_sleepersEnd[sp->idx], &sp->q); _InterlockedOr(&sp->states, OSI_SLEEPINFO_INHASH); LeaveCriticalSection(csp); LeaveCriticalSection(releasep); InterlockedIncrement(&osi_totalSleeps); /* stats */ while(1) { /* wait */ code = WaitForSingleObject(sp->sema, /* timeout */ INFINITE); /* if the reason for the wakeup was that we were signalled, * break out, otherwise try again, since the semaphore count is * decreased only when we get WAIT_OBJECT_0 back. */ if (code == WAIT_OBJECT_0) break; } /* now clean up */ EnterCriticalSection(csp); /* must be signalled */ osi_assert(sp->states & OSI_SLEEPINFO_SIGNALLED); /* free the sleep structure, must be done under bucket lock * so that we can check reference count and serialize with * those who change it. */ osi_FreeSleepInfo(sp); LeaveCriticalSection(csp); }
void osi_TWaitExt(osi_turnstile_t *turnp, int waitFor, void *patchp, DWORD *tidp, CRITICAL_SECTION *releasep, int prepend) { osi_sleepInfo_t *sp; unsigned int code; sp = TlsGetValue(osi_SleepSlot); if (sp == NULL) { sp = osi_AllocSleepInfo(); TlsSetValue(osi_SleepSlot, sp); } else { _InterlockedAnd(&sp->states, 0); } sp->waitFor = waitFor; sp->value = (LONG_PTR) patchp; sp->tidp = tidp; sp->idx = -1; if (prepend) osi_QAddH((osi_queue_t **) &turnp->firstp, (osi_queue_t **) &turnp->lastp, &sp->q); else osi_QAddT((osi_queue_t **) &turnp->firstp, (osi_queue_t **) &turnp->lastp, &sp->q); LeaveCriticalSection(releasep); /* now wait for the signal */ while(1) { /* wait */ code = WaitForSingleObject(sp->sema, /* timeout */ INFINITE); /* if the reason for the wakeup was that we were signalled, * break out, otherwise try again, since the semaphore count is * decreased only when we get WAIT_OBJECT_0 back. */ if (code == WAIT_OBJECT_0) break; } /* while we're waiting */ /* we're the only one who should be looking at or changing this * structure after it gets signalled. Sema sp->sema isn't signalled * any longer after we're back from WaitForSingleObject, so we can * free this element directly. */ osi_assert(sp->states & OSI_SLEEPINFO_SIGNALLED); osi_FreeSleepInfo(sp); /* reobtain, since caller commonly needs it */ EnterCriticalSection(releasep); }
// Locks all other processors and returns exclusivity pointer. This function // should never be called before the last exclusivity is released. _Use_decl_annotations_ EXTERN_C void *ExclGainExclusivity() { NT_ASSERT(InterlockedAdd(&g_ExclpNumberOfLockedProcessors, 0) == 0); _InterlockedAnd(&g_ExclpReleaseAllProcessors, 0); const auto numberOfProcessors = KeQueryActiveProcessorCount(nullptr); // Allocates DPCs for all processors. auto context = reinterpret_cast<ExclusivityContext *>(ExAllocatePoolWithTag( NonPagedPoolNx, sizeof(void *) + (numberOfProcessors * sizeof(KDPC)), EXCLP_POOL_TAG)); if (!context) { return nullptr; } // Execute a lock DPC for all processors but this. context->OldIrql = KeRaiseIrqlToDpcLevel(); const auto currentCpu = KeGetCurrentProcessorNumber(); for (auto i = 0ul; i < numberOfProcessors; i++) { if (i == currentCpu) { continue; } // Queue a lock DPC. KeInitializeDpc(&context->Dpcs[i], ExclpRaiseIrqlAndWaitDpc, nullptr); KeSetTargetProcessorDpc(&context->Dpcs[i], static_cast<CCHAR>(i)); KeInsertQueueDpc(&context->Dpcs[i], nullptr, nullptr); } // Wait until all other processors were halted. const auto needToBeLocked = numberOfProcessors - 1; while (_InterlockedCompareExchange(&g_ExclpNumberOfLockedProcessors, needToBeLocked, needToBeLocked) != static_cast<LONG>(needToBeLocked)) { KeStallExecutionProcessor(10); } return context; }
BOOL Condition::Wait(DWORD timeout) { // 参考程度の空き開始位置調査 // (正確な確認は、INIT_EVENT <-> WAIT_EVENT の CAS で) u_int idx = get_ntz(_InterlockedExchangeAdd(&gEventMap, 0)); u_int self_bit = 0; if (idx >= MaxThreads) idx = 0; int count = 0; while (count < MaxThreads) { if (InterlockedCompareExchange(&gEvents[idx].kind, WAIT_EVENT, INIT_EVENT) == INIT_EVENT) { self_bit = 1 << idx; _InterlockedAnd(&gEventMap, ~self_bit); break; } if (++idx == MaxThreads) idx = 0; count++; } if (count >= MaxThreads) { // 通常はありえない MessageBox(0, "Detect too many wait threads", "TLib", MB_OK); return FALSE; } Event &event = gEvents[idx]; if (event.hEvent == NULL) { event.hEvent = ::CreateEvent(0, FALSE, FALSE, NULL); } waitBits |= self_bit; UnLock(); DWORD status = ::WaitForSingleObject(event.hEvent, timeout); Lock(); waitBits &= ~self_bit; InterlockedExchange(&event.kind, INIT_EVENT); _InterlockedOr(&gEventMap, self_bit); return status == WAIT_TIMEOUT ? FALSE : TRUE; }
/* call with cell write-locked and mutex held */ void cm_RemoveCellFromIDHashTable(cm_cell_t *cellp) { cm_cell_t **lcellpp; cm_cell_t *tcellp; int i; lock_AssertWrite(&cm_cellLock); lock_AssertMutex(&cellp->mx); if (cellp->flags & CM_CELLFLAG_IN_IDHASH) { /* hash it out first */ i = CM_CELL_ID_HASH(cellp->cellID); for (lcellpp = &cm_data.cellIDHashTablep[i], tcellp = cm_data.cellIDHashTablep[i]; tcellp; lcellpp = &tcellp->idNextp, tcellp = tcellp->idNextp) { if (tcellp == cellp) { *lcellpp = cellp->idNextp; _InterlockedAnd(&cellp->flags, ~CM_CELLFLAG_IN_IDHASH); cellp->idNextp = NULL; break; } } } }
cm_cell_t *cm_GetCell_Gen(char *namep, char *newnamep, afs_uint32 flags) { cm_cell_t *cp, *cp2; long code; char fullname[CELL_MAXNAMELEN]=""; char linkedName[CELL_MAXNAMELEN]=""; char name[CELL_MAXNAMELEN]=""; int hasWriteLock = 0; int hasMutex = 0; afs_uint32 hash; cm_cell_rock_t rock; size_t len; if (namep == NULL || !namep[0] || !strcmp(namep,CM_IOCTL_FILENAME_NOSLASH)) return NULL; /* * Strip off any trailing dots at the end of the cell name. * Failure to do so results in an undesireable alias as the * result of DNS AFSDB record lookups where a trailing dot * has special meaning. */ strncpy(name, namep, CELL_MAXNAMELEN); for (len = strlen(namep); len > 0 && namep[len-1] == '.'; len--) { name[len-1] = '\0'; } if (len == 0) return NULL; namep = name; hash = CM_CELL_NAME_HASH(namep); lock_ObtainRead(&cm_cellLock); for (cp = cm_data.cellNameHashTablep[hash]; cp; cp=cp->nameNextp) { if (cm_stricmp_utf8(namep, cp->name) == 0) { strncpy(fullname, cp->name, CELL_MAXNAMELEN); fullname[CELL_MAXNAMELEN-1] = '\0'; break; } } if (!cp) { for (cp = cm_data.allCellsp; cp; cp=cp->allNextp) { if (strnicmp(namep, cp->name, strlen(namep)) == 0) { strncpy(fullname, cp->name, CELL_MAXNAMELEN); fullname[CELL_MAXNAMELEN-1] = '\0'; break; } } } if (cp) { lock_ReleaseRead(&cm_cellLock); cm_UpdateCell(cp, flags); } else if (flags & CM_FLAG_CREATE) { lock_ConvertRToW(&cm_cellLock); hasWriteLock = 1; /* when we dropped the lock the cell could have been added * to the list so check again while holding the write lock */ for (cp = cm_data.cellNameHashTablep[hash]; cp; cp=cp->nameNextp) { if (cm_stricmp_utf8(namep, cp->name) == 0) { strncpy(fullname, cp->name, CELL_MAXNAMELEN); fullname[CELL_MAXNAMELEN-1] = '\0'; break; } } if (cp) goto done; for (cp = cm_data.allCellsp; cp; cp=cp->allNextp) { if (strnicmp(namep, cp->name, strlen(namep)) == 0) { strncpy(fullname, cp->name, CELL_MAXNAMELEN); fullname[CELL_MAXNAMELEN-1] = '\0'; break; } } if (cp) { lock_ReleaseWrite(&cm_cellLock); lock_ObtainMutex(&cp->mx); lock_ObtainWrite(&cm_cellLock); cm_AddCellToNameHashTable(cp); cm_AddCellToIDHashTable(cp); lock_ReleaseMutex(&cp->mx); goto done; } if ( cm_data.freeCellsp != NULL ) { cp = cm_data.freeCellsp; cm_data.freeCellsp = cp->freeNextp; /* * The magic, cellID, and mx fields are already set. */ } else { if ( cm_data.currentCells >= cm_data.maxCells ) osi_panic("Exceeded Max Cells", __FILE__, __LINE__); /* don't increment currentCells until we know that we * are going to keep this entry */ cp = &cm_data.cellBaseAddress[cm_data.currentCells]; memset(cp, 0, sizeof(cm_cell_t)); cp->magic = CM_CELL_MAGIC; /* the cellID cannot be 0 */ cp->cellID = ++cm_data.currentCells; /* otherwise we found the cell, and so we're nearly done */ lock_InitializeMutex(&cp->mx, "cm_cell_t mutex", LOCK_HIERARCHY_CELL); } lock_ReleaseWrite(&cm_cellLock); hasWriteLock = 0; rock.cellp = cp; rock.flags = flags; code = cm_SearchCellRegistry(1, namep, fullname, linkedName, cm_AddCellProc, &rock); if (code && code != CM_ERROR_FORCE_DNS_LOOKUP) code = cm_SearchCellFileEx(namep, fullname, linkedName, cm_AddCellProc, &rock); if (code) { osi_Log4(afsd_logp,"in cm_GetCell_gen cm_SearchCellFileEx(%s) returns code= %d fullname= %s linkedName= %s", osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname), osi_LogSaveString(afsd_logp,linkedName)); if (cm_dnsEnabled) { int ttl; code = cm_SearchCellByDNS(namep, fullname, &ttl, cm_AddCellProc, &rock); if ( code ) { osi_Log3(afsd_logp,"in cm_GetCell_gen cm_SearchCellByDNS(%s) returns code= %d fullname= %s", osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname)); lock_ObtainMutex(&cp->mx); lock_ObtainWrite(&cm_cellLock); hasWriteLock = 1; cm_RemoveCellFromIDHashTable(cp); cm_RemoveCellFromNameHashTable(cp); lock_ReleaseMutex(&cp->mx); cm_FreeCell(cp); cp = NULL; goto done; } else { /* got cell from DNS */ lock_ObtainMutex(&cp->mx); hasMutex = 1; _InterlockedOr(&cp->flags, CM_CELLFLAG_DNS); _InterlockedAnd(&cp->flags, ~CM_CELLFLAG_VLSERVER_INVALID); cp->timeout = time(0) + ttl; } } else { lock_ObtainMutex(&cp->mx); lock_ObtainWrite(&cm_cellLock); hasWriteLock = 1; cm_RemoveCellFromIDHashTable(cp); cm_RemoveCellFromNameHashTable(cp); lock_ReleaseMutex(&cp->mx); cm_FreeCell(cp); cp = NULL; goto done; } } else { lock_ObtainMutex(&cp->mx); hasMutex = 1; cp->timeout = time(0) + 7200; /* two hour timeout */ } /* we have now been given the fullname of the cell. It may * be that we already have a cell with that name. If so, * we should use it instead of completing the allocation * of a new cm_cell_t */ lock_ObtainRead(&cm_cellLock); hash = CM_CELL_NAME_HASH(fullname); for (cp2 = cm_data.cellNameHashTablep[hash]; cp2; cp2=cp2->nameNextp) { if (cm_stricmp_utf8(fullname, cp2->name) == 0) { break; } } if (cp2) { if (!hasMutex) { lock_ObtainMutex(&cp->mx); hasMutex = 1; } lock_ConvertRToW(&cm_cellLock); hasWriteLock = 1; cm_RemoveCellFromIDHashTable(cp); cm_RemoveCellFromNameHashTable(cp); lock_ReleaseMutex(&cp->mx); hasMutex = 0; cm_FreeCell(cp); cp = cp2; goto done; } lock_ReleaseRead(&cm_cellLock); /* randomise among those vlservers having the same rank*/ cm_RandomizeServer(&cp->vlServersp); if (!hasMutex) lock_ObtainMutex(&cp->mx); /* copy in name */ strncpy(cp->name, fullname, CELL_MAXNAMELEN); cp->name[CELL_MAXNAMELEN-1] = '\0'; strncpy(cp->linkedName, linkedName, CELL_MAXNAMELEN); cp->linkedName[CELL_MAXNAMELEN-1] = '\0'; lock_ObtainWrite(&cm_cellLock); hasWriteLock = 1; cm_AddCellToNameHashTable(cp); cm_AddCellToIDHashTable(cp); lock_ReleaseMutex(&cp->mx); hasMutex = 0; /* append cell to global list */ if (cm_data.allCellsp == NULL) { cm_data.allCellsp = cp; } else { for (cp2 = cm_data.allCellsp; cp2->allNextp; cp2=cp2->allNextp) ; cp2->allNextp = cp; } cp->allNextp = NULL; } else { lock_ReleaseRead(&cm_cellLock); } done: if (hasMutex && cp) lock_ReleaseMutex(&cp->mx); if (hasWriteLock) lock_ReleaseWrite(&cm_cellLock); /* fullname is not valid if cp == NULL */ if (newnamep) { if (cp) { strncpy(newnamep, fullname, CELL_MAXNAMELEN); newnamep[CELL_MAXNAMELEN-1]='\0'; } else { newnamep[0] = '\0'; } } if (cp && cp->linkedName[0]) { cm_cell_t * linkedCellp = NULL; if (!strcmp(cp->name, cp->linkedName)) { cp->linkedName[0] = '\0'; } else if (!(flags & CM_FLAG_NOMOUNTCHASE)) { linkedCellp = cm_GetCell(cp->linkedName, CM_FLAG_CREATE|CM_FLAG_NOPROBE|CM_FLAG_NOMOUNTCHASE); lock_ObtainWrite(&cm_cellLock); if (!linkedCellp || (linkedCellp->linkedName[0] && strcmp(cp->name, linkedCellp->linkedName))) { cp->linkedName[0] = '\0'; } else { strncpy(linkedCellp->linkedName, cp->name, CELL_MAXNAMELEN); linkedCellp->linkedName[CELL_MAXNAMELEN-1]='\0'; } lock_ReleaseWrite(&cm_cellLock); } } return cp; }
LONG test_InterlockedAnd(LONG volatile *value, LONG mask) { return _InterlockedAnd(value, mask); }
void cm_PingServer(cm_server_t *tsp) { long code; int wasDown = 0; cm_conn_t *connp; struct rx_connection * rxconnp; Capabilities caps = {0, 0}; char hoststr[16]; cm_req_t req; lock_ObtainMutex(&tsp->mx); if (InterlockedIncrement(&tsp->pingCount) > 1) { tsp->waitCount++; osi_SleepM((LONG_PTR)tsp, &tsp->mx); lock_ObtainMutex(&tsp->mx); InterlockedDecrement(&tsp->pingCount); if (--tsp->waitCount > 0) osi_Wakeup((LONG_PTR)tsp); lock_ReleaseMutex(&tsp->mx); return; } wasDown = tsp->flags & CM_SERVERFLAG_DOWN; afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr); lock_ReleaseMutex(&tsp->mx); if (cm_noIPAddr > 0) code = cm_ConnByServer(tsp, cm_rootUserp, FALSE, &connp); else code = RX_CALL_DEAD; /* No network */ if (code == 0) { /* now call the appropriate ping call. Drop the timeout if * the server is known to be down, so that we don't waste a * lot of time retiming out down servers. */ osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x", osi_LogSaveString(afsd_logp, hoststr), tsp->type == CM_SERVER_VLDB ? "vldb" : "file", wasDown ? "down" : "up", tsp->capabilities); rxconnp = cm_GetRxConn(connp); if (wasDown) rx_SetConnHardDeadTime(rxconnp, 10); if (tsp->type == CM_SERVER_VLDB) { code = VL_ProbeServer(rxconnp); } else { /* file server */ code = RXAFS_GetCapabilities(rxconnp, &caps); } if (wasDown) rx_SetConnHardDeadTime(rxconnp, HardDeadtimeout); rx_PutConnection(rxconnp); cm_PutConn(connp); } /* got an unauthenticated connection to this server */ lock_ObtainMutex(&tsp->mx); if (code >= 0 || code == RXGEN_OPCODE) { /* mark server as up */ _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN); tsp->downTime = 0; /* we currently handle 32-bits of capabilities */ if (code != RXGEN_OPCODE && caps.Capabilities_len > 0) { tsp->capabilities = caps.Capabilities_val[0]; xdr_free((xdrproc_t) xdr_Capabilities, &caps); caps.Capabilities_len = 0; caps.Capabilities_val = 0; } else { tsp->capabilities = 0; } osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x", osi_LogSaveString(afsd_logp, hoststr), tsp->type == CM_SERVER_VLDB ? "vldb" : "file", tsp->capabilities); /* Now update the volume status if necessary */ if (wasDown) { cm_server_vols_t * tsrvp; cm_volume_t * volp; int i; for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) { for (i=0; i<NUM_SERVER_VOLS; i++) { if (tsrvp->ids[i] != 0) { cm_InitReq(&req); lock_ReleaseMutex(&tsp->mx); code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp, &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp); lock_ObtainMutex(&tsp->mx); if (code == 0) { cm_UpdateVolumeStatus(volp, tsrvp->ids[i]); cm_PutVolume(volp); } } } } cm_RankServer(tsp); } } else { cm_MarkServerDown(tsp, code, wasDown); osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x", osi_LogSaveString(afsd_logp, hoststr), tsp->type == CM_SERVER_VLDB ? "vldb" : "file", tsp->capabilities); } InterlockedDecrement(&tsp->pingCount); if (tsp->waitCount > 0) osi_Wakeup((LONG_PTR)tsp); lock_ReleaseMutex(&tsp->mx); }
/* _Atomic_fetch_and_4 */ _Uint4_t _Fetch_and_seq_cst_4(volatile _Uint4_t *_Tgt, _Uint4_t _Value) { /* and _Value with *_Tgt atomically with sequentially consistent memory order */ _Value = _InterlockedAnd((volatile long *)_Tgt, _Value); return (_Value); }
Int32 KInterlockedAnd(Int32 volatile * var, Int32 add) { return _InterlockedAnd((volatile long*)var, add); }
long cm_CreateCellWithInfo( char * cellname, char * linked_cellname, unsigned short vlport, afs_uint32 host_count, char *hostname[], afs_uint32 flags) { afs_uint32 code = 0; cm_cell_rock_t rock; struct hostent *thp; struct sockaddr_in vlSockAddr; afs_uint32 i, j; rock.cellp = cm_GetCell(cellname, CM_FLAG_CREATE | CM_FLAG_NOPROBE); rock.flags = 0; cm_FreeServerList(&rock.cellp->vlServersp, CM_FREESERVERLIST_DELETE); if (!(flags & CM_CELLFLAG_DNS)) { for (i = 0; i < host_count; i++) { thp = gethostbyname(hostname[i]); if (thp) { int foundAddr = 0; for (j=0 ; thp->h_addr_list[j]; j++) { if (thp->h_addrtype != AF_INET) continue; memcpy(&vlSockAddr.sin_addr.s_addr, thp->h_addr_list[j], sizeof(long)); vlSockAddr.sin_port = htons(vlport ? vlport : 7003); vlSockAddr.sin_family = AF_INET; cm_AddCellProc(&rock, &vlSockAddr, hostname[i], CM_FLAG_NOPROBE); } } } lock_ObtainMutex(&rock.cellp->mx); _InterlockedAnd(&rock.cellp->flags, ~CM_CELLFLAG_DNS); } else if (cm_dnsEnabled) { int ttl; code = cm_SearchCellByDNS(rock.cellp->name, NULL, &ttl, cm_AddCellProc, &rock); lock_ObtainMutex(&rock.cellp->mx); if (code == 0) { /* got cell from DNS */ _InterlockedOr(&rock.cellp->flags, CM_CELLFLAG_DNS); rock.cellp->timeout = time(0) + ttl; #ifdef DEBUG fprintf(stderr, "cell %s: ttl=%d\n", rock.cellp->name, ttl); #endif } } else { lock_ObtainMutex(&rock.cellp->mx); rock.cellp->flags &= ~CM_CELLFLAG_DNS; } _InterlockedOr(&rock.cellp->flags, CM_CELLFLAG_VLSERVER_INVALID); StringCbCopy(rock.cellp->linkedName, CELL_MAXNAMELEN, linked_cellname); lock_ReleaseMutex(&rock.cellp->mx); if (rock.cellp->vlServersp) cm_RandomizeServer(&rock.cellp->vlServersp); return code; }
/* if it's from DNS, see if it has expired * and check to make sure we have a valid set of volume servers * this function must not be called with a lock on cm_cellLock */ cm_cell_t *cm_UpdateCell(cm_cell_t * cp, afs_uint32 flags) { long code = 0; cm_cell_rock_t rock; afs_uint32 mxheld = 0; if (cp == NULL) return NULL; lock_ObtainMutex(&cp->mx); mxheld = 1; #ifdef AFS_FREELANCE_CLIENT if (cp->flags & CM_CELLFLAG_FREELANCE) { lock_ReleaseMutex(&cp->mx); return cp; } #endif if (cm_IsServerListEmpty(cp->vlServersp) || (time(0) > cp->timeout) || (cm_dnsEnabled && (cp->flags & CM_CELLFLAG_DNS) && ((cp->flags & CM_CELLFLAG_VLSERVER_INVALID)))) { lock_ReleaseMutex(&cp->mx); mxheld = 0; /* must empty cp->vlServersp */ if (cp->vlServersp) cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE); rock.cellp = cp; rock.flags = flags; code = cm_SearchCellRegistry(1, cp->name, NULL, cp->linkedName, cm_AddCellProc, &rock); if (code && code != CM_ERROR_FORCE_DNS_LOOKUP) code = cm_SearchCellFileEx(cp->name, NULL, cp->linkedName, cm_AddCellProc, &rock); if (code == 0) { lock_ObtainMutex(&cp->mx); mxheld = 1; cp->timeout = time(0) + 7200; } else { if (cm_dnsEnabled) { int ttl; code = cm_SearchCellByDNS(cp->name, NULL, &ttl, cm_AddCellProc, &rock); if (code == 0) { /* got cell from DNS */ lock_ObtainMutex(&cp->mx); mxheld = 1; _InterlockedOr(&cp->flags, CM_CELLFLAG_DNS); _InterlockedAnd(&cp->flags, ~CM_CELLFLAG_VLSERVER_INVALID); cp->timeout = time(0) + ttl; #ifdef DEBUG fprintf(stderr, "cell %s: ttl=%d\n", cp->name, ttl); #endif } else { /* if we fail to find it this time, we'll just do nothing and leave the * current entry alone */ lock_ObtainMutex(&cp->mx); mxheld = 1; _InterlockedOr(&cp->flags, CM_CELLFLAG_VLSERVER_INVALID); } } } } if (code == 0) cm_RandomizeServer(&cp->vlServersp); if (mxheld) lock_ReleaseMutex(&cp->mx); return code ? NULL : cp; }
long test_InterlockedAnd(long volatile *value, long mask) { return _InterlockedAnd(value, mask); }