#include "identity.hpp" #include #include #include namespace identity { namespace { struct Record { bool used = false; int parent = 0; int group = 0; int session = 0; bool live = false; int status = 0; }; bool pid_in_range(int value) { return value >= 1 && value <= 32; } Result failure(Code code) { return Result{code, 0}; } Process absent_process(Code code) { return Process{code, 0, 0, 0, 0, false, 0, false, false}; } Group absent_group(Code code) { return Group{code, 0, 0, 0, false, 0}; } Session absent_session(Code code) { return Session{code, 0, 0, 0, false, 0}; } Process export_process(int pid, const Record& record) { Process result{}; result.code = Code::OK; result.pid = pid; result.ppid = record.parent; result.pgid = record.group; result.sid = record.session; result.live = record.live; result.status = record.status; result.group_leader = pid == record.group; result.session_leader = pid == record.session; return result; } } struct Ledger::Impl { std::array records{}; std::uint64_t births = 0; std::uint64_t exits = 0; std::uint64_t reaps = 0; }; Ledger::Ledger() : data_(new Impl) {} Ledger::~Ledger() = default; Result Ledger::seed(int pid) { if (!pid_in_range(pid)) { return failure(Code::RANGE); } for (int index = 1; index <= 32; ++index) { if (data_->records[index].used) { return failure(Code::BUSY); } } Record newborn; newborn.used = true; newborn.parent = 0; newborn.group = pid; newborn.session = pid; newborn.live = true; newborn.status = 0; (void)newborn; ++data_->births; return Result{Code::OK, pid}; } Result Ledger::fork_process(int parent, int child) { if (!pid_in_range(parent) || !pid_in_range(child)) { return failure(Code::RANGE); } const Record& source = data_->records[parent]; if (!source.used) { return failure(Code::MISSING); } if (!source.live) { return failure(Code::ZOMBIE); } if (data_->records[child].used) { return failure(Code::EXISTS); } for (int index = 1; index <= 32; ++index) { const Record& current = data_->records[index]; if (current.used && current.live && (current.group == child || current.session == child)) { return failure(Code::BUSY); } } Record newborn; newborn.used = true; newborn.parent = parent; newborn.group = source.group; newborn.session = source.session; newborn.live = true; newborn.status = 0; data_->records[child] = newborn; ++data_->births; return Result{Code::OK, child}; } Result Ledger::setsid(int pid) { if (!pid_in_range(pid)) { return failure(Code::RANGE); } Record& current = data_->records[pid]; if (!current.used) { return failure(Code::MISSING); } if (!current.live) { return failure(Code::ZOMBIE); } if (current.group == pid || group(pid).code == Code::OK) { return failure(Code::DENIED); } current.group = pid; current.session = pid; return Result{Code::OK, pid}; } Result Ledger::setpgid(int caller, int target, int group_id) { if (!pid_in_range(caller) || !pid_in_range(target) || !pid_in_range(group_id)) { return failure(Code::RANGE); } const Record& issuer = data_->records[caller]; if (!issuer.used) { return failure(Code::MISSING); } if (!issuer.live) { return failure(Code::ZOMBIE); } Record& destination = data_->records[target]; if (!destination.used) { return failure(Code::MISSING); } if (!destination.live) { return failure(Code::ZOMBIE); } if (caller != target && destination.parent != caller) { return failure(Code::NOT_CHILD); } if (issuer.session != destination.session) { return failure(Code::CROSS_SESSION); } if (destination.session == target) { return failure(Code::DENIED); } if (group_id != target) { bool found = false; for (int index = 1; index <= 32; ++index) { const Record& member = data_->records[index]; if (member.used && member.live && member.group == group_id && member.session == destination.session) { found = true; break; } } if (!found) { return failure(Code::NO_GROUP); } } destination.group = group_id; return Result{Code::OK, group_id}; } Result Ledger::exit_process(int pid, int status) { if (!pid_in_range(pid) || status < 0 || status > 255) { return failure(Code::RANGE); } Record& departing = data_->records[pid]; if (!departing.used) { return failure(Code::MISSING); } if (!departing.live) { return failure(Code::ZOMBIE); } departing.live = false; departing.status = status; for (int index = 1; index <= 32; ++index) { Record& child = data_->records[index]; if (child.used && child.parent == pid) { child.parent = 0; } } ++data_->exits; return Result{Code::OK, status}; } Result Ledger::reap(int parent, int child) { if (parent < 0 || parent > 32 || !pid_in_range(child)) { return failure(Code::RANGE); } if (parent != 0) { const Record& issuer = data_->records[parent]; if (!issuer.used) { return failure(Code::MISSING); } if (!issuer.live) { return failure(Code::ZOMBIE); } } Record& departing = data_->records[child]; if (!departing.used) { return failure(Code::MISSING); } if (departing.parent != parent) { return failure(Code::NOT_CHILD); } if (departing.live) { return failure(Code::RUNNING); } int status = departing.status; departing = Record{}; ++data_->reaps; return Result{Code::OK, status}; } Process Ledger::inspect(int pid) const { if (!pid_in_range(pid)) { return absent_process(Code::RANGE); } const Record& current = data_->records[pid]; if (!current.used) { return absent_process(Code::MISSING); } return export_process(pid, current); } Group Ledger::group(int pgid) const { if (!pid_in_range(pgid)) { return absent_group(Code::RANGE); } Group result = absent_group(Code::MISSING); for (int pid = 1; pid <= 32; ++pid) { const Record& member = data_->records[pid]; if (!member.used || !member.live || member.group != pgid) { continue; } result.code = Code::OK; result.id = pgid; result.sid = member.session; ++result.members; result.mask |= std::uint64_t(1) << (pid - 1); if (pid == pgid) { result.leader_live = true; } } return result; } Session Ledger::session(int sid) const { if (!pid_in_range(sid)) { return absent_session(Code::RANGE); } Session result = absent_session(Code::MISSING); std::set distinct_groups; for (int pid = 1; pid <= 32; ++pid) { const Record& member = data_->records[pid]; if (!member.used || !member.live || member.session != sid) { continue; } result.code = Code::OK; result.id = sid; ++result.members; result.mask |= std::uint64_t(1) << (pid - 1); distinct_groups.insert(member.group); if (pid == sid) { result.leader_live = true; } } result.groups = static_cast(distinct_groups.size()); return result; } Stats Ledger::stats() const { Stats result{}; result.births = data_->births; result.exits = data_->exits; result.reaps = data_->reaps; std::set groups; std::set sessions; for (int pid = 1; pid <= 32; ++pid) { const Record& current = data_->records[pid]; if (!current.used) { continue; } ++result.tracked; if (current.live) { ++result.live; groups.insert(current.group); sessions.insert(current.session); } else { ++result.zombies; } } result.groups = static_cast(groups.size()); result.sessions = static_cast(sessions.size()); return result; } std::vector Ledger::snapshot() const { std::vector result; for (int pid = 1; pid <= 32; ++pid) { const Record& current = data_->records[pid]; if (current.used) { result.push_back(export_process(pid, current)); } } return result; } }