diff --git a/Cargo.lock b/Cargo.lock index b7ba4440ab..e4e280a07f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -873,6 +873,7 @@ dependencies = [ "layerfs-storage", "layerfs-telemetry", "layerfs-workspace", + "libc", ] [[package]] diff --git a/docs/architecture/engine/daemon/README.md b/docs/architecture/engine/daemon/README.md index b9fc6cf087..3dca44653b 100644 --- a/docs/architecture/engine/daemon/README.md +++ b/docs/architecture/engine/daemon/README.md @@ -62,7 +62,7 @@ layerfs-daemon --config | Takes a fresh incarnation | `generate_keypair()`; the public half is `DaemonStatus.instance` | [`application/owner.rs`](../../../../engine/crates/layerfs-daemon/src/application/owner.rs) | | Opens the Store | An installed SQLite file with the `Disposable` profile, or PostgreSQL; `Sqlite { install: None }` waits for an install | [`application/owner.rs`](../../../../engine/crates/layerfs-daemon/src/application/owner.rs), [`Cargo.toml`](../../../../engine/crates/layerfs-daemon/Cargo.toml) | | Starts FUSE serving (Linux) | `/dev/fuse` to `0600`, checks the mount home, mounts a private `fusectl` tree for abort controls; if that fails, writes `LAYERFS_DAEMON_ABORT_UNBOUND` and starts without forced unmount | [`application/filesystem.rs`](../../../../engine/crates/layerfs-daemon/src/application/filesystem.rs) | -| Starts NFS serving | `ExportServing`; force-unmounts client mounts a previous daemon left (`LAYERFS_NFS_RECLAIM` lines); helper overrides `LAYERFS_NFS_MOUNT`, `_UNMOUNT`, `_FORCE`, `_FLUSH` | [`application/filesystem.rs`](../../../../engine/crates/layerfs-daemon/src/application/filesystem.rs) | +| Starts NFS serving | `ExportServing`; force-unmounts client mounts a previous daemon left (`LAYERFS_NFS_RECLAIM` lines); the same reclaim deletes `/.appledouble`, the AppleDouble companions' disposable scratch area (directories `0700`, files `0600`, no fsync, no space reserved ahead), and touches nothing else under the mount home; helper overrides `LAYERFS_NFS_MOUNT`, `_UNMOUNT`, `_FORCE`, `_FLUSH` | [`application/filesystem.rs`](../../../../engine/crates/layerfs-daemon/src/application/filesystem.rs), [`export.rs`](../../../../engine/crates/layerfs-daemon/src/control/export.rs) | ### Phases and Hello diff --git a/docs/architecture/engine/kernel-routes/README.md b/docs/architecture/engine/kernel-routes/README.md index 3bfa12028a..938fabffaf 100644 --- a/docs/architecture/engine/kernel-routes/README.md +++ b/docs/architecture/engine/kernel-routes/README.md @@ -73,7 +73,7 @@ stops: a stopped mount starts nothing new and still gives back what it holds. ```text LOOKUP/GETATTR/OPEN/OPENDIR KernelRead::prepare - loop: observe_visit -> Value | Refused | Needs(n): base(); supply; repeat + loop: observe_visit -> Value(Decided) | Refused | Needs(n): base(); supply; repeat READ/READLINK KernelData::read read_visit -> local window; base() only for inherited bytes mutation KernelMutation::perform @@ -85,7 +85,7 @@ stops: a stopped mount starts nothing new and still gives back what it holds. | Type or module | Kernel requests | Source | | --- | --- | --- | -| `KernelRead` | LOOKUP, GETATTR, OPEN, OPENDIR; holds nothing after its visits | [`lookup.rs`](../../../../engine/crates/layerfs-mount-ports/src/operations/lookup.rs) | +| `KernelRead` | LOOKUP, GETATTR, OPEN, OPENDIR; holds nothing after its visits (a LOOKUP also carries the directory it named, and a refused LOOKUP the directory row its own job read) | [`lookup.rs`](../../../../engine/crates/layerfs-mount-ports/src/operations/lookup.rs) | | `KernelData` | READ, READLINK | [`read.rs`](../../../../engine/crates/layerfs-mount-ports/src/operations/read.rs) | | `KernelMutation` | Every changing request; holds one `Publication` ticket until `replied` | [`mutation.rs`](../../../../engine/crates/layerfs-mount-ports/src/operations/mutation.rs) | | `DirectoryStream` | READDIR; only accepted names become valid offsets | [`directory.rs`](../../../../engine/crates/layerfs-mount-ports/src/operations/directory.rs) | diff --git a/docs/architecture/engine/kernel-routes/nfs.md b/docs/architecture/engine/kernel-routes/nfs.md index 4c8f4e0325..48032f82a8 100644 --- a/docs/architecture/engine/kernel-routes/nfs.md +++ b/docs/architecture/engine/kernel-routes/nfs.md @@ -14,7 +14,7 @@ and MOUNT are written over `std::net` with no third-party dependency and no platform `cfg` ([`lib.rs`](../../../../engine/crates/layerfs-nfs/src/lib.rs)). The daemon starts it and has the host's own NFS client mount it. -## Server (`server.rs`, `kernel.rs`, `block.rs`) +## Server (`server.rs`, `kernel.rs`, `read.rs`, `block.rs`) ```text host NFS client (mount_nfs on macOS) @@ -35,7 +35,7 @@ The daemon starts it and has the host's own NFS client mount it. | Item | Meaning | Source | | --- | --- | --- | | `Server::start` | Starts the accept thread; one connection serves one call at a time, in arrival order | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | -| `ExportConfig` | `path` (normally `/`), `uid`/`gid` shown on every inode, `read_only`, `refuse_apple_double`, `lookups_held`; `writable(uid, gid)` is the default | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | +| `ExportConfig` | `path` (normally `/`), `uid`/`gid` shown on every inode, `read_only`, `refuse_apple_double`, `lookups_held`, `companion_spill_dir`, `companion_resident_bytes`, `companions_held`; `writable(uid, gid)` is the default | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | | `Server::stop` | Stop accepting, shut down and join every connection, then `Kernel::release`: descriptors first, then lookup references. The engine mount stays with the caller | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | | `Kernel` | What a FUSE kernel would hold for a stateless client: one lookup reference per handed-out serial, implicit file and directory descriptors with the facts last published through them, a parent index for `..` | [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs) | | Verifier | One WRITE/COMMIT verifier per export, from the clock and process id under a random key | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | @@ -108,18 +108,22 @@ drawn once per export; it makes guessing costly and does not authenticate. ## Directories (`directory.rs`) ```text - READDIR / READDIRPLUS (handle, cookie, cookieverf, budget) + READDIR / READDIRPLUS (handle, cookie, cookieverf, maxcount) cookie 0 -> open_directory: fresh descriptor; verifier = its id cookie >0 -> descriptor (serial, verifier) still open? no: BAD_COOKIE cookies: 1 = ".", 2 = "..", then engine-published offsets - one reply = at most one engine window; entries that fit the budget + one reply = at most one engine window; entries that fit maxcount -> publish_cookies(those names); eof only when the window ended and fit ``` | Rule | Source | | --- | --- | | The cookie is the engine's kernel offset on one implicit directory descriptor named by `cookieverf`; a retired offset or a listing continued after an install is `NFS3ERR_BAD_COOKIE`, and the client lists again | [`directory.rs`](../../../../engine/crates/layerfs-nfs/src/directory.rs), [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs) | -| A READDIRPLUS entry carries the facts its listing already read and its handle; each handle takes its one lookup reference in the publishing visit | [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs), [`kernel_cookie.rs`](../../../../engine/crates/layerfs-overlay/src/lifetime/kernel_cookie.rs) | +| A READDIRPLUS entry carries the facts its window read — a local inode's current row, or an inherited inode's immutable base stat — and the handle of its serial, so the client needs no LOOKUP per name; both are optional in RFC 1813 and this export sends both for every named entry whose offsets the reply publishes, each handle taking its one lookup reference in the publishing visit (reused offset ranges take none) | [`directory.rs`](../../../../engine/crates/layerfs-nfs/src/directory.rs), [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs), [`kernel_cookie.rs`](../../../../engine/crates/layerfs-overlay/src/lifetime/kernel_cookie.rs) | +| A window's inherited inode values cost one batch inode demand for each level of the inode tree the cache does not already answer (`lookup_many` reads a level's pages in one `read_canonical_batch`, resident levels cost none) and its ordinary file lengths one batch length demand (`provide_lengths`) while the cache can remember them (too small for one entry remembers nothing, so each file asks for its own length); entries memory already answers cost no Store reader. Names and kinds come first, the offer then truncates the window to the names the reply publishes, and only those names' facts are read, so a re-sent reply reads nothing for a name it does not send. Test counts where earlier visits warmed upper levels are not a fresh mount's first window | [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs), [`client.rs`](../../../../engine/crates/layerfs-workspace/src/base/client.rs) | +| Those batches are not everything an entry costs, and this route changes none of the rest: an inherited inode whose metadata is not inline reports one portable-metadata demand per distinct metadata root, a listed subdirectory one listing of that subdirectory for its child-directory count, and a symlink entry one read of its target; only ordinary files with inline metadata pay only those batches (when the cache remembers lengths) | [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs), [`view.rs`](../../../../engine/crates/layerfs-workspace/src/base/view.rs), [`links.rs`](../../../../engine/crates/layerfs-workspace/src/base/links.rs) | +| READDIR has one count, which bounds the whole reply; READDIRPLUS sends `dircount` before it, and only `maxcount` bounds this reply | [`nfs.rs`](../../../../engine/crates/layerfs-nfs/src/nfs.rs), [`directory.rs`](../../../../engine/crates/layerfs-nfs/src/directory.rs) | +| A reply's `dir_attributes` are the facts of the listed directory its window read — a local row, fresh from that visit, costing no extra read. An inherited directory has no local row, so its window reads none and the reply carries no attributes; the client then falls back to its own `actimeo` rather than restarting it on facts nothing refreshes | [`directory.rs`](../../../../engine/crates/layerfs-nfs/src/directory.rs), [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs) | | `.` and `..` carry no attributes; `..` comes from the parent recorded at lookup, create, move or listing | [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs) | | Silly names and AppleDouble companions are never listed | [`names.rs`](../../../../engine/crates/layerfs-nfs/src/names.rs), [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs) | @@ -137,7 +141,7 @@ drawn once per export; it makes guessing costly and does not authenticate. | --- | --- | | A publication ticket is released only after the reply's one send attempt, whether or not it reached the client | [`server.rs`](../../../../engine/crates/layerfs-nfs/src/server.rs) | | A WRITE is split into `WRITE_WINDOW` (256 KiB) windows, each one publication; a failure after the first is a short write of the windows already published. WRITE answers `FILE_SYNC`: published, not durable | [`change.rs`](../../../../engine/crates/layerfs-nfs/src/change.rs), [`changing.rs`](../../../../engine/crates/layerfs-nfs/src/changing.rs) | -| `wcc_data` pre- and post-op attributes come from the publishing job's own inode state, RENAME included; no reply reads an attribute outside the job | [`changing.rs`](../../../../engine/crates/layerfs-nfs/src/changing.rs), [`kernel_visit.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_visit.rs) | +| `wcc_data` pre- and post-op attributes come from the publishing job's own inode state, RENAME included; no reply reads an attribute outside the job. An AppleDouble companion's CREATE, REMOVE or RENAME publishes no engine job and answers both halves from `Table::directory_stats` (or absent when unseen) | [`changing.rs`](../../../../engine/crates/layerfs-nfs/src/changing.rs), [`kernel_visit.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_visit.rs), [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs) | | RENAME looks nothing up first; a detached (`nlink == 0`) destination's reference and descriptor are retired inside that job | [`change.rs`](../../../../engine/crates/layerfs-nfs/src/change.rs) | | COMMIT answers the attributes last published or observed through the implicit descriptor, so `fsync` costs no owner job | [`change.rs`](../../../../engine/crates/layerfs-nfs/src/change.rs) | | A client silly rename (`.nfs` + 24 hex on Linux; `.nfs.` + 8 hex + `.` + 4 hex on macOS) is served as an UNLINK; the export keeps the inode until the final REMOVE | [`names.rs`](../../../../engine/crates/layerfs-nfs/src/names.rs) | @@ -145,6 +149,15 @@ drawn once per export; it makes guessing costly and does not authenticate. | SETATTR's guard compares a fresh GETATTR ctime, not atomic with the change; access time is dropped | [`change.rs`](../../../../engine/crates/layerfs-nfs/src/change.rs) | | ACCESS grants owner bits to the inode's uid or uid 0, group bits to its group, else other bits; a read-only export grants no change | [`attributes.rs`](../../../../engine/crates/layerfs-nfs/src/attributes.rs) | +## LOOKUP and GETATTR (`nfs.rs`, `kernel.rs`) + +| Rule | Source | +| --- | --- | +| One owner visit answers a LOOKUP: the job that resolves a name has already read the directory's own row, so the reply's `dir_attributes` cost no second visit | [`nfs.rs`](../../../../engine/crates/layerfs-nfs/src/nfs.rs), [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs), [`kernel_read.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_read.rs) | +| A LOOKUP that fails answers the directory's own fresh facts whenever the job that failed read its row, which is every name this export looks up: a name that binds nothing still read its parent's row in the same visit. `.`, `..`, a silly name, an AppleDouble companion and a refusal decided before any visit read no directory row and send no `dir_attributes`, so the client falls back to its own `actimeo`; RFC 1813 makes both fields optional. No LOOKUP answer repeats the export's last observation of the directory, which nothing ages. A failed LOOKUP's directory row is kept as the export's observation, as a successful one's is | [`nfs.rs`](../../../../engine/crates/layerfs-nfs/src/nfs.rs), [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs), [`kernel_read.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_read.rs) | +| `read.rs` holds what a read answers: the entry, its directory and its descriptors, and the refusal with its status (`NFS3ERR_STALE` for an engine `Stale`, else `NFS3ERR_IO`) and the directory row the job read | [`read.rs`](../../../../engine/crates/layerfs-nfs/src/read.rs) | +| An export remembers the facts it last published or observed for a directory (LOOKUP, GETATTR, OPENDIR, a publishing change) and answers from them only where no job reads that directory: an AppleDouble companion's `wcc_data`, whose change never touches it. A directory listing is not such a place: its reply says only what its own window read | [`kernel.rs`](../../../../engine/crates/layerfs-nfs/src/kernel.rs), [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs) | + ## Refresh after install (`refresh.rs`, daemon `export.rs`, `invalidate.rs`) ```text @@ -163,22 +176,157 @@ drawn once per export; it makes guessing costly and does not authenticate. | The refresh never writes into the Workspace and never reverts a mode the install changed | [`refresh.rs`](../../../../engine/crates/layerfs-nfs/src/refresh.rs) | | `LAYERFS_NFS_REFRESH=0` leaves the client to `actimeo` and close-to-open | [`export.rs`](../../../../engine/crates/layerfs-daemon/src/control/export.rs) | -## AppleDouble files (`apple_double.rs`) +## AppleDouble files (`apple_double.rs`, `apple_double/edit.rs`, `apple_double/index.rs`, `apple_double/reclaim.rs`, `apple_double_codec.rs`, `apple_double_spill.rs`) On NFSv3 the macOS client keeps extended attributes and resource forks in -`._` files. With `refuse_apple_double`, a regular `._` file (at least -one byte after `._`) lives in export memory only, at serial -`SERIALS` (2^62) and above: LOOKUP, GETATTR, ACCESS, READ, WRITE, SETATTR, +`._` files (at least one byte after `._`). With `refuse_apple_double`, a +regular `._` file lives in export state only (`Companions`, serials +`SERIALS` = 2^62 and above): LOOKUP, GETATTR, ACCESS, READ, WRITE, SETATTR, COMMIT, REMOVE and RENAME to another `._` name are served there, READDIR never lists it and the engine is never called. Any other kind is `NFS3ERR_ACCES`. `cp`, `copyfile`, `ditto` and `tar` succeed while nothing -reaches the Workspace or a Commit; everything is dropped with the export. +reaches the Workspace, SQLite overlay or a Commit; everything is dropped with +the export. -| Bound | Value | Over the bound | -| --- | --- | --- | -| `HELD` | 4,096 companions | CREATE `NFS3ERR_ACCES` | -| `FILE_BYTES` | 1 MiB per companion | WRITE `NFS3ERR_FBIG` | -| `TOTAL_BYTES` | 64 MiB in all | WRITE `NFS3ERR_NOSPC` | +| Bound | Value | Over the bound | Source | +| --- | --- | --- | --- | +| `HELD` | 65,536 slotted companion entries | `Companions::admits` decides the bound in one place, before anything is committed: CREATE, and a WRITE, SETATTR or RENAME that needs a new slot, first reclaim the orphan slotted companions outside the companion lock, once, and then answer the whole operation `NFS3ERR_NOSPC` with the body, its length and its name as they were (CREATE also increments `names_refused` and logs at most once per 60 s per export). A call whose commit needs I/O in between (`Companions::reserve`) holds the slot from the decision, so the bound holds when calls race for the last one | [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs) | +| `FILE_BYTES` | 1 MiB per companion | WRITE / SETATTR `NFS3ERR_FBIG` | [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs) | +| `RESIDENT_BYTES` | 32 MiB of companion bodies in all: a body kept as written at its length, a decoded one as `Image::cost`; an edit that leaves a body whole decodes it as it records it, so the count may stand one decoded body over until the next edit needs room | Spill the least recently touched bodies, decoded ones included, to `companion_spill_dir` (`/.appledouble//`); host disk I/O errors map to `NFS3ERR_NOSPC` (`ENOSPC`/`EDQUOT`), `NFS3ERR_FBIG` (`EFBIG`), `NFS3ERR_ACCES` (`EACCES`), `NFS3ERR_PERM` (`EPERM`), `NFS3ERR_ROFS` (`EROFS`) or `NFS3ERR_IO` | [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs), [`apple_double_spill.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double_spill.rs), [`export.rs`](../../../../engine/crates/layerfs-daemon/src/control/export.rs) | +| `DECODED_ENTRY_BYTES` | 128 KiB counted for one decoded companion: a cap on what one decoded body is charged, not on what a companion may store | A whole image costing more, or costing at least its own length (many small attributes), keeps its bytes as written, is charged at their length and still takes no `HELD` slot | [`apple_double.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double.rs) | + +A companion whose main inode the export knows belongs to that inode rather than +to one name: hard links share it, main-file RENAME keeps it under the new name +and existing aliases, and only the inode's last name (or its silly rename) +drops it. A name of the inode that goes does not take its `._` name with it: +after `rm a` of a file that `b` still names, `._a` still answers the inode's +companion, because the `._` name key stays until the inode's last name (a +client whose `actimeo` expired may ask either name). A new file that takes the +freed name reaches the old companion nowhere: `Companions::resolve` takes a +name key only for the inode its companion belongs to, so `._a` answers that new +inode's companion, or `NFS3ERR_NOENT` while it has none. It can hold several of +the inode's `._` names at once: a LINK of a +companion name (`._a` to `._b`, which a client that carries the attributes to +a new name sends) adds one, answering `NFS3ERR_EXIST` for a name already held +and `NFS3ERR_ACCES` for a name of the Workspace, and a REMOVE of one of those +names drops only that name while the companion holds another or its inode has +another name the export knows, and a RENAME of one of them moves only that +name. The REMOVE of the last name of an inode with one +name is the client clearing the attributes, which takes the companion with it, +as does any name of a companion no main inode owns. + +When a write leaves an inode-bound companion holding a complete +AppleDouble image that encodes back to the exact bytes written +([`apple_double_codec.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double_codec.rs)), +it is marked whole and takes no `HELD` slot: decoded in memory (counted as +`Image::cost` against `RESIDENT_BYTES`, at most `DECODED_ENTRY_BYTES` each), or +kept as written bytes, which take the same budget at their length; partial +writes, resource forks, other layouts and unknown-main companions stay as +written bytes and occupy a slot. `companion_rename` re-classifies under the +destination so moving onto an unknown main name takes a slot (a spilled body +keeps its prior class); a decoded body that would be the client's bytes again +and does not fit `RESIDENT_BYTES` is written out first, under the companion's +edit gate and outside the companion lock, so the rename never exceeds the +budget and only records the new name and class. + +`HELD` is the admission limit of this export-local shim, not a Workspace or +Sandbox capacity: the companions live for one mount, are deleted at release and +never reach the Workspace, the SQLite overlay or a Commit (owner decision, +2026-11-14, option C, a scoped waiver). Option A, a per-export SQLite index, is +deferred until `NFS3ERR_NOSPC` shows up in real use; it would add a `rusqlite` +dependency edge to `layerfs-nfs`, which the workspace already pins. + +`Table::names` and `Table::aliases` index each serial's names so unlink, +`entry_taken` (when `nlink <= 1`), `renamed` (keeping an overwritten recalled +name as an alias) and retirement drop only that serial's keys from `by_name` +without scanning it. At the `HELD` bound, CREATE releases the companion lock to +collect orphans from `Companions::slots` (walking only slotted entries under +the table and companion locks, never whole images or `by_name`), then re-acquires +the lock and re-reads the companion name and main file before inserting, so +concurrent GUARDED creates of one name yield one serial and one +`NFS3ERR_EXIST`. The name index is lossy (its own bound, a name never looked +up, a client-side rename), so a candidate whose main inode the export does not +know costs one read-only lookup of its main file in the engine, outside both +locks - and a companion it holds several names of is reached by any of them, so +one whose name the index holds is no candidate at all: a file that is there binds the companion back to that inode and keeps +its attributes, `NFS3ERR_NOENT` - or `NFS3ERR_STALE`/`NFS3ERR_NOTDIR`, a main +file whose directory the engine no longer has, which cannot hold it either - +makes it an orphan, and a lookup that cannot answer any other way leaves it +alone. The lookup that finds the main file took one +engine reference on it, and the export keeps exactly one per serial, so the +visit registers the name it found the file under (`Kernel::entry_taken`, as +`Kernel::lookup` does) before the companion is bound: that name is what makes +the bound companion live for the next reclamation, and its reference is the one +the export later gives back. + +Bodies kept as written and decoded bodies alike, exceeding `RESIDENT_BYTES` +together, are written to `..tmp` (`create_new`, dir `0700`, file +`0600`) and renamed to ``, all of it outside the companion lock; the +body is committed as spilled under the lock afterwards, so a reader reads the +body in memory until its file is whole. One writer per companion is the edit +gate (`Companion::editing`): an edit holds it, and an eviction takes it with +`try_lock`, skipping a companion someone is editing, one another call removed +and one whose file cannot be written out; only a call that finds no room and +then cannot write out its own body answers its own error. A rename is dropped when +the body changed since the snapshot (`used` tick), and a spilled body is opened +by path per `pread`/`pwrite`/`set_len` and never held open; a `pread` shorter +than the length the lock saw is a short read, not `NFS3ERR_IO`. + +One edit per companion runs under that gate +([`edit.rs`](../../../../engine/crates/layerfs-nfs/src/apple_double/edit.rs)), +recording length and bytes together and spilling its own body rather than +failing with `NFS3ERR_IO`. A SETATTR is one such edit from its guard to its +mode and time, and a WRITE reads its pre-op attributes under the gate, so a +guarded SETATTR checks the very body its size change applies to. A body is written out at the length it has and the +edit grows its file itself; the recorded length moves only once the edit's bytes +are in the file, so no GETATTR or READ sees a length whose bytes are not there, +and a refused write leaves the length it had. A spill never replaces a body that +is already on disk. With no spill directory, a body that does not fit evicts +nothing. Eviction follows `Companions::by_use`, the +`(used tick, serial)` order kept on attach, detach and every use: the victim is +the first entry (O(log n) per round, no walk of the index), and the rounds end +when no companion holding memory is left. `ExportServing::reclaim` and release +delete `/.appledouble`. + +Release logs one line per export that still holds companions: +`held= slotted= decoded= resident_bytes= unreachable=`. `unreachable` counts the +companions no name reaches - neither the name a companion records nor another +name of its inode finds it - which is the shape a lost attribute takes when the +body is still held but a client cannot ask for it; a zero beside a client that +lost attributes says the loss was a missing companion rather than a lost name. +The same count is in the holdings a status read reports +(`Released::companions_unreachable`), so the two never disagree; it walks the +companion index, like the release line and the reclamation walk, and only those +diagnostics read it. + +The requests one real client makes can be read from an optional trace +([`trace.rs`](../../../../engine/crates/layerfs-nfs/src/trace.rs)): with +`LAYERFS_NFS_TRACE=1` the export prints, to the daemon's standard error, one +line for each request that names an AppleDouble companion - the `._` names +themselves and the main file names of the inodes that hold one - carrying the +directory serial, the name, the main inode the export's name index gave the +name, which part of the companion index answered it (`route=name` for the +companion's own name key, `route=inode` for the main inode, `route=none` when +neither did), the companion serial a reply carries as its fileid, and the +status the client is answered. A CREATE that finds the companion already held +says whether it would truncate it (`existing-truncate`), a SETATTR of a `._` +file is traced by handle, `BIND` shows a main name the kernel table +re-attributed to an inode that has a companion (`alias` while that inode keeps +several names, `unbound` when the one it held is all it has), and `UNPAIR` +shows what a main name that went left behind: `name-kept` when the companion +belongs to its inode and keeps the `._` name, `companion-dropped` when the +companion goes with it. It is off unless +the variable is exactly `1`, is read once per process, and changes no state; +the lines are written under the lock the request already holds. + +On the `native` route the daemon is started with `env_clear` and an empty +environment (`control/crates/layerfs-sandbox-backend/src/local/create.rs`), so +it does not inherit `LAYERFS_NFS_TRACE=1` from the shell that created the +Sandbox: a trace run there needs `machine update native --daemon` pointed at a +wrapper that exports the variable and `exec`s the real daemon (measured on +macOS 27.2 for #636, where the plain variable gave 0 trace lines and the wrapper +55 and 77 on the two matrices). Other routes start the daemon through a worker +or container, where the environment is passed differently. ## Mount (`mount.rs`, daemon `export.rs`) diff --git a/docs/architecture/engine/workspace/operations.md b/docs/architecture/engine/workspace/operations.md index 480d5e7a02..5c7e1d8fdc 100644 --- a/docs/architecture/engine/workspace/operations.md +++ b/docs/architecture/engine/workspace/operations.md @@ -167,6 +167,7 @@ job. | --- | --- | --- | | Offset from before the handle was last listed from 0 | `rewound()`: lists nothing | [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs) | | Window of whiteouts only | Empty with a continuation; the request reads the next window | same | +| READDIRPLUS reply | Names and kinds come first (batched per inode-tree level), the reply's offer truncates the window to the names it publishes, and only those names' facts are read outside the owner: a re-sent reply reads nothing for a name it does not send | [`kernel_directory.rs`](../../../../engine/crates/layerfs-workspace/src/operations/kernel_directory.rs) | | Names the kernel buffer accepted | Become resume cookies; nothing is held between the two visits or after the reply | same | ## Kernel mutations diff --git a/docs/general/cleanup.md b/docs/general/cleanup.md index 0de4bdc7c1..da5558e14c 100644 --- a/docs/general/cleanup.md +++ b/docs/general/cleanup.md @@ -79,6 +79,7 @@ net change; do not attribute an unisolated change entirely to one removal. | Historical sample databases, exports, and payloads | Closed run, no current consumer, records preserved, disposal authorized | Remove selected payloads and record that they are unavailable for future proof reuse | | Prepared fixture masters, inventories, sealed Stores, binaries, and images | Current task, harness defaults, source identities, and reuse records | Keep resources selected for ongoing work or qualifying reuse | | Docker sample containers and volumes | Exact mapping to closed run records, current processes, consumers, and ownership | Stop and remove the identified resources after ownership is established | +| AppleDouble companion scratch area, `/.appledouble//` in a Sandbox's mount home | Disposable per-mount area: directories `0700`, files `0600`, no fsync and no space reserved ahead; the daemon deletes it at export release and its startup reclaim deletes any it finds, touching nothing else in the mount home | Remove it with the mount home or Sandbox it belongs to; it never holds Workspace, Commit or Store state, so no proof needs it kept | | Inactive agent transcripts and text records | No writer; no pinned file identity or current allocation requirement | Prefer verified transparent compression where supported | | Live application databases, WAL files, active logs, and session state | Owning application and current use | Preserve | | Download, installer, browser, and package caches | Current consumers, installation activity, and supported pruning behavior | Remove unused staging files or prune through the appropriate installed tool | diff --git a/engine/crates/layerfs-daemon/src/control/export.rs b/engine/crates/layerfs-daemon/src/control/export.rs index ead80216dd..2128e08893 100644 --- a/engine/crates/layerfs-daemon/src/control/export.rs +++ b/engine/crates/layerfs-daemon/src/control/export.rs @@ -179,27 +179,44 @@ impl ExportServing { fn directory(&self, token: WorkspaceToken) -> PathBuf { self.config.mounts.join(token.namespace.to_string()) } + fn companion_spill_dir(&self, token: WorkspaceToken) -> PathBuf { + self.spill_root().join(token.namespace.to_string()) + } + /// Every companion's scratch directory lives below this one, outside the + /// mount home's mounts. + fn spill_root(&self) -> PathBuf { + self.config.mounts.join(".appledouble") + } /// At startup, before any Attach: every mount the host still has at or /// under the mount home is one a daemon that ended without unmounting /// left (its export is gone, so the client would hang on it). Each is /// forced off once with the force helper; one line per mount says what - /// happened. Nothing is retried. + /// happened. Nothing is retried. The companions' scratch directories of + /// that daemon belong to exports that are gone too, so they go as well; + /// nothing else under the mount home is touched. pub fn reclaim(&self) -> Vec { + let mut lines = Vec::new(); + let spill = self.spill_root(); + if std::fs::remove_dir_all(&spill).is_ok() { + lines.push(format!("removed leftovers under {}", spill.display())); + } let points = match mounted_under(&self.config.mounts) { Ok(points) => points, - Err(error) => return vec![format!("mount table unreadable: {error}")], + Err(error) => { + lines.push(format!("mount table unreadable: {error}")); + return lines; + } }; - (points.into_iter()) - .map(|point| { - let text = point.display().to_string(); - match self.helpers.run(&self.config.mounter.force, 0, &text) { - Ran::Done => format!("forced off {text}"), - Ran::Busy(detail) | Ran::Failed(detail) | Ran::Interrupted(detail) => { - format!("left {text}: {detail}") - } + lines.extend((points.into_iter()).map(|point| { + let text = point.display().to_string(); + match self.helpers.run(&self.config.mounter.force, 0, &text) { + Ran::Done => format!("forced off {text}"), + Ran::Busy(detail) | Ran::Failed(detail) | Ran::Interrupted(detail) => { + format!("left {text}: {detail}") } - }) - .collect() + } + })); + lines } } /// Mount points at or under `home`, deepest first, from the host's table: @@ -481,12 +498,10 @@ impl Service { } }; let export = ExportConfig { - path: "/".into(), - uid: config.command_uid, - gid: config.command_gid, - read_only: false, refuse_apple_double: config.refuse_apple_double, lookups_held: config.lookups_held, + companion_spill_dir: Some(serving.companion_spill_dir(token)), + ..ExportConfig::writable(config.command_uid, config.command_gid) }; let started = TcpListener::bind((config.listen, 0)).and_then(|listener| { Server::start( @@ -531,6 +546,7 @@ impl Service { Ran::Busy(detail) | Ran::Failed(detail) => { let released = server.stop(); drop(std::fs::remove_dir(&directory)); + drop(std::fs::remove_dir(serving.spill_root())); return Err(self.unwind_export( workspace, mount, @@ -751,6 +767,9 @@ impl Service { return Err(Failure::Retained(Box::new(reply))); } drop(std::fs::remove_dir(&ready.directory)); + if let Some(serving) = self.export.as_ref() { + drop(std::fs::remove_dir(serving.spill_root())); + } if let Ok(mut entries) = self.entries.lock() { if let Ok(binding) = bound_mut(&mut entries, token) { binding.kernel = Kernel::Unattached; diff --git a/engine/crates/layerfs-daemon/src/service/filesystem_port.rs b/engine/crates/layerfs-daemon/src/service/filesystem_port.rs index 173c851221..c2ec044c5a 100644 --- a/engine/crates/layerfs-daemon/src/service/filesystem_port.rs +++ b/engine/crates/layerfs-daemon/src/service/filesystem_port.rs @@ -10,7 +10,7 @@ use layerfs_mount_ports::ports::{ }; use layerfs_overlay::{KernelCookieOffer, KernelMount, Publication}; use layerfs_workspace::{ - BaseView, CanonicalClient, JobOutcome, KernelDirectoryWindow, KernelInput, + BaseView, CanonicalClient, JobOutcome, KernelDirectoryRead, KernelDirectoryWindow, KernelInput, KernelMutationOutcome, KernelReadOperation, KernelReadOutcome, KernelVisitRequest, KernelWindow, Recognition, RecognizeWork, VisitFacts, WorkspaceError, WriteData, RECOGNIZE_BYTES, @@ -106,6 +106,7 @@ impl RequestServices for FilesystemPort { handle: u64, offset: u64, after: Option>, + attributes: bool, ) -> ServiceFuture<'_, ServiceReply>> { // A stopped mount refuses before anything about the request is read. if let Err(fenced) = self.fenced(true) { @@ -116,8 +117,11 @@ impl RequestServices for FilesystemPort { mount, serial, handle, - offset, - after, + KernelDirectoryRead { + offset, + after, + attributes, + }, ); match visit { Ok(visit) => self.call( diff --git a/engine/crates/layerfs-daemon/tests/mounted_sqlite_full.rs b/engine/crates/layerfs-daemon/tests/mounted_sqlite_full.rs index d60ac12e34..2b718a38f2 100644 --- a/engine/crates/layerfs-daemon/tests/mounted_sqlite_full.rs +++ b/engine/crates/layerfs-daemon/tests/mounted_sqlite_full.rs @@ -68,7 +68,7 @@ macro_rules! forward { } impl RequestServices for ObserveRequest { forward! { - directory_visit(mount:KernelMount,serial:u64,handle:u64,offset:u64,after:Option>) -> ServiceReply>; + directory_visit(mount:KernelMount,serial:u64,handle:u64,offset:u64,after:Option>,attributes:bool) -> ServiceReply>; publish_cookies(offer:KernelCookieOffer,names:Vec>) -> ServiceReply<()>; close_directory(mount:KernelMount,serial:u64,handle:u64) -> ServiceReply<()>; read_visit(mount:KernelMount,serial:u64,handle:Option,offset:u64,length:u32) -> ServiceReply>; diff --git a/engine/crates/layerfs-mount-ports/src/operations/directory.rs b/engine/crates/layerfs-mount-ports/src/operations/directory.rs index 874c7bb002..61c8732d82 100644 --- a/engine/crates/layerfs-mount-ports/src/operations/directory.rs +++ b/engine/crates/layerfs-mount-ports/src/operations/directory.rs @@ -20,8 +20,7 @@ pub struct DirectoryStream { offset: u64, parent: Option, window: Option, - /// The reply shows every entry's facts, as READDIRPLUS does: the listing - /// then reads them from the authoritative base, outside the owner. + /// The reply shows each entry's facts (READDIRPLUS). attributes: bool, ended: bool, } @@ -183,7 +182,14 @@ impl DirectoryStream { let started = std::time::Instant::now(); let reply = self .services - .directory_visit(self.mount, self.serial, self.handle, self.offset, after) + .directory_visit( + self.mount, + self.serial, + self.handle, + self.offset, + after, + self.attributes, + ) .await; crate::phase::charge(crate::phase::Phase::DirectoryVisit, started); let reply = reply?; @@ -223,11 +229,12 @@ impl DirectoryStream { let Some(window) = self.window.take().filter(|_| !self.ended) else { return Ok(None); }; - // Only a window whose inherited names or kinds memory did not - // hold leaves the receive loop and takes one Store reader; a - // reply that shows facts needs that reader even when it does. + // Only a window whose inherited names, kinds or facts memory did + // not hold leaves the receive loop and takes one Store reader: a + // local directory, and a window whose inherited entries are all + // resident, are answered without it. let started = std::time::Instant::now(); - let base = if self.attributes || window.listing.is_none() { + let base = if window.needs_base(self.attributes) { // Provider reads never run on the loop that received the request. Some(self.services.base().await?) } else { @@ -277,9 +284,8 @@ impl DirectoryBatch { } /// Records the entries whose handles this reply hands out, so the /// publishing visit takes their kernel references with the offsets. - /// `accepted` is the prefix the reply buffer took; only published - /// offsets can make a handle's fence answer, so a reused reply adopts - /// nothing. + /// `accepted` is the prefix the reply buffer took; only published offsets + /// can make a handle's fence answer, so a reused reply adopts nothing. pub fn adopt(&mut self, accepted: usize) { let entries: Vec<(u64, bool)> = self.batch.entries[..accepted] .iter() diff --git a/engine/crates/layerfs-mount-ports/src/operations/lookup.rs b/engine/crates/layerfs-mount-ports/src/operations/lookup.rs index 5cebfc3bb0..0a77df6119 100644 --- a/engine/crates/layerfs-mount-ports/src/operations/lookup.rs +++ b/engine/crates/layerfs-mount-ports/src/operations/lookup.rs @@ -3,7 +3,7 @@ use crate::ports::{BaseDemandFailed, Fenced, RequestServices, ServiceError, Serv use layerfs_overlay::KernelMount; use layerfs_workspace::{ KernelReadDecision, KernelReadFailure, KernelReadOperation, KernelReadOutcome, KernelReadValue, - Refusal, VisitFacts, + Refusal, ViewStat, VisitFacts, }; use std::{fmt, sync::Arc}; @@ -17,6 +17,9 @@ pub(super) struct Custody { pub data_input: Option, // Retain the engine receipt through every cloned outcome consumer. pub receipt: Option>>, + /// The directory row a refused LOOKUP read in the same job, fresh from + /// that job (see [`KernelRead::refused_directory`]). + pub refused_directory: Option, } /// A deciding answer and the receipt of the visit that decided it. /// The request holds nothing else in the engine; the kernel's lookup, open @@ -126,6 +129,13 @@ impl KernelRead { pub fn value(&self) -> Result<&KernelReadValue, Refusal> { self.value.as_ref().map_err(|refusal| *refusal) } + /// The directory row a refused LOOKUP read in its own job, when it read + /// one: the fresh facts its reply's directory attributes are made of. + /// `None` for every other refusal and for every other operation, none of + /// which read a directory row. + pub fn refused_directory(&self) -> Option<&ViewStat> { + self.custody.refused_directory.as_ref() + } /// Preserve a successfully decided request when kernel reply conversion or /// another downstream invariant fails before consumer disposal. pub fn retain(self, reason: ServiceError) -> ReadFailure { @@ -160,6 +170,7 @@ impl Custody { operation, data_input: None, receipt: None, + refused_directory: None, } } pub(super) const fn target(&self) -> (KernelMount, u64, Option) { @@ -189,17 +200,21 @@ impl Custody { let receipt = receipt?; let original = receipt.get().clone(); let needs = match (&original.result, &original.decision) { - (Ok(None), Some(KernelReadDecision::Value(inode))) => { - let stat = inode.clone().into(); + (Ok(None), Some(KernelReadDecision::Value(decided))) => { + let stat = decided.inode.clone().into(); self.receipt = Some(receipt); return Ok(Ok(KernelReadValue { stat, + parent: decided.parent.clone().map(Into::into), file: original.open_candidate, directory: original.directory_candidate, original, })); } - (Ok(None), Some(KernelReadDecision::Refused(refusal))) => return Ok(Err(*refusal)), + (Ok(None), Some(KernelReadDecision::Refused { refusal, directory })) => { + self.refused_directory = directory.clone().map(Into::into); + return Ok(Err(*refusal)); + } (Ok(None), Some(KernelReadDecision::Needs(needs))) if !needs.is_empty() => needs, _ => { self.receipt = Some(receipt); diff --git a/engine/crates/layerfs-mount-ports/src/ports.rs b/engine/crates/layerfs-mount-ports/src/ports.rs index f7c6f1c789..1bfd63ba81 100644 --- a/engine/crates/layerfs-mount-ports/src/ports.rs +++ b/engine/crates/layerfs-mount-ports/src/ports.rs @@ -161,8 +161,10 @@ pub trait RequestServices: Send + Sync { /// READDIR's reading visit as one read-only owner job on the open /// directory `handle`: the position of the kernel `offset`, one window /// of current names (after `after` when it continues an earlier window - /// of the same request) and the offsets the reply may hand out. It - /// records nothing, so its request holds nothing afterwards. + /// of the same request) and the offsets the reply may hand out. When + /// `attributes` is set (READDIRPLUS), the visit also answers what memory + /// already holds of each entry's facts. It records nothing, so its + /// request holds nothing afterwards. fn directory_visit( &self, mount: KernelMount, @@ -170,6 +172,7 @@ pub trait RequestServices: Send + Sync { handle: u64, offset: u64, after: Option>, + attributes: bool, ) -> ServiceFuture<'_, ServiceReply>>; /// READDIR's publishing visit, before the reply is sent: exactly the /// names the reply buffer accepted become valid offsets, in one diff --git a/engine/crates/layerfs-nfs/Cargo.toml b/engine/crates/layerfs-nfs/Cargo.toml index 63bb04f3d1..309e571a94 100644 --- a/engine/crates/layerfs-nfs/Cargo.toml +++ b/engine/crates/layerfs-nfs/Cargo.toml @@ -20,3 +20,4 @@ layerfs-persistence = { path = "../layerfs-persistence" } layerfs-project = { path = "../layerfs-project" } layerfs-storage = { path = "../../../core/crates/layerfs-storage" } layerfs-telemetry = { path = "../../../core/crates/layerfs-telemetry" } +libc = "=0.2.189" diff --git a/engine/crates/layerfs-nfs/src/apple_double.rs b/engine/crates/layerfs-nfs/src/apple_double.rs index 4f2e2eb4c8..ae9cd22731 100644 --- a/engine/crates/layerfs-nfs/src/apple_double.rs +++ b/engine/crates/layerfs-nfs/src/apple_double.rs @@ -3,11 +3,12 @@ //! On NFSv3 the macOS client keeps a file's extended attributes and resource //! fork in a `._` companion file (see [`crate::names`]). When the export //! keeps such names out of the Workspace, a CREATE of one makes a file that -//! lives only here, in memory, under its own serial range: LOOKUP, GETATTR, -//! ACCESS, READ, WRITE, SETATTR, COMMIT, REMOVE and a RENAME to another -//! AppleDouble name work on it, READDIR does not list it, and no mutation of -//! it ever reaches the engine, so the Workspace stays clean and no Commit can -//! capture it. Everything is dropped when the export is released. +//! lives only here, under its own serial range: LOOKUP, GETATTR, ACCESS, READ, +//! WRITE, SETATTR, COMMIT, REMOVE, a LINK to another AppleDouble name and a +//! RENAME to another AppleDouble name +//! work on it, READDIR does not list it, and no mutation of it ever reaches +//! the engine, so the Workspace stays clean and no Commit can capture it. +//! Everything is dropped when the export is released. //! //! The tree is not consulted for such a name: while this mode is on, a //! LOOKUP of a `._` name answers `NFS3ERR_NOENT` unless the export holds that @@ -16,99 +17,254 @@ //! directory it names, so its `wcc_data` answers both halves from the last //! facts the export saw for it (see [`Kernel::directory_wcc`]). //! -//! The memory is bounded: [`HELD`] companions of at most [`FILE_BYTES`] -//! each and [`TOTAL_BYTES`] in all. Beyond the count a creation is refused -//! (`NFS3ERR_ACCES`, as before this module), beyond the bytes a write -//! (`NFS3ERR_FBIG` per file, `NFS3ERR_NOSPC` in all). +//! A companion created while the export knows its main file (`` in the +//! same directory) belongs to that inode: any name of the inode reaches it, so +//! hard links share one companion, it follows the inode through RENAME, and it +//! goes with the inode's last name rather than with one name. Its FinderInfo +//! and extended attributes are kept under that inode's serial, not under the +//! `._` name. It may hold several of the inode's `._` names at once (a LINK of +//! a companion name makes one, and a client that links a file keeps the +//! attributes aside under each name), and removing one of them leaves the +//! companion to the inode's other names: only its last name, on an inode with +//! no other name the export knows, is the client clearing the attributes. Whenever a write leaves such a companion holding a whole +//! AppleDouble image the client laid out itself (see +//! [`crate::apple_double_codec`]), it is decoded: one whose attributes cost +//! less than its bytes keeps only its FinderInfo and attributes in memory +//! (each at most [`DECODED_ENTRY_BYTES`] counted), and every read synthesizes +//! the same bytes again. Such a whole +//! image takes no slot of the index bound. Any other body +//! (a resource fork, another layout, a half-written image, or a companion whose +//! main file is unknown) is kept as the client wrote it and takes a slot: the +//! index bound, the refusal, its rate-limited log and orphan reclamation stay +//! the fallback for everything decoding does not compress. +//! +//! Every companion keeps its index entry in memory (at most [`HELD`] of them +//! not holding a whole image, each companion at most [`FILE_BYTES`]). Bodies up +//! to [`RESIDENT_BYTES`] in all stay in memory, a body kept as written counted +//! at its length and a decoded one as [`Image::cost`], so a decoded image is +//! memory the budget sees. An edit that leaves a body whole decodes it as it +//! records it rather than asking for room first, so the pool may stand one +//! decoded body over until the next write or resize needs room; that one then +//! spills the least recently touched bodies, decoded ones included, to the +//! export's own scratch directory (see [`crate::apple_double_spill`]). Removing +//! or replacing a main file drops its paired `._` companion when no main +//! inode owns it; a companion that belongs to an inode goes with the inode, so +//! `._` still answers for that inode after the name went, and only the +//! inode's last name takes the companion and every `._` name it holds. When +//! [`HELD`] is reached, orphan companions whose main inode or main +//! file the export no longer knows are reclaimed first, and only if [`HELD`] +//! live companions still remain does `CREATE` answer `NFS3ERR_NOSPC`. use crate::{ + apple_double_codec::Image, + apple_double_spill::{now, unlink_paths, Edit}, attributes::Status, change::{How, Sattr, Tickets, Wcc}, kernel::Kernel, + trace::{self, Route as Trace}, }; -use layerfs_content::{filesystem::attributes::PortableMetadata, object::inode_leaf::InodeKind}; -use layerfs_mount_ports::operations::write::Stamp; +use layerfs_content::filesystem::attributes::PortableMetadata; use layerfs_workspace::ViewStat; use std::{ - collections::HashMap, - sync::atomic::Ordering, - time::{SystemTime, UNIX_EPOCH}, + collections::{BTreeSet, HashMap, HashSet}, + fs, + path::PathBuf, + sync::{atomic::Ordering, Arc, Mutex}, + time::{Duration, Instant}, }; +mod edit; +mod index; +mod reclaim; + /// The first serial of the export's own companions, far above any serial the /// engine allocates. pub const SERIALS: u64 = 1 << 62; -/// Companions held at once. -pub const HELD: usize = 4096; +/// Companion index entries not holding a whole image, held at once. +pub const HELD: usize = 65_536; /// Largest companion kept. pub const FILE_BYTES: u64 = 1 << 20; -/// Bytes kept over all companions. -pub const TOTAL_BYTES: usize = 64 << 20; -/// Mode of a companion created without one. -const MODE: u32 = 0o644; +/// Companion body bytes kept resident in memory before spilling to disk: a +/// body kept as written counts its length, a decoded one [`Image::cost`]. +pub const RESIDENT_BYTES: usize = 32 << 20; +/// Most bytes counted for one decoded companion, [`Image::cost`]: a cap on +/// what one decoded body is charged to [`RESIDENT_BYTES`], not on what a +/// companion may store. A whole image costing more keeps its bytes as written +/// and is charged at their length, so one companion cannot take the whole +/// budget. +pub const DECODED_ENTRY_BYTES: usize = 128 << 10; + +/// A name in one directory: (directory serial, name bytes). +type Named = (u64, Vec); + +enum Body { + Resident(Vec), + /// On disk in the spill directory, under the companion's own serial; each + /// operation opens it by path instead of holding it open. + Spilled, + /// A whole image kept as its FinderInfo and attributes; a read encodes the + /// image again, byte for byte as the client wrote it. + Decoded(Image), +} struct Companion { - named: (u64, Vec), - data: Vec, + /// The `._` name it was created or last renamed to. + named: Named, + /// The other `._` names of the same companion, which a LINK made: a client + /// that links a file keeps its attributes aside under each of the file's + /// names, and every one of them is a name of this one companion. + also: Vec, + /// The main inode it belongs to, when the export knew it at creation. + inode: Option, + /// Its body is a whole image: any name of the inode reads it, and it takes + /// no slot of the index bound. + whole: bool, + len: usize, + body: Body, metadata: PortableMetadata, + used: u64, + /// One edit of this companion at a time: its body's bytes, its length and + /// its spilled file change together, so a truncate and a write can never + /// leave a length its file does not have, and no round has to decide + /// again on a body another call changed under it. + editing: Arc>, +} +impl Companion { + /// The bytes it takes of [`RESIDENT_BYTES`]: its body as written, or what + /// its decoded form is counted as. + fn resident_cost(&self) -> usize { + match &self.body { + Body::Resident(bytes) => bytes.len(), + Body::Spilled => 0, + Body::Decoded(image) => image.cost(), + } + } + /// Whether it takes a slot of the index bound. + fn slotted(&self) -> bool { + !self.whole + } } + +/// A slot of the index the export's own name index cannot reach, and what the +/// reclaim needs to decide about it. +#[derive(Clone)] +struct Orphan { + serial: u64, + /// The main inode the export knows for it; an inode holding no name in the + /// kernel table is gone. + inode: Option, + /// Its main file's directory and name when it has no inode: the name index + /// is lossy, so only the engine can say whether that file is there. + main: Option, + /// Its last use when it was found: a companion used since keeps itself. + used: u64, +} + +/// What [`Companions::reserve`] made of a call's claim on a slot of the index +/// bound. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum Slot { + /// It took the slot, which it gives back if its commit does not land. + Taken, + /// It already held a slot (or a reservation for one), or the companion + /// is gone: nothing was taken. + Held, + /// The bound has none. + Full, +} + +/// What [`Companions::keep_decoded`] made of an edited body. +pub(crate) enum Decoded { + /// The companion holds the body's decoded form. + Kept, + /// The body decodes, but the resident budget needs this many more bytes + /// before the decoded form fits. + Room(usize), + /// Not a body the export decodes: not a whole image, too large to decode, + /// or no main inode. + Unchanged, +} + +/// What an export's companion index holds (see [`crate::kernel::Released`]). +#[derive(Clone, Copy, Debug, Default)] +pub(crate) struct Holding { + pub held: usize, + pub slotted: usize, + pub resident_bytes: usize, + pub decoded: usize, + /// The companions no name reaches, so that a status read and the release + /// line report the same number. + pub unreachable: usize, +} + /// The companions of one export. -#[derive(Default)] pub(crate) struct Companions { next: u64, + tick: u64, files: HashMap, - names: HashMap<(u64, Vec), u64>, - bytes: usize, + names: HashMap, + /// Main inode serial -> the companion holding its FinderInfo and + /// attributes. + inodes: HashMap, + /// The serials taking a slot of the index bound, so reclamation walks only + /// the [`HELD`]-bounded slots rather than every companion: a whole image + /// takes no slot, whether it is decoded or kept as written bytes, so whole + /// images add nothing to the walk. + slots: HashSet, + /// The serials holding a slot for a commit that is still on its way, whose + /// I/O runs outside this lock. A reserved slot counts against the bound, so + /// two calls cannot both be told the bound has room for one. + reserved: HashSet, + /// Every companion holding memory, oldest use first: (used tick, serial). + /// One tick is one touch and no serial takes two ticks, so the keys are + /// unique and the oldest entry is the first one. + by_use: BTreeSet<(u64, u64)>, + resident_bytes: usize, + decoded: usize, + spill_dir: Option, + resident_budget: usize, + held_limit: usize, + last_refusal_log: Option, } -impl Companions { - pub(crate) fn len(&self) -> usize { - self.files.len() - } - fn stat(serial: u64, file: &Companion) -> ViewStat { - ViewStat { - serial, - kind: InodeKind::RegularFile, - metadata: file.metadata, - namespace_refs: 1, - logical_len: file.data.len() as u64, - subdirs: 0, - } - } - fn drop_serial(&mut self, serial: u64) { - if let Some(file) = self.files.remove(&serial) { - self.names.remove(&file.named); - self.bytes -= file.data.len(); +impl Default for Companions { + fn default() -> Self { + Self { + next: 0, + tick: 0, + files: HashMap::new(), + names: HashMap::new(), + inodes: HashMap::new(), + slots: HashSet::new(), + reserved: HashSet::new(), + by_use: BTreeSet::new(), + resident_bytes: 0, + decoded: 0, + spill_dir: None, + resident_budget: RESIDENT_BYTES, + held_limit: HELD, + last_refusal_log: None, } } - /// Resizes `serial` to `size`, within the bounds. - fn resize(&mut self, serial: u64, size: u64) -> Result<(), Status> { - if size > FILE_BYTES { - return Err(Status::FBig); - } - let file = self.files.get_mut(&serial).ok_or(Status::Stale)?; - let old = file.data.len(); - let new = size as usize; - if new > old && self.bytes + (new - old) > TOTAL_BYTES { - return Err(Status::NoSpc); - } - file.data.resize(new, 0); - self.bytes = self.bytes + new - old; - Ok(()) +} +/// How a CREATE that found the companion already held is traced: an UNCHECKED +/// create with an explicit size truncates the body every name of the inode +/// shares, and a GUARDED or EXCLUSIVE one is answered `NFS3ERR_EXIST`. +fn opening(how: &How) -> &'static str { + match how { + How::Unchecked(sattr) if sattr.size.is_some() => "existing-truncate", + How::Unchecked(_) | How::Guarded(_) => "existing", + How::Exclusive(_) => "existing-exclusive", } } -fn now() -> PortableMetadata { - let elapsed = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or_default(); - PortableMetadata { - mode: MODE, - mtime_seconds: i64::try_from(elapsed.as_secs()).unwrap_or(i64::MAX), - mtime_nanoseconds: elapsed.subsec_nanos(), +/// The body length `edit` leaves on a body that had `len` bytes. +fn edited_len(edit: &Edit<'_>, len: usize) -> usize { + match edit { + Edit::Write { .. } => len.max(edit.target_len()), + Edit::Size(size) => *size, } } -fn touch(metadata: &mut PortableMetadata) { - let fresh = now(); - metadata.mtime_seconds = fresh.mtime_seconds; - metadata.mtime_nanoseconds = fresh.mtime_nanoseconds; +/// Records the length `edit` leaves on `file`. +fn record(edit: &Edit<'_>, file: &mut Companion) { + file.len = edited_len(edit, file.len); } /// A serial of the export's own companions. pub fn companion(serial: u64) -> bool { @@ -121,20 +277,86 @@ impl Kernel { .lock() .unwrap_or_else(|poison| poison.into_inner()) } + pub(crate) fn configure_companions( + &self, + spill_dir: Option, + resident_budget: usize, + held_limit: usize, + ) { + if let Some(dir) = &spill_dir { + drop(fs::remove_dir_all(dir)); + } + let mut companions = self.companions(); + companions.spill_dir = spill_dir; + companions.resident_budget = resident_budget; + companions.held_limit = held_limit.max(1); + } + /// The main inode `._` in `parent` pairs with, as the export's own + /// name index knows it. Takes the kernel table: never call it under the + /// companion lock. + fn main_of(&self, parent: u64, name: &[u8]) -> Option { + let main = name.strip_prefix(b"._").filter(|main| !main.is_empty())?; + self.table().by_name.get(&(parent, main.to_vec())).copied() + } /// GETATTR of a companion serial. pub(crate) fn companion_stat(&self, serial: u64) -> Result { - let companions = self.companions(); + let mut companions = self.companions(); let file = companions.files.get(&serial).ok_or(Status::Stale)?; - Ok(Companions::stat(serial, file)) + let stat = Companions::stat(serial, file); + companions.use_serial(serial); + Ok(stat) } - /// LOOKUP of a companion name, if one is held. + /// LOOKUP of a companion name, if one is held for it or for its main + /// inode. pub(crate) fn companion_named(&self, parent: u64, name: &[u8]) -> Option { - let companions = self.companions(); - let serial = *companions.names.get(&(parent, name.to_vec()))?; - companions - .files - .get(&serial) - .map(|file| Companions::stat(serial, file)) + let main = self.main_of(parent, name); + let mut companions = self.companions(); + let (serial, route) = companions.resolve_route(&(parent, name.to_vec()), main); + if crate::names::apple_double(name) { + trace::companion( + "LOOKUP", + parent, + name, + main, + route, + serial, + match serial { + Some(_) => "Ok", + None => "NoEnt", + }, + ); + } + let stat = Companions::stat(serial?, companions.files.get(&serial?)?); + companions.use_serial(serial?); + Some(stat) + } + /// CREATE of an already-held companion name: UNCHECKED applies its size, + /// as an open with truncation would; GUARDED and EXCLUSIVE find it taken. + fn companion_open( + &self, + serial: u64, + how: How, + directory: Wcc, + mut companions: std::sync::MutexGuard<'_, Companions>, + tickets: &mut Tickets, + ) -> Result<(ViewStat, Wcc), Status> { + let stat = Companions::stat(serial, &companions.files[&serial]); + companions.use_serial(serial); + drop(companions); + let How::Unchecked(sattr) = how else { + return Err(Status::Exist); + }; + match sattr.size { + Some(size) => { + let sized = Sattr { + size: Some(size), + ..Sattr::default() + }; + let (stat, _) = self.companion_setattr(stat.serial, sized, None, tickets)?; + Ok((stat, directory)) + } + None => Ok((stat, directory)), + } } /// CREATE of an AppleDouble name. pub(crate) fn companion_create( @@ -145,32 +367,54 @@ impl Kernel { tickets: &mut Tickets, ) -> Result<(ViewStat, Wcc), Status> { let directory = self.directory_wcc(parent); - if let Some(stat) = self.companion_named(parent, name) { - // Opened again: UNCHECKED applies its size, as an open with - // truncation would; GUARDED and EXCLUSIVE find it taken. - let How::Unchecked(sattr) = how else { - return Err(Status::Exist); - }; - return match sattr.size { - Some(size) => { - let sized = Sattr { - size: Some(size), - ..Sattr::default() - }; - let (stat, _) = self.companion_setattr(stat.serial, sized, None, tickets)?; - Ok((stat, directory)) - } - None => Ok((stat, directory)), - }; - } if parent != self.root() && !self.table().parents.contains_key(&parent) { return Err(Status::NotDir); } + let named = (parent, name.to_vec()); + let mut main = self.main_of(parent, name); let mut companions = self.companions(); - if companions.len() >= HELD { + let (held, route) = companions.resolve_route(&named, main); + if let Some(serial) = held { + trace::companion("CREATE", parent, name, main, route, held, opening(&how)); + return self.companion_open(serial, how, directory, companions, tickets); + } + // At the index bound, reclaim the companions no name reaches any more + // first, outside this lock. + if !companions.admits(None, true) { drop(companions); - self.names_refused.fetch_add(1, Ordering::Relaxed); - return Err(Status::Access); + self.reclaim_orphans(); + // The reclaim held no companion lock, so another CREATE of this + // name may have inserted it meanwhile and the main file may have + // changed: both are read again, and the name is inserted under the + // lock this call now holds without releasing it again. + main = self.main_of(parent, name); + companions = self.companions(); + let (held, route) = companions.resolve_route(&named, main); + if let Some(serial) = held { + trace::companion("CREATE", parent, name, main, route, held, opening(&how)); + return self.companion_open(serial, how, directory, companions, tickets); + } + } + if !companions.admits(None, true) { + let held = companions.slots.len(); + let limit = companions.held_limit; + let log = companions + .last_refusal_log + .is_none_or(|last| last.elapsed() >= Duration::from_secs(60)); + let namespace = log.then(|| companions.spill_dir.clone()); + if log { + companions.last_refusal_log = Some(Instant::now()); + } + trace::companion("CREATE", parent, name, main, Trace::None, None, "NoSpc"); + drop(companions); + let refused = self.names_refused.fetch_add(1, Ordering::Relaxed) + 1; + if let Some(namespace) = namespace { + eprintln!( + "layerfs-nfs: AppleDouble index full: export={:?} namespace={namespace:?} parent={parent} companions={held} limit={limit} names_refused={refused}; NFS3ERR_NOSPC", + self.mount() + ); + } + return Err(Status::NoSpc); } let mut metadata = now(); if let How::Unchecked(sattr) | How::Guarded(sattr) = how { @@ -180,34 +424,209 @@ impl Kernel { } let serial = SERIALS + companions.next; companions.next += 1; - let named = (parent, name.to_vec()); - companions.names.insert(named.clone(), serial); - companions.files.insert( - serial, - Companion { - named, - data: Vec::new(), - metadata, - }, + let used = companions.tick(); + let file = Companion { + named, + also: Vec::new(), + inode: main, + whole: false, + len: 0, + body: Body::Resident(Vec::new()), + metadata, + used, + editing: Arc::new(Mutex::new(())), + }; + let stat = Companions::stat(serial, &file); + trace::companion( + "CREATE", + parent, + name, + main, + Trace::None, + Some(serial), + "Ok", ); - let file = &companions.files[&serial]; - let stat = Companions::stat(serial, file); + companions.index(serial, &file); + companions.attach(serial, file); drop(companions); self.names_detached.fetch_add(1, Ordering::Relaxed); Ok((stat, directory)) } /// REMOVE of a companion name, with the directory's `wcc_data`; `None` /// when no companion has that name. + /// + /// A companion the export pairs with a main inode is the inode's, not one + /// name's: its FinderInfo and attributes belong to the file, so a client + /// that links the file (or removes one of its names) and drops the `._` + /// name it no longer uses leaves the companion to the inode's remaining + /// names. Only while this name is the companion's last one, and its inode + /// has no other name the export knows, is the REMOVE the client clearing + /// the attributes, which takes the companion with it. A companion no main + /// inode owns has nothing else to go with and always goes. pub(crate) fn companion_remove(&self, parent: u64, name: &[u8]) -> Option { - { + let named = (parent, name.to_vec()); + let main = self.main_of(parent, name); + let resolved = { + let companions = self.companions(); + let (serial, route) = companions.resolve_route(&named, main); + serial.and_then(|serial| { + let file = companions.files.get(&serial)?; + Some(( + serial, + route, + file.inode, + !companions.holds_another(serial, &named), + )) + }) + }; + let Some((serial, route, inode, one_name)) = resolved else { + if crate::names::apple_double(name) { + trace::companion("REMOVE", parent, name, main, Trace::None, None, "NoEnt"); + } + return None; + }; + let kept = !one_name || inode.is_some_and(|inode| self.knows_another_name(inode)); + trace::companion( + "REMOVE", + parent, + name, + main, + route, + Some(serial), + match kept { + true => "name-dropped", + false => "companion-dropped", + }, + ); + let spilled = { let mut companions = self.companions(); - let serial = companions.names.get(&(parent, name.to_vec())).copied()?; - companions.drop_serial(serial); - } + if kept { + companions.drop_name(serial, &named); + Vec::new() + } else { + companions.take_serial(serial).into_iter().collect() + } + }; + unlink_paths(spilled); Some(self.directory_wcc(parent)) } - /// RENAME of a companion name: only to another AppleDouble name, which - /// it replaces when held. `None` when no companion has that name. + /// Whether the export's name index knows a name of `inode` beyond the one + /// it remembers: a hard link the client made, which the companion of an + /// inode follows. + fn knows_another_name(&self, inode: u64) -> bool { + let table = self.table(); + let remembered = usize::from(table.names.contains_key(&inode)); + remembered + table.aliases.get(&inode).map_or(0, Vec::len) > 1 + } + /// The main file `name` in `parent` was removed, silly-renamed or replaced + /// by `RENAME`: drops the companion held under `._` when no main + /// inode owns it, and leaves an inode's companion to the inode - it goes + /// with the inode's last name instead (see + /// [`Kernel::companion_drop_inode`]), which is also where the `._` names it + /// held go (`Companions::unindex`). A plain non-replacing `RENAME` of a + /// main file only cleans the destination name `to/new_name` (via + /// `finish_unlink`) and leaves `from/name` alone so a client that renames + /// `a -> b` and then renames `._a -> ._b` can still move the companion + /// across. + /// + /// The `._` name stays after its main name for as long as the inode does, + /// because the inode's FinderInfo and attributes are the file's: `/rm a` + /// on a file `b` still names leaves `._a` answering the companion of the + /// inode, rather than reporting attributes that the file `b` still has as + /// gone. A new file under that name reaches the old companion nowhere: + /// [`Companions::resolve`] takes a name key only for the inode its + /// companion belongs to, so the answer falls back to that inode's + /// companion, which a new file does not have. + pub(crate) fn companion_drop_for(&self, parent: u64, name: &[u8]) { + if crate::names::apple_double(name) { + return; + } + let mut paired = Vec::with_capacity(2 + name.len()); + paired.extend_from_slice(b"._"); + paired.extend_from_slice(name); + let named = (parent, paired); + let spilled = { + let mut companions = self.companions(); + let Some(&serial) = companions.names.get(&named) else { + return; + }; + let of_inode = companions + .files + .get(&serial) + .is_some_and(|file| file.inode.is_some()); + trace::companion( + "UNPAIR", + parent, + name, + companions.files.get(&serial).and_then(|file| file.inode), + Trace::Name, + Some(serial), + match of_inode { + true => "name-kept", + false => "companion-dropped", + }, + ); + match of_inode { + true => None, + false => companions.take_serial(serial), + } + }; + unlink_paths(spilled); + } + /// Drops the companion of inode `main`, whose last name is gone. + pub(crate) fn companion_drop_inode(&self, main: u64) { + let spilled = { + let mut companions = self.companions(); + let Some(serial) = companions.inodes.get(&main).copied() else { + return; + }; + companions.take_serial(serial) + }; + unlink_paths(spilled); + } + /// LINK of a companion name: the same companion under another AppleDouble + /// name, as a client that links a file makes to carry its attributes to + /// the new name. The name it names must be free, and a name that is not + /// another companion name is refused, so a companion never becomes a file + /// of the Workspace. + pub(crate) fn companion_link( + &self, + serial: u64, + parent: u64, + name: &[u8], + ) -> Result<(ViewStat, Wcc), Status> { + if !crate::names::apple_double(name) || name.len() > 255 { + return Err(Status::Access); + } + if parent != self.root() && !self.table().parents.contains_key(&parent) { + return Err(Status::NotDir); + } + let named = (parent, name.to_vec()); + let directory = self.directory_wcc(parent); + let main = self.main_of(parent, name); + let mut companions = self.companions(); + if companions.names.contains_key(&named) + || companions + .resolve(&named, main) + .is_some_and(|other| other != serial) + { + trace::companion("LINK", parent, name, main, Trace::Name, None, "Exist"); + return Err(Status::Exist); + } + let Some(mut file) = companions.detach(serial) else { + return Err(Status::Stale); + }; + file.also.push(named); + file.used = companions.tick(); + let stat = Companions::stat(serial, &file); + trace::companion("LINK", parent, name, main, Trace::None, Some(serial), "Ok"); + companions.index(serial, &file); + companions.attach(serial, file); + Ok((stat, directory)) + } + /// RENAME of a companion name: only to another AppleDouble name, which it + /// replaces when held. It then belongs to the destination's main inode, or + /// to none when that is unknown. `None` when no companion has that name. pub(crate) fn companion_rename( &self, from: u64, @@ -215,116 +634,188 @@ impl Kernel { to: u64, new_name: &[u8], ) -> Option> { - let mut companions = self.companions(); - let serial = *companions.names.get(&(from, name.to_vec()))?; + let from_main = self.main_of(from, name); + let to_main = self.main_of(to, new_name); + let serial = { + let companions = self.companions(); + companions.resolve(&(from, name.to_vec()), from_main)? + }; if !crate::names::apple_double(new_name) || new_name.len() > 255 { return Some(Err(Status::Access)); } - let target = (to, new_name.to_vec()); - if let Some(replaced) = companions.names.get(&target).copied() { - if replaced != serial { - companions.drop_serial(replaced); - } - } - companions.names.remove(&(from, name.to_vec())); - companions.names.insert(target.clone(), serial); - if let Some(file) = companions.files.get_mut(&serial) { - file.named = target; - } - Some(Ok(())) - } - /// READ of a companion, at most `count` bytes from `offset`, appended to - /// `out`; `eof` when the reply reaches the companion's end. - pub(crate) fn companion_read( - &self, - serial: u64, - offset: u64, - count: u32, - out: &mut Vec, - ) -> Result { - let companions = self.companions(); - let file = companions.files.get(&serial).ok_or(Status::Stale)?; - let length = file.data.len() as u64; - let start = offset.min(length) as usize; - let end = offset.saturating_add(u64::from(count)).min(length) as usize; - out.extend_from_slice(&file.data[start..end]); - Ok(end as u64 >= length) + let source = (from, name.to_vec()); + let renamed = self.rename_companion(serial, &source, (to, new_name.to_vec()), to_main); + trace::companion( + "RENAME", + to, + new_name, + to_main, + Trace::None, + Some(serial), + match &renamed { + Ok(()) => "Ok", + Err(status) => trace::status(*status), + }, + ); + Some(renamed) } - /// WRITE to a companion: all of it or nothing. - pub(crate) fn companion_write( + /// Moves `serial`'s companion from its name `source` to `target`, under + /// `to_main`'s inode. Only `source` is replaced: its other names (a LINK + /// made them) stay, and a companion reached only through its inode keeps + /// every name it holds and gains `target`. + /// + /// The body is classified again under the destination, so a whole image + /// renamed onto an unknown main is the client's bytes again and takes a + /// slot: such a body no longer fits the resident budget as attributes, and + /// is written out first (outside the companion lock, with the companion's + /// edit gate held), so the rename itself only records a name and a class. + /// A companion that needs a new slot of the index bound takes the same + /// decision the edit path takes: the orphan slots are reclaimed once and + /// the rename is refused if the bound still has none. + fn rename_companion( &self, serial: u64, - offset: u64, - data: &[u8], - ) -> Result<(u32, Wcc), Status> { - let mut companions = self.companions(); - let end = offset.checked_add(data.len() as u64).ok_or(Status::FBig)?; - let before = { - let file = companions.files.get(&serial).ok_or(Status::Stale)?; - Companions::stat(serial, file) + source: &Named, + target: Named, + to_main: Option, + ) -> Result<(), Status> { + let gate = { + let companions = self.companions(); + companions + .files + .get(&serial) + .ok_or(Status::Stale)? + .editing + .clone() }; - if end > before.logical_len { - companions.resize(serial, end)?; - } - let file = companions.files.get_mut(&serial).ok_or(Status::Stale)?; - file.data[offset as usize..end as usize].copy_from_slice(data); - touch(&mut file.metadata); - let after = Companions::stat(serial, file); - Ok((data.len() as u32, (Some(before), Some(after)))) - } - /// SETATTR of a companion: mode, size and modification time; the - /// owner is the export's identity, as for every inode. - pub(crate) fn companion_setattr( - &self, - serial: u64, - sattr: Sattr, - guard: Option<(u32, u32)>, - _tickets: &mut Tickets, - ) -> Result<(ViewStat, Wcc), Status> { - let identity = self.identity(); - let foreign = sattr.uid.is_some_and(|uid| uid != identity.uid) - || sattr.gid.is_some_and(|gid| gid != identity.gid); - if foreign { - return Err(Status::Perm); - } - let mut companions = self.companions(); - let before = { + // Held to the end: the body written out below is the body renamed. + let _editing = gate.lock().unwrap_or_else(|poison| poison.into_inner()); + // A decoded body renamed onto an unknown main would cost its whole + // image of the resident budget: write it out instead, which costs none. + let leaves_memory = { + let companions = self.companions(); let file = companions.files.get(&serial).ok_or(Status::Stale)?; - Companions::stat(serial, file) + match &file.body { + Body::Decoded(image) if to_main.is_none() => { + let cost = image.len(); + companions + .resident_bytes + .saturating_sub(image.cost()) + .saturating_add(cost) + > companions.resident_budget + } + _ => false, + } }; - if let Some(expected) = guard { - if crate::attributes::ctime(&before) != expected { - return Err(Status::NotSync); + if leaves_memory { + self.spill_gated(serial, 0)?; + } + // A companion moved onto an unknown main takes a slot; one already + // holding a slot keeps it, and one that stays a whole image keeps its + // exemption. The slot is held from here, so the commit below cannot + // find another call took the last one while this rename waited. + if to_main.is_none() && self.companions().reserve(serial) == Slot::Full { + self.reclaim_orphans(); + if self.companions().reserve(serial) == Slot::Full { + return Err(Status::NoSpc); } } - if let Some(size) = sattr.size { - companions.resize(serial, size)?; + let mut replaced_path = None; + { + let mut companions = self.companions(); + let Some(mut file) = companions.detach(serial) else { + companions.unreserve(serial); + return Err(Status::Stale); + }; + companions.unindex(serial, &file); + if let Some(replaced) = companions.resolve(&target, to_main) { + if replaced != serial { + replaced_path = companions.take_serial(replaced); + } + } + if file.named == *source { + file.named = target.clone(); + } else if let Some(named) = file.also.iter_mut().find(|named| **named == *source) { + *named = target.clone(); + } else if file.named != target { + file.also.push(target.clone()); + } + file.also.retain(|named| *named != file.named); + file.also.dedup(); + file.inode = to_main; + file.used = companions.tick(); + // A client may write a companion under another name first, and a + // name it moves onto may belong to another main inode, or to + // none: the body is classified again under the destination, so + // one whose main file is unknown takes its slot and none keeps a + // whole image's exemption. + companions.classify(&mut file); + companions.index(serial, &file); + companions.attach(serial, file); + companions.unreserve(serial); } - let file = companions.files.get_mut(&serial).ok_or(Status::Stale)?; - if let Some(mode) = sattr.mode { - file.metadata.mode = mode & 0o777; + unlink_paths(replaced_path); + Ok(()) + } + /// Drops every companion and removes the export's spill directory; returns + /// what the index held. + pub(crate) fn companions_release(&self) -> Holding { + let (holding, dir) = { + let mut companions = self.companions(); + let holding = companions.holding(); + let dir = companions.spill_dir.take(); + drop(std::mem::take(&mut *companions)); + (holding, dir) + }; + if let Some(dir) = dir { + drop(fs::remove_dir_all(dir)); } - match sattr.mtime { - Some(Stamp::At(time)) => { - file.metadata.mtime_seconds = time.seconds; - file.metadata.mtime_nanoseconds = time.nanoseconds; - } - Some(Stamp::Processing) => touch(&mut file.metadata), - None if sattr.size.is_some() => touch(&mut file.metadata), - None => {} + if holding.held > 0 { + eprintln!( + "layerfs-nfs: AppleDouble companions released: export={:?} held={} slotted={} decoded={} resident_bytes={} unreachable={}", + self.mount(), + holding.held, + holding.slotted, + holding.decoded, + holding.resident_bytes, + holding.unreachable + ); } - let after = Companions::stat(serial, file); - Ok((after.clone(), (Some(before), Some(after)))) + holding } - /// Drops every companion; their count. - pub(crate) fn companions_release(&self) -> usize { - let mut companions = self.companions(); - let held = companions.len(); - *companions = Companions::default(); - held + /// What the companion index holds now. + pub(crate) fn companions_held(&self) -> Holding { + self.companions().holding() } - /// Companions held now. - pub(crate) fn companions_held(&self) -> usize { - self.companions().len() + /// Traces a request about a main file (`op`, its directory and name) when + /// the export holds a companion for that inode: these are the requests + /// that make a `._` name resolvable (see [`crate::trace`]). + pub(crate) fn trace_main_file( + &self, + op: &str, + parent: u64, + name: &[u8], + inode: u64, + status: &str, + ) { + if !trace::enabled() { + return; + } + let companion = self.companions().inodes.get(&inode).copied(); + if companion.is_some() { + trace::main_file(op, parent, name, Some(inode), companion, status); + } + } + /// Traces a name the export's kernel table bound to `inode` (`alias`: kept + /// as another name of it) or dropped from it (`unbound`), when the inode + /// has a companion: a `._` name resolves through those names. + pub(crate) fn trace_bind(&self, parent: u64, name: &[u8], inode: u64, status: &str) { + if !trace::enabled() { + return; + } + let companion = self.companions().inodes.get(&inode).copied(); + if companion.is_some() { + trace::main_file("BIND", parent, name, Some(inode), companion, status); + } } } diff --git a/engine/crates/layerfs-nfs/src/apple_double/edit.rs b/engine/crates/layerfs-nfs/src/apple_double/edit.rs new file mode 100644 index 0000000000..2d145fb248 --- /dev/null +++ b/engine/crates/layerfs-nfs/src/apple_double/edit.rs @@ -0,0 +1,506 @@ +//! Companion bodies: READ, WRITE and SETATTR, and the spill that moves a body +//! from memory to the export's scratch directory. +//! +//! One edit of a companion runs at a time, under that companion's own edit +//! gate (`Companion::editing` in the parent module): it applies to the resident +//! bytes under the +//! companion lock or to the spilled file outside it, and records the length +//! its own bytes leave, so a truncate and a write of the same companion can +//! never leave a length its file does not have and no round has to decide +//! again on a body another call changed under it. +//! +//! A body that does not fit the resident budget is spilled first, least +//! recently touched first; the body that still does not fit is written out +//! itself and edited in its file, which needs no budget. The file I/O never +//! holds the companion lock: the file is written from a body read under the +//! lock and renamed to the companion's own name outside it, before the body is +//! committed as spilled under the lock again. No descriptor is kept for a +//! spilled body: each operation opens its file by path and closes it again. +use super::{edited_len, record, Body, Companions, Decoded, Slot, DECODED_ENTRY_BYTES, FILE_BYTES}; +use crate::{ + apple_double_spill::{ + create_spilled, io_status, spill_path, touch, unlink_paths, Edit, Edited, Room, + }, + attributes::Status, + change::{Sattr, Tickets, Wcc}, + kernel::Kernel, +}; +use layerfs_mount_ports::operations::write::Stamp; +use layerfs_workspace::ViewStat; +use std::{ + collections::BTreeSet, + fs::{self, File, OpenOptions}, + io, + os::unix::fs::FileExt, + path::Path, +}; + +/// One `pread` of `buf` at `offset`: a short read is the answer, and a read a +/// signal interrupted is asked again, since no bytes of it moved. +fn read_window(file: &File, buf: &mut [u8], offset: u64) -> Result { + loop { + match file.read_at(buf, offset) { + Ok(read) => return Ok(read), + Err(e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(io_status(&e)), + } + } +} + +impl Kernel { + /// READ of a companion, at most `count` bytes from `offset`, appended to + /// `out`; `eof` when the reply reaches the companion's end. + pub(crate) fn companion_read( + &self, + serial: u64, + offset: u64, + count: u32, + out: &mut Vec, + ) -> Result { + let (spilled, length, start, end) = { + let mut companions = self.companions(); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + let length = file.len as u64; + let start = offset.min(length) as usize; + let end = offset.saturating_add(u64::from(count)).min(length) as usize; + let spilled = match &file.body { + Body::Resident(bytes) => { + // A body and its length are recorded under one lock; clamp + // anyway so no reply slices past the bytes it holds. + let stop = end.min(bytes.len()); + out.extend_from_slice(bytes.get(start..stop).unwrap_or_default()); + false + } + Body::Decoded(image) => { + // The image the client wrote, synthesized again over the + // window this reply asks for rather than in full. + let stop = end.min(image.len()); + out.extend_from_slice(&image.encode_range(start, stop)); + false + } + Body::Spilled => true, + }; + companions.use_serial(serial); + (spilled, length, start, end) + }; + if spilled { + // One `pread` of the window the last lock saw, outside it: another + // call may have truncated the file since, and the bytes the file + // still holds are the reply - a short read, not an I/O error. + let mut buf = vec![0u8; end - start]; + let read = read_window(&self.spill_file(serial, false)?, &mut buf, start as u64)?; + buf.truncate(read); + out.extend_from_slice(&buf); + } + Ok(end as u64 >= length) + } + /// WRITE to a companion: all of it or nothing. + pub(crate) fn companion_write( + &self, + serial: u64, + offset: u64, + data: &[u8], + ) -> Result<(u32, Wcc), Status> { + let end = offset.checked_add(data.len() as u64).ok_or(Status::FBig)?; + if end > FILE_BYTES { + return Err(Status::FBig); + } + let gate = self.edit_gate(serial)?; + // Held to the end: the reply's before is the body this edit changes. + let _editing = gate.lock().unwrap_or_else(|poison| poison.into_inner()); + let before = self.companion_stat(serial)?; + let offset = offset as usize; + let after = self.edit_gated(serial, Edit::Write { offset, data })?; + Ok((data.len() as u32, (Some(before), Some(after)))) + } + /// SETATTR of a companion: mode, size and modification time; the + /// owner is the export's identity, as for every inode. + pub(crate) fn companion_setattr( + &self, + serial: u64, + sattr: Sattr, + guard: Option<(u32, u32)>, + _tickets: &mut Tickets, + ) -> Result<(ViewStat, Wcc), Status> { + let identity = self.identity(); + if sattr.uid.is_some_and(|uid| uid != identity.uid) + || sattr.gid.is_some_and(|gid| gid != identity.gid) + { + return Err(Status::Perm); + } + // One SETATTR runs as one edit: the guard is checked against the body + // its size change then applies to, with no WRITE in between. + let gate = self.edit_gate(serial)?; + let _editing = gate.lock().unwrap_or_else(|poison| poison.into_inner()); + let before = { + let companions = self.companions(); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + let before = Companions::stat(serial, file); + if let Some(expected) = guard { + if crate::attributes::ctime(&before) != expected { + return Err(Status::NotSync); + } + } + before + }; + if let Some(size) = sattr.size { + if size > FILE_BYTES { + return Err(Status::FBig); + } + if crate::trace::enabled() { + crate::trace::handle("SETATTR", serial, &format!("size={size}")); + } + self.edit_gated(serial, Edit::Size(size as usize))?; + } + let mut companions = self.companions(); + if !companions.files.contains_key(&serial) { + return Err(Status::Stale); + } + companions.use_serial(serial); + let file = companions.files.get_mut(&serial).ok_or(Status::Stale)?; + if let Some(mode) = sattr.mode { + file.metadata.mode = mode & 0o777; + } + match sattr.mtime { + Some(Stamp::At(time)) => { + file.metadata.mtime_seconds = time.seconds; + file.metadata.mtime_nanoseconds = time.nanoseconds; + } + Some(Stamp::Processing) => touch(&mut file.metadata), + None if sattr.size.is_some() => touch(&mut file.metadata), + None => {} + } + let after = Companions::stat(serial, file); + Ok((after.clone(), (Some(before), Some(after)))) + } + /// `serial`'s edit gate: whoever holds it is the companion's one edit. + fn edit_gate(&self, serial: u64) -> Result>, Status> { + let companions = self.companions(); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + Ok(file.editing.clone()) + } + /// Applies `edit` to `serial` and answers its stat afterwards: in the + /// resident body while the budget holds it, else in its spilled file + /// outside the companion lock. The caller holds this companion's gate, so + /// the edit runs alone and the length recorded is the one its own bytes + /// leave. + fn edit_gated(&self, serial: u64, edit: Edit<'_>) -> Result { + match self.apply_edit(serial, &edit)? { + Edited::Done(stat) => Ok(stat), + Edited::NoSlot => { + // A body that takes a slot of the index bound has none: + // reclaim the companions no name reaches any more, once, + // outside the companion lock, and apply the same edit again. + // A bound that still has no room refuses the whole edit, with + // the body, its length and its name as they were. + if self.reclaim_orphans() == 0 { + return Err(Status::NoSpc); + } + match self.apply_edit(serial, &edit)? { + Edited::Done(stat) => Ok(stat), + Edited::NoSlot => Err(Status::NoSpc), + } + } + } + } + /// Applies `edit` to `serial` once: in the resident body while the budget + /// holds it, else in its spilled file. It answers that a slot of the index + /// bound is missing rather than changing anything, so the caller can make + /// room and try again. + fn apply_edit(&self, serial: u64, edit: &Edit<'_>) -> Result { + let target = edit.target_len(); + loop { + match self.edit_resident(serial, target, edit)? { + Room::Resident(stat) => return Ok(Edited::Done(stat)), + Room::NoSlot => return Ok(Edited::NoSlot), + Room::Spilled => break, + Room::Grow(need) => { + // No other call changes this body, so a round that finds + // room leaves the next edit in it. + if !self.spill_for(serial, need)? { + break; + } + } + } + } + // The body still does not fit resident memory: write it out and edit + // its file, which needs no body budget. A body edited on its file is no + // longer known to be a whole image, so it takes a slot of the index + // bound: decide that before the file is written, and leave the body, + // its file and its name as they were when the bound has none. The slot + // is held from the decision, not taken by the commit after the I/O, so + // another call cannot be told the same last slot is free. + if self.companions().reserve(serial) == Slot::Full { + return Ok(Edited::NoSlot); + } + // The body is written out at the length it has, and the edit grows + // its file itself: the companion's recorded length moves only once + // the edit's bytes are in the file, so no GETATTR or READ meanwhile + // sees a length whose bytes are not there, and a failed file + // operation leaves the length it had. + let written = self.spill_gated(serial, 0).and_then(|()| { + let file = self.spill_file(serial, true)?; + edit.disk(&file) + }); + if let Err(status) = written { + self.companions().unreserve(serial); + return Err(status); + } + self.record_edit(serial, edit).map(Edited::Done) + } + /// Applies `edit` to `serial`'s body in memory while the budget holds it + /// (a decoded body is encoded first), recording its length, recency and + /// time and deciding again whether it is a whole image, under the same + /// lock, so no other call ever sees a body and a length that disagree. + fn edit_resident(&self, serial: u64, target: usize, edit: &Edit<'_>) -> Result { + let mut companions = self.companions(); + let avail = companions + .resident_budget + .saturating_sub(companions.resident_bytes); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + let need = match &file.body { + Body::Spilled => return Ok(Room::Spilled), + Body::Resident(bytes) => target.saturating_sub(bytes.len()), + // The decoded form's own charge comes back when it becomes bytes. + Body::Decoded(image) => edited_len(edit, image.len()).saturating_sub(image.cost()), + }; + if need > avail { + // The body does not fit the resident budget, but the edit may + // complete a whole image, whose decoded form costs its attributes + // rather than its bytes. Only a body small enough to decode is + // tried. + if target > DECODED_ENTRY_BYTES + crate::apple_double_codec::IMAGE_UNIT { + return Ok(Room::Grow(need)); + } + let mut bytes = match &file.body { + Body::Resident(bytes) => bytes.clone(), + Body::Decoded(image) => image.encode(), + Body::Spilled => return Ok(Room::Spilled), + }; + let len = edited_len(edit, file.len); + edit.memory(&mut bytes); + match companions.keep_decoded(serial, &bytes, len) { + Decoded::Kept => { + let stat = companions + .files + .get(&serial) + .map(|file| Companions::stat(serial, file)); + if let Some(stat) = stat { + return Ok(Room::Resident(stat)); + } + } + // Make room for the decoded form rather than for the bytes the + // edit holds: one eviction usually takes it. + Decoded::Room(needed) => return Ok(Room::Grow(needed)), + Decoded::Unchanged => {} + } + return Ok(Room::Grow(need)); + } + let tick = companions.tick(); + let mut file = companions.detach(serial).ok_or(Status::Stale)?; + let mut bytes = match std::mem::replace(&mut file.body, Body::Spilled) { + Body::Resident(bytes) => bytes, + Body::Decoded(image) => image.encode(), + Body::Spilled => { + companions.attach(serial, file); + return Ok(Room::Spilled); + } + }; + // A companion holding no slot while the bound is full may take one with + // this edit, and only the edited body says whether it does: its bytes + // are kept when that is the case, so a refusal puts them back exactly. + let restore = (!file.slotted() && !companions.admits(Some(serial), true)) + .then(|| (bytes.clone(), file.whole, file.len)); + edit.memory(&mut bytes); + file.body = Body::Resident(bytes); + record(edit, &mut file); + companions.classify(&mut file); + if let Some((bytes, whole, len)) = restore { + if !companions.admits(Some(serial), file.slotted()) { + file.body = Body::Resident(bytes); + file.whole = whole; + file.len = len; + companions.attach(serial, file); + return Ok(Room::NoSlot); + } + } + touch(&mut file.metadata); + file.used = tick; + let stat = Companions::stat(serial, &file); + companions.attach(serial, file); + Ok(Room::Resident(stat)) + } + /// Records an edit applied to `serial`'s spilled file and answers its + /// stat. A body changed on disk is no longer known to be a whole image. + fn record_edit(&self, serial: u64, edit: &Edit<'_>) -> Result { + let mut companions = self.companions(); + let tick = companions.tick(); + // The slot held for this commit is given back whether or not the + // companion is still there to take it. + companions.unreserve(serial); + let mut file = companions.detach(serial).ok_or(Status::Stale)?; + record(edit, &mut file); + file.used = tick; + file.whole = false; + touch(&mut file.metadata); + let stat = Companions::stat(serial, &file); + companions.attach(serial, file); + Ok(stat) + } + /// Spills the least recently used bodies to disk (outside the companion + /// lock) until adding `need` bytes stays within `resident_budget`. Returns + /// `true` if `need` fits in resident memory afterwards. Each round takes + /// the oldest entry of the eviction order, so a round costs one step into + /// it rather than a walk of every companion, and the rounds end when no + /// companion holding memory is left: a victim another call changed + /// meanwhile has moved to the newest end of the order, so it is not picked + /// twice, and the caller then writes out its own body, which needs no + /// budget at all. + /// + /// A victim that cannot be written out is no failure of this call: one + /// another call removed has nothing left to give back, and one whose file + /// cannot be written keeps its body in memory, so the round passes over it + /// and looks at the body after it. Only a call that finds no room and then + /// cannot write out its own body reports that error, and it is its own. + fn spill_for(&self, target: u64, need: usize) -> Result { + let mut skip = BTreeSet::from([target]); + loop { + let victim = { + let companions = self.companions(); + if companions.resident_bytes + need <= companions.resident_budget { + return Ok(true); + } + // With nowhere to spill to, no victim can give memory back. + if companions.spill_dir.is_none() { + return Ok(false); + } + companions.oldest_resident(&skip) + }; + let Some(victim) = victim else { + return Ok(false); + }; + if self.spill_one(victim, None) != Ok(true) { + // The body changed under the file written from it, the + // companion's own edit holds it, or its file could not be + // written: this call does not pick it again, and the next + // round looks at the body after it. + skip.insert(victim); + } + } + } + /// Writes `serial`'s body out to the spill directory and switches it to + /// that file, keeping at least `keep` bytes (all of them when `None`), + /// with the disk I/O outside the companion lock. `Ok(false)` when another + /// call changed the companion, or already spilled it, while the file was + /// written, or when the companion's own edit holds it: that temporary file + /// is dropped and the caller decides again on the body it now finds. + fn spill_one(&self, serial: u64, keep: Option) -> Result { + let gate = { + let companions = self.companions(); + match companions.files.get(&serial) { + Some(file) => file.editing.clone(), + None => return Ok(true), + } + }; + // One writer of a companion's file at a time: an edit of this companion + // is writing to it, and a spill may not wait for another call's I/O. A + // gate poisoned by a panic is taken anyway, as every other holder of it + // does, so one panicked edit does not make its body undevictable. + let _editing = match gate.try_lock() { + Ok(editing) => editing, + Err(std::sync::TryLockError::Poisoned(poison)) => poison.into_inner(), + Err(std::sync::TryLockError::WouldBlock) => return Ok(false), + }; + let (dir, bytes, size, used) = { + let companions = self.companions(); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + let bytes = match &file.body { + Body::Resident(bytes) => bytes.clone(), + Body::Decoded(image) => image.encode(), + Body::Spilled => return Ok(true), + }; + let dir = companions.spill_dir.clone().ok_or(Status::NoSpc)?; + let size = keep.unwrap_or(0).max(bytes.len()); + (dir, bytes, size, file.used) + }; + let temp = create_spilled(&dir, serial, &bytes, size as u64)?; + let adopted = self.adopt_spilled(serial, Some(used), &temp, size); + if matches!(adopted, Ok(true)) { + return Ok(true); + } + unlink_paths([temp]); + adopted.map(|_| false) + } + /// Writes `serial`'s body out while its own edit runs alone, keeping + /// `size` bytes: no other edit can change the body, so the file written is + /// the body this edit then applies to. + pub(super) fn spill_gated(&self, serial: u64, size: usize) -> Result<(), Status> { + let (dir, bytes, size) = { + let companions = self.companions(); + let file = companions.files.get(&serial).ok_or(Status::Stale)?; + let bytes = match &file.body { + Body::Resident(bytes) => bytes.clone(), + Body::Decoded(image) => image.encode(), + Body::Spilled => return Ok(()), + }; + let dir = companions.spill_dir.clone().ok_or(Status::NoSpc)?; + let size = size.max(bytes.len()); + (dir, bytes, size) + }; + let temp = create_spilled(&dir, serial, &bytes, size as u64)?; + let adopted = self.adopt_spilled(serial, None, &temp, size); + if !matches!(adopted, Ok(true)) { + unlink_paths([temp]); + } + adopted.map(|_| ()) + } + /// Renames `temp`, holding `serial`'s body written out, onto the + /// companion's own spill file and switches the companion to it. The + /// rename runs outside the companion lock: a reader keeps reading the + /// body in memory until the rename is done and the body is committed + /// under the lock again, and the file is never visible half written. The + /// caller holds the companion's edit gate for the whole adoption, so no + /// other call writes this companion's file. + fn adopt_spilled( + &self, + serial: u64, + used: Option, + temp: &Path, + len: usize, + ) -> Result { + let path = match self.companions().spill_target(serial, used) { + Ok(Some(path)) => path, + Ok(None) => return Ok(false), + Err(status) => return Err(status), + }; + if let Err(e) = fs::rename(temp, &path) { + // The temporary file is the caller's to drop: nothing was adopted. + return Err(io_status(&e)); + } + let committed = self.companions().commit_spilled(serial, len); + if !committed { + // The companion is gone or already holds a file: the file just put + // in place is this call's to drop. + unlink_paths([path]); + } + Ok(committed) + } + /// The spill directory's file of `serial`, opened for one operation and + /// closed again when the returned descriptor drops: the export holds no + /// descriptor per spilled companion. A file or directory that is gone + /// means the companion itself is gone. + fn spill_file(&self, serial: u64, write: bool) -> Result { + let dir = { + let companions = self.companions(); + companions.spill_dir.clone().ok_or(Status::Stale)? + }; + OpenOptions::new() + .read(true) + .write(write) + .open(spill_path(&dir, serial)) + .map_err(|e| match e.kind() { + io::ErrorKind::NotFound => Status::Stale, + _ => io_status(&e), + }) + } +} diff --git a/engine/crates/layerfs-nfs/src/apple_double/index.rs b/engine/crates/layerfs-nfs/src/apple_double/index.rs new file mode 100644 index 0000000000..3ca6861fda --- /dev/null +++ b/engine/crates/layerfs-nfs/src/apple_double/index.rs @@ -0,0 +1,366 @@ +//! The companion index of one export: its names, main inodes, slots of the +//! index bound, resident budget and eviction order. +use super::{ + Body, Companion, Companions, Decoded, Holding, Named, Orphan, Slot, DECODED_ENTRY_BYTES, +}; +use crate::{ + apple_double_codec::Image, + apple_double_spill::{spill_path, touch}, + attributes::Status, + trace::Route as Trace, +}; +use layerfs_content::object::inode_leaf::InodeKind; +use layerfs_workspace::ViewStat; +use std::{collections::BTreeSet, path::PathBuf}; + +impl Companions { + pub(super) fn tick(&mut self) -> u64 { + self.tick += 1; + self.tick + } + /// Marks `serial` as used now, which is the order eviction follows. Only a + /// companion holding memory is in the order: a spilled body has nothing to + /// give back. + pub(super) fn use_serial(&mut self, serial: u64) { + let tick = self.tick(); + self.set_used(serial, tick); + } + /// Moves `serial`'s index entry to `used`. + pub(super) fn set_used(&mut self, serial: u64, used: u64) { + let Some(file) = self.files.get_mut(&serial) else { + return; + }; + let old = std::mem::replace(&mut file.used, used); + self.by_use.remove(&(old, serial)); + if file.resident_cost() > 0 { + self.by_use.insert((used, serial)); + } + } + pub(super) fn stat(serial: u64, file: &Companion) -> ViewStat { + ViewStat { + serial, + kind: InodeKind::RegularFile, + metadata: file.metadata, + namespace_refs: 1, + logical_len: file.len as u64, + subdirs: 0, + } + } + /// Adds `file` to the index, the slot and byte counts and the eviction + /// order. + pub(super) fn attach(&mut self, serial: u64, file: Companion) { + if file.slotted() { + self.slots.insert(serial); + } + if file.resident_cost() > 0 { + self.by_use.insert((file.used, serial)); + } + self.resident_bytes += file.resident_cost(); + self.decoded += usize::from(matches!(file.body, Body::Decoded(_))); + self.files.insert(serial, file); + } + /// Takes `serial` out of the index and the counts; its name keys stay for + /// the caller to unindex. + pub(super) fn detach(&mut self, serial: u64) -> Option { + let file = self.files.remove(&serial)?; + self.slots.remove(&serial); + self.by_use.remove(&(file.used, serial)); + self.resident_bytes -= file.resident_cost(); + self.decoded -= usize::from(matches!(file.body, Body::Decoded(_))); + Some(file) + } + /// Makes every name of `file` and its main inode find `serial`. + pub(super) fn index(&mut self, serial: u64, file: &Companion) { + self.names.insert(file.named.clone(), serial); + for named in &file.also { + self.names.insert(named.clone(), serial); + } + if let Some(inode) = file.inode { + self.inodes.insert(inode, serial); + } + } + /// Drops every name of `file` and its inode key that still find `serial`. + pub(super) fn unindex(&mut self, serial: u64, file: &Companion) { + for named in std::iter::once(&file.named).chain(&file.also) { + if self.names.get(named) == Some(&serial) { + self.names.remove(named); + } + } + if let Some(inode) = file.inode { + if self.inodes.get(&inode) == Some(&serial) { + self.inodes.remove(&inode); + } + } + } + /// Whether `serial` holds a name other than `named`. + pub(super) fn holds_another(&self, serial: u64, named: &Named) -> bool { + self.files.get(&serial).is_some_and(|file| { + (file.named != *named && self.names.get(&file.named) == Some(&serial)) + || file.also.iter().any(|also| also != named) + }) + } + /// Drops `named`, one of `serial`'s names, and answers whether it held it. + /// A companion left with no name is still reached through its main inode, + /// so it keeps its record; another held name becomes the one its record + /// names, so a later `index` puts back only names it still holds. + pub(super) fn drop_name(&mut self, serial: u64, named: &Named) -> bool { + let Some(file) = self.files.get_mut(&serial) else { + return false; + }; + let primary = file.named == *named; + if !primary && !file.also.iter().any(|also| also == named) { + return false; + } + if self.names.get(named) == Some(&serial) { + self.names.remove(named); + } + if primary { + if let Some(next) = file.also.pop() { + file.named = next; + } + } else { + file.also.retain(|also| also != named); + } + true + } + /// The companion `named` reaches when its main file is `main`: the one + /// held under that name, unless it belongs to another inode than `main`, + /// else the one its main inode already has. + pub(super) fn resolve(&self, named: &Named, main: Option) -> Option { + self.resolve_route(named, main).0 + } + /// [`Self::resolve`], and which part of the index answered, for the trace. + pub(super) fn resolve_route(&self, named: &Named, main: Option) -> (Option, Trace) { + if let Some(&serial) = self.names.get(named) { + let inode = self.files.get(&serial).and_then(|file| file.inode); + if inode.is_none() || main.is_none() || inode == main { + return (Some(serial), Trace::Name); + } + } + match main.and_then(|main| self.inodes.get(&main).copied()) { + Some(serial) => (Some(serial), Trace::Inode), + None => (None, Trace::None), + } + } + /// Replaces `serial`'s body by the decoded form of `bytes`, the caller's + /// edited body of `len` bytes, while the resident budget takes it and the + /// export knows the companion's main inode. The decoded form is counted as + /// its attributes rather than its image, so a body that decodes usually + /// needs much less room than its bytes, and the caller is told the room it + /// would need instead of spilling a body that fits after one eviction. + pub(super) fn keep_decoded(&mut self, serial: u64, bytes: &[u8], len: usize) -> Decoded { + // Only an inode's companion is decoded: one whose main file the export + // never saw keeps the client's bytes as written and a slot of the + // index bound, so that bound and orphan reclamation still reach it. + let Some(file) = self.files.get(&serial) else { + return Decoded::Unchanged; + }; + let (inode, before) = (file.inode, file.resident_cost()); + if inode.is_none() { + return Decoded::Unchanged; + } + let Some(image) = Image::compact(bytes) else { + return Decoded::Unchanged; + }; + if !worth_decoding(&image, bytes.len()) { + return Decoded::Unchanged; + } + let cost = image.cost(); + let tick = self.tick(); + let Some(mut file) = self.detach(serial) else { + return Decoded::Unchanged; + }; + if self.resident_bytes + cost > self.resident_budget { + self.attach(serial, file); + // The body decodes, so the room to ask for is what the decoded + // form adds to the count, not the length of the bytes edited. + return Decoded::Room(cost.saturating_sub(before)); + } + file.len = len; + file.body = Body::Decoded(image); + file.whole = true; + file.used = tick; + touch(&mut file.metadata); + self.attach(serial, file); + Decoded::Kept + } + /// Decides whether `file`'s body is a whole image: a decoded body of an + /// inode's companion always is; a resident body of one is decoded when it + /// parses back to the same bytes and [`DECODED_ENTRY_BYTES`] takes it. A + /// companion whose main file the export does not know is never a whole + /// image: it keeps the client's bytes as written and a slot of the index + /// bound, so that bound and orphan reclamation still reach it. `file` must + /// be detached from the index. + pub(super) fn classify(&self, file: &mut Companion) { + if file.inode.is_none() { + // Only a decoded body has to become bytes again; a body on disk + // keeps its file and takes a slot. + if let Body::Decoded(image) = &file.body { + file.body = Body::Resident(image.encode()); + } + file.whole = false; + return; + } + // A body on disk cannot be decoded here (that reads its file under + // this lock): it keeps the class the write that spilled it left it. + file.whole = match &file.body { + Body::Decoded(_) => true, + Body::Spilled => file.whole, + Body::Resident(_) => false, + }; + let Body::Resident(bytes) = &file.body else { + return; + }; + let Some(image) = Image::compact(bytes) else { + return; + }; + file.whole = true; + if worth_decoding(&image, bytes.len()) { + file.body = Body::Decoded(image); + } + } + pub(super) fn take_serial(&mut self, serial: u64) -> Option { + self.reserved.remove(&serial); + let file = self.detach(serial)?; + self.unindex(serial, &file); + match file.body { + Body::Resident(_) | Body::Decoded(_) => None, + Body::Spilled => (self.spill_dir.as_ref()).map(|dir| spill_path(dir, serial)), + } + } + /// Where a body a spill wrote out replaces its companion: the companion's + /// own file, or `None` when another call changed the body since the + /// snapshot (`used` is the tick read then, and only a body still in memory + /// can be replaced). The caller renames its file to that path itself, + /// outside this lock, and then commits the body with + /// [`Self::commit_spilled`]. + pub(super) fn spill_target( + &self, + serial: u64, + used: Option, + ) -> Result, Status> { + let file = self.files.get(&serial).ok_or(Status::Stale)?; + // A body already on disk is never replaced: its file is the body. + if matches!(file.body, Body::Spilled) || used.is_some_and(|used| used != file.used) { + return Ok(None); + } + let dir = self.spill_dir.as_ref().ok_or(Status::NoSpc)?; + Ok(Some(spill_path(dir, serial))) + } + /// Commits the body whose bytes now sit at the companion's spill file: it + /// holds them on disk from now on, `len` bytes of them, which were the + /// whole body the file was written from. `false` when the companion is gone + /// or already holds a file, and the file just renamed into place is the + /// caller's to drop. + /// + /// The caller holds the companion's edit gate and no other call writes this + /// companion's file, so a body that changed between the snapshot and here + /// cannot be the body this file was written from. + pub(super) fn commit_spilled(&mut self, serial: u64, len: usize) -> bool { + let Some(mut file) = self.detach(serial) else { + return false; + }; + if matches!(file.body, Body::Spilled) { + self.attach(serial, file); + return false; + } + file.body = Body::Spilled; + // A body written out whole is still a whole image; a shorter file + // than the companion had described is not. + file.whole &= len <= file.len; + file.len = file.len.max(len); + self.attach(serial, file); + true + } + /// The least recently used companion holding memory, a body kept as + /// written or a decoded one: the budget counts both, so both are evicted. + /// The companions the caller will not take are passed over, one step into + /// the eviction order rather than a walk of every companion. + pub(super) fn oldest_resident(&self, skip: &BTreeSet) -> Option { + self.by_use + .iter() + .find(|(_, serial)| !skip.contains(serial)) + .map(|(_, serial)| *serial) + } + /// Whether the index takes a companion that takes a slot of the bound: the + /// one place the bound is decided. A companion already holding a slot + /// keeps it, and a body that takes no slot is always admitted. + pub(super) fn admits(&self, serial: Option, slotted: bool) -> bool { + !slotted + || serial.is_some_and(|serial| { + self.slots.contains(&serial) || self.reserved.contains(&serial) + }) + || self.slots.len() + self.reserved.len() < self.held_limit + } + /// Decides whether `serial` may take a slot of the bound and holds it when + /// it may, in one step under this lock: a call that needs I/O before its + /// commit keeps the slot for the commit, so two calls cannot both be told + /// the bound has room for one. [`Slot::Held`] means it already has one + /// (or a reservation) and nothing was taken. + pub(super) fn reserve(&mut self, serial: u64) -> Slot { + // A companion another call removed takes nothing: its commit finds it + // gone, and a reservation left for it would shrink the bound for good. + if self.slots.contains(&serial) + || self.reserved.contains(&serial) + || !self.files.contains_key(&serial) + { + return Slot::Held; + } + if self.slots.len() + self.reserved.len() >= self.held_limit { + return Slot::Full; + } + self.reserved.insert(serial); + Slot::Taken + } + /// Gives back a slot reserved for a commit that did not land. + pub(super) fn unreserve(&mut self, serial: u64) { + self.reserved.remove(&serial); + } + /// The companions no name of the export reaches: neither the name it + /// records nor another name of its inode finds it. Such a companion holds + /// its body with no way for a client to ask for it, which is one of the two + /// shapes a lost attribute takes (the other is no companion at all). A + /// companion reached only through its main inode - one whose `._` name the + /// client removed, or whose main file went under that name - is reachable, + /// which is why a name key kept for an inode's companion is not a leak. + /// Counted with the other holdings, by who reports them: the release line + /// says which shape a loss had, and a status read says so while serving. + pub(super) fn unreachable(&self) -> usize { + self.files + .iter() + .filter(|(serial, file)| { + self.names.get(&file.named) != Some(serial) + && !file + .also + .iter() + .any(|also| self.names.get(also) == Some(serial)) + && file + .inode + .is_none_or(|inode| self.inodes.get(&inode) != Some(serial)) + }) + .count() + } + /// Whether `orphan` is still the slot reclamation found: the same main + /// inode, still taking a slot, and not used by any call since. + pub(super) fn unchanged(&self, orphan: &Orphan) -> bool { + self.files.get(&orphan.serial).is_some_and(|file| { + file.inode == orphan.inode && file.slotted() && file.used == orphan.used + }) + } + pub(super) fn holding(&self) -> Holding { + Holding { + held: self.files.len(), + slotted: self.slots.len(), + resident_bytes: self.resident_bytes, + decoded: self.decoded, + unreachable: self.unreachable(), + } + } +} +/// Whether a whole image of `len` bytes is kept decoded: only when its decoded +/// form costs less than the bytes it replaces, and at most +/// [`DECODED_ENTRY_BYTES`]. Many small attributes cost more decoded than as +/// written, and such an image is kept as the client wrote it. +fn worth_decoding(image: &Image, len: usize) -> bool { + image.cost() <= DECODED_ENTRY_BYTES && image.cost() < len +} diff --git a/engine/crates/layerfs-nfs/src/apple_double/reclaim.rs b/engine/crates/layerfs-nfs/src/apple_double/reclaim.rs new file mode 100644 index 0000000000..bae04d79aa --- /dev/null +++ b/engine/crates/layerfs-nfs/src/apple_double/reclaim.rs @@ -0,0 +1,143 @@ +//! Reclamation of the companion slots no name reaches, at the index bound. +use super::Orphan; +use crate::{apple_double_spill::unlink_paths, attributes::Status, kernel::Kernel}; +use layerfs_content::filesystem::PathName; +use layerfs_workspace::KernelReadOperation; + +impl Kernel { + /// The companion slots no name reaches any more: one whose main inode + /// holds no name in the kernel table, and one whose main file the export + /// never observed and whose name its name index does not hold. Taken under + /// the kernel table lock and, inside it, the companion lock, so nothing + /// here copies the namespace; the caller drops them by serial under the + /// companion lock again. + pub(super) fn orphans(&self) -> Vec { + let table = self.table(); + let companions = self.companions(); + companions + .slots + .iter() + .filter_map(|serial| { + let file = companions.files.get(serial)?; + if let Some(inode) = file.inode { + let live = + table.names.contains_key(&inode) || table.aliases.contains_key(&inode); + return (!live).then_some(Orphan { + serial: *serial, + inode: Some(inode), + main: None, + used: file.used, + }); + } + // A name the index does hold reaches the companion; one it + // does not hold only makes it a candidate, since that index is + // lossy. Any of the names it holds reaches it, so one whose + // main file the export knows keeps it, and the first name whose + // main it does not know is the one the lookup asks about. + let mut candidate = None; + for named in std::iter::once(&file.named).chain(&file.also) { + let Some(main) = named.1.strip_prefix(b"._") else { + continue; + }; + let main = (named.0, main.to_vec()); + if table.by_name.contains_key(&main) { + return None; + } + candidate.get_or_insert(main); + } + candidate.map(|main| Orphan { + serial: *serial, + inode: None, + main: Some(main), + used: file.used, + }) + }) + .collect() + } + /// Drops the companion slots no name reaches any more and answers how many + /// it dropped. Takes the kernel table lock and, inside it, the companion + /// lock; the files it retires are unlinked afterwards, outside both. Never + /// call it under the companion lock. + /// + /// A companion whose main inode the export does not know is not dropped on + /// the name index's word: that index is lossy (its own bound, a name the + /// export never looked up, a rename on the client side), so each one costs + /// one read-only lookup of its main file in the engine, run outside both + /// locks. A main file that is there binds the companion back to its inode, + /// which keeps its attributes; only a lookup that answers "no such file", + /// or whose parent directory the engine no longer has (so the file cannot + /// be there either), makes it an orphan, and one that cannot answer leaves + /// it as it is. + /// + /// A lookup that finds the main file took one engine reference on it, and + /// the export keeps exactly one per serial: the visit is the entry's, so it + /// is registered as `Kernel::lookup` registers one (`entry_taken` remembers + /// the name and forgets a second reference). Without that the name reaches + /// the companion nowhere, and the next reclamation would read the bound one + /// as an inode holding no name and drop it. + pub(super) fn reclaim_orphans(&self) -> usize { + let (bound, dead) = self.orphans().into_iter().fold( + (Vec::new(), Vec::new()), + |(mut bound, mut dead), orphan| { + let Some((parent, main)) = orphan.main.clone() else { + dead.push(orphan); + return (bound, dead); + }; + // A name the engine cannot take, or a lookup it cannot answer, + // leaves the companion as it is. The engine answers a lookup in + // a directory whose reference the export collected as well. + let Ok(name) = PathName::from_bytes(&main) else { + return (bound, dead); + }; + let lookup = KernelReadOperation::Lookup { parent, name }; + match self.observe(parent, None, lookup) { + Ok(answer) => { + self.entry_taken(&answer.stat, parent, &main); + bound.push((orphan, answer.stat.serial)); + } + // A directory that no longer holds the main file, or that + // is gone itself, makes the companion an orphan. + Err(refused) + if matches!( + refused.status, + Status::NoEnt | Status::Stale | Status::NotDir + ) => + { + dead.push(orphan) + } + Err(_) => {} + } + (bound, dead) + }, + ); + let (reclaimed, spilled) = { + let mut companions = self.companions(); + let mut spilled = Vec::new(); + let mut reclaimed = 0; + for (orphan, main) in bound { + // Bound back to the inode the engine found, unless a call used + // it meanwhile or that inode already has its companion: it + // keeps the slot it took and follows that inode's names. + if !companions.unchanged(&orphan) || companions.inodes.contains_key(&main) { + continue; + } + if let Some(mut file) = companions.detach(orphan.serial) { + file.inode = Some(main); + companions.index(orphan.serial, &file); + companions.attach(orphan.serial, file); + } + } + // A call that used a companion after the decision (a READ, a + // WRITE, a LINK or RENAME of one of its names) keeps it. + for orphan in dead { + if companions.unchanged(&orphan) { + reclaimed += 1; + spilled.extend(companions.take_serial(orphan.serial)); + } + } + (reclaimed, spilled) + }; + unlink_paths(spilled); + reclaimed + } +} diff --git a/engine/crates/layerfs-nfs/src/apple_double_codec.rs b/engine/crates/layerfs-nfs/src/apple_double_codec.rs new file mode 100644 index 0000000000..033e4dde6b --- /dev/null +++ b/engine/crates/layerfs-nfs/src/apple_double_codec.rs @@ -0,0 +1,384 @@ +//! The AppleDouble image a macOS NFSv3 client writes as `._`, and its +//! decoded form. +//! +//! The client lays an image out as an AppleDouble v2 header with two entries: +//! the FinderInfo, whose entry runs on into an `ATTR` table of extended +//! attributes (each name with its NUL, padded to four bytes, in entry order; +//! the values packed in the same order), and a resource fork at the end of +//! the image. The image length is a whole number of [`IMAGE_UNIT`] bytes, and +//! the bytes the layout leaves unused are zero. +//! +//! [`Image::parse`] reads those fields. [`Image::compact`] additionally +//! requires that [`Image::encode`] gives back the very same bytes, so a +//! companion held as an [`Image`] encodes again to exactly the image its +//! client wrote: no attribute, value or byte the layout carries is dropped. +//! Each attribute entry keeps the alignment padding the client left after its +//! name, because the client does not clear the bytes a shorter name replaced. +//! [`Image::encode_range`] gives back any window of the image, so a READ serves +//! the bytes it asked for without laying out the whole image first. +//! +//! Anything else - a resource fork with data, still another layout, a +//! half-written image - yields `None` and is stored as the client wrote it. + +use std::fmt; + +const MAGIC: u32 = 0x0005_1607; +const VERSION: u32 = 0x0002_0000; +const FILLER: &[u8; 16] = b"Mac OS X "; +const FINDER_TAG: u32 = 9; +const FORK_TAG: u32 = 2; +/// Bytes of FinderInfo. +pub const FINDER_INFO: usize = 32; +/// The FinderInfo's offset: after the header, the entry count and two entries. +const FINDER_AT: usize = 50; +/// The `ATTR` header: the FinderInfo and two bytes of padding follow the +/// header of the image. +const ATTR_AT: usize = FINDER_AT + FINDER_INFO + 2; +const ATTR_MAGIC: u32 = 0x4154_5452; +/// The first attribute entry, after the 36-byte `ATTR` header. +const ENTRIES_AT: usize = ATTR_AT + 36; +/// An attribute entry before its name: value offset, value length, flags, +/// name length in bytes including the NUL. +const ENTRY_FIXED: usize = 11; +/// The step an image grows by. +pub const IMAGE_UNIT: usize = 4096; +/// The empty resource fork the client writes at the end of an image. +const BLANK_FORK: usize = 286; +const BLANK_FORK_TAG: &[u8] = b"This resource fork intentionally left blank "; +/// Index bytes counted for one decoded image, besides its names and values. +const IMAGE_OVERHEAD: usize = 96; +/// Index bytes counted for one decoded attribute, besides its name and value. +const ATTR_OVERHEAD: usize = 56; + +/// One extended attribute of a decoded image. +#[derive(Clone, Eq, PartialEq)] +pub struct Attribute { + pub name: Vec, + pub value: Vec, + /// The bytes the client left between the name's NUL and the next entry. + pad: [u8; 3], +} +impl Attribute { + /// An attribute the client would write with a cleared pad. + pub fn new(name: &[u8], value: &[u8]) -> Self { + Self { + name: name.to_vec(), + value: value.to_vec(), + pad: [0; 3], + } + } +} +impl fmt::Debug for Attribute { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .debug_struct("Attribute") + .field("name", &String::from_utf8_lossy(&self.name)) + .field("bytes", &self.value.len()) + .field("pad", &self.pad) + .finish() + } +} + +/// The resource-fork entry of an image that has no resource-fork data. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Fork { + /// A zero-length entry at the end of the image. + None, + /// The client's own empty resource fork, [`BLANK_FORK`] bytes. + Blank, +} +impl Fork { + fn len(self) -> usize { + match self { + Fork::None => 0, + Fork::Blank => BLANK_FORK, + } + } +} + +/// A decoded image: its FinderInfo, tag, extended attributes in entry order +/// and resource-fork entry, at its image length. +#[derive(Clone, Eq, PartialEq)] +pub struct Image { + finder: [u8; FINDER_INFO], + tag: u32, + attrs: Vec, + fork: Fork, + len: usize, +} +impl fmt::Debug for Image { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .debug_struct("Image") + .field("tag", &self.tag) + .field("attrs", &self.attrs) + .field("fork", &self.fork) + .field("len", &self.len) + .finish() + } +} +impl Image { + /// The image a client would write for these attributes from scratch: the + /// smallest whole number of [`IMAGE_UNIT`] bytes with its empty resource + /// fork, and cleared padding. `None` for an empty name, a name holding a + /// NUL, a name an entry cannot describe, or more attributes than an entry + /// count can say. + pub fn new(finder: [u8; FINDER_INFO], tag: u32, attrs: Vec) -> Option { + let named = |name: &Vec| !name.is_empty() && name.len() < 255 && !name.contains(&0); + if attrs.len() > usize::from(u16::MAX) || !attrs.iter().all(|attr| named(&attr.name)) { + return None; + } + let mut image = Self { + finder, + tag, + attrs, + fork: Fork::Blank, + len: 0, + }; + let used = image.data_start() + image.data_len() + BLANK_FORK; + image.len = used.div_ceil(IMAGE_UNIT) * IMAGE_UNIT; + u32::try_from(image.len).ok()?; + Some(image) + } + /// Its FinderInfo. + pub fn finder_info(&self) -> [u8; FINDER_INFO] { + self.finder + } + /// Its attributes. + pub fn attributes(&self) -> &[Attribute] { + &self.attrs + } + /// Its resource-fork entry. + pub fn fork(&self) -> Fork { + self.fork + } + /// The image length the client wrote, in bytes. + pub fn len(&self) -> usize { + self.len + } + /// Whether no image has an empty length; here for `len`'s sake only. + pub fn is_empty(&self) -> bool { + self.len == 0 + } + /// Index bytes this decoded form is counted for. + pub fn cost(&self) -> usize { + IMAGE_OVERHEAD + + self + .attrs + .iter() + .map(|attr| attr.name.len() + attr.value.len() + ATTR_OVERHEAD) + .sum::() + } + fn entry_end(&self, at: usize) -> usize { + ENTRIES_AT + + self + .attrs + .iter() + .take(at) + .map(|attr| entry_len(attr.name.len() + 1)) + .sum::() + } + fn data_start(&self) -> usize { + self.entry_end(self.attrs.len()) + } + fn data_len(&self) -> usize { + self.attrs.iter().map(|attr| attr.value.len()).sum() + } + /// The image these fields describe, as the client lays one out. + pub fn encode(&self) -> Vec { + self.encode_range(0, self.len) + } + /// The bytes of the encoded image in `[start, end)`, both clamped to its + /// length: a READ of one window pays for that window, not for the whole + /// image, and gives back the same bytes [`Self::encode`] would. + pub fn encode_range(&self, start: usize, end: usize) -> Vec { + let start = start.min(self.len); + let end = end.max(start).min(self.len); + let mut out = vec![0u8; end - start]; + let fork_at = self.len - self.fork.len(); + let data_start = self.data_start(); + // The fixed part of the image, whose offsets are absolute and known + // without walking the entries. + let mut head = [0u8; ENTRIES_AT]; + put32(&mut head, 0, MAGIC); + put32(&mut head, 4, VERSION); + head[8..24].copy_from_slice(FILLER); + put16(&mut head, 24, 2); + put32(&mut head, 26, FINDER_TAG); + put32(&mut head, 30, FINDER_AT as u32); + put32(&mut head, 34, (fork_at - FINDER_AT) as u32); + put32(&mut head, 38, FORK_TAG); + put32(&mut head, 42, fork_at as u32); + put32(&mut head, 46, self.fork.len() as u32); + head[FINDER_AT..FINDER_AT + FINDER_INFO].copy_from_slice(&self.finder); + put32(&mut head, ATTR_AT, ATTR_MAGIC); + put32(&mut head, ATTR_AT + 4, self.tag); + put32(&mut head, ATTR_AT + 8, fork_at as u32); + put32(&mut head, ATTR_AT + 12, data_start as u32); + put32(&mut head, ATTR_AT + 16, self.data_len() as u32); + put16(&mut head, ATTR_AT + 34, self.attrs.len() as u16); + emit(&mut out, start, 0, &head); + let (mut entry, mut value_at) = (ENTRIES_AT, data_start); + for attr in &self.attrs { + // Entries and values only grow, and the fork sits past both: once + // neither of this one's is in the window, no later one is either. + if entry >= end && value_at >= end { + break; + } + let name_len = attr.name.len() + 1; + emit(&mut out, start, entry, &(value_at as u32).to_be_bytes()); + emit( + &mut out, + start, + entry + 4, + &(attr.value.len() as u32).to_be_bytes(), + ); + emit(&mut out, start, entry + 10, &[name_len as u8]); + let name_at = entry + ENTRY_FIXED; + let name_end = name_at + attr.name.len(); + emit(&mut out, start, name_at, &attr.name); + let next = entry + entry_len(name_len); + emit( + &mut out, + start, + name_end + 1, + &attr.pad[..next - name_end - 1], + ); + emit(&mut out, start, value_at, &attr.value); + entry = next; + value_at += attr.value.len(); + } + if self.fork == Fork::Blank { + emit(&mut out, start, fork_at, &blank_fork()); + } + out + } + /// The fields of `image`, laid out as the client writes one; [`Self::compact`] + /// also requires that they encode back to the same bytes. + pub fn parse(image: &[u8]) -> Option { + let len = image.len(); + u32::try_from(len).ok()?; + if len < ENTRIES_AT + || get32(image, 0)? != MAGIC + || get32(image, 4)? != VERSION + || image[8..24] != FILLER[..] + || get16(image, 24)? != 2 + || get32(image, 26)? != FINDER_TAG + || get32(image, 30)? as usize != FINDER_AT + || get32(image, 38)? != FORK_TAG + { + return None; + } + let fork = match get32(image, 46)? as usize { + 0 => Fork::None, + BLANK_FORK => Fork::Blank, + _ => return None, + }; + let fork_at = get32(image, 42)? as usize; + if fork_at.checked_add(fork.len())? != len + || fork_at < ENTRIES_AT + || get32(image, 34)? as usize != fork_at - FINDER_AT + || get32(image, ATTR_AT)? != ATTR_MAGIC + || get32(image, ATTR_AT + 8)? as usize != fork_at + { + return None; + } + let tag = get32(image, ATTR_AT + 4)?; + let data_start = get32(image, ATTR_AT + 12)? as usize; + let data_len = get32(image, ATTR_AT + 16)? as usize; + let count = get16(image, ATTR_AT + 34)?; + let (mut entry, mut value_at) = (ENTRIES_AT, data_start); + // Each entry takes more than its fixed part, so the image bounds the + // count a client may claim before any entry is read. + let fits = (len - ENTRIES_AT) / (ENTRY_FIXED + 1); + let mut attrs = Vec::with_capacity(usize::from(count).min(fits)); + for _ in 0..count { + let value_len = get32(image, entry + 4)? as usize; + let name_len = usize::from(*image.get(entry + 10)?); + let name_at = entry + ENTRY_FIXED; + let name_end = entry + ENTRY_FIXED + name_len; + let name = image.get(name_at..name_end)?; + let (last, name) = name.split_last()?; + if get32(image, entry)? as usize != value_at || *last != 0 || name.is_empty() { + return None; + } + let value = image.get(value_at..value_at.checked_add(value_len)?)?; + let next = entry + entry_len(name_len); + let mut pad = [0u8; 3]; + pad[..next - name_end].copy_from_slice(image.get(name_end..next)?); + attrs.push(Attribute { + name: name.to_vec(), + value: value.to_vec(), + pad, + }); + entry = next; + value_at += value_len; + } + if entry != data_start + || value_at != data_start.checked_add(data_len)? + || value_at > fork_at + { + return None; + } + let mut finder = [0u8; FINDER_INFO]; + finder.copy_from_slice(image.get(FINDER_AT..FINDER_AT + FINDER_INFO)?); + Some(Self { + finder, + tag, + attrs, + fork, + len, + }) + } + /// The decoded form of `image` when it encodes back to exactly `image`. + pub fn compact(image: &[u8]) -> Option { + let decoded = Self::parse(image)?; + (decoded.encode() == image).then_some(decoded) + } +} + +/// An attribute entry's bytes for a name of `name_len` bytes with its NUL, +/// rounded up to four. +fn entry_len(name_len: usize) -> usize { + (ENTRY_FIXED + name_len + 3) & !3 +} +/// The empty resource fork: a resource map with no types, after the tag. +fn blank_fork() -> [u8; BLANK_FORK] { + let mut fork = [0u8; BLANK_FORK]; + for (at, value) in [ + (0, 0x100), + (4, 0x100), + (12, 0x1e), + (256, 0x100), + (260, 0x100), + ] { + put32(&mut fork, at, value); + } + put32(&mut fork, 268, 0x1e); + put16(&mut fork, 280, 0x1c); + put16(&mut fork, 282, 0x1e); + put16(&mut fork, 284, 0xffff); + fork[16..16 + BLANK_FORK_TAG.len()].copy_from_slice(BLANK_FORK_TAG); + fork +} +/// Copies the `bytes` that sit at `at` in the image into `out`, which holds +/// the image from `start` to its end. +fn emit(out: &mut [u8], start: usize, at: usize, bytes: &[u8]) { + let from = at.max(start); + let until = (at + bytes.len()).min(start + out.len()); + if from < until { + out[from - start..until - start].copy_from_slice(&bytes[from - at..until - at]); + } +} +fn put32(out: &mut [u8], at: usize, value: u32) { + out[at..at + 4].copy_from_slice(&value.to_be_bytes()); +} +fn put16(out: &mut [u8], at: usize, value: u16) { + out[at..at + 2].copy_from_slice(&value.to_be_bytes()); +} +fn get32(bytes: &[u8], at: usize) -> Option { + Some(u32::from_be_bytes(bytes.get(at..at + 4)?.try_into().ok()?)) +} +fn get16(bytes: &[u8], at: usize) -> Option { + Some(u16::from_be_bytes(bytes.get(at..at + 2)?.try_into().ok()?)) +} diff --git a/engine/crates/layerfs-nfs/src/apple_double_spill.rs b/engine/crates/layerfs-nfs/src/apple_double_spill.rs new file mode 100644 index 0000000000..c55d520070 --- /dev/null +++ b/engine/crates/layerfs-nfs/src/apple_double_spill.rs @@ -0,0 +1,166 @@ +//! The export's own scratch files for AppleDouble companion bodies. +//! +//! A companion body beyond the resident budget lives in one file per +//! companion serial under the export's spill directory, read and written with +//! `pread`/`pwrite` by an operation that opens it and closes it again: the +//! export holds no descriptor per spilled body. A spill writes a temporary +//! `..tmp` that only the call adopting it renames to ``, so +//! two calls spilling the same companion never share a file; the rename runs +//! outside the companion lock, once the renaming call holds the companion's +//! edit gate, and the body is committed as spilled under the lock afterwards. +//! A reader therefore keeps reading the body in memory until the file is +//! whole, and never sees a partial one. The directory +//! and its files are this user's alone; the modes are set here rather than +//! left to the caller's umask. +use crate::attributes::Status; +use layerfs_content::filesystem::attributes::PortableMetadata; +use std::{ + fs::{self, File, OpenOptions}, + io, + os::unix::fs::{DirBuilderExt, FileExt, OpenOptionsExt}, + path::{Path, PathBuf}, + sync::atomic::{AtomicU64, Ordering}, + time::{SystemTime, UNIX_EPOCH}, +}; + +/// Mode of a companion created without one. +pub(crate) const MODE: u32 = 0o644; +/// Temporary names tried for one spilled body before the spill gives up. +const SPILL_TEMP_TRIES: u32 = 64; +/// Counter behind the distinct temporary name of each spilled body. +static SPILL_TEMP: AtomicU64 = AtomicU64::new(0); + +/// A failed file operation as the client sees it. +pub(crate) fn io_status(error: &io::Error) -> Status { + match (error.kind(), error.raw_os_error()) { + (io::ErrorKind::StorageFull, _) | (_, Some(28 | 69 | 122)) => Status::NoSpc, + (_, Some(27)) => Status::FBig, + (_, Some(1)) => Status::Perm, + (io::ErrorKind::PermissionDenied, _) | (_, Some(13)) => Status::Access, + (io::ErrorKind::ReadOnlyFilesystem, _) | (_, Some(30)) => Status::RoFs, + _ => Status::Io, + } +} +/// The spill directory's own file of `serial`. +pub(crate) fn spill_path(dir: &Path, serial: u64) -> PathBuf { + dir.join(serial.to_string()) +} +/// Creates `dir` and a temporary file in it holding `bytes` extended to `len` +/// bytes, then closes it: the caller adopts it by renaming it to the +/// companion's own name. +pub(crate) fn create_spilled( + dir: &Path, + serial: u64, + bytes: &[u8], + len: u64, +) -> Result { + let made = fs::DirBuilder::new() + .recursive(true) + .mode(0o700) + .create(dir); + made.map_err(|e| io_status(&e))?; + for _ in 0..SPILL_TEMP_TRIES { + let name = SPILL_TEMP.fetch_add(1, Ordering::Relaxed); + let path = dir.join(format!("{serial}.{name}.tmp")); + let file = match OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .mode(0o600) + .open(&path) + { + Ok(file) => file, + Err(e) if e.kind() == io::ErrorKind::AlreadyExists => continue, + Err(e) => return Err(io_status(&e)), + }; + let written = (file.write_all_at(bytes, 0)).and_then(|()| file.set_len(len)); + drop(file); + return match written { + Ok(()) => Ok(path), + Err(e) => { + drop(fs::remove_file(&path)); + Err(io_status(&e)) + } + }; + } + Err(Status::Io) +} +/// Unlinks the spilled files a companion operation retired, outside the lock. +pub(crate) fn unlink_paths(paths: impl IntoIterator) { + for path in paths { + drop(fs::remove_file(path)); + } +} +/// The facts of a companion body created now. +pub(crate) fn now() -> PortableMetadata { + let elapsed = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default(); + PortableMetadata { + mode: MODE, + mtime_seconds: i64::try_from(elapsed.as_secs()).unwrap_or(i64::MAX), + mtime_nanoseconds: elapsed.subsec_nanos(), + } +} +/// Records a change of a companion body's time, keeping its mode. +pub(crate) fn touch(metadata: &mut PortableMetadata) { + let mode = metadata.mode; + *metadata = now(); + metadata.mode = mode; +} +/// One change to a companion body, applied to the resident bytes under the +/// lock or to the spilled file outside it. +pub(crate) enum Edit<'a> { + Write { offset: usize, data: &'a [u8] }, + Size(usize), +} +impl Edit<'_> { + /// The body length this edit needs; a write keeps what the body had beyond + /// its end. + pub(crate) fn target_len(&self) -> usize { + match self { + Edit::Write { offset, data } => offset + data.len(), + Edit::Size(size) => *size, + } + } + /// Applies the edit to resident bytes, which already hold `target_len`. + pub(crate) fn memory(&self, bytes: &mut Vec) { + match self { + Edit::Write { offset, data } => { + bytes.resize(bytes.len().max(offset + data.len()), 0); + bytes[*offset..*offset + data.len()].copy_from_slice(data); + } + Edit::Size(size) => bytes.resize(*size, 0), + } + } + /// Applies the edit to a spilled file, outside the companion lock. + pub(crate) fn disk(&self, file: &File) -> Result<(), Status> { + match self { + Edit::Write { offset, data } => { + (file.write_all_at(data, *offset as u64)).map_err(|e| io_status(&e)) + } + Edit::Size(size) => (file.set_len(*size as u64)).map_err(|e| io_status(&e)), + } + } +} +/// Where [`crate::apple_double`] found a companion's body. +pub(crate) enum Room { + /// Applied to the resident body, whose length, recency and time were + /// recorded under the same lock: this is the companion's stat afterwards. + Resident(layerfs_workspace::ViewStat), + /// On disk: finish with its file outside the lock. + Spilled, + /// Resident, but growing it needs this many more budget bytes first. + Grow(usize), + /// The body takes a slot of the index bound and the bound has none. + NoSlot, +} + +/// What one application of an edit made of a companion. +pub(crate) enum Edited { + /// It landed; this is the companion's stat afterwards. + Done(layerfs_workspace::ViewStat), + /// The body would take a slot of the index bound and none is free, so + /// nothing was changed. + NoSlot, +} diff --git a/engine/crates/layerfs-nfs/src/change.rs b/engine/crates/layerfs-nfs/src/change.rs index 7932d219b5..2456d43b53 100644 --- a/engine/crates/layerfs-nfs/src/change.rs +++ b/engine/crates/layerfs-nfs/src/change.rs @@ -183,7 +183,7 @@ impl Kernel { let mutation = match wait(KernelMutation::perform(services, request)) { Ok(mutation) => mutation, Err(failure) => { - let status = if crate::kernel::failure_is_stale(&failure.reason) { + let status = if crate::read::failure_is_stale(&failure.reason) { Status::Stale } else { Status::Io @@ -261,9 +261,11 @@ impl Kernel { /// The entry a name binds now, or none. fn existing(&self, parent: u64, name: &[u8]) -> Result, Status> { match self.lookup(parent, name) { - Ok(stat) => Ok(Some(stat)), - Err(Status::NoEnt) => Ok(None), - Err(status) => Err(status), + Ok((stat, _)) => Ok(Some(stat)), + Err(refused) => match refused.status { + Status::NoEnt => Ok(None), + status => Err(status), + }, } } /// CREATE of a regular file. @@ -463,7 +465,8 @@ impl Kernel { /// export held for the inode it detached. Only the inode the publishing /// job itself retired skips the release jobs. fn finish_unlink(&self, parent: u64, name: &[u8], retire: Retire, detached: Option) { - self.table().by_name.remove(&(parent, name.to_vec())); + self.companion_drop_for(parent, name); + self.table().unbind_any(&(parent, name.to_vec())); let Some(target) = detached else { return; }; @@ -499,6 +502,9 @@ impl Kernel { tickets, |_| Ok(MutationInput::Named(remove::unlink(parent, checked))), )?; + if let Some(detached) = &published.detached { + self.trace_main_file("REMOVE", parent, name, detached.serial, "Ok"); + } self.finish_unlink(parent, name, retire, published.detached); Ok(published.wcc[0].clone()) } @@ -572,6 +578,11 @@ impl Kernel { self.mutate(from, None, None, Expect::Nothing, tickets, |_| { Ok(MutationInput::Named(remove::unlink(from, source_name))) })?; + self.companion_drop_for(from, name); + if source.namespace_refs <= 1 { + // The last name of the inode went with the silly rename. + self.companion_drop_inode(source.serial); + } self.silly_renamed.fetch_add(1, Ordering::Relaxed); let replaced = { let mut table = self.table(); @@ -627,7 +638,7 @@ impl Kernel { if directory { self.saw_directory(serial, to); } - self.renamed(serial, to, new_name); + self.renamed(serial, from, name, to, new_name); } /// LINK: one more name for `serial`. pub fn link( @@ -637,8 +648,10 @@ impl Kernel { name: &[u8], tickets: &mut Tickets, ) -> Result<(ViewStat, Wcc), Status> { + // A companion holds no engine inode, so its LINK is another `._` name + // of the same companion, decided in the export alone. if crate::apple_double::companion(serial) { - return Err(Status::Access); + return self.companion_link(serial, parent, name); } let checked = self.checked(name, true)?; let published = self.mutate( @@ -652,6 +665,7 @@ impl Kernel { let stat = published.stat.ok_or(Status::ServerFault)?; // The engine took one more lookup reference; the export holds one. self.entry_taken(&stat, parent, name); + self.trace_main_file("LINK", parent, name, stat.serial, "Ok"); Ok((stat, published.wcc[0].clone())) } /// SETATTR. `guard` is the client's expected ctime (seconds, diff --git a/engine/crates/layerfs-nfs/src/directory.rs b/engine/crates/layerfs-nfs/src/directory.rs index 5842d6c6dd..7f7e00fb19 100644 --- a/engine/crates/layerfs-nfs/src/directory.rs +++ b/engine/crates/layerfs-nfs/src/directory.rs @@ -12,10 +12,12 @@ //! directory's end, so the same reply says so; any other reply's next call //! resumes after the last accepted cookie. //! -//! A READDIRPLUS entry carries the attributes the listing already read — the -//! local inode row of the name, or the inherited inode's own immutable facts -//! — and the handle of the entry's serial. Both are optional in RFC 1813; -//! here they are present for every named entry whose offsets this request +//! A READDIRPLUS entry carries the attributes the listing read — the local +//! inode row of the name, or the inherited inode's immutable facts, read for +//! the window in one batch demand for file lengths and one inode batch per +//! level of the inode tree the cache does not already answer — +//! and the handle of the entry's serial. Both are optional in RFC 1813; here +//! they are present for every named entry whose offsets this request //! publishes, and the publishing visit takes one kernel lookup reference per //! handed-out handle in that same job, so nothing is looked up twice and no //! entry is left without the reference its handle presents. @@ -23,7 +25,8 @@ use crate::{ attributes::{post_op_maybe, Identity, Status}, block::wait, handle::HANDLE_BYTES, - kernel::{failure, Kernel}, + kernel::Kernel, + read::failure, xdr::{opaque_size, Writer}, }; use layerfs_content::object::inode_leaf::InodeKind; @@ -210,6 +213,15 @@ pub fn list(kernel: &Kernel, request: Listing) -> Result, Status> { (at_end, directory) } }; + // A window that read the listed directory's own row answers it: the + // reply's `post_op_attr` is those fresh facts and no further read. An + // inherited directory has no local row, so its window reads none. + // Answering the facts this export last observed for it instead — what its + // OPENDIR visit read, whenever the descriptor was opened — restarts the + // client's `actimeo` on a snapshot that nothing ages, so a directory + // whose facts moved on since is answered as it was then, for as long as + // the descriptor lives. RFC 1813 makes the field optional, so such a + // reply says nothing and the client falls back to its own timer. finish(entries, directory.as_ref(), handle, eof) } diff --git a/engine/crates/layerfs-nfs/src/kernel.rs b/engine/crates/layerfs-nfs/src/kernel.rs index dd03a6ab8f..48c5c087bf 100644 --- a/engine/crates/layerfs-nfs/src/kernel.rs +++ b/engine/crates/layerfs-nfs/src/kernel.rs @@ -40,13 +40,14 @@ use crate::{ block::wait, change::Wcc, handle::{HandleError, SqliteHandles}, + read::{failure, read_failure, Answer, Refused}, }; use layerfs_content::{filesystem::PathName, object::inode_leaf::InodeKind}; use layerfs_mount_ports::{ - operations::{KernelData, KernelRead, MutationFailure, ReadDataInput, ReadFailure}, - ports::{Fence, MountServices, RequestServices, ServiceError}, + operations::{KernelData, KernelRead, MutationFailure, ReadDataInput}, + ports::{Fence, MountServices, RequestServices}, }; -use layerfs_overlay::{KernelMount, OverlayError, READ_WINDOW}; +use layerfs_overlay::{KernelMount, READ_WINDOW}; use layerfs_workspace::{KernelReadOperation, ViewStat}; use std::{ collections::{HashMap, HashSet}, @@ -56,6 +57,9 @@ use std::{ }, }; +mod released; +pub use released::Released; + /// Implicit file descriptors kept open at once. pub const FILES_HELD: usize = 1024; /// Implicit directory descriptors (enumerations) kept open at once. @@ -106,8 +110,15 @@ pub(crate) struct Table { /// Serial -> the name it was last reached by, kept after its reference /// is collected so a later handle can be resolved again. pub names: HashMap, - /// (directory, name) -> serial last seen under that name. + /// Every observed (directory, name) -> serial, including hard-link aliases. + /// A second name does not retire the first; unlink/rename remove known + /// vanished names, and retiring a serial removes all its keys. pub by_name: HashMap, + /// Serial -> the names it is reached by besides [`Table::names`]: the + /// hard-link aliases it was also observed under. Every key of + /// [`Table::by_name`] is one of the two, so dropping one record removes + /// exactly its own keys instead of scanning the whole index. + pub aliases: HashMap>, /// Serial -> last use, for the collection order. pub used: HashMap, /// Serials marked for a cache refresh, and when (see [`crate::refresh`]). @@ -128,6 +139,55 @@ impl Table { pub fn pinned(&self, serial: u64) -> bool { self.silly.values().any(|held| *held == serial) } + /// Records that `serial` is reached as `named`. + pub(crate) fn bind_name(&mut self, named: Named, serial: u64) { + self.by_name.insert(named, serial); + } + /// Remembers that `serial` is also reached as `named`, a name beyond its + /// remembered one, so dropping the serial needs no scan of `by_name`. + pub(crate) fn remember_alias(&mut self, serial: u64, named: &Named) { + let aliases = self.aliases.entry(serial).or_default(); + if !aliases.iter().any(|alias| alias == named) { + aliases.push(named.clone()); + } + } + /// Drops `named`, which `serial` no longer holds. Returns whether it did. + pub(crate) fn unbind_name(&mut self, named: &Named, serial: u64) -> bool { + if self.by_name.get(named) != Some(&serial) { + return false; + } + self.by_name.remove(named); + self.drop_alias(serial, named); + true + } + /// Drops `named` whatever serial holds it, and its alias record. + pub(crate) fn unbind_any(&mut self, named: &Named) -> Option { + let serial = self.by_name.remove(named)?; + self.drop_alias(serial, named); + Some(serial) + } + fn drop_alias(&mut self, serial: u64, named: &Named) { + let Some(aliases) = self.aliases.get_mut(&serial) else { + return; + }; + aliases.retain(|alias| alias != named); + if aliases.is_empty() { + self.aliases.remove(&serial); + } + } + /// Drops every key `serial` holds: its remembered name and its aliases. + pub(crate) fn unbind_serial(&mut self, serial: u64) { + if let Some(named) = self.names.remove(&serial) { + if self.by_name.get(&named) == Some(&serial) { + self.by_name.remove(&named); + } + } + for named in self.aliases.remove(&serial).unwrap_or_default() { + if self.by_name.get(&named) == Some(&serial) { + self.by_name.remove(&named); + } + } + } } /// One opened file as READ and WRITE need it. #[derive(Clone, Copy)] @@ -135,7 +195,6 @@ pub(crate) struct OpenFile { pub handle: u64, pub size: u64, } - /// One kernel mount served over NFS: its ports and its synthetic kernel state. pub struct Kernel { services: Arc, @@ -285,11 +344,12 @@ impl Kernel { None, KernelReadOperation::Lookup { parent, name: path }, ) + .map_err(|refused| refused.status) }); match found { - Ok((stat, _, _)) => { - self.entry_taken(&stat, parent, &name); - if stat.serial == serial { + Ok(answer) => { + self.entry_taken(&answer.stat, parent, &name); + if answer.stat.serial == serial { self.resolved.fetch_add(1, Ordering::Relaxed); return Ok(()); } @@ -298,16 +358,12 @@ impl Kernel { Err(status) => return Err(status), } let mut table = self.table(); - if table + let remembered = table .names .get(&serial) - .is_some_and(|(p, n)| *p == parent && *n == name) - { - if let Some(old) = table.names.remove(&serial) { - if table.by_name.get(&old) == Some(&serial) { - table.by_name.remove(&old); - } - } + .is_some_and(|(p, n)| *p == parent && *n == name); + if remembered { + table.unbind_serial(serial); } self.unresolved.fetch_add(1, Ordering::Relaxed); Err(Status::Stale) @@ -316,26 +372,42 @@ impl Kernel { let services = self.services.request(&self.fence).map_err(failure)?; Ok((services, self.requests.fetch_add(1, Ordering::Relaxed))) } - fn observe( + pub(crate) fn observe( &self, protected: u64, handle: Option, operation: KernelReadOperation, - ) -> Result<(ViewStat, Option, Option), Status> { - let (services, request) = self.request()?; + ) -> Result { + let (services, request) = self.request().map_err(|status| Refused { + status, + directory: None, + })?; let found = wait(KernelRead::prepare( services, self.mount, request, protected, handle, operation, )) - .map_err(read_failure)?; - let answer = found.value().map(|value| { - ( - value.stat.clone(), - value.file.map(|file| file.owner_id()), - value.directory.map(|directory| directory.owner_id()), - ) - }); - wait(found.dispose()).map_err(read_failure)?; - answer.map_err(refusal) + .map_err(|failure| Refused { + status: read_failure(failure), + directory: None, + })?; + let answer = match found.value() { + Ok(value) => Ok(Answer { + stat: value.stat.clone(), + parent: value.parent.clone(), + file: value.file.map(|file| file.owner_id()), + directory: value.directory.map(|directory| directory.owner_id()), + }), + // A refusal still carries the directory row its job read, when it + // read one: fresh facts, not this export's last observation. + Err(status) => Err(Refused { + status: refusal(status), + directory: found.refused_directory().cloned(), + }), + }; + wait(found.dispose()).map_err(|failure| Refused { + status: read_failure(failure), + directory: None, + })?; + answer } /// GETATTR. An inode that lost its last name while a silly name keeps it /// is observed through its descriptor; any other inode no name reaches @@ -354,58 +426,82 @@ impl Kernel { }; let stat = self .observe(serial, handle, KernelReadOperation::Getattr { serial }) - .map(|(stat, _, _)| stat) - .map_err(|status| { - if status == Status::NoEnt { - Status::Stale - } else { - status - } + .map(|answer| answer.stat) + .map_err(|refused| match refused.status { + Status::NoEnt => Status::Stale, + status => status, })?; self.observed(&stat); Ok(stat) } /// LOOKUP of `name` in directory `parent`, including `.`, `..` and the - /// export's own silly names. - pub fn lookup(&self, parent: u64, name: &[u8]) -> Result { + /// export's own silly names. One owner job answers both the entry and, + /// when the name resolved, the directory itself: the same job had to read + /// the directory's row to resolve it, so the reply's directory attributes + /// cost nothing more. + /// + /// A failure answers the directory's own fresh facts only when the job + /// that failed read its row, which is every name this export looked up: + /// a name that binds nothing still read the parent's row. `.`, `..`, a + /// silly name and a refusal decided before any visit read no directory + /// row and answer `None`, so the client falls back to its own `actimeo` + /// instead of restarting its timer on facts nothing refreshes. + pub fn lookup( + &self, + parent: u64, + name: &[u8], + ) -> Result<(ViewStat, Option), Refused> { match name { - b"" => return Err(Status::NoEnt), - b"." => return self.getattr(parent), + b"" => return Err(Refused::plain(Status::NoEnt)), + b"." => { + return self + .getattr(parent) + .map(|stat| (stat, None)) + .map_err(Refused::plain) + } b".." => { let up = if parent == self.root() { parent } else { let known = self.table().parents.get(&parent).copied(); - known.ok_or(Status::NoEnt)? + known.ok_or(Refused::plain(Status::NoEnt))? }; - self.held_reference(up)?; - return self.getattr(up); + self.held_reference(up).map_err(Refused::plain)?; + return self + .getattr(up) + .map(|stat| (stat, None)) + .map_err(Refused::plain); } - _ if name.len() > 255 => return Err(Status::NameTooLong), + _ if name.len() > 255 => return Err(Refused::plain(Status::NameTooLong)), _ => {} } + // A companion lives in the export alone: no job read the directory. if let Some(stat) = self.companion_named(parent, name) { - return Ok(stat); + return Ok((stat, None)); } if self.refuses_apple_double() && crate::names::apple_double(name) { if parent != self.root() && !self.table().parents.contains_key(&parent) { - return Err(Status::NotDir); + return Err(Refused::plain(Status::NotDir)); } - return Err(Status::NoEnt); + return Err(Refused::plain(Status::NoEnt)); } let silly = self.table().silly.get(&(parent, name.to_vec())).copied(); if let Some(serial) = silly { - return self.getattr(serial); - } - let path = PathName::from_bytes(name).map_err(|_| Status::Inval)?; - let (stat, _, _) = self.observe( - parent, - None, - KernelReadOperation::Lookup { parent, name: path }, - )?; + return self + .getattr(serial) + .map(|stat| (stat, None)) + .map_err(Refused::plain); + } + let path = PathName::from_bytes(name).map_err(|_| Refused::plain(Status::Inval))?; + let lookup = KernelReadOperation::Lookup { parent, name: path }; + let answer = self.observe(parent, None, lookup).inspect_err(|refused| { + refused.directory.iter().for_each(|row| self.observed(row)); + })?; + answer.parent.iter().for_each(|row| self.observed(row)); // The deciding visit took one engine reference; keep exactly one. - self.entry_taken(&stat, parent, name); - Ok(stat) + self.entry_taken(&answer.stat, parent, name); + self.trace_main_file("LOOKUP", parent, name, answer.stat.serial, "Ok"); + Ok((answer.stat, answer.parent)) } /// A visit or mutation that decided `stat` as the entry `name` of /// `parent` took one engine lookup reference on it: the export keeps @@ -424,11 +520,40 @@ impl Kernel { if table.names.len() < NAMES_HELD || table.names.contains_key(&stat.serial) { let named = (parent, name.to_vec()); if let Some(old) = table.names.insert(stat.serial, named.clone()) { - if table.by_name.get(&old) == Some(&stat.serial) { - table.by_name.remove(&old); + if old != named { + if stat.namespace_refs <= 1 { + // The inode has one name: every other name the + // index held for it is one it no longer has. + // (Its old keys stay a moment in a state whose + // nlink the engine last reported higher.) + table.unbind_name(&old, stat.serial); + for alias in table.aliases.remove(&stat.serial).unwrap_or_default() + { + if table.by_name.get(&alias) == Some(&stat.serial) { + table.by_name.remove(&alias); + } + } + } else { + // A hard link: the old name still reaches the + // inode, so it stays, remembered per serial so + // that retiring the serial drops no other name. + table.remember_alias(stat.serial, &old); + } + // Held here: the table lock, and inside it the + // companion lock as everywhere else. Off unless the + // trace is on. + self.trace_bind( + parent, + name, + stat.serial, + match stat.namespace_refs <= 1 { + true => "unbound", + false => "alias", + }, + ); } } - table.by_name.insert(named, stat.serial); + table.bind_name(named, stat.serial); } } let extra = root || !table.lookups.insert(stat.serial); @@ -449,16 +574,26 @@ impl Kernel { } self.observed(stat); } - /// Records that `serial` is now reached as `name` in `parent` (RENAME). - pub(crate) fn renamed(&self, serial: u64, parent: u64, name: &[u8]) { + /// Records that `serial` is now reached as `new_name` in `to` rather than as + /// `name` in `from` (RENAME). Only the name that moved leaves the index: + /// other names of the inode, its hard links, stay reachable as they were. + pub(crate) fn renamed(&self, serial: u64, from: u64, name: &[u8], to: u64, new_name: &[u8]) { let mut table = self.table(); - let named = (parent, name.to_vec()); - if let Some(slot) = table.names.get_mut(&serial) { - let old = std::mem::replace(slot, named.clone()); - if table.by_name.get(&old) == Some(&serial) { - table.by_name.remove(&old); + let named = (to, new_name.to_vec()); + let moved = (from, name.to_vec()); + table.unbind_name(&moved, serial); + let previous = table + .names + .get_mut(&serial) + .map(|slot| std::mem::replace(slot, named.clone())); + if let Some(previous) = previous { + // The name the inode was last recalled by did not move and is still + // one of its names: overwriting the remembered name keeps it only + // as an alias, which is what retiring the serial reads. + if previous != moved && previous != named { + table.remember_alias(serial, &previous); } - table.by_name.insert(named, serial); + table.bind_name(named, serial); } } pub(crate) fn forget(&self, serial: u64, count: u64) { @@ -486,11 +621,7 @@ impl Kernel { let mut table = self.table(); table.parents.remove(&serial); table.directory_stats.remove(&serial); - if let Some(old) = table.names.remove(&serial) { - if table.by_name.get(&old) == Some(&serial) { - table.by_name.remove(&old); - } - } + table.unbind_serial(serial); table.used.remove(&serial); table.verifiers.retain(|_, entry| entry.1 != serial); let directories: Vec = table @@ -521,6 +652,8 @@ impl Kernel { if held && !retired_in_job { self.forget(serial, 1); } + // An inode's last name is gone: so is its AppleDouble companion. + self.companion_drop_inode(serial); } /// Records the parent of a directory seen in a listing or moved by RENAME. pub fn saw_directory(&self, serial: u64, parent: u64) { @@ -611,9 +744,11 @@ impl Kernel { } } let operation = KernelReadOperation::Open { serial, writable }; - let (stat, file, _) = self.observe(serial, None, operation)?; - let handle = file.ok_or(Status::ServerFault)?; - Ok(self.file_taken(serial, handle, &stat, writable)) + let answer = self + .observe(serial, None, operation) + .map_err(|refused| refused.status)?; + let handle = answer.file.ok_or(Status::ServerFault)?; + Ok(self.file_taken(serial, handle, &answer.stat, writable)) } /// Records an open file descriptor (from `OPEN` or `CREATE`), evicting /// the oldest unpinned descriptor when the bound is reached. @@ -730,9 +865,13 @@ impl Kernel { if crate::apple_double::companion(serial) { return Err(Status::NotDir); } - let (_, _, directory) = - self.observe(serial, None, KernelReadOperation::Opendir { serial })?; - let handle = directory.ok_or(Status::ServerFault)?; + let answer = self + .observe(serial, None, KernelReadOperation::Opendir { serial }) + .map_err(|refused| refused.status)?; + let handle = answer.directory.ok_or(Status::ServerFault)?; + // The visit read the directory's own row: remember it, so a LOOKUP in + // this directory answers its `dir_attributes` from memory. + self.observed(&answer.stat); let evicted = { let mut table = self.table(); let tick = table.tick(); @@ -776,61 +915,6 @@ impl Kernel { drop(wait(services.close_directory(self.mount, serial, handle))); } } - /// Gives back everything the synthetic kernel holds: descriptors first, - /// then lookup references. Run once, before the engine mount is revoked. - /// Retained mutation failures keep their custody and are only counted. - pub fn release(&self) -> Released { - let table = std::mem::take(&mut *self.table()); - let companions = self.companions_release(); - let released = Released { - companions, - files: table.files.len(), - directories: table.directories.len(), - lookups: table.lookups.len(), - silly: table.silly.len(), - retained: self.retained_count(), - silly_renamed: self.silly_renamed.load(Ordering::Relaxed), - names_refused: self.names_refused.load(Ordering::Relaxed), - names_detached: self.names_detached.load(Ordering::Relaxed), - collected: self.collected.load(Ordering::Relaxed), - resolved: self.resolved.load(Ordering::Relaxed), - unresolved: self.unresolved.load(Ordering::Relaxed), - }; - for (serial, held) in table.files { - self.close_file(serial, held.handle); - } - for (handle, (serial, _)) in table.directories { - self.close_directory(serial, handle); - } - for serial in table.lookups { - self.forget(serial, 1); - } - released - } - fn retained_count(&self) -> usize { - self.retained - .lock() - .unwrap_or_else(|poison| poison.into_inner()) - .len() - } - /// Current holdings, for diagnostics. - pub fn held(&self) -> Released { - let table = self.table(); - Released { - companions: self.companions_held(), - files: table.files.len(), - directories: table.directories.len(), - lookups: table.lookups.len(), - silly: table.silly.len(), - retained: self.retained_count(), - silly_renamed: self.silly_renamed.load(Ordering::Relaxed), - names_refused: self.names_refused.load(Ordering::Relaxed), - names_detached: self.names_detached.load(Ordering::Relaxed), - collected: self.collected.load(Ordering::Relaxed), - resolved: self.resolved.load(Ordering::Relaxed), - unresolved: self.unresolved.load(Ordering::Relaxed), - } - } /// Closes every implicit file descriptor that no silly name needs, so /// nothing the export opened is held across a Commit. Returns how many. pub fn close_files(&self) -> usize { @@ -906,64 +990,6 @@ fn collectable(table: &mut Table, keep: usize) -> Vec { } candidates.into_iter().map(|(_, serial)| serial).collect() } -/// What [`Kernel::release`] gave back. -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] -pub struct Released { - pub files: usize, - pub directories: usize, - pub lookups: usize, - /// Silly names whose inode was kept alive until release. - pub silly: usize, - /// Failed mutations still holding engine custody. - pub retained: usize, - /// Client silly renames served as unlinks, over the export's life. - pub silly_renamed: u64, - /// Creations refused for their AppleDouble name, over the export's life. - pub names_refused: u64, - /// AppleDouble companions held in memory (see [`crate::apple_double`]). - pub companions: usize, - /// AppleDouble companions created, over the export's life. - pub names_detached: u64, - /// References collected beyond the bound, over the export's life. - pub collected: u64, - /// SqliteHandles of collected serials resolved again by their name. - pub resolved: u64, - /// SqliteHandles of collected serials whose name no longer reaches them. - pub unresolved: u64, -} fn oldest(entries: impl Iterator) -> Option { entries.min_by_key(|(_, tick)| *tick).map(|(key, _)| key) } -fn stale(error: &(dyn std::error::Error + 'static)) -> bool { - let mut current = Some(error); - while let Some(error) = current { - if matches!( - error.downcast_ref::(), - Some(OverlayError::Stale) - ) { - return true; - } - current = error.source(); - } - false -} -/// Whether a failed step's cause chain holds an engine `Stale`. -pub(crate) fn failure_is_stale(error: &ServiceError) -> bool { - stale(error.as_ref()) -} -/// A failed port step: an engine `Stale` is the client's stale handle; any -/// other failure is an I/O error of this request alone. -pub fn failure(error: ServiceError) -> Status { - if stale(error.as_ref()) { - Status::Stale - } else { - Status::Io - } -} -fn read_failure(failure: ReadFailure) -> Status { - if stale(failure.reason.as_ref()) { - Status::Stale - } else { - Status::Io - } -} diff --git a/engine/crates/layerfs-nfs/src/kernel/released.rs b/engine/crates/layerfs-nfs/src/kernel/released.rs new file mode 100644 index 0000000000..51a4d08db5 --- /dev/null +++ b/engine/crates/layerfs-nfs/src/kernel/released.rs @@ -0,0 +1,103 @@ +//! What the synthetic kernel gives back, counted. +//! +//! [`Kernel::release`] runs once, before the engine mount is revoked; [`Kernel::held`] +//! reports the same counts while the export serves, for diagnostics. +use super::{Kernel, Table}; +use std::sync::atomic::{AtomicU64, Ordering}; + +impl Kernel { + /// Gives back everything the synthetic kernel holds: descriptors first, + /// then lookup references. Run once, before the engine mount is revoked. + /// Retained mutation failures keep their custody and are only counted. + pub fn release(&self) -> Released { + let table = std::mem::take(&mut *self.table()); + let companions = self.companions_release(); + let released = self.holdings(&table, companions); + for (serial, held) in table.files { + self.close_file(serial, held.handle); + } + for (handle, (serial, _)) in table.directories { + self.close_directory(serial, handle); + } + for serial in table.lookups { + self.forget(serial, 1); + } + released + } + fn retained_count(&self) -> usize { + self.retained + .lock() + .unwrap_or_else(|poison| poison.into_inner()) + .len() + } + /// Current holdings, for diagnostics. + pub fn held(&self) -> Released { + let table = self.table(); + let companions = self.companions_held(); + self.holdings(&table, companions) + } + /// What this export holds now, as [`Released`] reports it. + fn holdings(&self, table: &Table, companions: crate::apple_double::Holding) -> Released { + let count = |counter: &AtomicU64| counter.load(Ordering::Relaxed); + Released { + companions: companions.held, + companion_bytes: companions.resident_bytes, + companions_slotted: companions.slotted, + companions_decoded: companions.decoded, + companions_unreachable: companions.unreachable, + files: table.files.len(), + directories: table.directories.len(), + lookups: table.lookups.len(), + silly: table.silly.len(), + retained: self.retained_count(), + silly_renamed: count(&self.silly_renamed), + names_refused: count(&self.names_refused), + names_detached: count(&self.names_detached), + collected: count(&self.collected), + resolved: count(&self.resolved), + unresolved: count(&self.unresolved), + } + } +} + +/// What [`Kernel::release`] gave back. +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct Released { + pub files: usize, + pub directories: usize, + pub lookups: usize, + /// Silly names whose inode was kept alive until release. + pub silly: usize, + /// Failed mutations still holding engine custody. + pub retained: usize, + /// Client silly renames served as unlinks, over the export's life. + pub silly_renamed: u64, + /// Creations refused for their AppleDouble name, over the export's life. + pub names_refused: u64, + /// AppleDouble companions held in the export's index (see + /// [`crate::apple_double`]), whole images included. + pub companions: usize, + /// Companion body bytes currently counted against the export's resident + /// budget: a body kept as written at its length, a decoded one at what its + /// attributes are counted as. + pub companion_bytes: usize, + /// Of the companions held, those taking a slot of the index bound: all but + /// the ones holding a whole image. + pub companions_slotted: usize, + /// Of the companions held, those kept decoded. + pub companions_decoded: usize, + /// Of the companions held, those no name reaches: neither the name a + /// companion records nor another name of its inode finds it. It is what a + /// status read and the release line both report, so a client that lost + /// attributes can be told whether the export still held the body with no + /// way to ask for it. + pub companions_unreachable: usize, + /// AppleDouble companions created, over the export's life. + pub names_detached: u64, + /// References collected beyond the bound, over the export's life. + pub collected: u64, + /// SqliteHandles of collected serials resolved again by their name. + pub resolved: u64, + /// SqliteHandles of collected serials whose name no longer reaches them. + pub unresolved: u64, +} diff --git a/engine/crates/layerfs-nfs/src/lib.rs b/engine/crates/layerfs-nfs/src/lib.rs index f5cb633717..a33f6f6887 100644 --- a/engine/crates/layerfs-nfs/src/lib.rs +++ b/engine/crates/layerfs-nfs/src/lib.rs @@ -17,6 +17,8 @@ #![forbid(unsafe_code)] pub mod apple_double; +pub mod apple_double_codec; +mod apple_double_spill; pub mod attributes; mod block; pub mod change; @@ -27,9 +29,11 @@ pub mod kernel; mod mount; pub mod names; mod nfs; +pub mod read; pub mod refresh; pub mod rpc; mod server; +mod trace; pub mod xdr; pub use kernel::Released; diff --git a/engine/crates/layerfs-nfs/src/nfs.rs b/engine/crates/layerfs-nfs/src/nfs.rs index ecffcda5f0..1b05fc15de 100644 --- a/engine/crates/layerfs-nfs/src/nfs.rs +++ b/engine/crates/layerfs-nfs/src/nfs.rs @@ -107,23 +107,37 @@ pub fn call( 3 => { let parent = handle(kernel, arguments).map_err(garbage)?; let name = arguments.opaque(NAME_LIMIT).map_err(garbage)?; - // Both answers carry the directory's attributes (RFC 1813 - // LOOKUP3resok and LOOKUP3resfail), so the client keeps its - // cached view of the directory without a GETATTR of its own. - let directory = parent - .as_ref() - .ok() - .and_then(|parent| kernel.getattr(*parent).ok()); - match parent.and_then(|parent| kernel.lookup(parent, name)) { - Ok(stat) => { + // One owner job answers the entry and the directory it was named + // in (RFC 1813 LOOKUP3resok's `obj_attributes` and + // `dir_attributes`, and the failure's). The job had to read the + // directory's own row to resolve the name, so its attributes cost + // no second job, and a name that binds nothing still read that row: + // the failed answer carries the same fresh facts. + // + // Every answer that read no directory row says so instead of + // repeating this export's last observation: `.`, `..`, a silly + // name and a refusal decided before the job. Stale attributes are + // worse than none here — the client would load them into its + // attribute cache, restart `actimeo` and keep a listing nothing + // refreshes — and RFC 1813 keeps both fields optional. + let found = match parent { + Ok(parent) => kernel.lookup(parent, name), + Err(status) => { + out.u32(status.code()); + post_op_maybe(kernel.identity(), out, None); + return Ok(()); + } + }; + match found { + Ok((stat, directory)) => { out.u32(Status::Ok.code()); out.opaque(&kernel.encode(stat.serial)); kernel.identity().post_op(out, &stat); post_op_maybe(kernel.identity(), out, directory.as_ref()); } - Err(status) => { - out.u32(status.code()); - post_op_maybe(kernel.identity(), out, directory.as_ref()); + Err(refused) => { + out.u32(refused.status.code()); + post_op_maybe(kernel.identity(), out, refused.directory.as_ref()); } } Ok(()) @@ -188,8 +202,10 @@ pub fn call( let verifier = arguments.fixed(8).map_err(garbage)?; let mut budget = arguments.u32().map_err(garbage)?; if plus { - // dircount bounds the names alone; maxcount the whole reply. - let _dircount = budget; + // A READDIRPLUS request carries the entries' own count + // (`dircount`) before the reply's (`maxcount`). Only the + // reply's bounds what this export sends: the client sized its + // buffer by it, and names alone are never what fills a reply. budget = arguments.u32().map_err(garbage)?; } let mut word = [0; 8]; diff --git a/engine/crates/layerfs-nfs/src/read.rs b/engine/crates/layerfs-nfs/src/read.rs new file mode 100644 index 0000000000..4b0e31e027 --- /dev/null +++ b/engine/crates/layerfs-nfs/src/read.rs @@ -0,0 +1,79 @@ +//! What one kernel read answers this export, and what a failed one means. +//! +//! A read is served by one owner job (see [`crate::kernel`]). Its answer is +//! the entry it names and, for a LOOKUP, the directory it was named in, which +//! that job had to read anyway. A refusal keeps the directory row its own job +//! read, when it read one, so a reply's `dir_attributes` are current facts and +//! never this export's last observation: nothing ages such an observation, so +//! a client that loaded it would restart its own `actimeo` on facts that do +//! not change until the export happens to observe the directory again. +use crate::attributes::Status; +use layerfs_mount_ports::{operations::ReadFailure, ports::ServiceError}; +use layerfs_overlay::OverlayError; +use layerfs_workspace::ViewStat; + +/// One kernel read's answer, as this export uses it. +pub(crate) struct Answer { + pub stat: ViewStat, + /// The directory a LOOKUP named the inode in: the same visit read it, so + /// the reply's directory attributes cost no second owner job. + pub parent: Option, + pub file: Option, + pub directory: Option, +} + +/// A read this export refused: the status its reply answers, and the fresh +/// directory facts the refusing job read, when it read one. A LOOKUP that +/// binds no name read its parent's row in the same job, so the failure's +/// `dir_attributes` are those facts and never a last observation that no +/// time bound ages (see [`crate::kernel::Kernel::lookup`]). +pub struct Refused { + pub status: Status, + pub directory: Option, +} +impl Refused { + /// A refusal no visit decided: no job read a directory row for it. + pub(crate) const fn plain(status: Status) -> Self { + Self { + status, + directory: None, + } + } +} + +fn stale(error: &(dyn std::error::Error + 'static)) -> bool { + let mut current = Some(error); + while let Some(error) = current { + if matches!( + error.downcast_ref::(), + Some(OverlayError::Stale) + ) { + return true; + } + current = error.source(); + } + false +} + +/// Whether a failed step's cause chain holds an engine `Stale`. +pub(crate) fn failure_is_stale(error: &ServiceError) -> bool { + stale(error.as_ref()) +} + +/// A failed port step: an engine `Stale` is the client's stale handle; any +/// other failure is an I/O error of this request alone. +pub fn failure(error: ServiceError) -> Status { + if stale(error.as_ref()) { + Status::Stale + } else { + Status::Io + } +} + +pub(crate) fn read_failure(failure: ReadFailure) -> Status { + if stale(failure.reason.as_ref()) { + Status::Stale + } else { + Status::Io + } +} diff --git a/engine/crates/layerfs-nfs/src/server.rs b/engine/crates/layerfs-nfs/src/server.rs index 798282c7eb..8db26faf1f 100644 --- a/engine/crates/layerfs-nfs/src/server.rs +++ b/engine/crates/layerfs-nfs/src/server.rs @@ -43,6 +43,17 @@ pub struct ExportConfig { /// Lookup references kept before the least recently used are collected /// (see [`crate::kernel`]); [`crate::kernel::LOOKUPS_HELD`] by default. pub lookups_held: usize, + /// Scratch directory where AppleDouble companion bodies spill when resident + /// bytes exceed [`Self::companion_resident_bytes`]. Removed when set and + /// when the export releases. + pub companion_spill_dir: Option, + /// Resident memory budget for AppleDouble companion bodies before spilling + /// to [`Self::companion_spill_dir`]; [`crate::apple_double::RESIDENT_BYTES`] + /// by default. + pub companion_resident_bytes: usize, + /// Maximum AppleDouble companion index entries held at once; + /// [`crate::apple_double::HELD`] by default. + pub companions_held: usize, } impl ExportConfig { /// A writable export of "/" shown as `uid`:`gid`, refusing AppleDouble @@ -55,6 +66,9 @@ impl ExportConfig { read_only: false, refuse_apple_double: true, lookups_held: crate::kernel::LOOKUPS_HELD, + companion_spill_dir: None, + companion_resident_bytes: crate::apple_double::RESIDENT_BYTES, + companions_held: crate::apple_double::HELD, } } } @@ -137,10 +151,16 @@ impl Server { config: ExportConfig, ) -> io::Result { let address = listener.local_addr()?; + let kernel = Kernel::new(services, mount, config.uid, config.gid) + .refusing_apple_double(config.refuse_apple_double) + .holding(config.lookups_held); + kernel.configure_companions( + config.companion_spill_dir.clone(), + config.companion_resident_bytes, + config.companions_held, + ); let shared = Arc::new(Shared { - kernel: Kernel::new(services, mount, config.uid, config.gid) - .refusing_apple_double(config.refuse_apple_double) - .holding(config.lookups_held), + kernel, verifier: fresh_verifier(), config, counters: Counters::default(), diff --git a/engine/crates/layerfs-nfs/src/trace.rs b/engine/crates/layerfs-nfs/src/trace.rs new file mode 100644 index 0000000000..c8759dcf1f --- /dev/null +++ b/engine/crates/layerfs-nfs/src/trace.rs @@ -0,0 +1,124 @@ +//! An optional trace of the AppleDouble names one client asks about. +//! +//! On a real client the export sees only the requests that arrive: whether a +//! companion a client cannot read was never asked for, was asked for under a +//! name the export cannot resolve, or was answered and then dropped by the +//! client, is invisible from the outside. This module prints one line for each +//! request that names an AppleDouble (`._`) companion - the `._` names +//! themselves and the main file names of the inodes that have one - with the +//! directory it named them in, the name, the companion the export resolved, +//! which part of its index found it (the companion's own name key or the main +//! inode) or that neither did, and the answer the client gets. A run of a real +//! client with this on is the only way to read its sequence; see +//! `docs/architecture/engine/kernel-routes/nfs.md`. +//! +//! `LAYERFS_NFS_TRACE=1` turns it on; anything else, and no variable at all, +//! leaves it off. It is read once per process and changes no state, so when it +//! is off every hook costs one `OnceLock` load. Lines go to the daemon's +//! standard error, like the release line, and are written under whatever lock +//! the request already holds. +//! +//! A `native` Sandbox's daemon is spawned after `env_clear`, so it does not +//! inherit this variable from the shell that created the Sandbox; tracing one +//! means pointing the machine's daemon at a wrapper that exports it and +//! `exec`s the real daemon (see `docs/architecture/engine/kernel-routes/nfs.md`). +use crate::attributes::Status; +use std::sync::OnceLock; + +static ENABLED: OnceLock = OnceLock::new(); + +/// Whether this process traces AppleDouble names. +pub fn enabled() -> bool { + *ENABLED.get_or_init(|| std::env::var("LAYERFS_NFS_TRACE").as_deref() == Ok("1")) +} + +/// Which part of the export's index found a companion for a `._` name. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Route { + /// The companion's own name key (`Companions::names`). + Name, + /// The main inode the name's main file has (`Companions::inodes`). + Inode, + /// Neither: no companion answers that name. + None, +} +impl Route { + const fn named(self) -> &'static str { + match self { + Route::Name => "name", + Route::Inode => "inode", + Route::None => "none", + } + } +} + +/// How a status is traced: the RFC's own name for it (`Ok`, `NoEnt`, `Exist`, +/// ...), for the answers a companion request gives. +pub fn status(status: Status) -> &'static str { + match status { + Status::Ok => "Ok", + Status::NoEnt => "NoEnt", + Status::Exist => "Exist", + Status::Access => "Access", + Status::Stale => "Stale", + Status::NotDir => "NotDir", + Status::NoSpc => "NoSpc", + Status::Inval => "Inval", + Status::Perm => "Perm", + Status::Io => "Io", + Status::NotSync => "NotSync", + Status::FBig => "FBig", + _ => "other", + } +} + +/// One request about a `._` name: `main` is the main inode the export's name +/// index gave it (`None` when it does not know the main file), `found` the +/// companion it resolved, and `route` which key found it. +pub fn companion( + op: &str, + directory: u64, + name: &[u8], + main: Option, + route: Route, + found: Option, + status: &str, +) { + if !enabled() { + return; + } + eprintln!( + "layerfs-nfs trace: op={op} dir={directory} name={:?} main={main:?} route={} companion={found:?} status={status}", + String::from_utf8_lossy(name), + route.named() + ); +} + +/// One request about a companion by handle only, where the client named no +/// name: a SETATTR of a `._` file it already holds, which can truncate the +/// body shared by every name of the inode. +pub fn handle(op: &str, companion: u64, detail: &str) { + if !enabled() { + return; + } + eprintln!("layerfs-nfs trace: op={op} companion={companion} {detail}"); +} + +/// One request about a main file whose inode has a companion, which is where +/// the export learns (or forgets) the names a `._` name resolves through. +pub fn main_file( + op: &str, + directory: u64, + name: &[u8], + inode: Option, + companion: Option, + status: &str, +) { + if !enabled() { + return; + } + eprintln!( + "layerfs-nfs trace: op={op} dir={directory} name={:?} inode={inode:?} companion={companion:?} status={status}", + String::from_utf8_lossy(name) + ); +} diff --git a/engine/crates/layerfs-nfs/tests/apple_double_codec.rs b/engine/crates/layerfs-nfs/tests/apple_double_codec.rs new file mode 100644 index 0000000000..548eeb87a9 --- /dev/null +++ b/engine/crates/layerfs-nfs/tests/apple_double_codec.rs @@ -0,0 +1,319 @@ +//! The AppleDouble image codec on its own: what a macOS client's images +//! decode to, and that a decoded one encodes back to the very same bytes. +use layerfs_nfs::apple_double_codec::{Attribute, Fork, Image, IMAGE_UNIT}; + +const FILLER_AT: usize = 8; +const COUNT_AT: usize = 24; +const FINDER_TAG_AT: usize = 26; +const FINDER_ENTRY_AT: usize = 30; +const FINDER_ENTRY_LEN_AT: usize = 34; +const FORK_TAG_AT: usize = 38; +const FORK_AT: usize = 42; +const FORK_LEN_AT: usize = 46; +const FINDER_AT: usize = 50; +const ATTR_AT: usize = 84; +const ATTR_TAG_AT: usize = ATTR_AT + 4; +const ATTR_FORK_AT: usize = ATTR_AT + 8; +const ATTR_DATA_AT: usize = ATTR_AT + 12; +const ATTR_DATA_LEN_AT: usize = ATTR_AT + 16; +const ATTR_COUNT_AT: usize = ATTR_AT + 34; +const ENTRIES_AT: usize = ATTR_AT + 36; + +fn pattern(seed: u32, length: usize) -> Vec { + (0..length) + .map(|n| (n as u32).wrapping_mul(31).wrapping_add(seed * 97) as u8) + .collect() +} +fn image(finder: [u8; 32], tag: u32, attrs: &[(&[u8], Vec)]) -> Image { + let attrs = attrs + .iter() + .map(|(name, value)| Attribute::new(name, value)) + .collect(); + Image::new(finder, tag, attrs).expect("attributes an entry can describe") +} +fn get32(bytes: &[u8], at: usize) -> u32 { + u32::from_be_bytes(bytes[at..at + 4].try_into().unwrap()) +} +fn put32(bytes: &mut [u8], at: usize, value: u32) { + bytes[at..at + 4].copy_from_slice(&value.to_be_bytes()); +} +fn get16(bytes: &[u8], at: usize) -> u16 { + u16::from_be_bytes(bytes[at..at + 2].try_into().unwrap()) +} +/// The decoded form of `image`, required to encode back to the same bytes. +fn whole(image: &Image) -> Vec { + let bytes = image.encode(); + let decoded = Image::compact(&bytes).expect("a whole image decodes"); + assert_eq!(decoded.encode(), bytes, "decoded form re-encodes the image"); + assert_eq!(decoded.finder_info(), image.finder_info()); + assert_eq!(decoded.fork(), image.fork()); + assert_eq!(decoded.len(), bytes.len()); + bytes +} +/// Where the first attribute entry's name ends: its NUL byte. +fn first_name_end(name_len: usize) -> usize { + ENTRIES_AT + 11 + name_len +} + +#[test] +fn any_window_of_the_image_encodes_to_that_window() { + // An image the client would write and decode: attributes whose names end + // on every alignment, values of several sizes, a padding byte the client + // left behind and its own empty resource fork. + let attrs: &[(&[u8], Vec)] = &[ + (b"user.a", pattern(11, 1)), + (b"com.example.long-name", pattern(12, 300)), + (b"user.c", pattern(13, 0)), + (b"com.apple.provenance", pattern(14, 40)), + (b"user.tail", pattern(15, 1000)), + ]; + let mut bytes = image([0x5a; 32], 0x0123_4567, attrs).encode(); + bytes[first_name_end(b"user.a".len()) + 1] = 0x3d; + let built = Image::compact(&bytes).expect("the image decodes"); + assert_eq!(built.encode(), bytes, "the whole image is unchanged"); + let len = bytes.len(); + let window = |start: usize, end: usize| { + let start = start.min(len); + let end = end.max(start).min(len); + bytes[start..end].to_vec() + }; + // Every window, in and past the image, byte for byte the same as the + // whole encoding: the header, each entry's offset, length and name, the + // padding after a name, each value, and the fork. + for start in (0..=len + 1).step_by(37) { + assert_eq!(built.encode_range(start, len + 1), window(start, len + 1)); + for end in (start..=len + 1).step_by(41) { + assert_eq!( + built.encode_range(start, end), + window(start, end), + "window {start}..{end} of {len} bytes" + ); + } + } + // An empty window, and a window that starts past the image. + assert_eq!(built.encode_range(0, 0), Vec::::new()); + assert_eq!(built.encode_range(len / 2, len / 2), Vec::::new()); + assert_eq!(built.encode_range(len + 10, len + 20), Vec::::new()); + assert_eq!(built.encode_range(7, 3), Vec::::new()); + assert_eq!(built.encode_range(0, len + 10), bytes); + assert_eq!( + built.encode_range(len - 1, len + 10), + bytes[len - 1..].to_vec() + ); + // The fork's own bytes are not all zero: a window inside it is served + // from the fork, not from the zeroed layout. + let fork_at = get32(&bytes, FORK_AT) as usize; + assert!(bytes[fork_at..].iter().any(|byte| *byte != 0)); + assert_eq!( + built.encode_range(fork_at, len), + bytes[fork_at..].to_vec(), + "the empty resource fork is part of the window" + ); +} + +#[test] +fn values_of_every_size_round_trip() { + for size in [0, 1, 4096, 64 * 1024, 100 * 1024] { + let value = pattern(3, size); + let name = format!("user.size-{size}"); + let attrs: &[(&[u8], Vec)] = &[(name.as_bytes(), value)]; + let built = image([1; 32], 0, attrs); + let bytes = whole(&built); + assert_eq!( + bytes.len() % IMAGE_UNIT, + 0, + "an image is whole {IMAGE_UNIT}-byte units" + ); + assert!(bytes.len() >= size); + let decoded = Image::compact(&bytes).unwrap(); + assert_eq!(decoded.attributes()[0].value.len(), size); + assert_eq!(&decoded.attributes()[0].value, &attrs[0].1); + assert_eq!(&decoded.attributes()[0].name, &attrs[0].0); + assert!(decoded.cost() >= size); + } +} + +#[test] +fn many_attributes_and_finder_info_round_trip() { + let finder = [9u8; 32]; + let attrs: Vec<(Vec, Vec)> = (0..12) + .map(|n| { + ( + format!("user.attr-{n:02}").into_bytes(), + pattern(n, 7 + 13 * n as usize), + ) + }) + .collect(); + let mut with_std = vec![ + (b"com.apple.provenance".to_vec(), pattern(21, 40)), + (b"com.apple.quarantine".to_vec(), pattern(22, 150)), + (b"com.apple.FinderInfo".to_vec(), finder.to_vec()), + ]; + with_std.extend(attrs); + let borrowed: Vec<(&[u8], Vec)> = with_std + .iter() + .map(|(name, value)| (name.as_slice(), value.clone())) + .collect(); + let built = image(finder, 0x2a2a_2a2a, &borrowed); + let bytes = whole(&built); + let decoded = Image::compact(&bytes).unwrap(); + assert_eq!(decoded.finder_info(), finder); + let names: Vec> = decoded + .attributes() + .iter() + .map(|attr| attr.name.clone()) + .collect(); + let expected: Vec> = with_std.iter().map(|(name, _)| name.clone()).collect(); + assert_eq!(names, expected, "entry order is kept"); + for (attr, (_, value)) in decoded.attributes().iter().zip(&with_std) { + assert_eq!(&attr.value, value); + } +} + +#[test] +fn the_clients_alignment_padding_is_kept() { + // A client that rewrote a shorter name does not clear what the longer one + // left behind: the bytes after the NUL stay, and the image must still + // decode to itself. + let attrs: &[(&[u8], Vec)] = &[ + (b"com.example.k4", pattern(5, 32)), + (b"user.other", pattern(6, 8)), + ]; + let mut bytes = image([2; 32], 0, attrs).encode(); + let name_end = first_name_end(b"com.example.k4".len()); + bytes[name_end + 1] = 0x5c; + bytes[name_end + 2] = 0x00; + let decoded = Image::compact(&bytes).expect("kept padding still decodes"); + assert_eq!( + decoded.encode(), + bytes, + "the padding is part of the decoded image" + ); + // A byte the layout leaves unused is not: such an image stays as written. + let mut foreign = bytes.clone(); + let fork_at = get32(&foreign, FORK_AT) as usize; + let data_len = get32(&foreign, ATTR_DATA_LEN_AT) as usize; + let data_start = get32(&foreign, ATTR_DATA_AT) as usize; + foreign[data_start + data_len..fork_at].fill(0x7f); + assert!( + Image::compact(&foreign).is_none(), + "a byte the decoded form does not keep is not claimed" + ); + assert!( + Image::parse(&foreign).is_some(), + "the fields still parse, only the round trip does not hold" + ); +} + +#[test] +fn a_resource_fork_is_left_as_the_client_wrote_it() { + // The client's own empty fork is part of the layout and decodes. + let built = image([3; 32], 0, &[(b"user.a", pattern(7, 16))]); + let bytes = whole(&built); + assert_eq!(Image::compact(&bytes).unwrap().fork(), Fork::Blank); + // The same entry holding other bytes is a real resource fork: the body is + // kept as written, so no fork byte is lost. + let mut fork_data = bytes.clone(); + fork_data[bytes.len() - 286..].fill(0x5a); + assert!(Image::parse(&fork_data).is_some()); + assert!(Image::compact(&fork_data).is_none()); + // A fork of another length is not the layout this codec describes. + let mut longer = bytes.clone(); + put32(&mut longer, FORK_LEN_AT, 300); + assert!(Image::parse(&longer).is_none()); + // An image with a zero-length fork entry decodes too. + let fork_at = get32(&bytes, FORK_AT) as usize; + let mut bare = bytes[..fork_at].to_vec(); + put32(&mut bare, FORK_LEN_AT, 0); + let decoded = Image::compact(&bare).expect("a fork-free image decodes"); + assert_eq!(decoded.fork(), Fork::None); + assert_eq!(decoded.encode(), bare); +} + +#[test] +fn malformed_images_are_not_decoded() { + let good = image( + [4; 32], + 0, + &[(b"user.a", pattern(8, 32)), (b"user.b", pattern(9, 4))], + ) + .encode(); + let fork_at = get32(&good, FORK_AT) as usize; + let data_start = get32(&good, ATTR_DATA_AT) as usize; + let mut cases: Vec<(&str, Vec)> = vec![ + ("empty", Vec::new()), + ("one byte", vec![0]), + ("a truncated header", good[..ENTRIES_AT - 1].to_vec()), + ("a truncated value", good[..data_start + 4].to_vec()), + ("a truncated image", good[..good.len() - 1].to_vec()), + ("an extended image", [good.clone(), vec![0]].concat()), + ]; + let mut each = |name: &'static str, at: usize, value: u32| { + let mut bytes = good.clone(); + put32(&mut bytes, at, value); + cases.push((name, bytes)); + }; + each("another magic", 0, 0x0005_1608); + each("another version", 4, 0x0003_0000); + each("another entry count", COUNT_AT, 3); + each("another FinderInfo tag", FINDER_TAG_AT, 8); + each("another FinderInfo offset", FINDER_ENTRY_AT, 51); + each("another FinderInfo length", FINDER_ENTRY_LEN_AT, 32); + each("another fork tag", FORK_TAG_AT, 1); + each( + "a fork before the entries", + FORK_AT, + (ENTRIES_AT - 1) as u32, + ); + each("a fork past the image", FORK_AT, (good.len() + 1) as u32); + each("another fork length", FORK_LEN_AT, 285); + each("another ATTR magic", ATTR_AT, 0x4154_5453); + each("another ATTR fork", ATTR_FORK_AT, (fork_at - 1) as u32); + each( + "a data start past the fork", + ATTR_DATA_AT, + (fork_at + 1) as u32, + ); + each("a longer data length", ATTR_DATA_LEN_AT, 1024); + each("another entry count", ATTR_COUNT_AT, 3); + each("another value offset", ENTRIES_AT, (data_start + 1) as u32); + let mut filler = good.clone(); + filler[FILLER_AT..FILLER_AT + 16].copy_from_slice(b"Mac OS "); + cases.push(("another filler", filler)); + let mut unterminated = good.clone(); + *unterminated + .get_mut(first_name_end(b"user.a".len())) + .unwrap() = b'X'; + cases.push(("a name without its NUL", unterminated)); + let mut nameless = good.clone(); + let name_len_at = ENTRIES_AT + 10; + assert_eq!(nameless[name_len_at], (b"user.a".len() + 1) as u8); + nameless[name_len_at] = 1; + cases.push(("an empty name", nameless)); + for (name, bytes) in cases { + assert!( + Image::compact(&bytes).is_none(), + "{name} is not claimed as a whole image" + ); + } +} + +#[test] +fn an_image_the_client_would_write_has_whole_units() { + let built = image([6; 32], 0, &[]); + let bytes = built.encode(); + assert_eq!(bytes.len() % IMAGE_UNIT, 0); + assert_eq!(bytes.len(), IMAGE_UNIT, "the smallest image is one unit"); + assert_eq!(get16(&bytes, COUNT_AT), 2); + assert_eq!(get32(&bytes, ATTR_TAG_AT), 0); + assert_eq!( + get32(&bytes, ATTR_DATA_AT) as usize, + ENTRIES_AT, + "no attribute, no entry" + ); + assert_eq!(bytes[FINDER_AT..FINDER_AT + 32], [6; 32]); + // An image whose FinderInfo the client filled and whose tag is its own. + let tagged = image([7; 32], 0x1234_5678, &[]); + let bytes = whole(&tagged); + assert_eq!(get32(&bytes, ATTR_TAG_AT), 0x1234_5678); +} diff --git a/engine/crates/layerfs-nfs/tests/apple_double_decode.rs b/engine/crates/layerfs-nfs/tests/apple_double_decode.rs new file mode 100644 index 0000000000..d309dda38d --- /dev/null +++ b/engine/crates/layerfs-nfs/tests/apple_double_decode.rs @@ -0,0 +1,1862 @@ +//! AppleDouble companions decoded into their main inode's own record: a +//! `._` the client writes is served byte for byte, takes no slot of the +//! index bound, is shared by every name of the inode, follows the inode +//! through RENAME and goes with its last name. A body that is not a whole +//! image (a resource fork, another layout, a half-written one) is stored as +//! the client wrote it, which is the #636 fallback. +#[allow(dead_code)] +#[path = "support/client.rs"] +mod client; +#[allow(dead_code)] +#[path = "support/rig.rs"] +mod rig; +#[allow(dead_code)] +#[path = "support/spy.rs"] +mod spy; +#[allow(dead_code)] +#[path = "support/tree.rs"] +mod tree; +use client::{Client, Set, NOENT, STALE}; +use layerfs_nfs::apple_double::SERIALS; +use layerfs_nfs::apple_double_codec::{Attribute, Image}; +use std::{ + fs, + net::TcpListener, + path::{Path, PathBuf}, + time::Duration, +}; + +const NOSPC: u32 = 28; +const UID: u32 = 501; +const GID: u32 = 20; + +fn temp(label: &str) -> PathBuf { + std::env::temp_dir().join(format!("layerfs-nfs-ad{}-{label}", std::process::id())) +} +fn source(root: &Path) { + fs::create_dir_all(root.join("docs")).unwrap(); + fs::write(root.join("README.md"), b"# fixture\nhello nfs\n").unwrap(); + fs::write(root.join("docs/guide.md"), b"guide\n").unwrap(); +} +fn pattern(seed: u32, length: usize) -> Vec { + (0..length) + .map(|n| (n as u32).wrapping_mul(31).wrapping_add(seed * 97) as u8) + .collect() +} +/// The image a macOS client writes for these attributes. +fn image(finder: [u8; 32], attrs: &[(&[u8], Vec)]) -> Vec { + let attrs = attrs + .iter() + .map(|(name, value)| Attribute::new(name, value)) + .collect(); + Image::new(finder, 0, attrs) + .expect("an entry can describe these attributes") + .encode() +} + +#[test] +fn an_image_whose_attributes_cost_more_than_its_bytes_is_kept_as_written() { + let base = temp("decode-costly"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.touch(&root, b"f", 0o644).unwrap(); + let ad = c.touch(&root, b"._f", 0o644).unwrap(); + // Many one-byte names with empty values: a whole image the client could + // write, whose decoded attributes would be counted at several times its + // bytes. + let names: Vec<[u8; 2]> = (0..600u16) + .map(|n| [b'a' + (n % 26) as u8, (n / 26) as u8 + b'a']) + .collect(); + let attrs: Vec<(&[u8], Vec)> = names.iter().map(|name| (&name[..], Vec::new())).collect(); + let bytes = image([0x22; 32], &attrs); + let decoded = Image::compact(&bytes).expect("a whole image"); + assert!( + decoded.cost() > bytes.len(), + "{} <= {}", + decoded.cost(), + bytes.len() + ); + c.write(&ad.handle, 0, &bytes).unwrap(); + let held = server.held(); + assert_eq!((held.companions, held.companions_decoded), (1, 0)); + assert_eq!(held.companion_bytes, bytes.len(), "charged at its length"); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), bytes); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_whole_image_is_read_back_as_written_from_every_name_of_the_inode() { + let base = temp("decode"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // What `cp` does: the data file, then its companion with the attributes. + let main = c.touch(&root, b"f", 0o644).unwrap(); + c.write(&main.handle, 0, b"the data file").unwrap(); + let ad = c.touch(&root, b"._f", 0o644).unwrap(); + let finder = [0x11; 32]; + let first = image( + finder, + &[ + (b"com.apple.provenance", pattern(1, 40)), + (b"com.apple.quarantine", pattern(2, 150)), + (b"com.apple.FinderInfo", finder.to_vec()), + (b"user.custom", pattern(3, 4096)), + ], + ); + c.write(&ad.handle, 0, &first).unwrap(); + assert_eq!(c.getattr(&ad.handle).unwrap().size, first.len() as u64); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), first); + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (1, 1, 0), + "a whole image is decoded and takes no slot" + ); + // The decoded form is memory the budget sees: its names and values, the + // 4 KiB one included, are what it is counted as. + assert!(held.companion_bytes >= 4096); + + // A second name of the same inode reads the same companion. + c.link(&main.handle, &root, b"g").unwrap(); + let (alias, attr) = c.lookup(&root, b"._g").unwrap(); + assert_eq!(alias, ad.handle, "hard links share one companion"); + assert_eq!(attr.size, first.len() as u64); + assert_eq!(c.read_all(&alias, 64 * 1024), first); + + // A write under the alias changes the inode's attributes for every name. + let second = image( + [0x22; 32], + &[ + (b"com.apple.provenance", pattern(4, 40)), + (b"user.custom", pattern(5, 100 * 1024)), + ], + ); + c.write(&alias, 0, &second).unwrap(); + assert_eq!(c.read_all(&ad.handle, 256 * 1024), second); + + // RENAME of the main file carries the companion to the new name. + c.rename(&root, b"f", &root, b"h").unwrap(); + let (renamed, _) = c.lookup(&root, b"._h").unwrap(); + assert_eq!(renamed, ad.handle); + assert_eq!(c.read_all(&renamed, 256 * 1024), second); + + // The companion goes with the inode's last name, not with one name. + c.remove(&root, b"h").unwrap(); + assert_eq!(server.held().companions, 1, "g still names the inode"); + assert_eq!(c.read_all(&alias, 256 * 1024), second); + c.remove(&root, b"g").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.getattr(&alias), Err(STALE)); + assert_eq!(c.lookup(&root, b"._h").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +/// The companions whose bodies the spill directory holds, by serial. +fn spill_serials(dir: &Path) -> Vec { + let mut serials: Vec = fs::read_dir(dir) + .map(|entries| { + entries + .flatten() + .filter_map(|entry| { + entry.file_type().ok().filter(std::fs::FileType::is_file)?; + entry.file_name().to_str()?.parse().ok() + }) + .collect() + }) + .unwrap_or_default(); + serials.sort_unstable(); + serials +} + +#[test] +fn a_read_racing_a_truncation_is_a_short_read_not_an_io_error() { + let base = temp("read-truncate"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(base.join("spill")); + // Smaller than one body, so every read of the body is a `pread` of its file. + rig.companion_resident_bytes = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut reader = Client::connect(server.local_addr(), UID, GID); + let mut writer = Client::connect(server.local_addr(), UID, GID); + let root = reader.mnt("/"); + reader.touch(&root, b"raced", 0o644).unwrap(); + let ad = reader.touch(&root, b"._raced", 0o644).unwrap(); + let body = pattern(60, 64 * 1024); + reader.write(&ad.handle, 0, &body).unwrap(); + assert_eq!(server.held().companion_bytes, 0, "the body spilled"); + + // A length read under the companion lock and the bytes read outside it can + // disagree: the truncation below may land in between. The reply is then the + // bytes the file still holds, a short read, never `NFS3ERR_IO`. + let empty = Set { + size: Some(0), + ..Set::default() + }; + for round in 0..512 { + let start = std::sync::Barrier::new(2); + let (read, truncate) = std::thread::scope(|scope| { + let read = scope.spawn(|| { + start.wait(); + reader.read_all(&ad.handle, 64 * 1024) + }); + let truncate = scope.spawn(|| { + start.wait(); + writer.setattr(&ad.handle, empty, None) + }); + (read.join().unwrap(), truncate.join().unwrap()) + }); + truncate.unwrap(); + assert!( + body.starts_with(&read), + "round {round}: {} bytes read of the body or its truncation", + read.len() + ); + // The next round starts from the whole body again: nothing else runs + // while it is written back. + writer.write(&ad.handle, 0, &body).unwrap(); + assert_eq!( + reader.getattr(&ad.handle).unwrap().size as usize, + body.len() + ); + } + + drop((reader, writer)); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn eviction_follows_the_order_of_use_not_the_shape_of_the_index() { + const HELD: usize = 64; + let base = temp("use-order"); + let tree = base.join("tree"); + source(&tree); + let spill = base.join("spill"); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(spill.clone()); + // Room for exactly 64 bodies of 16 bytes, so every body after the 64th + // takes the room of one other. + rig.companion_resident_bytes = 16 * HELD; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let body = pattern(50, 16); + let mut handles = Vec::with_capacity(HELD); + for n in 0..HELD { + c.touch(&root, format!("c{n}").as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, format!("._c{n}").as_bytes(), 0o644).unwrap(); + c.write(&ad.handle, 0, &body).unwrap(); + handles.push(ad.handle); + } + assert_eq!(server.held().companion_bytes, 16 * HELD); + assert!(spill_serials(&spill).is_empty(), "nothing is on disk yet"); + // Three bodies are read again, so they are the most recently used ones. + for n in [0, 1, 2] { + assert_eq!(c.read_all(&handles[n], 4096), body); + } + // Eight more bodies: the eight least recently used ones leave memory, in + // that order, and the three read again stay. + for n in HELD..HELD + 8 { + c.touch(&root, format!("c{n}").as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, format!("._c{n}").as_bytes(), 0o644).unwrap(); + c.write(&ad.handle, 0, &body).unwrap(); + } + let expected: Vec = (3..11).map(|n| SERIALS + n).collect(); + assert_eq!(spill_serials(&spill), expected); + assert_eq!(server.held().companion_bytes, 16 * HELD); + assert_eq!(server.held().companions, HELD + 8); + // The evicted bodies still hold their bytes, and the kept ones never left + // memory. + for n in [3, 7, 10, 0, 1, 2] { + assert_eq!(c.read_all(&handles[n], 4096), body, "companion {n}"); + } + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn the_clients_write_sequence_is_served_byte_for_byte() { + let base = temp("sequence"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + let main = c.touch(&root, b"seq", 0o644).unwrap(); + c.write(&main.handle, 0, b"data").unwrap(); + let ad = c.touch(&root, b"._seq", 0o644).unwrap(); + let whole = image( + [0x33; 32], + &[ + (b"com.apple.provenance", pattern(6, 40)), + (b"user.big", pattern(7, 4096)), + ], + ); + // The client writes the header first: a half-written image is served + // exactly as written and never claimed as a whole one. + c.write(&ad.handle, 0, &whole[..50]).unwrap(); + assert_eq!(c.getattr(&ad.handle).unwrap().size, 50); + assert_eq!(c.read_all(&ad.handle, 4096), whole[..50]); + assert_eq!(server.held().companions_decoded, 0); + // The rest arrives: the image is whole now and reads synthesize it. + c.write(&ad.handle, 50, &whole[50..]).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + assert_eq!(server.held().companions_decoded, 1); + // The decoded form is memory too: it is counted against the same resident + // budget as a body kept as written, at what its attributes cost. + let decoded = Image::compact(&whole).expect("the client's image decodes"); + assert_eq!(server.held().companion_bytes, decoded.cost()); + + // A delete and rebuild starts empty and decodes the rewrite again. + c.remove(&root, b"._seq").unwrap(); + assert_eq!(c.getattr(&ad.handle), Err(STALE)); + let again = c.touch(&root, b"._seq", 0o644).unwrap(); + assert_eq!(again.attr.size, 0); + assert_eq!( + server.held().companion_bytes, + 0, + "the removed companion gave its bytes back" + ); + assert_eq!(c.read_all(&again.handle, 4096), Vec::::new()); + let rebuilt = image( + [0x44; 32], + &[ + (b"com.apple.provenance", pattern(8, 40)), + (b"user.other", pattern(9, 64 * 1024)), + ], + ); + c.write(&again.handle, 0, &rebuilt).unwrap(); + assert_eq!(c.read_all(&again.handle, 128 * 1024), rebuilt); + let rebuilt_cost = Image::compact(&rebuilt).expect("decodes").cost(); + assert_eq!(server.held().companion_bytes, rebuilt_cost); + + // An edit that leaves the image not whole is served as written, and a + // later edit that completes it decodes again: both are the client's own + // bytes. + let mut edited = rebuilt.clone(); + edited[24..28].copy_from_slice(b"EDIT"); + c.write(&again.handle, 24, b"EDIT").unwrap(); + assert_eq!(c.read_all(&again.handle, 128 * 1024), edited); + assert_eq!(server.held().companions_decoded, 0); + assert_eq!( + server.held().companion_bytes, + edited.len(), + "a body kept as written counts its length" + ); + c.write(&again.handle, 24, &rebuilt[24..28]).unwrap(); + assert_eq!(c.read_all(&again.handle, 128 * 1024), rebuilt); + assert_eq!(server.held().companions_decoded, 1); + assert_eq!(server.held().companion_bytes, rebuilt_cost); + + // Truncating below the image is served as the client's truncation, and + // resizing back up serves zeros, as on any file. + let shrink = Set { + size: Some(64), + ..Set::default() + }; + c.setattr(&again.handle, shrink, None).unwrap(); + assert_eq!(c.read_all(&again.handle, 4096), rebuilt[..64]); + let grow = Set { + size: Some(rebuilt.len() as u64), + ..Set::default() + }; + c.setattr(&again.handle, grow, None).unwrap(); + let mut zeros = rebuilt[..64].to_vec(); + zeros.resize(rebuilt.len(), 0); + assert_eq!(c.read_all(&again.handle, 128 * 1024), zeros); + c.write(&again.handle, 0, &rebuilt).unwrap(); + assert_eq!(c.read_all(&again.handle, 128 * 1024), rebuilt); + + // The companion never reaches the Workspace. + let (entries, _) = c.list(&root, 64 * 1024, true); + assert!(entries.iter().all(|entry| !entry.name.starts_with(b"._"))); + drop(c); + let released = server.stop(); + assert_eq!(released.companions_decoded, 1); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_resource_fork_keeps_the_stored_as_written_fallback() { + let base = temp("fork"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // A file with a resource fork: the fork's entry carries 286 bytes of the + // client's own, which the decoded form does not keep. + c.touch(&root, b"rf", 0o644).unwrap(); + let ad = c.touch(&root, b"._rf", 0o644).unwrap(); + let plain = image([0x55; 32], &[(b"com.apple.provenance", pattern(10, 40))]); + let mut forked = plain.clone(); + let fork = pattern(11, 286); + forked[plain.len() - 286..].copy_from_slice(&fork); + c.write(&ad.handle, 0, &forked).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), forked); + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (1, 0, 1), + "a resource fork takes the stored-as-written path and its slot" + ); + // A companion whose main file the export never saw keeps that path too. + let _unknown = c.touch(&root, b"._no-main", 0o644).unwrap(); + let unknown = c.lookup(&root, b"._no-main").unwrap().0; + c.write(&unknown, 0, b"not an image").unwrap(); + assert_eq!(server.held().companions_slotted, 2); + + drop(c); + let released = server.stop(); + assert_eq!(released.companions_decoded, 0); + assert_eq!(released.companions_slotted, 2); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_rename_onto_an_unknown_main_keeps_the_resident_budget() { + let base = temp("rename-budget"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(base.join("spill")); + // Nearly full: a decoded image of a few hundred bytes and a written body + // of 700 bytes. + rig.companion_resident_bytes = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.touch(&root, b"a", 0o644).unwrap(); + let image_name = c.touch(&root, b"._a", 0o644).unwrap(); + let whole = image([0x31; 32], &[(b"user.small", pattern(80, 64))]); + c.write(&image_name.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions_decoded, 1); + c.touch(&root, b"b", 0o644).unwrap(); + let other = c.touch(&root, b"._b", 0o644).unwrap(); + c.write(&other.handle, 0, &pattern(81, 700)).unwrap(); + let before = server.held(); + assert!(before.companion_bytes <= 1024, "{}", before.companion_bytes); + + // Onto a name whose main file the export does not know: the decoded body is + // the client's bytes again, which the budget does not take, so it leaves + // memory first and the rename still happens. + c.rename(&root, b"._a", &root, b"._zzz").unwrap(); + let after = server.held(); + assert_eq!( + after.companion_bytes, 700, + "only the written body takes the budget: the image left memory" + ); + assert_eq!(after.companions_decoded, 0); + let (moved, attr) = c.lookup(&root, b"._zzz").unwrap(); + assert_eq!(attr.size as usize, whole.len()); + assert_eq!(c.read_all(&moved, 64 * 1024), whole); + assert_eq!(c.lookup(&root, b"._a").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_of_a_main_file_the_name_index_missed_is_kept() { + let base = temp("orphan-live"); + let tree = base.join("tree"); + source(&tree); + // The main file is part of the tree the export is initialized from, and + // this export never looks its name up, so its name index does not hold it: + // the companion created for it has no main inode, which the export's own + // index reads as an orphan. + fs::write(tree.join("live"), b"the data file").unwrap(); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // One slot, so the next CREATE has to reclaim before it can ask. + rig.companions_held = 1; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let ad = c.touch(&root, b"._live", 0o644).unwrap(); + let whole = image([0x51; 32], &[(b"user.kept", pattern(90, 128))]); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + + // The bound is full, so the next CREATE reclaims the orphan slots first. + // The main file is there, so the lookup keeps the companion and binds it to + // that inode, and the CREATE is then refused. + c.touch(&root, b"other", 0o644).unwrap(); + assert_eq!(c.touch(&root, b"._other", 0o644).map(|_| ()), Err(NOSPC)); + let held = server.held(); + assert_eq!((held.companions, held.companions_slotted), (1, 1)); + assert_eq!(held.names_refused, 1); + assert_eq!(c.getattr(&ad.handle).unwrap().size as usize, whole.len()); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole, "attributes kept"); + + // It belongs to that inode now: another name of the inode reaches it. + let live = c.lookup(&root, b"live").unwrap().0; + c.link(&live, &root, b"alias").unwrap(); + let (shared, attr) = c.lookup(&root, b"._alias").unwrap(); + assert_eq!(shared, ad.handle, "hard links share one companion"); + assert_eq!(attr.size as usize, whole.len()); + assert_eq!(c.read_all(&shared, 64 * 1024), whole); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_bound_back_to_its_main_file_survives_the_next_reclaim() { + let base = temp("orphan-bound"); + let tree = base.join("tree"); + source(&tree); + // As in the test above: the main file is part of the tree the export was + // initialized from, and never looked up, so the companion starts with no + // main inode and takes the one slot. + fs::write(tree.join("live"), b"the data file").unwrap(); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 1; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let ad = c.touch(&root, b"._live", 0o644).unwrap(); + let whole = image([0x52; 32], &[(b"user.kept", pattern(91, 128))]); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + + // The bound is full, so this CREATE reclaims first: the lookup finds the + // main file, the companion becomes that inode's, and the name the visit + // found is the export's one reference (not a second one it never gives + // back). The CREATE is then refused. + c.touch(&root, b"other", 0o644).unwrap(); + let lookups = server.held().lookups; + assert_eq!(c.touch(&root, b"._other", 0o644).map(|_| ()), Err(NOSPC)); + assert_eq!(server.held().lookups, lookups + 1, "one reference, kept"); + assert_eq!(server.held().companions_slotted, 1); + + // A second reclamation runs without the client ever looking the main file + // up: the bound companion holds a name in the export's table now, so it is + // not an orphan, and its attributes stay. + c.touch(&root, b"other2", 0o644).unwrap(); + let lookups = server.held().lookups; + assert_eq!(c.touch(&root, b"._other2", 0o644).map(|_| ()), Err(NOSPC)); + assert_eq!( + server.held().lookups, + lookups, + "the live name needs no visit" + ); + assert_eq!(server.held().companions, 1); + assert_eq!(server.held().companions_slotted, 1); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole, "attributes kept"); + + // It follows that inode: it goes with the inode's last name. + c.remove(&root, b"live").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.getattr(&ad.handle), Err(STALE)); + assert_eq!(c.lookup(&root, b"._live").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_write_that_takes_the_last_slot_is_refused_by_the_bound() { + let base = temp("write-bound"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // Two slots, reached through WRITE and not through CREATE: each companion + // is created as a whole image, which takes none, and then broken by a write + // that leaves it not whole, which takes one. + rig.companions_held = 2; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let mut images = Vec::new(); + for i in 0..3 { + c.touch(&root, format!("m{i}").as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, format!("._m{i}").as_bytes(), 0o644).unwrap(); + let whole = image( + [i as u8 + 1; 32], + &[(b"user.value", pattern(70 + i, 512 + i as usize))], + ); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + images.push((ad.handle, whole)); + } + assert_eq!(server.held().companions, 3); + assert_eq!( + server.held().companions_slotted, + 0, + "no companion takes a slot" + ); + // Two writes that break an image take the two slots. + for (taken, (handle, _)) in images.iter().take(2).enumerate() { + c.write(handle, 24, b"EDIT").unwrap(); + assert_eq!(server.held().companions_slotted, taken + 1); + } + // The third would take one more, and the bound has none: the whole write is + // refused, and no companion loses a byte. + assert_eq!(c.write(&images[2].0, 24, b"EDIT").map(|_| ()), Err(NOSPC)); + assert_eq!(server.held().companions, 3, "no companion was dropped"); + assert_eq!(server.held().companions_slotted, 2); + for (handle, whole) in &images { + assert_eq!(c.getattr(handle).unwrap().size as usize, whole.len()); + } + assert_eq!( + c.read_all(&images[2].0, 64 * 1024), + images[2].1, + "the refused companion still holds its image" + ); + for (handle, whole) in images.iter().take(2) { + let mut broken = whole.clone(); + broken[24..28].copy_from_slice(b"EDIT"); + assert_eq!(c.read_all(handle, 64 * 1024), broken); + } + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn whole_images_take_no_slot_of_the_index_bound() { + let base = temp("slots"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // Two slots, and a body budget small enough that raw bodies spill. + rig.companions_held = 2; + rig.companion_resident_bytes = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // More whole images than slots: every one is accepted. + let mut images = Vec::new(); + for i in 0..5 { + let main = format!("live-{i}"); + c.touch(&root, main.as_bytes(), 0o644).unwrap(); + let ad = c + .touch(&root, format!("._{main}").as_bytes(), 0o644) + .unwrap(); + let bytes = image( + [0; 32], + &[(b"user.value", format!("value-{i}").into_bytes())], + ); + c.write(&ad.handle, 0, &bytes).unwrap(); + images.push((ad.handle, bytes)); + } + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (5, 5, 0) + ); + assert_eq!(held.names_refused, 0); + + // Bodies that are not whole images do take slots: the bound still answers + // NOSPC once they fill it, and its rate-limited log is the same. + for i in 0..2 { + let main = format!("raw-{i}"); + c.touch(&root, main.as_bytes(), 0o644).unwrap(); + let ad = c + .touch(&root, format!("._{main}").as_bytes(), 0o644) + .unwrap(); + c.write(&ad.handle, 0, b"stored as written").unwrap(); + } + assert_eq!(server.held().companions_slotted, 2); + c.touch(&root, b"raw-extra", 0o644).unwrap(); + assert_eq!( + c.touch(&root, b"._raw-extra", 0o644).map(|_| ()), + Err(NOSPC) + ); + assert_eq!(server.held().names_refused, 1); + // Removing a raw companion's main file frees its slot, and a new whole + // image is then accepted again without taking one. + c.remove(&root, b"raw-0").unwrap(); + assert_eq!(server.held().companions_slotted, 1); + c.touch(&root, b"new-image", 0o644).unwrap(); + let ad = c.touch(&root, b"._new-image", 0o644).unwrap(); + let fresh = image([1; 32], &[(b"user.fresh", pattern(20, 64))]); + c.write(&ad.handle, 0, &fresh).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + assert_eq!(server.held().names_refused, 1); + assert_eq!(c.read_all(&ad.handle, 4096), fresh); + // The refused raw companion now fits. + c.touch(&root, b"._raw-extra", 0o644).unwrap(); + assert_eq!(server.held().companions_slotted, 2); + // Every whole image still reads back byte for byte. + for (handle, bytes) in &images { + assert_eq!(&c.read_all(handle, 64 * 1024), bytes); + } + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_decoded_companion_is_gone_once_its_inode_is_silly_renamed() { + let base = temp("silly"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let main = c.touch(&root, b"open", 0o644).unwrap(); + c.write(&main.handle, 0, b"still open").unwrap(); + let ad = c.touch(&root, b"._open", 0o644).unwrap(); + let bytes = image([2; 32], &[(b"user.a", pattern(12, 32))]); + c.write(&ad.handle, 0, &bytes).unwrap(); + assert_eq!(server.held().companions_decoded, 1); + // A client that unlinks a file it keeps open renames it to a silly name. + let silly: &[u8] = b".nfs.20051025.b896"; + c.rename(&root, b"open", &root, silly).unwrap(); + assert_eq!(server.held().companions, 0, "the last name went"); + assert_eq!(c.getattr(&ad.handle), Err(STALE)); + c.remove(&root, silly).unwrap(); + assert_eq!(c.lookup(&root, silly).map(|_| ()), Err(NOENT)); + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_replaced_main_file_takes_its_companion_with_it() { + let base = temp("replace"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.touch(&root, b"dst", 0o644).unwrap(); + c.touch(&root, b"src", 0o644).unwrap(); + let dst = c.touch(&root, b"._dst", 0o644).unwrap(); + c.write( + &dst.handle, + 0, + &image([3; 32], &[(b"user.dst", pattern(13, 16))]), + ) + .unwrap(); + let src = c.touch(&root, b"._src", 0o644).unwrap(); + c.write( + &src.handle, + 0, + &image([4; 32], &[(b"user.src", pattern(14, 16))]), + ) + .unwrap(); + assert_eq!(server.held().companions_decoded, 2); + // RENAME over the destination detaches it as an unlink would. + c.rename(&root, b"src", &root, b"dst").unwrap(); + assert_eq!(c.getattr(&dst.handle), Err(STALE)); + assert_eq!(server.held().companions_decoded, 1, "only src's is left"); + // The client moves the source's companion to the destination's name. + c.rename(&root, b"._src", &root, b"._dst").unwrap(); + let (moved, _) = c.lookup(&root, b"._dst").unwrap(); + assert_eq!(moved, src.handle); + assert_eq!( + c.read_all(&moved, 4096), + image([4; 32], &[(b"user.src", pattern(14, 16))]) + ); + c.remove(&root, b"dst").unwrap(); + assert_eq!(server.held().companions, 0); + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn eviction_takes_the_decoded_body_before_the_written_ones() { + let base = temp("decoded-evict"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(base.join("spill")); + // Room for two 2,000-byte bodies and one decoded image of a few hundred + // bytes. + rig.companion_resident_bytes = 4096; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // A whole image, decoded: it costs its attributes, not its 4 KiB. + let whole = image([0x21; 32], &[(b"com.apple.provenance", pattern(40, 40))]); + c.touch(&root, b"old", 0o644).unwrap(); + let old = c.touch(&root, b"._old", 0o644).unwrap(); + c.write(&old.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions_decoded, 1); + let decoded_cost = server.held().companion_bytes; + assert!( + decoded_cost < 4096, + "the image is counted as its attributes" + ); + + // Two bodies kept as written fill the budget: the decoded body is the least + // recently used memory there is, so it is the one spilled, and its file + // holds the image the client wrote. + let first = pattern(41, 2000); + let second = pattern(42, 2000); + c.touch(&root, b"one", 0o644).unwrap(); + let one = c.touch(&root, b"._one", 0o644).unwrap(); + c.write(&one.handle, 0, &first).unwrap(); + c.touch(&root, b"two", 0o644).unwrap(); + let two = c.touch(&root, b"._two", 0o644).unwrap(); + c.write(&two.handle, 0, &second).unwrap(); + assert_eq!( + server.held().companions_decoded, + 0, + "the decoded body was the memory evicted" + ); + assert_eq!(server.held().companion_bytes, 4000); + assert_eq!( + c.read_all(&old.handle, 64 * 1024), + whole, + "from its spill file" + ); + assert_eq!(c.read_all(&one.handle, 64 * 1024), first); + assert_eq!(c.read_all(&two.handle, 64 * 1024), second); + assert_eq!(c.getattr(&old.handle).unwrap().size as usize, whole.len()); + + drop(c); + let released = server.stop(); + assert_eq!(released.companions_decoded, 0); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_decoded_companion_is_edited_under_a_full_resident_budget() { + let base = temp("decoded-budget"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // A body budget that takes the image's attributes but not its bytes: a + // decoded image costs `Image::cost`, so it fits where its 8 KiB does not, + // and an edit that leaves the image not whole has to spill rather than grow + // memory. + rig.companion_resident_bytes = 5120; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + let main = c.touch(&root, b"full", 0o644).unwrap(); + c.write(&main.handle, 0, b"the data file").unwrap(); + let ad = c.touch(&root, b"._full", 0o644).unwrap(); + let whole = image( + [0x77; 32], + &[ + (b"com.apple.provenance", pattern(30, 40)), + (b"user.big", pattern(31, 4096)), + ], + ); + // Another companion's body stays in memory; truncating a decoded body needs + // no room for its image, so that body must not be evicted for it. + c.touch(&root, b"other", 0o644).unwrap(); + let other = c.touch(&root, b"._other", 0o644).unwrap(); + c.write(&other.handle, 0, &pattern(35, 100)).unwrap(); + assert_eq!(server.held().companion_bytes, 100); + + // A whole image costs its attributes, not its bytes: it is decoded. + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + assert_eq!(server.held().companions_decoded, 1); + + // Truncating a decoded body to nothing is the client's truncation, with no + // resident room for its image, and a rewrite decodes again. + let empty = Set { + size: Some(0), + ..Set::default() + }; + c.setattr(&ad.handle, empty, None).unwrap(); + assert_eq!(c.getattr(&ad.handle).unwrap().size, 0); + assert_eq!(c.read_all(&ad.handle, 4096), Vec::::new()); + assert_eq!(server.held().companions_decoded, 0); + assert_eq!( + server.held().companion_bytes, + 100, + "the image was never resident, so nothing had to be evicted for it" + ); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + assert_eq!(server.held().companions_decoded, 1); + + // An edit that leaves the image not whole cannot grow memory: the decoded + // body is spilled and the write applied to its file, not refused. + let mut edited = whole.clone(); + edited[24..28].copy_from_slice(b"EDIT"); + c.write(&ad.handle, 24, b"EDIT").unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), edited); + assert_eq!(server.held().companions_decoded, 0); + + // Truncating the spilled body is the client's truncation. + c.setattr(&ad.handle, empty, None).unwrap(); + assert_eq!(c.getattr(&ad.handle).unwrap().size, 0); + assert_eq!(c.read_all(&ad.handle, 4096), Vec::::new()); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_without_a_main_file_takes_a_slot_and_is_reclaimed() { + let base = temp("no-main"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 3; + // Too small for the image written below, so that write needs the spill path. + rig.companion_resident_bytes = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // A whole image under a name whose main file the export does not know is + // not decoded: it keeps the client's bytes and a slot of the index bound, + // both when it fits the resident budget and when it does not. + let small = image([0x88; 32], &[(b"user.small", pattern(32, 16))]); + c.touch(&root, b"._small", 0o644).unwrap(); + let fits = c.lookup(&root, b"._small").unwrap().0; + c.write(&fits, 0, &small).unwrap(); + assert_eq!(c.read_all(&fits, 4096), small); + let big = image([0x89; 32], &[(b"user.big", pattern(33, 4096))]); + c.touch(&root, b"._no-main", 0o644).unwrap(); + let spilled = c.lookup(&root, b"._no-main").unwrap().0; + c.write(&spilled, 0, &big).unwrap(); + assert_eq!(c.read_all(&spilled, 64 * 1024), big); + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (2, 0, 2), + "a companion with no main file is stored as written and takes its slot" + ); + + // A decoded companion renamed onto a name whose main file is unknown is no + // longer an inode's: it keeps the bytes as written and takes its slot too. + let main = c.touch(&root, b"owned", 0o644).unwrap(); + c.write(&main.handle, 0, b"owned by an inode").unwrap(); + let owned = c.touch(&root, b"._owned", 0o644).unwrap(); + c.write(&owned.handle, 0, &small).unwrap(); + assert_eq!(server.held().companions_decoded, 1); + c.rename(&root, b"._owned", &root, b"._gone").unwrap(); + assert_eq!(c.read_all(&owned.handle, 4096), small); + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (3, 0, 3), + "a companion with no main file is never a whole image" + ); + + // The bound reclaims them as orphans instead of refusing the next CREATE. + c.touch(&root, b"next", 0o644).unwrap(); + c.touch(&root, b"._next", 0o644).unwrap(); + let held = server.held(); + assert_eq!( + (held.companions, held.companions_slotted, held.names_refused), + (1, 1, 0), + "the three companions with no main file were reclaimed" + ); + assert_eq!(c.getattr(&spilled), Err(STALE)); + assert_eq!(c.getattr(&owned.handle), Err(STALE)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_spilled_body_renamed_off_its_inode_takes_its_slot() { + let base = temp("spilled-rename"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(base.join("spill-rename")); + rig.companion_resident_bytes = 512 * 1024; + rig.companions_held = 4; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // A whole image with an attribute larger than the decoded-entry bound is + // kept as written, takes no slot, and fits the resident budget. + c.touch(&root, b"m", 0o644).unwrap(); + let ad = c.touch(&root, b"._m", 0o644).unwrap(); + let whole = image( + [0x5a; 32], + &[ + (b"com.apple.provenance", pattern(40, 40)), + (b"user.bulk", pattern(41, 200 * 1024)), + ], + ); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!( + ( + server.held().companions_decoded, + server.held().companions_slotted + ), + (0, 0), + "a whole image takes no slot even when it is kept as written" + ); + + // Another companion's larger body evicts it to disk, still whole. + c.touch(&root, b"other", 0o644).unwrap(); + let other = c.touch(&root, b"._other", 0o644).unwrap(); + let stored = pattern(42, 400 * 1024); + c.write(&other.handle, 0, &stored).unwrap(); + assert_eq!(server.held().companion_bytes, stored.len()); + assert_eq!( + server.held().companions_slotted, + 1, + "only ._other takes a slot" + ); + + // RENAME onto a name whose main file the export never saw: the body stops + // being an inode's companion, so it may not keep a whole image's + // exemption from the index bound, even on disk. + c.rename(&root, b"._m", &root, b"._gone").unwrap(); + let held = server.held(); + assert_eq!( + (held.companions_decoded, held.companions_slotted), + (0, 2), + "a spilled body renamed off its inode takes its slot" + ); + assert_eq!(c.read_all(&ad.handle, 256 * 1024), whole); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn whole_images_take_no_slot_and_the_bound_reclaims_only_slots() { + let base = temp("whole-images-bound"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 2; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // Two companions that decode into whole images: neither takes a slot, so a + // full table may hold any number of them. + let mut whole = Vec::new(); + for (main, seed) in [(b"a".as_slice(), 1u32), (b"b".as_slice(), 2u32)] { + let data = c.touch(&root, main, 0o644).unwrap(); + c.write(&data.handle, 0, b"data").unwrap(); + let mut name = b"._".to_vec(); + name.extend_from_slice(main); + let ad = c.touch(&root, &name, 0o644).unwrap(); + let bytes = image([seed as u8; 32], &[(b"user.small", pattern(seed, 16))]); + c.write(&ad.handle, 0, &bytes).unwrap(); + whole.push((ad.handle, bytes)); + } + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted + ), + (2, 2, 0), + "whole images take no slot" + ); + + // Both slots go to companions whose main file the export knows, so there is + // no orphan to reclaim: the bound refuses instead of touching a whole image. + for index in 0..2 { + let main = format!("live-{index}"); + let companion = format!("._live-{index}"); + c.touch(&root, main.as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, companion.as_bytes(), 0o644).unwrap(); + c.write(&ad.handle, 0, &[b'L'; 64]).unwrap(); + } + c.touch(&root, b"next", 0o644).unwrap(); + assert_eq!(c.touch(&root, b"._next", 0o644).map(|_| ()), Err(NOSPC)); + let held = server.held(); + assert_eq!( + ( + held.companions, + held.companions_decoded, + held.companions_slotted, + held.names_refused + ), + (4, 2, 2, 1), + "the refusal kept both whole images and both slots" + ); + for (handle, bytes) in &whole { + assert_eq!(c.read_all(handle, 4096), *bytes); + } + + // Freeing a slot, not a whole image, lets the next companion in. + c.remove(&root, b"._live-0").unwrap(); + c.touch(&root, b"._next", 0o644).unwrap(); + assert_eq!(server.held().companions_slotted, 2); + assert_eq!(server.held().companions, 4); + assert_eq!(server.held().companions_decoded, 2); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_rename_keeps_the_other_names_of_the_inode_companion() { + let base = temp("aliases"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + let main = c.touch(&root, b"a", 0o644).unwrap(); + c.write(&main.handle, 0, b"two names, one inode").unwrap(); + let ad = c.touch(&root, b"._a", 0o644).unwrap(); + let bytes = image([0x99; 32], &[(b"user.link", pattern(34, 64))]); + c.write(&ad.handle, 0, &bytes).unwrap(); + c.link(&main.handle, &root, b"b").unwrap(); + assert_eq!(c.lookup(&root, b"._b").unwrap().0, ad.handle); + + // RENAME moves one name of the inode: every other name still reaches the + // companion, before and after the moved name goes. + c.rename(&root, b"a", &root, b"c").unwrap(); + assert_eq!( + c.lookup(&root, b"._b").unwrap().0, + ad.handle, + "b still names the inode" + ); + assert_eq!(c.lookup(&root, b"._c").unwrap().0, ad.handle); + assert_eq!(c.read_all(&ad.handle, 4096), bytes); + c.remove(&root, b"c").unwrap(); + assert_eq!( + c.lookup(&root, b"._b").unwrap().0, + ad.handle, + "b is the inode's last name" + ); + assert_eq!(c.read_all(&ad.handle, 4096), bytes); + + // The companion goes with the inode's last name. + c.remove(&root, b"b").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.lookup(&root, b"._b").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn an_eviction_victim_that_cannot_be_written_out_does_not_fail_the_writer() { + let base = temp("victim-error"); + let tree = base.join("tree"); + source(&tree); + let spill = base.join("spill"); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(spill.clone()); + // Room for two bodies of 1,000 bytes: a third one makes the two oldest + // give their room back. + rig.companion_resident_bytes = 2000; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let mut bodies = Vec::new(); + for i in 0..2 { + c.touch(&root, format!("m{i}").as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, format!("._m{i}").as_bytes(), 0o644).unwrap(); + let body = pattern(60 + i, 1000); + c.write(&ad.handle, 0, &body).unwrap(); + bodies.push((ad.handle, body)); + } + assert_eq!(server.held().companion_bytes, 2000); + + // The oldest body's spill file is a directory with a file in it, so no + // file can be renamed onto it: evicting that body fails. + let oldest = format!("{SERIALS}"); + fs::create_dir_all(spill.join(&oldest)).unwrap(); + fs::write(spill.join(&oldest).join("kept"), b"not a spill file").unwrap(); + + // A third body needs room. The victim that cannot be written out is + // passed over, the next one gives its room back, and this call's own + // write lands: the failure belonged to a companion this writer never + // named. + c.touch(&root, b"m2", 0o644).unwrap(); + let third = c.touch(&root, b"._m2", 0o644).unwrap(); + let body = pattern(62, 1000); + c.write(&third.handle, 0, &body).unwrap(); + assert_eq!(c.read_all(&third.handle, 4096), body); + assert_eq!( + spill_serials(&spill), + vec![SERIALS + 1], + "the victim whose file cannot be written stays in memory" + ); + assert_eq!(server.held().companion_bytes, 2000); + // Both other bodies still read back byte for byte: the spilled one from + // its file, the passed-over one from memory. + for (handle, want) in &bodies { + assert_eq!(&c.read_all(handle, 4096), want); + } + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_hard_link_keeps_the_companion_under_its_other_names() { + let base = temp("hard-link"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + // What `cp` leaves: the data file and its attributes alongside. + let a = c.touch(&root, b"a", 0o644).unwrap(); + c.write(&a.handle, 0, b"the data file").unwrap(); + let ad = c.touch(&root, b"._a", 0o644).unwrap(); + let whole = image([0x61; 32], &[(b"user.kept", pattern(11, 64))]); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions, 1); + + // `ln a b`, and the client drops the `._` name of the old name it no + // longer uses: the attributes belong to the inode `b` still names, so the + // companion stays. + c.link(&a.handle, &root, b"b").unwrap(); + let (shared, attr) = c.lookup(&root, b"._b").unwrap(); + assert_eq!( + shared, ad.handle, + "the linked name reads the same companion" + ); + assert_eq!(attr.size as usize, whole.len()); + c.remove(&root, b"._a").unwrap(); + assert_eq!(server.held().companions, 1); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole, "attributes kept"); + + // `rm a`: one name of the inode goes, the companion stays with `b`. + c.remove(&root, b"a").unwrap(); + assert_eq!(server.held().companions, 1); + let (still, _) = c.lookup(&root, b"._b").unwrap(); + assert_eq!(still, ad.handle); + assert_eq!(c.read_all(&still, 64 * 1024), whole); + + // The inode's last name takes it with it. + c.remove(&root, b"b").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.lookup(&root, b"._b").map(|_| ()), Err(NOENT)); + assert_eq!(c.getattr(&ad.handle), Err(STALE)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +/// `name` and its `._` companion holding a whole image, as `cp` leaves +/// them: the main file's handle, the companion's, and the bytes written. +fn pair(c: &mut Client, root: &[u8], name: &[u8], seed: u32) -> (Vec, Vec, Vec) { + let main = c.touch(root, name, 0o644).unwrap(); + c.write(&main.handle, 0, b"the data file").unwrap(); + let mut paired = b"._".to_vec(); + paired.extend_from_slice(name); + let ad = c.touch(root, &paired, 0o644).unwrap(); + let whole = image([seed as u8; 32], &[(b"user.kept", pattern(seed, 64))]); + c.write(&ad.handle, 0, &whole).unwrap(); + (main.handle, ad.handle, whole) +} + +#[test] +fn a_removed_name_still_reaches_the_companion_of_its_inode() { + let base = temp("removed-name"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + // `cp a`, then `ln a b`: one inode behind two names, the attributes under + // `._a`. This is the matrix's g2 order: `ln`, `rm` of the original before + // the linked name was read once. + let (a, ad, whole) = pair(&mut c, &root, b"a", 13); + c.link(&a, &root, b"b").unwrap(); + c.remove(&root, b"a").unwrap(); + assert_eq!(server.held().companions, 1, "b still names the inode"); + assert_eq!(c.lookup(&root, b"a").map(|_| ()), Err(NOENT)); + + // The name is gone, the inode is not: `._a` is still the attributes of the + // file `b` names. A client that still holds `._a`, or asks for it again + // once its `actimeo` expired, reads them there instead of finding nothing. + let (named, attr) = c.lookup(&root, b"._a").unwrap(); + assert_eq!( + named, ad, + "a name of the inode that is gone still answers its `._` name" + ); + assert_eq!(attr.size as usize, whole.len()); + assert_eq!(c.read_all(&named, 64 * 1024), whole); + assert_eq!( + server.held().companions_unreachable, + 0, + "the name key reaches it" + ); + let (linked, attr) = c.lookup(&root, b"._b").unwrap(); + assert_eq!(linked, ad, "the surviving name answers it too"); + assert_eq!(attr.size as usize, whole.len()); + assert_eq!(c.read_all(&linked, 64 * 1024), whole); + assert_eq!(server.held().companions, 1); + + drop(c); + let released = server.stop(); + assert_eq!(released.companions, 1, "the last name stays to the export"); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_name_the_link_read_before_its_removal_keeps_its_companion_name() { + let base = temp("removed-name-read"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + // The matrix's g3 order: `ln`, one read of the linked name and of its `._` + // name, then `rm` of the original. + let (a, ad, whole) = pair(&mut c, &root, b"a", 14); + c.link(&a, &root, b"b").unwrap(); + let (read, _) = c.lookup(&root, b"._b").unwrap(); + assert_eq!(read, ad, "the linked name reaches the inode's companion"); + assert_eq!(c.lookup(&root, b"b").unwrap().0, a); + c.remove(&root, b"a").unwrap(); + + // Every name of the inode keeps answering, the removed one included. + let (named, _) = c.lookup(&root, b"._a").unwrap(); + assert_eq!(named, ad); + assert_eq!(c.read_all(&named, 64 * 1024), whole); + assert_eq!(c.lookup(&root, b"._b").unwrap().0, ad); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_name_asked_right_after_its_removal_still_reaches_the_companion() { + let base = temp("removed-name-after"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + // The matrix's g5 order: `ln`, `rm` of the original, the linked name read + // right after, and then the removed name's `._` name. + let (a, ad, whole) = pair(&mut c, &root, b"a", 15); + c.link(&a, &root, b"b").unwrap(); + c.remove(&root, b"a").unwrap(); + let (linked, _) = c.lookup(&root, b"b").unwrap(); + assert_eq!(linked, a, "b is the inode's remaining name"); + let (named, _) = c.lookup(&root, b"._a").unwrap(); + assert_eq!(named, ad); + assert_eq!(c.read_all(&named, 64 * 1024), whole); + assert_eq!(c.lookup(&root, b"._b").unwrap().0, ad); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_new_file_under_a_removed_name_does_not_reach_the_old_companion() { + let base = temp("removed-name-reused"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let (a, ad, whole) = pair(&mut c, &root, b"a", 16); + c.link(&a, &root, b"b").unwrap(); + c.remove(&root, b"a").unwrap(); + + // Another inode takes the freed name. The `._a` name the old companion + // still holds is the one the inode that had it answers, not this file `a` + // is now: `Companions::resolve` takes a name key only for the inode the + // companion belongs to. + let fresh = c.touch(&root, b"a", 0o644).unwrap(); + c.write(&fresh.handle, 0, b"the new data file").unwrap(); + assert_eq!( + c.lookup(&root, b"._a").map(|_| ()), + Err(NOENT), + "the new file `a` has no attributes yet" + ); + // The old attributes are still the file `b` names, and the old body is + // untouched by the file that took the name. + let (kept, _) = c.lookup(&root, b"._b").unwrap(); + assert_eq!(kept, ad); + assert_eq!(c.read_all(&kept, 64 * 1024), whole); + + // A companion created under the name is the new inode's: it starts empty + // and never reads the old body. + let new_ad = c.touch(&root, b"._a", 0o644).unwrap(); + assert_ne!(new_ad.handle, ad, "another companion for another inode"); + assert_eq!(c.getattr(&new_ad.handle).unwrap().size, 0); + let fresh_whole = image([0x17; 32], &[(b"user.new", pattern(17, 32))]); + c.write(&new_ad.handle, 0, &fresh_whole).unwrap(); + assert_eq!(c.read_all(&new_ad.handle, 64 * 1024), fresh_whole); + assert_eq!(server.held().companions, 2); + assert_eq!(c.lookup(&root, b"._b").unwrap().0, ad); + assert_eq!(c.read_all(&ad, 64 * 1024), whole); + + // The old inode's last name takes only the old companion and the `._a` + // name it held, so the new file's attributes stay. + c.remove(&root, b"b").unwrap(); + assert_eq!(server.held().companions, 1, "only the new file's companion"); + assert_eq!(c.getattr(&ad), Err(STALE)); + assert_eq!(c.lookup(&root, b"._b").map(|_| ()), Err(NOENT)); + assert_eq!(c.lookup(&root, b"._a").unwrap().0, new_ad.handle); + assert_eq!(c.read_all(&new_ad.handle, 64 * 1024), fresh_whole); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn the_last_name_of_a_hard_link_reclaims_its_companion_and_every_name_key() { + let base = temp("removed-name-last"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let (a, ad, whole) = pair(&mut c, &root, b"a", 18); + c.link(&a, &root, b"b").unwrap(); + c.remove(&root, b"a").unwrap(); + assert_eq!(c.lookup(&root, b"._a").unwrap().0, ad); + assert_eq!(c.read_all(&ad, 64 * 1024), whole); + + // The inode's last name goes: the companion goes with it, and so does the + // `._a` name key it kept for the name that went first. + c.remove(&root, b"b").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(server.held().companions_unreachable, 0); + assert_eq!(c.getattr(&ad), Err(STALE)); + assert_eq!(c.lookup(&root, b"._a").map(|_| ()), Err(NOENT)); + assert_eq!(c.lookup(&root, b"._b").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + assert_eq!( + (released.companions, released.companions_unreachable), + (0, 0) + ); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_linked_companion_name_is_another_name_of_the_same_companion() { + let base = temp("companion-link"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let a = c.touch(&root, b"a", 0o644).unwrap(); + c.write(&a.handle, 0, b"the data file").unwrap(); + let ad = c.touch(&root, b"._a", 0o644).unwrap(); + let whole = image([0x62; 32], &[(b"user.kept", pattern(12, 80))]); + c.write(&ad.handle, 0, &whole).unwrap(); + + // What a client that carries the attributes to the new name does: the + // main file first, then its companion, one companion behind both names. + c.link(&a.handle, &root, b"b").unwrap(); + let linked = c.link(&ad.handle, &root, b"._b").unwrap(); + assert_eq!(linked.fileid, ad.attr.fileid); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + assert_eq!(server.held().companions, 1); + // A name already held is not linked again, and a companion is never + // linked onto a name of the Workspace. + assert_eq!(c.link(&ad.handle, &root, b"._b").map(|_| ()), Err(17)); + assert_eq!(c.link(&ad.handle, &root, b"plain").map(|_| ()), Err(13)); + + // The client drops the old name: the companion keeps the new one and its + // bytes, and reads through the inode as well. + c.remove(&root, b"._a").unwrap(); + assert_eq!(server.held().companions, 1); + let (kept, _) = c.lookup(&root, b"._b").unwrap(); + assert_eq!(kept, ad.handle); + assert_eq!(c.read_all(&kept, 64 * 1024), whole); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + + // An inode with one name has only one `._` name: removing it is the client + // clearing its attributes, which takes the companion. + let alone = c.touch(&root, b"alone", 0o644).unwrap(); + c.write(&alone.handle, 0, b"data").unwrap(); + let one = c.touch(&root, b"._alone", 0o644).unwrap(); + c.write(&one.handle, 0, &whole).unwrap(); + assert_eq!(server.held().companions, 2); + c.remove(&root, b"._alone").unwrap(); + assert_eq!(server.held().companions, 1); + assert_eq!(c.getattr(&one.handle), Err(STALE)); + assert_eq!(c.lookup(&root, b"._alone").map(|_| ()), Err(NOENT)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn renaming_one_linked_companion_name_moves_only_that_name() { + let base = temp("companion-link-rename"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let a = c.touch(&root, b"a", 0o644).unwrap(); + c.write(&a.handle, 0, b"the data file").unwrap(); + let ad = c.touch(&root, b"._a", 0o644).unwrap(); + let whole = image([0x63; 32], &[(b"user.kept", pattern(13, 80))]); + c.write(&ad.handle, 0, &whole).unwrap(); + // `ln a b` with the attributes carried to the new name. + c.link(&a.handle, &root, b"b").unwrap(); + c.link(&ad.handle, &root, b"._b").unwrap(); + + // `mv b c`: the main name, then its companion name. + c.rename(&root, b"b", &root, b"c").unwrap(); + c.rename(&root, b"._b", &root, b"._c").unwrap(); + + // Only `._b` moved: `._a` still names the companion, `._c` is the new + // name, and `._b` names nothing any more. + assert_eq!(c.lookup(&root, b"._a").unwrap().0, ad.handle); + assert_eq!(c.lookup(&root, b"._c").unwrap().0, ad.handle); + assert_eq!(c.lookup(&root, b"._b").map(|_| ()), Err(NOENT)); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + assert_eq!(server.held().companions, 1); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn the_slot_bound_holds_when_writes_claim_the_last_slot_together() { + const WRITERS: usize = 8; + let base = temp("slot-race"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // One slot, and a body budget smaller than the images below, so each + // breaking write spills its body and needs the slot after I/O. + rig.companions_held = 1; + rig.companion_resident_bytes = 1024; + rig.companion_spill_dir = Some(base.join("spill")); + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let address = server.local_addr(); + let mut c = Client::connect(address, UID, GID); + let root = c.mnt("/"); + let mut images = Vec::new(); + for i in 0..WRITERS { + c.touch(&root, format!("m{i}").as_bytes(), 0o644).unwrap(); + let ad = c.touch(&root, format!("._m{i}").as_bytes(), 0o644).unwrap(); + // A whole image is 4,096 bytes however small its attributes are: it + // costs a few dozen bytes of the budget and is broken by one byte of + // its header, which leaves 4,096 bytes that cannot stay resident here. + let whole = image( + [i as u8 + 7; 32], + &[(b"user.value", pattern(70 + i as u32, 64))], + ); + assert_eq!(whole.len(), 4096); + c.write(&ad.handle, 0, &whole).unwrap(); + assert_eq!(c.read_all(&ad.handle, 64 * 1024), whole); + images.push((ad.handle.clone(), whole)); + } + assert_eq!(server.held().companions, WRITERS); + assert_eq!( + server.held().companions_slotted, + 0, + "a whole image takes no slot" + ); + + // Every companion is broken at once, each on its own connection: one slot + // is free, so exactly one may take it. A bound decided before the I/O and + // taken after it lets more than one through. + let barrier = std::sync::Arc::new(std::sync::Barrier::new(WRITERS + 1)); + let writers: Vec<_> = images + .iter() + .map(|(handle, _)| { + let (barrier, mut writer) = (barrier.clone(), Client::connect(address, UID, GID)); + let handle = handle.clone(); + std::thread::spawn(move || { + barrier.wait(); + writer.write(&handle, 0, b"X").map(|_| ()) + }) + }) + .collect(); + barrier.wait(); + let results: Vec> = writers + .into_iter() + .map(|writer| writer.join().unwrap()) + .collect(); + assert_eq!( + results.iter().filter(|result| result.is_ok()).count(), + 1, + "one slot, one writer: {results:?}" + ); + assert_eq!(server.held().companions_slotted, 1, "{results:?}"); + assert_eq!(server.held().companions, WRITERS); + // The refused ones kept their image, the taken one holds the edit. + let refused = results.iter().filter(|result| result.is_err()).count(); + assert_eq!(refused, WRITERS - 1); + for (handle, whole) in &images { + let bytes = c.read_all(handle, 64 * 1024); + let mut edited = whole.clone(); + edited[0] = b'X'; + assert!( + bytes == *whole || bytes == edited, + "every companion is its image or the edit" + ); + } + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_of_a_removed_directory_is_reclaimed() { + let base = temp("orphan-dir-gone"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // One slot, and both companions below take one: a whole image whose main + // file the export never saw stays as the client wrote it. + rig.companions_held = 1; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.mkdir(&root, b"gone", 0o755).unwrap(); + let gone = c.lookup(&root, b"gone").unwrap().0; + let held = c.touch(&gone, b"._x", 0o644).unwrap(); + c.write(&held.handle, 0, &pattern(80, 64)).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + + // The client removes the directory: nothing the engine can see is in it, + // so the removal succeeds and leaves the companion it never listed behind, + // with a main file whose parent the engine no longer has. + c.rmdir(&root, b"gone").unwrap(); + assert_eq!(server.held().companions, 1); + + // The next CREATE at the bound reclaims first. The lookup of the vanished + // main file answers `NFS3ERR_STALE` (its parent is gone), which is as much + // "there is no such file" as `NFS3ERR_NOENT`, so the slot comes free and + // this CREATE lands instead of the bound staying full for good. + let made = c.touch(&root, b"._y", 0o644).unwrap(); + assert_eq!(server.held().companions, 1); + assert_eq!(server.held().companions_slotted, 1); + assert_eq!(c.getattr(&held.handle), Err(STALE)); + c.write(&made.handle, 0, &pattern(81, 32)).unwrap(); + assert_eq!(c.read_all(&made.handle, 4096), pattern(81, 32)); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_in_a_collected_directory_is_kept_while_its_main_file_is_there() { + let base = temp("orphan-collected-dir"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 1; + rig.lookups_held = 8; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let kept = c.mkdir(&root, b"kept", 0o755).unwrap().handle; + // Nothing names `x` yet, so the companion takes the one slot with no main + // inode. + let held = c.touch(&kept, b"._x", 0o644).unwrap(); + let body = pattern(83, 64); + c.write(&held.handle, 0, &body).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + + // Enough other names that the export collects its reference to `kept`. + let names = layerfs_nfs::kernel::RECENT_KEPT as usize + 32; + for index in 0..names { + let name = format!("f{index}"); + c.touch(&root, name.as_bytes(), 0o644) + .unwrap_or_else(|status| panic!("{name}: {status}")); + } + assert!(server.held().collected > 0, "{:?}", server.held()); + + // Another writer makes the main file; this export never looks it up. + let second = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut other = Client::connect(second.local_addr(), UID, GID); + let other_root = other.mnt("/"); + let (other_kept, _) = other.lookup(&other_root, b"kept").unwrap(); + other.touch(&other_kept, b"x", 0o644).unwrap(); + + // The CREATE at the bound asks the engine about `kept/x` through the + // directory resolved again, finds it and keeps the companion: the bound + // stays full and the companion keeps its bytes. + assert_eq!(c.touch(&root, b"._y", 0o644).map(|_| ()), Err(NOSPC)); + assert_eq!(c.read_all(&held.handle, 4096), body); + + drop(c); + drop(other); + let released = server.stop(); + second.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_reached_by_one_of_its_names_is_not_an_orphan() { + let base = temp("orphan-alias"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 1; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.mkdir(&root, b"d", 0o755).unwrap(); + let d = c.lookup(&root, b"d").unwrap().0; + // Nothing names `ghost`, so this companion starts with no main inode and + // takes the one slot. + let ghost = c.touch(&d, b"._ghost", 0o644).unwrap(); + let body = pattern(82, 64); + c.write(&ghost.handle, 0, &body).unwrap(); + assert_eq!(server.held().companions_slotted, 1); + + // The client links the companion name, then creates the main file of the + // linked name: one of the companion's names now has a main file the export + // knows. + c.link(&ghost.handle, &d, b"._kept").unwrap(); + c.touch(&d, b"kept", 0o644).unwrap(); + assert_eq!(c.read_all(&ghost.handle, 4096), body); + + // A CREATE at the bound reclaims first. The companion is reached by + // `._kept`, whose main file the export knows, so it is no orphan: nothing + // is dropped and the CREATE is refused. + c.touch(&root, b"y", 0o644).unwrap(); + assert_eq!(c.touch(&root, b"._y", 0o644).map(|_| ()), Err(NOSPC)); + assert_eq!(server.held().companions, 1); + assert_eq!(c.read_all(&ghost.handle, 4096), body); + let (kept, attr) = c.lookup(&d, b"._kept").unwrap(); + assert_eq!(kept, ghost.handle); + assert_eq!(attr.size as usize, body.len()); + + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} diff --git a/engine/crates/layerfs-nfs/tests/daemon.rs b/engine/crates/layerfs-nfs/tests/daemon.rs index eacaf9e35b..2d831256bb 100644 --- a/engine/crates/layerfs-nfs/tests/daemon.rs +++ b/engine/crates/layerfs-nfs/tests/daemon.rs @@ -136,8 +136,18 @@ fn workspace_control_over_the_nfs_route() { // Mount + Attach: Ready with an NFS receipt; the helper mounted it. let token = bind(&service, 31, rig.branch); + let spill_dir = mounts + .join(".appledouble") + .join(token.namespace.to_string()); + fs::create_dir_all(&spill_dir).unwrap(); + let stale_spill = spill_dir.join("stale-from-crashed-daemon"); + fs::write(&stale_spill, b"stale").unwrap(); assert_eq!(phase(&service, token), MountPhase::Unattached); let ready = attach(&service, token); + assert!( + !stale_spill.exists(), + "Attach cleans any leftover companion spill directory" + ); assert_eq!(ready.receipt.abi_major, 0); assert_eq!( ready.directory, @@ -242,6 +252,7 @@ fn workspace_control_over_the_nfs_route() { Reply::Unmounted(token) ); assert!(!Path::new(&ready.directory).exists()); + assert!(!spill_dir.exists()); let released = service.export_released(token).unwrap(); assert_eq!(released.lookups, held.lookups); assert_eq!(released.retained, 0); @@ -290,3 +301,39 @@ fn workspace_control_over_the_nfs_route() { } fs::remove_file(&log).unwrap(); } + +/// A daemon that ended without unmounting leaves the companions' scratch +/// directories behind. Its successor clears them before serving anything, and +/// touches nothing else under the mount home. +#[test] +fn startup_reclaim_clears_leftover_companion_spill_directories() { + let mounts = temp("reclaim-mounts"); + let log = temp("reclaim-helpers.log"); + drop(fs::remove_dir_all(&mounts)); + drop(fs::remove_file(&log)); + fs::create_dir_all(mounts.join(".appledouble/7")).unwrap(); + fs::write(mounts.join(".appledouble/7/stale"), b"stale").unwrap(); + fs::create_dir_all(mounts.join("kept")).unwrap(); + fs::write(mounts.join("kept/note"), b"keep").unwrap(); + let export = ExportServing::start(ExportServingConfig::new( + mounts.clone(), + UID, + GID, + Mounter { + mount: recording("mount", &log, None), + unmount: recording("unmount", &log, None), + force: recording("force", &log, None), + flush: None, + }, + )); + let lines = export.reclaim(); + assert_eq!(lines.len(), 1, "{lines:?}"); + assert!( + lines[0].starts_with("removed leftovers under "), + "{lines:?}" + ); + assert!(!mounts.join(".appledouble").exists()); + assert_eq!(fs::read(mounts.join("kept/note")).unwrap(), b"keep"); + drop(fs::remove_dir_all(&mounts)); + drop(fs::remove_file(&log)); +} diff --git a/engine/crates/layerfs-nfs/tests/export.rs b/engine/crates/layerfs-nfs/tests/export.rs index e14ea03528..4db545e2ce 100644 --- a/engine/crates/layerfs-nfs/tests/export.rs +++ b/engine/crates/layerfs-nfs/tests/export.rs @@ -9,6 +9,9 @@ mod client; #[path = "support/rig.rs"] mod rig; #[allow(dead_code)] +#[path = "support/spy.rs"] +mod spy; +#[allow(dead_code)] #[path = "support/tree.rs"] mod tree; use client::{Attr, Client, BADHANDLE, BAD_COOKIE, NOENT, ROFS, STALE}; @@ -19,6 +22,7 @@ use std::{ net::TcpListener, os::unix::fs::{MetadataExt, PermissionsExt}, path::{Path, PathBuf}, + sync::{atomic::Ordering, Arc}, time::Duration, }; use tree::{oracle, walk, Node}; @@ -114,7 +118,7 @@ fn readdirplus_lists_a_directory_with_attributes_and_handles() { let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, true); let mut client = Client::connect(server.local_addr(), UID, GID); let root = client.mnt("/"); - let (src, src_attr) = client.lookup(&root, b"src").unwrap(); + let (src, _) = client.lookup(&root, b"src").unwrap(); let held = server.held().lookups; // One reply lists the whole directory: the window that lists its last @@ -125,10 +129,12 @@ fn readdirplus_lists_a_directory_with_attributes_and_handles() { .unwrap(); assert_eq!(client.calls - calls, 1, "one READDIRPLUS for the directory"); assert!(eof, "the reply that lists the last name is the end"); + // `src` is inherited from the committed base: the window reads no local + // row of it, so the reply says nothing about the directory rather than + // repeating the facts this export last observed for it. assert_eq!( - directory, - Some(src_attr), - "dir_attributes of the listed directory" + directory, None, + "no dir_attributes for an inherited directory" ); let names: BTreeSet> = entries.iter().map(|entry| entry.name.clone()).collect(); assert_eq!( @@ -247,6 +253,71 @@ fn readdirplus_reports_a_local_directorys_own_rows() { fs::remove_dir_all(base).unwrap(); } +#[test] +fn an_inherited_directorys_listing_never_answers_a_stale_observation() { + let base = temp("inherited"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let first = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut client = Client::connect(first.local_addr(), UID, GID); + let root = client.mnt("/"); + // `many` comes from the committed base: the overlay holds no local row of + // it, so no listing visit reads the directory's own row. + let (many, _) = client.lookup(&root, b"many").unwrap(); + let before = client.getattr(&many).unwrap(); + assert_eq!(before.nlink, 2, "the directory has no child directory"); + + // The first reply lists the two dots only, so the descriptor stays open + // across the change below and the next reply continues this enumeration. + // Its window read no row of `many`, so it carries no attributes of it + // rather than the facts the OPENDIR visit observed. + let (dots, verifier, eof, directory) = client + .readdir_with_directory(&many, 0, 0, 300, true) + .unwrap(); + assert!(!eof, "the enumeration continues after the dots"); + assert_eq!( + directory, None, + "an inherited directory's window reads no row to answer" + ); + let cookie = dots.last().expect("the dots").cookie; + + // A second export of the same Workspace adds a child directory to + // `many`, which this export does not observe: its last observation of the + // directory is now older than the directory's own row, and nothing ages + // it. + let second = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut other = Client::connect(second.local_addr(), UID, GID); + let other_root = other.mnt("/"); + let (target, _) = other.lookup(&other_root, b"many").unwrap(); + other.mkdir(&target, b"child", 0o755).unwrap(); + + // The continued reply says the directory's current facts or nothing at + // all; it never repeats the pre-change observation. + let (_, _, _, directory) = client + .readdir_with_directory(&many, cookie, verifier, 4096, true) + .unwrap(); + let fresh = client.getattr(&many).unwrap(); + assert_eq!(fresh.nlink, 3, "the directory gained a child directory"); + assert_ne!( + directory, + Some(before), + "never the last observation of the directory" + ); + assert!( + directory.is_none() || directory == Some(fresh), + "the current facts or no attributes at all: {directory:?}" + ); + + drop(client); + drop(other); + let released = first.stop(); + second.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + #[test] fn a_large_directory_keeps_its_names_and_its_references() { let base = temp("large"); @@ -374,3 +445,293 @@ fn cookies_refusals_and_stale_handles() { assert_eq!(outstanding, 0); fs::remove_dir_all(base).unwrap(); } + +#[test] +fn a_lookup_spends_one_owner_visit() { + let base = temp("lookup"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let watch = Arc::new(spy::Watch::default()); + let services = Arc::new(spy::Spy { + inner: Arc::new(layerfs_daemon::Mounted(rig.bound.clone())), + watch: watch.clone(), + }); + let server = rig.export_services( + TcpListener::bind("127.0.0.1:0").unwrap(), + services, + UID, + GID, + false, + ); + let mut client = Client::connect(server.local_addr(), UID, GID); + let root = client.mnt("/"); + + // RFC 1813 answers the entry's attributes and its directory's: the one + // visit that resolved the name had to read the directory's row too. The + // names are looked up once first, so the visit below is the steady state + // and not the mount's first read of a base name. + client.lookup(&root, b"src").unwrap(); + assert_eq!(client.lookup(&root, b"absent").map(|_| ()), Err(NOENT)); + let root_attr: Attr = client.getattr(&root).unwrap(); + + let visits = watch.visits.load(Ordering::Acquire); + let (status, found, directory) = client.lookup_with_directory(&root, b"src"); + assert_eq!(status, 0); + let (_, src_attr) = found.clone().expect("the directory's own name"); + assert_eq!( + watch.visits.load(Ordering::Acquire) - visits, + 1, + "one owner visit for a LOOKUP and its directory" + ); + assert_eq!( + directory, + Some(root_attr.clone()), + "the directory it was named in" + ); + + // A missing name is one visit as well, and answers the directory facts + // the export already published for it. + let visits = watch.visits.load(Ordering::Acquire); + let (status, found, directory) = client.lookup_with_directory(&root, b"absent"); + assert_eq!((status, found), (NOENT, None)); + assert_eq!( + watch.visits.load(Ordering::Acquire) - visits, + 1, + "one owner visit for a failing LOOKUP" + ); + assert_eq!(directory, Some(root_attr)); + + // The name resolved to the same inode a later LOOKUP reports, and the + // directory half of the reply is the directory's own facts. + let (_, again) = client.lookup(&root, b"src").unwrap(); + assert_eq!(again.fileid, src_attr.fileid, "the same inode"); + drop(client); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_listing_spends_one_owner_visit_and_reads_its_window_in_batches() { + let base = temp("listing"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let watch = Arc::new(spy::Watch::default()); + let services = Arc::new(spy::Spy { + inner: Arc::new(layerfs_daemon::Mounted(rig.bound.clone())), + watch: watch.clone(), + }); + let server = rig.export_services( + TcpListener::bind("127.0.0.1:0").unwrap(), + services, + UID, + GID, + false, + ); + let mut client = Client::connect(server.local_addr(), UID, GID); + let root = client.mnt("/"); + let (many, _) = client.lookup(&root, b"many").unwrap(); + + // A directory of 700 inherited names over several replies: one OPENDIR + // visit for the whole enumeration, at most one Store reader per reply, + // and never one per listed name — the window's names, kinds and facts + // are read in batches outside the owner. + let (visits, bases) = ( + watch.visits.load(Ordering::Acquire), + watch.bases.load(Ordering::Acquire), + ); + let (entries, calls) = client.list(&many, 64 * 1024, true); + assert!(calls > 1, "a budget spreads one directory over replies"); + assert_eq!(entries.len(), MANY + 2, "every name, once"); + for entry in entries + .iter() + .filter(|entry| entry.name != b"." && entry.name != b"..") + { + // Every inherited name arrives with both optional fields, so the + // client needs no LOOKUP per name on a cold tree. + assert!( + entry.attr.is_some(), + "READDIRPLUS attributes: {:?}", + entry.name + ); + assert!( + entry.handle.is_some(), + "READDIRPLUS handle: {:?}", + entry.name + ); + } + assert_eq!( + watch.visits.load(Ordering::Acquire) - visits, + 1, + "one owner visit for the whole enumeration" + ); + assert!( + watch.bases.load(Ordering::Acquire) - bases <= calls, + "at most one Store reader per reply, never one per name" + ); + // Each handed-out handle holds one reference, and an identical reply + // reuses the published offsets instead of taking more. + let held = server.held().lookups; + assert_eq!(held, 1 + MANY, "the directory and one reference per entry"); + let (again, _) = client.list(&many, 64 * 1024, true); + assert_eq!(again.len(), entries.len(), "the same names again"); + assert_eq!( + server.held().lookups, + held, + "no second reference for a listed name" + ); + + // A directory this export created is answered from the rows its visit + // already read: its listing takes no Store reader at all. + client.mkdir(&root, b"local", 0o755).unwrap(); + let (local, _) = client.lookup(&root, b"local").unwrap(); + client.touch(&local, b"a", 0o644).unwrap(); + let bases = watch.bases.load(Ordering::Acquire); + let (entries, _, _) = client + .readdir(&local, 0, 0, 4096, true) + .map(|(entries, _, eof)| (entries, eof, ())) + .unwrap(); + let created = entries + .iter() + .find(|entry| entry.name == b"a") + .expect("the created name"); + assert!( + created.attr.is_some() && created.handle.is_some(), + "a local row carries its facts and its handle" + ); + assert_eq!( + watch.bases.load(Ordering::Acquire), + bases, + "a local listing takes no Store reader" + ); + + drop(client); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_lookup_never_answers_a_stale_directory_observation() { + let base = temp("lookup-companion-directory"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let first = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut client = Client::connect(first.local_addr(), UID, GID); + let root = client.mnt("/"); + let made = client.mkdir(&root, b"watched", 0o755).unwrap(); + client.touch(&made.handle, b"file", 0o644).unwrap(); + let companion = client.touch(&made.handle, b"._file", 0o644).unwrap(); + let before = client.getattr(&made.handle).unwrap(); + assert_eq!(before.nlink, 2, "an empty directory"); + + // Another writer adds a child directory; this export observes nothing. + let second = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut other = Client::connect(second.local_addr(), UID, GID); + let other_root = other.mnt("/"); + let (target, _) = other.lookup(&other_root, b"watched").unwrap(); + other.mkdir(&target, b"child", 0o755).unwrap(); + + // The export answers a companion alone: no job read the directory, so the + // reply carries no directory attributes rather than the last observation. + let (status, found, directory) = client.lookup_with_directory(&made.handle, b"._file"); + assert_eq!(status, 0); + assert_eq!(found.map(|(handle, _)| handle), Some(companion.handle)); + assert_eq!(directory, None, "never the last observation"); + + // A failed LOOKUP read the directory's row: the export keeps those facts, + // so a companion change's `wcc_data` answers them, not the older ones. + let (status, _, directory) = client.lookup_with_directory(&made.handle, b"absent"); + assert_eq!(status, NOENT); + let fresh = directory.expect("the failed LOOKUP's directory row"); + assert_eq!(fresh.nlink, 3, "the directory gained a child directory"); + let removed = client.remove(&made.handle, b"._file").unwrap(); + assert_eq!( + removed.after, + Some(fresh), + "the facts the failed LOOKUP read" + ); + + drop(client); + drop(other); + let released = first.stop(); + second.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_failed_lookup_answers_fresh_directory_facts_never_a_stale_observation() { + let base = temp("lookup-directory"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let first = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut client = Client::connect(first.local_addr(), UID, GID); + let root = client.mnt("/"); + let made = client.mkdir(&root, b"watched", 0o755).unwrap(); + let before = client.getattr(&made.handle).unwrap(); + assert_eq!(before.nlink, 2, "an empty directory"); + + // A second engine mount of the same Workspace adds a name to the + // directory this export watches. This export observes no publication for + // it, which is the install and other-writer case: its last observation of + // the directory is now older than the directory's own row. + let second = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut other = Client::connect(second.local_addr(), UID, GID); + let other_root = other.mnt("/"); + let (target, _) = other.lookup(&other_root, b"watched").unwrap(); + other.mkdir(&target, b"child", 0o755).unwrap(); + + // The failed LOOKUP answers the directory's current facts: the job that + // found no name read the directory's row in the same visit. Nothing may + // answer the last observation instead, which no time bound ages. + let (status, found, directory) = client.lookup_with_directory(&made.handle, b"absent"); + assert_eq!((status, found), (NOENT, None)); + let fresh = client.getattr(&made.handle).unwrap(); + assert_eq!(fresh.nlink, 3, "the directory gained a child directory"); + assert_eq!(directory, Some(fresh.clone()), "the current facts"); + assert_ne!(directory, Some(before), "never the last observation"); + + // A name this export decides without an owner job reads no directory row + // and answers no directory attributes, so a client falls back to its own + // `actimeo` rather than restarting it on facts nothing refreshes. + let (status, found, directory) = client.lookup_with_directory(&made.handle, b"."); + assert_eq!(status, 0); + assert!(found.is_some()); + assert_eq!(directory, None, "no attributes for `.`"); + let (status, found, directory) = client.lookup_with_directory(&made.handle, b".."); + assert_eq!(status, 0); + assert!(found.is_some()); + assert_eq!(directory, None, "no attributes for `..`"); + + // A silly name is kept by this export alone; its reply names none either. + let open = client.touch(&made.handle, b"open", 0o644).unwrap(); + client + .rename( + &made.handle, + b"open", + &made.handle, + b".nfs00000000000012ab00000001", + ) + .unwrap(); + let (status, found, directory) = + client.lookup_with_directory(&made.handle, b".nfs00000000000012ab00000001"); + assert_eq!(status, 0); + assert_eq!(found.map(|(handle, _)| handle), Some(open.handle)); + assert_eq!(directory, None, "no attributes for a silly name"); + + drop(client); + drop(other); + let released = first.stop(); + second.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} diff --git a/engine/crates/layerfs-nfs/tests/support/rig.rs b/engine/crates/layerfs-nfs/tests/support/rig.rs index f30ad75e95..a5a8cbc801 100644 --- a/engine/crates/layerfs-nfs/tests/support/rig.rs +++ b/engine/crates/layerfs-nfs/tests/support/rig.rs @@ -40,6 +40,12 @@ pub struct Rig { pub entries: u64, /// The reference bound exports of this rig are configured with. pub lookups_held: usize, + /// Resident memory budget for AppleDouble companion bodies. + pub companion_resident_bytes: usize, + /// Maximum AppleDouble companion index entries held at once. + pub companions_held: usize, + /// Optional explicit spill directory override for AppleDouble companions. + pub companion_spill_dir: Option, } impl Rig { /// Initializes a Store from `source`, publishes Branch `main` at that @@ -142,8 +148,16 @@ impl Rig { branch, entries: initialized.entries, lookups_held: layerfs_nfs::kernel::LOOKUPS_HELD, + companion_resident_bytes: layerfs_nfs::apple_double::RESIDENT_BYTES, + companions_held: layerfs_nfs::apple_double::HELD, + companion_spill_dir: None, } } + fn spill_dir(&self, sub: &str) -> PathBuf { + self.companion_spill_dir + .clone() + .unwrap_or_else(|| self.directory.join("tmp").join("appledouble").join(sub)) + } /// Serves this rig's engine mount read-only on `listener`. pub fn serve(&self, listener: TcpListener, uid: u32, gid: u32) -> Server { self.export(listener, uid, gid, true) @@ -179,6 +193,9 @@ impl Rig { read_only, refuse_apple_double: true, lookups_held: self.lookups_held, + companion_spill_dir: Some(self.spill_dir("export")), + companion_resident_bytes: self.companion_resident_bytes, + companions_held: self.companions_held, }, ) .unwrap() @@ -247,6 +264,9 @@ impl Rig { read_only: true, refuse_apple_double: true, lookups_held: self.lookups_held, + companion_spill_dir: Some(self.spill_dir(&format!("view-{}", view.1.owner_id()))), + companion_resident_bytes: self.companion_resident_bytes, + companions_held: self.companions_held, }, ) .unwrap() diff --git a/engine/crates/layerfs-nfs/tests/support/spy.rs b/engine/crates/layerfs-nfs/tests/support/spy.rs index ea761166d9..c96973dafb 100644 --- a/engine/crates/layerfs-nfs/tests/support/spy.rs +++ b/engine/crates/layerfs-nfs/tests/support/spy.rs @@ -42,6 +42,12 @@ pub struct Watch { /// Each engine read window the export asked for: offset and length. One /// call may fill its whole transfer from several of them. pub reads: Mutex>, + /// Owner read visits (`observe_visit`): the jobs a LOOKUP, GETATTR or + /// OPEN spends. One LOOKUP spends exactly one. + pub visits: AtomicU64, + /// Store readers a request took for a base demand: at most one per reply, + /// never one per listed name. + pub bases: AtomicU64, } pub struct Spy { pub inner: Arc, @@ -70,9 +76,10 @@ impl RequestServices for Request { handle: u64, offset: u64, after: Option>, + attributes: bool, ) -> ServiceFuture<'_, ServiceReply>> { self.inner - .directory_visit(mount, serial, handle, offset, after) + .directory_visit(mount, serial, handle, offset, after, attributes) } fn publish_cookies( &self, @@ -123,10 +130,12 @@ impl RequestServices for Request { operation: KernelReadOperation, facts: Arc, ) -> ServiceFuture<'_, ServiceReply>> { + self.watch.visits.fetch_add(1, Ordering::AcqRel); self.inner .observe_visit(mount, request, serial, handle, operation, facts) } fn base(&self) -> ServiceFuture<'_, BaseView> { + self.watch.bases.fetch_add(1, Ordering::AcqRel); self.inner.base() } fn mutate_visit( diff --git a/engine/crates/layerfs-nfs/tests/write.rs b/engine/crates/layerfs-nfs/tests/write.rs index a6c94d0f74..f1e444cfe3 100644 --- a/engine/crates/layerfs-nfs/tests/write.rs +++ b/engine/crates/layerfs-nfs/tests/write.rs @@ -33,6 +33,7 @@ use std::{ const UID: u32 = 501; const GID: u32 = 20; const FILE_SYNC: u32 = 2; +const NOSPC: u32 = 28; const LINUX_SILLY: &[u8] = b".nfs00000000000012ab00000001"; const MAC_SILLY: &[u8] = b".nfs.20051025.b896"; @@ -56,6 +57,14 @@ fn pattern(seed: u32, length: usize) -> Vec { .map(|n| (n as u32).wrapping_mul(31).wrapping_add(seed * 97) as u8) .collect() } +/// The files an export spilled into `dir`, and their bytes. +fn spilled(dir: &Path) -> (usize, u64) { + let files: Vec = (fs::read_dir(dir).into_iter().flatten().flatten()) + .filter_map(|entry| entry.metadata().ok()) + .map(|metadata| metadata.len()) + .collect(); + (files.len(), files.iter().sum()) +} #[test] fn every_changing_procedure_and_its_statuses() { @@ -531,6 +540,698 @@ fn apple_double_files_stay_out_of_the_workspace() { fs::remove_dir_all(base).unwrap(); } +#[test] +fn apple_double_companions_spill_preserve_all_bytes_reclaim_orphans_and_clean_up() { + use layerfs_nfs::apple_double::{FILE_BYTES, HELD}; + let base = temp("appledouble-spill"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + + // 1. Pre-populate a leftover file in the spill directory (simulating a + // crashed daemon) and configure a small resident budget (64 KiB) so + // spilling is exercised across both the old 4096 companion count and + // the memory budget. + let spill_dir = base.join("spill-export"); + fs::create_dir_all(&spill_dir).unwrap(); + let stale_residue = spill_dir.join("stale-from-crash"); + fs::write(&stale_residue, b"leftover").unwrap(); + assert!(stale_residue.exists()); + + let budget = 64 * 1024; + rig.companion_spill_dir = Some(spill_dir.clone()); + rig.companion_resident_bytes = budget; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + assert!( + !stale_residue.exists(), + "starting an export cleans any leftover spill directory from an earlier crash" + ); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // 2. Removing a main file, silly-renaming it, or replacing it with RENAME + // drops its paired `._` companion and deletes its spilled disk + // file at once. Plain non-replacing RENAME (`mv plain_a plain_b`) + // cleans only the destination side so the client can subsequently + // rename `._plain_a -> ._plain_b`. + let big_payload = pattern(11, 40 * 1024); + c.touch(&root, b"rm.txt", 0o644).unwrap(); + let rm_ad = c.touch(&root, b"._rm.txt", 0o644).unwrap(); + c.write(&rm_ad.handle, 0, &big_payload).unwrap(); + c.touch(&root, b"silly.txt", 0o644).unwrap(); + let silly_ad = c.touch(&root, b"._silly.txt", 0o644).unwrap(); + c.write(&silly_ad.handle, 0, &big_payload).unwrap(); + // Second 40 KiB write crosses the 64 KiB budget, spilling `._rm.txt`. + let rm_spill_file = spill_dir.join(rm_ad.attr.fileid.to_string()); + assert!( + rm_spill_file.is_file(), + "oldest companion body spilled to disk" + ); + assert!(server.held().companion_bytes <= budget); + assert_eq!(spilled(&spill_dir), (1, big_payload.len() as u64)); + // The scratch directory and its files are this user's alone, whatever the + // process umask is. + for (path, mode) in [(&spill_dir, 0o700), (&rm_spill_file, 0o600)] { + assert_eq!( + fs::metadata(path).unwrap().permissions().mode() & 0o777, + mode, + "{}", + path.display() + ); + } + + c.remove(&root, b"rm.txt").unwrap(); + assert!( + !rm_spill_file.exists(), + "removing the main file unlinks its spilled companion file" + ); + assert_eq!(c.lookup(&root, b"._rm.txt").map(|_| ()), Err(NOENT)); + assert_eq!(c.getattr(&rm_ad.handle), Err(STALE)); + + c.rename(&root, b"silly.txt", &root, MAC_SILLY).unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.getattr(&silly_ad.handle), Err(STALE)); + c.remove(&root, MAC_SILLY).unwrap(); + + c.touch(&root, b"src.txt", 0o644).unwrap(); + c.touch(&root, b"dst.txt", 0o644).unwrap(); + let dst_ad = c.touch(&root, b"._dst.txt", 0o644).unwrap(); + c.write(&dst_ad.handle, 0, &big_payload).unwrap(); + let src_ad = c.touch(&root, b"._src.txt", 0o644).unwrap(); + c.write(&src_ad.handle, 0, &big_payload).unwrap(); + let dst_spill_file = spill_dir.join(dst_ad.attr.fileid.to_string()); + assert!(dst_spill_file.is_file()); + c.rename(&root, b"src.txt", &root, b"dst.txt").unwrap(); + assert!( + !dst_spill_file.exists(), + "replacing RENAME unlinks the destination's spilled companion" + ); + assert_eq!(c.getattr(&dst_ad.handle), Err(STALE)); + // Source companion `._src.txt` is still present so the client can rename + // it to `._dst.txt`, then remove `dst.txt`. + c.rename(&root, b"._src.txt", &root, b"._dst.txt").unwrap(); + assert_eq!(c.read_all(&src_ad.handle, 64 * 1024), big_payload); + c.remove(&root, b"dst.txt").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(server.held().companion_bytes, 0); + + // 3. Create and write > 4096 companions (4160), crossing both the old + // 4096 cap and the 64 KiB resident memory budget: every CREATE, WRITE + // and READ succeeds, resident bytes never exceed `budget`, spilled + // files exist on disk, and the earliest companions read back byte for + // byte (0 data loss). + const TOTAL_COUNT: usize = 4160; + let mut handles = Vec::with_capacity(TOTAL_COUNT); + for i in 0..TOTAL_COUNT { + let name = format!("._c-{i}"); + let made = c.touch(&root, name.as_bytes(), 0o644).unwrap(); + let payload = if i < 32 || i % 128 == 0 { + format!("companion-payload-{i:04}-{}", "x".repeat(2048)).into_bytes() + } else { + format!("short-{i:04}").into_bytes() + }; + c.write(&made.handle, 0, &payload).unwrap(); + assert!( + server.held().companion_bytes <= budget, + "resident bytes {} exceeded budget {budget} at {i}", + server.held().companion_bytes + ); + handles.push((made.handle, made.attr.fileid, payload)); + } + assert_eq!(server.held().companions, TOTAL_COUNT); + assert_eq!(server.held().names_refused, 0); + assert!( + spilled(&spill_dir).0 > 0, + "companions beyond the resident budget are on disk" + ); + assert!(spill_dir.join(handles[0].1.to_string()).is_file()); + + // Earliest, middle and latest companions all read back byte-for-byte. + for idx in [ + 0, + 1, + 2, + 15, + 31, + 128, + 1024, + 2048, + 4095, + 4096, + TOTAL_COUNT - 1, + ] { + let (ref handle, _, ref expected) = handles[idx]; + let name = format!("._c-{idx}"); + let (looked, attr) = c.lookup(&root, name.as_bytes()).unwrap(); + assert_eq!(&looked, handle); + assert_eq!(attr.size, expected.len() as u64); + assert_eq!( + c.read_all(handle, 64 * 1024), + *expected, + "companion {idx} content mismatch" + ); + } + + // Overwriting and truncating an already-spilled companion works via + // pread/pwrite/set_len and removes its disk file on explicit REMOVE. + let (ref h0, id0, _) = handles[0]; + c.write(h0, 0, b"updated-header").unwrap(); + let shrink = Set { + size: Some(14), + ..Set::default() + }; + c.setattr(h0, shrink, None).unwrap(); + assert_eq!(c.read_all(h0, 64), b"updated-header"); + c.remove(&root, b"._c-0").unwrap(); + assert!(!spill_dir.join(id0.to_string()).exists()); + + // Single-file limit `FILE_BYTES` (1 MiB) is still enforced (`NFS3ERR_FBIG`). + const FBIG: u32 = 27; + let (ref h_last, _, _) = handles[TOTAL_COUNT - 1]; + assert_eq!(c.write(h_last, FILE_BYTES, b"!").map(|_| ()), Err(FBIG)); + + // 4. Stopping the export removes the entire spill directory. + drop(c); + let released = server.stop(); + assert_eq!(released.companions, TOTAL_COUNT - 1); + assert!(released.companion_bytes <= budget); + assert!( + !spill_dir.exists(), + "export stop removes the spill directory" + ); + + // 5. At the index bound (`companions_held`; default `HELD` = 65_536): + // orphan companions (whose paired main file is not in `Table::by_name`) + // are reclaimed first so new creations succeed; when all slots are + // held by live main files, `CREATE` answers `NFS3ERR_NOSPC`. + assert_eq!(HELD, 65_536); + let small_cap = 8; + let cap_spill = base.join("spill-cap"); + rig.companion_spill_dir = Some(cap_spill.clone()); + rig.companions_held = small_cap; + rig.companion_resident_bytes = 1024; + let server2 = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c2 = Client::connect(server2.local_addr(), UID, GID); + let root2 = c2.mnt("/"); + + // Create 4 live pairs (main file + companion) and 4 orphan companions + // (no main file created), filling all 8 index slots and spilling some. + for i in 0..4 { + let main = format!("live-{i}"); + let comp = format!("._live-{i}"); + c2.touch(&root2, main.as_bytes(), 0o644).unwrap(); + let ad = c2.touch(&root2, comp.as_bytes(), 0o644).unwrap(); + c2.write(&ad.handle, 0, &[b'L'; 512]).unwrap(); + } + let mut orphan_handles = Vec::new(); + for i in 0..4 { + let comp = format!("._orphan-{i}"); + let ad = c2.touch(&root2, comp.as_bytes(), 0o644).unwrap(); + c2.write(&ad.handle, 0, &[b'O'; 512]).unwrap(); + orphan_handles.push((ad.handle, ad.attr.fileid)); + } + assert_eq!(server2.held().companions, small_cap); + + // Creating 4 more live pairs at the bound reclaims the 4 orphans (and + // unlinks their spilled files) while preserving the first 4 live pairs. + for i in 4..small_cap { + let main = format!("live-{i}"); + let comp = format!("._live-{i}"); + c2.touch(&root2, main.as_bytes(), 0o644).unwrap(); + let ad = c2.touch(&root2, comp.as_bytes(), 0o644).unwrap(); + c2.write(&ad.handle, 0, &[b'N'; 128]).unwrap(); + } + assert_eq!(server2.held().companions, small_cap); + assert_eq!(server2.held().names_refused, 0); + for (oh, oid) in &orphan_handles { + assert_eq!(c2.getattr(oh), Err(STALE)); + assert!(!cap_spill.join(oid.to_string()).exists()); + } + for i in 0..4 { + let comp = format!("._live-{i}"); + let (lh, _) = c2.lookup(&root2, comp.as_bytes()).unwrap(); + assert_eq!(c2.read_all(&lh, 1024), vec![b'L'; 512]); + } + + // Now all 8 slots belong to live main files: one more companion CREATE + // finds no orphans to reclaim and answers `NFS3ERR_NOSPC`. Repeated + // refusals count individually but log at most once per minute per export. + c2.touch(&root2, b"extra", 0o644).unwrap(); + for _ in 0..3 { + assert_eq!(c2.touch(&root2, b"._extra", 0o644).map(|_| ()), Err(NOSPC)); + } + assert_eq!(server2.held().names_refused, 3); + // Existing names still honor GUARDED / UNCHECKED when the table is full. + assert_eq!( + c2.create(&root2, b"._live-0", How::Guarded(Set::default())) + .map(|_| ()), + Err(EXIST) + ); + c2.touch(&root2, b"._live-0", 0o644).unwrap(); + c2.remove(&root2, b"live-7").unwrap(); + c2.touch(&root2, b"._extra", 0o644).unwrap(); + assert_eq!(server2.held().names_refused, 3); + + drop(c2); + let released2 = server2.stop(); + assert!(!cap_spill.exists()); + let (_, outstanding) = rig.stop(released2); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn two_guarded_creates_of_one_companion_name_leave_one_entry() { + let base = temp("appledouble-create-race"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 8; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let mut other = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.touch(&root, b"dup", 0o644).unwrap(); + + // Two actual connections start each CREATE together. Repeat the schedule + // with an empty companion table, so every round exercises first insertion. + for _ in 0..4096 { + let start = std::sync::Barrier::new(2); + let (a, b) = std::thread::scope(|scope| { + let a = scope.spawn(|| { + start.wait(); + c.create(&root, b"._dup", How::Guarded(Set::default())) + }); + let b = scope.spawn(|| { + start.wait(); + other.create(&root, b"._dup", How::Guarded(Set::default())) + }); + (a.join().unwrap(), b.join().unwrap()) + }); + let mut statuses = [ + a.as_ref().map(|_| OK).unwrap_or_else(|e| *e), + b.as_ref().map(|_| OK).unwrap_or_else(|e| *e), + ]; + statuses.sort(); + assert_eq!(statuses, [OK, EXIST]); + let made = a.or(b).unwrap(); + assert_eq!(server.held().companions, 1); + c.remove(&root, b"._dup").unwrap(); + assert_eq!(server.held().companions, 0); + assert_eq!(c.getattr(&made.handle), Err(STALE)); + } + c.touch(&root, b"._dup", 0o644).unwrap(); + assert_eq!(server.held().names_refused, 0); + drop((c, other)); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_guarded_create_reclaims_the_last_slot_for_one_entry_only() { + let base = temp("appledouble-create-race-bound"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 3; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let mut other = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + c.touch(&root, b"dup", 0o644).unwrap(); + // Two slots belong to live main files, which reclamation must keep. + for index in 0..2 { + let main = format!("live-{index}"); + let companion = format!("._live-{index}"); + c.touch(&root, main.as_bytes(), 0o644).unwrap(); + let made = c.touch(&root, companion.as_bytes(), 0o644).unwrap(); + c.write(&made.handle, 0, &[b'L'; 64]).unwrap(); + } + assert_eq!(server.held().companions_slotted, 2); + // Every round fills the last slot with a companion whose main file does not + // exist, so both creates below are over the bound and one of them has to + // reclaim that orphan while it holds no companion lock. + for round in 0..256 { + let orphan = format!("._orphan-{round}"); + let made = c.touch(&root, orphan.as_bytes(), 0o644).unwrap(); + c.write(&made.handle, 0, &[b'O'; 64]).unwrap(); + assert_eq!(server.held().companions_slotted, 3, "round {round}"); + let start = std::sync::Barrier::new(2); + let (a, b) = std::thread::scope(|scope| { + let a = scope.spawn(|| { + start.wait(); + c.create(&root, b"._dup", How::Guarded(Set::default())) + }); + let b = scope.spawn(|| { + start.wait(); + other.create(&root, b"._dup", How::Guarded(Set::default())) + }); + (a.join().unwrap(), b.join().unwrap()) + }); + let mut statuses = [ + a.as_ref().map(|_| OK).unwrap_or_else(|status| *status), + b.as_ref().map(|_| OK).unwrap_or_else(|status| *status), + ]; + statuses.sort(); + assert_eq!(statuses, [OK, EXIST], "round {round}"); + // The two live pairs and the one name: the loser inserted no second + // serial for a name that is already taken. + assert_eq!(server.held().companions_slotted, 3, "round {round}"); + assert_eq!(server.held().companions, 3, "round {round}"); + assert_eq!(c.getattr(&made.handle), Err(STALE), "round {round}"); + c.remove(&root, b"._dup").unwrap(); + assert_eq!(server.held().companions_slotted, 2, "round {round}"); + } + assert_eq!(server.held().names_refused, 0); + drop((c, other)); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_renamed_hard_link_alias_keeps_the_inodes_recalled_name_bound() { + let base = temp("appledouble-rename-alias"); + let tree = base.join("tree"); + source(&tree); + let rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + // Two exports of one mount: the second one moves a name the first one does + // not observe, as another client of the same Workspace would. + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let second = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let mut them = Client::connect(second.local_addr(), UID, GID); + let root = c.mnt("/"); + let their_root = them.mnt("/"); + + // One inode, three names: the export recalls it by `p` and holds `q` as an + // alias of it. + let main = c.touch(&root, b"p", 0o644).unwrap(); + c.link(&main.handle, &root, b"q").unwrap(); + assert_eq!(c.lookup(&root, b"p").unwrap().0, main.handle); + // RENAME of `q` to `r` keeps `p` as the recalled name; the next RENAME moves + // `p` itself, which is an alias, so `r` stops being the recalled name and + // is still one of the inode's names. + c.rename(&root, b"q", &root, b"r").unwrap(); + c.rename(&root, b"p", &root, b"s").unwrap(); + + // The other export moves and then removes `r`; this export removes `s`, + // which is the inode's last name: it retires the inode, and `r` must leave + // the name index with it. + them.rename(&their_root, b"r", &their_root, b"t").unwrap(); + them.remove(&their_root, b"t").unwrap(); + c.remove(&root, b"s").unwrap(); + + // A `._r` companion created while `r` is gone belongs to no inode. + c.touch(&root, b"._r", 0o644).unwrap(); + let companion = c.lookup(&root, b"._r").unwrap().0; + let payload = b"a companion of no inode"; + c.write(&companion, 0, payload).unwrap(); + + // A new file takes the name `r`; the companion is still reachable by name. + them.touch(&their_root, b"r", 0o644).unwrap(); + let (fresh, _) = c.lookup(&root, b"r").unwrap(); + assert_ne!(fresh, main.handle); + let (found, _) = c + .lookup(&root, b"._r") + .expect("the companion still belongs to no inode"); + assert_eq!(found, companion); + assert_eq!(c.read_all(&found, 64), payload); + + drop((c, them)); + let released = server.stop(); + second.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +#[test] +fn a_companion_survives_reclaim_after_its_main_file_gains_a_second_name() { + let base = temp("appledouble-hardlink-reclaim"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companions_held = 2; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let main = c.touch(&root, b"anchor", 0o644).unwrap(); + let companion = c.touch(&root, b"._anchor", 0o644).unwrap(); + let payload = b"held-cap-preserve-me"; + c.write(&companion.handle, 0, payload).unwrap(); + c.link(&main.handle, &root, b"anchor-alias").unwrap(); + let orphan = c.touch(&root, b"._orphan", 0o644).unwrap(); + assert_eq!(server.held().companions, 2); + c.touch(&root, b"other", 0o644).unwrap(); + c.touch(&root, b"._other", 0o644).unwrap(); + assert_eq!(c.read_all(&companion.handle, 1024), payload); + assert_eq!(c.lookup(&root, b"anchor").unwrap().0, main.handle); + assert_eq!(c.lookup(&root, b"anchor-alias").unwrap().0, main.handle); + assert_eq!(c.getattr(&orphan.handle), Err(STALE)); + assert_eq!(server.held().companions, 2); + assert_eq!(server.held().names_refused, 0); + drop(c); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +/// The process's soft and hard `RLIMIT_NOFILE`. +fn nofile_limits() -> (libc::rlim_t, libc::rlim_t) { + let mut limit = libc::rlimit { + rlim_cur: 0, + rlim_max: 0, + }; + // SAFETY: `getrlimit` only fills the limit structure it is given. + let asked = unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &mut limit) }; + assert_eq!(asked, 0, "RLIMIT_NOFILE is readable"); + (limit.rlim_cur, limit.rlim_max) +} + +/// Sets the process's soft `RLIMIT_NOFILE`, leaving the hard limit alone. +fn set_nofile_soft(soft: libc::rlim_t) { + let (_, hard) = nofile_limits(); + let limit = libc::rlimit { + rlim_cur: soft, + rlim_max: hard, + }; + // SAFETY: a soft limit at or below the hard limit is always allowed. + let set = unsafe { libc::setrlimit(libc::RLIMIT_NOFILE, &limit) }; + assert_eq!(set, 0, "soft RLIMIT_NOFILE is settable"); +} + +/// Puts the process's soft `RLIMIT_NOFILE` back when it drops, `panic` included. +struct SoftNofile(libc::rlim_t); +impl SoftNofile { + fn lower(soft: libc::rlim_t) -> Self { + let (was, _) = nofile_limits(); + set_nofile_soft(soft); + Self(was) + } +} +impl Drop for SoftNofile { + fn drop(&mut self) { + set_nofile_soft(self.0); + } +} + +/// The descriptors this process holds, counted from the kernel's own view. +fn open_fds() -> Option { + ["/dev/fd", "/proc/self/fd"] + .into_iter() + .find_map(|dir| fs::read_dir(dir).ok()) + .map(|entries| entries.flatten().count()) +} + +#[test] +fn a_spilled_companion_keeps_its_length_and_bytes_together() { + let base = temp("appledouble-spilled-race"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + rig.companion_spill_dir = Some(base.join("spill-race")); + // Smaller than the body below, which therefore lives on disk. + rig.companion_resident_bytes = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let mut other = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + let name = b"._raced".as_slice(); + let made = c.touch(&root, b"raced", 0o644).unwrap(); + let ad = c.touch(&root, name, 0o644).unwrap(); + let payload = pattern(29, 2048); + c.write(&ad.handle, 0, &payload).unwrap(); + assert_eq!(made.handle, c.lookup(&root, b"raced").unwrap().0); + assert_eq!(server.held().companion_bytes, 0, "the body spilled"); + + // A truncate and a write of this companion start together, round after + // round: each runs to completion under the companion's own gate, so the + // length a reply reports is always the length its file holds, and a read + // never asks for bytes the file does not have (NFS3ERR_IO). + for round in 0..64 { + let start = std::sync::Barrier::new(2); + let empty = Set { + size: Some(0), + ..Set::default() + }; + let (a, b) = std::thread::scope(|scope| { + let a = scope.spawn(|| { + start.wait(); + c.setattr(&ad.handle, empty, None) + }); + let b = scope.spawn(|| { + start.wait(); + other.write(&ad.handle, 0, &payload) + }); + (a.join().unwrap(), b.join().unwrap()) + }); + a.unwrap(); + b.unwrap(); + let size = c.getattr(&ad.handle).unwrap().size as usize; + assert!( + size == 0 || size == payload.len(), + "round {round}: length {size} of a truncate or a write" + ); + assert_eq!( + c.read_all(&ad.handle, 4096).len(), + size, + "round {round}: the bytes served match the length" + ); + } + + drop((c, other)); + let released = server.stop(); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + +/// Set in the child process [`run_alone`] starts, so it runs the body of the one +/// test it was started for. +const FD_LIMIT_CHILD: &str = "LAYERFS_NFS_FD_LIMIT_CHILD"; + +/// Re-runs one test of this binary in its own process, so a change of +/// process-wide state (a soft `RLIMIT_NOFILE`, the descriptors this process +/// holds) can neither reach nor be reached by the tests running in parallel in +/// this one. `name` is selected with `--exact`, so exactly that test runs. +fn run_alone(marker: &str, name: &str) { + // Bounded: a child that hangs is killed and fails this test, so it never + // outlives the parent holding its server and spill directory. + const DEADLINE: Duration = Duration::from_secs(90); + let exe = std::env::current_exe().expect("the test binary's own path"); + let mut child = std::process::Command::new(exe) + .arg("--exact") + .arg(name) + .arg("--test-threads=1") + .env(marker, "1") + .spawn() + .expect("the test binary starts again"); + let started = std::time::Instant::now(); + let status = loop { + if let Some(status) = child.try_wait().expect("the child's status") { + break status; + } + if started.elapsed() >= DEADLINE { + drop(child.kill()); + drop(child.wait()); + panic!("{name} did not finish within {DEADLINE:?} in its own process"); + } + std::thread::sleep(Duration::from_millis(50)); + }; + assert!(status.success(), "{name} failed in its own process"); +} + +/// The export opens a spilled body by path for one operation and closes it +/// again, so companions far outnumbering the process's own file limit all +/// read and write: a descriptor per spilled body would end in `EMFILE` here. +#[test] +fn spilled_companions_outnumber_the_open_file_limit() { + // The soft limit is process-wide and the descriptor count is the whole + // process's: both are set and asserted in a process running this test + // alone, never next to the tests this binary runs in parallel. + if std::env::var_os(FD_LIMIT_CHILD).is_none() { + run_alone( + FD_LIMIT_CHILD, + "spilled_companions_outnumber_the_open_file_limit", + ); + return; + } + let base = temp("appledouble-fd"); + let tree = base.join("tree"); + source(&tree); + let mut rig = rig::Rig::new(&tree, &base.join("rig"), Duration::from_secs(30)); + let spill_dir = base.join("spill-fd"); + rig.companion_spill_dir = Some(spill_dir.clone()); + rig.companion_resident_bytes = 1024; + let budget = 1024; + let server = rig.export(TcpListener::bind("127.0.0.1:0").unwrap(), UID, GID, false); + let mut c = Client::connect(server.local_addr(), UID, GID); + let root = c.mnt("/"); + + // Four times as many companions as the process may hold open at once. + // This process runs no other test: the limit and the count are its own. + let (soft, hard) = nofile_limits(); + let limit = soft.min(hard).min(512); + let count = limit as usize * 4; + let payload = pattern(29, 600); + let mut handles = Vec::with_capacity(count); + { + let _restored = SoftNofile::lower(limit); + assert_eq!(nofile_limits().0, limit); + for i in 0..count { + let name = format!("._fd-{i}"); + let made = c.touch(&root, name.as_bytes(), 0o644).unwrap(); + c.write(&made.handle, 0, &payload).unwrap(); + handles.push((made.handle, made.attr.fileid)); + } + assert!(server.held().companion_bytes <= budget); + let (on_disk, _) = spilled(&spill_dir); + assert_eq!(on_disk, count - 1, "all but the newest body spilled"); + if let Some(fds) = open_fds() { + assert!( + fds < count / 4, + "{fds} descriptors open for {count} companions" + ); + } + for (i, (handle, fileid)) in handles.iter().enumerate() { + assert_eq!(c.read_all(handle, 64 * 1024), payload, "companion {i}"); + // The newest body is still resident; every older one is on disk. + assert_eq!( + spill_dir.join(fileid.to_string()).is_file(), + i + 1 < count, + "companion {i}" + ); + } + // The disk half still writes and truncates through its own open. + let (ref h0, _) = handles[0]; + c.write(h0, 0, b"opened by path").unwrap(); + let shrink = Set { + size: Some(14), + ..Set::default() + }; + c.setattr(h0, shrink, None).unwrap(); + assert_eq!(c.read_all(h0, 64), b"opened by path"); + } + assert_eq!(nofile_limits().0, soft, "the soft limit is put back"); + + drop(c); + let released = server.stop(); + assert_eq!(released.companions, count); + assert!(released.companion_bytes <= budget); + assert!( + !spill_dir.exists(), + "export stop removes the spill directory" + ); + let (_, outstanding) = rig.stop(released); + assert_eq!(outstanding, 0); + fs::remove_dir_all(base).unwrap(); +} + #[test] fn tickets_are_released_only_after_the_reply() { let base = temp("tickets"); @@ -831,12 +1532,13 @@ impl layerfs_mount_ports::ports::RequestServices for CountingRequest { handle: u64, offset: u64, after: Option>, + attributes: bool, ) -> layerfs_mount_ports::ports::ServiceFuture< '_, layerfs_mount_ports::ports::ServiceReply>, > { self.inner - .directory_visit(mount, serial, handle, offset, after) + .directory_visit(mount, serial, handle, offset, after, attributes) } fn publish_cookies( &self, @@ -1014,8 +1716,9 @@ fn create_write_remove_and_apple_double_avoid_redundant_owner_jobs_and_orphans() // 4. AppleDouble companion changing lifecycle (CREATE, WRITE, SETATTR, // REMOVE) issues 0 SQLite owner jobs (0 observe_visit, 0 mutate_visit), - // and LOOKUP of an absent companion issues 0 lookup observe_visit - // (only the 1 parent getattr in nfs.rs proc 3). + // and LOOKUP of an absent companion issues none either: the export + // refuses the name before any visit, and the reply's directory + // attributes come from the facts it already published. let before = counts.snapshot(); let ad = c.touch(&root, b"._single.txt", 0o644).unwrap(); // The directory's wcc_data is not a hole: a companion changes nothing in @@ -1055,8 +1758,8 @@ fn create_write_remove_and_apple_double_avoid_redundant_owner_jobs_and_orphans() assert_eq!(c.lookup(&root, b"._single.txt").map(|_| ()), Err(NOENT)); assert_eq!( counts.snapshot(), - (before.0 + 1, before.1, before.2, before.3), - "AppleDouble LOOKUP avoids the target lookup visit" + before, + "an absent AppleDouble LOOKUP issues no owner job at all" ); // 5. REMOVE drops the last link and retires the synthetic kernel's file diff --git a/engine/crates/layerfs-store-service/tests/postgresql_readdirplus_window.rs b/engine/crates/layerfs-store-service/tests/postgresql_readdirplus_window.rs new file mode 100644 index 0000000000..8c1bfff01f --- /dev/null +++ b/engine/crates/layerfs-store-service/tests/postgresql_readdirplus_window.rs @@ -0,0 +1,614 @@ +//! LP73 Ask 1-B on a PostgreSQL Store: a READDIRPLUS window reads its +//! inherited facts in batches — one batch length demand for the window and +//! one batch inode demand for each level of the inode tree the cache does not +//! already answer — as a SQLite Store does, and answers the facts a per-name +//! LOOKUP answers. What it counts is a partly warm window: the visits before +//! it read the inode table's upper level into the same cache, so its batches +//! are not a fresh mount's first window's. +//! +//! The window is driven through the product's mount path, not a fixture store: +//! a Workspace bound on the Store, OPENDIR, the reading visit, and the window's +//! facts read outside the owner over the Workspace's own base. Those are the +//! calls `layerfs-mount-ports`' `DirectoryStream` makes for a READDIRPLUS +//! reply. `Store::work()` counts the port demands themselves, so a PostgreSQL +//! and a SQLite Store are compared on the same counters. +//! +//! Needs a PostgreSQL server: set `LAYERFS_TEST_POSTGRES_URL` (for example +//! `host=127.0.0.1 port=5432 user=layerfs password=… dbname=layerfs_test +//! sslmode=disable`). Without it the two PostgreSQL cases report NOT_RUN and +//! assert nothing, while the SQLite cases still run. +#[path = "support/installed_store.rs"] +#[allow(dead_code)] +mod installed; + +use layerfs_content::filesystem::attributes::PortableMetadata; +use layerfs_content::object::inode_leaf::InodeKind; +use layerfs_history::{ + BranchId, ForkRequest, ForkSource, HistoryCatalog, HistoryCatalogConfig, HistoryName, + LayerStackId, WorkspaceId, +}; +use layerfs_persistence::{PostgresHandles, PostgresSelection, StoreSelection}; +use layerfs_project::{init, InitRequest}; +use layerfs_storage::{ReservationBlocks, Storage, StoragePolicy}; +use layerfs_store_service::bootstrap::open_store_observed; +use layerfs_store_service::store::{BindRequest, StoreWork}; +use layerfs_store_service::{Owner, OwnerConfig, StoreService}; +use layerfs_telemetry::timer::Timing; +use layerfs_workspace::{ + CanonicalCache, CanonicalClient, KernelDirectoryRead, KernelDirectoryWindow, + KernelReadDecision, VisitFacts, +}; +use std::collections::BTreeMap; +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use std::time::{Duration, Instant}; + +const BINDING: &[u8] = b"readdirplus-window-batches"; +const CURSOR: [u8; 32] = [73; 32]; +const PROJECT: &str = "window"; +const BRANCH_NAME: &str = "work"; +/// The daemon's Store object cache. +const CACHE_BYTES: usize = 64 * 1024 * 1024; +/// Most OPENDIR rounds one undecided visit gets before the test fails. +const ROUNDS: usize = 4; +/// The branch the SQLite fixture's installed Store already holds: stack +/// `[23; 16]`, branch `[24; 16]`, named `main` under the project `installed`. +const INSTALLED_BRANCH: [u8; 16] = [24; 16]; + +/// The names below the root: `files` regular files of known bytes, and one +/// subdirectory holding one file of its own. +fn tree(files: usize) -> Vec<(String, Vec)> { + (0..files) + .map(|n| { + let name = format!("f{n:04}"); + let bytes = vec![(n % 251) as u8; 16 + n % 97]; + (name, bytes) + }) + .collect() +} + +fn build(source: &Path, files: usize) { + for (name, bytes) in tree(files) { + std::fs::write(source.join(name), bytes).unwrap(); + } + let sub = source.join("sub"); + std::fs::create_dir(&sub).unwrap(); + std::fs::write(sub.join("inner"), b"the subdirectory's only file\n").unwrap(); +} + +/// The port demands one window's facts made. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +struct Counts { + object_batches: u64, + object_ids: u64, + length_batches: u64, + length_ids: u64, +} +impl Counts { + fn between(before: StoreWork, after: StoreWork) -> Self { + Self { + object_batches: after.object_batches - before.object_batches, + object_ids: after.object_ids - before.object_ids, + length_batches: after.length_batches - before.length_batches, + length_ids: after.length_ids - before.length_ids, + } + } +} +/// One entry's facts as the reply showed them. +#[derive(Clone, Debug, Eq, PartialEq)] +struct Fact { + name: String, + kind: InodeKind, + metadata: PortableMetadata, + logical_len: u64, + subdirs: u64, +} +impl Fact { + /// What two Stores must answer identically: name, kind, permission bits, + /// length and child-directory count. The mtime is the source tree's, and + /// each test builds its own. + fn shape(&self) -> (&str, InodeKind, u32, u64, u64) { + ( + &self.name, + self.kind, + self.metadata.mode, + self.logical_len, + self.subdirs, + ) + } +} + +/// What one READDIRPLUS window answered and what it cost. +struct Measured { + counts: Counts, + facts: Vec, + exhausted: bool, +} + +/// One READDIRPLUS window of `branch`'s root, driven as a mount drives +/// it: OPENDIR, the reading visit, one Store reader for the window's facts, +/// and the reply's offsets published and then reused. +fn measure( + service: &StoreService, + owner: &Owner, + files: usize, + tag: &str, + branch: BranchId, +) -> Measured { + let bound = service + .store + .bind( + owner.client(), + BindRequest { + workspace: WorkspaceId::from_authority([91; 32]).unwrap(), + branch, + }, + ) + .unwrap_or_else(|refusal| panic!("{tag}: bind refused: {refusal:?}")) + .workspace; + let operation = bound.operation().unwrap(); + let route = bound.route(); + let jobs = operation.overlay(); + let workspace = operation.workspace(); + let base = workspace.base().unwrap(); + let root = base.root().root_inode().serial(); + let mount = jobs.kernel_mount(route, root).unwrap(); + // The cache starts empty, so every fact this window shows is the Store's + // to read. The OPENDIR below and the facts it supplies fill it with the + // inode table's upper level, so the window that follows is not a fresh + // mount's first one. + let resident = Arc::new(CanonicalClient::resident(Arc::new(CanonicalCache::new( + 1 << 20, + )))); + + // OPENDIR: owner jobs that ask the Store nothing, and the facts they name + // read outside them. + let mut facts = VisitFacts::default(); + let mut directory = None; + for _ in 0..ROUNDS { + let visit = workspace + .kernel_opendir_visit(resident.clone(), mount, 1, root, Arc::new(facts.clone())) + .unwrap(); + let before = service.store.work(); + let outcome = jobs.kernel_observe_visit(route, Box::new(visit)).unwrap(); + assert_eq!( + service.store.work(), + before, + "{tag}: an owner job made a Store demand" + ); + match &outcome.decision { + Some(KernelReadDecision::Needs(needs)) => facts + .supply(&workspace.base().unwrap(), needs, None) + .unwrap(), + Some(KernelReadDecision::Value(_)) => { + directory = outcome.directory_candidate; + break; + } + other => panic!("{tag}: undecided OPENDIR: {other:?}"), + } + } + let directory = directory.unwrap_or_else(|| panic!("{tag}: an open directory")); + + // The reading visit: one read-only owner job that makes no Store demand. + let visit = workspace + .kernel_directory_visit( + resident.clone(), + mount, + root, + directory.owner_id(), + KernelDirectoryRead { + offset: 2, + after: None, + attributes: true, + }, + ) + .unwrap(); + let before_visit = service.store.work(); + let reply = jobs.kernel_directory_visit(route, visit).unwrap(); + assert_eq!( + service.store.work(), + before_visit, + "{tag}: the reading visit made a Store demand" + ); + let window = KernelDirectoryWindow::clone(&reply); + drop(reply); + assert!( + window.needs_base(true), + "{tag}: the window leaves its facts to the Store" + ); + + // The window's facts, outside the owner, over the Workspace's reader: one + // batch length demand for the window and one batch inode demand per tree + // level the OPENDIR left unread. + let before = service.store.work(); + let batch = window.finish_with(Some(&base), true).unwrap(); + let after = service.store.work(); + let counts = Counts::between(before, after); + eprintln!("{tag}: port demands of one window: {counts:?}"); + + let names: Vec> = batch + .entries + .iter() + .map(|entry| entry.name.clone()) + .collect(); + let mut shown = Vec::with_capacity(batch.entries.len()); + for entry in &batch.entries { + let name = String::from_utf8(entry.name.clone()).unwrap(); + let stat = entry + .stat + .as_ref() + .unwrap_or_else(|| panic!("{tag}: no facts for {name}")); + assert_eq!(stat.kind, entry.kind, "{tag}: kind of {name}"); + // A per-name LOOKUP answers the same facts, field for field: the + // window's batch read and the single demand agree. + let lookup = base.stat(entry.serial).unwrap(); + assert_eq!(stat.kind, lookup.value.kind, "{tag}: LOOKUP kind of {name}"); + assert_eq!( + stat.metadata, lookup.metadata, + "{tag}: LOOKUP metadata of {name}" + ); + assert_eq!( + stat.logical_len, lookup.logical_len, + "{tag}: LOOKUP length of {name}" + ); + shown.push(Fact { + name, + kind: stat.kind, + metadata: stat.metadata, + logical_len: stat.logical_len, + subdirs: stat.subdirs, + }); + } + // Every inherited name and the subdirectory, exactly once, with the bytes + // the fixture wrote. + let expected: BTreeMap = tree(files) + .into_iter() + .map(|(name, bytes)| (name, bytes.len())) + .collect(); + assert_eq!(shown.len(), files + 1, "{tag}: every name of the window"); + for fact in &shown { + if let Some(len) = expected.get(&fact.name) { + assert_eq!( + fact.kind, + InodeKind::RegularFile, + "{tag}: kind {}", + fact.name + ); + assert_eq!(fact.logical_len, *len as u64, "{tag}: length {}", fact.name); + } else { + assert_eq!(fact.name, "sub", "{tag}: the subdirectory"); + assert_eq!(fact.kind, InodeKind::Directory, "{tag}: kind sub"); + assert_eq!(fact.subdirs, 0, "{tag}: sub holds no directory"); + assert_eq!(fact.logical_len, 0, "{tag}: a directory has no length"); + } + } + + // The reply's offsets are published once, and a request inside that reply + // is answered at them instead of recording them again: the handles a + // READDIRPLUS reply hands out follow these offsets. + let first = batch.first; + let exhausted = batch.exhausted; + assert!(exhausted, "{tag}: one window lists the root"); + let offer = batch + .publish + .clone() + .unwrap_or_else(|| panic!("{tag}: a fresh reply publishes its names")); + jobs.kernel_directory_publish(route, offer, names.clone()) + .unwrap(); + let reuse = workspace + .kernel_directory_visit( + resident.clone(), + mount, + root, + directory.owner_id(), + KernelDirectoryRead { + offset: 2, + after: None, + attributes: true, + }, + ) + .unwrap(); + let reply = jobs.kernel_directory_visit(route, reuse).unwrap(); + let window = KernelDirectoryWindow::clone(&reply); + drop(reply); + let reused = window.finish_with(Some(&base), true).unwrap(); + assert_eq!( + reused + .entries + .iter() + .map(|entry| entry.name.clone()) + .collect::>(), + names, + "{tag}: the published reply is answered at its offsets" + ); + assert_eq!(reused.first, first, "{tag}: at the published offsets"); + assert!( + reused.publish.is_none(), + "{tag}: a reused reply records nothing again" + ); + // A seek inside the published reply resumes strictly after its name, and + // hands out a fresh range for what follows it. + let seek = workspace + .kernel_directory_visit( + resident, + mount, + root, + directory.owner_id(), + KernelDirectoryRead { + offset: first + names.len() as u64 - 2, + after: None, + attributes: true, + }, + ) + .unwrap(); + let reply = jobs.kernel_directory_visit(route, seek).unwrap(); + let window = KernelDirectoryWindow::clone(&reply); + drop(reply); + let next = window.finish_with(Some(&base), true).unwrap(); + assert_eq!( + next.entries + .iter() + .map(|entry| entry.name.clone()) + .collect::>(), + names[names.len() - 1..], + "{tag}: the offset resumes strictly after its name" + ); + assert!( + next.entries.iter().all(|entry| entry.stat.is_some()), + "{tag}: the resumed window's facts too" + ); + + jobs.kernel_directory_close(route, mount, root, directory.owner_id()) + .unwrap(); + jobs.kernel_revoke(route, mount).unwrap(); + bound.close().unwrap(); + owner.client().retire_namespace(route.namespace()).unwrap(); + Measured { + counts, + facts: shown, + exhausted, + } +} + +fn catalog() -> HistoryCatalogConfig { + HistoryCatalogConfig { + binding_key: BINDING.to_vec(), + cursor_key: CURSOR, + incarnation: 1, + } +} + +fn url() -> Option { + let url = std::env::var("LAYERFS_TEST_POSTGRES_URL").ok(); + if url.is_none() { + eprintln!("NOT_RUN: LAYERFS_TEST_POSTGRES_URL is unset"); + } + url +} + +/// The test's own PostgreSQL schema and source tree, dropped when it ends, +/// pass or fail. +struct Postgres { + url: String, + schema: String, + directory: PathBuf, + stack: LayerStackId, +} +impl Postgres { + fn new(tag: &str, url: &str, files: usize, stack: [u8; 16]) -> Self { + let directory = + std::env::temp_dir().join(format!("lfs73-window-{tag}-{}", std::process::id())); + std::fs::create_dir_all(&directory).unwrap(); + let schema = format!("lfs73_window_{tag}_{}", std::process::id()); + let source = directory.join("source"); + std::fs::create_dir(&source).unwrap(); + build(&source, files); + Self { + url: url.to_owned(), + schema, + directory, + stack: LayerStackId::from_authority(stack), + } + } + /// One PostgreSQL Store holding the fixture's tree on one Branch. + fn open(&self) -> (Owner, StoreService) { + let selection = PostgresSelection::new(&self.url, &self.schema); + let created = + PostgresHandles::create(&selection, StoragePolicy::frozen_default(), &catalog()) + .unwrap(); + let storage = Storage::new(created.storage.clone()).unwrap(); + let initialized = Timing::disabled("init", |timing| { + init( + &storage, + &created.history, + InitRequest { + source: &self.directory.join("source"), + acquisition: &created.acquisition, + stack: self.stack, + name: HistoryName::new(PROJECT).unwrap(), + scope_seed: [75; 32], + deadline: Instant::now() + Duration::from_secs(120), + }, + timing, + ) + }) + .0 + .unwrap(); + created + .history + .fork(&ForkRequest { + stack: initialized.stack.id, + branch: pg_branch(self.stack), + name: HistoryName::new(BRANCH_NAME).unwrap(), + source: ForkSource::Layer(initialized.stack.head_layer), + }) + .unwrap(); + drop(storage); + drop(created); + let config = OwnerConfig::default(); + let opened = open_store_observed( + StoreSelection::Postgres(selection), + BINDING, + CURSOR, + config.namespaces, + CACHE_BYTES, + ReservationBlocks::default(), + ) + .unwrap(); + let owner = Owner::start( + &self.directory.join("overlay.sqlite"), + layerfs_overlay::ProfileConfig::default(), + config, + ) + .unwrap(); + let service = StoreService::new(opened, &owner); + (owner, service) + } +} +impl Drop for Postgres { + fn drop(&mut self) { + if let Ok(mut client) = postgres::Client::connect(&self.url, postgres::NoTls) { + let _ = client.batch_execute(&format!("DROP SCHEMA IF EXISTS {} CASCADE", self.schema)); + } + let _ = std::fs::remove_dir_all(&self.directory); + } +} + +/// The Branch this test's PostgreSQL fixtures fork. +fn pg_branch(stack: LayerStackId) -> BranchId { + BranchId::named(stack, &HistoryName::new(BRANCH_NAME).unwrap()) +} + +/// One READDIRPLUS window over an Init'd PostgreSQL Store's root. +fn postgres_window(url: &str, files: usize, tag: &str, stack: [u8; 16]) -> Measured { + let fixture = Postgres::new(tag, url, files, stack); + let (owner, service) = fixture.open(); + let measured = measure(&service, &owner, files, tag, pg_branch(fixture.stack)); + drop(service); + owner.stop().unwrap(); + measured +} + +/// The same window over a SQLite Store built from the same tree, through the +/// installed-Store fixture the Store's own tests use. +fn sqlite_window(files: usize, tag: &str) -> Measured { + let host = installed::Fixture::built(tag, |source| { + build(source, files); + files + 2 + }); + let config = OwnerConfig::default(); + let opened = open_store_observed( + host.config.clone(), + installed::BINDING, + installed::CURSOR, + config.namespaces, + CACHE_BYTES, + ReservationBlocks::default(), + ) + .unwrap(); + let owner = Owner::start( + &host.directory.join("overlay.sqlite"), + layerfs_overlay::ProfileConfig::default(), + config, + ) + .unwrap(); + let service = StoreService::new(opened, &owner); + let measured = measure( + &service, + &owner, + files, + tag, + BranchId::from_authority(INSTALLED_BRANCH), + ); + drop(service); + owner.stop().unwrap(); + host.cleanup(); + measured +} + +#[test] +fn a_postgresql_window_reads_its_facts_in_batches() { + let Some(url) = url() else { + return; + }; + let small = postgres_window(&url, 8, "small", [81; 16]); + let large = postgres_window(&url, 200, "large", [82; 16]); + // One length demand carries the whole window, and it names each ordinary + // file once: no entry asks the provider for its own length. + for (measured, files) in [(&small, 8u64), (&large, 200)] { + assert_eq!(measured.counts.length_batches, 1, "one length demand"); + assert_eq!( + measured.counts.length_ids, files, + "the one length demand names each file once" + ); + } + // The window's object demands and length demands do not grow with the + // names it lists: one batch length demand carries the window's ordinary + // files, and one batch inode demand carries its inherited serials for each + // tree level the cache does not already hold, so the names add no batch + // while a deeper tree adds one. Here the visits before the window read the + // tree's upper level into the same cache, leaving one level: these are not + // a fully cold window's counts. This + // tree's metadata roots are inline and its subdirectory's child count was + // built with the Commit, so no entry here costs a read of its own; an + // entry whose metadata root is an object, a subdirectory counted by a scan + // and a symlink's target are still read one at a time. + assert_eq!( + large.counts.object_batches, small.counts.object_batches, + "8 names: {:?}, 200 names: {:?}", + small.counts, large.counts + ); + for (measured, files) in [(&small, 8u64), (&large, 200)] { + assert_eq!( + measured.counts.object_batches, 1, + "{files} names: one batch inode demand" + ); + } + assert_eq!(small.facts.len(), 9); + assert_eq!(large.facts.len(), 201); + assert!(small.exhausted && large.exhausted); +} + +#[test] +fn a_sqlite_window_makes_the_same_batches_and_answers_the_same_facts() { + let sqlite = sqlite_window(40, "sqlite"); + assert_eq!( + (sqlite.counts.object_batches, sqlite.counts.length_batches), + (1, 1), + "one batch inode demand and one length demand: {:?}", + sqlite.counts + ); + assert_eq!(sqlite.counts.length_ids, 40); + assert_eq!(sqlite.facts.len(), 41); + let Some(url) = url() else { + return; + }; + // The same tree on a PostgreSQL Store, mounted and listed the same way. + let postgres = postgres_window(&url, 40, "compare", [83; 16]); + assert_eq!( + ( + postgres.counts.object_batches, + postgres.counts.length_batches, + postgres.counts.length_ids + ), + ( + sqlite.counts.object_batches, + sqlite.counts.length_batches, + sqlite.counts.length_ids + ), + "the same demands on both Stores: PostgreSQL {:?}, SQLite {:?}", + postgres.counts, + sqlite.counts + ); + // What both Stores must answer identically. The mtime of each fixture's + // own source tree differs between the two runs; it is compared there with + // that tree's own LOOKUP, not across Stores. + assert_eq!( + postgres.facts.iter().map(Fact::shape).collect::>(), + sqlite.facts.iter().map(Fact::shape).collect::>(), + "the same facts on both Stores" + ); + // The offset a reply starts at is the handle's own counter, not a cross + // Store contract; that it lists the whole directory in one window is. + assert!(postgres.exhausted && sqlite.exhausted); +} diff --git a/engine/crates/layerfs-store-service/tests/refresh_lookups.rs b/engine/crates/layerfs-store-service/tests/refresh_lookups.rs index d0c21d221e..0874986666 100644 --- a/engine/crates/layerfs-store-service/tests/refresh_lookups.rs +++ b/engine/crates/layerfs-store-service/tests/refresh_lookups.rs @@ -208,7 +208,7 @@ fn refresh_lookups() { visits += 1; match &outcome.decision { Some(KernelReadDecision::Value(_)) => break, - Some(KernelReadDecision::Refused(_)) => { + Some(KernelReadDecision::Refused { .. }) => { missing += 1; break; } diff --git a/engine/crates/layerfs-workspace/src/lib.rs b/engine/crates/layerfs-workspace/src/lib.rs index 323588aa04..dd93212f7e 100644 --- a/engine/crates/layerfs-workspace/src/lib.rs +++ b/engine/crates/layerfs-workspace/src/lib.rs @@ -55,12 +55,13 @@ pub use operations::file::recognize::{ }; pub use operations::kernel_data::{KernelDataVisit, KernelWindow}; pub use operations::kernel_directory::{ - KernelDirectoryBatch, KernelDirectoryEntry, KernelDirectoryListing, KernelDirectoryVisit, - KernelDirectoryWindow, + KernelDirectoryBatch, KernelDirectoryEntry, KernelDirectoryListing, KernelDirectoryRead, + KernelDirectoryVisit, KernelDirectoryWindow, }; pub use operations::kernel_mutation::KernelMutationOutcome; pub use operations::kernel_read::{ - KernelReadDecision, KernelReadFailure, KernelReadOperation, KernelReadOutcome, KernelReadValue, + Decided, KernelReadDecision, KernelReadFailure, KernelReadOperation, KernelReadOutcome, + KernelReadValue, }; pub use operations::kernel_visit::{ KernelInput, KernelMutationVisit, KernelReadVisit, KernelVisitRequest, diff --git a/engine/crates/layerfs-workspace/src/operations/kernel_directory.rs b/engine/crates/layerfs-workspace/src/operations/kernel_directory.rs index c6a9d54b63..10764718f2 100644 --- a/engine/crates/layerfs-workspace/src/operations/kernel_directory.rs +++ b/engine/crates/layerfs-workspace/src/operations/kernel_directory.rs @@ -3,16 +3,29 @@ //! kernel offset, and one window of current local names with their kinds. //! Inherited names and kinds are merged inside the job when the canonical //! cache holds them; otherwise the request merges them outside the owner -//! over one Store reader, at the base root the visit named. The request then -//! fills its reply and a publishing visit records exactly the accepted -//! names. Nothing is held between the two visits or after the reply. +//! over one Store reader, at the base root the visit named. A reply that +//! shows each entry's facts (READDIRPLUS) takes them from the same memory +//! first; what is left is read outside the owner once the reply's published +//! names are known: one batch length demand and one batch inode demand for +//! each level of the inode tree the cache does not already answer, for the +//! names that reply sends and not for the rest of the window, so those counts +//! follow the tree's depth and the reply's size and not the number of listed +//! names. What those batches +//! do not cover is per entry and unchanged here: a non-inline metadata root, +//! a listed subdirectory's child-directory count, and a symlink's target are +//! still read once for each entry that needs them. The request then fills its +//! reply and a publishing visit records exactly the accepted names. Nothing +//! is held between the two visits or after the reply. use crate::{BaseView, SourceView, ViewStat, Workspace, WorkspaceResult}; -use layerfs_content::{object::inode_leaf::InodeKind, ContentError}; +use layerfs_content::filesystem::inode::{lookup_many, InodeReadWork}; +use layerfs_content::filesystem::Resolved; +use layerfs_content::object::inode_leaf::{InodeKind, InodeValue}; +use layerfs_content::{ContentError, ObjectId}; use layerfs_overlay::{ KernelCookieOffer, KernelDirectoryCursor, KernelDirectoryPage, KernelMount, Overlay, OverlayError, OverlayResult, PAGE_ROWS, }; -use std::{fmt, sync::Arc}; +use std::{collections::BTreeMap, collections::BTreeSet, fmt, sync::Arc}; #[derive(Clone, Debug, Eq, PartialEq)] pub struct KernelDirectoryEntry { @@ -30,6 +43,16 @@ pub struct KernelDirectoryListing { pub continuation: Option>, pub visited: usize, } +/// Where one enumeration request reads and what its reply shows. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct KernelDirectoryRead { + /// The kernel offset this request resumes at. + pub offset: u64, + /// The name it continues after, when it continues an earlier window. + pub after: Option>, + /// The reply shows each entry's facts (READDIRPLUS). + pub attributes: bool, +} /// One READDIR reading visit as one read-only owner job. #[derive(Clone)] pub struct KernelDirectoryVisit { @@ -39,20 +62,23 @@ pub struct KernelDirectoryVisit { offset: u64, after: Option>, resident: BaseView, + /// The reply shows each entry's facts (READDIRPLUS): this visit answers + /// from memory what it holds, and the request reads only what it left. + attributes: bool, } /// What the reading visit found, as plain values its request owns. #[derive(Clone, Debug)] pub struct KernelDirectoryWindow { pub page: KernelDirectoryPage, /// The merged names of the window, when memory answered every inherited - /// name and kind inside the job. + /// name and kind inside the job; a reply that shows facts also takes + /// from here every fact memory held. pub listing: Option, /// The offsets the reply may hand out. Absent when the job decided that /// the window lists no name. pub offer: Option, /// The facts of the directory being listed, when the visit read its own - /// local row and the reply shows them: a READDIRPLUS reply's - /// `dir_attributes` then costs no further read. + /// local row: a reply's `dir_attributes` then costs no further read. pub directory: Option, } /// The entries one reply may offer, in order, with their offsets. @@ -87,17 +113,22 @@ impl fmt::Debug for KernelDirectoryVisit { } } impl Workspace { - /// `resident` answers from memory only. No I/O here. `after` continues - /// an earlier window of the same request past names that listed nothing. + /// `resident` answers from memory only. No I/O here. `read` names the + /// position (continuing past names that listed nothing) and whether the + /// reply shows each entry's facts. pub fn kernel_directory_visit( &self, resident: Arc, mount: KernelMount, serial: u64, handle: u64, - offset: u64, - after: Option>, + read: KernelDirectoryRead, ) -> WorkspaceResult { + let KernelDirectoryRead { + offset, + after, + attributes, + } = read; let base = self.base()?; if mount.engine() != self.route().engine() || mount.root_serial() != base.root().root_inode().serial() @@ -111,6 +142,7 @@ impl Workspace { offset, after, resident: base.with_client(resident), + attributes, }) } } @@ -145,7 +177,25 @@ impl KernelDirectoryVisit { } let listing = (self.resident.identity().0.to_bytes() == page.source().root()) .then(|| listing(&self.resident, &page).ok()) - .flatten(); + .flatten() + .map(|Kinds { listing, values }| { + let mut listing = listing; + // A reply that shows facts takes the local rows this window + // already read and whatever else memory answers, from the base + // values the kinds came from: no inode is read twice here, so + // only the names memory left undecided take the one Store read. + if self.attributes { + for entry in &mut listing.entries { + entry.stat = memory_stat( + &self.resident, + &page, + entry.serial, + values.get(&entry.serial), + ); + } + } + listing + }); let offer = match &listing { Some(listing) if listing.entries.is_empty() => None, _ => Some(db.offer_kernel_cookies(&page)?), @@ -169,6 +219,16 @@ impl KernelDirectoryWindow { pub fn rewound(&self) -> bool { *self.page.cursor() == KernelDirectoryCursor::Rewound } + /// Whether this reply needs the Store reader at all: the visit left the + /// merge undone, or the reply shows facts of a name memory did not hold. + /// A local directory, and a window whose inherited entries are all + /// resident, take no reader and issue no Store read. + pub fn needs_base(&self, attributes: bool) -> bool { + match &self.listing { + None => true, + Some(listing) => attributes && listing.entries.iter().any(|entry| entry.stat.is_none()), + } + } /// The entries this window may offer and their offsets. `base` is the /// Workspace's base over an admitted Store reader and is required when /// the visit left the merge undone; it is read at the root the visit @@ -180,14 +240,23 @@ impl KernelDirectoryWindow { /// the offer's fresh range. /// /// A plain READDIR reply shows no entry's facts, so this reads no - /// portable metadata and no file length. + /// portable metadata and no file length for one: only the names, their + /// kinds and their offsets. pub fn finish(self, base: Option<&BaseView>) -> WorkspaceResult { self.finish_with(base, false) } /// The same for a reply that also shows what each accepted entry is, as - /// READDIRPLUS does: every entry's facts and the directory's own are read - /// here, outside the owner, from the authoritative base — a local entry's - /// facts are its current row, an inherited one's its immutable inode. + /// READDIRPLUS does. Names and kinds come first — from memory in the + /// reading visit, else here in one batch inode demand for each level of the + /// inode tree the cache does not already answer — and the offer then + /// truncates that window to the names this reply publishes, so only those + /// names' facts are read: one batch length demand for them and the same + /// per-level batches. A re-sent reply therefore reads nothing for a name it + /// will not send. Those batches are not the whole + /// cost of an entry: + /// [`base_facts`] still reads an inherited inode's non-inline metadata + /// root, a listed subdirectory's child-directory count and a symlink's + /// target once per entry that needs them, as the base route always did. pub fn finish_with( self, base: Option<&BaseView>, @@ -199,15 +268,22 @@ impl KernelDirectoryWindow { offer, directory, } = self; - // A reply that shows an entry's facts reads the authoritative base, - // not the resident one the reading visit merged with. + // The authoritative base is read at the root the visit named, and + // only when memory did not answer the window's names or its facts. + let undecided = attributes + && merged + .as_ref() + .is_none_or(|listing| listing.entries.iter().any(|entry| entry.stat.is_none())); let base = match base { - Some(base) if attributes || merged.is_none() => Some(base.at(page.source().root())?), + Some(base) if merged.is_none() || undecided => Some(base.at(page.source().root())?), _ => None, }; let listing = match (merged, base.as_deref()) { - (Some(listing), _) if !attributes => listing, - (_, Some(base)) => listing(base, &page)?, + (Some(listing), _) => listing, + // Names and kinds only: a re-sent reply that publishes fewer + // names than this window lists reads no fact of one it will not + // send. `facts` reads what the truncated reply does send. + (_, Some(base)) => listing(base, &page)?.listing, (_, None) => { return Err( ContentError::InvalidRecord("kernel directory window without its base").into(), @@ -238,15 +314,11 @@ impl KernelDirectoryWindow { _ => (offer.first(), Some(offer)), }, }; - // Only the names this reply actually offers are read, and only a - // reply that shows facts reads anything at all. - let (directory, entries) = match base.as_deref() { - Some(base) if attributes => ( - directory.or_else(|| base_stat(base, page.directory().serial()).ok()), - facts(base, &page, entries)?, - ), - _ => (None, entries), - }; + if attributes { + if let Some(base) = base.as_deref() { + facts(base, &page, &mut entries)?; + } + } let exhausted = !truncated && listing.continuation.is_none(); Ok(KernelDirectoryBatch { entries, @@ -258,33 +330,129 @@ impl KernelDirectoryWindow { }) } } -/// One listing's entries with the facts a reply shows for each: a local -/// serial's current row, or an inherited one's immutable base inode. +/// Fills the facts a reply shows for the entries that still lack them: the +/// window's inherited serials in one batch inode demand for each level of the +/// inode tree the cache does not already answer, and the lengths of its +/// regular files in one batch length demand, so listing more names costs no +/// more of either while a deeper tree costs one more inode batch per level. A +/// local serial's facts are its current row. What +/// [`base_facts`] still reads once per entry is not batched here. fn facts( base: &BaseView, page: &KernelDirectoryPage, - entries: Vec, -) -> WorkspaceResult> { - entries + entries: &mut [KernelDirectoryEntry], +) -> WorkspaceResult<()> { + let inherited: Vec = entries + .iter() + .filter(|entry| entry.stat.is_none() && local_row(page, entry.serial).is_none()) + .map(|entry| entry.serial) + .collect::>() .into_iter() - .map(|mut entry| { - entry.stat = Some( - match page - .local_inodes - .binary_search_by_key(&entry.serial, |row| row.0) - { - Ok(index) => ViewStat::from(page.local_inodes[index].1.clone()), - Err(_) => base_stat(base, entry.serial)?, - }, - ); - Ok(entry) - }) - .collect() + .collect(); + let found = inherited_values(base, &inherited)?; + for entry in entries.iter_mut().filter(|entry| entry.stat.is_none()) { + entry.stat = Some(match local_row(page, entry.serial) { + Some(row) => ViewStat::from(row.clone()), + None => { + let value = *found.get(&entry.serial).ok_or(ContentError::PathNotFound)?; + base_facts(base, entry.serial, value)? + } + }); + } + Ok(()) +} +/// The base values of the window's inherited serials, in one batch inode +/// demand for each level of the inode tree the cache does not already answer. +fn inode_values(base: &BaseView, serials: &[u64]) -> WorkspaceResult> { + if serials.is_empty() { + return Ok(BTreeMap::new()); + } + let values = lookup_many( + base.client().as_ref(), + base.table(), + serials, + &mut InodeReadWork::default(), + )?; + Ok(serials + .iter() + .copied() + .zip(values) + .filter_map(|(serial, value)| Some((serial, value?))) + .collect()) +} +/// The base values of the window's inherited serials, in one batch inode +/// demand for each level of the inode tree the cache does not already answer, +/// after one length demand remembered the window's ordinary file lengths. +fn inherited_values( + base: &BaseView, + serials: &[u64], +) -> WorkspaceResult> { + let values = inode_values(base, serials)?; + // Every ordinary file's length, from the one demand this window makes. + let roots: Vec = values + .values() + .filter(|value| value.kind == InodeKind::RegularFile) + .map(|value| value.content_root) + .collect(); + if !roots.is_empty() { + base.client().provide_lengths(&roots)?; + } + Ok(values) +} +/// The facts of one inherited name: its base inode, the metadata every +/// attribute carries, its content length and, for a directory, the count its +/// POSIX link count is derived from. The metadata root, a directory's child +/// directory count and a symlink's target are read here one entry at a time: +/// the base has no batch port for them, and this route adds none. +fn base_facts(base: &BaseView, serial: u64, value: InodeValue) -> WorkspaceResult { + let stat = + base.stat_resolved_with_lengths(Resolved { serial, value }, base.client().as_ref())?; + let subdirs = match stat.value.kind { + InodeKind::Directory => base.subdirs(stat.value)?, + _ => 0, + }; + Ok(ViewStat::of_base(stat, subdirs)) +} +/// The local row of one listed serial at this window's view, when it has one. +fn local_row(page: &KernelDirectoryPage, serial: u64) -> Option<&layerfs_overlay::Inode> { + page.local_inodes + .binary_search_by_key(&serial, |row| row.0) + .ok() + .map(|index| &page.local_inodes[index].1) +} +/// The content kind of a local row's kind. +const fn kind_of(kind: layerfs_overlay::InodeKind) -> InodeKind { + match kind { + layerfs_overlay::InodeKind::File => InodeKind::RegularFile, + layerfs_overlay::InodeKind::Directory => InodeKind::Directory, + layerfs_overlay::InodeKind::Symlink => InodeKind::Symlink, + } +} +/// The facts of one entry as far as memory alone answers them: a local row, +/// or an inherited inode whose value this window's listing already read, with +/// the metadata, length and child-directory count this daemon's caches hold. +/// Anything else is absent here, and the request's one Store read supplies it. +fn memory_stat( + base: &BaseView, + page: &KernelDirectoryPage, + serial: u64, + value: Option<&InodeValue>, +) -> Option { + if let Some(row) = local_row(page, serial) { + return Some(ViewStat::from(row.clone())); + } + base_facts(base, serial, *value?).ok() +} +/// One window's listed names over `base`, before their kinds and facts. +struct MergedNames { + names: Vec<(Vec, u64)>, + continuation: Option>, + visited: usize, } /// One window's merged names over `base`, which must be the page's own base /// root. This issues no SQL and acquires no kernel lookup reference. An /// empty result with a continuation needs another window of the same request. -fn listing(base: &BaseView, page: &KernelDirectoryPage) -> WorkspaceResult { +fn merge(base: &BaseView, page: &KernelDirectoryPage) -> WorkspaceResult { let view = SourceView { base: base.clone(), source: page.source(), @@ -306,8 +474,8 @@ fn listing(base: &BaseView, page: &KernelDirectoryPage) -> WorkspaceResult WorkspaceResult match page.local_inodes[index].1.kind { - layerfs_overlay::InodeKind::File => InodeKind::RegularFile, - layerfs_overlay::InodeKind::Directory => InodeKind::Directory, - layerfs_overlay::InodeKind::Symlink => InodeKind::Symlink, - }, - Err(_) => view.base().inode(serial)?.value.kind, + Ok(MergedNames { + names: listing.entries, + continuation: listing.continuation, + visited: listing.visited, + }) +} +/// One window's merged names over `base` with their kinds, and the base +/// values those inherited kinds came from: a reply that shows facts takes them +/// from here, so no inode this listing read is read again. +struct Kinds { + listing: KernelDirectoryListing, + /// Base values of the inherited names, by serial. + values: BTreeMap, +} +/// One window's merged names over `base` with their kinds: a local row answers +/// its own kind, and the window's inherited serials come in one batch inode +/// demand for each level of the inode tree the cache does not already answer. +/// Kinds alone cost no length demand, which belongs to a reply's facts. +fn listing(base: &BaseView, page: &KernelDirectoryPage) -> WorkspaceResult { + let merged = merge(base, page)?; + let inherited: Vec = merged + .names + .iter() + .map(|(_, serial)| *serial) + .filter(|serial| local_row(page, *serial).is_none()) + .collect::>() + .into_iter() + .collect(); + let values = inode_values(base, &inherited)?; + let mut entries = Vec::with_capacity(merged.names.len()); + for (name, serial) in merged.names { + let kind = match local_row(page, serial) { + Some(row) => kind_of(row.kind), + None => { + let value = *values.get(&serial).ok_or(ContentError::PathNotFound)?; + value.kind + } }; entries.push(KernelDirectoryEntry { name, @@ -335,20 +528,12 @@ fn listing(base: &BaseView, page: &KernelDirectoryPage) -> WorkspaceResult WorkspaceResult { - let stat = base.stat(serial)?; - let subdirs = match stat.value.kind { - InodeKind::Directory => base.subdirs(stat.value)?, - _ => 0, - }; - Ok(ViewStat::of_base(stat, subdirs)) -} diff --git a/engine/crates/layerfs-workspace/src/operations/kernel_read.rs b/engine/crates/layerfs-workspace/src/operations/kernel_read.rs index a0bfea566e..ad457daa71 100644 --- a/engine/crates/layerfs-workspace/src/operations/kernel_read.rs +++ b/engine/crates/layerfs-workspace/src/operations/kernel_read.rs @@ -32,15 +32,34 @@ pub enum KernelReadOperation { #[derive(Debug)] pub enum KernelReadDecision { Needs(Vec), - Value(Inode), - Refused(Refusal), + Value(Decided), + /// A refusal and, when the refusing job read it, the directory that job + /// read: a LOOKUP that binds no name still read its parent's row, so the + /// failure's directory attributes are those fresh facts and cost no + /// second visit. `None` when no job read a directory (a refusal decided + /// before the visit, or one about the name itself). + Refused { + refusal: Refusal, + directory: Option, + }, Failed(WorkspaceError), } +/// What a read decided: the inode it names and, for a LOOKUP, the directory +/// it named it in. That job read the directory's own row to resolve the name, +/// so a reply that shows the directory's attributes needs no second visit. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Decided { + pub inode: Inode, + pub parent: Option, +} pub type KernelReadOutcome = KernelObservation; #[derive(Debug)] pub struct KernelReadValue { pub stat: ViewStat, + /// The directory a LOOKUP named the inode in, from the same job: a reply + /// that carries the directory's attributes reads nothing more for them. + pub parent: Option, pub file: Option, pub directory: Option, pub original: Arc, @@ -90,20 +109,25 @@ pub(crate) fn decide_read( kernel: None, needs: Vec::new(), }; - let decision = match decide(operation, &mut eval) { - Ok(Some(inode)) => KernelReadDecision::Value(inode), + // The directory a refusing decision read, when it read one. + let mut refused_directory = None; + let decision = match decide(operation, &mut eval, &mut refused_directory) { + Ok(Some(decided)) => KernelReadDecision::Value(decided), Ok(None) if !eval.needs.is_empty() => KernelReadDecision::Needs(eval.needs), Ok(None) => KernelReadDecision::Failed( ContentError::InvalidRecord("empty kernel read needs").into(), ), Err(WorkspaceError::Overlay(error)) => return Err(error), - Err(WorkspaceError::Refused(refusal)) => KernelReadDecision::Refused(refusal), + Err(WorkspaceError::Refused(refusal)) => KernelReadDecision::Refused { + refusal, + directory: refused_directory, + }, Err(error) => KernelReadDecision::Failed(error), }; Ok(match decision { KernelReadDecision::Needs(_) => KernelDecision::Needs(decision), - KernelReadDecision::Value(ref inode) => KernelDecision::Finished { - inode: Some(inode.clone()), + KernelReadDecision::Value(ref decided) => KernelDecision::Finished { + inode: Some(decided.inode.clone()), value: decision, }, _ => KernelDecision::Finished { @@ -112,20 +136,37 @@ pub(crate) fn decide_read( }, }) } -fn decide(operation: &KernelReadOperation, eval: &mut Eval<'_>) -> WorkspaceResult> { +/// One read's decision. `refused` receives the directory row a refusal read, +/// when the refused operation read one (LOOKUP of a name that binds nothing). +fn decide( + operation: &KernelReadOperation, + eval: &mut Eval<'_>, + refused: &mut Option, +) -> WorkspaceResult> { match operation { // The source's independent read reference permits removed metadata. KernelReadOperation::Getattr { serial } | KernelReadOperation::Data { serial } => { - eval.target(*serial) + Ok(eval.target(*serial)?.map(|inode| Decided { + inode, + parent: None, + })) + } + KernelReadOperation::Opendir { serial } => { + Ok(eval.directory(*serial)?.map(|inode| Decided { + inode, + parent: None, + })) } - KernelReadOperation::Opendir { serial } => eval.directory(*serial), // The kernel names an inode it still references. A file whose // last name is gone stays openable under that reference, so a // path open racing an unlink or replacement gets the old file. KernelReadOperation::Open { serial, .. } => { let inode = eval.target(*serial)?; match inode { - Some(inode) if inode.kind == InodeKind::File => Ok(Some(inode)), + Some(inode) if inode.kind == InodeKind::File => Ok(Some(Decided { + inode, + parent: None, + })), Some(inode) if inode.kind == InodeKind::Directory => { Err(WorkspaceError::Refused(Refusal::IsDirectory)) } @@ -137,11 +178,22 @@ fn decide(operation: &KernelReadOperation, eval: &mut Eval<'_>) -> WorkspaceResu let directory = eval.directory(*parent)?; let layers = eval.layers(*parent, name)?; let bound = eval.bound(*parent, directory.as_ref(), name, layers); - let (Some(_), Some(bound)) = (directory, bound) else { + let (Some(directory), Some(bound)) = (directory, bound) else { return Ok(None); }; - let serial = bound.ok_or(WorkspaceError::Refused(Refusal::Missing))?; - eval.target(serial) + let Some(serial) = bound else { + // The name binds nothing. This job still read the directory's + // own row, so its fresh facts answer the failure's directory + // attributes without a second visit. + *refused = Some(directory); + return Err(WorkspaceError::Refused(Refusal::Missing)); + }; + // The name resolved, so the reply also says what the directory + // is: the same job read its row, and no second visit is needed. + Ok(eval.target(serial)?.map(|inode| Decided { + inode, + parent: Some(directory), + })) } } } diff --git a/engine/crates/layerfs-workspace/tests/common/mod.rs b/engine/crates/layerfs-workspace/tests/common/mod.rs index 83fbcbb5d5..702bfffdb6 100644 --- a/engine/crates/layerfs-workspace/tests/common/mod.rs +++ b/engine/crates/layerfs-workspace/tests/common/mod.rs @@ -28,10 +28,18 @@ pub struct Store { pub lengths: Arc>>, /// Canonical bytes served upstream, to tell metadata demand from payload. pub served: Arc, + /// Object batch demands: one per `read_canonical_batch` call, whatever + /// the number of objects it names. A window's SQL batches, not its rows. + pub batches: Arc, + /// Length demands that asked for several ids in one call. + pub length_batches: Arc, + /// Length demands that asked for one id at a time. + pub length_demands: Arc, } impl AuthenticatedObjects for Store { fn read_canonical_batch(&self, ids: &[ObjectId]) -> ContentResult>> { self.demand.fetch_add(ids.len() as u64, Ordering::Relaxed); + self.batches.fetch_add(1, Ordering::Relaxed); let objects = self.objects.lock().unwrap(); ids.iter() .map(|id| { @@ -47,6 +55,7 @@ impl AuthenticatedObjects for Store { } impl layerfs_workspace::FileLengths for Store { fn file_length(&self, id: ObjectId) -> layerfs_workspace::WorkspaceResult { + self.length_demands.fetch_add(1, Ordering::Relaxed); self.lengths .lock() .unwrap() @@ -54,6 +63,18 @@ impl layerfs_workspace::FileLengths for Store { .copied() .ok_or(ContentError::MissingObject.into()) } + fn file_lengths(&self, ids: &[ObjectId]) -> layerfs_workspace::WorkspaceResult> { + self.length_batches.fetch_add(1, Ordering::Relaxed); + let lengths = self.lengths.lock().unwrap(); + ids.iter() + .map(|id| { + lengths + .get(id) + .copied() + .ok_or(ContentError::MissingObject.into()) + }) + .collect() + } } impl FinalizedConsumer for Store { fn accept(&mut self, object: FinalizedObject) -> ContentResult<()> { diff --git a/engine/crates/layerfs-workspace/tests/directory_links.rs b/engine/crates/layerfs-workspace/tests/directory_links.rs index 2940c31d30..59c278ad5d 100644 --- a/engine/crates/layerfs-workspace/tests/directory_links.rs +++ b/engine/crates/layerfs-workspace/tests/directory_links.rs @@ -575,7 +575,12 @@ fn a_visit_that_misses_the_count_is_undecided_writes_nothing_and_decides_once_su panic!("the supplied facts did not decide the lookup") }; assert_eq!( - (found.serial, found.entries, found.subdirs, found.nlink), + ( + found.inode.serial, + found.inode.entries, + found.inode.subdirs, + found.inode.nlink + ), (MIXED, 5, 2, 1) ); // Another request, carrying nothing, decides in its one visit: the @@ -688,7 +693,13 @@ fn remembered_counts_are_bounded_and_an_evicted_one_is_derived_again() { let Some(KernelReadDecision::Value(found)) = observe(&b, mount, "d00000", &facts) else { panic!("the carried facts did not decide the lookup") }; - assert_eq!((found.serial, found.entries, found.subdirs), (100, 3, 2)); + assert_eq!( + (found.inode.serial, found.inode.entries, found.inode.subdirs), + (100, 3, 2) + ); + // The same job answered the directory the name was looked up in, so a + // reply that shows the directory's attributes pays no second visit. + assert_eq!(found.parent.expect("the lookup's directory").serial, 1); assert_eq!(work().directory_count_scans, capacity + 3); // Both were evicted: each is derived again, correctly, and remembered diff --git a/engine/crates/layerfs-workspace/tests/kernel_directory.rs b/engine/crates/layerfs-workspace/tests/kernel_directory.rs index 2f1e4f4438..48c9b2153b 100644 --- a/engine/crates/layerfs-workspace/tests/kernel_directory.rs +++ b/engine/crates/layerfs-workspace/tests/kernel_directory.rs @@ -4,14 +4,16 @@ mod harness; use harness::{create, mkdir, path, rename, rmdir, unlink, Bench, T1, T2}; use layerfs_content::{ filesystem::{ - update_filesystem, DirectoryUpdate, FilesystemInput, FilesystemObjects, FilesystemResources, + attributes::PortableMetadata, build_filesystem, scope_for_seed, update_filesystem, + DirectoryUpdate, FilesystemInput, FilesystemObjects, FilesystemResources, InodeUpdate, }, - object::inode_leaf::InodeKind, + object::inode_leaf::{InodeKind, InodeMetadata, InodeValue}, + ObjectId, }; use layerfs_overlay::{KernelDirectory, KernelMount, OverlayError, PAGE_ROWS}; use layerfs_workspace::{ - CanonicalCache, CanonicalClient, KernelDirectoryBatch, KernelDirectoryWindow, - KernelReadDecision, KernelReadOperation, VisitFacts, + CanonicalCache, CanonicalClient, KernelDirectoryBatch, KernelDirectoryRead, + KernelDirectoryWindow, KernelReadDecision, KernelReadOperation, VisitFacts, }; use std::sync::Arc; /// A memory-only client over a cache that holds nothing. @@ -69,6 +71,16 @@ fn visit( directory: KernelDirectory, offset: u64, after: Option>, +) -> Result { + visit_with(b, directory, offset, after, false) +} +/// The same, for a reply that shows each entry's facts (READDIRPLUS). +fn visit_with( + b: &Bench, + directory: KernelDirectory, + offset: u64, + after: Option>, + attributes: bool, ) -> Result { let visit = b .workspace @@ -77,8 +89,11 @@ fn visit( directory.mount(), directory.serial(), directory.owner_id(), - offset, - after, + KernelDirectoryRead { + offset, + after, + attributes, + }, ) .unwrap(); let before = b.demand(); @@ -316,3 +331,253 @@ fn next_directory_read_observes_parent_moved_by_the_atomic_namespace_job() { .unwrap(); b.overlay.revoke_kernel_mount(mount).unwrap(); } +#[test] +fn a_re_sent_reply_reads_no_fact_of_a_name_it_does_not_send() { + let b = Bench::over("kernel-directory-resend", window_fixture(8), 4 << 20); + let mount = b.overlay.create_kernel_mount(1).unwrap(); + let directory = open(&b, mount, 1, 1); + let first = batch(&b, visit(&b, directory, 2, None).unwrap()); + assert_eq!(first.entries.len(), 9, "eight names and the subdirectory"); + // Publish only the first two names, as a reply with a smaller budget does: + // a later reply at the same offset reuses that range and sends no name + // beyond it. + let names: Vec<_> = first + .entries + .iter() + .map(|entry| entry.name.clone()) + .collect(); + let offer = first.publish.as_ref().expect("a fresh reply to publish"); + b.overlay + .publish_kernel_cookies(offer, &names[..2]) + .unwrap(); + assert_eq!( + b.cache.diagnostics().unwrap().file_lengths, + 0, + "a plain listing reads no length" + ); + // Only the two names this reply sends have their facts read: seven names + // of the same window are read nothing, so only two lengths are demanded + // and remembered. + let window = visit_with(&b, directory, 2, None, true).unwrap(); + let listed = window + .finish_with(Some(&b.workspace.base().unwrap()), true) + .unwrap(); + assert_eq!(listed.entries.len(), 2); + assert!(listed.entries.iter().all(|entry| entry.stat.is_some())); + assert_eq!( + b.cache.diagnostics().unwrap().file_lengths, + 2, + "two names sent, two lengths read" + ); + b.overlay + .close_kernel_directory(directory.mount(), directory.serial(), directory.owner_id()) + .unwrap(); + b.overlay.revoke_kernel_mount(mount).unwrap(); +} +/// A root holding `files` inherited regular files, each with its own content, +/// and one inherited subdirectory with a file of its own: a window whose +/// names, kinds, lengths and child-directory count all come from the base. +fn window_fixture(files: u64) -> common::Fixture { + let store = common::Store::default(); + let scope = scope_for_seed([21; 32]); + let directory = InodeMetadata::Inline(PortableMetadata { + mode: 0o755, + mtime_seconds: 7, + mtime_nanoseconds: 3, + }); + let regular = InodeMetadata::Inline(PortableMetadata { + mode: 0o644, + mtime_seconds: 7, + mtime_nanoseconds: 3, + }); + let mut inodes = Vec::new(); + for serial in 1..=2 { + inodes.push(InodeUpdate { + serial, + value: InodeValue { + kind: InodeKind::Directory, + content_root: ObjectId::for_bytes(&[serial as u8; 8]), + metadata_root: directory, + namespace_ref_count: 0, + }, + }); + } + let mut changes = Vec::new(); + for n in 0..files { + let root = common::file(&store, format!("file {n} of the window").as_bytes()); + inodes.push(InodeUpdate { + serial: 3 + n, + value: InodeValue { + kind: InodeKind::RegularFile, + content_root: root, + metadata_root: regular, + namespace_ref_count: 0, + }, + }); + changes.push((common::name(&format!("f{n:04}")), Some(3 + n))); + } + // Names bind in byte order: the subdirectory follows the files. + changes.push((common::name("sub"), Some(2))); + let inner = common::file(&store, b"the subdirectory's only name"); + inodes.push(InodeUpdate { + serial: 3 + files, + value: InodeValue { + kind: InodeKind::RegularFile, + content_root: inner, + metadata_root: regular, + namespace_ref_count: 0, + }, + }); + let directories = vec![ + DirectoryUpdate { parent: 1, changes }, + DirectoryUpdate { + parent: 2, + changes: vec![(common::name("only"), Some(3 + files))], + }, + ]; + let new: Vec = (1..=3 + files).collect(); + let mut sink = store.clone(); + let mut objects = FilesystemObjects::new(&store, &mut sink); + let input = FilesystemInput { + base: None, + scope, + root_serial: 1, + directories: &directories, + inodes: &inodes, + new_inodes: &new, + resources: FilesystemResources::default(), + }; + let root = build_filesystem(&mut objects, &input, None).unwrap().root; + common::Fixture { + store, + root, + scope, + bytes: Vec::new(), + } +} +/// One READDIRPLUS window over `files` inherited names, as a reply that shows each +/// entry's facts reads it: (object batches, length batches, single length +/// demands, entries listed). +fn window_reads(files: u64) -> (u64, u64, u64, usize) { + use std::sync::atomic::Ordering; + let b = Bench::over( + &format!("kernel-directory-facts-{files}"), + window_fixture(files), + 4 << 20, + ); + let mount = b.overlay.create_kernel_mount(1).unwrap(); + let directory = open(&b, mount, 1, 1); + // The cache starts empty, so the window's names and facts come from the + // Store; the OPENDIR and reading visit below fill the inode table's upper + // level into the same cache before the window's own reads are counted. + let window = visit_with(&b, directory, 2, None, true).unwrap(); + assert!(window.listing.is_none() && window.needs_base(true)); + let store = &b.fixture.store; + let before = ( + store.batches.load(Ordering::Relaxed), + store.length_batches.load(Ordering::Relaxed), + store.length_demands.load(Ordering::Relaxed), + ); + let base = b.workspace.base().unwrap(); + let listed = window.finish_with(Some(&base), true).unwrap(); + let after = ( + store.batches.load(Ordering::Relaxed), + store.length_batches.load(Ordering::Relaxed), + store.length_demands.load(Ordering::Relaxed), + ); + // Every inherited name, the subdirectory included, carries its facts. + for entry in &listed.entries { + assert!(entry.stat.is_some(), "facts of {:?}", entry.name); + } + let sub = listed + .entries + .iter() + .find(|entry| entry.name == b"sub") + .expect("the subdirectory"); + let sub = sub.stat.as_ref().unwrap(); + assert_eq!((sub.kind, sub.subdirs), (InodeKind::Directory, 0)); + assert_eq!(listed.entries.len() as u64, files + 1); + ( + after.0 - before.0, + after.1 - before.1, + after.2 - before.2, + listed.entries.len(), + ) +} +#[test] +fn a_window_that_shows_facts_reads_it_in_batches() { + let small = window_reads(8); + let large = window_reads(200); + assert_eq!((small.3, large.3), (9, 201), "every inherited name"); + // One length demand for the whole window, and it is a batch: no entry + // asks the provider for its own length. + assert_eq!((small.1, large.1), (1, 1), "one batch length demand"); + assert_eq!((small.2, large.2), (0, 0), "no single length demand"); + // The window's object batches do not grow with the names it lists: an + // inode tree level whose pages are resident costs no demand, and the rest + // come one batch per level, not one read per name. (What the count is + // here depends on the levels the visits before the window left unread: in + // this fixture they read the tree's upper level into the same cache, so + // this is not a fully cold window's count.) This fixture + // keeps every metadata root inline and builds its subdirectory's child + // count during construction, so neither costs a demand here; a tree whose + // metadata roots are objects, or a subdirectory counted by a scan, pays + // one read per entry that needs it, as before. + assert_eq!( + small.0, large.0, + "the same object batches for 8 and 200 names" + ); + assert!(large.0 < 3, "{} object batches", large.0); +} +#[test] +fn a_local_window_shows_its_rows_without_a_store_reader() { + use std::sync::atomic::Ordering; + let b = Bench::new("kernel-directory-local-facts"); + let made = b.applied(mkdir(1, "all-local"), T1).unwrap().serial; + let mount = b.overlay.create_kernel_mount(1).unwrap(); + // The kernel's own first LOOKUP of the name records the directory's + // parent, which its OPENDIR reads. + let lookup = b + .workspace + .kernel_read_visit( + empty(), + mount, + 1, + None, + KernelReadOperation::Lookup { + parent: 1, + name: common::name("all-local"), + }, + Arc::new(VisitFacts::default()), + ) + .unwrap(); + assert!(lookup.perform(&b.overlay).result.is_ok()); + let directory = open(&b, mount, 2, made); + b.applied(create(made, "one"), T1); + b.applied(create(made, "two"), T2); + let store = &b.fixture.store; + let before = ( + store.batches.load(Ordering::Relaxed), + store.length_demands.load(Ordering::Relaxed), + ); + // Every name of this window is a local row the visit already read: the + // reply shows all their facts, and the request takes no Store reader. + let window = visit_with(&b, directory, 2, None, true).unwrap(); + assert!(window.listing.is_some()); + assert!(!window.needs_base(true), "memory answered every fact"); + let listed = window.finish_with(None, true).unwrap(); + assert_eq!(listed.entries.len(), 2); + assert!(listed.entries.iter().all(|entry| entry.stat.is_some())); + assert_eq!( + ( + store.batches.load(Ordering::Relaxed), + store.length_demands.load(Ordering::Relaxed) + ), + before, + "a local window reads nothing" + ); + b.overlay + .close_kernel_directory(directory.mount(), directory.serial(), directory.owner_id()) + .unwrap(); + b.overlay.revoke_kernel_mount(mount).unwrap(); +} diff --git a/engine/crates/layerfs-workspace/tests/kernel_visit.rs b/engine/crates/layerfs-workspace/tests/kernel_visit.rs index 6aea36ab7e..42b80d892e 100644 --- a/engine/crates/layerfs-workspace/tests/kernel_visit.rs +++ b/engine/crates/layerfs-workspace/tests/kernel_visit.rs @@ -93,8 +93,8 @@ fn observe( assert!(outcome.directory_candidate.is_none()); match outcome.decision { Some(KernelReadDecision::Needs(needs)) => Seen::Needs(needs), - Some(KernelReadDecision::Value(inode)) => Seen::Value(inode), - Some(KernelReadDecision::Refused(refusal)) => Seen::Refused(refusal), + Some(KernelReadDecision::Value(decided)) => Seen::Value(decided.inode), + Some(KernelReadDecision::Refused { refusal, .. }) => Seen::Refused(refusal), other => panic!("undecided read visit: {other:?}"), } } @@ -127,8 +127,8 @@ fn open( assert!(outcome.directory_candidate.is_none()); let seen = match outcome.decision { Some(KernelReadDecision::Needs(needs)) => Seen::Needs(needs), - Some(KernelReadDecision::Value(inode)) => Seen::Value(inode), - Some(KernelReadDecision::Refused(refusal)) => Seen::Refused(refusal), + Some(KernelReadDecision::Value(decided)) => Seen::Value(decided.inode), + Some(KernelReadDecision::Refused { refusal, .. }) => Seen::Refused(refusal), other => panic!("undecided open visit: {other:?}"), }; assert_eq!( @@ -962,7 +962,7 @@ fn a_visit_through_a_read_only_descriptor_is_refused_and_changes_nothing() { .perform(&b.overlay); assert!(matches!( stat.decision, - Some(KernelReadDecision::Value(ref inode)) if inode.serial == serial + Some(KernelReadDecision::Value(ref decided)) if decided.inode.serial == serial )); b.overlay .kernel_close_file(mount, serial, file.owner_id()) @@ -1079,3 +1079,55 @@ fn a_resident_client_answers_only_from_memory_and_only_small_objects() { ); assert_eq!(memory.read_canonical_batch(&[absent]).unwrap().len(), 1); } + +#[test] +fn a_refused_lookup_answers_the_directory_its_job_read() { + let b = Bench::new("kernel-read-refused-directory"); + let mount = b.overlay.create_kernel_mount(1).unwrap(); + let mut facts = VisitFacts::default(); + // The name binds nothing: the job still read the root's own row, and its + // refusal carries that row, so a reply's directory attributes need no + // second visit and are never a stale observation. + for _ in 0..4 { + let visit = b + .workspace + .kernel_read_visit( + empty(), + mount, + 1, + None, + lookup(1, "absent"), + Arc::new(facts.clone()), + ) + .unwrap(); + let demand = b.demand(); + let outcome = visit.perform(&b.overlay); + assert_eq!(b.demand(), demand, "an owner visit asked the provider"); + match outcome.decision { + Some(KernelReadDecision::Needs(needs)) => facts + .supply(&b.workspace.base().unwrap(), &needs, None) + .unwrap(), + Some(KernelReadDecision::Refused { refusal, directory }) => { + assert_eq!(refusal, Refusal::Missing); + let directory = directory.expect("the directory the job read"); + let fresh = b.stat(1).unwrap(); + assert_eq!( + directory.serial, fresh.serial, + "the directory the name was in" + ); + assert_eq!( + (directory.mtime_seconds, directory.mtime_nanoseconds), + ( + fresh.metadata.mtime_seconds, + fresh.metadata.mtime_nanoseconds + ), + "the directory's own current row" + ); + assert_eq!(directory.nlink, fresh.namespace_refs, "its reference count"); + return; + } + other => panic!("undecided read visit: {other:?}"), + } + } + panic!("the missing lookup was not decided in four visits"); +}