One user-space repair task per eligible HWE debug-diag / compile-deploy base ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content filter. Each ships a public spec with a check-to-basis table, at least two defects with single-fix fixtures, a symptom-masking fixture and an alternative correct implementation. Claude re-checked all 320: structure, the HWE quality items and trace6 Docker calibration receipts against current digests (320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120 ad-hoc family names; the next batch maps them to the canonical list. The batch's 1,256-line progress log stays in its factory report and the 36-local branch batch15-hwe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
281 lines
7.3 KiB
C
281 lines
7.3 KiB
C
#include "layout.h"
|
|
|
|
#include <string.h>
|
|
|
|
static int valid_bank(const LayoutBank *bank)
|
|
{
|
|
return bank != NULL && (bank->width == 64u || bank->width == 128u)
|
|
&& bank->count > 0u && bank->count <= LAYOUT_MAX_SLOTS;
|
|
}
|
|
|
|
static int valid_slot(const LayoutBank *bank, size_t index)
|
|
{
|
|
return valid_bank(bank) && index < bank->count;
|
|
}
|
|
|
|
static unsigned char *row(LayoutBank *bank, size_t index)
|
|
{
|
|
return bank->slots[index].bytes + bank->width;
|
|
}
|
|
|
|
static const unsigned char *constant_row(const LayoutBank *bank, size_t index)
|
|
{
|
|
return bank->slots[index].bytes + bank->width;
|
|
}
|
|
|
|
static int length_ok(const LayoutBank *bank, size_t length)
|
|
{
|
|
return length <= bank->width;
|
|
}
|
|
|
|
static void bump(LayoutBank *bank, size_t index)
|
|
{
|
|
bank->slots[index].generation++;
|
|
bank->revision++;
|
|
}
|
|
|
|
int layout_init(LayoutBank *bank, size_t width, size_t count)
|
|
{
|
|
if (bank == NULL || (width != 64u && width != 128u) ||
|
|
count == 0u || count > LAYOUT_MAX_SLOTS) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
memset(bank, 0, sizeof(*bank));
|
|
bank->width = width;
|
|
bank->count = count;
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_clear(LayoutBank *bank, size_t index)
|
|
{
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
bank->slots[index].used = 0u;
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_store(LayoutBank *bank, size_t index, const unsigned char *data, size_t length)
|
|
{
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (!length_ok(bank, length)) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (length && data == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (length) {
|
|
memmove(row(bank, index), data, length);
|
|
}
|
|
bank->slots[index].used = length;
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_fill(LayoutBank *bank, size_t index, unsigned char value, size_t length)
|
|
{
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (!length_ok(bank, length)) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (length) {
|
|
memset(row(bank, index), (int)value, length);
|
|
}
|
|
bank->slots[index].used = length;
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_patch(LayoutBank *bank, size_t index, size_t offset,
|
|
const unsigned char *data, size_t length)
|
|
{
|
|
unsigned char saved[LAYOUT_MAX_ROW];
|
|
size_t used;
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
used = bank->slots[index].used;
|
|
if (offset > used || length > used - offset) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (length && data == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (length) {
|
|
memcpy(saved, data, length);
|
|
memcpy(row(bank, index) + offset, saved, length);
|
|
}
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_insert(LayoutBank *bank, size_t index, size_t offset,
|
|
const unsigned char *data, size_t length)
|
|
{
|
|
unsigned char saved[LAYOUT_MAX_ROW];
|
|
size_t used;
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
used = bank->slots[index].used;
|
|
if (offset > used || length > bank->width - used) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (length && data == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (length) {
|
|
memcpy(saved, data, length);
|
|
memmove(row(bank, index) + offset + length,
|
|
constant_row(bank, index) + offset, used - offset);
|
|
memcpy(row(bank, index) + offset, saved, length);
|
|
}
|
|
bank->slots[index].used = used + length;
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_erase(LayoutBank *bank, size_t index, size_t offset, size_t length)
|
|
{
|
|
size_t used;
|
|
if (!valid_slot(bank, index)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
used = bank->slots[index].used;
|
|
if (offset > used || length > used - offset) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (length) {
|
|
memmove(row(bank, index) + offset,
|
|
constant_row(bank, index) + offset + length,
|
|
used - offset - length);
|
|
}
|
|
bank->slots[index].used = used - length;
|
|
bump(bank, index);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_fetch(const LayoutBank *bank, size_t index, unsigned char *out,
|
|
size_t capacity, size_t *length)
|
|
{
|
|
size_t used;
|
|
if (!valid_slot(bank, index) || length == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
used = bank->slots[index].used;
|
|
if (capacity < used) {
|
|
return LAYOUT_ERANGE;
|
|
}
|
|
if (used && out == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (used) {
|
|
memmove(out, constant_row(bank, index), used);
|
|
}
|
|
*length = used;
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_view(const LayoutBank *bank, size_t index, const unsigned char **data,
|
|
size_t *length)
|
|
{
|
|
if (!valid_slot(bank, index) || data == NULL || length == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
*data = constant_row(bank, index);
|
|
*length = bank->slots[index].used;
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_copy(LayoutBank *bank, size_t source, size_t destination)
|
|
{
|
|
size_t used;
|
|
if (!valid_slot(bank, source) || !valid_slot(bank, destination)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
used = bank->slots[source].used;
|
|
if (source != destination && used) {
|
|
memmove(row(bank, destination), constant_row(bank, source), used);
|
|
}
|
|
bank->slots[destination].used = used;
|
|
bump(bank, destination);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_swap(LayoutBank *bank, size_t left, size_t right)
|
|
{
|
|
unsigned char temporary[LAYOUT_MAX_ROW];
|
|
size_t left_length;
|
|
size_t right_length;
|
|
if (!valid_slot(bank, left) || !valid_slot(bank, right)) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
if (left == right) {
|
|
bump(bank, left);
|
|
return LAYOUT_OK;
|
|
}
|
|
left_length = bank->slots[left].used;
|
|
right_length = bank->slots[right].used;
|
|
if (left_length) {
|
|
memcpy(temporary, constant_row(bank, left), left_length);
|
|
}
|
|
if (right_length) {
|
|
memmove(row(bank, left), constant_row(bank, right), right_length);
|
|
}
|
|
if (left_length) {
|
|
memcpy(row(bank, right), temporary, left_length);
|
|
}
|
|
bank->slots[left].used = right_length;
|
|
bank->slots[right].used = left_length;
|
|
bump(bank, left);
|
|
bump(bank, right);
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
int layout_stats(const LayoutBank *bank, LayoutStats *stats)
|
|
{
|
|
size_t index;
|
|
LayoutStats result = {0u, 0u, 0u, 0u};
|
|
if (!valid_bank(bank) || stats == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
for (index = 0u; index < bank->count; index++) {
|
|
size_t used = bank->slots[index].used;
|
|
if (used != 0u) {
|
|
result.occupied++;
|
|
}
|
|
result.total_bytes += used;
|
|
if (used > result.longest) {
|
|
result.longest = used;
|
|
}
|
|
}
|
|
result.revision = bank->revision;
|
|
*stats = result;
|
|
return LAYOUT_OK;
|
|
}
|
|
|
|
uint32_t layout_hash(const unsigned char *data, size_t length)
|
|
{
|
|
uint32_t hash = UINT32_C(2166136261);
|
|
size_t index;
|
|
for (index = 0u; index < length; index++) {
|
|
hash ^= (uint32_t)data[index];
|
|
hash *= UINT32_C(16777619);
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
int layout_slot_hash(const LayoutBank *bank, size_t index, uint32_t *hash)
|
|
{
|
|
if (!valid_slot(bank, index) || hash == NULL) {
|
|
return LAYOUT_EINVAL;
|
|
}
|
|
*hash = layout_hash(constant_row(bank, index), bank->slots[index].used);
|
|
return LAYOUT_OK;
|
|
}
|