Pipe.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 PIPE_H
#define PIPE_H
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/ConditionVariable.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/String.h"
 
#include "File.h"
#include "PipeBuffer.h"
 
#define PIPE_BUF_MAX 4096
 
class EXPORTED_PUBLIC Pipe : public File {
  friend class Filesystem;
  friend class ZombiePipe;
 
 public:
  static Pipe* fromFile(File* pF) {
    if (!(pF->isPipe() || pF->isFifo()))
      FATAL("Casting non-pipe/fifo File to Pipe!");
    return reinterpret_cast<Pipe*>(pF);
  }
 
  Pipe();
 
  Pipe(const Pipe& file);
 
 private:
  Pipe& operator=(const Pipe&);
 
 public:
  Pipe(const String& name, Time::Timestamp accessedTime, Time::Timestamp modifiedTime,
       Time::Timestamp creationTime, uintptr_t inode, class Filesystem* pFs, size_t size,
       File* pParent, bool bIsAnonymous = false);
  virtual ~Pipe();
 
  virtual int select(bool bWriting = false, int timeout = 0);
 
  ReadyMask queryReady(bool reading, bool writing) override;
  ReadinessGenerations readinessGenerations() override;
 
  bool supportsReadinessNotifications() const override {
    return true;
  }
 
  virtual uint64_t readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                bool bCanBlock = true);
  virtual uint64_t writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                 bool bCanBlock = true);
 
  virtual bool isPipe() const;
  virtual bool isFifo() const;
 
  virtual bool isSeekable() const {
    return false;
  }
 
  virtual void increaseRefCount(bool bIsWriter);
 
  virtual void decreaseRefCount(bool bIsWriter);
 
  bool retainVfsReference() override;
 
  void releaseVfsReference() override;
 
  size_t readableBytes();
 
  size_t getReaderCount();
 
  size_t getWriterCount();
 
  bool waitForReader(bool bCanBlock);
 
  class EXPORTED_PUBLIC ReadReservation {
   public:
    ReadReservation() = default;
    ~ReadReservation();
    ReadReservation(const ReadReservation&) = delete;
    ReadReservation& operator=(const ReadReservation&) = delete;
    size_t size() const;
    void copyTo(uint8_t* destination, size_t count) const;
    void consume(size_t accepted);
    void cancel();
 
   private:
    friend class Pipe;
    TerminationDeferral m_Termination;
    Pipe* m_Pipe = nullptr;
    PipeBuffer::ReadReservation m_Reservation;
  };
 
  class EXPORTED_PUBLIC WriteReservation {
   public:
    WriteReservation() = default;
    ~WriteReservation();
    WriteReservation(const WriteReservation&) = delete;
    WriteReservation& operator=(const WriteReservation&) = delete;
    size_t size() const;
    PipeBuffer::Result commit(const uint8_t* source, size_t accepted);
    void cancel();
 
   private:
    friend class Pipe;
    TerminationDeferral m_Termination;
    Pipe* m_Pipe = nullptr;
    PipeBuffer::WriteReservation m_Reservation;
  };
 
  PipeBuffer::Result reserveRead(size_t maximum, bool block, ReadReservation& reservation);
  PipeBuffer::Result reserveWrite(size_t maximum, bool block, WriteReservation& reservation);
  PipeBuffer::Result waitTransfer(bool writing, bool block);
  PipeBuffer::Result transferTo(Pipe& output, size_t maximum, bool consume, bool block);
 
 protected:
  bool m_bIsAnonymous;
 
  volatile bool m_bIsEOF;
 
  PipeBuffer m_Buffer;
 
  ConditionVariable m_ReaderCondition;
 
  uint64_t m_WriteGeneration;
  uint64_t m_ErrorGeneration;
  uint64_t m_HangupGeneration;
 
  size_t m_nLifetimePins;
 
  bool m_bRetirementQueued;
 
  bool shouldQueueRetirementLocked();
 
  static void bufferChanged(void* context);
 
  virtual bool isBytewise() const {
    return true;
  }
};
 
#endif