| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // See http://www.boost.org/libs/interprocess for documentation. |
| // |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTERPROCESS_FILE_LOCK_HPP |
| #define BOOST_INTERPROCESS_FILE_LOCK_HPP |
| |
| #if (defined _MSC_VER) && (_MSC_VER >= 1200) |
| # pragma once |
| #endif |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| #include <boost/interprocess/exceptions.hpp> |
| #include <boost/interprocess/detail/os_file_functions.hpp> |
| #include <boost/interprocess/detail/os_thread_functions.hpp> |
| #include <boost/interprocess/detail/posix_time_types_wrk.hpp> |
| #include <boost/interprocess/detail/move.hpp> |
| |
| //!\file |
| //!Describes a class that wraps file locking capabilities. |
| |
| namespace boost { |
| namespace interprocess { |
| |
| |
| //!A file lock, is a mutual exclusion utility similar to a mutex using a |
| //!file. A file lock has sharable and exclusive locking capabilities and |
| //!can be used with scoped_lock and sharable_lock classes. |
| //!A file lock can't guarantee synchronization between threads of the same |
| //!process so just use file locks to synchronize threads from different processes. |
| class file_lock |
| { |
| /// @cond |
| //Non-copyable |
| BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(file_lock) |
| /// @endcond |
| |
| public: |
| //!Constructs an empty file mapping. |
| //!Does not throw |
| file_lock() |
| : m_file_hnd(file_handle_t(detail::invalid_file())) |
| {} |
| |
| //!Opens a file lock. Throws interprocess_exception if the file does not |
| //!exist or there are no operating system resources. |
| file_lock(const char *name); |
| |
| //!Moves the ownership of "moved"'s file mapping object to *this. |
| //!After the call, "moved" does not represent any file mapping object. |
| //!Does not throw |
| file_lock(BOOST_INTERPROCESS_RV_REF(file_lock) moved) |
| : m_file_hnd(file_handle_t(detail::invalid_file())) |
| { this->swap(moved); } |
| |
| //!Moves the ownership of "moved"'s file mapping to *this. |
| //!After the call, "moved" does not represent any file mapping. |
| //!Does not throw |
| file_lock &operator=(BOOST_INTERPROCESS_RV_REF(file_lock) moved) |
| { |
| file_lock tmp(boost::interprocess::move(moved)); |
| this->swap(tmp); |
| return *this; |
| } |
| |
| //!Closes a file lock. Does not throw. |
| ~file_lock(); |
| |
| //!Swaps two file_locks. |
| //!Does not throw. |
| void swap(file_lock &other) |
| { |
| file_handle_t tmp = m_file_hnd; |
| m_file_hnd = other.m_file_hnd; |
| other.m_file_hnd = tmp; |
| } |
| |
| //Exclusive locking |
| |
| //!Effects: The calling thread tries to obtain exclusive ownership of the mutex, |
| //! and if another thread has exclusive, or sharable ownership of |
| //! the mutex, it waits until it can obtain the ownership. |
| //!Throws: interprocess_exception on error. |
| void lock(); |
| |
| //!Effects: The calling thread tries to acquire exclusive ownership of the mutex |
| //! without waiting. If no other thread has exclusive, or sharable |
| //! ownership of the mutex this succeeds. |
| //!Returns: If it can acquire exclusive ownership immediately returns true. |
| //! If it has to wait, returns false. |
| //!Throws: interprocess_exception on error. |
| bool try_lock(); |
| |
| //!Effects: The calling thread tries to acquire exclusive ownership of the mutex |
| //! waiting if necessary until no other thread has has exclusive, or sharable |
| //! ownership of the mutex or abs_time is reached. |
| //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. |
| //!Throws: interprocess_exception on error. |
| bool timed_lock(const boost::posix_time::ptime &abs_time); |
| |
| //!Precondition: The thread must have exclusive ownership of the mutex. |
| //!Effects: The calling thread releases the exclusive ownership of the mutex. |
| //!Throws: An exception derived from interprocess_exception on error. |
| void unlock(); |
| |
| //Sharable locking |
| |
| //!Effects: The calling thread tries to obtain sharable ownership of the mutex, |
| //! and if another thread has exclusive ownership of the mutex, waits until |
| //! it can obtain the ownership. |
| //!Throws: interprocess_exception on error. |
| void lock_sharable(); |
| |
| //!Effects: The calling thread tries to acquire sharable ownership of the mutex |
| //! without waiting. If no other thread has has exclusive ownership of the |
| //! mutex this succeeds. |
| //!Returns: If it can acquire sharable ownership immediately returns true. If it |
| //! has to wait, returns false. |
| //!Throws: interprocess_exception on error. |
| bool try_lock_sharable(); |
| |
| //!Effects: The calling thread tries to acquire sharable ownership of the mutex |
| //! waiting if necessary until no other thread has has exclusive ownership of |
| //! the mutex or abs_time is reached. |
| //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. |
| //!Throws: interprocess_exception on error. |
| bool timed_lock_sharable(const boost::posix_time::ptime &abs_time); |
| |
| //!Precondition: The thread must have sharable ownership of the mutex. |
| //!Effects: The calling thread releases the sharable ownership of the mutex. |
| //!Throws: An exception derived from interprocess_exception on error. |
| void unlock_sharable(); |
| /// @cond |
| private: |
| file_handle_t m_file_hnd; |
| |
| bool timed_acquire_file_lock |
| (file_handle_t hnd, bool &acquired, const boost::posix_time::ptime &abs_time) |
| { |
| //Obtain current count and target time |
| boost::posix_time::ptime now = microsec_clock::universal_time(); |
| using namespace boost::detail; |
| |
| if(now >= abs_time) return false; |
| |
| do{ |
| if(!detail::try_acquire_file_lock(hnd, acquired)) |
| return false; |
| |
| if(acquired) |
| return true; |
| else{ |
| now = microsec_clock::universal_time(); |
| |
| if(now >= abs_time){ |
| acquired = false; |
| return true; |
| } |
| // relinquish current time slice |
| detail::thread_yield(); |
| } |
| }while (true); |
| } |
| |
| bool timed_acquire_file_lock_sharable |
| (file_handle_t hnd, bool &acquired, const boost::posix_time::ptime &abs_time) |
| { |
| //Obtain current count and target time |
| boost::posix_time::ptime now = microsec_clock::universal_time(); |
| using namespace boost::detail; |
| |
| if(now >= abs_time) return false; |
| |
| do{ |
| if(!detail::try_acquire_file_lock_sharable(hnd, acquired)) |
| return false; |
| |
| if(acquired) |
| return true; |
| else{ |
| now = microsec_clock::universal_time(); |
| |
| if(now >= abs_time){ |
| acquired = false; |
| return true; |
| } |
| // relinquish current time slice |
| detail::thread_yield(); |
| } |
| }while (true); |
| } |
| /// @endcond |
| }; |
| |
| inline file_lock::file_lock(const char *name) |
| { |
| m_file_hnd = detail::open_existing_file(name, read_write); |
| |
| if(m_file_hnd == detail::invalid_file()){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| inline file_lock::~file_lock() |
| { |
| if(m_file_hnd != detail::invalid_file()){ |
| detail::close_file(m_file_hnd); |
| m_file_hnd = detail::invalid_file(); |
| } |
| } |
| |
| inline void file_lock::lock() |
| { |
| if(!detail::acquire_file_lock(m_file_hnd)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| inline bool file_lock::try_lock() |
| { |
| bool result; |
| if(!detail::try_acquire_file_lock(m_file_hnd, result)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| return result; |
| } |
| |
| inline bool file_lock::timed_lock(const boost::posix_time::ptime &abs_time) |
| { |
| if(abs_time == boost::posix_time::pos_infin){ |
| this->lock(); |
| return true; |
| } |
| bool result; |
| if(!this->timed_acquire_file_lock(m_file_hnd, result, abs_time)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| return result; |
| } |
| |
| inline void file_lock::unlock() |
| { |
| if(!detail::release_file_lock(m_file_hnd)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| inline void file_lock::lock_sharable() |
| { |
| if(!detail::acquire_file_lock_sharable(m_file_hnd)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| inline bool file_lock::try_lock_sharable() |
| { |
| bool result; |
| if(!detail::try_acquire_file_lock_sharable(m_file_hnd, result)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| return result; |
| } |
| |
| inline bool file_lock::timed_lock_sharable(const boost::posix_time::ptime &abs_time) |
| { |
| if(abs_time == boost::posix_time::pos_infin){ |
| this->lock_sharable(); |
| return true; |
| } |
| bool result; |
| if(!this->timed_acquire_file_lock_sharable(m_file_hnd, result, abs_time)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| return result; |
| } |
| |
| inline void file_lock::unlock_sharable() |
| { |
| if(!detail::release_file_lock_sharable(m_file_hnd)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //BOOST_INTERPROCESS_FILE_LOCK_HPP |