amos 73a5240295 Batches 21 and 18: add 74 calibrated tasks (40 Bos redo, 34 HWE code-gen)
Batch 21 (20261027-A-bos-redo-21) rebuilt 40 of the 53 rejected Bos-qiao
environments: hidden assertions that ran inside the candidate's process
now run in a trusted parent that reads observations from a low-UID
worker; gold bytes are unchanged. 9 were excluded for scope (ROS2,
oversize, security core), 3 are blocked because the source requires an
exec bit the platform does not freeze, 1 lacks requests/bs4 in trace6.

Batch 18 (20261026-C-hwe-codegen-18) adds its last 34 of 134 tasks; the
first 100 landed in 2f32624d.

Claude reviewed 74/74 USABLE against current digests, canonical
families, no ID or source overlap with main, plain public docs. Only the
new task directories are taken; the stale pre-batch-20 copies of
concur-release-capsule and resource-temp-link on the batch 21 branch and
both branches' progress notes stay as main has them. Difficulty is
unmeasured.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 10:23:12 +08:00

302 lines
8.5 KiB
C++

#include "identity.hpp"
#include <array>
#include <set>
#include <utility>
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<Record, 33> 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;
data_->records[pid] = 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);
}
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<int> 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<int>(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<int> groups;
std::set<int> 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<int>(groups.size());
result.sessions = static_cast<int>(sessions.size());
return result;
}
std::vector<Process> Ledger::snapshot() const {
std::vector<Process> 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;
}
}