FileHandle.Linux.cpp

#include "FileHandle.h"
 
#include "../StringView.h"
 
#include "../Logging/Logger.h"
 
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("FileHandle");
}
 
Cogs::FileHandle::~FileHandle() {
  close();
}
 
Cogs::FileHandle::Ptr Cogs::FileHandle::open(std::string_view path, OpenMode openMode, AccessMode accessMode) {
  Ptr handle = std::make_shared<FileHandle>();
  int flags = 0;
 
  if (accessMode == AccessMode::Read) {
    flags = O_RDONLY;
 
    if (openMode == OpenMode::OpenAlways) {
      flags |= O_CREAT;
    }
  }
  else {
    flags = O_WRONLY;
 
    switch (openMode) {
      case OpenMode::Create:        flags |= O_CREAT | O_EXCL;    break;
      case OpenMode::CreateAlways:  flags |= O_CREAT | O_TRUNC;   break;
      case OpenMode::OpenAlways:    flags |= O_CREAT;             break;
      case OpenMode::Open:                                        break;
    }
  }
 
  handle->fileDescriptor = ::open(std::string(path).c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 
  if (handle->isOpen()) {
    return handle;
  }
  LOG_ERROR(logger, "Failed to open %.*s. Error: %s.", StringViewFormat(path), strerror( errno ));
  return nullptr;
}
 
void Cogs::FileHandle::close() {
  if (isOpen()) {
    ::close(fileDescriptor);
    fileDescriptor = -1;
  }
}
 
bool Cogs::FileHandle::isOpen() const {
  return fileDescriptor != -1;
}
 
size_t Cogs::FileHandle::getSize() const {
  if (isOpen()) {
    struct stat buf = {};
    int ret = ::fstat(fileDescriptor, &buf);
    if(ret == -1){
      LOG_ERROR(logger, "fstat error: %s.", strerror( errno ));
      return 0;
    }
    return buf.st_size;
  }
  LOG_WARNING(logger, "Tried to query size of closed file.");
  return 0;
}
 
bool Cogs::FileHandle::write(const void* ptr, size_t size, size_t& bytesWritten)
{
  const uint8_t*  src = reinterpret_cast<const uint8_t*>(ptr);
 
  bytesWritten = 0;
 
  for (constexpr size_t limit = 0x7ffff000; size > limit; ) {
    ssize_t justWritten = ::write(fileDescriptor, src, limit);
 
    if (justWritten >= 0) {
      bytesWritten += justWritten;
      size -= justWritten;
      src += justWritten;
    }
    else {
      LOG_ERROR(logger, "Failed to write FileHandle %d. Error: %s.", fileDescriptor, strerror(errno));
      return false;
    }
  }
  if (size) {
    ssize_t justWritten = ::write(fileDescriptor, src, size);
 
    if (justWritten >= 0) {
      bytesWritten += justWritten;
    }
    else {
      LOG_ERROR(logger, "Failed to write FileHandle %d. Error: %s.", fileDescriptor, strerror(errno));
      return false;
    }
  }
  return true;
}
 
bool Cogs::FileHandle::read(void* buffer, size_t size, size_t& bytesRead)
{
  uint8_t*  dest = reinterpret_cast<uint8_t*>(buffer);
 
  bytesRead = 0;
 
  for (constexpr size_t limit = 0x7ffff000; size > limit; ) {
    ssize_t justRead = ::read(fileDescriptor, dest, limit);
 
    if (justRead >= 0) {
      dest += justRead;
      size -= justRead;
      bytesRead += justRead;
    }
    else {
      LOG_ERROR(logger, "Failed to read FileHandle %d. Error: %s.", fileDescriptor, strerror(errno));
      return false;
    }
  }
  if (size) {
    ssize_t justRead = ::read(fileDescriptor, dest, size);
 
    if (justRead >= 0) {
      bytesRead += justRead;
    }
    else {
      LOG_ERROR(logger, "Failed to read FileHandle %d. Error: %s.", fileDescriptor, strerror(errno));
      return false;
    }
  }
  return true;
}
 
void* Cogs::FileHandle::map(ProtectionMode /*protectionMode*/, size_t offset, size_t size) {
  if (isOpen()) {
    if (!isMapped()) {
      mappedMemory = ::mmap(nullptr, size, PROT_READ, MAP_SHARED, fileDescriptor, offset);
 
      if (mappedMemory) {
        mappedSize = size;
        return mappedMemory;
      }
      else {
        LOG_ERROR(logger, "Failed to map file into memory. Error: %s", strerror( errno ));
      }
    }
    else {
      LOG_ERROR(logger, "File handle cannot be mapped multiple times.");
    }
  }
  else {
    LOG_ERROR(logger, "Files must be opened before they can be memory mapped.");
  }
  return nullptr;
}
 
void Cogs::FileHandle::unmap() {
  if (mappedMemory) {
    ::munmap(mappedMemory, mappedSize);
 
    mappedMemory = nullptr;
    mappedSize = 0;
  }
}