Subsystem.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 SUBSYSTEM_H
#define SUBSYSTEM_H
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/FilesystemContext.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/utilities/String.h"
 
class File;
class Process;
class Thread;
class Event;
class UserReturnFrame;
template <class T>
class Vector;
 
class EXPORTED_PUBLIC Subsystem {
  friend class Process;
 
 public:
  virtual bool filesystemConstrained() const {
    return false;
  }
  virtual uint64_t filesystemAccess(const FilesystemPathRef*, size_t) const {
    return ~uint64_t(0);
  }
  virtual bool filesystemReparent(const FilesystemPathRef*, size_t, const FilesystemPathRef*,
                                  size_t) const {
    return true;
  }
  enum class UserReturnResult { Continue, Terminal };
  enum class UserReturnEventResult { Deliver, Consumed, Terminal };
  virtual UserReturnResult userReturnCheckpoint(Thread&, UserReturnFrame&) {
    return UserReturnResult::Continue;
  }
  virtual UserReturnEventResult userReturnEvent(Thread&, Event&, UserReturnFrame&) {
    return UserReturnEventResult::Deliver;
  }
 
  enum SubsystemType { Posix = 0, Native = 1, None = 255 };
 
  enum KillReason { Interrupted = 0, Terminated = 1, Unknown = 255 };
 
  enum class ExitCause { Normal, Signal };
 
  enum ExceptionType {
    InvalidOpcode = 0,
    PageFault = 1,
    GeneralProtectionFault = 2,
    DivideByZero = 3,
    FpuError = 4,
    SpecialFpuError = 5,
    TerminalInput = 6,   // Read from terminal, but not foreground.
    TerminalOutput = 7,  // Output to terminal, but not foreground.
    Continue = 8,
    Stop = 9,
    Interrupt = 10,
    Quit = 11,
    Child = 12,  // Child pause/continue/quit.
    Pipe = 13,   // Pipe broken.
    FileMappingFault = 14,
    Other = 255
  };
 
  Subsystem() : m_Type(None), m_pProcess(0) {}
 
  Subsystem(const Subsystem& s) : m_Type(s.m_Type), m_pProcess(0) {}
 
  Subsystem(SubsystemType type) : m_Type(type), m_pProcess(0) {}
 
  virtual ~Subsystem();
 
  virtual void acquire();
 
  virtual void release();
 
  virtual void exit(int code, ExitCause cause = ExitCause::Normal) = 0;
 
  virtual bool kill(KillReason killReason, Thread* pThread = 0) = 0;
 
  virtual void threadException(Thread* pThread, ExceptionType eType,
                               InterruptState* pState = nullptr, uintptr_t faultAddress = 0,
                               uintptr_t errorCode = 0);
 
  virtual bool resolveUserPageFault(Thread&, InterruptState&, uintptr_t, uintptr_t) {
    return false;
  }
 
  SubsystemType getType() {
    return m_Type;
  }
 
  virtual void setProcess(Process* p) {
    if ((!m_pProcess) | (m_pProcess == p))
      m_pProcess = p;
    else
      WARNING("An attempt was made to change the Process of a Subsystem!");
  }
 
  virtual bool invoke(const char* name, Vector<String>& argv, Vector<String>& env) = 0;
 
  virtual bool invoke(const char* name, Vector<String>& argv, Vector<String>& env,
                      SyscallState& state) = 0;
 
  virtual bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
                      Vector<String>& env) = 0;
 
  virtual bool invoke(File* originalFile, const String& originalName, Vector<String>& argv,
                      Vector<String>& env, SyscallState& state) = 0;
 
 protected:
  virtual void prepareThreadsForExec(Thread* owner) {}
 
  virtual void preserveProcessSignalsForThreadExit(Thread* thread) {}
 
  virtual void threadExiting(Thread* pThread) {}
 
  virtual void threadRemoved(Thread* pThread) {}
 
  SubsystemType m_Type;
 
  Process* m_pProcess;
 
 private:
  const Subsystem& operator=(const Subsystem&);
};
 
#endif