task_control_block.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cpu_io.h>
#include <etl/flags.h>
#include <etl/intrusive_links.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "file_descriptor.hpp"
#include "resource_id.hpp"
#include "task_fsm.hpp"
 
using Pid = size_t;
 
using ThreadEntry = void (*)(void*);
 
namespace clone_flag {
inline constexpr uint64_t kVm = 0x00000100;
inline constexpr uint64_t kFs = 0x00000200;
inline constexpr uint64_t kFiles = 0x00000400;
inline constexpr uint64_t kSighand = 0x00000800;
inline constexpr uint64_t kParent = 0x00008000;
inline constexpr uint64_t kThread = 0x00010000;
inline constexpr uint64_t kAllMask =
    kVm | kFs | kFiles | kSighand | kParent | kThread;
}  // namespace clone_flag
 
using CloneFlags = etl::flags<uint64_t, clone_flag::kAllMask>;
 
using CpuAffinity = etl::flags<uint64_t>;
 
namespace TaskStatus = TaskStatusId;
 
enum class SchedPolicy : uint8_t {
  kRealTime = 0,
  kNormal = 1,
  kIdle = 2,
  kPolicyCount
};
 
using ThreadGroupLink = etl::bidirectional_link<0>;
 
struct TaskAuxData {
  Pid parent_pid{0};
  Pid pgid{0};
  Pid sid{0};
  Pid tgid{0};
 
  int exit_code{0};
 
  CloneFlags clone_flags{};
 
  CpuAffinity cpu_affinity{UINT64_MAX};
 
  ResourceId blocked_on{};
 
  bool is_interrupt_thread{false};
  uint64_t interrupt_number{0};
 
 
  filesystem::FileDescriptorTable* fd_table{nullptr};
};
 
struct TaskControlBlock : public ThreadGroupLink {
  static constexpr size_t kDefaultKernelStackSize = 16 * 1024;
 
  struct PriorityCompare {
    auto operator()(TaskControlBlock* a, TaskControlBlock* b) -> bool {
      return a->sched_info.priority > b->sched_info.priority;
    }
  };
 
  struct WakeTickCompare {
    auto operator()(TaskControlBlock* a, TaskControlBlock* b) -> bool {
      return a->sched_info.wake_tick > b->sched_info.wake_tick;
    }
  };
 
  const char* name{"Unnamed Task"};
 
  Pid pid{0};
 
  TaskFsm fsm{};
 
  SchedPolicy policy{SchedPolicy::kNormal};
 
  struct SchedInfo {
    int priority{10};
    int base_priority{10};
    int inherited_priority{0};
    uint64_t wake_tick{0};
    uint64_t time_slice_remaining{10};
    uint64_t time_slice_default{10};
    uint64_t total_runtime{0};
    uint64_t context_switches{0};
  } sched_info;
 
  union SchedData {
    struct {
      uint64_t vruntime;
      uint32_t weight;
    } cfs;
 
    struct {
      uint8_t level;
    } mlfq;
  } sched_data{};
 
  uint8_t* kernel_stack{nullptr};
 
  cpu_io::TrapContext* trap_context_ptr{nullptr};
  cpu_io::CalleeSavedContext task_context{};
  uint64_t* page_table{nullptr};
 
  TaskAuxData* aux{nullptr};
 
  [[nodiscard]] auto GetStatus() const -> etl::fsm_state_id_t;
 
  [[nodiscard]] auto IsThreadGroupLeader() const -> bool {
    return aux && pid == aux->tgid;
  }
 
  auto JoinThreadGroup(TaskControlBlock* leader) -> void;
 
  auto LeaveThreadGroup() -> void;
 
  [[nodiscard]] auto GetThreadGroupSize() const -> size_t;
 
  [[nodiscard]] auto InSameThreadGroup(const TaskControlBlock* other) const
      -> bool {
    return aux && other && other->aux && (aux->tgid == other->aux->tgid) &&
           (aux->tgid != 0);
  }
 
 
  TaskControlBlock(const char* name, int priority, ThreadEntry entry,
                   void* arg);
 
  TaskControlBlock(const char* name, int priority, uint8_t* elf, int argc,
                   char** argv);
 
  TaskControlBlock() = default;
  TaskControlBlock(const TaskControlBlock&) = delete;
  TaskControlBlock(TaskControlBlock&&) = delete;
  auto operator=(const TaskControlBlock&) -> TaskControlBlock& = delete;
  auto operator=(TaskControlBlock&&) -> TaskControlBlock& = delete;
  ~TaskControlBlock();
};