UserProcessScheduler.h

Go to the documentation of this file.

/* ========================================
 
  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
 
======================================== */
 
#ifndef INC_PROCESS_SCHEDULER_H
#define INC_PROCESS_SCHEDULER_H

 
#include <ArchKit/ArchKit.h>
#include <KernelKit/CoreProcessScheduler.h>
#include <KernelKit/LockDelegate.h>
#include <KernelKit/UserMgr.h>
#include <NeKit/MutableArray.h>

// Last revision date is: Fri Mar 28 2025         //
 
namespace Kernel {
 
class IDylibObject;
class UserProcessScheduler;
class UserProcessHelper;
 
/***********************************************************************************/
/***********************************************************************************/
class USER_PROCESS final NE_VETTABLE {
 public:
  explicit USER_PROCESS();
  ~USER_PROCESS();
 
  auto DoVet() const { return *this; }
 
 public:
  NE_COPY_DEFAULT(USER_PROCESS)
 
 public:
  Char               Name[kSchedNameLen] = {"USER_PROCESS"};
  ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemUser};
  User*              Owner{nullptr};
  HAL::StackFramePtr StackFrame{nullptr};
  AffinityKind       Affinity{AffinityKind::kStandard};
  ProcessStatusKind  Status{ProcessStatusKind::kKilled};
  UInt8              StackReserve[kSchedMaxStackSz];
  ProcessImage       Image{};
  SizeT              StackSize{kSchedMaxStackSz};
  IDylibObject*      DylibDelegate{nullptr};
  SizeT              MemoryCursor{0UL};
  SizeT              MemoryLimit{kSchedMaxMemoryLimit};
  SizeT              UsedMemory{0UL};
 
  struct USER_PROCESS_SIGNAL final {
    UIntPtr           SignalArg{0};
    ProcessStatusKind Status{ProcessStatusKind::kKilled};
    UIntPtr           SignalID{0};
  };
 
  USER_PROCESS_SIGNAL         Signal;
  PROCESS_FILE_TREE<VoidPtr>* FileTree{nullptr};
  PROCESS_HEAP_TREE<VoidPtr>* HeapTree{nullptr};
  UserProcessTeam*            ParentTeam;
 
  VoidPtr VMRegister{0UL};
 
  enum {
    kInvalidExecutableKind,
    kExecutableKind,
    kExecutableDylibKind,
    kExecutableKindCount,
  };
 
  ProcessTime PTime{0};  
  ProcessTime RTime{0};  
  ProcessTime UTime{0};  
 
  ProcessID ProcessId{kSchedInvalidPID};
  Int32     Kind{kExecutableKind};
 
 public:
  /***********************************************************************************/
  /***********************************************************************************/
  explicit operator bool();
 
  /***********************************************************************************/
  /***********************************************************************************/
  Void Crash();
 
  /***********************************************************************************/
  /***********************************************************************************/
  Bool InitDylib();
 
  /***********************************************************************************/
  /***********************************************************************************/
  Void Exit(const Int32& exit_code = 0);
 
  /***********************************************************************************/
  /***********************************************************************************/
  ErrorOr<VoidPtr> New(SizeT sz, SizeT pad_amount = 0);
 
  /***********************************************************************************/
  /***********************************************************************************/
  template <typename T>
  Boolean Delete(ErrorOr<T*> ptr);
 
  /***********************************************************************************/
  /***********************************************************************************/
  Void Wake(Bool wakeup = false);
 
 public:
  /***********************************************************************************/
  /***********************************************************************************/
  KPCError& GetExitCode();
 
  /***********************************************************************************/
  /***********************************************************************************/
  const Char* GetName();
 
  /***********************************************************************************/
  /***********************************************************************************/
  KPCError& GetLocalCode();
 
  const User* GetOwner();
 
  const ProcessStatusKind& GetStatus();
 
  const AffinityKind& GetAffinity();
 
 private:
  KPCError LastExitCode{0};
  KPCError LocalCode{0};
 
  friend UserProcessScheduler;
  friend UserProcessHelper;
};
 
typedef Array<USER_PROCESS, kSchedProcessLimitPerTeam> USER_PROCESS_ARRAY;
typedef Ref<USER_PROCESS>                              USER_PROCESS_REF;

class UserProcessTeam final {
 public:
  explicit UserProcessTeam();
  ~UserProcessTeam() = default;
 
  NE_COPY_DEFAULT(UserProcessTeam)
 
  Array<USER_PROCESS, kSchedProcessLimitPerTeam>& AsArray();
  Ref<USER_PROCESS>&                              AsRef();
  ProcessID&                                      Id();
 
 public:
  USER_PROCESS_ARRAY mProcessList;
  USER_PROCESS_REF   mCurrentProcess;
  ProcessID          mTeamId{0};
  ProcessID          mProcessCur{0};
};
 
/***********************************************************************************/
/***********************************************************************************/
class UserProcessScheduler final : public ISchedulable {
  friend class UserProcessHelper;
 
 public:
  explicit UserProcessScheduler()  = default;
  ~UserProcessScheduler() override = default;
 
  NE_COPY_DELETE(UserProcessScheduler)
  NE_MOVE_DELETE(UserProcessScheduler)
 
 public:
  explicit operator bool();
  bool     operator!();
 
 public:
  UserProcessTeam& TheCurrentTeam();
  BOOL             SwitchTeam(UserProcessTeam& team);
 
 public:
  ProcessID Spawn(const Char* name, VoidPtr code, VoidPtr image);
  Void      Remove(ProcessID process_id);
 
  Bool IsUser() override;
  Bool IsKernel() override;
  Bool HasMP() override;
 
 public:
  USER_PROCESS_REF& TheCurrentProcess();
  SizeT             Run();
 
 public:
  STATIC UserProcessScheduler& The();
 
 private:
  UserProcessTeam mTeam{};
};
 
/***********************************************************************************/
/***********************************************************************************/
 
class UserProcessHelper final {
 public:
  STATIC Bool Switch(HAL::StackFramePtr frame_ptr, ProcessID new_pid);
  STATIC Bool CanBeScheduled(const USER_PROCESS& process);
  STATIC ErrorOr<ProcessID> TheCurrentPID();
  STATIC SizeT              StartScheduling();
};
}  // namespace Kernel
 
#include <KernelKit/ThreadLocalStorage.h>
#include <KernelKit/UserProcessScheduler.inl>

// END
 
#endif /* ifndef INC_PROCESS_SCHEDULER_H */