Posix_File.cpp

Go to the documentation of this file.

#include "joedb/journal/Posix_File.h"
#include "joedb/error/Exception.h"
#include "joedb/error/Global_Logger.h"
 
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <errno.h>
#include <string.h>
#include <filesystem>
 
#ifdef JOEDB_HAS_BROKEN_POSIX_LOCKING
#define JOEDB_SETLK F_SETLK
#define JOEDB_SETLKW F_SETLKW
//#warning is C++23
//#warning Joedb is using old-style POSIX locks. File locking is broken if you open the same file more than once within the same process. New OFD locks work better and should be enabled if your system supports them.
#else
#define JOEDB_SETLK F_OFD_SETLK
#define JOEDB_SETLKW F_OFD_SETLKW
#endif
 
namespace joedb
{
#ifndef _FILE_OFFSET_BITS
 static_assert
 (
  sizeof(off_t) == sizeof(int64_t),
  "Define the _FILE_OFFSET_BITS macro to 32 or 64 to silence this error. 64 is recommended if possible. Joedb does not check for file-size overflow."
 );
#endif
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::throw_last_error(const char *action) const
 /////////////////////////////////////////////////////////////////////////////
 {
  throw Exception
  (
   std::string(action) + ' ' + file_name + ": " + ::strerror(errno)
  );
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NOLINTNEXTLINE(readability-make-member-function-const)
 int Posix_File::lock(int command, short type, int64_t start, int64_t size)
 /////////////////////////////////////////////////////////////////////////////
 {
  struct flock lock;
  lock.l_type = type;
  lock.l_whence = SEEK_SET;
  lock.l_start = off_t(start);
  lock.l_len = off_t(size);
  lock.l_pid = 0;
 
  return ::fcntl(posix_fd.get_fd(), command, &lock);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 bool Posix_File::try_exclusive_lock(int64_t start, int64_t size)
 /////////////////////////////////////////////////////////////////////////////
 {
  return lock(JOEDB_SETLK, F_WRLCK, start, size) == 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::shared_lock(int64_t start, int64_t size)
 /////////////////////////////////////////////////////////////////////////////
 {
  if (lock(JOEDB_SETLKW, F_RDLCK, start, size) < 0)
   throw_last_error("read-locking");
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::exclusive_lock(int64_t start, int64_t size)
 /////////////////////////////////////////////////////////////////////////////
 {
  if (lock(JOEDB_SETLKW, F_WRLCK, start, size) < 0)
   throw_last_error("write-locking");
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::unlock(int64_t start, int64_t size) noexcept
 /////////////////////////////////////////////////////////////////////////////
 {
  lock(JOEDB_SETLK, F_UNLCK, start, size);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 size_t Posix_File::pread(char *buffer, size_t size, int64_t offset) const
 /////////////////////////////////////////////////////////////////////////////
 {
  const ssize_t result = ::pread(posix_fd.get_fd(), buffer, size, offset);
 
  if (result < 0)
   throw_last_error("reading");
 
  return size_t(result);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::pwrite(const char *buffer, size_t size, int64_t offset)
 /////////////////////////////////////////////////////////////////////////////
 {
  size_t written = 0;
 
  while (written < size)
  {
   const ssize_t result = ::pwrite
   (
    posix_fd.get_fd(),
    buffer + written,
    size - written,
    offset + written
   );
 
   if (result < 0)
    throw_last_error("writing");
   else
    written += size_t(result);
  }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 int Posix_FD::fullsync()
 /////////////////////////////////////////////////////////////////////////////
 {
#ifdef __APPLE__
  return ::fcntl(fd, F_FULLFSYNC);
#else
  return ::fsync(fd);
#endif
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::sync()
 /////////////////////////////////////////////////////////////////////////////
 {
  if (posix_fd.fullsync() == -1)
   throw_last_error("syncing");
 
  if (!created_durably && !file_name.empty())
  {
   auto directory = std::filesystem::path(file_name).parent_path();
   if (directory.empty())
    directory = ".";
 
   Posix_FD dir_fd(::open(directory.c_str(), O_RDONLY | O_DIRECTORY));
 
   if (dir_fd.get_fd() < 0)
   {
    // ignore errors (OK if the directory was moved, ...)
    Global_Logger::warning("could not open parent directory for fsync: " + file_name);
   }
   else
   {
    if (dir_fd.fullsync() < 0)
    {
     // also ignore errors (do like sqlite)
     Global_Logger::warning("fsync failed on parent directory: " + file_name);
    }
   }
 
   created_durably = true;
  }
 }
 
#if _POSIX_SYNCHRONIZED_IO > 0
 /////////////////////////////////////////////////////////////////////////////
 void Posix_File::datasync()
 /////////////////////////////////////////////////////////////////////////////
 {
  if (::fdatasync(posix_fd.get_fd()) == -1)
  {
   throw_last_error("syncing");
  }
 }
#endif
 
 /////////////////////////////////////////////////////////////////////////////
 Posix_FD::Posix_FD(const char *file_name, const Open_Mode mode)
 /////////////////////////////////////////////////////////////////////////////
 {
  if (mode == Open_Mode::read_existing)
   fd = ::open(file_name, O_RDONLY);
  else if (mode == Open_Mode::write_existing)
   fd = ::open(file_name, O_RDWR);
  else if (mode == Open_Mode::create_new)
   fd = ::open(file_name, O_RDWR | O_CREAT | O_EXCL, 00644);
  else if
  (
   mode == Open_Mode::write_existing_or_create_new ||
   mode == Open_Mode::shared_write ||
   mode == Open_Mode::write_lock
  )
  {
   fd = ::open(file_name, O_RDWR | O_CREAT, 00644);
  }
  else
   fd = -1;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 Posix_File::Posix_File(const char *file_name, const Open_Mode mode):
 /////////////////////////////////////////////////////////////////////////////
  Abstract_File(mode),
  posix_fd(file_name, mode),
  file_name(file_name)
 {
  if (posix_fd.get_fd() < 0)
   throw_last_error("opening");
 
  if (mode == Open_Mode::write_lock)
   exclusive_lock_tail();
  else if (
   mode == Open_Mode::write_existing ||
   mode == Open_Mode::create_new ||
   mode == Open_Mode::write_existing_or_create_new)
  {
   if (!try_exclusive_lock(last_position, 1))
    throw_last_error("locking");
  }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 int64_t Posix_File::get_size() const
 /////////////////////////////////////////////////////////////////////////////
 {
  struct stat s;
 
  if (::fstat(posix_fd.get_fd(), &s) < 0)
   throw_last_error("getting size of");
 
  return int64_t(s.st_size);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 Posix_FD::~Posix_FD()
 /////////////////////////////////////////////////////////////////////////////
 {
  ::close(fd);
 }
}