BOOL ConsumeElement(int nThreadNum, int nRequestNum, HWND hWndLB) { // Get access to the queue to consume a new element AcquireSRWLockShared(&g_srwLock); // Fall asleep until there is something to read. // Check if, while it was asleep, // it was not decided that the thread should stop while (g_q.IsEmpty(nThreadNum) && !g_fShutdown) { // There was not a readable element AddText(hWndLB, TEXT("[%d] Nothing to process"), nThreadNum); // The queue is empty // --> Wait until a writer adds a new element to read // and come back with the lock acquired in shared mode SleepConditionVariableSRW(&g_cvReadyToConsume, &g_srwLock, INFINITE, CONDITION_VARIABLE_LOCKMODE_SHARED); } // When thread is exiting, the lock should be released for writer // and readers should be signaled through the condition variable if (g_fShutdown) { // Show that the current thread is exiting AddText(hWndLB, TEXT("[%d] bye bye"), nThreadNum); // Another writer thread might still be blocked on the lock // --> release it before exiting ReleaseSRWLockShared(&g_srwLock); // Notify other readers that it is time to exit // --> release readers WakeConditionVariable(&g_cvReadyToConsume); return(FALSE); } // Get the first new element CQueue::ELEMENT e; // Note: No need to test the return value since IsEmpty // returned FALSE g_q.GetNewElement(nThreadNum, e); // No need to keep the lock any longer ReleaseSRWLockShared(&g_srwLock); // Show result of consuming the element AddText(hWndLB, TEXT("[%d] Processing %d:%d"), nThreadNum, e.m_nThreadNum, e.m_nRequestNum); // A free slot is now available for writer threads to produce // --> wake up a writer thread WakeConditionVariable(&g_cvReadyToProduce); return(TRUE); }
static size_t winfs_read(struct file *f, void *buf, size_t count) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; WaitForSingleObject(winfile->fp_mutex, INFINITE); size_t num_read = 0; while (count > 0) { DWORD count_dword = (DWORD)min(count, (size_t)UINT_MAX); DWORD num_read_dword; if (!ReadFile(winfile->handle, buf, count_dword, &num_read_dword, NULL)) { if (GetLastError() == ERROR_HANDLE_EOF) break; log_warning("ReadFile() failed, error code: %d", GetLastError()); num_read = -L_EIO; break; } if (num_read_dword == 0) break; num_read += num_read_dword; count -= num_read_dword; } ReleaseMutex(winfile->fp_mutex); ReleaseSRWLockShared(&f->rw_lock); return num_read; }
static int winfs_statfs(struct file *f, struct statfs64 *buf) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; FILE_FS_FULL_SIZE_INFORMATION info; IO_STATUS_BLOCK status_block; NTSTATUS status = NtQueryVolumeInformationFile(winfile->handle, &status_block, &info, sizeof(info), FileFsFullSizeInformation); int r = 0; if (!NT_SUCCESS(status)) { log_warning("NtQueryVolumeInformationFile() failed, status: %x", status); r = -L_EIO; goto out; } buf->f_type = 0x5346544e; /* NTFS_SB_MAGIC */ buf->f_bsize = info.SectorsPerAllocationUnit * info.BytesPerSector; buf->f_blocks = info.TotalAllocationUnits.QuadPart; buf->f_bfree = info.ActualAvailableAllocationUnits.QuadPart; buf->f_bavail = info.CallerAvailableAllocationUnits.QuadPart; buf->f_files = 0; buf->f_ffree = 0; buf->f_fsid.val[0] = 0; buf->f_fsid.val[1] = 0; buf->f_namelen = PATH_MAX; buf->f_frsize = 0; buf->f_flags = 0; buf->f_spare[0] = 0; buf->f_spare[1] = 0; buf->f_spare[2] = 0; buf->f_spare[3] = 0; out: ReleaseSRWLockShared(&f->rw_lock); return r; }
static int winfs_link(struct mount_point *mp, struct file *f, const char *newpath) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; NTSTATUS status; int r = 0; char buf[sizeof(FILE_LINK_INFORMATION) + PATH_MAX * 2]; FILE_LINK_INFORMATION *info = (FILE_LINK_INFORMATION *)buf; info->ReplaceIfExists = FALSE; info->RootDirectory = NULL; info->FileNameLength = 2 * filename_to_nt_pathname(mp, newpath, info->FileName, PATH_MAX); if (info->FileNameLength == 0) { r = -L_ENOENT; goto out; } IO_STATUS_BLOCK status_block; status = NtSetInformationFile(winfile->handle, &status_block, info, info->FileNameLength + sizeof(FILE_LINK_INFORMATION), FileLinkInformation); if (!NT_SUCCESS(status)) { log_warning("NtSetInformationFile() failed, status: %x.", status); r = -L_ENOENT; goto out; } out: ReleaseSRWLockShared(&f->rw_lock); return r; }
void ui::sendmouse(char param, vector2d pos) { mouse.update(pos); uielement* front = 0; if (actionsenabled) { if (TryAcquireSRWLockShared(&uilock)) { for (map<char, uielement*>::iterator elit = elements.begin(); elit != elements.end(); elit++) { if (util::colliding(pos, elit->second->bounds()) && elit->second->isactive()) { if (front != 0) front->sendmouse(pos, -1); front = elit->second; } } ReleaseSRWLockShared(&uilock); } } if (front != 0) { mouse.setstate(front->sendmouse(pos, param)); } else { mouse.setstate(param); if (mouse.getstate() == 1) mouse.setstate(0); } }
void SimpleRWLock::unlock_shared() { int& state = s.getRef(); dassert( state == 1 ); state--; shares--; ReleaseSRWLockShared(&_lock); }
int rwmutex_rdunlock(XQ_rwmutex_t *m) { #if _WIN32_WINNT >= 0x0700 ReleaseSRWLockShared(m); #endif return 0; }
void nfs41_session_free_slot( IN nfs41_session *session, IN uint32_t slotid) { nfs41_slot_table *table = &session->table; AcquireSRWLockShared(&session->client->session_lock); EnterCriticalSection(&table->lock); /* flag the slot as unused */ if (slotid < NFS41_MAX_NUM_SLOTS && table->used_slots[slotid]) { table->used_slots[slotid] = 0; table->num_used--; } /* update highest_used if necessary */ if (slotid == table->highest_used) { while (table->highest_used && !table->used_slots[table->highest_used]) table->highest_used--; } dprintf(3, "freeing slot#=%d used=%d highest=%d\n", slotid, table->num_used, table->highest_used); /* wake any threads waiting on a slot */ if (slot_table_avail(table)) WakeAllConditionVariable(&table->cond); LeaveCriticalSection(&table->lock); ReleaseSRWLockShared(&session->client->session_lock); }
int pthread_rwlock_unlock(pthread_rwlock_t *l) { #ifndef PTHREAD_WIN_XP_SYNC void *state = *(void **)l; if (state == (void *) 1) { /* Known to be an exclusive lock */ ReleaseSRWLockExclusive(l); } else { /* A shared unlock will work */ ReleaseSRWLockShared(l); } #else WaitForSingleObject(l->mutex,INFINITE); if(l->reader_count < 0) // Known to be an exclusive lock { l->reader_count = 0; if(l->nb_waiting_writer) // writter have the priority ReleaseSemaphore(l->sema_write,1,NULL); // Wakeup one writer else if(l->nb_waiting_reader) ReleaseSemaphore(l->sema_read,l->nb_waiting_reader,NULL); // Wake up all readers } else if(!--(l->reader_count) && l->nb_waiting_writer) // maybe wake up one writer ReleaseSemaphore(l->sema_write,1,NULL); ReleaseMutex(l->mutex); #endif return 0; }
int virtualfs_custom_stat(struct file *f, struct newstat *buf) { AcquireSRWLockShared(&f->rw_lock); struct virtualfs_custom *file = (struct virtualfs_custom *)f; struct virtualfs_custom_desc *desc = (struct virtualfs_custom_desc *)file->desc; INIT_STRUCT_NEWSTAT_PADDING(buf); buf->st_dev = mkdev(0, 1); buf->st_ino = 0; buf->st_mode = S_IFCHR + 0644; buf->st_nlink = 1; buf->st_uid = 0; buf->st_gid = 0; buf->st_rdev = desc->device; buf->st_size = 0; buf->st_blksize = PAGE_SIZE; buf->st_blocks = 0; buf->st_atime = 0; buf->st_atime_nsec = 0; buf->st_mtime = 0; buf->st_mtime_nsec = 0; buf->st_ctime = 0; buf->st_ctime_nsec = 0; ReleaseSRWLockShared(&f->rw_lock); return 0; }
static int cl_exid_compare( IN const struct list_entry *entry, IN const void *value) { nfs41_client *client = client_entry(entry); const struct cl_exid_info *info = (const struct cl_exid_info*)value; int status = ERROR_FILE_NOT_FOUND; AcquireSRWLockShared(&client->exid_lock); /* match any of the desired roles */ if ((info->roles & client->roles) == 0) goto out; /* match server_owner.major_id */ if (strncmp(info->exchangeid->server_owner.so_major_id, client->server->owner, NFS4_OPAQUE_LIMIT) != 0) goto out; /* match server_scope */ if (strncmp(info->exchangeid->server_scope, client->server->scope, NFS4_OPAQUE_LIMIT) != 0) goto out; /* match clientid */ if (info->exchangeid->clientid != client->clnt_id) goto out; status = NO_ERROR; out: ReleaseSRWLockShared(&client->exid_lock); return status; }
static size_t winfs_write(struct file *f, const void *buf, size_t count) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; WaitForSingleObject(winfile->fp_mutex, INFINITE); size_t num_written = 0; OVERLAPPED overlapped; overlapped.Internal = 0; overlapped.InternalHigh = 0; overlapped.Offset = 0xFFFFFFFF; overlapped.OffsetHigh = 0xFFFFFFFF; overlapped.hEvent = NULL; OVERLAPPED *overlapped_pointer = (f->flags & O_APPEND)? &overlapped: NULL; while (count > 0) { DWORD count_dword = (DWORD)min(count, (size_t)UINT_MAX); DWORD num_written_dword; if (!WriteFile(winfile->handle, buf, count_dword, &num_written_dword, overlapped_pointer)) { log_warning("WriteFile() failed, error code: %d", GetLastError()); num_written = -L_EIO; break; } num_written += num_written_dword; count -= num_written_dword; } ReleaseMutex(winfile->fp_mutex); ReleaseSRWLockShared(&f->rw_lock); return num_written; }
BOOL acl_filter(PACL_LIST acl,const unsigned char HwType,const unsigned char* HwAddr,unsigned char HwAddrLen){ AcquireSRWLockShared(&acl->lock); DEBUG("acl_filter: AcquireSRWLockShared()\n"); __try{ char buf[16*2+1]; DEBUG("acl_filter(HwType=%d, HwAddr=%s)\n",(int)HwType,dhcp_hw_addr(buf,HwAddr,(int)HwAddrLen)); unsigned int len = acl->length,i,j; PACL_ENTRY entries = acl->entry; for(i = 0;i<len;i++){ DEBUG("acl_filter: entry[%d].HwType=%d arg.HwType=%d\n",i,(int)entries[i].HwType,(int)HwType); if(entries[i].HwType!=HwType) continue; for(j=0;j<HwAddrLen;j++){ DEBUG("acl_filter: entry[%d].HwAddr[%d]=0x%02x arg.HwAddr[%d]=0x%02x\n",i,j,(int)entries[i].HwAddr[j],j,(int)HwAddr[j]); if((HwAddr[j]&entries[i].HwMask[j])!=entries[i].HwAddr[j]){ goto next; } } return entries[i].access; next: DEBUG("Goto Next\n"); (void)0; } return TRUE; }__finally{ ReleaseSRWLockShared(&acl->lock); DEBUG("acl_filter: ReleaseSRWLockShared()\n"); } }
/// <summary> /// Unlocks for reading (Call if thread acquired a read lock). /// </summary> void RWLock::UnlockRead() { #ifdef PLATFORM_WIN ReleaseSRWLockShared( &mRwlock ); #else pthread_rwlock_unlock( &mRwlock ); #endif }
void rwlock_rdunlock(rwlock_t *l) { #ifndef _WIN32 atomic_ref(&l->s.write); #else ReleaseSRWLockShared(l); #endif }
static size_t virtualfs_char_write(struct file *f, const void *buf, size_t count) { AcquireSRWLockShared(&f->rw_lock); struct virtualfs_char *file = (struct virtualfs_char *)f; size_t r = file->desc->write(file->tag, buf, count); ReleaseSRWLockShared(&f->rw_lock); return r; }
int mutex_unlock_shared(struct mutex_handle *mutex) { struct mutex_priv *priv = (struct mutex_priv *)mutex->priv; ReleaseSRWLockShared(&priv->lock); return 0; }
void shared_mutex::unlock() { bool ex = d->ex; if(ex) { d->ex=false; ReleaseSRWLockExclusive(&d->m); } else ReleaseSRWLockShared(&d->m); }
void RWLock::ReadUnlockInternal() { #ifdef XP_WIN ReleaseSRWLockShared(NativeHandle(mRWLock)); #else MOZ_RELEASE_ASSERT(pthread_rwlock_unlock(NativeHandle(mRWLock)) == 0, "pthread_rwlock_unlock failed"); #endif }
void RWLock::ReadUnlock() { #if defined(OVR_CAPTURE_WINDOWS) ReleaseSRWLockShared(&m_lock); #elif defined(OVR_CAPTURE_POSIX) pthread_rwlock_unlock(&m_lock); #else #error Unknown Platform! #endif }
static int winfs_getpath(struct file *f, char *buf) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *)f; buf[0] = '/'; /* the mountpoint */ memcpy(buf + 1, winfile->pathname, winfile->pathlen); buf[1 + winfile->pathlen] = 0; int r = winfile->pathlen + 1; ReleaseSRWLockShared(&f->rw_lock); return r; }
static int winfs_stat(struct file *f, struct newstat *buf) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; BY_HANDLE_FILE_INFORMATION info; GetFileInformationByHandle(winfile->handle, &info); /* Programs (ld.so) may use st_dev and st_ino to identity files so these must be unique for each file. */ INIT_STRUCT_NEWSTAT_PADDING(buf); buf->st_dev = mkdev(8, 0); // (8, 0): /dev/sda //buf->st_ino = ((uint64_t)info.nFileIndexHigh << 32ULL) + info.nFileIndexLow; /* Hash 64 bit inode to 32 bit to fix legacy applications * We may later add an option for changing this behaviour */ buf->st_ino = info.nFileIndexHigh ^ info.nFileIndexLow; if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) buf->st_mode = 0555; else buf->st_mode = 0755; if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { buf->st_mode |= S_IFDIR; buf->st_size = 0; } else { int r; if ((info.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) && (r = winfs_read_symlink_unsafe(winfile->handle, NULL, 0)) > 0) { buf->st_mode |= S_IFLNK; buf->st_size = r; } else { buf->st_mode |= S_IFREG; buf->st_size = ((uint64_t)info.nFileSizeHigh << 32ULL) + info.nFileSizeLow; } } buf->st_nlink = info.nNumberOfLinks; buf->st_uid = 0; buf->st_gid = 0; buf->st_rdev = 0; buf->st_blksize = PAGE_SIZE; buf->st_blocks = (buf->st_size + buf->st_blksize - 1) / buf->st_blksize; buf->st_atime = filetime_to_unix_sec(&info.ftLastAccessTime); buf->st_atime_nsec = filetime_to_unix_nsec(&info.ftLastAccessTime); buf->st_mtime = filetime_to_unix_sec(&info.ftLastWriteTime); buf->st_mtime_nsec = filetime_to_unix_nsec(&info.ftLastWriteTime); buf->st_ctime = filetime_to_unix_sec(&info.ftCreationTime); buf->st_ctime_nsec = filetime_to_unix_nsec(&info.ftCreationTime); ReleaseSRWLockShared(&f->rw_lock); return 0; }
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock) { if (rwlock->exclusive_locked != 0) { rwlock->exclusive_locked = 0; ReleaseSRWLockExclusive(&rwlock->rwlock); } else ReleaseSRWLockShared(&rwlock->rwlock); return (0); }
FSP_API VOID FspFileSystemReadDirectoryBuffer(PVOID *PDirBuffer, PWSTR Marker, PVOID Buffer, ULONG Length, PULONG PBytesTransferred) { FSP_FILE_SYSTEM_DIRECTORY_BUFFER *DirBuffer = *PDirBuffer; MemoryBarrier(); if (0 != DirBuffer) { AcquireSRWLockShared(&DirBuffer->Lock); PULONG Index = (PULONG)(DirBuffer->Buffer + DirBuffer->HiMark); ULONG Count = (DirBuffer->Capacity - DirBuffer->HiMark) / sizeof(ULONG); ULONG IndexNum; FSP_FSCTL_DIR_INFO *DirInfo; if (0 == Marker) IndexNum = 0; else { FspFileSystemSearchDirectoryBuffer(DirBuffer, Marker, lstrlenW(Marker), &IndexNum); IndexNum++; } for (; IndexNum < Count; IndexNum++) { DirInfo = (PVOID)(DirBuffer->Buffer + Index[IndexNum]); if (!FspFileSystemAddDirInfo(DirInfo, Buffer, Length, PBytesTransferred)) { ReleaseSRWLockShared(&DirBuffer->Lock); return; } } ReleaseSRWLockShared(&DirBuffer->Lock); } FspFileSystemAddDirInfo(0, Buffer, Length, PBytesTransferred); }
_PPLXIMP void reader_writer_lock_impl::unlock() { if(m_locked_exclusive) { m_locked_exclusive = false; ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(&_M_impl)); } else { ReleaseSRWLockShared(reinterpret_cast<PSRWLOCK>(&_M_impl)); } }
static int winfs_fsync(struct file *f) { AcquireSRWLockShared(&f->rw_lock); struct winfs_file *winfile = (struct winfs_file *) f; BOOL ok = FlushFileBuffers(winfile->handle); ReleaseSRWLockShared(&f->rw_lock); if (!ok) { log_warning("FlushFileBuffers() failed, error code: %d", GetLastError()); return -L_EIO; } return 0; }
void CPacBioUtility::ReleaseLock(bool bExclusive) { #ifdef _WIN32 if(bExclusive) ReleaseSRWLockExclusive(&m_hRwLock); else ReleaseSRWLockShared(&m_hRwLock); #else pthread_rwlock_unlock(&m_hRwLock); #endif }
void ui::update() { field.update(); if (TryAcquireSRWLockShared(&uilock)) { for (map<char, uielement*>::iterator elit = elements.begin(); elit != elements.end(); elit++) { elit->second->update(); } ReleaseSRWLockShared(&uilock); } mouse.update(); }
void ui::draw(ID2D1HwndRenderTarget* target) { field.draw(target); if (TryAcquireSRWLockShared(&uilock)) { for (map<char, uielement*>::iterator elit = elements.begin(); elit != elements.end(); elit++) { elit->second->draw(target); } ReleaseSRWLockShared(&uilock); } mouse.draw(target); }
ts_tree_node_t* ts_tree_find_and_ref(ts_tree_t* ts_tree, uintptr_t key) { ts_tree_node_t* ts_tree_node; AcquireSRWLockShared(&ts_tree->lock); ts_tree_node = ts_tree__find_node(ts_tree, key); if (ts_tree_node != NULL) reflock_ref(&ts_tree_node->reflock); ReleaseSRWLockShared(&ts_tree->lock); return ts_tree_node; }