Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122//// locking.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Defines _locking(), which locks and unlocks regions of a file.//#include <corecrt_internal_lowio.h>#include <sys/locking.h>
static int __cdecl locking_nolock(int const fh, int const locking_mode, long const number_of_bytes) throw(){ __int64 const lock_offset = _lseeki64_nolock(fh, 0L, SEEK_CUR); if (lock_offset == -1) return -1;
OVERLAPPED overlapped = { 0 }; overlapped.Offset = static_cast<DWORD>(lock_offset); overlapped.OffsetHigh = static_cast<DWORD>((lock_offset >> 32) & 0xffffffff);
// Set the retry count, based on the mode: bool const allow_retry = locking_mode == _LK_LOCK || locking_mode == _LK_RLCK; int const retry_count = allow_retry ? 10 : 1;
// Ask the OS to lock the file either until the request succeeds or the // retry count is reached, whichever comes first. Note that the only error // possible is a locking violation, since an invalid handle would have // already failed above. bool succeeded = false; for (int i = 0; i != retry_count; ++i) { if (locking_mode == _LK_UNLCK) { succeeded = UnlockFileEx( reinterpret_cast<HANDLE>(_get_osfhandle(fh)), 0, number_of_bytes, 0, &overlapped) == TRUE; } else { // Ensure exclusive lock access, and return immediately if lock // acquisition fails: succeeded = LockFileEx( reinterpret_cast<HANDLE>(_get_osfhandle(fh)), LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, number_of_bytes, 0, &overlapped) == TRUE; }
if (succeeded) { break; }
// Doesnt sleep on the last try if (i != retry_count - 1) { Sleep(1000); } }
// If an OS error occurred (e.g., if the file was already locked), return // EDEADLOCK if this was ablocking call; otherwise map the error noramlly: if (!succeeded) { __acrt_errno_map_os_error(GetLastError()); if (locking_mode == _LK_LOCK || locking_mode == _LK_RLCK) { errno = EDEADLOCK; }
return -1; }
return 0;}
// Locks or unlocks the requested number of bytes in the specified file.//// Note that this function acquires the lock for the specified file and holds// this lock for the entire duration of the call, even during the one second// delays between calls into the operating system. This is to prevent other// threads from changing the file during the call.//// Returns 0 on success; returns -1 and sets errno on failure.extern "C" int __cdecl _locking(int const fh, int const locking_mode, long const number_of_bytes){ _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1); _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1); _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1); _VALIDATE_CLEAR_OSSERR_RETURN(number_of_bytes >= 0, EINVAL, -1);
__acrt_lowio_lock_fh(fh); int result = -1; __try { if ((_osfile(fh) & FOPEN) == 0) { errno = EBADF; _doserrno = 0; _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0)); __leave; }
result = locking_nolock(fh, locking_mode, number_of_bytes); } __finally { __acrt_lowio_unlock_fh(fh); } __endtry return result;}