# LibMCPU 0.4.0 LibMCPU 0.4.0 is the first public version. # LibMCPU 0.3.35 LibMCPU 0.3.35 extends the MCPU CPU/system ISA with explicit writable arithmetic/status flag control. The new opcodes are `SETF=0x0010`, `CLRF=0x0011`, `CLRCPUF=0x0012`, and `CLRMPUF=0x0013`. `SETF flag` and `CLRF flag` accept only the writable PSW selectors AF through INXF (bits 0..15), changing exactly one selected bit while preserving every other PSW bit. HF, TF, IF and MODE remain outside this write contract; attempts to assemble or decode `SETF/CLRF` for HF/TF/IF are rejected. The arithmetic/status domain is now documented as two architectural byte ranges: CPU flags in `PSW[7:0]` and MPU mathematical flags in `PSW[15:8]`. `CLRCPUF` clears only mask `0x000000ff`; `CLRMPUF` clears only mask `0x0000ff00`; both preserve the other flag byte and all execution/control state above bit 15. `JSET/JCLR` keep their existing wider read-only selector contract. Existing LibMPU semantics of `IADC`, `ISBB`, and rotate-through-carry operations are unchanged; the new instructions provide a direct way to establish their input flag state. Assembler, decoder/executor, and `mcpu-objdump` are updated consistently. Regression coverage verifies opcode values, single-flag preservation, CPU/MPU bulk-clear masks, rejection of control-state writes, explicit carry input for IADC/ISBB, assembler encoding/decoding, and objdump disassembly. The maintained architecture PDF sources/PDF and the English/Russian `mcpu-as(1)` and `libmcpu(7)` manual pages document the new contract. MELF, syscall, HLL Runtime ABI, CRT, linker, loader and runtime lifecycle contracts are otherwise unchanged. # LibMCPU 0.3.34 LibMCPU 0.3.34 is a documentation-only production-readiness release over the verified 0.3.33 baseline. The two XeLaTeX reference manuals are made release-number-independent and are updated to the current signed HLL Runtime ABI joining mcpu-ld, CRT and MCPU Libc. The HLL manual now documents fixed-width int32/int64/PTR64 signatures, frontend normalization of fini, automatic PROGRAM/MODEL classification and CRT insertion, McpuStartup argc/argv ownership, the four reserved Libc hooks, PRE_RUNTIME/RUNNING behavior, MODEL life return values using `-__INT32_MAX__ - 1`, graceful finalization and dynamic non-interposition rules. The bytecode manual gains permanent reference appendices for the full mcpu-as directive set, every public OPCODE16 with operands and a Russian explanation, all branchable PSW selectors, and the existing RCONST selectors. Stale release-history sections and references to examples bundled inside LibMCPU are removed; examples are now a separate package. The MELF manual is likewise detached from LibMCPU package release numbers and corrected to describe HLL classification as an mcpu-ld layer above the language-neutral MELF wire format. Syscall documentation now states the stable host-independent MCPU errno contract rather than the historical host-errno plan. There is no MCPU ISA, MELF ABI, syscall ABI, HLL Runtime ABI, CRT, linker, loader, runtime or command-line semantic change in this release. # LibMCPU 0.3.33 LibMCPU 0.3.33 is a documentation/production-readiness follow-up to the user-verified 0.3.32 baseline. It does not change the MCPU ISA, MELF ABI, syscall ABI, HLL Runtime ABI v1, CRT implementation, linker behavior, loader/runtime behavior, or command-line semantics. The top-level README is converted from a release-note-like document into a version-independent description of the current source tree and installed interfaces. Release-specific history remains in NEWS.md and ChangeLog. Build instructions no longer contain a release-numbered source path, version-output examples use a symbolic package-version placeholder, and the README now documents the current HLL complete-program object contract, automatic PROGRAM/MODEL CRT selection, required CRT installation path, McpuStartup/CALL bridge, MODEL life status namespace, and graceful HLL finalization. All English and Russian manual pages now use the version-independent source label `LibMCPU` in their `.TH` headers instead of embedding a package release number. The installed utility `--version` / `--dump-version` interface is the authoritative package-version source. This removes the recurring risk of stale man-page release numbers during otherwise unrelated releases. The `libmcpu(7)`, `mcpu-ld(1)`, `mcpu-run(1)`, and `mcpu-as(1)` pages are updated for the signed HLL Runtime ABI v1 and the current package boundary. They describe low-level versus HLL lifecycle ownership, normalized PROGRAM/MODEL symbols, automatic CRT insertion from `/lib/mcpu`, fatal behavior when required CRT objects are unavailable, persistent McpuStartup argc/argv, HLL CALL/RET boundaries, MODEL life return semantics, PRE_RUNTIME/RUNNING finalization behavior, and the fact that the assembler itself neither classifies HLL programs nor synthesizes CRT. A new regression enforces the documentation version policy: README.md and installed man-page sources must not acquire release-bound LibMCPU semantic-version strings, and every man page must keep the version-independent `LibMCPU` `.TH` source field. # LibMCPU 0.3.32 LibMCPU 0.3.32 is a production-polish release over the verified 0.3.31 package baseline. Successful `mcpu-as` and `mcpu-ld` invocations are now quiet by default; the existing developer object summaries are preserved unchanged behind the new `-v` / `--verbose` option. `mcpu-ld` applies verbose reporting consistently to partial ET_REL output, ABI-v1 static ET_EXEC, ABI-v3 dynamic ET_EXEC and ABI-v3 ET_DYN output. The command-line help text of the installed MCPU utilities is normalized into a visually stable two-column form: option spellings are separated from their explanations by `-`, continuation lines begin at the explanation text column, and the `mcpu-run` Stage actions list is indented by four spaces. No option semantics other than the new assembler/linker verbose switch are changed. A dedicated regression verifies quiet defaults plus both `-v` and `--verbose` spellings for `mcpu-as` and all `mcpu-ld` output classes. The English and Russian `mcpu-as(1)` / `mcpu-ld(1)` pages document the new behavior. There is no MCPU ISA, MELF ABI, syscall ABI, HLL Runtime ABI, CRT, linker output-format or runtime semantic change in this release. # LibMCPU 0.3.31 LibMCPU 0.3.31 is a source-layout cleanup release over the verified 0.3.30 HLL Runtime ABI baseline. The complete `examples/` tree is removed from the LibMCPU distribution; manual and book examples are now intentionally owned by a separate package rather than by the CPU/runtime implementation release. The canonical `mcpu-ld.conf` source moves from top-level `etc/` to `sysroot/etc/`, matching the existing rule that `sysroot/` is the build-time image of the target MCPU environment. Its installed location and runtime lookup contract are unchanged: LibMCPU still installs it as `/etc/mcpu-ld.conf`. The obsolete development-only `sysroot/usr/src/mcpu/libc-stub/` and `sysroot/usr/src/mcpu/hll-emul/` trees are removed. The small assembler inputs required by the HLL/CRT regression suite now live under `tests/fixtures/hll/`, so tests remain self-contained without placing test emulators in the target sysroot. There is no MCPU ISA, MELF ABI, syscall ABI, HLL Runtime ABI, CRT behavior, linker/runtime semantics, or installed-path change in this release. It is the clean LibMCPU package boundary for future development: implementation + target sysroot + regression tests + documentation, with examples distributed separately. # LibMCPU 0.3.30 LibMCPU 0.3.30 fixes the dynamic-MCPU-Libc side of the signed HLL Runtime ABI v1. Internal runtime hooks (`__mcpu_libc_init`, `__mcpu_init_array`, `__mcpu_fini_array`, `__mcpu_libc_fini`) may now be exported by a normal ABI-v3 ET_DYN MCPU Libc dependency and resolved by an HLL dynamic executable. Explicit preload modules are still forbidden from interposing those four hooks. HLL complete-program entry functions and MELF lifecycle symbols retain their existing non-preemptible rules. No existing manual example is changed. # LibMCPU 0.3.29 LibMCPU 0.3.29 is a small development-convenience follow-up to the verified 0.3.28 HLL Runtime ABI implementation. It adds standalone Makefiles under `sysroot/usr/src/mcpu/libc-stub/` and `sysroot/usr/src/mcpu/hll-emul/`. The libc-stub Makefile builds the temporary `libc-stub.o`; the HLL emulator Makefile builds the PROGRAM and MODEL compiler-output emulator objects and links runnable `program-main` and `model-pendulum-life` executables through the installed CRT, while allowing an alternate MCPU sysroot through `MCPU_LDFLAGS`. These Makefiles remain development-only source artifacts: neither libc-stub nor hll-emul outputs are installed. The existing `examples/` tree, including `examples/pendulum/`, is unchanged. # LibMCPU 0.3.28 LibMCPU 0.3.28 implements the first concrete stage of the signed MCPU HLL Runtime ABI v1 without changing any existing manual example. The release adds the canonical CRT sources under `sysroot/usr/src/mcpu/crt/`: `crt0.S` adapts PROGRAM executables to `main`, `crt1.S` adapts MODEL executables to `init`/`life`, `crti.S` performs common `McpuStartup` validation and runtime initialization, and `crtn.S` provides mandatory HLL finalization. The generated `crt0.o`, `crt1.o`, `crti.o`, and `crtn.o` are built out of tree and installed under the active MCPU system root at `lib/mcpu/`. The existing `mcpu-ld` now recognizes compiler-normalized HLL defining objects automatically, with no `--program` or `--model` switch. A PROGRAM defining ET_REL contains strong GLOBAL/FUNC `main` and `fini`; a MODEL defining ET_REL contains strong GLOBAL/FUNC `init`, `life`, and `fini`, all in the same object. The linker rejects incomplete or split complete-program definitions and mixing raw `_start`/`_life` lifecycle ownership with HLL roots, then injects the appropriate CRT for final ET_EXEC links. HLL roots, lifecycle symbols, CRT-private names, and the internal CRT/Libc runtime-hook bindings are kept non-preemptible in ABI-v3 executables. The CRT uses the existing persistent `McpuStartup` area created by the loader. It validates the v1 descriptor before Libc initialization, checks that the unsigned startup `argc` is representable by the signed target `int64` HLL ABI, preserves the existing PTR64 `argv`, and builds the ordinary two-slot CALL ABI argument block for `main(int64 argc, PTR64 argv)` or `init(int64 argc, PTR64 argv)`. The internal runtime-hook ABI is `void __mcpu_libc_init(void)`, `void __mcpu_init_array(void)`, `void __mcpu_fini_array(void)`, and `void __mcpu_libc_fini(void)`; Libc does not build or own `argc`/`argv`. The release also implements the signed PRE_RUNTIME/RUNNING distinction. Startup validation failures use the normal graceful `EXIT` path while CRT state is still PRE_RUNTIME; `_fini` therefore performs only `END` and does not call user `fini` or Libc finalization hooks. Once startup hooks complete, normal PROGRAM/MODEL exits run `fini`, `__mcpu_fini_array`, `__mcpu_libc_fini`, then `END` while preserving the original exit status. MODEL `life()` uses the fixed int32 namespace: `-2147483648` means continue through one `END`, zero means natural `EXIT(0)`, positive values are error exit statuses, and the remaining negative values stay reserved. Until the separate MCPU Libc and `mcpu-cc` projects exist, regression-only sources live beside the CRT under `sysroot/usr/src/mcpu/`. `libc-stub/` emulates the four internal Libc hooks and is never installed. `hll-emul/` contains PROGRAM and pendulum-shaped MODEL assembler fixtures that emulate future compiler output while defining no MELF lifecycle symbols. The MODEL fixture does not include, depend on, or modify `examples/pendulum/`. The complete pre-existing `examples/` tree remains byte-identical to LibMCPU 0.3.27. The existing ET_DYN ownership rule is retained: shared objects may allocate only ordinary `.text`, `.data`, and `.bss`; `.init`, `.fini`, `.control`, `.input`, `.output`, `.trace`, lifecycle ownership, STACK, and HEAP remain properties of the main ET_EXEC. New end-to-end regressions cover automatic CRT insertion, PROGRAM and MODEL lifecycle behavior, startup failure, hook ordering, ABI-v3 non-interposition, and the ET_DYN restrictions. # LibMCPU 0.3.27 LibMCPU 0.3.27 extends the verified 0.3.26 descriptor baseline with `dup` (`__NR_dup=0x126`) and `dup2` (`__NR_dup2=0x127`). Both calls operate entirely in the per-`cpu_context` guest descriptor namespace: HOST descriptor numbers remain private implementation details. `dup` returns the lowest available guest descriptor, including a previously closed standard guest slot, and returns `-EMFILE` when no guest slot is available. `dup2(oldfd,newfd)` validates the source before changing the target, rejects target values outside 0..255 with `-EBADF`, returns `newfd` unchanged when `oldfd == newfd`, and otherwise replaces exactly the requested guest descriptor. A real duplication clears guest descriptor flags on the new descriptor, while the `oldfd == newfd` no-op preserves them. Replacement of borrowed guest stdin/stdout/stderr never closes the supervisor process HOST stdio. The common layer intentionally does not call HOST `dup2()`: it first creates an independent HOST duplicate with the new `__cpu_sys_dup()` adapter and then binds that HOST descriptor to the requested guest slot. A new `tst-dup` regression checks lowest-free allocation, exact-target replacement, descriptor-flag semantics, `oldfd == newfd`, reuse of closed guest fd 0, stable `-EBADF`, and preservation of an occupied target when the source is invalid. `examples/syscalls/` adds manual `dup-basic` and `dup2-basic` demonstrations and the canonical `sysroot/include/sys/asm/syscall.h` plus the standalone example snapshot publish the two new syscall numbers. No other `examples/` subtree is changed. # LibMCPU 0.3.26 LibMCPU 0.3.26 is a control/layout release with no MCPU ABI change. The canonical public assembler ABI headers move from the manual examples tree to `sysroot/include/sys/asm/`. Top-level installation now takes `sys/asm/*.h` only from this canonical sysroot tree, and `tests/tst-errno-abi` validates the public errno/MPU errno headers through `-I$(top_srcdir)/sysroot/include`, so regression tests no longer depend on `examples/`. `examples/syscalls/include/sys/asm/` remains a byte-identical standalone snapshot for the manual/book syscall examples. A maintainer-only `make sync-example-syscall-headers` target copies canonical headers from `sysroot/` to that snapshot; normal `make`, `make check`, `make dist`, and `make install` do not invoke the sync operation. This establishes the one-way ownership rule `sysroot -> examples` and allows the examples tree to be split into a separate distribution later without moving or reconstructing the public MCPU ABI headers. The control release also removes the remaining regression-test dependency on the manual `examples/` tree. Assembly inputs that had historically been reused by test runners are copied unchanged into `tests/fixtures/`, including the dynamic shared-library fixtures, and every affected runner now resolves those files below `TEST_SRCDIR/fixtures`. The manual examples themselves are unchanged. Therefore `make check` no longer consumes files from `examples/`; examples remain user/book material only. # LibMCPU 0.3.25 LibMCPU 0.3.25 replaces the historical negative HOST-errno syscall ABI with a stable HOST-independent MCPU error namespace. System-call failures now return `-MCPU_errno`; `SYS_brk` retains its previously signed special return contract. The public assembler header `sys/asm/errno.h` fixes the MCPU values through `EFTYPE=134`, preserves `EWOULDBLOCK=EAGAIN`, `EDEADLOCK=EDEADLK`, and `ENOTSUP=EOPNOTSUPP`, reserves 135..4094 for future ABI growth, and defines `EUNKNOWN=4095` for an unknown or unmapped HOST error. All existing common-layer error paths now use internal `__MCPU_E*` constants. Every selected HOST syscall adapter translates a real HOST failure through `__cpu_errno_from_host()` before returning to common MCPU code, including the direct positive error-number convention of HOST `clock_nanosleep()`. Raw HOST errno values therefore stop at the sysdeps boundary. The translator maps symbolic HOST errno names rather than assuming numeric identity, accepts HOST aliases whether or not their numbers coincide, maps zero to zero, and falls back to `__MCPU_EUNKNOWN` for an invalid or unknown value. The release also adds `sys/asm/mpu-errno.h`, which publishes the LibMPU 1.0.25 error names and values unchanged. For MCPU users, MPU is documented as the conceptual Math Processor Unit coprocessor with independent integer, real, complex, and math error-state domains. MPU error state is not automatically converted to system errno; that mapping remains future guest-libc policy. Two regression programs verify the public/internal MCPU errno contract, HOST translation including aliases and fallback, and the fixed MPU constants. No new syscall, signal, socket, timer, or ISA operation is introduced. # LibMCPU 0.3.24 LibMCPU 0.3.24 extends the verified 0.3.23 time ABI with `nanosleep` (`__NR_nanosleep=0x030`) and `clock_nanosleep` (`__NR_clock_nanosleep=0x031`). Both calls reuse the fixed 16-byte signed-64-bit MCPU `timespec`; valid sleep values require `tv_sec >= 0` and `0 <= tv_nsec < 1000000000`. `nanosleep` is implemented in the common syscall layer as a relative `CLOCK_MONOTONIC` wait over the single new fundamental HOST adapter `__cpu_sys_clock_nanosleep()`. `clock_nanosleep` supports only the existing MCPU `CLOCK_REALTIME=0` and `CLOCK_MONOTONIC=1` namespace and adds the HOST-independent `TIMER_ABSTIME=1` flag. Relative mode validates writable `rem` before blocking and writes it only when the HOST wait is interrupted with `EINTR`. Absolute mode treats `req` as a clock deadline and deliberately ignores `rem` completely, including pointer validation. The Linux/x86_64/LP64 adapter explicitly maps clock IDs and `TIMER_ABSTIME`, checks signed 64-bit seconds against HOST `time_t`, and normalizes the libc `clock_nanosleep()` direct error-number convention into LibMCPU's usual negative HOST errno ABI. `examples/syscalls/` adds manual `nanosleep-relative` and `clock-nanosleep-absolute` demonstrations. The first exposes before/after `CLOCK_MONOTONIC` timestamps using `--after-run=print-int-data:64@16,64@24,64@32,64@40`; the second demonstrates an absolute monotonic deadline one second in the future. The syscall README explains interruption/remainder semantics and why absolute deadlines avoid cumulative period drift. No signal, POSIX timer, time-setting, CPU-time clock, or Linux-specific clock interface is added. No other `examples/` subtree and no regression test is changed. # LibMCPU 0.3.23 LibMCPU 0.3.23 extends the verified 0.3.22 syscall baseline with the first time-reading block: `gettimeofday` (`__NR_gettimeofday=0x01c`), `clock_getres` (`__NR_clock_getres=0x021`), and `clock_gettime` (`__NR_clock_gettime=0x022`). The MCPU ABI defines fixed 16-byte `timeval` and `timespec` objects containing signed 64-bit seconds plus a separate signed 64-bit fractional field. HOST `time_t`, `long`, `struct timeval`, and `struct timespec` never cross the guest boundary. The initial MCPU clock namespace contains only `CLOCK_REALTIME=0` and `CLOCK_MONOTONIC=1`. The Linux/x86_64/LP64 sysdeps adapters explicitly translate those IDs to HOST clocks and reject every unsupported ID with `-EINVAL`. `clock_gettime` requires a non-NULL writable guest timespec pointer; `clock_getres` permits a NULL result pointer while still validating the clock ID. `gettimeofday` remains a two-argument compatibility ABI, requires a non-NULL timeval pointer and a NULL obsolete timezone pointer, and is implemented in the common syscall layer by reading MCPU `CLOCK_REALTIME` and converting nanoseconds to microseconds. No independent HOST `gettimeofday` wrapper is added. `examples/syscalls/include/sys/asm/time.h` publishes the fixed layouts and clock IDs, while `select.h` now imports that shared timeval definition without changing the existing select ABI. Manual `gettimeofday`, `clock-gettime`, and `clock-getres` examples expose the returned two-field structures through `mcpu-run --int-data=64@16,64@24`, and the syscall README documents the clock semantics, 64-bit range, HOST conversion boundary, and why CPU-time clocks and time-setting calls are intentionally outside this release. No other `examples/` subtree and no regression test is changed. # LibMCPU 0.3.22 LibMCPU 0.3.22 extends the verified 0.3.21 syscall baseline with a current-working-directory state owned by each `cpu_context`. The new calls are `chdir` (`__NR_chdir=0x108`) and `fchdir` (`__NR_fchdir=0x125`). Neither call proxies HOST `chdir()` or HOST `fchdir()`: the Linux/x86_64/LP64 implementation stores an independent `O_PATH|O_DIRECTORY` directory capability in the MCPU context, so changing a guest cwd never changes the process-global cwd of `mcpu-run`. All existing pathname syscalls that accept relative names now resolve them against this context-local directory by using the corresponding Linux `*at()` interfaces. This covers `open`, `creat`, `link`, `unlink`, `rename`, `mkdir`, `chmod`, `chown`, `access`, `rmdir`, `symlink` link-path resolution, `readlink`, `stat`, `lstat`, and pathname `truncate`. Absolute pathnames continue to behave normally. Since Linux has no `truncateat`, the selected adapter implements context-relative pathname `truncate` as `openat` followed by `ftruncate`, without changing the guest ABI. `fchdir` resolves a guest descriptor through the per-context fd table and creates a separate directory capability for cwd state. The original guest descriptor may therefore be closed immediately after `fchdir` without invalidating the current directory. `examples/syscalls/` adds manual `chdir-open` and `fchdir-open` demonstrations and the README documents context isolation, relative pathname resolution, lifecycle ownership, and the distinction between guest cwd and the supervisor process cwd. No other `examples/` subtree and no regression test is changed. # LibMCPU 0.3.21 LibMCPU 0.3.21 extends the verified 0.3.20 descriptor baseline with `select` (`__NR_select=0x11e`). The guest ABI uses a fixed 32-byte descriptor set containing four target-order u64 words, covering all 256 guest descriptor numbers, and an optional fixed 16-byte input-only timeout containing signed 64-bit seconds and microseconds. HOST `fd_set`, HOST `timeval`, and HOST descriptor numbers are never exposed. The common syscall layer validates every selected guest descriptor below `nfds`, resolves it through the per-`cpu_context` descriptor table, and overwrites only the supplied guest sets with ready bits on success. `nfds` is limited to 0..256, invalid guest descriptors return `-EBADF`, invalid timeout values return `-EINVAL`, and a NULL timeout means an unlimited wait. The timeout is deliberately input-only so the guest ABI does not inherit HOST-specific timeout-update behavior. The Linux/x86_64/LP64 adapter uses `ppoll()` internally rather than HOST `fd_set`. This avoids HOST `FD_SETSIZE` limitations and keeps readiness translation explicit: read, write, and exceptional conditions are mapped into MCPU readiness classes. `examples/syscalls/` adds the manual `select-pipe` demonstration and `sys/asm/select.h`; the guest creates a pipe, writes data, waits for the read end with select, prints the bytes, and exposes the returned ready-bit count through DATA:16. No other `examples/` subtree and no regression test is changed. # LibMCPU 0.3.20 LibMCPU 0.3.20 extends the verified 0.3.19 descriptor baseline with `pipe2` (`__NR_pipe2=0x11a`). The guest ABI writes two u64 guest descriptor numbers into a fixed 16-byte output array: the read end at offset 0 and the write end at offset 8. The pair is allocated atomically in the per-`cpu_context` descriptor namespace and HOST fd numbers are never exposed. The supported MCPU flags are `O_NONBLOCK` and `O_CLOEXEC`. `O_NONBLOCK` is explicitly translated by the Linux/x86_64/LP64 sysdeps adapter. `O_CLOEXEC` is deliberately kept as guest descriptor state (`FD_CLOEXEC`) on both new descriptors and is not proxied to HOST `FD_CLOEXEC`, preserving the future guest `exec` contract established by `fcntl`. Unknown flag bits return `-EINVAL`; inability to allocate two guest descriptor slots returns `-EMFILE`. `examples/syscalls/` adds the manual `pipe2-basic` demonstration. The guest writes a line through the write end, reads it from the read end, prints the returned bytes, and exposes `F_GETFD` through DATA:16 so the reader can see that `O_CLOEXEC` became guest `FD_CLOEXEC=1`. The README documents the 16-byte pipefd layout, rollback rules and flag translation. No other `examples/` subtree and no regression test is changed. # LibMCPU 0.3.19 LibMCPU 0.3.19 extends the verified 0.3.18 filesystem baseline with `fcntl` (`__NR_fcntl=0x119`). The initial HOST-independent MCPU command set is `F_DUPFD=0`, `F_GETFD=1`, `F_SETFD=2`, `F_GETFL=3`, and `F_SETFL=4`; `FD_CLOEXEC=1` is a guest descriptor flag. `F_DUPFD` duplicates the underlying HOST file description but allocates the returned descriptor in the per-`cpu_context` guest namespace at or above the guest-provided minimum. The new guest descriptor owns its duplicated HOST fd and starts with descriptor flags cleared. `F_GETFD`/`F_SETFD` operate only on guest descriptor flags; they deliberately do not proxy HOST `FD_CLOEXEC`, so future guest `exec` semantics remain independent from the supervisor process. `F_GETFL` explicitly translates HOST access mode, `O_APPEND`, and `O_NONBLOCK` into MCPU flags. `F_SETFL` accepts the MCPU access-mode bits for the conventional GETFL/SETFL cycle but only changes `O_APPEND` and `O_NONBLOCK`; creation-time flags are rejected with `-EINVAL`. HOST `F_*` and `O_*` numbers are never exposed as MCPU ABI. `examples/syscalls/` adds manual `fcntl-getfl`, `fcntl-setfl`, `fcntl-dupfd`, and `fcntl-fdflags` demonstrations. The README explains descriptor flags versus file-status flags, guest descriptor duplication, the future role of `FD_CLOEXEC`, and the exact three-argument MCPU syscall ABI. No other `examples/` subtree is changed. # LibMCPU 0.3.18 LibMCPU 0.3.18 extends the verified 0.3.17 filesystem baseline with `getdents` (`__NR_getdents=0x11d`) and a fixed 288-byte `struct __cpu_dirent` guest ABI. HOST directory layouts are never copied into guest memory. The Linux/x86_64/LP64 adapter translates inode, directory cookie, entry type and UTF-8 name into fixed records; returned byte counts are always whole-record multiples, and zero means end of directory. `examples/syscalls/` adds a manual `getdents-dir` demonstration and `sys/asm/dirent.h`. The guest itself walks the returned records and prints each `d_name`; the README documents the complete layout, UTF-8 boundary, fixed record size and directory-order semantics. No other `examples/` subtree is changed. # LibMCPU 0.3.17 LibMCPU 0.3.17 extends the verified 0.3.16 filesystem baseline with file-length and synchronization calls: `truncate`, `ftruncate`, and `fsync`. Their MINIX3-inspired VFS numbers are `__NR_fsync=0x120`, `__NR_truncate=0x121`, and `__NR_ftruncate=0x122`. `truncate(path,length)` accepts a strict NUL-terminated UTF-8 pathname and a signed 64-bit guest length. `ftruncate(fd,length)` resolves the per-context guest descriptor before entering the HOST adapter. Both adapters require the guest length to be exactly representable by HOST `off_t`; an unrepresentable value returns `-EOVERFLOW`, while filesystem and negative-length policy remains the responsibility of the HOST kernel and is reported as `-host_errno`. `fsync(fd)` also resolves a guest descriptor through the current `cpu_context` and forwards an explicit synchronization request to the selected HOST backend. It introduces no new guest structure or HOST typedef into the ABI. `examples/syscalls/` adds manual `truncate-file`, `ftruncate-file`, and `fsync-file` demonstrations. The first two show observable file sizes before and after the guest operation; the fsync example demonstrates `open -> write -> fsync -> close` and the README explains why durability itself is not a distinct content transformation that can be displayed after a normal run. No other `examples/` subtree is changed. # LibMCPU 0.3.16 LibMCPU 0.3.16 extends the verified 0.3.15 filesystem baseline with metadata modification calls: `chmod`, `fchmod`, `chown`, and `fchown`. Their MINIX3-inspired VFS numbers are `__NR_chmod=0x10b`, `__NR_chown=0x10c`, `__NR_fchmod=0x123`, and `__NR_fchown=0x124`. `chmod` and `fchmod` reuse the existing HOST-independent MCPU permission bits and explicitly translate them into HOST `mode_t`. `fchmod` resolves the guest descriptor through the per-context guest-fd table before entering the HOST adapter. The ownership ABI uses 64-bit unsigned guest uid/gid scalars. `__MCPU_ID_NO_CHANGE` is `UINT64_MAX` and maps explicitly to the POSIX `(uid_t)-1` / `(gid_t)-1` sentinel. Other values must be representable by the selected HOST `uid_t`/`gid_t`; otherwise the wrappers return `-EOVERFLOW`. No HOST typedef is exported into the guest ABI. `examples/syscalls/` adds manual `chmod-file`, `fchmod-file`, `chown-file`, and `fchown-file` demonstrations. The ownership examples deliberately use the no-change sentinel so they remain safe and runnable by an ordinary user; the README explains how real ownership changes interact with HOST permissions. No other `examples/` subtree is changed. # LibMCPU 0.3.15 LibMCPU 0.3.15 extends the verified 0.3.14 pathname syscall baseline with hard and symbolic link operations: `link`, `symlink`, and `readlink`. Their syscall numbers continue the established MINIX3-inspired VFS space: `__NR_link=0x106`, `__NR_symlink=0x113`, and `__NR_readlink=0x114`. `link(oldpath,newpath)` and `symlink(target,linkpath)` reuse the strict NUL-terminated UTF-8 guest pathname boundary. `readlink(path,buffer,count)` writes raw target bytes into writable guest memory and returns the exact number of bytes written; it deliberately does not add a NUL terminator. The Linux/x86_64/LP64 sysdeps layer gains `sys-link.c`, `sys-symlink.c`, and `sys-readlink.c`, and configure now requires the corresponding HOST interfaces and selected wrappers. `examples/syscalls/` adds manual `link-file`, `symlink-file`, and `readlink-file` demonstrations. The README explains hard-link inode identity, symbolic-link target storage, the non-NUL-terminated `readlink` contract, buffer truncation semantics, and the use of the syscall return value as the byte count for a following `write`. No other `examples/` subtree is changed. # LibMCPU 0.3.14 LibMCPU 0.3.14 extends the verified 0.3.13 pathname syscall baseline with directory and access operations: `mkdir`, `access`, and `rmdir`. Their syscall numbers continue the established MINIX3-inspired VFS space: `__NR_mkdir=0x109`, `__NR_access=0x10f`, and `__NR_rmdir=0x112`. `mkdir(path, mode)` uses the existing strict UTF-8 pathname boundary and translates MCPU mode bits explicitly into HOST `mode_t`. `access(path, mode)` adds the stable guest constants `F_OK=0`, `X_OK=1`, `W_OK=2`, and `R_OK=4`; unsupported guest access bits are rejected with `-EINVAL` instead of being passed through to the HOST. `rmdir(path)` removes an empty directory through the selected HOST sysdeps adapter. All failures continue to return negative HOST `errno` values. The Linux/x86_64/LP64 sysdeps layer gains `sys-mkdir.c`, `sys-access.c`, and `sys-rmdir.c`; configure now requires all three adapters and also checks the corresponding POSIX interfaces. No new HOST structure layout or typedef is exposed to the guest ABI. `examples/syscalls/` adds manual `mkdir-dir`, `access-file`, and `rmdir-dir` examples with reader-oriented run scripts. The README explains requested directory modes, HOST umask interaction, `F_OK/R_OK/W_OK/X_OK`, access semantics, and the observable effects of directory creation/removal. No other `examples/` subtree is changed. # LibMCPU 0.3.13 LibMCPU 0.3.13 extends the verified 0.3.12 filesystem syscall baseline with three pathname operations: `creat`, `unlink`, and `rename`. Their syscall numbers follow the established MINIX3-inspired VFS space: `__NR_creat=0x104`, `__NR_unlink=0x107`, and `__NR_rename=0x111`. `creat(path, mode)` returns a LibMCPU guest descriptor and reuses the existing `open` host adapter with `O_WRONLY|O_CREAT|O_TRUNC`, preserving the already verified MCPU mode-bit translation and guest-fd namespace. `unlink(path)` and `rename(oldpath,newpath)` use the existing strict NUL-terminated UTF-8 pathname boundary and return `-host_errno` on failure. The Linux/x86_64/LP64 sysdeps layer gains `sys-creat.c`, `sys-unlink.c`, and `sys-rename.c`, and configure now requires these adapters for the selected HOST sysdeps hierarchy. No new host structure layout is exposed to the guest ABI. `examples/syscalls/` adds manual `creat-file`, `rename-file`, and `unlink-file` examples and matching reader-oriented run scripts. Its README documents the new ABI and examples in detail for later use in the LibMCPU programming book. No other `examples/` subtree is changed. # LibMCPU 0.3.12 LibMCPU 0.3.12 is a small user-facing refinement of the verified 0.3.11 filesystem-metadata syscall release. The `stat`, `fstat`, and `lstat` ABI and implementation are unchanged. The external assembler header `sys/asm/stat.h` now uses the `__MCPU_STAT_*` prefix consistently for the fixed 128-byte stat layout and all field offsets. The internal LibMCPU C type remains `struct __cpu_stat`; the change only separates the public assembler namespace from the private `__cpu_` C namespace. The manual `stat-file`, `fstat-file`, and `lstat-link` examples copy `st_size` from their `.bss` stat buffer into a small 64-bit DATA result slot at DATA offset 16. Their run scripts invoke `mcpu-run --int-data=64@16`, allowing readers to see a real metadata value returned by the syscall. The accompanying `examples/syscalls/README` explains the data flow and the expected output in detail.