FileDescriptor.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef POSIX_FILEDESCRIPTOR_H
#define POSIX_FILEDESCRIPTOR_H
 
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/FilesystemContext.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/Process.h"
#include "pedigree/kernel/process/Readiness.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/String.h"
 
#include "advisory-lock-state.h"
 
class ConsoleIoState;
class File;
class UnixSocket;
class IoEvent;
class NetworkSyscalls;
class EpollInstance;
class EventFd;
class TimerFd;
class SignalFd;
class InotifyInstance;
class FanotifyInstance;
class PosixMessageQueue;
 
class EXPORTED_PUBLIC FileDescriptor {
 public:
  class PositionGuard;
  class TransferPositionGuard;
 
  class OpenFileDescription {
   public:
    ~OpenFileDescription();
    SharedPointer<Process::ControllingTerminal> terminalContext;
    SharedPointer<FilesystemWriteLease> mountWrite;
 
    AdvisoryOwner& advisoryOwner() {
      return m_AdvisoryOwner;
    }
 
    uint64_t identity() const {
      return m_AdvisoryOwner.identity();
    }
 
    File* getFile() const {
      return path ? path->node() : anonymousFile;
    }
    FilesystemPathRef openingPath() const;
    ReadyMask queryFileReady(bool reading, bool writing) const;
    ReadinessGenerations fileReadinessGenerations() const;
    SharedPointer<ConsoleIoState> terminalEpoch(bool waitForReopen = true) const;
    // Endpoint owners are set before descriptor publication and never replaced.
    // Retaining the description therefore protects lock-free owner snapshots.
    SharedPointer<NetworkSyscalls> getNetworkImpl() const;
    SharedPointer<EventFd> getEventFdImpl() const;
    SharedPointer<TimerFd> getTimerFdImpl() const;
    SharedPointer<SignalFd> getSignalFdImpl() const;
    SharedPointer<InotifyInstance> getInotifyImpl() const;
    SharedPointer<FanotifyInstance> getFanotifyImpl() const;
    SharedPointer<PosixMessageQueue> getMqueueImpl() const;
    size_t descriptorOwnerCount() const;
 
   private:
    friend class FileDescriptor;
    friend class PositionGuard;
    friend class TransferPositionGuard;
 
    OpenFileDescription(File* file, uint64_t initialOffset, int initialStatusFlags);
    OpenFileDescription(const FilesystemPathRef& path, uint64_t initialOffset,
                        int initialStatusFlags);
 
    void addDescriptorOwner();
    void removeDescriptorOwner();
    void ensureVfsLease();
 
    AdvisoryOwner m_AdvisoryOwner;
    mutable Mutex lock;
    // Exactly one arm is set. Path-based descriptions derive their File from path.
    FilesystemPathRef path;
    File* anonymousFile;
    SharedPointer<NetworkSyscalls> networkImpl;
    SharedPointer<EventFd> eventFdImpl;
    SharedPointer<TimerFd> timerFdImpl;
    SharedPointer<SignalFd> signalFdImpl;
    SharedPointer<InotifyInstance> inotifyImpl;
    SharedPointer<FanotifyInstance> fanotifyImpl;
    SharedPointer<PosixMessageQueue> mqueueImpl;
    SharedPointer<ConsoleIoState> consoleEpoch;
    uint64_t offset;
    const int accessFlags;
    int statusFlags;
    size_t descriptorOwners;
    bool vfsLease;
    bool allowTruncate = true;
  };
 
  using OpenFileDescriptionLease = SharedPointer<OpenFileDescription>;
 
  class PositionGuard {
   public:
    uint64_t offset() const {
      return m_Description->offset;
    }
 
    int statusFlags() const {
      return m_Description->statusFlags;
    }
 
    File* file() const {
      return m_Description->getFile();
    }
 
    bool isNoopSeekEndpoint() const {
      return m_Description->timerFdImpl || m_Description->signalFdImpl ||
             m_Description->fanotifyImpl;
    }
 
    void setOffset(uint64_t offset) {
      m_Description->offset = offset;
    }
 
    void advanceOffset(uint64_t amount) {
      m_Description->offset += amount;
    }
 
   private:
    friend class FileDescriptor;
 
    explicit PositionGuard(const SharedPointer<OpenFileDescription>& description);
 
    SharedPointer<OpenFileDescription> m_Description;
    LockGuard<Mutex> m_Guard;
  };
 
  class TransferPositionGuard {
   public:
    enum class Endpoint { Input, Output };
    TransferPositionGuard(const OpenFileDescriptionLease& input,
                          const OpenFileDescriptionLease& output, bool lockInput, bool lockOutput);
    ~TransferPositionGuard();
    TransferPositionGuard(const TransferPositionGuard&) = delete;
    TransferPositionGuard& operator=(const TransferPositionGuard&) = delete;
 
    int statusFlags(Endpoint endpoint) const;
    uint64_t offset(Endpoint endpoint) const;
    void commitOffset(Endpoint endpoint, uint64_t finalOffset);
    bool sameDescription() const;
 
   private:
    OpenFileDescription& lockedDescription(Endpoint endpoint) const;
 
#if THREADS && !defined(STANDALONE_MUTEXES)
    TerminationDeferral m_TerminationDeferral;
#endif
    OpenFileDescriptionLease m_Input;
    OpenFileDescriptionLease m_Output;
    OpenFileDescription* m_First;
    OpenFileDescription* m_Second;
    int m_InputFlags;
    int m_OutputFlags;
  };
 
  FileDescriptor();
 
  FileDescriptor(File* newFile, uint64_t newOffset = 0, size_t newFd = 0xFFFFFFFF, int fdFlags = 0,
                 int flFlags = 0);
 
  FileDescriptor(const FilesystemPathRef& path, uint64_t newOffset = 0, size_t newFd = 0xFFFFFFFF,
                 int fdFlags = 0, int flFlags = 0);
 
  FileDescriptor(FileDescriptor& desc);
 
  FileDescriptor(FileDescriptor* desc);
 
  FileDescriptor& operator=(FileDescriptor& desc) = delete;
 
  virtual ~FileDescriptor();
 
  void setFlags(int newFlags);
 
  void addFlag(int newFlag);
 
  int getFlags() const;
 
  void setStatusFlags(int newFlags);
 
  void addStatusFlag(int newFlag);
 
  void removeStatusFlag(int flag);
 
  int getStatusFlags() const;
  bool truncateAllowed() const {
    return m_OpenFile && m_OpenFile->allowTruncate;
  }
  // Set before publication; duplicated and transferred descriptors share this grant.
  void setTruncateAllowed(bool allowed) {
    if (m_OpenFile) {
      m_OpenFile->allowTruncate = allowed;
    }
  }
 
  // F_SETFL cannot change access permissions; permission checks need no OFD lock.
  int getAccessFlags() const {
    return m_OpenFile->accessFlags;
  }
 
  OpenFileDescriptionLease acquireOpenFileDescription() const;
 
  void setNetworkImpl(const SharedPointer<NetworkSyscalls>& implementation);
 
  bool networkPublished() const;
 
  void setEventFdImpl(const SharedPointer<EventFd>& implementation);
 
  SharedPointer<EventFd> getEventFdImpl() const;
 
  bool eventFdPublished() const;
 
  void setTimerFdImpl(const SharedPointer<TimerFd>& implementation);
  SharedPointer<TimerFd> getTimerFdImpl() const;
  bool timerFdPublished() const;
 
  void setSignalFdImpl(const SharedPointer<SignalFd>& implementation);
  SharedPointer<SignalFd> getSignalFdImpl() const;
  bool signalFdPublished() const;
 
  void setInotifyImpl(const SharedPointer<InotifyInstance>& implementation);
 
  SharedPointer<InotifyInstance> getInotifyImpl() const;
  void setFanotifyImpl(const SharedPointer<FanotifyInstance>& implementation);
  SharedPointer<FanotifyInstance> getFanotifyImpl() const;
 
  void setMqueueImpl(const SharedPointer<PosixMessageQueue>& implementation);
  SharedPointer<PosixMessageQueue> getMqueueImpl() const;
 
  void unpublish();
 
  PositionGuard lockPosition() const;
 
  uint64_t getOffset() const;
 
  void setOffset(uint64_t offset);
 
  uint64_t read(uint64_t size, uintptr_t buffer, bool canBlock = true);
 
  uint64_t write(uint64_t size, uintptr_t buffer, bool canBlock = true);
 
  class TerminalOperation {
   public:
    TerminalOperation();
    ~TerminalOperation();
 
   private:
    friend class FileDescriptor;
    TerminationDeferral lifetime;
    SharedPointer<ConsoleIoState> state;
    OperationBarrier::Lease operation;
  };
 
  bool acquireTerminalOperation(TerminalOperation& operation) const;
  bool terminalHungUp() const;
  bool terminalAvailable() const;
  SharedPointer<ConsoleIoState> terminalEpoch(bool waitForReopen = true) const;
  uint64_t readFile(uint64_t location, uint64_t size, uintptr_t buffer, bool canBlock);
  uint64_t writeFile(uint64_t location, uint64_t size, uintptr_t buffer, bool canBlock);
 
  File* getFile() const {
    return m_OpenFile ? m_OpenFile->getFile() : nullptr;
  }
  FilesystemPathRef openingPath() const;
 
  size_t fd;
 
  SharedPointer<NetworkSyscalls> networkImpl;
 
  SharedPointer<EpollInstance> epollImpl;
 
  IoEvent* ioevent;
 
 public:  
  int fdflags;
 
 private:
  friend class PosixSubsystem;
 
  OpenFileDescriptionLease m_OpenFile;
 
  bool m_NetworkPublished;
  bool m_EventFdPublished;
  bool m_TimerFdPublished = false;
  bool m_SignalFdPublished = false;
};
 
#endif