Codex 69521e54e0 Add 15 embedded repair tasks and correct grader-read controls
Complete batch 20261016-C-embedded-2: 45 verified GLM/Pi samples, independent regrades and archives; preserve difficulty misses and Salty blockage.
2026-10-16 14:23:48 +08:00

30 lines
32 KiB
JSON
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"kind": "journal",
"seed": 4869708,
"context": {
"journal.h": "#ifndef ABI_JOURNAL_H\n#define ABI_JOURNAL_H\n#include <stddef.h>\n#include <stdint.h>\n#include <sys/types.h>\n\nenum {\n JOURNAL_HEADER_SIZE = 16,\n JOURNAL_PREFIX_SIZE = 12,\n JOURNAL_TRAILER_SIZE = 4,\n JOURNAL_PAYLOAD_MAX = 240,\n JOURNAL_RECORD_MAX = 260,\n JOURNAL_COMMAND_BYTES = 4096,\n JOURNAL_FAULT_KINDS = 4\n};\n\ntypedef struct {\n int opened;\n uint64_t end;\n uint32_t sequence;\n int dirty;\n} journal_state;\n\ntypedef struct {\n void *context;\n ssize_t (*read_at)(void *, int, void *, size_t, off_t);\n ssize_t (*write_at)(void *, int, const void *, size_t, off_t);\n int (*resize)(void *, int, off_t);\n int (*synchronize)(void *, int);\n} journal_io;\n\ntypedef struct {\n int error;\n unsigned remaining;\n} journal_fault;\n\ntypedef struct {\n int descriptor;\n size_t read_cap;\n size_t write_cap;\n journal_fault faults[JOURNAL_FAULT_KINDS];\n} journal_file;\n\nvoid journal_init(journal_state *);\nint journal_recover(journal_state *, const journal_io *, int);\nint journal_append(journal_state *, const journal_io *, int,\n const uint8_t *, size_t);\nint journal_read_exact(const journal_io *, int, uint8_t *, size_t,\n uint64_t, size_t *);\nint journal_write_exact(const journal_io *, int, const uint8_t *, size_t,\n uint64_t);\nint journal_resize(const journal_io *, int, uint64_t);\nint journal_synchronize(const journal_io *, int);\nint journal_size(int, uint64_t *);\nuint16_t journal_load16(const uint8_t *);\nuint32_t journal_load32(const uint8_t *);\nvoid journal_store16(uint8_t *, uint16_t);\nvoid journal_store32(uint8_t *, uint32_t);\nuint32_t journal_checksum(const uint8_t *, size_t, const uint8_t *, size_t);\nuint32_t journal_buffer_hash(const uint8_t *, size_t);\nint journal_file_create(journal_file *);\nint journal_file_close(journal_file *);\nvoid journal_file_bind(journal_file *, journal_io *);\nvoid journal_file_caps(journal_file *, size_t, size_t);\nint journal_file_fault(journal_file *, unsigned, int, unsigned);\nint journal_file_replace(journal_file *, const uint8_t *, size_t);\nint journal_file_dump(journal_file *, uint8_t **, size_t *);\n#endif\n",
"Makefile": "CC = gcc\nCFLAGS = -std=c11 -O2 -Wall -Wextra -Werror -pedantic\nSOURCES = console.c file_ops.c codec.c text.c journal_io.c journal_recover.c journal_append.c\nall: observe traffic\nobserve: $(SOURCES) journal.h text.h\n\t$(CC) $(CFLAGS) $(SOURCES) -o observe\ntraffic: traffic.c codec.c text.c journal_io.c journal_append.c journal.h text.h\n\t$(CC) $(CFLAGS) traffic.c codec.c text.c journal_io.c journal_append.c -o traffic\nclean:\n\trm -f observe traffic\n.PHONY: all clean\n",
"console.c": "#include \"journal.h\"\n#include \"text.h\"\n#include <errno.h>\n#include <inttypes.h>\n#include <stdlib.h>\n\ntypedef struct {\n journal_file file;\n journal_io io;\n journal_state state;\n} session;\n\nstatic int print_snapshot(session *current)\n{\n uint8_t *bytes;\n size_t length;\n int status = journal_file_dump(&current->file, &bytes, &length);\n if (status != 0) {\n return 0;\n }\n printf(\"S %d %\" PRIu64 \" %\" PRIu32 \" %d \",\n current->state.opened, current->state.end,\n current->state.sequence, current->state.dirty);\n text_hex(stdout, bytes, length);\n putchar('\\n');\n free(bytes);\n return !ferror(stdout);\n}\n\nstatic int reset_file(session *current, text_reader *reader)\n{\n uint8_t bytes[JOURNAL_COMMAND_BYTES];\n size_t length;\n if (!text_count(reader, 2) ||\n !text_bytes(reader->word[1], bytes, sizeof(bytes), &length)) {\n return 0;\n }\n int status = journal_file_replace(&current->file, bytes, length);\n if (status != 0) {\n return 0;\n }\n journal_init(&current->state);\n return 1;\n}\n\nstatic int configure_caps(session *current, text_reader *reader)\n{\n unsigned read_cap, write_cap;\n if (!text_count(reader, 3) ||\n !text_unsigned(reader, 1, JOURNAL_COMMAND_BYTES, &read_cap) ||\n !text_unsigned(reader, 2, JOURNAL_COMMAND_BYTES, &write_cap) ||\n read_cap == 0 || write_cap == 0) {\n return 0;\n }\n journal_file_caps(&current->file, read_cap, write_cap);\n return 1;\n}\n\nstatic int configure_fault(session *current, text_reader *reader)\n{\n unsigned operation, error, count;\n if (!text_count(reader, 4) ||\n !text_unsigned(reader, 1, JOURNAL_FAULT_KINDS - 1, &operation) ||\n !text_unsigned(reader, 2, 4095, &error) ||\n !text_unsigned(reader, 3, 1000000, &count) || error == 0) {\n return 0;\n }\n return journal_file_fault(&current->file, operation, (int)error, count) == 0;\n}\n\nstatic int open_journal(session *current, text_reader *reader)\n{\n if (!text_count(reader, 1)) {\n return 0;\n }\n int status = journal_recover(&current->state, &current->io,\n current->file.descriptor);\n printf(\"O %d\\n\", status);\n return 1;\n}\n\nstatic int append_payload(session *current, text_reader *reader)\n{\n uint8_t payload[JOURNAL_COMMAND_BYTES];\n size_t length;\n if (!text_count(reader, 2) ||\n !text_bytes(reader->word[1], payload, sizeof(payload), &length)) {\n return 0;\n }\n uint32_t before = journal_buffer_hash(payload, length);\n int status = journal_append(&current->state, &current->io,\n current->file.descriptor, payload, length);\n uint32_t after = journal_buffer_hash(payload, length);\n printf(\"A %d %\" PRIu32 \" %\" PRIu32 \"\\n\", status, before, after);\n return 1;\n}\n\nstatic int dispatch(session *current, text_reader *reader)\n{\n const char *command = reader->word[0];\n if (command[1] != '\\0') {\n return 0;\n }\n switch (command[0]) {\n case 'Z':\n return reset_file(current, reader);\n case 'C':\n return configure_caps(current, reader);\n case 'F':\n return configure_fault(current, reader);\n case 'O':\n return open_journal(current, reader);\n case 'A':\n return append_payload(current, reader);\n case 'S':\n return text_count(reader, 1);\n default:\n return 0;\n }\n}\n\nint main(void)\n{\n session current;\n text_reader reader;\n text_init(&reader);\n if (journal_file_create(&current.file) != 0) {\n return 3;\n }\n journal_file_bind(&current.file, &current.io);\n journal_init(&current.state);\n int result;\n int exit_status = 0;\n while ((result = text_next(&reader, stdin)) > 0) {\n if (!dispatch(&current, &reader)) {\n text_error(&reader, \"invalid journal command or setup IO failure\");\n exit_status = 2;\n break;\n }\n if (!print_snapshot(&current)) {\n exit_status = 3;\n break;\n }\n }\n if (result < 0 || reader.failed) {\n exit_status = 2;\n }\n if (journal_file_close(&current.file) != 0 && exit_status == 0) {\n exit_status = 3;\n }\n return exit_status;\n}\n",
"text.c": "#include \"text.h\"\n#include <errno.h>\n#include <inttypes.h>\n#include <limits.h>\n#include <stdlib.h>\n#include <string.h>\n\nstatic int separator(unsigned char ch)\n{\n return ch == ' ' || ch == '\\t' || ch == '\\r' || ch == '\\n';\n}\n\nvoid text_init(text_reader *reader)\n{\n memset(reader, 0, sizeof *reader);\n}\n\nstatic int split_line(text_reader *reader)\n{\n char *cursor = reader->line;\n reader->count = 0;\n while (*cursor != '\\0') {\n while (separator((unsigned char)*cursor))\n ++cursor;\n if (*cursor == '\\0' || *cursor == '#')\n break;\n if (reader->count == TEXT_WORDS)\n return 0;\n reader->word[reader->count++] = cursor;\n while (*cursor != '\\0' && !separator((unsigned char)*cursor))\n ++cursor;\n if (*cursor != '\\0')\n *cursor++ = '\\0';\n }\n return 1;\n}\n\nint text_next(text_reader *reader, FILE *stream)\n{\n while (fgets(reader->line, sizeof reader->line, stream) != NULL) {\n ++reader->number;\n size_t length = strlen(reader->line);\n if (length == sizeof reader->line - 1 && reader->line[length - 1] != '\\n') {\n reader->failed = 1;\n return -1;\n }\n if (!split_line(reader)) {\n reader->failed = 1;\n return -1;\n }\n if (reader->count != 0)\n return 1;\n }\n if (ferror(stream)) {\n reader->failed = 1;\n return -1;\n }\n return 0;\n}\n\nint text_count(text_reader *reader, size_t expected)\n{\n if (reader->count == expected)\n return 1;\n reader->failed = 1;\n return 0;\n}\n\nint text_u64(const char *word, uint64_t maximum, uint64_t *value)\n{\n char *end = NULL;\n unsigned long long parsed;\n if (word == NULL || *word == '\\0' || *word == '-')\n return 0;\n errno = 0;\n parsed = strtoull(word, &end, 10);\n if (errno != 0 || end == word || *end != '\\0' || parsed > maximum)\n return 0;\n *value = (uint64_t)parsed;\n return 1;\n}\n\nint text_i64(const char *word, int64_t minimum, int64_t maximum, int64_t *value)\n{\n char *end = NULL;\n long long parsed;\n if (word == NULL || *word == '\\0')\n return 0;\n errno = 0;\n parsed = strtoll(word, &end, 10);\n if (errno != 0 || end == word || *end != '\\0' || parsed < minimum || parsed > maximum)\n return 0;\n *value = (int64_t)parsed;\n return 1;\n}\n\nint text_unsigned(text_reader *reader, size_t index, unsigned maximum, unsigned *value)\n{\n uint64_t parsed;\n if (index >= reader->count || !text_u64(reader->word[index], maximum, &parsed)) {\n reader->failed = 1;\n return 0;\n }\n *value = (unsigned)parsed;\n return 1;\n}\n\nint text_signed(text_reader *reader, size_t index, int minimum, int maximum, int *value)\n{\n int64_t parsed;\n if (index >= reader->count || !text_i64(reader->word[index], minimum, maximum, &parsed)) {\n reader->failed = 1;\n return 0;\n }\n *value = (int)parsed;\n return 1;\n}\n\nstatic int hex_digit(unsigned char ch)\n{\n if (ch >= '0' && ch <= '9')\n return (int)(ch - '0');\n if (ch >= 'a' && ch <= 'f')\n return (int)(ch - 'a') + 10;\n if (ch >= 'A' && ch <= 'F')\n return (int)(ch - 'A') + 10;\n return -1;\n}\n\nint text_bytes(const char *word, uint8_t *data, size_t capacity, size_t *length)\n{\n size_t count;\n *length = 0;\n if (strcmp(word, \"-\") == 0)\n return 1;\n count = strlen(word);\n if ((count & 1u) != 0 || count / 2 > capacity)\n return 0;\n for (size_t index = 0; index < count / 2; ++index) {\n int high = hex_digit((unsigned char)word[index * 2]);\n int low = hex_digit((unsigned char)word[index * 2 + 1]);\n if (high < 0 || low < 0)\n return 0;\n data[index] = (uint8_t)((unsigned)high * 16u + (unsigned)low);\n }\n *length = count / 2;\n return 1;\n}\n\nvoid text_hex(FILE *stream, const uint8_t *data, size_t length)\n{\n if (length == 0) {\n fputc('-', stream);\n return;\n }\n for (size_t index = 0; index < length; ++index)\n fprintf(stream, \"%02x\", data[index]);\n}\n\nuint32_t text_hash(const uint8_t *data, size_t length)\n{\n uint32_t value = UINT32_C(2166136261);\n for (size_t index = 0; index < length; ++index) {\n value ^= data[index];\n value *= UINT32_C(16777619);\n }\n return value;\n}\n\nvoid text_error(const text_reader *reader, const char *message)\n{\n fprintf(stderr, \"input line %lu: %s\\n\", reader->number, message);\n}\n",
"codec.c": "#include \"journal.h\"\n\nuint16_t journal_load16(const uint8_t *bytes)\n{\n uint16_t value = bytes[0];\n value |= (uint16_t)((uint16_t)bytes[1] << 8);\n return value;\n}\n\nuint32_t journal_load32(const uint8_t *bytes)\n{\n uint32_t value = 0;\n for (unsigned index = 0; index < 4; ++index) {\n value |= (uint32_t)bytes[index] << (8u * index);\n }\n return value;\n}\n\nvoid journal_store16(uint8_t *bytes, uint16_t value)\n{\n bytes[0] = (uint8_t)value;\n bytes[1] = (uint8_t)(value >> 8);\n}\n\nvoid journal_store32(uint8_t *bytes, uint32_t value)\n{\n for (unsigned index = 0; index < 4; ++index) {\n bytes[index] = (uint8_t)(value >> (8u * index));\n }\n}\n\nuint32_t journal_buffer_hash(const uint8_t *bytes, size_t length)\n{\n uint32_t value = UINT32_C(2166136261);\n for (size_t index = 0; index < length; ++index) {\n value ^= bytes[index];\n value *= UINT32_C(16777619);\n }\n return value;\n}\n",
"text.h": "#ifndef ABI_TEXT_H\n#define ABI_TEXT_H\n#include <stddef.h>\n#include <stdint.h>\n#include <stdio.h>\n\nenum { TEXT_LINE = 16384, TEXT_WORDS = 32, TEXT_BYTES = 4096 };\n\ntypedef struct {\n char line[TEXT_LINE];\n char *word[TEXT_WORDS];\n size_t count;\n unsigned long number;\n int failed;\n} text_reader;\n\nvoid text_init(text_reader *reader);\nint text_next(text_reader *reader, FILE *stream);\nint text_count(text_reader *reader, size_t expected);\nint text_u64(const char *word, uint64_t maximum, uint64_t *value);\nint text_i64(const char *word, int64_t minimum, int64_t maximum, int64_t *value);\nint text_unsigned(text_reader *reader, size_t index, unsigned maximum, unsigned *value);\nint text_signed(text_reader *reader, size_t index, int minimum, int maximum, int *value);\nint text_bytes(const char *word, uint8_t *data, size_t capacity, size_t *length);\nvoid text_hex(FILE *stream, const uint8_t *data, size_t length);\nuint32_t text_hash(const uint8_t *data, size_t length);\nvoid text_error(const text_reader *reader, const char *message);\n#endif\n",
"file_ops.c": "#define _POSIX_C_SOURCE 200809L\n#include \"journal.h\"\n#include <errno.h>\n#include <fcntl.h>\n#include <stdlib.h>\n#include <string.h>\n#include <sys/stat.h>\n#include <unistd.h>\n\nstatic int injected(journal_file *file, unsigned operation)\n{\n journal_fault *fault = &file->faults[operation];\n if (fault->remaining == 0) {\n return 0;\n }\n --fault->remaining;\n errno = fault->error;\n return -1;\n}\n\nstatic size_t limited(size_t count, size_t cap)\n{\n return count < cap ? count : cap;\n}\n\nstatic ssize_t capped_read(void *context, int descriptor, void *bytes,\n size_t count, off_t offset)\n{\n journal_file *file = context;\n if (injected(file, 0) != 0) {\n return -1;\n }\n return pread(descriptor, bytes, limited(count, file->read_cap), offset);\n}\n\nstatic ssize_t capped_write(void *context, int descriptor, const void *bytes,\n size_t count, off_t offset)\n{\n journal_file *file = context;\n if (injected(file, 1) != 0) {\n return -1;\n }\n return pwrite(descriptor, bytes, limited(count, file->write_cap), offset);\n}\n\nstatic int controlled_resize(void *context, int descriptor, off_t length)\n{\n journal_file *file = context;\n if (injected(file, 2) != 0) {\n return -1;\n }\n return ftruncate(descriptor, length);\n}\n\nstatic int controlled_sync(void *context, int descriptor)\n{\n journal_file *file = context;\n if (injected(file, 3) != 0) {\n return -1;\n }\n return fsync(descriptor);\n}\n\nint journal_file_create(journal_file *file)\n{\n memset(file, 0, sizeof(*file));\n file->descriptor = -1;\n char name[] = \"journal-file-XXXXXX\";\n int descriptor = mkstemp(name);\n if (descriptor < 0) {\n return -errno;\n }\n if (unlink(name) != 0) {\n int error = errno;\n close(descriptor);\n return -error;\n }\n file->descriptor = descriptor;\n file->read_cap = JOURNAL_COMMAND_BYTES;\n file->write_cap = JOURNAL_COMMAND_BYTES;\n return 0;\n}\n\nint journal_file_close(journal_file *file)\n{\n if (file->descriptor < 0) {\n return 0;\n }\n int descriptor = file->descriptor;\n file->descriptor = -1;\n return close(descriptor) == 0 ? 0 : -errno;\n}\n\nvoid journal_file_bind(journal_file *file, journal_io *io)\n{\n io->context = file;\n io->read_at = capped_read;\n io->write_at = capped_write;\n io->resize = controlled_resize;\n io->synchronize = controlled_sync;\n}\n\nvoid journal_file_caps(journal_file *file, size_t read_cap, size_t write_cap)\n{\n file->read_cap = read_cap;\n file->write_cap = write_cap;\n}\n\nint journal_file_fault(journal_file *file, unsigned operation, int error,\n unsigned count)\n{\n if (operation >= JOURNAL_FAULT_KINDS || error <= 0) {\n return -EINVAL;\n }\n file->faults[operation].error = error;\n file->faults[operation].remaining = count;\n return 0;\n}\n\nstatic int raw_resize(int descriptor, off_t length)\n{\n int status;\n do {\n status = ftruncate(descriptor, length);\n } while (status < 0 && errno == EINTR);\n return status == 0 ? 0 : -errno;\n}\n\nstatic int raw_write(int descriptor, const uint8_t *bytes, size_t count)\n{\n size_t done = 0;\n while (done < count) {\n ssize_t written = pwrite(descriptor, bytes + done, count - done,\n (off_t)done);\n if (written < 0 && errno == EINTR) {\n continue;\n }\n if (written <= 0) {\n return written < 0 ? -errno : -EIO;\n }\n done += (size_t)written;\n }\n return 0;\n}\n\nint journal_file_replace(journal_file *file, const uint8_t *bytes, size_t count)\n{\n int status = raw_resize(file->descriptor, 0);\n if (status != 0) {\n return status;\n }\n return raw_write(file->descriptor, bytes, count);\n}\n\nstatic int raw_read(int descriptor, uint8_t *bytes, size_t count)\n{\n size_t done = 0;\n while (done < count) {\n ssize_t received = pread(descriptor, bytes + done, count - done,\n (off_t)done);\n if (received < 0 && errno == EINTR) {\n continue;\n }\n if (received <= 0) {\n return received < 0 ? -errno : -EIO;\n }\n done += (size_t)received;\n }\n return 0;\n}\n\nint journal_file_dump(journal_file *file, uint8_t **bytes, size_t *count)\n{\n struct stat info;\n int status;\n do {\n status = fstat(file->descriptor, &info);\n } while (status < 0 && errno == EINTR);\n if (status != 0) {\n return -errno;\n }\n if (info.st_size < 0 || (uintmax_t)info.st_size > SIZE_MAX) {\n return -EOVERFLOW;\n }\n size_t length = (size_t)info.st_size;\n uint8_t *copy = malloc(length != 0 ? length : 1);\n if (copy == NULL) {\n return -ENOMEM;\n }\n status = raw_read(file->descriptor, copy, length);\n if (status != 0) {\n free(copy);\n return status;\n }\n *bytes = copy;\n *count = length;\n return 0;\n}\n",
"traffic.c": "#include \"journal.h\"\n#include \"text.h\"\n#include <errno.h>\n#include <inttypes.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct {\n uint32_t random;\n unsigned round;\n} traffic_state;\n\nstatic uint32_t random_word(traffic_state *state)\n{\n uint32_t word = state->random;\n word ^= word << 13;\n word ^= word >> 17;\n word ^= word << 5;\n state->random = word;\n return word;\n}\n\nstatic void random_bytes(traffic_state *state, uint8_t *bytes, size_t length)\n{\n for (size_t index = 0; index < length; ++index) {\n bytes[index] = (uint8_t)random_word(state);\n }\n}\n\nstatic void blob_command(const char *name, const uint8_t *bytes, size_t length)\n{\n printf(\"%s \", name);\n text_hex(stdout, bytes, length);\n putchar('\\n');\n}\n\nstatic void open_log(void)\n{\n puts(\"O\");\n}\n\nstatic void snapshot(void)\n{\n puts(\"S\");\n}\n\nstatic void caps(unsigned read_cap, unsigned write_cap)\n{\n printf(\"C %u %u\\n\", read_cap, write_cap);\n}\n\nstatic void fault(unsigned operation, int error, unsigned count)\n{\n printf(\"F %u %d %u\\n\", operation, error, count);\n}\n\nstatic size_t encoded_record(uint8_t *bytes, uint32_t sequence,\n const uint8_t *payload, size_t length)\n{\n memcpy(bytes, \"LOG1\", 4);\n journal_store16(bytes + 4, (uint16_t)length);\n journal_store16(bytes + 6, 0);\n journal_store32(bytes + 8, sequence);\n memcpy(bytes + JOURNAL_HEADER_SIZE, payload, length);\n journal_store32(bytes + 12,\n journal_checksum(bytes, JOURNAL_PREFIX_SIZE,\n payload, length));\n journal_store32(bytes + JOURNAL_HEADER_SIZE + length,\n sequence ^ UINT32_C(0xffffffff));\n return JOURNAL_HEADER_SIZE + length + JOURNAL_TRAILER_SIZE;\n}\n\nstatic void ordinary_records(traffic_state *state)\n{\n uint8_t payload[JOURNAL_PAYLOAD_MAX];\n static const unsigned lengths[] = {0, 1, 2, 16, 239, 240};\n blob_command(\"Z\", payload, 0);\n caps(1, 1);\n open_log();\n for (size_t index = 0; index < sizeof(lengths) / sizeof(lengths[0]); ++index) {\n size_t length = lengths[index];\n random_bytes(state, payload, length);\n blob_command(\"A\", payload, length);\n snapshot();\n open_log();\n }\n uint8_t too_long[JOURNAL_PAYLOAD_MAX + 1];\n random_bytes(state, too_long, sizeof(too_long));\n blob_command(\"A\", too_long, sizeof(too_long));\n open_log();\n}\n\nstatic size_t two_record_image(traffic_state *state, uint8_t *image,\n size_t *first_length)\n{\n uint8_t first[7];\n uint8_t second[29];\n random_bytes(state, first, sizeof(first));\n random_bytes(state, second, sizeof(second));\n *first_length = encoded_record(image, 1, first, sizeof(first));\n return *first_length + encoded_record(image + *first_length, 2,\n second, sizeof(second));\n}\n\nstatic void truncated_tails(traffic_state *state)\n{\n uint8_t image[JOURNAL_RECORD_MAX * 2];\n size_t prefix;\n size_t total = two_record_image(state, image, &prefix);\n for (size_t at = prefix; at < total; ++at) {\n blob_command(\"Z\", image, at);\n caps(1u + (unsigned)(at % 13), 1u + (unsigned)(at % 17));\n open_log();\n uint8_t repair[] = {0, (uint8_t)at, 255};\n blob_command(\"A\", repair, sizeof(repair));\n open_log();\n }\n}\n\nstatic void corrupted_records(traffic_state *state)\n{\n uint8_t image[JOURNAL_RECORD_MAX * 2];\n size_t prefix;\n size_t total = two_record_image(state, image, &prefix);\n for (size_t offset = prefix; offset < total; ++offset) {\n uint8_t damaged[JOURNAL_RECORD_MAX * 2];\n memcpy(damaged, image, total);\n damaged[offset] ^= (uint8_t)(1u << (offset % 8));\n blob_command(\"Z\", damaged, total);\n open_log();\n uint8_t repair[] = {1, 2, (uint8_t)offset};\n blob_command(\"A\", repair, sizeof(repair));\n snapshot();\n open_log();\n }\n}\n\nstatic void failed_operations(traffic_state *state)\n{\n uint8_t image[JOURNAL_RECORD_MAX * 2];\n size_t prefix;\n size_t total = two_record_image(state, image, &prefix);\n for (unsigned operation = 0; operation < JOURNAL_FAULT_KINDS; ++operation) {\n const int errors[] = {EINTR, EIO};\n for (unsigned index = 0; index < 2; ++index) {\n blob_command(\"Z\", image, total - 3);\n open_log();\n fault(operation, errors[index], index == 0 ? 2 : 1);\n if (operation == 0) {\n open_log();\n } else {\n const uint8_t payload[] = {17, 34, 51, 68};\n blob_command(\"A\", payload, sizeof(payload));\n }\n snapshot();\n const uint8_t retry[] = {0, 0, 255};\n blob_command(\"A\", retry, sizeof(retry));\n open_log();\n }\n }\n}\n\nstatic void sequence_gap(traffic_state *state)\n{\n uint8_t payload[8];\n uint8_t image[JOURNAL_RECORD_MAX];\n random_bytes(state, payload, sizeof(payload));\n size_t length = encoded_record(image, 2, payload, sizeof(payload));\n blob_command(\"Z\", image, length);\n open_log();\n blob_command(\"A\", payload, sizeof(payload));\n open_log();\n}\n\nstatic int argument(const char *word, uint64_t limit, uint64_t *value)\n{\n return text_u64(word, limit, value);\n}\n\nint main(int argc, char **argv)\n{\n uint64_t seed = 17;\n uint64_t cycles = 1;\n if (argc > 3 ||\n (argc > 1 && !argument(argv[1], UINT32_MAX, &seed)) ||\n (argc > 2 && (!argument(argv[2], 100, &cycles) || cycles == 0))) {\n fputs(\"usage: traffic [seed] [cycles 1..100]\\n\", stderr);\n return 2;\n }\n traffic_state state = {(uint32_t)(seed != 0 ? seed : 1), 0};\n for (state.round = 0; state.round < cycles; ++state.round) {\n ordinary_records(&state);\n truncated_tails(&state);\n corrupted_records(&state);\n failed_operations(&state);\n sequence_gap(&state);\n }\n return ferror(stdout) ? 3 : 0;\n}\n",
"README.md": "# 修复真实文件追加日志的恢复与持久提交\n\n设备的用户态日志在短读写、系统调用被信号中断或文件尾部残缺后,会重复读取旧字节、破坏已提交前缀,或在 fsync 失败时把未完成的追加发布到内存。请修复本完整 C11/POSIX 工程,使公开合同成立。只验证软件文件与系统调用语义,不验证真实断电、存储介质缓存或硬件掉电持久性。\n\n最终仅冻结并评分 `journal_io.c`、`journal_recover.c`、`journal_append.c`。其余头文件、真实文件与故障注入层、控制台、字节编解码、自查流量工具及 Makefile 是只读上下文,评分逐字重建;新增文件和构建产物不参与评分。\n\n## P1:工程、接口、命令与原始观察\n\n接口、状态和操作表见 journal.h。`make` 构建 observe 与 traffic。评分构建的等价 argv 为 `gcc -std=c11 -O2 -Wall -Wextra -pedantic console.c file_ops.c codec.c text.c journal_io.c journal_recover.c journal_append.c -o observe`。构建20秒、完整有限输入执行15秒、任务期限120秒。正常EOF退出0,语法/字段/参数范围错误退出2,控制台自己的文件建立或原始观察失败退出3。库函数不得打印,EOF不隐式恢复、追加或同步。\n\nobserve 启动时建立一个真实空普通文件,随即 unlink 路径并持有 fd;本进程的后续命令操作同一 inode,不跨进程保留。初态为 `opened=0,end=0,sequence=1,dirty=0`,两个单次传输上限均4096,四种错误计数均0。所有接口指针有效,payload缓冲区不与state/io对象重叠,给定操作表使用POSIX返回值和errno,实际文件大小可用fstat查询。end是已发布的有效日志前缀末端,而不是任意时刻的物理文件长度。\n\nstdin逐行读取命令,空行与#注释忽略。hex为偶数个十六进制字符,大小写均可;`-`表示0字节。每个Z/A的hex最多4096字节。命令如下:\n\n- `Z hex`:用给定原始字节替换整个真实文件,状态重置为0/0/1/0;保留全部caps与F故障计数。用于输入外部已有日志或尾部损坏,不调用O,不受注入故障限制;Z设置文件失败按控制台setup错误退出2。\n- `C read_cap write_cap`:各为1..4096,只替换单次pread/pwrite最多可返回的字节数,不改状态、文件、故障计数。\n- `F operation error count`:operation为0..3,error为正errno数字1..4095,count为0..1000000;替换该操作的故障计数。操作0=pread、1=pwrite、2=ftruncate、3=fsync。每次相应底层调用若count非0,先减1,设置errno并返回-1,本次不执行真实调用。其他操作的计数不变。count0关闭该类注入。\n- `O`:执行P3恢复,先打印 `O rc`。\n- `A hex`:执行P4追加,先打印 `A rc hash_before hash_after`。两个hash是调用前后输入payload的FNV-1a uint32(初值2166136261,逐字节xor后乘16777619取模2^32),输入不得被修改。\n- `S`:只观察,不执行恢复或同步。\n\n每条命令在上述可选返回行之后,都打印 `S opened end sequence dirty file_hex`。file_hex是通过未注入故障、无caps的真实文件读取所得完整物理内容,小写十六进制,空文件为`-`;观察不会消耗F计数。Z/C/F/S没有额外返回行。业务失败以负errno返回,进程仍继续处理后续命令。\n\n## P2:记录字节布局与完整性\n\n每条记录为16字节header、n字节payload和4字节trailer,总长20+n,n为0..240(空payload合法):\n\n| 偏移 | 长度 | 内容 |\n| --- | --- | --- |\n| 0 | 4 | ASCII `LOG1` |\n| 4 | 2 | n,小端uint16 |\n| 6 | 2 | flags,小端uint16,必须0 |\n| 8 | 4 | sequence,小端uint32 |\n| 12 | 4 | CRC32,小端uint32 |\n| 16 | n | payload,逐字节原样 |\n| 16+n | 4 | sequence xor 0xffffffff,小端uint32 |\n\nCRC为header前12字节与payload拼接后的IEEE CRC32:reflected polynomial 0xedb88320,初值与最终xor均0xffffffff,等于zlib.crc32;不包含header内CRC字段或trailer。序号必须从1开始逐条加1,不允许跳号、重复或扫描中途重新找magic。本题有限输入不会产生超过uint32序号容量的合法记录数。\n\n## P3:无损恢复、短读与失败原子性\n\nO始终从物理offset0、期望sequence1开始扫描,包括此前已经opened的状态。以局部临时状态扫描,只有完整扫描到有效前缀末端才一次发布;任何真实读取或查询文件大小的系统调用失败,都返回负errno且原有全部state不变,不修改文件。\n\n当当前位置小于物理文件长度时,先尝试完整读取16字节header,即使剩余不足16也须进行读尝试。完整header的magic、n<=240、flags0和连续sequence全部有效后,才尝试读取n+4字节payload/trailer,即使剩余尾部不足也须尝试。每次逻辑读取都用pread,短的正数返回必须累计buffer进度和文件offset;返回0表示EOF,EINTR必须原位置重试,其他错误立即返回。不能把短的正数当作完整记录,也不能把真实读错误当成普通坏尾。\n\n短header、非法header、短payload/trailer、CRC错误或trailer错误均表示有效前缀结束;这是成功恢复,不是系统错误。发布 `opened=1,end=有效前缀字节数,sequence=有效记录数+1,dirty=(end!=物理文件长度)` 并返回0。空文件成功恢复为1/0/1/0。有效前缀之后即使还有看似合法记录也不跳过损坏尾部继续扫描。O永不ftruncate、重写或fsync文件。\n\n## P4:追加阶段、重试与发布顺序\n\nA先检查opened,未恢复时返回-ENODEV;再检查payload长度,大于240返回-EINVAL。这两类拒绝不改state/文件、不消耗F计数,优先级也适用于长度非法且未opened的组合。\n\n合法A先设置dirty=1,使用当前sequence编码完整独立记录,并严格执行:\n\n1. ftruncate到旧state.end;每次合法A均执行,不能因为文件看似没有尾部就跳过,也不能截到0破坏已提交前缀。\n2. pwrite完整记录到旧state.end;正数短写必须同时推进buffer与文件offset,写0返回-EIO;EINTR原位置重试。\n3. fsync,EINTR重试。\n4. 三阶段均成功后,最后发布end=旧end+记录总长、sequence=旧sequence+1、dirty=0,opened仍1,返回0。\n\nftruncate也必须对EINTR重试。任一阶段的其他错误立即原样返回,后续阶段不执行,旧end/sequence/opened保留,dirty保持1;已实际完成的截尾或写入仍保留,不自动回滚物理文件。尤其fsync失败时,文件中可能已存在一条字节完整的新记录,缓存仍指向旧前缀;稍后O可以认可这条完整记录,后续A则先按旧缓存end截尾重试。这是软件可观察的提交协议,不模拟文件系统真实断电后的数据丢失。\n\n所有读写使用提供的操作表,不能绕过F或C,也不能只更新RAM来代替文件。公开 `./traffic [seed] [cycles]`(seed为uint32,默认17,cycles为1..100,默认1)只生成命令,覆盖边界payload、短传输、截断/损坏尾部、序号链和各操作的EINTR/EIO;没有期望表或判分。可运行 `./traffic 17 1 | ./observe` 自查,或手工输入 `printf 'Z -\\nO\\nA -\\nO\\n' | ./observe`,最后应为opened1、end20、sequence2、dirty0和一条合法空记录。\n"
},
"candidates": [
"journal_io.c",
"journal_recover.c",
"journal_append.c"
],
"sources": [
"console.c",
"file_ops.c",
"codec.c",
"text.c",
"journal_io.c",
"journal_recover.c",
"journal_append.c"
]
}