File lock (#4734)

* add RWLock implementation for file [posix] * add implementation FileStreamRWLock for windows replace FileStreamRWLock to the Process package * add files FileStreamRWLock* into makefile and vcproj * remove unnecessary file from makefile * use absolute path to the TesApp with ProcessRunner * fix vc*.proj * add new test files into vc.proj.filters * fix comments * fix spelling fo PR #4723 add atomic_bool _locked and check if FileStreamRWLock is locked on destruction for force unlock * add atomic header * File lock (#4740) * throw error on any errno not only on EDEADLK * fix function naming * fix windows build * fix windows build --------- Co-authored-by: Alexander B <ale.bychuk@gmail.com> Co-authored-by: bas524 <bas524@ya.ru>
2025-10-23 08:31:43 +02:00 · 2024-10-16 16:58:00 -05:00
parent 6f34ec89ce
commit e5752a5c6d
18 changed files with 1141 additions and 8 deletions
--- a/Foundation/include/Poco/FileStreamRWLock.h
+++ b/Foundation/include/Poco/FileStreamRWLock.h
@@ -0,0 +1,204 @@
+//
+// FileStreamRWLock.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  FileStreamRWLock
+//
+// Definition of the FileStreamRWLock class.
+//
+// Copyright (c) 2004-2024, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStreamRWLock_INCLUDED
+#define Foundation_FileStreamRWLock_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/FileStream.h"
+#include <atomic>
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/FileStreamRWLock_WIN32.h"
+#else
+#include "Poco/FileStreamRWLock_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class ScopedFStreamRWLock;
+class ScopedFStreamReadRWLock;
+class ScopedFStreamWriteRWLock;
+
+
+class Foundation_API FileStreamRWLock: private FileStreamRWLockImpl
+	/// A reader writer lock on the file region allows multiple concurrent
+	/// process-readers or one exclusive process-writer.
+{
+public:
+	using ScopedLock = ScopedFStreamRWLock;
+	using ScopedReadLock = ScopedFStreamReadRWLock;
+	using ScopedWriteLock = ScopedFStreamWriteRWLock;
+
+	FileStreamRWLock(const FileStream &fs, Poco::UInt64 offset, Poco::UInt64 size);
+		/// Creates the Reader/Writer lock on the file region.
+		/// offset - from start of the file
+		/// size - size of the locker region
+
+	~FileStreamRWLock();
+		/// Destroys the Reader/Writer lock on the file region.
+
+	void readLock();
+		/// Acquires a read lock. If another process currently holds a write lock,
+		/// waits until the write lock is released.
+
+	bool tryReadLock();
+		/// Tries to acquire a read lock. Immediately returns true if successful, or
+		/// false if another process currently holds a write lock.
+
+	void writeLock();
+		/// Acquires a write lock on the file region. If one or more other processes currently hold
+		/// locks, waits until all locks are released.
+
+	bool tryWriteLock();
+		/// Tries to acquire a write lock on the file region. Immediately returns true if successful,
+		/// or false if one or more other processes currently hold
+		/// locks.
+
+	void unlock();
+		/// Releases the read or write lock.
+
+private:
+	std::atomic_bool _locked = false;
+	FileStreamRWLock(const FileStreamRWLock&);
+	FileStreamRWLock& operator = (const FileStreamRWLock&);
+};
+
+
+class Foundation_API ScopedFStreamRWLock
+	/// A variant of ScopedLock for reader/writer locks.
+{
+public:
+	ScopedFStreamRWLock(FileStreamRWLock& rwl, bool write = false);
+	~ScopedFStreamRWLock();
+
+private:
+	FileStreamRWLock& _rwl;
+
+	ScopedFStreamRWLock();
+	ScopedFStreamRWLock(const ScopedFStreamRWLock&);
+	ScopedFStreamRWLock& operator = (const ScopedFStreamRWLock&);
+};
+
+
+class Foundation_API ScopedFStreamReadRWLock : public ScopedFStreamRWLock
+	/// A variant of ScopedLock for reader locks.
+{
+public:
+	ScopedFStreamReadRWLock(FileStreamRWLock& rwl);
+	~ScopedFStreamReadRWLock();
+};
+
+
+class Foundation_API ScopedFStreamWriteRWLock : public ScopedFStreamRWLock
+	/// A variant of ScopedLock for writer locks.
+{
+public:
+	ScopedFStreamWriteRWLock(FileStreamRWLock& rwl);
+	~ScopedFStreamWriteRWLock();
+};
+
+
+//
+// inlines
+//
+inline void FileStreamRWLock::readLock()
+{
+	readLockImpl();
+	_locked = true;
+}
+
+
+inline bool FileStreamRWLock::tryReadLock()
+{
+	bool locked = tryReadLockImpl();
+	if (locked) _locked = true; // assign only if success lock
+	return locked;
+}
+
+
+inline void FileStreamRWLock::writeLock()
+{
+	writeLockImpl();
+	_locked = true;
+}
+
+
+inline bool FileStreamRWLock::tryWriteLock()
+{
+	bool locked = tryWriteLockImpl();
+	if (locked) _locked = true; // assign only if success lock
+	return locked;
+}
+
+
+inline void FileStreamRWLock::unlock()
+{
+	unlockImpl();
+	_locked = false;
+}
+
+
+inline ScopedFStreamRWLock::ScopedFStreamRWLock(FileStreamRWLock& rwl, bool write): _rwl(rwl)
+{
+	if (write)
+		_rwl.writeLock();
+	else
+		_rwl.readLock();
+}
+
+
+inline ScopedFStreamRWLock::~ScopedFStreamRWLock()
+{
+	try
+	{
+		_rwl.unlock();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+inline ScopedFStreamReadRWLock::ScopedFStreamReadRWLock(FileStreamRWLock& rwl): ScopedFStreamRWLock(rwl, false)
+{
+}
+
+
+inline ScopedFStreamReadRWLock::~ScopedFStreamReadRWLock()
+{
+}
+
+
+inline ScopedFStreamWriteRWLock::ScopedFStreamWriteRWLock(FileStreamRWLock& rwl): ScopedFStreamRWLock(rwl, true)
+{
+}
+
+
+inline ScopedFStreamWriteRWLock::~ScopedFStreamWriteRWLock()
+{
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStreamRWLock_INCLUDED
--- a/Foundation/include/Poco/FileStreamRWLock_POSIX.h
+++ b/Foundation/include/Poco/FileStreamRWLock_POSIX.h
@@ -0,0 +1,115 @@
+//
+// FileStreamRWLock_POSIX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  FileStreamRWLock
+//
+// Definition of the FileStreamRWLockImpl class for POSIX FileStream.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStreamRWLock_POSIX_INCLUDED
+#define Foundation_FileStreamRWLock_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/FileStream.h"
+#include <fcntl.h>
+#include <cerrno>
+
+
+namespace Poco {
+
+
+class Foundation_API FileStreamRWLockImpl
+{
+protected:
+	FileStreamRWLockImpl(const FileStream::NativeHandle &fd, Poco::UInt64 offset, Poco::UInt64 size);
+	~FileStreamRWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+
+private:
+	FileStream::NativeHandle _fd;
+	struct flock _flock;
+	int _lockMode;
+};
+
+
+//
+// inlines
+//
+inline void FileStreamRWLockImpl::readLockImpl()
+{
+	_flock.l_type = F_RDLCK;
+	_lockMode = F_SETLKW;
+	int rc = fcntl(_fd, _lockMode, &_flock);
+	if (rc == -1)
+		throw SystemException("cannot lock reader lock", errno);
+}
+
+
+inline bool FileStreamRWLockImpl::tryReadLockImpl()
+{
+	_flock.l_type = F_RDLCK;
+	_lockMode = F_SETLK;
+	int rc = fcntl(_fd, _lockMode, &_flock);
+	if (rc == 0)
+		return true;
+	else if (errno == EAGAIN || errno == EACCES)
+		return false;
+	else
+		throw SystemException("cannot lock try-reader lock", errno);
+
+}
+
+
+inline void FileStreamRWLockImpl::writeLockImpl()
+{
+	_flock.l_type = F_WRLCK;
+	_lockMode = F_SETLKW;
+	int rc = fcntl(_fd, _lockMode, &_flock);
+	if (rc == -1)
+		throw SystemException("cannot lock writer lock", errno);
+}
+
+
+inline bool FileStreamRWLockImpl::tryWriteLockImpl()
+{
+	_flock.l_type = F_WRLCK;
+	_lockMode = F_SETLK;
+	int rc = fcntl(_fd, _lockMode, &_flock);
+	if (rc != -1)
+		return true;
+	else if (errno == EAGAIN || errno == EACCES)
+		return false;
+	else
+		throw SystemException("cannot lock writer lock", errno);
+
+}
+
+
+inline void FileStreamRWLockImpl::unlockImpl()
+{
+	_flock.l_type = F_UNLCK;
+	_lockMode = F_SETLKW;
+	int rc = fcntl(_fd, _lockMode, &_flock);
+	if (rc == -1)
+		throw SystemException("cannot unlock", errno);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStreamRWLock_POSIX_INCLUDED
--- a/Foundation/include/Poco/FileStreamRWLock_WIN32.h
+++ b/Foundation/include/Poco/FileStreamRWLock_WIN32.h
@@ -0,0 +1,134 @@
+//
+// FileStreamRWLock_WIN32.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  FileStreamRWLock
+//
+// Definition of the FileStreamRWLockImpl class for WIN32 FileStream.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStreamRWLock_WIN32_INCLUDED
+#define Foundation_FileStreamRWLock_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/FileStream.h"
+#include <Windows.h>
+
+namespace Poco {
+
+struct LockMode
+{
+	static constexpr DWORD READ = 0;
+	static constexpr DWORD WRITE = LOCKFILE_EXCLUSIVE_LOCK;
+	static constexpr DWORD TRY_READ = LOCKFILE_FAIL_IMMEDIATELY;
+	static constexpr DWORD TRY_WRITE = (LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY);
+};
+
+class Foundation_API FileStreamRWLockImpl
+{
+protected:
+	FileStreamRWLockImpl(const FileStream::NativeHandle &fd, Poco::UInt64 offset, Poco::UInt64 size);
+	~FileStreamRWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+
+private:
+	FileStream::NativeHandle _fd;
+	OVERLAPPED _overlapped;
+	LARGE_INTEGER _size;
+};
+
+
+//
+// inlines
+//
+inline void FileStreamRWLockImpl::readLockImpl()
+{
+	BOOL fSuccess = LockFileEx(_fd, LockMode::READ, 0, _size.LowPart, _size.HighPart, &_overlapped);
+	if (!fSuccess)
+	{
+		throw SystemException("cannot lock reader lock", GetLastError());
+	}
+}
+
+
+inline bool FileStreamRWLockImpl::tryReadLockImpl()
+{
+	BOOL fSuccess = LockFileEx(_fd, LockMode::TRY_READ, 0, _size.LowPart, _size.HighPart, &_overlapped);
+	if (fSuccess)
+	{
+		return true;
+	}
+	else
+	{
+		auto lastError = GetLastError();
+		if (lastError == ERROR_IO_PENDING || lastError == ERROR_LOCK_VIOLATION)
+		{
+			return false;
+		}
+		else
+		{
+			throw SystemException("cannot lock try-reader lock", lastError);
+		}
+	}
+}
+
+
+inline void FileStreamRWLockImpl::writeLockImpl()
+{
+	BOOL fSuccess = LockFileEx(_fd, LockMode::WRITE, 0, _size.LowPart, _size.HighPart, &_overlapped);
+	if (!fSuccess)
+	{
+		throw SystemException("cannot lock writer lock", GetLastError());
+	}
+}
+
+
+inline bool FileStreamRWLockImpl::tryWriteLockImpl()
+{
+	BOOL fSuccess = LockFileEx(_fd, LockMode::TRY_WRITE, 0, _size.LowPart, _size.HighPart, &_overlapped);
+	if (fSuccess)
+	{
+		return true;
+	}
+	else 
+	{
+		auto lastError = GetLastError();
+		if (lastError == ERROR_IO_PENDING || lastError == ERROR_LOCK_VIOLATION)
+		{
+			return false;
+		}
+		else
+		{
+			throw SystemException("cannot lock try-writer lock", lastError);
+		}
+	}
+}
+
+
+inline void FileStreamRWLockImpl::unlockImpl()
+{
+	BOOL fSuccess = UnlockFileEx(_fd, 0, _size.LowPart, _size.HighPart, &_overlapped);
+	if (!fSuccess)
+	{
+		throw SystemException("cannot unlock ", GetLastError());
+	}
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStreamRWLock_WIN32_INCLUDED