<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE rfc [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>
<?xml-stylesheet type="text/xsl" href="rfc2629.xslt" ?>
<!-- generated by https://github.com/cabo/kramdown-rfc version 1.7.39 (Ruby 2.6.10) -->
<?rfc docmapping="yes"?>
<?rfc comments="yes"?>
<rfc xmlns:xi="http://www.w3.org/2001/XInclude" ipr="trust200902" docName="draft-haynes-nfsv4-flexfiles-v2-09" category="std" consensus="true" tocInclude="true" sortRefs="true" symRefs="true" version="3">
  <!-- xml2rfc v2v3 conversion 3.34.0 -->
  <front>
    <title abbrev="Flex File Layout v2">Parallel NFS (pNFS) Flexible File Layout Version 2</title>
    <seriesInfo name="Internet-Draft" value="draft-haynes-nfsv4-flexfiles-v2-09"/>
    <author initials="T." surname="Haynes" fullname="Thomas Haynes">
      <organization>Hammerspace</organization>
      <address>
        <email>loghyr@gmail.com</email>
      </address>
    </author>
    <date/>
    <area>General</area>
    <workgroup>Network File System Version 4</workgroup>
    <keyword>Internet-Draft</keyword>
    <abstract>
      <?line 156?>

<t>Parallel NFS (pNFS) allows a separation between the metadata (onto a
metadata server) and data (onto a storage device) for a file.  The
Flexible File Version 2 Layout Type is defined in this document as
an extension to pNFS that allows the use of storage devices that
require only a limited degree of interaction with the metadata
server and use already-existing protocols.  Data protection is also
added to provide integrity.  Both Client-side mirroring and the
erasure coding algorithms are used for data protection.</t>
    </abstract>
    <note removeInRFC="true">
      <name>About This Document</name>
      <t>
        The latest revision of this draft can be found at <eref target="https://ietf-wg-nfsv4.github.io/flexfiles-v2/draft-haynes-nfsv4-flexfiles-v2.html"/>.
        Status information for this document may be found at <eref target="https://datatracker.ietf.org/doc/draft-haynes-nfsv4-flexfiles-v2/"/>.
      </t>
      <t>
        Discussion of this document takes place on the
        Network File System Version 4 Working Group mailing list (<eref target="mailto:nfsv4@ietf.org"/>),
        which is archived at <eref target="https://mailarchive.ietf.org/arch/browse/nfsv4/"/>.
        Subscribe at <eref target="https://www.ietf.org/mailman/listinfo/nfsv4/"/>.
      </t>
      <t>Source for this draft and an issue tracker can be found at
        <eref target="https://github.com/ietf-wg-nfsv4/flexfiles-v2"/>.</t>
    </note>
    <note>
      <name>Note to Readers</name>
      <?line 167?>

<t>This is an individual submission and does not reflect Working Group
consensus.  The "About This Document" section above has the current
discussion venue, latest rendering, and source location.</t>
    </note>
  </front>
  <middle>
    <?line 173?>

<section anchor="introduction">
      <name>Introduction</name>
      <t>In Parallel NFS (pNFS) (see <xref section="12" sectionFormat="of" target="RFC8881"/>), the metadata
server returns layout type structures that describe where file data is
located.  There are different layout types for different storage systems
and methods of arranging data on storage devices.  <xref target="RFC8435"/> defined
the Flexible File Version 1 Layout Type used with file-based data
servers that are accessed using the NFS protocols: NFSv3 <xref target="RFC1813"/>,
NFSv4.0 <xref target="RFC7530"/>, NFSv4.1 <xref target="RFC8881"/>, and NFSv4.2 <xref target="RFC7862"/>.</t>
      <t>A metadata server that supports the Flexible File Version 2 Layout
Type <bcp14>MUST</bcp14> be an NFSv4.2 server.  The new operations defined by this
document for the metadata server (the TRUST_STATEID family on the
metadata server / storage device control session, and the
CB_CHUNK_REPAIR back-channel callback to clients) are NFSv4.2
operations and have no representation in NFSv4.1 or earlier minor
versions.  Storage devices can speak NFSv3, NFSv4.1, or NFSv4.2, but
some encoding types and coupling configurations narrow that choice;
see <xref target="sec-ff_device_addr4"/> for the exact rules.</t>
      <t>To provide a global state model equivalent to that of the files
layout type, a back-end control protocol might be implemented between
the metadata server and NFSv4.1+ storage devices.  An implementation
can either define its own proprietary mechanism or it could define a
control protocol in a Standards Track document.  The requirements for
a control protocol are specified in <xref target="RFC8881"/> and clarified in
<xref target="RFC8434"/>.</t>
      <t>The control protocol described in this document is based on NFS.  It
does not provide for knowledge of stateids to be passed between the
metadata server and the storage devices.  Instead, the storage
devices are configured such that the metadata server has full access
rights to the data file system and then the metadata server uses
synthetic ids to control client access to individual data files.</t>
      <t>In traditional mirroring of data, the server is responsible for
replicating, validating, and repairing copies of the data file.  With
client-side mirroring, the metadata server provides a layout that
presents the available mirrors to the client.  The client then picks
a mirror to read from and ensures that all writes go to all mirrors.
The client only considers the write transaction to have succeeded if
all mirrors are successfully updated.  In case of error, the client
can use the LAYOUTERROR operation to inform the metadata server,
which is then responsible for the repairing of the mirrored copies of
the file.</t>
      <t>This client side mirroring provides for replication of data but does
not provide for integrity of data.  In the event of an error, a user
would be able to repair the file by silvering the mirror contents.
I.e., they would pick one of the mirror instances and replicate it to
the other instance locations.</t>
      <t>However, lacking integrity checks, silent corruptions are not able to
be detected and the choice of what constitutes the good copy is
difficult.  This document defines the Flexible File Version 2 Layout
Type, an independent layout type that adds error-detection integrity
(checksum) for erasure coding.  It does not modify the Flexible File
Version 1 Layout Type (<xref target="RFC8435"/>); the two coexist.  Data blocks are
transformed into a header and a chunk.  This document also introduces
new operations that allow the client to roll back writes to the data
file.</t>
      <t>Using the process detailed in <xref target="RFC8178"/>, the revisions in this
document become an extension of NFSv4.2 <xref target="RFC7862"/>.  They are built on
top of the external data representation (XDR) <xref target="RFC4506"/> generated
from <xref target="RFC7863"/>.</t>
      <t>This document defines <tt>LAYOUT4_FLEX_FILES_V2</tt>, a new and independent
layout type that coexists with the Flexible File Version 1 Layout Type
(<tt>LAYOUT4_FLEX_FILES</tt>, <xref target="RFC8435"/>).  The two layout types are
wire-format-incompatible: a flexible file v1 layout receiver
cannot parse flexible file v2 layout bytes, and a flexible file
v2 layout receiver cannot parse flexible file v1 layout bytes.
Semantically, however, the flexible file v2 layout is a superset
of the flexible file v1 layout: any flexible file v1 layout has
a natural flexible file v2 layout representation using a single
FFV2<em>ENCODING_PASSTHROUGH mirror (see
<xref target="sec-encoding-passthrough"/>), with the flexible file v1 layout's
data servers mapped into ffv2_stripes4 and the flexible file v1
layout's layout-level ffl_stripe_unit mapped into per-mirror
ffv2m_striping_unit_size and ffv2m_striping.  The reverse does
not hold: flexible file v2 layouts that use any CHUNK-based
encoding (any FFV2_ENCODING</em>* value other than
FFV2_ENCODING_PASSTHROUGH) have no flexible file v1 layout
representation, because the flexible file v1 layout has neither
the chunk envelope (chunk_guard4, per-chunk checksum) nor the
per-mirror encoding choice that those encodings require.  A
server <bcp14>MAY</bcp14> support both layout types simultaneously; a client
selects the desired layout type in its LAYOUTGET request.</t>
    </section>
    <section anchor="requirements-language">
      <name>Requirements Language</name>
      <t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>", "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL
NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>",
"<bcp14>MAY</bcp14>", and "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as
described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they
appear in all capitals, as shown here.</t>
      <?line -18?>

</section>
    <section anchor="sec-motivation">
      <name>Motivation</name>
      <t>Workloads that need both the throughput of parallel pNFS
data servers and the durability of erasure coding have
driven the work in this draft.  The deployments span
scientific-instrumentation pipelines that produce
petabytes of detector data per year, training-checkpoint
files written hot from machine-learning jobs, archive
workloads in which a single file may hold the only copy of
an experiment's result, and ordinary production
filesystems where read patterns evolve across a file's
lifetime.  These deployments are documented in detail in
<xref target="sec-use-cases"/>; the protocol shape that follows is the
result of looking at them and asking what a pNFS layout
type would have to provide.</t>
      <t>The first thing the deployments share is that erasure
coding moves work off the data servers that are already
the bottleneck in the write-heavy parallel case.
Server-side erasure coding makes each data server compute
its share of the parity transform on every write,
multiplying the per-write CPU cost by (k + m) across the
storage tier and serializing on the data server's limited
compute.  Client-side erasure coding shifts that compute
to the writers, which scale horizontally with the
workload, and lets the data servers stay close to their
strength -- storing and serving bytes.  Flexible file v1
layout (<xref target="RFC8435"/>) already chose client-side compute by
placing replication at the writer; this draft extends that
choice to client-side erasure coding.  Benchmark
measurements summarized in <xref target="sec-implementation-status"/>
confirm that the resulting overhead is competitive with
server-side encoding on realistic workloads and that the
encoding compute scales with the writer population rather
than with the data-server count.</t>
      <t>Client-side erasure coding has a corollary that protocol
designers cannot avoid: when a client fans a stripe out
across multiple data servers and fails mid-write, no
single data server has whole-transaction visibility.  The
state left behind on each data server is a partial
fragment of a write that may or may not have completed
elsewhere.  A server-side coordinator that holds the whole
stripe -- the flexible file v1 case -- can resilver from a
surviving copy without any client involvement.  In the v2
case there is no such coordinator, and the on-wire
protocol specifies how the partial state is reconciled.
This is the load-bearing constraint that shapes the rest
of the design.</t>
      <t>A natural-looking answer is to add a distributed-consensus
protocol between the data servers and have them agree on
which write committed.  That answer is rejected here.
Distributed consensus is operationally expensive,
introduces a synchronization cost on every write, and
makes the data servers themselves stateful peers in a way
that closes off the simpler implementations the protocol
is designed to accommodate.  Instead, this draft uses two
narrowly-scoped primitives that together provide just
enough on-wire reconciliation: the chunk_guard4
compare-and-swap (CAS) and the CB_CHUNK_REPAIR callback.</t>
      <t>Every CHUNK_WRITE carries a cohort header (a 64-bit
writer-chosen chunk_cohort_id4 plus the writer's 32-bit
layout-granted client id) once for the batch, and the
data server performs a per-chunk compare-and-swap against
its own chunk_guard4 (a 32-bit per-chunk generation
counter plus the last writer's client id) when the client
sets cwa_guard on receipt.  If two writers race for the
same chunk, exactly one wins on each data server, the
loser receives NFS4ERR_CHUNK_GUARDED for that chunk, and
the chunks the loser intended to write are left
unchanged.  No data server needs to consult its peers;
the CAS is local.  The cost on the metadata server is
bounded by the 12-byte cohort header per CHUNK_WRITE
plus a 32-bit per-layout client identifier
(<xref target="sec-chunk_guard4"/>, <xref target="sec-ffv2-mirror4"/>).
Independent collisions on different chunks resolve
independently; there is no file-wide lock and no global
ordering across writes.</t>
      <t>When the per-chunk CAS detects that a stripe ended up
non-atomic -- some shards under writer A's guard, others
under writer B's, or a writer crashed mid-fan-out -- the
metadata server selects a repair actor via
CB_CHUNK_REPAIR, and that actor
drives the repair: it acquires CHUNK_LOCK on the affected
range, reads the surviving shards, decodes through the
erasure transform, writes the reconstructed shards via
CHUNK_WRITE_REPAIR, and clears the errored state via
CHUNK_REPAIRED.  The repair actor may be a client, a data
server (in a tightly coupled deployment), or a proxy server;
exactly one holds the chunk-range lock per repair episode
so the data servers still do not coordinate among themselves.
The repair-actor selection rule is given in
<xref target="sec-repair-selection"/>.</t>
      <t>These two primitives -- the per-chunk CAS and the
callback-driven repair -- replace what would otherwise
require a distributed-consensus protocol.  The CAS handles
the common case at local cost, where independent writers
racing for different chunks resolve independently and
concurrent writers on the same chunk get a clean win/loss
decision.  CB_CHUNK_REPAIR handles the rare case of
partial-failure non-atomicity with a single coordinator
selected per repair episode.  The cost model is asymmetric
on purpose: the hot path pays for an 8-byte header and a
local CAS; the cold path pays for a selected actor and a
small number of round-trips.</t>
      <t>The CHUNK operation set in this draft is the minimum
sufficient to drive the chunk state machine
(<xref target="sec-system-model-chunk-state"/>) plus the repair flow
above.  CHUNK_WRITE places PENDING content; CHUNK_FINALIZE
signals that the writer is done with a generation;
CHUNK_COMMIT promotes that generation to durable, globally
visible state; CHUNK_READ retrieves it; CHUNK_HEADER_READ
provides the fast probe that lets repair coordinators and
recovering writers inspect chunk metadata without reading
payloads.  CHUNK_LOCK, CHUNK_UNLOCK, CHUNK_ERROR,
CHUNK_REPAIRED, CHUNK_WRITE_REPAIR, and CHUNK_ROLLBACK
together drive the repair flow.  Each operation does one
well-scoped job; the complexity is in the state machine
the operations drive, not in the operation set itself.
Each of these primitives closes a specific gap in the
lifecycle or the repair path.  The detailed treatment of
the operation set is in <xref target="sec-new-ops"/>.</t>
      <t>The same design discipline shapes the rest of the
specification.  The protocol describes wire format and
server obligations; it does not pin a data-server
backend, a control protocol between metadata server and
data server, a checksum algorithm, or a file-attribute
representation on the data server.  Different
implementations resolve these choices differently and
remain conformant.  TRUST_STATEID
(<xref target="sec-tight-coupling-control"/>) is one such control
protocol that this draft defines; storage devices with
their own established control protocols are conformant
without implementing it.  The tagged checksum4
(<xref target="sec-checksum4"/>) lets the metadata server pick any
registered checksum algorithm per file.  The
authorization-outcome parity rule
(<xref target="sec-state-locking"/>) lets data servers that do not
expose a POSIX file namespace satisfy the tight coupling
requirements without materializing POSIX uid/gid bits.</t>
      <t>A protocol-level consequence of placing erasure coding at
the client is that the layout is able to describe a
file's storage shape over its full lifetime -- including
the transition windows when the file is being assimilated
from a non-erasure-coded source, re-encoded from one
encoding to another, or recovered from a correlated encoding
failure through a mirror under a different encoding.
This draft allows a single file's layout to contain
mirrors under different encodings.  The
heterogeneous-mirror capability is not a steady-state
expectation; most files have one encoding most of the
time.  It is the protocol shape that lets transitions
happen while the file remains readable.  The deployment
cases that drive the allowance are catalogued in
<xref target="sec-use-cases"/>.</t>
      <t>Scope note: the consistency goal of flexible file v2
layout is RAID consistency across the shards that make
up an encoded stripe, not POSIX write ordering across
arbitrary application writes.  The protocol does not
attempt to make overlapping application writes from
different clients atomic; that is the province of file
locking (<xref section="12" sectionFormat="of" target="RFC8881"/>) and of application-level
coordination.  What the protocol does guarantee is that
the shards comprising a given stripe agree on which
write produced them -- expressed on the wire as agreement
on the chunk_guard4 value of every chunk that carries
those shards -- so that readers and repair actors never
observe a half-applied stripe.  Readers who need
cross-write ordering beyond a single stripe <bcp14>MUST</bcp14> use the
existing NFSv4 locking primitives.</t>
    </section>
    <section anchor="sec-use-cases">
      <name>Use Cases</name>
      <t>The protocol is designed around three workload classes.  The
labels below reflect the relative frequency of each class in
installations that choose flexible file v2 layout for its combination of
integrity and performance; individual deployments may diverge.</t>
      <dl>
        <dt>Single writer, multiple readers (the common case):</dt>
        <dd>
          <t>A file written by one client and subsequently read by many.
Examples include artifacts deposited by batch jobs, container
images, and media files.  The protocol is optimized for this
case; see <xref target="sec-system-model-progress"/>.</t>
        </dd>
        <dt>Multiple writers without sustained contention (occasional):</dt>
        <dd>
          <t>Files with multiple concurrent writers where races on the same
chunk are rare.  Examples include shared-directory append-only
logs and distributed builds.  The chunk_guard4 CAS primitive and
per-chunk locking cover this case without penalizing the common
single writer path.</t>
        </dd>
        <dt>Multiple writers, disjoint regions (rare):</dt>
        <dd>
          <t>High-performance computing (HPC) checkpoint workloads, in which
many ranks write disjoint regions of the same file in lockstep.
The protocol relies on block alignment to keep per-chunk
contention rare despite overall high writer count.  Contention
that does occur is resolved via the deterministic tiebreaker
rule defined in <xref target="sec-chunk_guard4"/>.  Deployments that use an
XOR-based erasure encoding (see <xref target="sec-mojette-encoding"/>) and
expect frequent small edits from this workload class <bcp14>MAY</bcp14> use the
optional delta-write protocol defined in
<xref target="I-D.haynes-nfsv4-flexfiles-v2-delta-writes"/>, which lets the
client forward per-projection XOR deltas directly to each data
server, avoiding client-side read-modify-write of the full
stripe on the small-edit path.</t>
        </dd>
      </dl>
      <t>Scale targets include multi-thousand-client deployments (on the
order of tens of thousands of concurrent clients for HPC
checkpointing), parallel-filesystem replacements, and multi-rack
shared-storage clusters.  The repair protocol (see
<xref target="sec-repair-selection"/>) is designed to let such deployments
tolerate data-server failures and concurrent writer races without
blocking the critical path for the first two workload classes.</t>
    </section>
    <section anchor="definitions">
      <name>Definitions</name>
      <dl>
        <dt>block:</dt>
        <dd>
          <t>the application's view of file data.  A block is a unit of file
content as observed by an NFS client at the POSIX layer or by the
local file system.  A chunk's payload, after any decoding the client
performs, is presented to the application as one or more blocks.</t>
        </dd>
        <dt>shard:</dt>
        <dd>
          <t>the encoding's view.  A shard is a single piece of an encoded stripe
produced by an erasure-coding (or replication) transformation.  A
stripe of k data shards plus m parity shards is the unit an encoding
encodes and decodes.  The word "shard" only has meaning while the
encoding is reasoning about a stripe; once a shard is at rest on a data
server it is, by virtue of having been transmitted, the payload of a
chunk.</t>
        </dd>
        <dt>chunk:</dt>
        <dd>
          <t>the protocol's unit of file data on the wire, carrying an
envelope that distinguishes it from a block: a compare-and-swap
guard (chunk_guard4 -- atomicity, see <xref target="sec-chunk_guard4"/>), a
checksum (per-chunk integrity), a provenance identifier
(chunk_owner4, see <xref target="sec-chunk_owner4"/>), a lifecycle state
(PENDING / FINALIZED / COMMITTED via the chunk state machine,
see <xref target="sec-system-model-chunk-state"/>), and per-chunk locking that
survives stateid revocation through lock escrow.  A chunk is the
addressable unit named in the CHUNK operations defined in this
document and durably persisted by a data server.  A chunk's
payload may be a block (mirrored layout) or a shard
(erasure-coded layout); the wire protocol does not distinguish.
The chunk size <bcp14>MAY</bcp14> differ from the size of the block or shard it
carries.  See <xref target="sec-system-model-chunk-not-block"/> for the
load-bearing role each envelope property plays in the protocol's
consistency story.</t>
        </dd>
      </dl>
      <t>The three terms describe the same data at three different layers and
should be used accordingly.  The encoding transforms blocks into shards;
the wire protocol transmits shards as chunk payloads; the data server
persists chunks.  On read the path reverses.</t>
      <t>A protocol-internal note: the chunk state machine
(<xref target="sec-system-model-chunk-state"/>) and several CHUNK operations
refer to the per-chunk-offset state records as "blocks" (PENDING /
FINALIZED / COMMITTED / errored).  This is a finer-grained use of
the word, internal to the data server's chunk metadata, and should
not be confused with the application-layer "block" defined above.
Where ambiguity matters, this document writes "chunk-state block"
or relies on context (operation names, state names) to disambiguate.</t>
      <dl>
        <dt>client-side erasure coding:</dt>
        <dd>
          <t>Erasure coding in which the encode and decode transforms are
performed on the pNFS client, and encoded shards are written
directly to the data servers (rather than being computed at
a server-side coordinator).  This is the deployment shape
Flexible File Version 2 Layout Type is designed for; the
chunk substrate and CHUNK operations that make it safe are
specified in <xref target="sec-system-model"/> and <xref target="sec-new-ops"/>.
Contrast: server-side erasure coding, where a coordinator
holds the entire stripe and produces parity, is out of scope
for this document.</t>
        </dd>
        <dt>client-side mirroring:</dt>
        <dd>
          <t>a feature in which the client, not the server, is responsible for
updating all of the mirrored copies of a layout segment.</t>
        </dd>
        <dt>compare-and-swap (CAS):</dt>
        <dd>
          <t>an atomic primitive from concurrent programming in which an
update is conditional on a prior observed value: the operation
succeeds only if the current value matches an expected prior value,
and otherwise fails so the caller can retry.  In this document, the
chunk_guard4 mechanism (see <xref target="sec-chunk_guard4"/>) implements CAS at
the chunk level; the "expected prior value" is the chunk_guard4 the
writer observed at read time, and the "fail" outcome is
NFS4ERR_CHUNK_GUARDED.</t>
        </dd>
        <dt>control communication requirements:</dt>
        <dd>
          <t>the specification for information on layouts, stateids, file metadata,
and file data that must be communicated between the metadata server and
the storage devices.  There is a separate set of requirements for each
layout type.</t>
        </dd>
        <dt>control protocol:</dt>
        <dd>
          <t>the particular mechanism that an implementation of a layout type would
use to meet the control communication requirement for that layout type.
This need not be a protocol as normally understood.  In some cases,
the same protocol may be used as a control protocol and storage protocol.</t>
        </dd>
        <dt>(file) data:</dt>
        <dd>
          <t>that part of the file system object that contains the data to be read
or written.  It is the contents of the object rather than the attributes
of the object.</t>
        </dd>
        <dt>data block:</dt>
        <dd>
          <t>A block (as defined above) in the client's cache for a file.</t>
        </dd>
        <dt>data file:</dt>
        <dd>
          <t>The data portion of the file, stored on the data server.</t>
        </dd>
        <dt>data server:</dt>
        <dd>
          <t>a pNFS server that provides the file's data when the file system
object is accessed over a file-based protocol.</t>
        </dd>
        <dt>erasure coding:</dt>
        <dd>
          <t>A data protection scheme where a stripe of data is encoded into
shards (k data shards and m parity shards) so that the original
content can be reconstructed from any sufficient subset of the
shards.  Shards are transmitted as the payload of CHUNK operations
and stored on different data servers.</t>
        </dd>
        <dt>escrow (lock escrow, metadata-server escrow):</dt>
        <dd>
          <t>a state in which a chunk lock is held by the metadata server on
behalf of an as-yet-unselected future owner.  Escrow preserves
the lock-continuity invariant across two survivability
scenarios: (a) client failure while holding chunk locks
(client-revocation case: the locks are transferred to the
metadata server rather than dropped), and (b)
metadata-server-instance change (restart / HA failover: a new
incarnation reclaims the escrows the departing incarnation
installed).  The escrowed lock is marked on the wire by the
reserved cg_client_id value CHUNK_GUARD_CLIENT_ID_MDS (see
<xref target="sec-chunk_guard_mds"/>) and named by an escrow_id4
(<xref target="sec-escrow_id4"/>).  A repair actor adopts an escrow via
CHUNK_LOCK with CHUNK_LOCK_FLAGS_ADOPT driven by
CB_CHUNK_REPAIR; a new metadata-server incarnation reclaims
outstanding escrows via CHUNK_ESCROW_TAKEOVER.  A
"metadata-server escrow owner" is the metadata server acting
in this placeholder role; "in escrow" describes a lock in this
state.  The full model is <xref target="sec-system-model-escrow"/>.</t>
        </dd>
        <dt>fencing:</dt>
        <dd>
          <t>the process by which the metadata server prevents the storage devices
from processing I/O from a specific client to a specific file.</t>
        </dd>
        <dt>file layout type:</dt>
        <dd>
          <t>a layout type in which the storage devices are accessed via the NFS
protocol (see <xref section="5.12.4" sectionFormat="of" target="RFC8881"/>).</t>
        </dd>
        <dt>gid:</dt>
        <dd>
          <t>the group id, a numeric value that identifies to which group a file
belongs.</t>
        </dd>
        <dt>layout:</dt>
        <dd>
          <t>the information a client uses to access file data on a storage device.
This information includes specification of the protocol (layout type)
and the identity of the storage devices to be used.</t>
        </dd>
        <dt>layout iomode:</dt>
        <dd>
          <t>a grant of either read-only or read/write I/O to the client.</t>
        </dd>
        <dt>layout segment:</dt>
        <dd>
          <t>a sub-division of a layout.  That sub-division might be by the layout
iomode (see Sections 3.3.20 and 12.2.9 of <xref target="RFC8881"/>), a striping pattern
(see <xref section="13.3" sectionFormat="of" target="RFC8881"/>), or requested byte range.</t>
        </dd>
        <dt>layout stateid:</dt>
        <dd>
          <t>a 128-bit quantity returned by a server that uniquely defines the
layout state provided by the server for a specific layout that describes
a layout type and file (see <xref section="12.5.2" sectionFormat="of" target="RFC8881"/>).  Further,
<xref section="12.5.3" sectionFormat="of" target="RFC8881"/> describes differences in handling between
layout stateids and other stateid types.</t>
        </dd>
        <dt>layout type:</dt>
        <dd>
          <t>a specification of both the storage protocol used to access the data
and the aggregation scheme used to lay out the file data on the underlying
storage devices.</t>
        </dd>
        <dt>loose coupling:</dt>
        <dd>
          <t>when the control protocol is a storage protocol.</t>
        </dd>
        <dt>(file) metadata:</dt>
        <dd>
          <t>the part of the file system object that contains various descriptive
data relevant to the file object, as opposed to the file data itself.
This could include the time of last modification, access time, EOF
position, etc.</t>
        </dd>
        <dt>metadata server:</dt>
        <dd>
          <t>the pNFS server that provides metadata information for a file system
object.  It is also responsible for generating, recalling, and revoking
layouts for file system objects, for performing directory operations,
and for performing I/O operations to regular files when the clients
direct these to the metadata server itself.</t>
        </dd>
        <dt>mirror:</dt>
        <dd>
          <t>a copy of a layout segment.  Note that if one copy of the mirror is
updated, then all copies must be updated.</t>
        </dd>
        <dt>non-systematic encoding:</dt>
        <dd>
          <t>An erasure coding scheme in which the encoded shards do not contain
verbatim copies of the original data.  Every read requires decoding,
even when no shards are lost.  The Mojette non-systematic transform is
an example.</t>
        </dd>
        <dt>proxy server:</dt>
        <dd>
          <t>a peer of the metadata server, defined in
<xref target="I-D.haynes-nfsv4-flexfiles-v2-proxy-server"/> (hereafter "the
proxy server draft"), that admits client I/O on the metadata
server's behalf -- either as a translator for clients that
cannot speak the file's native encoding, or as a proxy-mediated
data path during whole-file move and repair operations.  A
proxy server may have additional roles.  This document cites
the proxy server draft only when referencing a specific rule
or section within it; other mentions of "proxy server" or "the
proxy server draft" in this document refer to the same reference
without repeating the citation.</t>
        </dd>
        <dt>recalling a layout:</dt>
        <dd>
          <t>a graceful recall, via a callback, of a specific layout by the metadata
server to the client.  Graceful here means that the client would have
the opportunity to flush any WRITEs, etc., before returning the layout
to the metadata server.</t>
        </dd>
        <dt>replication of data:</dt>
        <dd>
          <t>Data replication is making and storing multiple copies of data in
different locations.</t>
        </dd>
        <dt>resilvering:</dt>
        <dd>
          <t>the act of rebuilding a mirrored copy of a layout segment from a
known good copy of the layout segment.  Note that this can also be done
to create a new mirrored copy of the layout segment.</t>
        </dd>
        <dt>revoking a layout:</dt>
        <dd>
          <t>an invalidation of a specific layout by the metadata server.
Once revocation occurs, the metadata server will not accept as valid any
reference to the revoked layout, and a storage device will not accept
any client access based on the layout.</t>
        </dd>
        <dt>rsize:</dt>
        <dd>
          <t>the data transfer buffer size used for READs.</t>
        </dd>
        <dt>stateid:</dt>
        <dd>
          <t>a 128-bit quantity returned by a server that uniquely defines the set
of locking-related state provided by the server.  Stateids may designate
state related to open files, byte range locks, delegations, or layouts.</t>
        </dd>
        <dt>storage device:</dt>
        <dd>
          <t>the target to which clients may direct I/O requests when they hold
an appropriate layout.  See <xref section="2.1" sectionFormat="of" target="RFC8434"/> for further
discussion of the difference between a data server and a storage device.</t>
        </dd>
        <dt>storage protocol:</dt>
        <dd>
          <t>the protocol used by clients to do I/O operations to the storage
device.  Each layout type specifies the set of storage protocols.</t>
        </dd>
        <dt>systematic encoding:</dt>
        <dd>
          <t>An erasure coding scheme in which the first k of the k + m encoded
shards are identical to the original k data blocks.  A healthy read
(no failures) requires no decoding -- the data shards are read directly.
Decoding is triggered only when data shards are missing.  Reed-Solomon
Vandermonde and Mojette systematic are examples.</t>
        </dd>
        <dt>tight coupling:</dt>
        <dd>
          <t>an arrangement in which the control protocol is one designed
specifically for control communication.  It may be either a proprietary
protocol adapted specifically to a particular metadata server or a
protocol based on a Standards Track document.  The specific
tight coupling variant defined by this document, in which the
control protocol is the TRUST_STATEID family, is referred to as
trusted stateid tight coupling (see <xref target="sec-tight-coupling-control"/>).</t>
        </dd>
        <dt>trusted stateid tight coupling:</dt>
        <dd>
          <t>the specific tight coupling control protocol defined in this
document, consisting of the operations TRUST_STATEID, REVOKE_STATEID,
and BULK_REVOKE_STATEID.  Within the scope of this document,
unqualified references to "tight coupling" or "tightly coupled" refer
to trusted stateid tight coupling unless the context explicitly
discusses the general concept.  Other tight coupling control
protocols (proprietary or future Standards Track) may exist but
are not covered by this specification.</t>
        </dd>
        <dt>uid:</dt>
        <dd>
          <t>the user id, a numeric value that identifies which user owns a file.</t>
        </dd>
        <dt>write hole:</dt>
        <dd>
          <t>A write hole is a data corruption scenario where either two clients
are trying to write to the same chunk or one client is overwriting an
existing chunk of data.</t>
        </dd>
        <dt>wsize:</dt>
        <dd>
          <t>the data transfer buffer size used for WRITEs.</t>
        </dd>
      </dl>
      <section removeInRFC="true" anchor="naming-the-layout-type-reviewer-note">
        <name>Naming the layout type (reviewer note)</name>
        <t>The layout type defined by this document is referred to by several
forms in the surrounding prose.  This note fixes the vocabulary so
the reader (and the sweep in the source) can keep them straight.
It follows the register RFC 8435 established for its own layout
type: a formal title-case name for headings and IANA registrations,
a lowercase running-text form, and separate XDR / struct-prefix
identifiers.  The parallel is exact -- everywhere RFC 8435 says
"flexible file layout" this document says "flexible file v2
layout", and everywhere RFC 8435 says "Flexible File Layout Type"
this document says "Flexible File Version 2 Layout Type".</t>
        <t>Formal name (headings, IANA registrations, the abstract):
"Flexible File Version 2 Layout Type".  This is the form to
use when naming the layout type as such -- for example, the
Section 5 heading, the IANA registry title, and the sentence
that introduces the layout type in the abstract.  A short
formal variant "Flexible File Version 2 Layout" drops "Type"
when "Type" would be redundant with the surrounding noun
(as in the IANA-registered creation-hint name).</t>
        <t>Running-text form (body prose): "flexible file v2 layout".
This is the form for sentences that mention the layout in
passing rather than naming it as an object of definition --
"the flexible file v2 layout supports multipathing to multiple
storage devices", "the flexible file v2 layout does not use
lou_body".  It parallels RFC 8435's lowercase "flexible file
layout" and is preferred over the title-case form for
sentences where the emphasis is on the mechanism, not the
name.  Do NOT write "flexible file v2 layout version 2" -- the
"v2" already carries the version, and appending "version 2"
is a rendering hazard.</t>
        <t>Short form (narrow tables and reviewer-aid appendix material
where cell width or repetition would otherwise dominate):
"FFv2", with "FFv1" reserved for the predecessor defined by
<xref target="RFC8435"/>.  The short forms are NOT appropriate in body
prose, headings, IANA registrations, or the abstract; body
prose that would otherwise repeat the layout name uses the
running-text form above.  Their scoped use is in tables where
"flexible file v2 layout" would break the column layout (e.g.,
the four-variant wire-path comparison table in the
Implementation Status appendix).</t>
        <t>XDR identifier: <tt>LAYOUT4_FLEX_FILES_V2</tt>.  This is the name
assigned to the layout type by the layout-type registry
(<xref target="RFC8434"/>) and is the constant a receiver compares against
when dispatching on layout type.  It parallels
<tt>LAYOUT4_FLEX_FILES</tt> for the predecessor layout type
(<xref target="RFC8435"/>).  Use the XDR identifier whenever the sentence
is about the value that appears on the wire; use the
"Flexible File Version 2 Layout Type" formal name whenever
the sentence is about the layout type as a specification.</t>
        <t>Struct-name prefix: <tt>ffv2_</tt> (as in <tt>ffv2_layout4</tt>,
<tt>ffv2_mirror4</tt>, <tt>ffv2_stripes4</tt>).  This parallels RFC 8435's
<tt>ff_</tt> prefix (as in <tt>ff_layout4</tt>, <tt>ff_device_addr4</tt>).  The
per-struct field prefix follows the RFC 8435 pattern of
struct-initials plus underscore: <tt>ffv2l_</tt> for
<tt>ffv2_layout4</tt>, <tt>ffv2m_</tt> for <tt>ffv2_mirror4</tt>, <tt>ffv2ds_</tt> for
<tt>ffv2_data_server4</tt>, and so on.</t>
        <t>Every field prefix carries the full <tt>ffv2</tt> stem; a bare <tt>f</tt>
plus struct initials is not used, so that a reader scanning
an XDR block can tell at a glance which specification a field
belongs to.</t>
        <t>Where two struct names would reduce to the same initials, the
prefix takes one letter from each word of the struct name so
that the prefixes stay distinct: <tt>ffv2l_</tt> for <tt>ffv2_layout4</tt>
but <tt>ffv2lu_</tt> for <tt>ffv2_layoutupdate4</tt>, <tt>ffv2lh_</tt> for
<tt>ffv2_layouthint4</tt>, and <tt>ffv2lr_</tt> for <tt>ffv2_layoutreturn4</tt>.
This matters most for <tt>ffv2_layout4</tt> and <tt>ffv2_layoutupdate4</tt>,
which both carry a field named for flags: <tt>ffv2l_flags</tt> is the
<tt>ffv2_flags4</tt> bitmask on the layout, while <tt>ffv2lu_flags</tt> is
the <tt>ffv2_layoutstats_flags4</tt> bitmask on a layout-statistics
report.  The two are different types with different registries,
and an implementation that conflates them will encode the wrong
bitmask.</t>
        <t>Document title and file abbreviation: the front-matter title is
"Parallel NFS (pNFS) Flexible File Layout Version 2" and the
<tt>abbrev</tt> used in the running header is "Flex File Layout v2".
These are document-metadata conventions and do not participate
in the body-prose vocabulary; the running text follows the
forms above, not the front-matter forms.</t>
      </section>
    </section>
    <section anchor="coupling-of-storage-devices">
      <name>Coupling of Storage Devices</name>
      <t>A server implementation may choose either a loosely coupled model or a
tightly coupled model between the metadata server and the storage devices.
<xref target="RFC8434"/> describes the general problems facing pNFS implementations.
This document details how the new flexible file v2 layout addresses
these issues.  To implement the tightly coupled model, a control protocol
has to be defined.  As the flexible file v2 layout imposes no special
requirements on the client, the control protocol will need to provide:</t>
      <ol spacing="normal" type="1"><li>
          <t>management of both security and LAYOUTCOMMITs; and</t>
        </li>
        <li>
          <t>a global stateid model and management of these stateids.</t>
        </li>
      </ol>
      <t>When implementing the loosely coupled model, the only control protocol
will be a version of NFS, with no ability to provide a global stateid
model or to prevent clients from using layouts inappropriately.  To enable
client use in that environment, this document specifies how security,
state, and locking are managed.</t>
      <t>The loosely and tightly coupled locking models defined in <xref section="2.3" sectionFormat="of" target="RFC8435"/> apply equally to this layout type, including the use
of anonymous stateids with loosely coupled storage devices, the
handling of lock and delegation stateids, and the mandatory byte range
lock requirements for the tightly coupled model.</t>
      <section anchor="layoutcommit">
        <name>LAYOUTCOMMIT</name>
        <t>Regardless of the coupling model, the metadata server has the
responsibility, upon receiving a LAYOUTCOMMIT (see <xref section="18.42" sectionFormat="of" target="RFC8881"/>) to ensure that the semantics of pNFS are respected (see
<xref section="3.1" sectionFormat="of" target="RFC8434"/>).  These do include a requirement that data
written to a data storage device be stable before the occurrence of
the LAYOUTCOMMIT.</t>
        <t>It is the responsibility of the client to make sure the data file is
stable before the metadata server begins to query the storage devices
about the changes to the file.  If any WRITE to a storage device did not
result with stable_how equal to FILE_SYNC, a LAYOUTCOMMIT to the metadata
server <bcp14>MUST</bcp14> be preceded by a COMMIT to the storage devices written to.
Note that if the client has not done a COMMIT to the storage device, then
the LAYOUTCOMMIT might not be synchronized to the last WRITE operation
to the storage device.</t>
      </section>
      <section anchor="sec-Fencing-Clients">
        <name>Fencing Clients from the Storage Device</name>
        <t>With loosely coupled storage devices, the metadata server uses synthetic
uids (user ids) and gids (group ids) for the data file, where the uid
owner of the data file is allowed read/write access and the gid owner
is allowed read-only access.  As part of the layout (see ffv2ds_user
and ffv2ds_group in <xref target="sec-ffv2_layout"/>), the client is provided
with the user and group to be used in the Remote Procedure Call
(RPC) <xref target="RFC5531"/> credentials needed to access the data file.
Fencing off of clients is achieved by the metadata server changing
the synthetic uid and/or gid owners of the data file on the storage
device to implicitly revoke the outstanding RPC credentials.  A
client presenting the wrong credential for the desired access will
get an NFS4ERR_ACCESS error.</t>
        <t>With this loosely coupled model, the metadata server is not able to fence
off a single client; it is forced to fence off all clients.  However,
as the other clients react to the fencing, returning their layouts and
trying to get new ones, the metadata server can hand out a new uid and
gid to allow access.</t>
        <t>It is <bcp14>RECOMMENDED</bcp14> to implement common access control methods at the
storage device file system to allow only the metadata server root
(super user) access to the storage device and to set the owner of all
directories holding data files to the root user.  This approach provides
a practical model to enforce access control and fence off cooperative
clients, but it cannot protect against malicious clients; hence, it
provides a level of security equivalent to AUTH_SYS.  It is <bcp14>RECOMMENDED</bcp14>
that the communication between the metadata server and storage device
be secure from eavesdroppers and man-in-the-middle protocol tampering.
The security measure could be physical security (e.g., the servers
are co-located in a physically secure area), encrypted communications,
or some other technique.</t>
        <t>With tightly coupled storage devices, the metadata server
and the storage device agree on the authorization decision
for each client access: a client allowed by the metadata
server to read or write a file is allowed the same access
at the storage device, and a client denied at the metadata
server is denied at the storage device.  How the storage
device reaches that decision is not constrained by this
specification.  Some storage devices replicate the user,
group, mode bits, and ACL of the metadata file onto a
POSIX-shaped local representation of the data file and let
their native filesystem enforce the decision; others (such
as storage devices backed by an object store, a
control-protocol-driven backend, or a backend with no
exposed file namespace) consult the control protocol
directly without ever materializing a POSIX file
representation.  Both approaches are conformant; the
specification's requirement is the authorization-outcome
parity, not the mechanism that produces it.</t>
        <t>The client authenticates with the storage device and
receives the same authorization outcome it would have
received via the metadata server.  In the case of tight
coupling, fencing is the responsibility of the control
protocol and is not described in detail in this document.
Implementations of the tightly coupled locking model (see
<xref target="sec-state-locking"/>) will need a way to prevent access by
certain clients to specific files by invalidating the
corresponding stateids on the storage device; in such a
scenario, the client receives NFS4ERR_BAD_STATEID.</t>
        <t>The client need not know the model used between the metadata server and
the storage device.  It need only react consistently to any errors in
interacting with the storage device.  It <bcp14>SHOULD</bcp14> both return the layout
and error to the metadata server and ask for a new layout.  At that point,
the metadata server can either hand out a new layout, hand out no layout
(forcing the I/O through it), or deny the client further access to
the file.</t>
        <section anchor="implementation-notes-for-synthetic-uidsgids">
          <name>Implementation Notes for Synthetic uids/gids</name>
          <t>The selection method for the synthetic uids and gids to be used for
fencing in loosely coupled storage devices is strictly an implementation
issue.  That is, an administrator might restrict a range of such ids
available to the Lightweight Directory Access Protocol (LDAP) 'uid' field
<xref target="RFC4519"/>.  The administrator might also be able to choose an id that
would never be used to grant access.  Then, when the metadata server had
a request to access a file, a SETATTR would be sent to the storage device
to set the owner and group of the data file.  The user and group might
be selected in a round-robin fashion from the range of available ids.</t>
          <t>Those ids would be sent back as ffv2ds_user and ffv2ds_group to the
client, who would present them as the RPC credentials to the storage
device.  When the client is done accessing the file and the metadata
server knows that no other client is accessing the file, it can
reset the owner and group to restrict access to the data file.</t>
          <t>When the metadata server wants to fence off a client, it changes the
synthetic uid and/or gid to the restricted ids.  Note that using a
restricted id ensures that there is a change of owner and at least one
id available that never gets allowed access.</t>
          <t>Under an AUTH_SYS security model, synthetic uids and gids of 0 <bcp14>SHOULD</bcp14> be
avoided.  These typically either grant super access to files on a storage
device or are mapped to an anonymous id.  In the first case, even if the
data file is fenced, the client might still be able to access the file.
In the second case, multiple ids might be mapped to the anonymous ids.</t>
        </section>
        <section anchor="example-of-using-synthetic-uidsgids">
          <name>Example of using Synthetic uids/gids</name>
          <t>The user loghyr creates a file "ompha.c" on the metadata server, which
then creates a corresponding data file on the storage device.</t>
          <t>The metadata server entry may look like:</t>
          <figure anchor="fig-meta-ompha">
            <name>Metadata's view of ompha.c</name>
            <sourcecode type="shell"><![CDATA[
-rw-r--r--    1 loghyr  staff    1697 Dec  4 11:31 ompha.c
]]></sourcecode>
          </figure>
          <t>On the storage device, the file may be assigned some unpredictable
synthetic uid/gid to deny access:</t>
          <figure anchor="fig-data-ompha">
            <name>Data's view of ompha.c</name>
            <sourcecode type="shell"><![CDATA[
-rw-r-----    1 19452   28418    1697 Dec  4 11:31 data_ompha.c
]]></sourcecode>
          </figure>
          <t>When the file is opened on a client and accessed, the user will try to
get a layout for the data file.  Since the layout knows nothing about
the user (and does not care), it does not matter whether the user loghyr
or garbo opens the file.  The client has to present an uid of 19452
to get write permission.  If it presents any other value for the uid,
then it must give a gid of 28418 to get read access.</t>
          <t>Further, if the metadata server decides to fence the file, it <bcp14>SHOULD</bcp14>
change the uid and/or gid such that these values neither match earlier
values for that file nor match a predictable change based on an earlier
fencing.</t>
          <figure anchor="fig-fenced-ompha">
            <name>Fenced Data's view of ompha.c</name>
            <sourcecode type="shell"><![CDATA[
-rw-r-----    1 19453   28419    1697 Dec  4 11:31 data_ompha.c
]]></sourcecode>
          </figure>
          <t>The set of synthetic gids on the storage device <bcp14>SHOULD</bcp14> be selected such
that there is no mapping in any of the name services used by the storage
device, i.e., each group <bcp14>SHOULD</bcp14> have no members.</t>
          <t>If the layout segment has an iomode of LAYOUTIOMODE4_READ, then the
metadata server <bcp14>SHOULD</bcp14> return a synthetic uid that is not set on the
storage device.  Only the synthetic gid would be valid.</t>
          <t>The client is thus solely responsible for enforcing file permissions
in a loosely coupled model.  To allow loghyr write access, it will send
an RPC to the storage device with a credential of 1066:1067.  To allow
garbo read access, it will send an RPC to the storage device with a
credential of 1067:1067.  The value of the uid does not matter as long
as it is not the synthetic uid granted when getting the layout.</t>
          <t>While pushing the enforcement of permission checking onto the client
may seem to weaken security, the client may already be responsible
for enforcing permissions before modifications are sent to a server.
With cached writes, the client is always responsible for tracking who is
modifying a file and making sure to not coalesce requests from multiple
users into one request.</t>
        </section>
      </section>
      <section anchor="sec-state-locking">
        <name>State and Locking Models</name>
        <t>The coupling model in effect for a given metadata-server /
storage-device pair is not negotiated over the NFS protocol.
The metadata server determines the coupling model from
out-of-band signals: administrative configuration, the
choice and capabilities of the control protocol between
the metadata server and the storage device, the storage
device's data-path protocol version, and the storage
device's backend architecture.  At the NFS protocol level,
the metadata server's expectations of the storage device
follow these classifications:</t>
        <ul spacing="normal">
          <li>
            <t>Storage devices implementing the NFSv3 or NFSv4.0
protocols on the data path are treated as loosely
coupled.</t>
          </li>
          <li>
            <t>NFSv4.1+ storage devices that do not return the
EXCHGID4_FLAG_USE_PNFS_DS flag in EXCHANGE_ID indicate
that they are to be treated as loosely coupled.  From
the locking viewpoint, they are treated in the same way
as NFSv4.0 storage devices.</t>
          </li>
          <li>
            <t>NFSv4.1+ storage devices that identify themselves with
the EXCHGID4_FLAG_USE_PNFS_DS flag set in EXCHANGE_ID
can potentially be tightly coupled.  They use a back-end
control protocol to implement the global stateid model
described in <xref target="RFC8881"/>.</t>
          </li>
        </ul>
        <t>Tight coupling additionally requires a control protocol
between the metadata server and the storage device,
discovered or advertised out-of-band as described above.</t>
        <t>Some storage devices cannot operate under the loosely
coupled model at all.  The loose coupling model in this
specification relies on the storage device authorizing
client access against synthetic uid and gid values
(<xref target="sec-Fencing-Clients"/>), which presupposes that the data
file has a local representation on the storage device
against which POSIX-style ownership checks can be applied.
Storage devices whose backend has no exposed file namespace
-- for example, object-store-backed data servers, or data
servers driven entirely through a control protocol against
a non-POSIX backend -- do not have that local representation
and <bcp14>MUST</bcp14> operate in the tightly coupled model with a
control protocol that conveys the authorization decision
directly.  A metadata server deploying with such a storage
device cannot fall back to loose coupling.</t>
        <section anchor="loosely-coupled-locking-model">
          <name>Loosely Coupled Locking Model</name>
          <t>When locking-related operations are requested, they are primarily dealt
with by the metadata server, which generates the appropriate stateids.
When an NFSv4 version is used as the data access protocol, the metadata
server may make stateid-related requests of the storage devices.  However,
it is not required to do so, and the resulting stateids are known only
to the metadata server and the storage device.</t>
          <t>Given this basic structure, locking-related operations are handled
as follows:</t>
          <ul spacing="normal">
            <li>
              <t>OPENs are dealt with by the metadata server.  Stateids are
selected by the metadata server and associated with the client
ID describing the client's connection to the metadata server.
The metadata server may need to interact with the storage device to
locate the file to be opened, but no locking-related functionality
need be used on the storage device.</t>
            </li>
            <li>
              <t>OPEN_DOWNGRADE and CLOSE only require local execution on the
metadata server.</t>
            </li>
            <li>
              <t>Advisory byte range locks can be implemented locally on the
metadata server.  As in the case of OPENs, the stateids associated
with byte range locks are assigned by the metadata server and only
used on the metadata server.</t>
            </li>
            <li>
              <t>Delegations are assigned by the metadata server that initiates
recalls when conflicting OPENs are processed.  No storage device
involvement is required.</t>
            </li>
            <li>
              <t>TEST_STATEID and FREE_STATEID are processed locally on the
metadata server, without storage device involvement.</t>
            </li>
          </ul>
          <t>All I/O operations to the storage device are done using the anonymous
stateid.  Thus, the storage device has no information about the openowner
and lockowner responsible for issuing a particular I/O operation.
As a result:</t>
          <ul spacing="normal">
            <li>
              <t>Mandatory byte range locking cannot be supported because the
storage device has no way of distinguishing I/O done on behalf of
the lock owner from those done by others.</t>
            </li>
            <li>
              <t>Enforcement of share reservations is the responsibility of the
client.  Even though I/O is done using the anonymous stateid, the
client <bcp14>MUST</bcp14> ensure that it has a valid stateid associated with the
openowner.</t>
            </li>
          </ul>
          <t>In the event that a stateid is revoked, the metadata server is responsible
for preventing client access, since it has no way of being sure that
the client is aware that the stateid in question has been revoked.</t>
          <t>As the client never receives a stateid generated by a storage device,
there is no client lease on the storage device and no prospect of lease
expiration, even when access is via NFSv4 protocols.  Clients will
have leases on the metadata server.  In dealing with lease expiration,
the metadata server may need to use fencing to prevent revoked stateids
from being relied upon by a client unaware of the fact that they have
been revoked.</t>
        </section>
        <section anchor="tightly-coupled-locking-model">
          <name>Tightly Coupled Locking Model</name>
          <t>When locking-related operations are requested, they are primarily dealt
with by the metadata server, which generates the appropriate stateids.
These stateids <bcp14>MUST</bcp14> be made known to the storage device using control
protocol facilities.  This document defines one such control protocol
-- the TRUST_STATEID, REVOKE_STATEID, and BULK_REVOKE_STATEID
operations in <xref target="sec-tight-coupling-control"/> -- for deployments in
which the storage devices are NFSv4.2 servers willing to implement
the new operations.  A storage device with its own established
back-end control protocol that provides the equivalent functional
capabilities is conformant under this specification without
implementing the TRUST_STATEID family; see
<xref target="sec-tight-coupling-control"/> for the conformance framing.</t>
          <t>When using the TRUST_STATEID control protocol defined in
<xref target="sec-tight-coupling-control"/>, the metadata server and a storage
device establish that they can use it via a two-part handshake,
both parts of which <bcp14>MUST</bcp14> succeed before the metadata server may
issue TRUST_STATEID against that storage device for production
traffic:</t>
          <dl>
            <dt>Capability probe:</dt>
            <dd>
              <t>At control-session setup the metadata
server sends a TRUST_STATEID against the anonymous stateid
(see <xref target="sec-tight-coupling-probe"/>).  A storage device that
supports tight coupling <bcp14>MUST</bcp14> reject the probe with
NFS4ERR_INVAL; a storage device that does not support tight
coupling returns NFS4ERR_NOTSUPP and the metadata server
falls back to loose coupling.  The metadata server records
result per storage device by setting the
FFV2_COUPLING_TRUSTED_STATEID bit in ffv2dv_coupling on
success (leaving the bit clear on NFS4ERR_NOTSUPP).</t>
            </dd>
            <dt>Control-session gating:</dt>
            <dd>
              <t>The metadata server presents
EXCHGID4_FLAG_USE_PNFS_MDS at EXCHANGE_ID when it opens the
control session to the storage device
(see <xref target="sec-tight-coupling-control-session"/>).  The storage
device <bcp14>MUST</bcp14> reject any incoming TRUST_STATEID,
REVOKE_STATEID, or BULK_REVOKE_STATEID that does not arrive
on such a session with NFS4ERR_PERM.  This check
distinguishes the metadata server from an ordinary pNFS
client, which connects with EXCHGID4_FLAG_USE_PNFS_DS or
EXCHGID4_FLAG_USE_NON_PNFS and so does not reach these
operations.  The flag is self-declared, so the check does
not authenticate the metadata server; the control
session's authentication does
(<xref target="sec-tight-coupling-control-session"/>).</t>
            </dd>
          </dl>
          <t>Given this basic structure, locking-related operations are handled
as follows:</t>
          <ul spacing="normal">
            <li>
              <t>OPENs are dealt with primarily on the metadata server.  Stateids
are selected by the metadata server and associated with the client
ID describing the client's connection to the metadata server.
The metadata server needs to interact with the storage device to
locate the file to be opened and to make the storage device aware of
the association between the metadata-server-chosen stateid and the
client and openowner that it represents.  OPEN_DOWNGRADE and CLOSE
are executed initially on the metadata server, but the state change
<bcp14>MUST</bcp14> be propagated to the storage device.</t>
            </li>
            <li>
              <t>Advisory byte range locks can be implemented locally on the
metadata server.  As in the case of OPENs, the stateids associated
with byte range locks are assigned by the metadata server and are
available for use on the metadata server.  Because I/O operations
are allowed to present lock stateids, the metadata server needs the
ability to make the storage device aware of the association between
the metadata-server-chosen stateid and the corresponding open stateid
it is associated with.</t>
            </li>
            <li>
              <t>Mandatory byte range locks can be supported when both the metadata
server and the storage devices have the appropriate support.  As in
the case of advisory byte range locks, these are assigned by the
metadata server and are available for use on the metadata server.
To enable mandatory lock enforcement on the storage device, the
metadata server needs the ability to make the storage device aware
of the association between the metadata-server-chosen stateid and
the client, openowner, and lock (i.e., lockowner, byte range, and
lock-type) that it represents.  Because I/O operations are allowed
to present lock stateids, this information needs to be propagated to
all storage devices to which I/O might be directed rather than only
to storage device that contain the locked region.</t>
            </li>
            <li>
              <t>Delegations are assigned by the metadata server that initiates
recalls when conflicting OPENs are processed.  Because I/O operations
are allowed to present delegation stateids, the metadata server
requires the ability:  </t>
              <ol spacing="normal" type="1"><li>
                  <t>to make the storage device aware of the association between
the metadata-server-chosen stateid and the filehandle and
delegation type it represents</t>
                </li>
                <li>
                  <t>to break such an association.</t>
                </li>
              </ol>
            </li>
            <li>
              <t>TEST_STATEID is processed locally on the metadata server, without
storage device involvement.</t>
            </li>
            <li>
              <t>FREE_STATEID is processed on the metadata server, but the metadata
server requires the ability to propagate the request to the
corresponding storage devices.</t>
            </li>
          </ul>
          <t>Scope of this document.  The wire-level control-protocol
operations this document defines -- TRUST_STATEID,
REVOKE_STATEID, and BULK_REVOKE_STATEID
(<xref target="sec-tight-coupling-control"/>) -- carry only the association
between a layout stateid, the NFSv4 clientid4 of the client
whose layout is authorized, the ffv2m_client_id the metadata
server assigned to that client, and (for TRUST_STATEID) the
iomode, expiry, and principal.  They do NOT carry openowner,
lockowner, byte range, lock-type, the identity of an
associated open stateid, or delegation-type.</t>
          <t>The bullets above (OPEN state, advisory byte range lock state,
mandatory byte range lock state, and delegation state)
enumerate the associations the storage device would need in
order to enforce POSIX-conformant OPEN, byte range locking,
and delegation semantics against per-client identity rather
than against the loose coupling synthetic uid/gid.  These are
inherited from the general tight coupling locking model in
<xref section="2.3" sectionFormat="of" target="RFC8435"/>.  Trusted-stateid tight coupling as
defined by this document satisfies these associations only
for the layout stateid; a deployment that requires mandatory
byte range locking, delegation recall, or the finer-grained
open/lock stateid associations <bcp14>MUST</bcp14> use a back-end control
protocol between the metadata server and the storage device
that carries this state.  Such a back-end control protocol is
out of scope for this document.</t>
          <t>A deployment that does not need those finer-grained
associations -- for example, a flexible file v2 layout
deployment whose per-file access-control decisions live entirely
on the metadata server
and whose storage devices see only chunk-level CAS on layout
stateids -- is conformant with the trusted stateid tight coupling
model using only the TRUST_STATEID family.  That
scope covers the layout stateid and, transitively via
ffv2m_client_id, the writer identity carried on CHUNK
operations.</t>
          <t>Because the client will possess and use stateids valid on the storage
device, there will be a client lease on the storage device, and the
possibility of lease expiration does exist.  The best approach for the
storage device is to retain these locks as a courtesy.  However, if it
does not do so, control protocol facilities need to provide the means
to synchronize lock state between the metadata server and storage device.</t>
          <t>Clients will also have leases on the metadata server that are subject
to expiration.  In dealing with lease expiration, the metadata server
would be expected to use control protocol facilities enabling it to
invalidate revoked stateids on the storage device.  In the event the
client is not responsive, the metadata server may need to use fencing
to prevent revoked stateids from being acted upon by the storage device.</t>
        </section>
      </section>
      <section anchor="sec-tight-coupling-control">
        <name>Tight Coupling Control Protocol</name>
        <t>When an NFSv4.2 storage device participates in a tightly coupled
deployment, the metadata server and the storage devices need a
control protocol that:</t>
        <ol spacing="normal" type="1"><li>
            <t>registers the layout stateid with each storage device so the
storage device can validate client I/O independently; and</t>
          </li>
          <li>
            <t>revokes trust promptly when the metadata server withdraws the
client's authorization -- for example, on CB_LAYOUTRECALL
timeout, lease expiry, or layout return after error.</t>
          </li>
        </ol>
        <t>This specification defines one such control protocol, designated
trusted stateid tight coupling, as three new NFSv4.2 operations:
TRUST_STATEID, REVOKE_STATEID, and BULK_REVOKE_STATEID.  These operations are sent by the
metadata server to each storage device over a dedicated control
session (see <xref target="sec-tight-coupling-control-session"/>) and <bcp14>MUST NOT</bcp14>
be sent by pNFS clients.</t>
        <t>Other tight coupling control protocols may exist or be defined
elsewhere.  Existing pNFS server implementations with established
back-end control protocols -- for example, dCache <xref target="DCACHE"/>,
which has its own control protocol between its metadata
service and its data servers -- satisfy the tightly coupled
locking model
(<xref target="sec-state-locking"/>) through their own mechanisms and are
conformant under this specification provided they meet the
functional capabilities described there.  Such implementations
need not adopt the TRUST_STATEID family, and their interoperability
with the TRUST_STATEID family is outside the scope of this
document.</t>
        <t>A storage device that does not implement TRUST_STATEID is treated
as not supporting trusted stateid tight coupling specifically; the
capability probe in <xref target="sec-tight-coupling-probe"/> detects this and
the metadata server falls back to loose coupling
(<xref target="sec-tight-coupling-compat"/>) or, if the storage device's own
control protocol is in use, that protocol governs.  Within the
remainder of <xref target="sec-tight-coupling-control"/> and its subsections,
unqualified references to "tight coupling" or "tightly coupled"
refer to the trusted stateid variant defined here.</t>
        <t>The receiver of these operations is any server the metadata
server delegates client-I/O admission to.  In this document that
is the storage device (data server).  The same mechanism applies to
a proxy server -- a proxy server may or may not additionally act
as a data server, but in either role it needs the metadata server
to register a layout stateid before it can admit client I/O.
Where this section says "storage device," read it as "storage
device, or proxy server"; the flag check and the three operations
are identical for both roles.</t>
        <section anchor="sec-tight-coupling-probe">
          <name>Capability Discovery</name>
          <t>A storage device indicates support for trusted stateid tight
coupling implicitly, by processing TRUST_STATEID rather than
returning NFS4ERR_NOTSUPP.  (A storage device that supports a
non-TRUST_STATEID form of tight coupling but not the
trusted stateid variant defined here will return NFS4ERR_NOTSUPP
on this probe; from this specification's perspective it is
treated the same as a storage device that does not support tight
coupling at all.)  The metadata server probes each storage device
during control-session setup:</t>
          <figure anchor="fig-trust-stateid-probe">
            <name>TRUST_STATEID capability probe</name>
            <artwork><![CDATA[
SEQUENCE + PUTROOTFH + TRUST_STATEID(
    tsa_layout_stateid = ANONYMOUS_STATEID,
    tsa_pnfs_clientid  = 0,
    tsa_client_id      = 0,
    tsa_iomode         = LAYOUTIOMODE4_READ,
    tsa_expire         = 0,
    tsa_principal      = "")
]]></artwork>
          </figure>
          <t>The anonymous stateid is used deliberately: a correctly implemented
storage device <bcp14>MUST</bcp14> reject it (see <xref target="sec-TRUST_STATEID"/>), so the
probe cannot accidentally register garbage in the trust table.  The
metadata server interprets the probe response as follows:</t>
          <dl>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>trusted stateid tight coupling is not supported on this
storage device.  The metadata server leaves the
FFV2_COUPLING_TRUSTED_STATEID bit clear in ffv2dv_coupling
for this storage device.  If ffv2dv_coupling has no other
tight coupling bits set for this storage device, the
metadata server falls back to the synthetic-uid model
(anonymous stateid plus fencing).</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>trusted stateid tight coupling is supported.  The anonymous
stateid was correctly rejected.  The metadata server sets the
FFV2_COUPLING_TRUSTED_STATEID bit in ffv2dv_coupling for this
storage device.</t>
            </dd>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the storage device accepted an anonymous stateid into
its trust table.  This is a storage device bug.  The metadata
server <bcp14>MAY</bcp14> treat the capability as confirmed to avoid
downgrading to loose coupling, but it <bcp14>MUST</bcp14> immediately issue
REVOKE_STATEID to remove the bogus entry.</t>
            </dd>
          </dl>
          <t>The capability is recorded per storage device, not per file.
Partial support across a mirror set is permitted: each
ffv2_device_versions4 entry returned by GETDEVICEINFO carries
its own ffv2dv_coupling value, set independently.</t>
        </section>
        <section anchor="sec-tight-coupling-control-session">
          <name>Control Session</name>
          <t>The metadata server establishes an NFSv4.2 session to each
tight coupling capable storage device at startup.  On this session
the metadata server acts as the storage device's client and
presents EXCHGID4_FLAG_USE_PNFS_MDS in its EXCHANGE_ID args.</t>
          <t>That is a repurposing of the flag, and implementers should
understand it as one.  <xref section="13.1" sectionFormat="of" target="RFC8881"/> determines a
server's pNFS role from the eir_flags it returns, not from what
the client asks for, and treats the argument flags as role
requests; read literally, EXCHGID4_FLAG_USE_PNFS_MDS in the args
asks the peer to act as this client's metadata server, which is
not what a metadata server wants from a storage device.  The flag
is used here precisely because it carries no other meaning on this
path.  <xref section="13.1" sectionFormat="of" target="RFC8881"/> does name a flag for a client
connecting to a data server, EXCHGID4_FLAG_USE_PNFS_DS, but a pNFS
client presents that one too, so it cannot separate a metadata
server from a client.  EXCHGID4_FLAG_USE_PNFS_MDS is the one role
request a client has no reason to make of a storage device, and
that is what leaves it free to mark the control session.</t>
          <t>Presenting it does not conflict with <xref target="RFC8881"/>.
<xref section="13.1" sectionFormat="of" target="RFC8881"/> permits a client to request zero or
more of the three role flags even where the combination requested
is contradictory, and constrains only the combinations a server
may return in its eir_flags.  A storage device that also serves a
metadata server role, and that selects among its roles from the
requested ones, should account for this document's use of the flag
when composing its eir_flags.</t>
          <t>The storage device <bcp14>MUST</bcp14> verify that any incoming TRUST_STATEID,
REVOKE_STATEID, or BULK_REVOKE_STATEID compound arrives on a
session whose owning client presented EXCHGID4_FLAG_USE_PNFS_MDS
in its EXCHANGE_ID args.  Requests that arrive on any other
session <bcp14>MUST</bcp14> be rejected with NFS4ERR_PERM.  This is the sole
access control on these operations; a pNFS client connecting to
the storage device does not present EXCHGID4_FLAG_USE_PNFS_MDS
and therefore cannot invoke them.</t>
          <t>The EXCHGID4_FLAG_USE_PNFS_MDS check replaces any path- or
filehandle-level gating.  TRUST_STATEID operates on a filehandle
that may be any file on the storage device, and the metadata
server is the sole authority that can legitimately speak this
protocol.</t>
          <t>Because the EXCHGID4_FLAG_USE_PNFS_MDS check relies on the
owning client's self-declaration at EXCHANGE_ID time, the
storage device cannot by itself distinguish a legitimate
metadata server from any other host that sets the flag.  The
wire protocol provides no primitive that binds a request to a
particular pNFS role; the flag is a hint whose operational
meaning is only as strong as the deployment's authentication
or isolation choice.</t>
          <t>The deployment requirement is that only entities the
deployment considers legitimate metadata servers can (a)
establish a control session with EXCHGID4_FLAG_USE_PNFS_MDS
against the storage device and (b) invoke TRUST_STATEID,
REVOKE_STATEID, or BULK_REVOKE_STATEID on it.  Because the
flag is self-declared, the deployment is what makes that
requirement hold; the wire protocol does not.</t>
          <t>The control session <bcp14>MUST</bcp14> be mutually authenticated and
integrity protected, by one of:</t>
          <ul spacing="normal">
            <li>
              <t>RPCSEC_GSS (<xref target="RFC7861"/>) with a machine principal that the
storage device has been configured to accept as a metadata
server, with at least the integrity service
(RPCSEC_GSS_KRB5I).  The storage device validates the
principal against a local policy list before accepting the
flag.</t>
            </li>
            <li>
              <t>RPC-over-TLS (<xref target="RFC9289"/>) with mutual authentication and a
client certificate that the storage device has been
configured to accept as a metadata server.  The storage
device validates the certificate against a local policy
list before accepting the flag.</t>
            </li>
          </ul>
          <t>AUTH_SYS <bcp14>MUST NOT</bcp14> be used as the authentication flavor of the
control session, and the control session <bcp14>MUST NOT</bcp14> run without
integrity protection.  An on-path attacker on an unprotected
control session can forge a TRUST_STATEID for a stateid and
writer identity of its choosing, suppress a REVOKE_STATEID so
that a revoked client keeps access, and force the fallback
described in <xref target="sec-security-trust-stateid"/>.  None of these
are detectable from the operations this document defines.</t>
          <t>Restricting which hosts can reach the control-session path is
defense in depth rather than a substitute for the above.  It
keeps an unauthorized host from opening a session; it does
not protect a session once open, and a deployment that relies
on it alone carries the forgery exposure just described.  Two
such measures are common:</t>
          <ul spacing="normal">
            <li>
              <t>Network-path isolation: the control-session path runs on a
network segment (dedicated management VLAN, private link,
or similar) that pNFS clients cannot reach, so only
configured metadata servers can open a session at all.</t>
            </li>
            <li>
              <t>Operating-system-level filesystem access control on the
storage device: the underlying export that backs the pNFS
data files is configured so that only the metadata server's
OS identity (typically root, or a dedicated privileged uid)
can access it.  A pNFS client that reaches the storage
device but presents any other uid receives permission
errors before it can invoke any operation, control-plane
or otherwise.</t>
            </li>
          </ul>
          <t>A single host <bcp14>MAY</bcp14> legitimately act in multiple pNFS roles
against the same storage device -- for example, an entity
that is a metadata server for one export and a plain pNFS
client for another.  The wire protocol does not distinguish
these roles at the operation level; the deployment is
responsible for arranging that the storage device can tell
them apart, typically by using distinct credentials or
distinct sessions for the two roles (each session presents
EXCHGID4_FLAG_USE_PNFS_MDS according to the role the entity
is acting in on that session).</t>
          <t>The security consequences of these choices -- what an
unauthenticated attacker can invoke if none of the mechanisms
above is deployed, and what an authenticated caller can still
achieve by misrepresenting role -- are discussed in
<xref target="sec-security-trust-stateid"/>.</t>
        </section>
        <section anchor="sec-tight-coupling-layoutget">
          <name>Flow at LAYOUTGET</name>
          <t>For each new or refreshed layout segment, the metadata server:</t>
          <ol spacing="normal" type="1"><li>
              <t>chooses the layout stateid (as it would without tight coupling);</t>
            </li>
            <li>
              <t>identifies the trusted stateid capable storage devices in
the mirror set (those for which ffv2dv_coupling has the
FFV2_COUPLING_TRUSTED_STATEID flag set);</t>
            </li>
            <li>
              <t>fans out TRUST_STATEID to each such storage device,
specifying the layout stateid, the layout iomode, a
tsa_expire derived from the metadata server's lease (see
<xref target="sec-tight-coupling-lease"/>), and the client's authenticated
identity in tsa_principal;</t>
            </li>
            <li>
              <t>waits for all fan-outs to complete (or reach their per-storage-device timeout) before returning the layout.</t>
            </li>
          </ol>
          <t>If every storage device in the mirror set rejects the TRUST_STATEID
fan-out, the metadata server <bcp14>MUST NOT</bcp14> return the layout; instead it
returns NFS4ERR_LAYOUTTRYLATER.  If some storage devices accept and
others reject, the metadata server <bcp14>MAY</bcp14> return a layout covering
only the accepting storage devices, provided the accepting subset
still meets the minimum servable coverage for the file's
encoding: at least one replica for FFV2_ENCODING_PASSTHROUGH or
FFV2_ENCODING_REPLICATED, or at least k of the k + m storage
devices for an erasure-coded encoding at (k, m) parameters.
If it does not, the metadata server <bcp14>MUST NOT</bcp14> return a partial
layout and instead returns NFS4ERR_LAYOUTTRYLATER as in the
all-reject case.  A storage device that returns
NFS4ERR_DELAY is retried until either success or the metadata
server's LAYOUTGET-response budget is exhausted.  If a storage
device returns NFS4ERR_NOTSUPP at this time (having accepted
the probe earlier), the metadata server <bcp14>MUST</bcp14> clear the
FFV2_COUPLING_TRUSTED_STATEID flag in ffv2dv_coupling for this
storage device.  If no tight coupling flags remain set for
this device, the metadata server falls back to the
synthetic-uid model and re-issues the layout accordingly.</t>
        </section>
        <section anchor="sec-tight-coupling-principal">
          <name>Principal Binding and the Kerberos Gap</name>
          <t>The flexible file v1 layout has a known gap: a client authenticated
to the metadata server with Kerberos has no way to present the same
authenticated identity to the storage device, because flexible file
v1 layouts carry only ffds_user / ffds_group (POSIX uid/gid for
AUTH_SYS).  A strict Kerberos deployment on the flexible file v1
layout must either allow AUTH_SYS from the metadata server's subnet
or accept that the flexible file v1 layout's data path is not
Kerberos-protected.</t>
          <t>The tsa_principal field in TRUST_STATEID closes that gap.  When a
client authenticates to the metadata server as a Kerberos
principal (e.g., alice@REALM), the metadata server passes that
principal name to each storage device in tsa_principal.  The
storage device then enforces a two-part check on each CHUNK
operation that presents the layout stateid:</t>
          <t>a.  the stateid is in the trust table and has not expired; and</t>
          <t>b.  the caller's authenticated identity (the RPCSEC_GSS display
    name on the CHUNK compound) matches tsa_principal.</t>
          <t>Both conditions <bcp14>MUST</bcp14> hold.  On principal mismatch the storage
device <bcp14>MUST</bcp14> return NFS4ERR_ACCESS -- the semantics are "you do
not have an authorized layout for this file", which matches the
existing fencing error and avoids the confusion of
NFS4ERR_WRONGSEC (which directs the client to re-authenticate
with a different flavor) or NFS4ERR_BAD_STATEID (which directs
the client to return the layout).</t>
          <t>The comparison in (b) is an octet-for-octet comparison.  The
metadata server <bcp14>MUST</bcp14> set tsa_principal to the GSS display name
of the client's context as the GSS-API returned it, without
case folding, realm rewriting, or any other normalization.
The storage device <bcp14>MUST</bcp14> compare the display name of the
inbound RPCSEC_GSS context against the stored tsa_principal
for equality of octets, and <bcp14>MUST NOT</bcp14> case fold or normalize
either string before comparing.  No partial match is defined:
a name that differs in any octet is a mismatch.</t>
          <t>The rule has to be stated for this field because the generic
rules for its type do not settle it.  tsa_principal is a
utf8str_cs, which <xref section="3.2" sectionFormat="of" target="RFC8881"/> defines as a
case-sensitive UTF-8 string and <xref section="14.1" sectionFormat="of" target="RFC8881"/>
binds to the nfs4_cs_prep profile.  That profile specifies no
normalization form (<xref section="14.1.4" sectionFormat="of" target="RFC8881"/>), so either
end may receive unnormalized characters, and its case-mapping
hook is conditioned on the case_insensitive and
case_preserving file system attributes, which describe a file
system's naming rules and say nothing about an authenticated
principal.  Comparing octets leaves the metadata server as the
one authority on the form of the name, which is what the
two-part check needs: the storage device is answering "is this
the principal the metadata server authorized", not "does this
name designate the same user".</t>
          <t>The name compared is a printable display name, not a GSS-API
exported name.  <xref section="1.1.5" sectionFormat="of" target="RFC2743"/> warns that the
printable syntax a mechanism produces is a local matter, and
that a caller wanting portability compares internal-format
names instead.  That option is not available here: the
registration travels over the wire as a utf8str_cs, and the
storage device holds no internal-format name from the metadata
server to compare against.  Two consequences follow.  The
metadata server passes the display name through unmodified, as
required above.  And a client authenticates to the metadata
server and to the storage device under the same GSS-API
mechanism; a deployment that offers different mechanisms on
the two paths cannot use trusted stateid tight coupling for
the affected clients, whose CHUNK operations present a name
that cannot match the registered one and fail the principal
check with NFS4ERR_ACCESS.</t>
          <t>The metadata server <bcp14>MUST</bcp14> populate tsa_principal with the
RPCSEC_GSS display name of the authenticated client when the
client authenticated to the metadata server via RPCSEC_GSS.  The
metadata server <bcp14>MUST</bcp14> set tsa_principal to the empty string only
for AUTH_SYS and TLS clients (for which there is no server-verified per-user identity).  Setting tsa_principal to the empty
string for an RPCSEC_GSS client disables the principal check on
the storage device and silently re-opens the flexible file v1 layout
Kerberos gap; it is a metadata server bug, not a protocol option.</t>
          <t>If tsa_principal is the empty string, no principal check applies.
This is the expected setting for AUTH_SYS and TLS clients:</t>
          <ul spacing="normal">
            <li>
              <t>AUTH_SYS clients have no server-verified identity.  The
storage device's stateid check and the AUTH_SYS uid/gid on the
data file together constitute the authorization.  In a tightly
coupled deployment the data file's owner/group need not match
the metadata file's, since ffv2ds_user and ffv2ds_group are
ignored (see <xref target="sec-ffv2-mirror4"/>).</t>
            </li>
            <li>
              <t>TLS clients have transport-layer authentication via mutual TLS
(<xref target="RFC9289"/>).  The TLS layer authenticates the client machine;
the stateid check confirms the metadata server authorized that
machine to access this file.  The machine-level authentication
is handled beneath the RPC layer and is not reflected in
tsa_principal.  Opportunistic TLS (STARTTLS without certificate
verification) provides encryption but not authentication, and
therefore has the same authorization properties as plain
AUTH_SYS.</t>
            </li>
          </ul>
          <t>When a client's I/O is routed through a proxy server -- that
is, the layout the metadata server returns to the client has
FFV2_DS_FLAGS_PROXY set on the proxy's ffv2_data_server4 entry --
the storage device observes CHUNK operations arriving from the
proxy server's address rather than from the client directly.  The tsa_principal the metadata server
populates in TRUST_STATEID is the principal the storage device
will observe on those CHUNK operations, and <xref target="I-D.haynes-nfsv4-flexfiles-v2-proxy-server"/>'s credential-forwarding rules (in particular rule 1,
"Credential pass-through") require the proxy server to forward the
client's credentials verbatim on every CHUNK operation it issues
on the client's behalf.  Therefore:</t>
          <ul spacing="normal">
            <li>
              <t>For an RPCSEC_GSS client whose I/O is proxied through a proxy server,
the metadata server <bcp14>MUST</bcp14> set tsa_principal to the client's
RPCSEC_GSS display name (identical to the non-proxied case).
The storage device's principal check on CHUNK operations will
match against the client's principal on the forwarded
compound, not the proxy server's service identity.</t>
            </li>
            <li>
              <t>For an AUTH_SYS client whose I/O is proxied through a proxy server,
the metadata server <bcp14>MUST</bcp14> set tsa_principal to the empty
string (identical to the non-proxied case).  The proxy server forwards
the client's AUTH_SYS uid/gid; the storage device's stateid
check plus the forwarded AUTH_SYS uid/gid constitute the
authorization.</t>
            </li>
          </ul>
          <t>The metadata server <bcp14>MUST NOT</bcp14> set tsa_principal to the proxy server's own
service principal.  Doing so would require the proxy server to
authenticate to the storage device as itself (bypassing
credential forwarding) which is explicitly prohibited by rule 4 of <xref target="I-D.haynes-nfsv4-flexfiles-v2-proxy-server"/> ("proxy server service identity is for the
control plane only").</t>
        </section>
        <section anchor="sec-tight-coupling-trust-gap">
          <name>Client-Detected Trust Gap</name>
          <t>A window exists between a successful TRUST_STATEID fan-out and
the client's first I/O to the storage device.  A transient failure
may cause the storage device to forget or reject the entry before
the client's first CHUNK_WRITE arrives.  The client cannot
distinguish this case from legitimate revocation; both surface as
NFS4ERR_BAD_STATEID on the storage device.</t>
          <t>The recovery path:</t>
          <ol spacing="normal" type="1"><li>
              <t>The client sends LAYOUTERROR(layout_stateid, device_id,
NFS4ERR_BAD_STATEID) to the metadata server.</t>
            </li>
            <li>
              <t>The metadata server retries TRUST_STATEID against the
reporting storage device.  If the retry succeeds, the
metadata server returns NFS4_OK for LAYOUTERROR.  The client
retries the original I/O.</t>
            </li>
            <li>
              <t>If the retry fails -- the storage device is unreachable or
returns a hard error -- the metadata server issues
CB_LAYOUTRECALL for that device and the client returns the
layout segment covering that storage device.  The client is
expected to re-request via LAYOUTGET.</t>
            </li>
          </ol>
          <t>This is the same LAYOUTERROR path used for NFS4ERR_ACCESS or
NFS4ERR_PERM in the fencing model (see <xref target="sec-Fencing-Clients"/>),
with the metadata server's action being "retry TRUST_STATEID"
instead of "rotate uid/gid".</t>
        </section>
        <section anchor="sec-tight-coupling-lease">
          <name>Lease and Renewal</name>
          <t>tsa_expire in a TRUST_STATEID request is a wall-clock expiry
instant expressed as an nfstime4.  The metadata server <bcp14>MUST</bcp14> set
tsa_expire to the current wall-clock time plus the metadata
server's client lease period.</t>
          <t>Clock-synchronization assumption: the metadata server and each
storage device <bcp14>MUST</bcp14> maintain wall-clock synchronization within
one lease period, e.g., via NTP <xref target="RFC5905"/> or an equivalent
mechanism.  Under this assumption, a tsa_expire computed by the
metadata server and evaluated by the storage device is
interpreted consistently within the storage device's local
clock.  Deployments unable to guarantee sub-lease-period clock
synchronization <bcp14>MUST</bcp14> either (a) shorten the effective TRUST_STATEID
lease so it exceeds the worst-case skew by at least 2x, or (b)
route I/O through the metadata server as the fallback path (no
tight coupling control session, no TRUST_STATEID) so lease
enforcement stays on the metadata server's clock alone.  A storage device that
detects sustained clock divergence from the metadata server
(e.g., via periodic wall-clock exchange as part of its
tight coupling control-session heartbeats) <bcp14>SHOULD</bcp14> log the
divergence and <bcp14>MAY</bcp14> refuse further TRUST_STATEID entries with
NFS4ERR_DELAY until the divergence is corrected.</t>
          <t>The metadata server <bcp14>MUST</bcp14> re-issue TRUST_STATEID for an entry
before tsa_expire while the corresponding layout is outstanding.
The <bcp14>RECOMMENDED</bcp14> trigger is: when an entry is within half the
lease period of its tsa_expire, re-issue TRUST_STATEID with a
refreshed tsa_expire.  Renewing on every SEQUENCE that keeps the
layout stateid alive is correct but produces
metadata-server-to-storage-device traffic proportional to the
client's SEQUENCE rate, which is undesirable in steady state.</t>
          <t>If an entry expires on the storage device before the metadata
server renews it -- for example, because the metadata server is
partitioned from the storage device for longer than the lease
period -- the storage device <bcp14>MUST</bcp14> return NFS4ERR_BAD_STATEID to
the client on the next CHUNK operation.  The client returns the
layout to the metadata server and re-requests.  This is the same
recovery path as the trust gap described above.</t>
        </section>
        <section anchor="sec-tight-coupling-ds-crash">
          <name>Storage Device Crash Recovery</name>
          <t>A storage device <bcp14>MAY</bcp14> persist its trust table across restarts.  An
implementation that does so <bcp14>MUST</bcp14> also persist its server-instance
identity, returning the same eir_server_owner.so_minor_id on
EXCHANGE_ID after the restart (per <xref section="18.35" sectionFormat="of" target="RFC8881"/>), so that
clients and the metadata server observe the device as
continuously available and the persisted trust entries remain
valid against the layout stateids that were issued before the
restart.</t>
          <t>A storage device that does NOT persist its trust table empties
the table on restart and <bcp14>MUST</bcp14> present a new server instance
(incremented so_minor_id) so that clients detect the restart.
The remainder of this section describes the recovery path for
the volatile case.</t>
          <t>The client detects a volatile storage device restart via
NFS4ERR_BADSESSION or NFS4ERR_STALE_CLIENTID on its data server
session.  The client returns the affected layout segment to the
metadata server via LAYOUTRETURN and re-requests via LAYOUTGET.
The metadata server then fans out fresh TRUST_STATEID operations
to the recovered storage device.</t>
          <t>Planned storage device restarts (software upgrade, etc.) <bcp14>SHOULD</bcp14>
drain in-flight CHUNK operations before shutting down.</t>
        </section>
        <section anchor="sec-tight-coupling-mds-crash">
          <name>Metadata Server Crash Recovery</name>
          <t>A metadata server <bcp14>MAY</bcp14> persist all its trust-management state
across restarts.  An implementation that does so <bcp14>MUST</bcp14> also
persist its server-instance identity, returning the same
eir_server_owner.so_minor_id on EXCHANGE_ID after the restart
(per <xref section="18.35" sectionFormat="of" target="RFC8881"/>), so that storage devices observe the
metadata server as continuously available and accept incoming
TRUST_STATEID and REVOKE_STATEID operations against the existing
trust entries without revalidation.  No grace period is required.</t>
          <t>A metadata server that presents a new server instance
(incremented so_minor_id) on restart follows the recovery path
in the remainder of this section.</t>
          <t>When the metadata server restarts as a new instance, its control
sessions to the storage devices are lost.  Trust entries remain
on the storage devices until tsa_expire, but the metadata server
is no longer renewing them; the entries are effectively orphaned
until the metadata server completes grace.</t>
          <t>When the metadata server reconnects to a storage device with a
new boot epoch -- that is, the EXCHANGE_ID returns a new server
owner on the storage device's view of the metadata server -- the
storage device <bcp14>SHOULD</bcp14> mark all trust entries established under
the prior metadata-server epoch as pending-revalidation.  While an
entry is pending-revalidation:</t>
          <ul spacing="normal">
            <li>
              <t>I/O that presents the entry's stateid <bcp14>MUST</bcp14> receive
NFS4ERR_DELAY, not NFS4ERR_BAD_STATEID.  NFS4ERR_DELAY tells
the client to retry with the same stateid -- the metadata
server is recovering and may yet revalidate the entry.
NFS4ERR_BAD_STATEID would instead cause the client to return
the layout immediately, producing a thundering herd against
the metadata server during grace.</t>
            </li>
            <li>
              <t>An entry remains pending-revalidation until the metadata
server either re-issues TRUST_STATEID for it (which transitions
it back to trusted) or until the entry's tsa_expire elapses
(which removes it).</t>
            </li>
          </ul>
          <t>The metadata server's recovery sequence is:</t>
          <ol spacing="normal" type="1"><li>
              <t>Reconnect to each storage device and establish a fresh
control session.</t>
            </li>
            <li>
              <t>Optionally issue BULK_REVOKE_STATEID with an all-zeros
clientid to each storage device.  This clears the prior trust
table eagerly; skipping this step is correct, because orphan
entries expire via tsa_expire.</t>
            </li>
            <li>
              <t>Enter grace and accept RECLAIM operations from clients.  For
each reclaimed layout, fan out TRUST_STATEID to the relevant
storage devices.</t>
            </li>
            <li>
              <t>Exit grace.  Clients that did not reclaim in time have their
state revoked; the metadata server issues REVOKE_STATEID or
BULK_REVOKE_STATEID on their behalf.</t>
            </li>
          </ol>
          <t>Metadata servers <bcp14>SHOULD</bcp14> persist the set of outstanding
TRUST_STATEID entries (clientid, layout stateid, storage device
address, tsa_expire) to stable storage.  With this persistence
the metadata server can re-issue TRUST_STATEID for all known
entries immediately upon reconnecting to each storage device,
before clients begin reclaiming.  This shrinks the window during
which the storage device returns NFS4ERR_DELAY for client I/O.
Persistence is a latency optimization, not a correctness
requirement: the re-layout path handles recovery in all cases.</t>
        </section>
        <section anchor="sec-tight-coupling-compat">
          <name>Backward Compatibility</name>
          <ul spacing="normal">
            <li>
              <t>NFSv3 storage devices are unchanged.  They are always treated
as loosely coupled; TRUST_STATEID does not exist on NFSv3
servers.</t>
            </li>
            <li>
              <t>NFSv4.2 storage devices for which the TRUST_STATEID probe
returns NFS4ERR_NOTSUPP are treated as loosely coupled;
fencing is the only revocation mechanism, the same as for
NFSv3.</t>
            </li>
            <li>
              <t>NFSv4.2 storage devices for which the probe returns
NFS4ERR_INVAL support tight coupling; the metadata server uses
TRUST_STATEID at LAYOUTGET and REVOKE_STATEID or
BULK_REVOKE_STATEID for revocation instead of fencing.</t>
            </li>
          </ul>
          <t>A single deployment <bcp14>MAY</bcp14> contain a mix of tight-coupled and
loose-coupled storage devices; each is negotiated independently
via the probe.</t>
        </section>
      </section>
    </section>
    <section anchor="device-addressing-and-discovery">
      <name>Device Addressing and Discovery</name>
      <t>Data operations to a storage device require the client to know the
network address of the storage device.  The NFSv4.1+ GETDEVICEINFO
operation (<xref section="18.40" sectionFormat="of" target="RFC8881"/>) is used by the client to
retrieve that information.</t>
      <section anchor="sec-ff_device_addr4">
        <name>ffv2_device_addr4</name>
        <t>The ffv2_device_addr4 data structure (see <xref target="fig-ff_device_addr4"/>)
is returned by the server as the layout type specific opaque field
da_addr_body in the device_addr4 structure by a successful GETDEVICEINFO
operation for LAYOUT_FLEX_FILES_V2.</t>
        <t>ffv2_device_addr4 and ffv2_device_versions4 are the flexible
file v2 layout counterparts to ff_device_addr4 and
ff_device_versions4 in <xref target="RFC8435"/>.  The two structures are
similar in shape but carry a flexible-file-v2-specific enrichment:
the boolean ffdv_tightly_coupled from RFC 8435 has been widened
to the uint32_t bitfield ffv2dv_coupling, which lets a storage
device advertise more than one coupling capability at the same
time (<xref target="sec-tight-coupling-control"/>).  Because the field type
has changed, the flexible file v2 layout structs are named
distinctly to avoid confusion with the RFC 8435 originals.</t>
        <figure anchor="fig-ff_device_versions4">
          <name>ffv2_device_versions4</name>
          <sourcecode type="xdr"><![CDATA[
   /*
    * ffv2dv_coupling flags -- bitwise-OR of the values below.
    *
    * A zero value (no flags set) indicates the loose coupling
    * synthetic-uid model of RFC 8435: the client presents an
    * anonymous stateid and a synthetic uid issued by the
    * metadata server, and the storage device validates access
    * via that synthetic uid.  The constant
    * FFV2_COUPLING_SYNTHETIC_UIDS is provided as a
    * documentation aid.
    *
    * FFV2_COUPLING_TIGHTLY_COUPLED indicates that the storage
    * device participates in tight coupling with the metadata
    * server via a back-end control protocol between the
    * metadata server and the data servers; the
    * specific mechanism is deployment-configured and outside
    * the scope of this document.
    *
    * FFV2_COUPLING_TRUSTED_STATEID indicates that the storage
    * device implements the TRUST_STATEID, REVOKE_STATEID, and
    * BULK_REVOKE_STATEID operations defined in the Tight
    * Coupling Control Protocol section.
    *
    * The two tight coupling flags are orthogonal: a storage
    * device MAY set either, both, or neither.  See the Tight
    * Coupling Control Protocol section for the semantics of
    * each combination.
    */
   const FFV2_COUPLING_SYNTHETIC_UIDS  = 0x00000000;
   const FFV2_COUPLING_TIGHTLY_COUPLED = 0x00000001;
   const FFV2_COUPLING_TRUSTED_STATEID = 0x00000002;

   struct ffv2_device_versions4 {
           uint32_t        ffv2dv_version;
           uint32_t        ffv2dv_minorversion;
           uint32_t        ffv2dv_rsize;
           uint32_t        ffv2dv_wsize;
           uint32_t        ffv2dv_coupling;
   };
]]></sourcecode>
        </figure>
        <figure anchor="fig-ff_device_addr4">
          <name>ffv2_device_addr4</name>
          <sourcecode type="xdr"><![CDATA[
   struct ffv2_device_addr4 {
           multipath_list4       ffv2da_netaddrs;
           ffv2_device_versions4 ffv2da_versions<>;
   };
]]></sourcecode>
        </figure>
        <t>The ffv2da_netaddrs field is used to locate the storage device.  It
<bcp14>MUST</bcp14> be set by the server to a list holding one or more of the device
network addresses.</t>
        <t>The ffv2da_versions array allows the metadata server to present choices
as to NFS version, minor version, and coupling capabilities to the
client.  The ffv2dv_version and ffv2dv_minorversion represent the NFS
protocol to be used to access the storage device.  This layout
specification defines the semantics for ffv2dv_versions 3 and 4.  If
ffv2dv_version equals 3, then the server <bcp14>MUST</bcp14> set ffv2dv_minorversion to
0 and ffv2dv_coupling to FFV2_COUPLING_SYNTHETIC_UIDS.  The client <bcp14>MUST</bcp14>
then access the storage device using the NFSv3 protocol <xref target="RFC1813"/>.
If ffv2dv_version equals 4, then the server <bcp14>MUST</bcp14> set ffv2dv_minorversion
to 1 or 2, and the client <bcp14>MUST</bcp14> access the storage device using NFSv4
with the specified minor version.</t>
        <t>Three additional constraints narrow the valid set of
(ffv2dv_version, ffv2dv_minorversion, ffv2dv_coupling) tuples
in specific cases:</t>
        <ul spacing="normal">
          <li>
            <t>When a mirror's encoding type uses CHUNK operations (that
is, any FFV2<em>ENCODING</em>* value other than
FFV2_ENCODING_PASSTHROUGH), the corresponding storage device
<bcp14>MUST</bcp14> be advertised with ffv2dv_version = 4 and
ffv2dv_minorversion = 2.  CHUNK operations are NFSv4.2 ops
defined in this document; NFSv3 and NFSv4.1 storage devices
cannot serve a non-PASSTHROUGH mirror.</t>
          </li>
          <li>
            <t>When ffv2dv_coupling has the FFV2_COUPLING_TRUSTED_STATEID
flag set, the storage device <bcp14>MUST</bcp14> be advertised with
ffv2dv_version = 4 and ffv2dv_minorversion = 2.  The
TRUST_STATEID family of operations is defined as NFSv4.2;
NFSv4.1 storage devices cannot participate in
trusted stateid tight coupling.</t>
          </li>
          <li>
            <t>When a mirror's encoding type uses CHUNK operations, the
corresponding storage device <bcp14>MUST</bcp14> be advertised with
ffv2dv_coupling having at least one tight coupling flag set
(FFV2_COUPLING_TIGHTLY_COUPLED or
FFV2_COUPLING_TRUSTED_STATEID, or both).  The chunk
lifecycle depends on the metadata-server-registered layout
stateid and the per-client identity conveyed to the data
server (<xref target="sec-CHUNK_WRITE"/>); a synthetic-uid-only storage
device has neither the trust-table entry required to
validate a presented stateid nor the client-id binding
required to authorize the writer, and therefore cannot
serve a non-PASSTHROUGH mirror.</t>
          </li>
        </ul>
        <t>PASSTHROUGH is the only encoding that admits loose coupling
(FFV2_COUPLING_SYNTHETIC_UIDS); every non-PASSTHROUGH encoding
requires ffv2dv_version = 4, ffv2dv_minorversion = 2, and at
least one tight coupling flag set in ffv2dv_coupling.
PASSTHROUGH itself may be advertised under any of the
following (ffv2dv_version, ffv2dv_minorversion) tuples:
(3, 0), (4, 1), or (4, 2); the first two of these tuples
are valid only for PASSTHROUGH under
FFV2_COUPLING_SYNTHETIC_UIDS, because they precede or lack
the NFSv4.2 features on which the CHUNK operations and the
TRUST_STATEID family depend.</t>
        <t>Note that while the client might determine that it cannot use any of
the configured combinations of ffv2dv_version, ffv2dv_minorversion, and
ffv2dv_coupling, when it gets the device list from the metadata
server, there is no way to indicate to the metadata server as to
which device it is version incompatible.  However, if the client
waits until it retrieves the layout from the metadata server, it can
at that time clearly identify the storage device in question (see
<xref target="sec-version-errors"/>).</t>
        <t>The ffv2dv_rsize and ffv2dv_wsize are used to communicate the maximum
rsize and wsize supported by the storage device.  As the storage
device can have a different rsize or wsize than the metadata server,
the ffv2dv_rsize and ffv2dv_wsize allow the metadata server to
communicate that information on behalf of the storage device.</t>
        <t>ffv2dv_coupling informs the client which tight coupling
capabilities the storage device supports.  The two
tight coupling flags are orthogonal:</t>
        <ul spacing="normal">
          <li>
            <t>FFV2_COUPLING_TIGHTLY_COUPLED asserts that the deployment
has a back-end control protocol between the metadata server
and the data servers (the RFC 8435 general tight coupling
concept); this document does not specify what that protocol
is or how it operates.  A dCache <xref target="DCACHE"/> deployment, for
example, would set this flag based on its own metadata-server
/ pool control plane.</t>
          </li>
          <li>
            <t>FFV2_COUPLING_TRUSTED_STATEID asserts that the storage
device implements the TRUST_STATEID, REVOKE_STATEID, and
BULK_REVOKE_STATEID operations defined in this document
(<xref target="sec-tight-coupling-control"/>).  This is the tight coupling
mechanism this specification adds; a storage
device <bcp14>MUST NOT</bcp14> advertise this flag until the metadata
server has confirmed the capability via the probe in
<xref target="sec-tight-coupling-probe"/>.</t>
          </li>
        </ul>
        <t>A storage device <bcp14>MAY</bcp14> advertise either, both, or neither
flag.  When both are set, the deployment supports two
tight coupling paths concurrently and <bcp14>MAY</bcp14> use either for a
given operation.  When neither is set (ffv2dv_coupling equals
FFV2_COUPLING_SYNTHETIC_UIDS), the storage device is loosely
coupled and the RFC 8435 synthetic-uid model applies (see
<xref target="sec-Fencing-Clients"/>).</t>
        <t>If ffv2dv_coupling has no tight coupling flag set, then the
client <bcp14>MUST</bcp14> commit writes to the storage devices for the file
before sending a
LAYOUTCOMMIT to the metadata server.  That is, the writes <bcp14>MUST</bcp14> be
committed by the client to stable storage via issuing WRITEs with
stable_how = FILE_SYNC or by issuing a COMMIT after WRITEs with
stable_how != FILE_SYNC (see <xref section="3.3.7" sectionFormat="of" target="RFC1813"/>).</t>
      </section>
      <section anchor="storage-device-multipathing">
        <name>Storage Device Multipathing</name>
        <t>The flexible file v2 layout supports multipathing to multiple
storage device addresses.  Storage-device-level multipathing is used
for bandwidth scaling via trunking and for higher availability of use
in the event of a storage device failure.  Multipathing allows the
client to switch to another storage device address that may be that
of another storage device that is exporting the same data stripe
unit, without having to contact the metadata server for a new layout.</t>
        <t>To support storage device multipathing, ffv2da_netaddrs contains an
array of one or more storage device network addresses.  This array
(data type multipath_list4) represents a list of storage devices
(each identified by a network address), with the possibility that
some storage device will appear in the list multiple times.</t>
        <t>The client is free to use any of the network addresses as a
destination to send storage device requests.  If some network
addresses are less desirable paths to the data than others, then the
metadata server <bcp14>SHOULD NOT</bcp14> include those network addresses in
ffv2da_netaddrs.  If less desirable network addresses exist to provide
failover, the <bcp14>RECOMMENDED</bcp14> method to offer the addresses is to provide
them in a replacement device-ID-to-device-address mapping or a
replacement device ID.  When a client finds no response from the
storage device using all addresses available in ffv2da_netaddrs, it
<bcp14>SHOULD</bcp14> send a GETDEVICEINFO to attempt to replace the existing
device-ID-to-device-address mappings.  If the metadata server detects
that all network paths represented by ffv2da_netaddrs are unavailable,
the metadata server <bcp14>SHOULD</bcp14> send a CB_NOTIFY_DEVICEID (if the client
has indicated it wants device ID notifications for changed device
IDs) to change the device-ID-to-device-address mappings to the
available addresses.  If the device ID itself will be replaced, the
metadata server <bcp14>SHOULD</bcp14> recall all layouts with the device ID and thus
force the client to get new layouts and device ID mappings via
LAYOUTGET and GETDEVICEINFO.</t>
        <t>Generally, if two network addresses appear in ffv2da_netaddrs, they
will designate the same storage device.  When the storage device is
accessed over NFSv4.1 or a higher minor version, the two storage
device addresses will support the implementation of client ID or
session trunking (the latter is <bcp14>RECOMMENDED</bcp14>) as defined in <xref target="RFC8881"/>.
The two storage device addresses will share the same server owner or
major ID of the server owner.  It is not always necessary for the two
storage device addresses to designate the same storage device with
trunking being used.  For example, the data could be read-only, and
the data consist of exact replicas.</t>
      </section>
    </section>
    <section anchor="flexible-file-version-2-layout-type">
      <name>Flexible File Version 2 Layout Type</name>
      <t>The original layouttype4 introduced in <xref target="RFC5662"/> is extended as shown in
<xref target="fig-orig-layout"/>.  The layout_content4 and layout4 structures are
reused unchanged from <xref target="RFC5662"/>; the layouttype4 enum is extended
with the new LAYOUT4_FLEX_FILES_V2 value.  The full enum and
surrounding structures below are reproduced for reader
convenience; only the new constant LAYOUT4_FLEX_FILES_V2 is part
of the XDR extracted from this document (see
<xref target="fig-orig-layout-extract"/>).</t>
      <figure anchor="fig-orig-layout">
        <name>The original layout type (illustrative; reused from RFC 5662 with extension)</name>
        <sourcecode type="xdr"><![CDATA[
       enum layouttype4 {
           LAYOUT4_NFSV4_1_FILES   = 1,
           LAYOUT4_OSD2_OBJECTS    = 2,
           LAYOUT4_BLOCK_VOLUME    = 3,
           LAYOUT4_FLEX_FILES      = 4,
           LAYOUT4_SCSI            = 5,
           LAYOUT4_FLEX_FILES_V2   = 6
       };

       struct layout_content4 {
           layouttype4             loc_type;
           opaque                  loc_body<>;
       };

       struct layout4 {
           offset4                 lo_offset;
           length4                 lo_length;
           layoutiomode4           lo_iomode;
           layout_content4         lo_content;
       };
]]></sourcecode>
      </figure>
      <t>The extracted XDR contribution for this extension is the new
layouttype4 constant alone:</t>
      <figure anchor="fig-orig-layout-extract">
        <name>New layouttype4 value (extracted)</name>
        <sourcecode type="xdr"><![CDATA[
   /// const LAYOUT4_FLEX_FILES_V2 = 6;
]]></sourcecode>
      </figure>
      <t>This document defines structures associated with the layouttype4
value LAYOUT4_FLEX_FILES_V2.  <xref target="RFC8881"/> specifies the loc_body structure
as an XDR type "opaque".  The opaque layout is uninterpreted by the
generic pNFS client layers but is interpreted by the flexible file
layout type implementation.  This section defines the structure of
this otherwise opaque value, ffv2_layout4.</t>
      <section anchor="ffv2encodingtype4">
        <name>ffv2_encoding_type4</name>
        <figure anchor="fig-ffv2_encoding_type4">
          <name>The encoding type</name>
          <sourcecode type="xdr"><![CDATA[
   /// enum ffv2_encoding_type4 {
   ///     FFV2_ENCODING_PASSTHROUGH             = 1,
   ///     FFV2_ENCODING_MOJETTE_SYSTEMATIC      = 2,
   ///     FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC  = 3,
   ///     FFV2_ENCODING_RS_VANDERMONDE          = 4,
   ///     FFV2_ENCODING_REPLICATED              = 5,
   ///     FFV2_ENCODING_XOR_PARITY              = 6,
   ///     FFV2_ENCODING_LINUX_MD_RAID           = 7
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_encoding_type4 (see <xref target="fig-ffv2_encoding_type4"/>) encompasses
a new IANA registry for 'Flexible File Version 2 Layout Type Erasure Coding
Type Registry'.  I.e., instead of defining a new Layout Type for
each erasure coding, we define a new Erasure Encoding Type.  The
encoding types this document defines fall into two groups:</t>
        <ul spacing="normal">
          <li>
            <t>FFV2_ENCODING_PASSTHROUGH is the non-chunked, non-integrity
on-ramp from flexible file v1 layout.  It uses NFSv3 WRITE / READ
or NFSv4 READ / WRITE directly against each replica's data server.
No CHUNK_WRITE, no CHUNK_READ, no per-chunk CRC.  See
<xref target="sec-encoding-passthrough"/>.</t>
          </li>
          <li>
            <t>Every other standards-track encoding (any FFV2<em>ENCODING</em>*
value other than FFV2_ENCODING_PASSTHROUGH; see
<xref target="tbl-coding-types"/>) uses the new operations defined here:
in particular CHUNK_WRITE and CHUNK_READ, which carry the per-chunk checksum this
version of the layout type relies on for end-to-end integrity.
The encoding type selects how chunks are produced from
application data; the wire and the storage device are the
same in every case.  See the individual encoding sections
for the mathematical constructions of each encoding and for
the wire-compatibility relationships among the Galois Field
GF(2^8) family.</t>
          </li>
        </ul>
        <t>The 32-bit ffv2_encoding_type4 value space is partitioned by
intended scope -- Standards Track, Experimental, Vendor (open),
and Private / proprietary -- with different allocation policies
per range, so that vendors can assign encoding values without
consuming standards-track codepoints.  See
<xref target="tbl-coding-ranges"/> and the accompanying prose in
<xref target="iana-considerations"/> for the range assignments and allocation
policies.</t>
        <section anchor="sec-heterogeneous-mirrors">
          <name>Heterogeneous Mirror Sets</name>
          <t>A single flexible file v2 layout's <tt>ffv2l_mirrors</tt> array <bcp14>MAY</bcp14> carry mirror
entries of different encoding types.  The protocol does not
require the entries to agree -- one mirror can be
FFV2_ENCODING_PASSTHROUGH, another can be
FFV2_ENCODING_RS_VANDERMONDE, both describing the same file's
data range.  This combination is the structural primitive for
three operations that motivate keeping PASSTHROUGH in the
layout type's vocabulary:</t>
          <dl>
            <dt>Assimilate:</dt>
            <dd>
              <t>A file that exists today as a plain copy on
storage outside flexible file v2 layout -- no chunk envelope, no per-chunk
CRC -- enters the namespace as a PASSTHROUGH mirror against
the source bytes as they are.  The metadata server then
adds one or more encoded mirrors (MIRRORED, RS, Mojette) to
the same layout and synchronizes them from the PASSTHROUGH
source.  Clients can read the file via the PASSTHROUGH
mirror immediately; the encoded mirrors become available as
they are populated.  No "rewrite before serve" step is
required.</t>
            </dd>
            <dt>Copy / migrate between encodings:</dt>
            <dd>
              <t>Changing a file from
one encoding to another is "add a mirror in the target
encoding to the same layout, let it sync from any healthy
source mirror, retire the source mirror."  PASSTHROUGH is
the special case where one endpoint of that migration is
"no encoding."</t>
            </dd>
            <dt>Repair across encodings:</dt>
            <dd>
              <t>When an encoded mirror has a
chunk whose CRC fails and whose parity cannot reconstruct,
a PASSTHROUGH mirror in the same layout is an authoritative
source: CHUNK_READ a peer encoded mirror or read the
PASSTHROUGH byte range, then CHUNK_WRITE the repaired
chunk.  The reverse is also true: a byte range on the
PASSTHROUGH copy whose contents the metadata server suspects
has drifted can be repaired by reconstructing from the
verified-CRC chunks of an encoded peer.  Two encodings of
the same file are two independent recovery paths.</t>
            </dd>
          </dl>
          <t>The metadata server is responsible for keeping the entries in
a heterogeneous mirror set in sync; the protocol does not
require client awareness of which encoding produced which
mirror beyond what the layout already states.</t>
          <t>The wire-level coordination that makes a heterogeneous mirror
set safe to operate -- in particular, the rule that a client
arriving during a transition sees a single layout naming the
proxy server rather than two layouts naming the source and
destination encodings, and the rule that the metadata server's
commit of a transition is a single transaction -- is specified
in the proxy server draft
(<xref target="I-D.haynes-nfsv4-flexfiles-v2-proxy-server"/>), in the
sections "Layout Shape During a Proxy Operation" and "Atomic
commit on PROXY_DONE".  This document specifies the per-mirror
encoding naming primitive; the proxy server document specifies
the transactional machinery that uses it.</t>
          <t>The full description of each encoding type is deferred to its
own section.  The mapping between the enum values above and
those sections is:</t>
          <table anchor="tbl-encoding-type-sections">
            <name>Encoding type value to section mapping</name>
            <thead>
              <tr>
                <th align="right">Value</th>
                <th align="left">Encoding type</th>
                <th align="left">Description</th>
                <th align="left">Section</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="right">1</td>
                <td align="left">FFV2_ENCODING_PASSTHROUGH</td>
                <td align="left">On-ramp from the flexible file v1 layout; direct NFSv3/v4 I/O, no chunk envelope</td>
                <td align="left">
                  <xref target="sec-encoding-passthrough"/></td>
              </tr>
              <tr>
                <td align="right">2</td>
                <td align="left">FFV2_ENCODING_MOJETTE_SYSTEMATIC</td>
                <td align="left">Discrete Radon projections, systematic (data shards passed through)</td>
                <td align="left">
                  <xref target="sec-mojette-encoding"/></td>
              </tr>
              <tr>
                <td align="right">3</td>
                <td align="left">FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC</td>
                <td align="left">Discrete Radon projections, non-systematic (all shards transformed)</td>
                <td align="left">
                  <xref target="sec-mojette-encoding"/></td>
              </tr>
              <tr>
                <td align="right">4</td>
                <td align="left">FFV2_ENCODING_RS_VANDERMONDE</td>
                <td align="left">Reed-Solomon Vandermonde over GF(2^8); arbitrary (k, m)</td>
                <td align="left">
                  <xref target="sec-rs-encoding"/></td>
              </tr>
              <tr>
                <td align="right">5</td>
                <td align="left">FFV2_ENCODING_REPLICATED</td>
                <td align="left">Chunked replication; N-way redundancy at N x storage</td>
                <td align="left">
                  <xref target="sec-encoding-replicated"/></td>
              </tr>
              <tr>
                <td align="right">6</td>
                <td align="left">FFV2_ENCODING_XOR_PARITY</td>
                <td align="left">Single-parity RAID-5 shape; k + 1, m=1, pure XOR</td>
                <td align="left">
                  <xref target="sec-encoding-xor-parity"/></td>
              </tr>
              <tr>
                <td align="right">7</td>
                <td align="left">FFV2_ENCODING_LINUX_MD_RAID</td>
                <td align="left">Linux md/raid6 P + Q double-parity; k + 2, m=2, GF(2^8)</td>
                <td align="left">
                  <xref target="sec-encoding-linux-md-raid"/></td>
              </tr>
            </tbody>
          </table>
        </section>
        <section anchor="encoding-type-interoperability">
          <name>Encoding Type Interoperability</name>
          <t>The data servers do not interpret erasure-coded data -- they store and
return opaque chunks.  The NFS wire protocol likewise does not depend
on the encoding mathematics.  However, a client that writes data using
one encoding type <bcp14>MUST</bcp14> be able to read it back, and a different
client implementation <bcp14>MUST</bcp14> be able to read data written by the first
client if both claim to support the same encoding type.</t>
          <t>This interoperability requirement means that each registered
encoding type <bcp14>MUST</bcp14> fully specify the encoding and decoding
mathematics such that two independent implementations produce
byte-identical encoded output for the same input.  The specification
of a new encoding type <bcp14>MUST</bcp14> include one of the following:</t>
          <ol spacing="normal" type="1"><li>
              <t>A complete mathematical specification of the encoding and decoding
algorithms, including all parameters (e.g., field polynomial,
matrix construction, element size) sufficient for an independent
implementation to produce interoperable results.</t>
            </li>
            <li>
              <t>A reference to a published patent or pending patent application
that contains the algorithm specification.  Implementors can then
evaluate the licensing terms and decide whether to support the
encoding type.</t>
            </li>
            <li>
              <t>A declaration that the encoding type is a proprietary
implementation.  In this case, the encoding type name <bcp14>SHOULD</bcp14>
include an organizational prefix (e.g.,
FFV2_ENCODING_ACME_FOOBAR) to signal that interoperability is
limited to implementations licensed by that organization.</t>
            </li>
          </ol>
          <t>Option 1 is <bcp14>RECOMMENDED</bcp14> for encoding types intended for broad
interoperability.  Options 2 and 3 allow vendors to register encoding
types for use within their own ecosystems while preserving the
encoding type namespace.</t>
          <t>The rationale for this requirement is that erasure coding moves
computation from the server to the client.  If the client cannot
determine how data was encoded, it cannot decode it.  Unlike layout
types (where the server controls the storage format), encoding types
require client-side agreement on the mathematics.</t>
        </section>
      </section>
      <section anchor="sec-ffv2_layout">
        <name>ffv2_layout4</name>
        <section anchor="sec-ffv2_flags4">
          <name>ffv2_flags4</name>
          <figure anchor="fig-ffv2_flags4">
            <name>The ffv2_flags4</name>
            <sourcecode type="xdr"><![CDATA[
   /// const FFV2_FLAGS_NO_LAYOUTCOMMIT  = FF_FLAGS_NO_LAYOUTCOMMIT;
   /// const FFV2_FLAGS_NO_IO_THRU_MDS   = FF_FLAGS_NO_IO_THRU_MDS;
   /// const FFV2_FLAGS_NO_READ_IO       = FF_FLAGS_NO_READ_IO;
   /// const FFV2_FLAGS_WRITE_ONE_MIRROR =
   ///     FF_FLAGS_WRITE_ONE_MIRROR;
   /// const FFV2_FLAGS_ONLY_ONE_WRITER  = 0x00000010;
   ///
   /// typedef uint32_t            ffv2_flags4;
]]></sourcecode>
          </figure>
          <t>The ffv2_flags4 in <xref target="fig-ffv2_flags4"/>  is a bitmap that allows the
metadata server to inform the client of particular conditions that
may result from more or less tight coupling of the storage devices.</t>
          <t>Each flag below describes both the semantics when set and the
normative requirement it places on the client.  When a flag is
not set, the client <bcp14>MUST</bcp14> follow the default behavior described
for its unset state.</t>
          <dl>
            <dt>FFV2_FLAGS_NO_LAYOUTCOMMIT:</dt>
            <dd>
              <t>When set, the client <bcp14>MAY</bcp14> omit the LAYOUTCOMMIT to the
metadata server.  When unset, the client <bcp14>MUST</bcp14> send LAYOUTCOMMIT
per <xref section="18.42." sectionFormat="of" target="RFC8881"/></t>
            </dd>
            <dt>FFV2_FLAGS_NO_IO_THRU_MDS:</dt>
            <dd>
              <t>When set, the client <bcp14>MUST NOT</bcp14> proxy I/O operations through
the metadata server, even after detecting a network disconnect
to a storage device.  When unset, the client <bcp14>MAY</bcp14> retry failed
I/O via the metadata server.</t>
            </dd>
            <dt>FFV2_FLAGS_NO_READ_IO:</dt>
            <dd>
              <t>When set, the client <bcp14>MUST NOT</bcp14> issue READ against layouts of
iomode LAYOUTIOMODE4_RW, and <bcp14>MUST</bcp14> instead request a separate
layout of iomode LAYOUTIOMODE4_READ for any read I/O.  When
unset, the client <bcp14>MAY</bcp14> issue READ against either iomode.</t>
            </dd>
            <dt>FFV2_FLAGS_WRITE_ONE_MIRROR:</dt>
            <dd>
              <t>When set, the client <bcp14>MAY</bcp14> update only one mirror of each
layout segment (see <xref target="sec-CSM"/>) and rely on the metadata server
(or a proxy server acting on its behalf) or a peer data server
to propagate the update to the remaining mirrors.  When unset,
the client <bcp14>MUST</bcp14> update all mirrors.</t>
              <t>The metadata server <bcp14>MUST NOT</bcp14> set FFV2_FLAGS_WRITE_ONE_MIRROR
on a layout whose ffv2l_mirrors carry more than one distinct
ffv2m_encoding_type_data value unless a propagation actor is
available that speaks every encoding present in the layout.
Cross-encoding propagation requires the actor to decode
through the source mirror's encoding transform and re-encode
for each target mirror's transform, which the metadata server
itself cannot do for chunked encodings (it does not hold the
encoded shards); a proxy server is the entity that performs
cross-encoding translation.  On a
mixed-encoding layout without a proxy server for the affected
file, the metadata server <bcp14>MUST</bcp14> leave
FFV2_FLAGS_WRITE_ONE_MIRROR unset and require the client to
update all mirrors directly.</t>
            </dd>
            <dt>FFV2_FLAGS_ONLY_ONE_WRITER:</dt>
            <dd>
              <t>When set, the client is the exclusive writer for the layout
and <bcp14>MAY</bcp14> issue CHUNK_WRITE without setting cwa_guard, retaining
the ability to use CHUNK_ROLLBACK in the event of a write hole
caused by overwriting.  When unset, the client <bcp14>MUST</bcp14> set
cwa_guard on every CHUNK_WRITE so that chunk_guard4 CAS can
prevent collisions across concurrent writers.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="ffv2fileinfo4">
        <name>ffv2_file_info4</name>
        <figure anchor="fig-ffv2_file_info4">
          <name>The ffv2_file_info4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_file_info4 {
   ///     stateid4                ffv2fi_stateid;
   ///     nfs_fh4                 ffv2fi_fh_vers;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_file_info4 is a new structure that resolves the
stateid-vs-fh_vers pairing issue discussed in <xref section="5.1" sectionFormat="of" target="RFC8435"/>.  In <xref target="RFC8435"/>'s flexible file v1 layout, a singleton
ffv2ds_stateid was paired with an ffv2ds_fh_vers array, forcing every
fh_vers on a data server to share one stateid.  In
<xref target="fig-ffv2_file_info4"/> each fh_vers has its own stateid alongside it.</t>
        <t>The stateid value ffv2fi_stateid <bcp14>MUST</bcp14> carry depends on the
coupling mode advertised for the corresponding
(ffv2dv_version, ffv2dv_minorversion, ffv2dv_coupling) tuple
(see <xref target="sec-ff_device_addr4"/>):</t>
        <ul spacing="normal">
          <li>
            <t>If ffv2dv_coupling for this entry equals
FFV2_COUPLING_SYNTHETIC_UIDS (loose coupling), ffv2fi_stateid
<bcp14>MUST</bcp14> be the anonymous stateid; the client authenticates to
the data server via the synthetic ffv2ds_user / ffv2ds_group
(<xref target="sec-Fencing-Clients"/>) rather than by presenting a
meaningful stateid.</t>
          </li>
          <li>
            <t>If ffv2dv_coupling for this entry has the
FFV2_COUPLING_TRUSTED_STATEID flag set, ffv2fi_stateid <bcp14>MUST</bcp14>
be the layout stateid the metadata server issued in the
LAYOUTGET that produced this layout.  The data server
validates presented stateids against its per-file trust
table populated by TRUST_STATEID
(<xref target="sec-tight-coupling-control"/>).</t>
          </li>
          <li>
            <t>If ffv2dv_coupling for this entry has only
FFV2_COUPLING_TIGHTLY_COUPLED set (a back-end control
protocol other than trusted stateid, with no TRUST_STATEID
support advertised), ffv2fi_stateid carries whatever
stateid the deployment's back-end control protocol expects
the client to present; this document does not further
specify that value.</t>
          </li>
        </ul>
        <t>Because ffv2ds_file_info&lt;&gt; has one element per
(version, minorversion, coupling) tuple advertised on the
data server (parallel to ffv2da_versions&lt;&gt;), a single data
server that exposes both loose and tight combinations
carries multiple ffv2_file_info4 entries with different
stateid values.  The client selects one tuple to use for
I/O; it presents that tuple's stateid on subsequent CHUNK
operations.</t>
      </section>
      <section anchor="sec-ffv2_ds_flags4">
        <name>ffv2_ds_flags4</name>
        <figure anchor="fig-ffv2_ds_flags4">
          <name>The ffv2_ds_flags4</name>
          <sourcecode type="xdr"><![CDATA[
   /// const FFV2_DS_FLAGS_ACTIVE        = 0x00000001;
   /// const FFV2_DS_FLAGS_PARITY        = 0x00000004;
   /// const FFV2_DS_FLAGS_REPAIR        = 0x00000008;
   /// const FFV2_DS_FLAGS_PROXY         = 0x00000010;
   /// typedef uint32_t            ffv2_ds_flags4;
]]></sourcecode>
        </figure>
        <t>The ffv2_ds_flags4 (in <xref target="fig-ffv2_ds_flags4"/>) flags detail the
state of the data servers.  With erasure coding algorithms,
there are both Systematic and Non-Systematic approaches.  In
the Systematic approach, the bits for integrity are placed
amongst the resulting transformed chunk.  Such an
implementation would typically see FFV2_DS_FLAGS_ACTIVE data
servers with FFV2_DS_FLAGS_REPAIR entries added by the
metadata server when a failed ACTIVE has been replaced.</t>
        <t>With the Non-Systematic approach, the data and integrity live
on different data servers.  Such an implementation would
typically see FFV2_DS_FLAGS_ACTIVE and FFV2_DS_FLAGS_PARITY
data servers, again with FFV2_DS_FLAGS_REPAIR entries appearing
as needed.</t>
        <t>The FFV2_DS_FLAGS_REPAIR flag informs the client that the
indicated data server is a replacement for a previously failed
ACTIVE data server, whose content has been (or is being)
reconstructed from the surviving shards of the mirror set.
Its payload was placed there by a repair actor executing the
flow in <xref target="sec-repair-selection"/> rather than directly by the
original writer.  The flag is the client's indication that
reads from this data server return erasure-decoded content
rather than content produced by the original write.</t>
        <t>Clients that rely on write-provenance information (for example,
deployments that track which client wrote which generation)
<bcp14>SHOULD</bcp14> be aware of the REPAIR flag so they do not treat the
reconstructed payload as if it had been written directly by the
cg_client_id recorded in the chunk_guard4; the guard values
still match across the mirror set by construction, but the
physical write path differs.</t>
        <t>Over the lifetime of a file, a single data server <bcp14>MAY</bcp14> transition
ACTIVE -&gt; REPAIR (on replacement) or REPAIR -&gt; ACTIVE (once the
metadata server has accepted the reconstructed content as
authoritative and the fail-over is complete); the metadata
server reflects the current flag set in the next layout it
returns.</t>
        <t>The following paragraphs describe the mechanics of these
transitions.  The client is not the driver in either
direction; both are metadata-server-initiated changes that a
client observes only by refreshing its layout.</t>
        <dl>
          <dt>ACTIVE -&gt; REPAIR:</dt>
          <dd>
            <t>Triggered when a client (or the metadata server itself,
via scrub) reports a failure via LAYOUTERROR against a
particular shard.  The metadata server picks a target for
the reconstructed content -- either an existing
FFV2_DS_FLAGS_REPAIR-flagged entry already in the layout,
or a fresh data server drawn from an out-of-band
deployment pool that the metadata server adds to the
layout with FFV2_DS_FLAGS_REPAIR set -- and initiates the
client-driven repair flow at <xref target="sec-repair-selection"/>.
Once the reconstructed shard is written and the
metadata server has accepted it (via CHUNK_REPAIRED),
the metadata server updates the affected layout to
remove the failed entry and mark the target entry as
FFV2_DS_FLAGS_REPAIR.  The metadata server <bcp14>SHOULD</bcp14> then
issue CB_LAYOUTRECALL against any client that holds an
outstanding layout for the affected file, so those
clients refresh via a subsequent LAYOUTGET and observe
the updated flag set.  Clients that never issued
LAYOUTGET during the incident window observe the new
layout on first fetch.</t>
          </dd>
          <dt>REPAIR -&gt; ACTIVE:</dt>
          <dd>
            <t>Triggered when the metadata server confirms the
reconstructed content has been durably committed and
the replaced data server is not returning.  This is a
metadata-server-internal state change; no client-visible
operations are required for the transition itself.  The
flag update is reflected in the next layout the metadata
server hands out (either the layout returned to the next
LAYOUTGET, or the layout delivered after a CB_LAYOUTRECALL
that the metadata server <bcp14>MAY</bcp14> issue to accelerate the
transition).</t>
          </dd>
        </dl>
        <t>Both transitions preserve the mirror set's array indexing:
the shard formerly held by the failed entry lives at the
same array position in the layout, under the REPAIR-flagged
entry.  A client reads by array position; the flag informs
the client of the read's provenance (originally written vs
reconstructed) but does not change the shard-index
addressing.  A client <bcp14>MUST NOT</bcp14> infer that a REPAIR-flagged
entry serves a different shard than the ACTIVE entry it
replaced.</t>
        <t>If the same payload identifier appears at the same shard
position across an ACTIVE entry (about to be retired) and a
REPAIR entry (being promoted) during a transition window,
the two entries are guaranteed to carry identical chunk
contents (the reconstructed content matches the original by
the erasure-coding correctness invariant, and the checksum
verifies).  There is no client-driven failover to a passive
data server; a client that observes a CHUNK_WRITE failure
against an ACTIVE <bcp14>MUST</bcp14> report the failure via LAYOUTERROR
and rely on the metadata-server-initiated repair flow above
to promote a replacement.</t>
        <t>The FFV2_DS_FLAGS_PROXY flag identifies a data-server entry
that names a proxy server rather than a real storage device.
A client whose local encoding capabilities cannot cover the
file's mirror set receives a layout in which one or more
mirror entries have FFV2_DS_FLAGS_PROXY set on their
ffv2_data_server4; the client directs I/O for that mirror
to the proxy, which translates on behalf of the client.  The
proxy server protocol itself is specified in the proxy server
draft; this document defines only the layout flag (this bit)
that lets the metadata server mark a data-server entry as
proxy-mediated.</t>
      </section>
      <section anchor="ffv2dataserver4">
        <name>ffv2_data_server4</name>
        <figure anchor="fig-ffv2_data_server4">
          <name>The ffv2_data_server4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_data_server4 {
   ///     deviceid4               ffv2ds_deviceid;
   ///     uint32_t                ffv2ds_efficiency;
   ///     ffv2_file_info4         ffv2ds_file_info<>;
   ///     fattr4_owner            ffv2ds_user;
   ///     fattr4_owner_group      ffv2ds_group;
   ///     ffv2_ds_flags4          ffv2ds_flags;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_data_server4 (in <xref target="fig-ffv2_data_server4"/>) describes a data
file and how to access it via the different NFS protocols.</t>
        <ul spacing="normal">
          <li>
            <t>ffv2ds_deviceid names the data server; see the flexible
file v1 layout (<xref target="RFC8435"/>) for the deviceid model this
layout inherits.</t>
          </li>
          <li>
            <t>ffv2ds_efficiency is the metadata-server-assigned mirror
ranking used for read-mirror selection
(<xref target="sec-select-mirror"/>).</t>
          </li>
          <li>
            <t>ffv2ds_file_info&lt;&gt; pairs a filehandle and a stateid for
each (version, minorversion, coupling) tuple the layout
advertises on this data server (see <xref target="sec-ff_device_addr4"/>
and the discussion at ffv2_file_info4 above for the
stateid-value rules per coupling mode).</t>
          </li>
          <li>
            <t>ffv2ds_user and ffv2ds_group are the synthetic uid/gid the
client presents in the RPC credentials to the data server
under loose coupling (see <xref target="sec-Fencing-Clients"/>).  They
are present in every ffv2_data_server4 regardless of the
coupling advertised on this data server, because the
underlying file on the data server has a single uid/gid
irrespective of which NFS protocol combination the client
uses to reach it.  If ffv2dv_coupling for the tuple the
client selects has any tight coupling flag set
(FFV2_COUPLING_TIGHTLY_COUPLED or
FFV2_COUPLING_TRUSTED_STATEID), the client <bcp14>MUST</bcp14> ignore
ffv2ds_user and ffv2ds_group; the data server authorizes
the write via the trusted stateid table or the back-end
control protocol instead of via the synthetic uid.  If the
client selects a tuple with ffv2dv_coupling =
FFV2_COUPLING_SYNTHETIC_UIDS, the client <bcp14>MUST</bcp14> present
ffv2ds_user and ffv2ds_group in the RPC credentials.</t>
          </li>
          <li>
            <t>ffv2ds_flags carries the ffv2_ds_flags4 state (ACTIVE,
PARITY, REPAIR, PROXY; see <xref target="sec-ffv2_ds_flags4"/>).</t>
          </li>
        </ul>
      </section>
      <section anchor="ffv2dataprotection4">
        <name>ffv2_data_protection4</name>
        <figure anchor="fig-ffv2_data_protection4">
          <name>The ffv2_data_protection4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_data_protection4 {
   ///     uint32_t ffv2dp_data;    /* data shards (k) */
   ///     uint32_t ffv2dp_parity;  /* parity shards (m) */
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_data_protection4 (in <xref target="fig-ffv2_data_protection4"/>) describes
the data protection geometry as a pair of counts: the number of data
shards (ffv2dp_data, also known as k) and the number of parity or
redundancy shards (ffv2dp_parity, also known as m).  This structure is
used in both layout hints and layout responses, and applies
uniformly to all encoding types:</t>
        <table anchor="fig-protection-examples">
          <name>Example data protection configurations</name>
          <thead>
            <tr>
              <th align="left">Protection Mode</th>
              <th align="left">ffv2dp_data</th>
              <th align="left">ffv2dp_parity</th>
              <th align="left">Total Data Servers</th>
              <th align="left">Description</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">Mirroring (3-way)</td>
              <td align="left">1</td>
              <td align="left">2</td>
              <td align="left">3</td>
              <td align="left">3 copies, no encoding</td>
            </tr>
            <tr>
              <td align="left">Striping (6-way)</td>
              <td align="left">6</td>
              <td align="left">0</td>
              <td align="left">6</td>
              <td align="left">Parallel I/O, no redundancy</td>
            </tr>
            <tr>
              <td align="left">RS Vandermonde 4+2</td>
              <td align="left">4</td>
              <td align="left">2</td>
              <td align="left">6</td>
              <td align="left">Tolerates 2 data-server failures</td>
            </tr>
            <tr>
              <td align="left">Mojette-sys 8+2</td>
              <td align="left">8</td>
              <td align="left">2</td>
              <td align="left">10</td>
              <td align="left">Tolerates 2 data-server failures</td>
            </tr>
          </tbody>
        </table>
        <t>By expressing all protection modes as (ffv2dp_data, ffv2dp_parity) pairs,
a single structure serves mirroring, striping, and all erasure
encoding types.  The encoding type (<xref target="fig-ffv2_encoding_type4"/>) determines
how the shards are encoded; the protection structure determines
how many shards there are.</t>
        <t>The total number of data servers required is ffv2dp_data + ffv2dp_parity.
The storage overhead is ffv2dp_parity / ffv2dp_data (e.g., 50% for 4+2,
25% for 8+2).</t>
      </section>
      <section anchor="ffv2encodingtypedata4">
        <name>ffv2_encoding_type_data4</name>
        <figure anchor="fig-ffv2_coding_type_data4">
          <name>The ffv2_encoding_type_data4</name>
          <sourcecode type="xdr"><![CDATA[
   /// union ffv2_encoding_type_data4 switch
   ///         (ffv2_encoding_type4 ffv2etd_encoding) {
   ///     case FFV2_ENCODING_PASSTHROUGH:
   ///         ffv2_data_protection4   ffv2etd_protection;
   ///     case FFV2_ENCODING_REPLICATED:
   ///         ffv2_data_protection4   ffv2etd_protection;
   ///     default:
   ///         ffv2_data_protection4   ffv2etd_protection;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_encoding_type_data4 (in <xref target="fig-ffv2_coding_type_data4"/>)
describes the data protection geometry for the layout.  All
encoding types carry an ffv2_data_protection4
(<xref target="fig-ffv2_data_protection4"/>) specifying the number of data and
parity shards.  The encoding type enum determines how the shards
are encoded; the protection structure determines how many shards
there are.</t>
        <t>Although every arm of the union currently carries the same
type, the union form is intentional.  Future revisions of this
specification may assign distinct arm types to specific coding
types; using a union now avoids an incompatible change to the
XDR at that time.</t>
        <t>The (data, parity) tuple is interpreted per encoding type:</t>
        <ul spacing="normal">
          <li>
            <t>FFV2_ENCODING_PASSTHROUGH preserves the flexible file v1 layout-style notation
for backward compatibility: ffv2dp_data is 1 and ffv2dp_parity is
the number of additional copies (e.g., ffv2dp_parity=2 for
3-way mirroring).  The "1" data carrier is the file as
stored; the ffv2dp_parity additional copies are the flexible file v1 layout
mirror replicas.</t>
          </li>
          <li>
            <t>FFV2_ENCODING_REPLICATED uses the N + 0 notation: ffv2dp_data is
the number of replicas (e.g., ffv2dp_data=3 for 3-way
mirroring) and ffv2dp_parity <bcp14>MUST</bcp14> be 0.  Every replica is a
full, independent data carrier; mirroring carries no
parity reconstruction.</t>
          </li>
          <li>
            <t>Erasure encoding types (FFV2_ENCODING_RS_VANDERMONDE,
FFV2_ENCODING_MOJETTE_SYSTEMATIC,
FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC, and any future types
subsequently registered in the IANA registry established by
this document) use ffv2dp_data &gt;= 2 and ffv2dp_parity &gt;= 1.</t>
          </li>
        </ul>
      </section>
      <section anchor="ffv2stripes4">
        <name>ffv2_stripes4</name>
        <figure anchor="fig-ffv2_stripes4">
          <name>The ffv2_stripes4 structure</name>
          <sourcecode type="xdr"><![CDATA[
   /// enum ffv2_striping4 {
   ///     FFV2_STRIPING_NONE = 0,
   ///     FFV2_STRIPING_SPARSE = 1,
   ///     FFV2_STRIPING_DENSE = 2
   /// };
   ///
   /// struct ffv2_stripes4 {
   ///         ffv2_data_server4       ffv2s_data_servers<>;
   /// };
]]></sourcecode>
        </figure>
        <t>Each stripe contains a set of data servers in ffv2s_data_servers.
If the stripe is part of a ffv2_encoding_type_data4 of
FFV2_ENCODING_PASSTHROUGH or FFV2_ENCODING_REPLICATED, then the
length of ffv2s_data_servers <bcp14>MUST</bcp14> be 1: under both encoding
types each stripe's data lives on a single data server, with
replica multiplicity expressed in ffv2l_mirrors rather than in
ffv2s_data_servers.</t>
        <t>ffv2_stripes4 has no direct counterpart in <xref target="RFC8435"/>.  In
the flexible file v1 layout, a mirror's data servers are
listed directly on the mirror (via ffm_data_servers&lt;&gt; on
ff_mirror4).  The flexible file v2 layout introduces this
intermediate stripes level so a single mirror <bcp14>MAY</bcp14> carry
multiple stripe groups, and pushes the striping-mode metadata
(ffv2m_striping, ffv2m_striping_unit_size) down onto the mirror
(see <xref target="sec-ffv2-mirror4"/>) rather than onto the layout as
<xref target="RFC8435"/> does with the layout-level ffl_stripe_unit.  The
ffv2_striping4 enum (FFV2_STRIPING_NONE / _SPARSE / _DENSE)
inherits its meaning from <xref section="13.3" sectionFormat="of" target="RFC8881"/> and
<xref section="5.1" sectionFormat="of" target="RFC8435"/>; the flexible file v2 layout
evolution is that the striping mode is a per-mirror decision
rather than a per-layout one.</t>
      </section>
      <section anchor="sec-ffv2-mirror4">
        <name>ffv2_mirror4</name>
        <figure anchor="fig-ffv2_mirror4">
          <name>The ffv2_mirror4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_mirror4 {
   ///         ffv2_encoding_type_data4  ffv2m_encoding_type_data;
   ///         ffv2_striping4            ffv2m_striping;
   ///         uint32_t                  ffv2m_striping_unit_size;
   ///         uint32_t                  ffv2m_client_id;
   ///         checksum_algorithm4       ffv2m_checksum_algorithm;
   ///         ffv2_stripes4             ffv2m_stripes<>;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_mirror4 (in <xref target="fig-ffv2_mirror4"/>) is the flexible
file v2 layout counterpart to ff_mirror4 in <xref target="RFC8435"/>.  The
flexible file v2 layout is a semantic superset of the flexible
file v1 layout: any ff_mirror4 can be re-expressed as an
ffv2_mirror4 by setting
ffv2m_encoding_type_data = FFV2_ENCODING_PASSTHROUGH,
ffv2m_striping and ffv2m_striping_unit_size to the flexible
file v1 layout's layout-level values, ffv2m_checksum_algorithm
to CHECKSUM_ALG_NONE, and wrapping the flexible file v1
layout's ffm_data_servers&lt;&gt; in a single-element
ffv2m_stripes&lt;&gt;.  The reverse does not hold: ffv2_mirror4
instances whose ffv2m_encoding_type_data is anything other than
FFV2_ENCODING_PASSTHROUGH have no ff_mirror4 representation.</t>
        <t>Relative to ff_mirror4, ffv2_mirror4 adds the following
per-mirror fields:</t>
        <ul spacing="normal">
          <li>
            <t>ffv2m_encoding_type_data: per-mirror encoding type choice
(see <xref target="fig-ffv2_encoding_type4"/>).  This enables a single
layout to carry mirrors under different encodings
(e.g., a PASSTHROUGH mirror alongside a Reed-Solomon
mirror over the same file; see <xref target="fig-example_mixing"/>) --
the transition-window and per-mirror-optimization patterns
that motivated the flexible file v2 layout.</t>
          </li>
          <li>
            <t>ffv2m_striping and ffv2m_striping_unit_size: pull the
striping-mode decision from the layout level down to the
mirror level.  The flexible file v1 layout's
ffl_stripe_unit is layout-wide; in the flexible file v2
layout different mirrors of the same file <bcp14>MAY</bcp14> use different
striping configurations.</t>
          </li>
          <li>
            <t>ffv2m_client_id: writer identity for chunk_guard4 CAS (see
<xref target="sec-chunk_guard4"/>).  No flexible file v1 layout
counterpart; introduced for the CHUNK operation set that
the flexible file v2 layout adds.</t>
          </li>
          <li>
            <t>ffv2m_checksum_algorithm: per-mirror integrity-checksum
algorithm.  No flexible file v1 layout counterpart;
introduced for the per-chunk checksum integrity the
flexible file v2 layout adds.</t>
          </li>
          <li>
            <t>ffv2m_stripes&lt;&gt;: replaces the flexible file v1 layout's
flat ffm_data_servers&lt;&gt;
with an array of ffv2_stripes4 (see <xref target="fig-ffv2_stripes4"/>),
allowing a single mirror to carry multiple stripe groups.</t>
          </li>
        </ul>
        <t>The ffv2m_checksum_algorithm field names the checksum
algorithm the client <bcp14>MUST</bcp14> use when computing
cwa_checksums on CHUNK_WRITE and cwra_checksums on
CHUNK_WRITE_REPAIR, and the algorithm the client <bcp14>MUST</bcp14>
expect in cr_checksum on CHUNK_READ responses, for chunks
in this mirror.  The metadata server picks the algorithm
at LAYOUTGET time; the value is one of the registered
checksum_algorithm4 codes (see <xref target="sec-checksum4"/>).
Different mirrors of the same file <bcp14>MAY</bcp14> name different
checksum algorithms, supporting transition cases where one
mirror is being migrated to a stronger algorithm while
others retain the previous algorithm.</t>
        <t>A client that does not implement the algorithm named in
ffv2m_checksum_algorithm <bcp14>MUST</bcp14> return the layout with
NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED; the metadata
server may then issue a new layout naming a different
algorithm the client supports, or deny the layout request.</t>
        <t>The ffv2m_client_id is a 32-bit value, assigned by the metadata
server at layout-grant time, that the client <bcp14>MUST</bcp14> use as the
cg_client_id field of chunk_guard4 (see <xref target="sec-chunk_guard4"/>) in
every CHUNK_WRITE it issues against the mirror's data servers.
Its purpose is to satisfy the 32-bit-per-field budget of
chunk_guard4 while preserving the guarantee that concurrent
writers on the same file are distinguishable:</t>
        <ul spacing="normal">
          <li>
            <t>The NFSv4 clientid4 (<xref target="RFC8881"/>) is a 64-bit identifier;
<xref target="RFC8881"/> does not constrain how a server populates its
bits, and the bit-layout choices made by any particular
metadata server implementation are not visible to the
client and <bcp14>MUST NOT</bcp14> be assumed by the client.  Folding
clientid4 to 32 bits locally at the client therefore risks
colliding with another client's folded value, which would
violate the uniqueness contract on chunk_guard4.</t>
          </li>
          <li>
            <t>Only the metadata server has the information needed to avoid
such collisions: it sees every layout it grants on a file and
can assign a dense 32-bit ffv2m_client_id that is guaranteed
distinct from the ffv2m_client_ids assigned to other clients
holding concurrent write layouts on the same file.  The
metadata server <bcp14>MUST</bcp14> assign ffv2m_client_id subject to this
uniqueness rule.</t>
          </li>
          <li>
            <t>Because cg_client_id participates in the deterministic
tiebreaker for racing writers (see <xref target="sec-chunk_guard4"/>),
having the metadata server assign it also lets the metadata
server influence which client wins contention by choosing
the numeric ordering of the values it hands out.  Specific
ordering policies are implementation-defined and out of
scope for this document, but the protocol mechanism is
present.</t>
          </li>
        </ul>
        <t>An ffv2m_client_id is scoped to the file and layout for which it
was granted.  A client that holds layouts on two different files
may receive two different ffv2m_client_ids from the same metadata
server, and a client that relinquishes and later re-acquires a
layout on a given file <bcp14>MAY</bcp14> be assigned a different ffv2m_client_id.
ffv2m_client_id does NOT survive a metadata server restart: the
metadata server reassigns values as clients reclaim layouts
during the grace period.</t>
        <t>The ffv2m_encoding_type_data is which encoding type is used
by the mirror.</t>
        <t>The ffv2m_striping selects the striping method used by the
mirror.  The three permissible values are FFV2_STRIPING_NONE
(the mirror is not striped), FFV2_STRIPING_SPARSE (stripe units
are mapped to the same physical offset on every data server,
leaving holes), and FFV2_STRIPING_DENSE (stripe units are
packed contiguously on each data server without holes).  See
<xref target="sec-striping"/> for the mapping math for each option.</t>
        <t>The ffv2m_striping_unit_size is the stripe unit size used
by the mirror.  The minimum stripe unit size is 64 bytes.  If
the value of ffv2m_striping is FFV2_STRIPING_NONE, then the value
of ffv2m_striping_unit_size <bcp14>MUST</bcp14> be 1.</t>
        <t>The ffv2m_stripes is the array of stripes for the mirror; the
length of the array is the stripe count.  If there is no
striping or the ffv2m_encoding_type_data is FFV2_ENCODING_PASSTHROUGH,
then the length of ffv2m_stripes <bcp14>MUST</bcp14> be 1.  Under
FFV2_ENCODING_REPLICATED the file <bcp14>MAY</bcp14> be striped within each
replica; the constraint that ffv2s_data_servers length is 1
still applies, but ffv2m_stripes can carry multiple stripes.</t>
      </section>
      <section anchor="ffv2layout4">
        <name>ffv2_layout4</name>
        <figure anchor="fig-ffv2_layout4">
          <name>The ffv2_layout4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_layout4 {
   ///     ffv2_mirror4            ffv2l_mirrors<>;
   ///     ffv2_flags4             ffv2l_flags;
   ///     uint32_t                ffv2l_stats_collect_hint;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_layout4 (in <xref target="fig-ffv2_layout4"/>) describes the Flexible
File Layout Version 2.</t>
        <t>The ffv2l_mirrors field is the array of mirrored storage devices that
provide the storage for the current stripe; see <xref target="fig-parallel-filesystem"/>.</t>
        <t>The ffv2l_stats_collect_hint field provides a hint to the client on
how often the server wants it to report LAYOUTSTATS for a file.
The time is in seconds.</t>
        <figure anchor="fig-parallel-filesystem">
          <name>The Relationship between Metadata Server and Data Servers</name>
          <artwork><![CDATA[
                +-----------+
                |           |
                |           |
                |   File    |
                |           |
                |           |
                +-----+-----+
                      |
     +-------------+-----+----------------+
     |                   |                |
+----+-----+       +-----+----+       +---+----------+
| Mirror 1 |       | Mirror 2 |       | Mirror 3     |
| MIRRORED |       | MIRRORED |       | REED_SOLOMON |
+----+-----+       +-----+----+       +---+----------+
     |                   |                |
     |                   |                |
+-----------+      +-----------+      +-----------+
|+-----------+     | Stripe 1  |      |+-----------+
+| Stripe N  |     +-----------+      +| Stripe N  |
 +-----------+           |             +-----------+
     |                   |                |
     |                   |                |
+-----------+      +-----------+      +-----------+
| Storage   |      | Storage   |      |+-----------+
| Device    |      | Device    |      ||+-----------+
+-----------+      +-----------+      +||  Storage  |
                                       +|  Devices  |
                                        +-----------+
]]></artwork>
        </figure>
        <t>As shown in <xref target="fig-parallel-filesystem"/> if the ffv2m_encoding_type_data
is FFV2_ENCODING_PASSTHROUGH or FFV2_ENCODING_REPLICATED, then each
of the stripes <bcp14>MUST</bcp14> only have 1 storage device.  I.e., the length
of ffv2s_data_servers <bcp14>MUST</bcp14> be 1.  The erasure-coding encoding types
distribute shards across multiple storage devices and so carry
multiple entries in ffv2s_data_servers.</t>
        <t>The abstraction here is that for FFV2_ENCODING_PASSTHROUGH and
FFV2_ENCODING_REPLICATED, each stripe describes exactly one data
server.  And for the erasure-coded encoding types, each of the
stripes describes a set of data servers to which the shards are
distributed.  Further, the payload length can be different per
stripe.</t>
      </section>
      <section anchor="sec-ffv2-layouthint">
        <name>ffv2_layouthint4</name>
        <figure anchor="fig-ffv2_layouthint4">
          <name>The ffv2_layouthint4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_layouthint4 {
   ///     ffv2_encoding_type4       ffv2lh_supported_types<>;
   ///     ffv2_data_protection4   ffv2lh_preferred_protection;
   ///     uint32_t                ffv2lh_stripe_unit;
   ///     uint64_t                ffv2lh_expected_file_size;
   /// };
]]></sourcecode>
        </figure>
        <t>The ffv2_layouthint4 (in <xref target="fig-ffv2_layouthint4"/>) describes the
layout_hint (see <xref section="5.12.4" sectionFormat="of" target="RFC8881"/>) that the client can
provide to the metadata server.</t>
        <t>The client provides four hints.  All four are advisory; the
metadata server <bcp14>MAY</bcp14> honor any subset and <bcp14>MAY</bcp14> override any of
them per administrative policy.</t>
        <dl>
          <dt>ffv2lh_supported_types</dt>
          <dd>
            <t>An ordered list of encoding types the client supports,
with the most preferred type first.  The server <bcp14>SHOULD</bcp14> select a type
from this list but <bcp14>MAY</bcp14> choose any type it supports.  If the server
does not support any of the listed types, it returns
NFS4ERR_ENCODING_NOT_SUPPORTED, and the client can retry
with a different list to discover the overlapping set.</t>
          </dd>
          <dt>ffv2lh_preferred_protection</dt>
          <dd>
            <t>The client's preferred data protection geometry as a
(ffv2dp_data, ffv2dp_parity) pair.  The server <bcp14>SHOULD</bcp14> honor this hint but
<bcp14>MAY</bcp14> override it based on server-side policy.  A server that manages
data protection via administrative policy (e.g., per-directory or
per-export objectives) will typically ignore this hint and return the
geometry dictated by policy.</t>
          </dd>
          <dt>ffv2lh_stripe_unit</dt>
          <dd>
            <t>The client's preferred stripe unit size in bytes.  A value of
zero means "no hint" -- the metadata server selects a stripe unit
from policy or from file history.  When the value is non-zero,
the metadata server <bcp14>SHOULD</bcp14> use it as the per-mirror stripe unit
when policy permits.  The metadata server <bcp14>MAY</bcp14> round to a
server-supported alignment.  The metadata server <bcp14>MAY</bcp14> return
NFS4ERR_INVAL when a non-zero value is below an
implementation-defined floor or above an implementation-defined
ceiling.  The hint <bcp14>SHOULD</bcp14> be a power of two.</t>
          </dd>
          <dt>ffv2lh_expected_file_size</dt>
          <dd>
            <t>The client's hint at the file's eventual size in bytes.  A
value of zero means "no hint."  When the value is non-zero, the
metadata server <bcp14>MAY</bcp14> use it to decide whether to issue a striped
layout (typically for files large enough that striping pays for
itself) versus a non-striped layout (typically for files
expected to remain small).  The hint applies to the layout
being requested and has no retroactive effect on layouts
already issued.  The hint is never required to be accurate; a
file is free to grow beyond its hint without protocol penalty,
and the metadata server is free to ignore the hint.</t>
          </dd>
        </dl>
        <t>The stripe_unit and expected_file_size hints are most useful at
the LAYOUTGET that follows file creation, when the file is at
size zero and the metadata server has no usage history to drive
its own striping decision.  On a LAYOUTGET against an
already-grown file, the metadata server <bcp14>SHOULD</bcp14> ignore both
hints and use the file's actual size and access history.</t>
        <t>For example, a client that prefers Mojette systematic with 8+2
protection, 1 MiB stripe units, and is creating a file expected
to grow to 16 GiB would send:</t>
        <artwork><![CDATA[
ffv2lh_supported_types = { FFV2_ENCODING_PASSTHROUGH,
                         FFV2_ENCODING_REPLICATED,
                         FFV2_ENCODING_MOJETTE_SYSTEMATIC,
                         FFV2_ENCODING_RS_VANDERMONDE }
ffv2lh_preferred_protection = { ffv2dp_data = 8, ffv2dp_parity = 2 }
ffv2lh_stripe_unit          = 1048576
ffv2lh_expected_file_size   = 17179869184
]]></artwork>
        <t>A server with a policy of RS 4+2 for this directory would ignore
both encoding hints and return a layout with
FFV2_ENCODING_RS_VANDERMONDE and (ffv2dp_data=4, ffv2dp_parity=2).  A
server without erasure coding might return FFV2_ENCODING_REPLICATED
with (ffv2dp_data=3, ffv2dp_parity=0) for 3-way mirroring with
per-chunk integrity, or FFV2_ENCODING_PASSTHROUGH with
(ffv2dp_data=1, ffv2dp_parity=2) for 3-way flexible file v1 layout-compatible
mirroring without per-chunk integrity.</t>
        <t>A server may also use ffv2lh_expected_file_size as a striping
gate: a deployment that wants to avoid the runway and bookkeeping
overhead of striping small files (which dominate file-count even
when they do not dominate byte count) can use a single-mirror
non-striped layout for any LAYOUTGET whose hint is below a
configured threshold, and a striped layout above it.  Without
the hint the metadata server must either always stripe, never
stripe, or rely on observing the file's growth -- which is
exactly the friction the hint exists to remove.</t>
        <section anchor="sec-encoding-negotiation">
          <name>Encoding Negotiation</name>
          <t>Because the encoding type registry is expected to grow over time
(new erasure encoding types are added, older ones fall out of favor,
vendors register private codes; see <xref target="iana-considerations"/>),
neither clients nor metadata servers are required to implement
every registered encoding.  The protocol negotiates encoding
capabilities via ffv2_layouthint4:</t>
          <dl>
            <dt>Client-side advertisement:</dt>
            <dd>
              <t>A client that wishes to influence encoding selection <bcp14>SHOULD</bcp14>
send the set of encodings it actually implements in
ffv2lh_supported_types.  A client <bcp14>MUST NOT</bcp14> claim support for
an encoding it cannot encode or decode: a false advertisement
produces silent data unavailability when the resulting layout
is issued.</t>
            </dd>
            <dt>Metadata-server selection at file creation:</dt>
            <dd>
              <t>When the LAYOUTGET is against a newly-created file (the file
has no committed data yet), the metadata server has real
discretion.  It <bcp14>SHOULD</bcp14> select an encoding from the client's
ffv2lh_supported_types list when the server's policy permits.
The server <bcp14>MAY</bcp14> override the hint when its policy dictates a
specific encoding (for example, per-export objectives); in that
case the server issues a layout with the policy-dictated
encoding and the client <bcp14>MUST</bcp14> either honor it or fail its I/O
with NFS4ERR_ENCODING_NOT_SUPPORTED.</t>
            </dd>
            <dt>Metadata-server selection for an existing file:</dt>
            <dd>
              <t>When the LAYOUTGET is against a file that already has
committed data on the data servers, the file's encoding is
fixed by the bytes already written; the metadata server does
not choose an encoding at layout-issue time.  Re-encoding an
existing file is a separate operation (see the
heterogeneous mirror set primitive in
<xref target="sec-heterogeneous-mirrors"/> and the migration paths in the
proxy server draft), not a consequence of a LAYOUTGET hint.  In this case
ffv2lh_supported_types is not a selection input; it is an
admissibility check.  The metadata server issues a layout
with the file's actual encoding and evaluates whether the
client can consume it:
</t>
              <ul spacing="normal">
                <li>
                  <t>If the file's encoding is in the client's
ffv2lh_supported_types list, the metadata server issues
the layout normally.</t>
                </li>
                <li>
                  <t>If it is not, the metadata server takes one of the
fallback actions enumerated in "Fallback when no overlap
exists" below (return NFS4ERR_ENCODING_NOT_SUPPORTED,
route I/O through the metadata server, or route through
a translating proxy server).</t>
                </li>
              </ul>
            </dd>
            <dt>Fallback when no overlap exists:</dt>
            <dd>
              <t>If the server's policy cannot be satisfied by any encoding the
client supports, the metadata server has three options:
</t>
              <ol spacing="normal" type="1"><li>
                  <t>Return NFS4ERR_ENCODING_NOT_SUPPORTED on the LAYOUTGET.
The client <bcp14>MAY</bcp14> retry with a different (possibly empty)
ffv2lh_supported_types list to learn the server's encoding
repertoire through the errors returned.</t>
                </li>
                <li>
                  <t>Fall back to I/O via the metadata server itself, so the
client's reads and writes are satisfied by the metadata server
translating to the underlying data server encoding on the client's
behalf (see <xref target="sec-Fencing-Clients"/> for the metadata-server I/O
fallback).  This is correct but serializes all I/O for
the encoding-ignorant client through a single actor.</t>
                </li>
                <li>
                  <t>Route the client through a translating proxy that
understands both the file's native encoding and an encoding
the client does support.  The metadata server issues a layout with
the proxy's data-server entry carrying
FFV2_DS_FLAGS_PROXY and a coding_type the client does
support (typically FFV2_ENCODING_REPLICATED for a minimal
NFSv4.2 client, or FFV2_ENCODING_PASSTHROUGH / a flat
NFSv3 view for an NFSv3 client).  The proxy encodes
and decodes on the fly
against the real data servers.  This preserves parallel I/O
for the encoding-ignorant client that the metadata-server I/O
fallback loses.  The proxy registration, directive, and
credential-forwarding rules are defined in the proxy server
draft; this draft defines only the layout flag
(FFV2_DS_FLAGS_PROXY in
<xref target="sec-ffv2_ds_flags4"/>) that makes the proxy visible to
the client.</t>
                </li>
              </ol>
              <t>Options (1), (2), and (3) are not mutually exclusive: a
given deployment <bcp14>MAY</bcp14> implement any combination.  A
deployment that supports (3) covers all the clients that
(1) and (2) would cover and additionally preserves parallel
I/O for encoding-ignorant clients.</t>
            </dd>
            <dt>Runtime encoding change:</dt>
            <dd>
              <t>If a metadata server changes its encoding policy after layouts
have been issued (for example, a deployment upgrade that
retires an older encoding), the metadata server <bcp14>MUST</bcp14> recall the
affected layouts via CB_LAYOUTRECALL and may re-issue new
layouts with the new encoding.  Clients that do not support the
new encoding LAYOUTRETURN with NFS4ERR_ENCODING_NOT_SUPPORTED,
and the server either grants a layout using a mutually-supported encoding or the client falls back to I/O via the
metadata server.</t>
            </dd>
          </dl>
          <t>This mechanism deliberately avoids a separate capability-bit
handshake at EXCHANGE_ID.  ffv2_layouthint4 already provides
per-request negotiation; adding a session-level
capability set would duplicate it and would complicate encoding
upgrades without additional value, because a client that
genuinely upgrades its encoding set at runtime can simply update
the ffv2lh_supported_types on its next LAYOUTGET.</t>
          <t>Note: In <xref target="fig-ffv2_layout4"/> ffv2_encoding_type_data4 is an enumerated
union with the payload of each arm being defined by the protection
type. ffv2m_client_id tells the client which id to use when interacting
with the data servers.</t>
          <t>The ffv2_layout4 structure (see <xref target="fig-ffv2_layout4"/>) specifies a layout
in that portion of the data file described in the current layout
segment.  It is either a single instance or a set of mirrored copies
of that portion of the data file.  When mirroring is in effect, it
protects against loss of data in layout segments.</t>
          <t>While not explicitly shown in <xref target="fig-ffv2_layout4"/>, each layout4
element returned in the logr_layout array of LAYOUTGET4res (see
<xref section="18.43.2" sectionFormat="of" target="RFC8881"/>) describes a layout segment.  Hence,
each ffv2_layout4 also describes a layout segment.  It is possible
that the file is concatenated from more than one layout segment.
Each layout segment <bcp14>MAY</bcp14> represent different striping parameters.</t>
          <t>The ffv2m_striping_unit_size field (inside each ffv2_mirror4) is
the stripe unit size in use for that mirror.  The stripe width
W is given by the number of elements in ffv2s_data_servers
within each ffv2_stripes4 (the count of data servers over which
each stripe is spread).  If ffv2m_striping is FFV2_STRIPING_NONE
the mirror is unstriped and ffv2m_striping_unit_size <bcp14>MUST</bcp14> be 1
(matching the FFV2_STRIPING_NONE rule in <xref target="sec-ffv2-mirror4"/>
and <xref target="sec-striping"/>); when ffv2m_striping is
FFV2_STRIPING_SPARSE or FFV2_STRIPING_DENSE the field carries
the stripe unit size in bytes with a minimum of 64.  The
mapping scheme (sparse or dense) is selected per mirror by
ffv2m_striping and is detailed in <xref target="sec-striping"/>.</t>
          <t>Stripe unit size and stripe count <bcp14>MAY</bcp14> differ between mirrors in
the same layout segment.  In particular, mirrors of different
encoding types (see <xref target="sec-heterogeneous-mirrors"/>) have stripe
counts determined by their respective (ffv2dp_data, ffv2dp_parity)
protection structures, and there is no requirement that those
structures match across mirrors.  Each mirror is self-consistent
internally; cross-mirror coherence is at the byte level (every
mirror represents the same file bytes), not at the stripe-geometry
level.</t>
          <t>The ffv2l_mirrors field represents an array of state information for
each mirrored copy of the current layout segment.  Each element is
described by a ffv2_mirror4 type.</t>
          <t>ffv2ds_deviceid provides the deviceid of the storage device holding
the data file.</t>
          <t>ffv2ds_file_info is an array of ffv2_file_info4 structures, each
pairing a filehandle (ffv2fi_fh_vers) with a stateid (ffv2fi_stateid).
There <bcp14>MUST</bcp14> be exactly as many elements in ffv2ds_file_info as there
are in ffv2da_versions.  Each element of the array corresponds to a
particular combination of ffv2dv_version, ffv2dv_minorversion, and
ffv2dv_coupling provided for the device.  The array allows for
server implementations that have different filehandles and stateids
for different combinations of version, minor version, and coupling
strength.  See <xref target="sec-version-errors"/> for how to handle versioning
issues between the client and storage devices.</t>
          <t>For tight coupling, ffv2fi_stateid provides the stateid to be used
by the client to access the file.  The metadata server registers
ffv2fi_stateid with each tight coupling capable storage device via
TRUST_STATEID (see <xref target="sec-tight-coupling-control"/>) before returning
the layout; the storage device validates subsequent CHUNK operations
against its trust table.</t>
          <t>For loose coupling and an NFSv4 storage device (necessarily a
PASSTHROUGH mirror per <xref target="sec-ff_device_addr4"/>, since non-PASSTHROUGH
encodings require tight coupling), the client <bcp14>MUST</bcp14>
use the anonymous stateid to perform I/O on the storage device,
because the metadata server stateid has no meaning to a storage
device that is not participating in the control protocol.  In
this case the metadata server <bcp14>MUST</bcp14> set ffv2fi_stateid to the
anonymous stateid.</t>
          <t>For an NFSv3 storage device (ffv2dv_version = 3), the tight coupling
model does not apply: <xref target="sec-ff_device_addr4"/> requires
ffv2dv_coupling to equal FFV2_COUPLING_SYNTHETIC_UIDS whenever
ffv2dv_version equals 3, because NFSv3 has no wire encoding for
stateids.  The corresponding
ffv2fi_stateid element in the ffv2ds_file_info array <bcp14>MUST</bcp14> therefore
be the anonymous stateid and is unused; an NFSv3 data server uses
the synthetic-uid fencing model (see <xref target="sec-Fencing-Clients"/>)
rather than a stateid-based trust table.</t>
          <t>This specification of the ffv2fi_stateid restricts both models for
NFSv4.x storage protocols:</t>
          <dl>
            <dt>loosely couple</dt>
            <dd>
              <t>the stateid has to be an anonymous stateid</t>
            </dd>
            <dt>tightly couple</dt>
            <dd>
              <t>the stateid has to be a global stateid</t>
            </dd>
          </dl>
          <t>By pairing each ffv2fi_fh_vers with its own ffv2fi_stateid inside
ffv2_file_info4, the flexible file v2 layout addresses a limitation
in the flexible file v1 layout where a single stateid was shared
across all filehandles.</t>
          <t>Whether the ffv2fi_stateid values across an ffv2_file_info4 array
are distinct depends on each entry's coupling mode per the rules
above.  Loose-coupling and NFSv3 entries <bcp14>MUST</bcp14> carry the anonymous
stateid; those entries are therefore byte-identical by mandate.
Tight-coupling entries carry stateids the metadata server assigned
and registered via TRUST_STATEID; the metadata server <bcp14>MAY</bcp14> assign
these distinctly per filehandle version or <bcp14>MAY</bcp14> reuse the same
stateid across entries.</t>
          <t>The client <bcp14>MUST</bcp14> treat each (ffv2fi_fh_vers, ffv2fi_stateid) pair as
an opaque, independent authorization unit.  The client <bcp14>MUST NOT</bcp14>
compare ffv2fi_stateid values across entries in the array and <bcp14>MUST
NOT</bcp14> infer any relationship between two entries whose stateid values
are byte-identical.  When the client selects an entry to use for
I/O, it presents that entry's stateid with that entry's filehandle;
other entries in the array are unused for that I/O.</t>
          <t>For loosely coupled storage devices, ffv2ds_user and ffv2ds_group
provide the synthetic user and group to be used in the RPC credentials
that the client presents to the storage device to access the data
files.  For tightly coupled storage devices, the user and group on
the storage device will be the same as on the metadata server; that
is, if ffv2dv_coupling has any tight coupling flag set (see
<xref target="sec-ff_device_addr4"/>), then the client <bcp14>MUST</bcp14> ignore both
ffv2ds_user and ffv2ds_group.</t>
          <t>The allowed values for both ffv2ds_user and ffv2ds_group are specified
as owner and owner_group, respectively, in <xref section="5.9" sectionFormat="of" target="RFC8881"/>.
For NFSv3 compatibility, user and group strings that consist of
decimal numeric values with no leading zeros can be given a special
interpretation by clients and servers that choose to provide such
support.  The receiver may treat such a user or group string as
representing the same user as would be represented by an NFSv3 uid
or gid having the corresponding numeric value.  Note that if using
Kerberos for security, the expectation is that these values will
be a name@domain string.</t>
          <t>ffv2ds_efficiency describes the metadata server's evaluation as to
the effectiveness of each mirror.  Note that this is per layout and
not per device as the metric may change due to perceived load,
availability to the metadata server, etc.  Higher values denote
higher perceived utility.  The way the client can select the best
mirror to access is discussed in <xref target="sec-select-mirror"/>.</t>
        </section>
        <section anchor="error-codes-from-layoutget">
          <name>Error Codes from LAYOUTGET</name>
          <t><xref target="RFC8881"/> provides little guidance as to how the client is to
proceed with a LAYOUTGET that returns an error of either
NFS4ERR_LAYOUTTRYLATER, NFS4ERR_LAYOUTUNAVAILABLE, and NFS4ERR_DELAY.
Within the context of this document:</t>
          <dl>
            <dt>NFS4ERR_LAYOUTUNAVAILABLE:</dt>
            <dd>
              <t>there is no layout available and the I/O is to go to the metadata
server.  Note that it is possible to have had a layout before a
recall and not after.</t>
            </dd>
            <dt>NFS4ERR_LAYOUTTRYLATER:</dt>
            <dd>
              <t>there is some issue preventing the layout from being granted.
If the client already has an appropriate layout, it should continue
with I/O to the storage devices.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>there is some issue preventing the layout from being granted.
If the client already has an appropriate layout, it should not
continue with I/O to the storage devices.</t>
            </dd>
          </dl>
        </section>
        <section anchor="client-interactions-with-ffv2flagsnoiothrumds">
          <name>Client Interactions with FFV2_FLAGS_NO_IO_THRU_MDS</name>
          <t>FFV2_FLAGS_NO_IO_THRU_MDS is normative: when the metadata
server sets FFV2_FLAGS_NO_IO_THRU_MDS on a layout, the client
<bcp14>MUST NOT</bcp14> proxy I/O for that layout through the metadata server,
even after detecting a network disconnect to a storage device
(<xref target="sec-ffv2_flags4"/>).  A client that cannot reach a storage
device on which it holds a NO_IO_THRU_MDS layout <bcp14>MUST</bcp14> return
the layout via LAYOUTRETURN and reacquire (via LAYOUTGET), at
which point the metadata server chooses whether to grant a new
layout with the flag cleared, grant a layout naming a different
storage device, or fall back to metadata-server-terminated I/O
via the encoding-negotiation path
(<xref target="sec-encoding-negotiation"/>) with the flag cleared.</t>
          <t>The NO_IO_THRU_MDS flag is not advisory; it is an
instruction the client <bcp14>MUST</bcp14> honor.  When I/O through the
metadata server is required (for example, via the
encoding-negotiation fallback path in <xref target="sec-encoding-negotiation"/>),
the metadata server <bcp14>MUST</bcp14> clear NO_IO_THRU_MDS on the
fallback layout it issues.  A client <bcp14>MUST NOT</bcp14> interpret
a set NO_IO_THRU_MDS flag as advisory or bypass it.</t>
        </section>
      </section>
      <section anchor="layoutcommit-1">
        <name>LAYOUTCOMMIT</name>
        <t>The flexible file v2 layout does not use lou_body inside the
loca_layoutupdate argument to LAYOUTCOMMIT.  If lou_type is
LAYOUT4_FLEX_FILES_V2, the lou_body field <bcp14>MUST</bcp14> have a zero length (see
<xref section="18.42.1" sectionFormat="of" target="RFC8881"/>).</t>
      </section>
      <section anchor="interactions-between-devices-and-layouts">
        <name>Interactions between Devices and Layouts</name>
        <t>The file layout type is defined such that the relationship between
multipathing and filehandles can result in either 0, 1, or N
filehandles (see <xref section="13.3" sectionFormat="of" target="RFC8881"/>).  Some rationales for
this are clustered servers that share the same filehandle or allow
for multiple read-only copies of the file on the same storage device.
In the flexible file v2 layout, while there is an array of
filehandles, they are independent of the multipathing being used.
If the metadata server wants to provide multiple read-only copies
of the same file on the same storage device, then it should provide
multiple mirrored instances, each with a different ffv2_device_addr4.
The client can then determine that, since each of the ffv2fi_fh_vers
values within ffv2ds_file_info are different, there are multiple
copies of the file for the current layout segment available.</t>
      </section>
      <section anchor="sec-version-errors">
        <name>Handling Version Errors</name>
        <t>When the metadata server provides the ffv2da_versions array in the
ffv2_device_addr4 (see <xref target="sec-ff_device_addr4"/>), the client is
able to determine whether or not it can access a storage device
with any of the supplied combinations of ffv2dv_version,
ffv2dv_minorversion, and ffv2dv_coupling.  However, due to the limitations of
reporting errors in GETDEVICEINFO (see Section 18.40 in <xref target="RFC8881"/>),
the client is not able to specify which specific device it cannot
communicate with over one of the provided ffv2dv_version and
ffv2dv_minorversion combinations.  Using ffv2_ioerr4 (<xref target="sec-ffv2_ioerr4"/>)
inside either the LAYOUTRETURN (see <xref section="18.44" sectionFormat="of" target="RFC8881"/>)
or the LAYOUTERROR (see <xref section="15.6" sectionFormat="of" target="RFC7862"/> and <xref target="sec-LAYOUTERROR"/>
of this document), the client can isolate the problematic storage
device.</t>
        <t>The error code to return for LAYOUTRETURN and/or LAYOUTERROR is
NFS4ERR_MINOR_VERS_MISMATCH.  It does not matter whether the mismatch
is a major version (e.g., client can use NFSv3 but not NFSv4) or
minor version (e.g., client can use NFSv4.1 but not NFSv4.2), the
error indicates that for all the supplied combinations for ffv2dv_version
and ffv2dv_minorversion, the client cannot communicate with the storage
device.  The client can retry the GETDEVICEINFO to see if the
metadata server can provide a different combination, or it can fall
back to doing the I/O through the metadata server.</t>
      </section>
    </section>
    <section anchor="sec-striping">
      <name>Striping</name>
      <t>The flexible file v2 layout inherits the dense and sparse striping
dispositions defined by the file layout type in <xref section="13.4" sectionFormat="of" target="RFC8881"/>.  The disposition for a given mirror is selected by the
ffv2m_striping field (see <xref target="sec-ffv2-mirror4"/>) and applies to every
data server in that mirror's ffv2s_data_servers list.  Three values
are permitted:</t>
      <dl>
        <dt>FFV2_STRIPING_NONE:</dt>
        <dd>
          <t>The mirror is not striped.  ffv2m_striping_unit_size <bcp14>MUST</bcp14> be 1
and ffv2m_stripes <bcp14>MUST</bcp14> contain exactly one stripe.  The entire
mirror lives on that stripe's single data server list, with
no offset transformation.</t>
        </dd>
        <dt>FFV2_STRIPING_SPARSE:</dt>
        <dd>
          <t>Logical offsets within the file map to the same numeric
offset on each data server.  A data server that does not own
the stripe unit at a given logical offset presents a hole at
that offset.  This is the simpler model and matches the
mental picture of "the file is laid out end-to-end on each
data server, but each data server stores only its stripe
units".</t>
        </dd>
        <dt>FFV2_STRIPING_DENSE:</dt>
        <dd>
          <t>Stripe units owned by a given data server are packed
contiguously on that data server, with no holes.  The
logical offset is transformed into a compact physical offset
on the target data server.  This matches pre-existing
deployments that follow the dense layout convention of
<xref section="13.4.4" sectionFormat="of" target="RFC8881"/>.</t>
        </dd>
      </dl>
      <t>The mapping math for sparse and dense is given in
<xref target="fig-striping-math"/>.  Common definitions apply to both.</t>
      <figure anchor="fig-striping-math">
        <name>Sparse and dense stripe mapping math</name>
        <artwork><![CDATA[
L: logical offset within the file (bytes)
U: stripe-unit size in bytes  = ffv2m_striping_unit_size
W: stripe width               = length of ffv2s_data_servers
S: stripe size in bytes       = W * U
N: stripe number              = L / S
i: index (0-based) of the data server that owns L
                              = (L / U) mod W
R: byte offset within the stripe unit
                              = L mod U

FFV2_STRIPING_SPARSE:
  physical offset on data server i:
      P_sparse(L) = L
  other data servers see a hole at offset L.

FFV2_STRIPING_DENSE:
  physical offset on data server i:
      P_dense(L) = N * U + R
             = (L / S) * U + (L mod U)
  each data server stores only the stripe units it owns,
  packed contiguously.
]]></artwork>
      </figure>
    </section>
    <section anchor="recovering-from-client-io-errors">
      <name>Recovering from Client I/O Errors</name>
      <t>The pNFS client may encounter errors when directly accessing the
storage devices.  However, it is the responsibility of the metadata
server to recover from the I/O errors.  When the LAYOUT4_FLEX_FILES_V2
layout type is used, the client <bcp14>MUST</bcp14> report the I/O errors to the
server at LAYOUTRETURN time using the ffv2_ioerr4 structure (see
<xref target="sec-ffv2_ioerr4"/>).</t>
      <t>The metadata server analyzes the error and determines the required
recovery operations such as recovering media failures or reconstructing
missing data files.</t>
      <t>The metadata server <bcp14>MUST</bcp14> recall any outstanding layouts to allow
it exclusive write access to the stripes being recovered and to
prevent other clients from hitting the same error condition.  In
these cases, the server <bcp14>MUST</bcp14> complete recovery before handing out
any new layouts to the affected byte ranges.</t>
      <t>The client's retry disposition depends on which encoding the
affected mirror uses.  The two subsections below split the
encoding types into two families: mirrored / PASSTHROUGH (where
the storage device holds the file's bytes directly, so retrying
the I/O through the metadata server is possible), and the
chunked encodings (where the storage device holds encoded
shards, so retrying the I/O through the metadata server is
meaningful only if a proxy server is available to translate).</t>
      <section anchor="sec-io-error-retry-mirrored">
        <name>Retry policy for mirrored and PASSTHROUGH encodings</name>
        <t>For a mirror using FFV2_ENCODING_REPLICATED or
FFV2_ENCODING_PASSTHROUGH, the storage device holds the file's
bytes directly (no chunk envelope, no encoding transform), and
an ordinary NFS READ or WRITE on the metadata server accesses
the same bytes.</t>
        <t>Although the client implementation has the option to propagate
a corresponding error to the application that initiated the I/O
operation and drop any unwritten data, the client should attempt
to retry the original I/O operation by either requesting a new
layout or sending the I/O via regular NFSv4.1+ READ or WRITE
operations to the metadata server.  The client <bcp14>SHOULD</bcp14> attempt to
retrieve a new layout and retry the I/O operation using the storage
device first and only retry the I/O operation via the metadata
server if the error persists.</t>
      </section>
      <section anchor="sec-io-error-retry-chunked">
        <name>Retry policy for chunked (erasure-coded) encodings</name>
        <t>For a mirror using any chunked encoding (any FFV2<em>ENCODING</em>*
value other than FFV2_ENCODING_PASSTHROUGH), the storage device
holds encoded shards inside chunk envelopes rather than the
file's bytes, and retrying the I/O through the metadata server
as a regular NFS READ or WRITE against the file is not an
equivalent fallback: the metadata server does not hold the
encoded shards, and the file's bytes are recoverable only by
decoding through the mirror's erasure transform.  The client's
retry disposition is correspondingly different.</t>
        <t>For a CHUNK_READ error, the client <bcp14>SHOULD</bcp14> attempt local
reconstruction from surviving shards before returning the layout,
provided the encoding is a k + m code and the client holds
(directly or by fetching from unaffected data servers in the
same stripe) at least k surviving shards.  A successful local
reconstruction satisfies the read; the client <bcp14>MUST</bcp14> still record
the ioerr and report it at LAYOUTRETURN so the metadata server
can drive repair via CB_CHUNK_REPAIR and the repair-actor flow
(<xref target="sec-repair-selection"/>).</t>
        <t>For a CHUNK_WRITE error, or when a CHUNK_READ error cannot be
satisfied by local reconstruction (fewer than k surviving
shards, or a non-recoverable chunk_guard4 CAS failure), the
client <bcp14>SHOULD</bcp14> return the layout with the ioerr recorded after
its own storage-device-directed retries (multipath, transient
error) have been exhausted.  The client <bcp14>MUST NOT</bcp14> retry the
same I/O through the metadata server as a regular NFSv4.1+
READ or WRITE against the file: the metadata server does not
hold the encoded shards, so an I/O through the metadata server
would either be rejected or would bypass the encoding transform
and corrupt the file.</t>
        <t>Retrying the I/O through the metadata server is meaningful for
a chunked encoding only when a proxy server is available to
translate on the metadata server's behalf: the proxy server
admits the client's I/O, performs the encoding transform, and
issues the corresponding CHUNK operations to the data servers.
When no proxy server is available for the affected file, the
client's remaining option is to re-request a layout after the
metadata server has driven repair to completion.</t>
      </section>
    </section>
    <section anchor="client-side-protection-modes">
      <name>Client-Side Protection Modes</name>
      <section anchor="sec-CSM">
        <name>Client-Side Mirroring</name>
        <t>The flexible file v2 layout has a simple model in place for the
mirroring of the file data constrained by a layout segment.  Each
mirror in ffv2l_mirrors is an independent representation of the
file's contents for that segment: the XDR (see <xref target="fig-ffv2_mirror4"/>)
lets each mirror carry its own encoding
(ffv2m_encoding_type_data), its own striping pattern
(ffv2m_striping and ffv2m_stripes), and its own set of data
servers.  A single layout <bcp14>MAY</bcp14> combine dissimilar mirrors -- for
example, one FFV2_ENCODING_REPLICATED mirror and one
FFV2_ENCODING_RS_VANDERMONDE mirror of the same file contents,
as sketched in <xref target="fig-parallel-filesystem"/> -- and there is no
cross-mirror constraint that striping patterns or encoding
choices match.</t>
        <t>There is likewise no assumption that each copy of the mirror is
stored identically on the storage devices.  For example, one device
might employ compression or deduplication on the data.  What each
mirror <bcp14>MUST</bcp14> provide is the same reconstructed file contents on
read (after any decoding through the mirror's encoding
transform); the on-disk representation and the wire representation
per mirror are consequences of that mirror's independently
selected encoding.</t>
        <t>The metadata server is responsible for determining the number of
mirrored copies and the location of each mirror.  While the client
may provide a hint to how many copies it wants (see <xref target="sec-ffv2-layouthint"/>),
the metadata server can ignore that hint; in any event, the client
has no means to dictate either the storage device (which also means
the coupling and/or protocol levels to access the layout segments)
or the location of said storage device.</t>
        <t>The updating of mirrored layout segments is done via client-side
mirroring.  With this approach, the client is responsible for making
sure modifications are made on all copies of the layout segments
it is informed of via the layout.  If a layout segment is being
resilvered to a storage device, that mirrored copy will not be in
the layout.  Thus, the metadata server (or a proxy server acting
on its behalf, if one is available for the file) <bcp14>MUST</bcp14> update that
copy until the client is presented it in a layout.  If the
FFV2_FLAGS_WRITE_ONE_MIRROR is set in ffv2l_flags, the client
need only update one of the mirrors (see <xref target="sec-write-mirrors"/>).
If the client is writing to the layout segments via the metadata
server, then the metadata server (or a proxy server acting on its
behalf) <bcp14>MUST</bcp14> update all copies of the mirror; see the encoding
constraint on FFV2_FLAGS_WRITE_ONE_MIRROR in <xref target="sec-ffv2_flags4"/>
for the case where doing so requires the propagation actor to
translate across encodings.  As seen in <xref target="sec-mds-resilvering"/>,
during the resilvering, the layout is recalled, and the client
has to make modifications through the metadata-server side.</t>
        <section anchor="sec-select-mirror">
          <name>Selecting a Mirror</name>
          <t>When the metadata server grants a layout to a client, it <bcp14>MAY</bcp14> let
the client know how fast it expects each mirror to be once the
request arrives at the storage devices via the ffv2ds_efficiency
member.  While the algorithms to calculate that value are left to
the metadata server implementations, factors that could contribute
to that calculation include speed of the storage device, physical
memory available to the device, operating system version, current
load, etc.</t>
          <t>However, what should not be involved in that calculation is a
perceived network distance between the client and the storage device.
The client is better situated for making that determination based
on past interaction with the storage device over the different
available network interfaces between the two; that is, the metadata
server might not know about a transient outage between the client
and storage device because it has no presence on the given subnet.</t>
          <t>As such, it is the client that decides which mirror to access for
reading the file.  The requirements for writing to mirrored layout
segments are presented below.</t>
        </section>
        <section anchor="sec-write-mirrors">
          <name>Writing to Mirrors</name>
          <section anchor="single-storage-device-updates-mirrors">
            <name>Single Storage Device Updates Mirrors</name>
            <t>If the FFV2_FLAGS_WRITE_ONE_MIRROR flag in ffv2l_flags is set, the
client <bcp14>MAY</bcp14> update just one of the copies of the layout segment.
For this case, the storage device <bcp14>MUST</bcp14> ensure that all copies of
the mirror are updated when any one of the mirrors is updated.  If
the storage device gets an error when updating one of the mirrors,
then it <bcp14>MUST</bcp14> inform the client that the original WRITE had an error.
The client then <bcp14>MUST</bcp14> inform the metadata server (see <xref target="sec-write-errors"/>).
The client's responsibility with respect to COMMIT is explained in
<xref target="sec-write-commits"/>.  The client may choose any one of the mirrors
and may use ffv2ds_efficiency as described in <xref target="sec-select-mirror"/>
when making this choice.</t>
          </section>
          <section anchor="client-updates-all-mirrors">
            <name>Client Updates All Mirrors</name>
            <t>If the FFV2_FLAGS_WRITE_ONE_MIRROR flag in ffv2l_flags is not set, the
client is responsible for updating all mirrored copies of the layout
segments that it is given in the layout.  A single failed update
is sufficient to fail the entire operation.  If all but one copy
is updated successfully and the last one provides an error, then
the client <bcp14>MUST</bcp14> inform the metadata server about the error.
The client can use either LAYOUTRETURN or LAYOUTERROR to inform the
metadata server that the update failed to that storage device.  If
the client is updating the mirrors serially, then it <bcp14>SHOULD</bcp14> stop
at the first error encountered and report that to the metadata
server.  If the client is updating the mirrors in parallel, then
it <bcp14>SHOULD</bcp14> wait until all storage devices respond so that it can
report all errors encountered during the update.</t>
          </section>
          <section anchor="sec-write-errors">
            <name>Handling Write Errors</name>
            <t>When the client reports a write error to the metadata server, the
metadata server is responsible for determining if it wants to remove
the errant mirror from the layout, if the mirror has recovered from
some transient error, etc.  When the client tries to get a new
layout, the metadata server informs it of the decision by the
contents of the layout.  The client <bcp14>MUST NOT</bcp14> assume that the contents
of the previous layout will match those of the new one.  If it has
updates that were not committed to all mirrors, then it <bcp14>MUST</bcp14> resend
those updates to all mirrors.</t>
            <t>There is no provision in the protocol for the metadata server to
directly determine that the client has or has not recovered from
an error.  For example, if a storage device was network partitioned
from the client and the client reported the error to the metadata
server, then the network partition would be repaired, and all of
the copies would be successfully updated.  There is no mechanism
for the client to report that fact, and the metadata server is
forced to repair the file across the mirror.</t>
            <t>If the client supports NFSv4.2, it can use LAYOUTERROR and LAYOUTRETURN
to provide hints to the metadata server about the recovery efforts.
A LAYOUTERROR on a file is for a non-fatal error.  A subsequent
LAYOUTRETURN without a ffv2_ioerr4 indicates that the client successfully
replayed the I/O to all mirrors.  Any LAYOUTRETURN with a ffv2_ioerr4
is an error that the metadata server needs to repair.  The client
<bcp14>MUST</bcp14> be prepared for the LAYOUTERROR to trigger a CB_LAYOUTRECALL
if the metadata server determines it needs to start repairing the
file.</t>
          </section>
          <section anchor="sec-write-commits">
            <name>Handling Write COMMITs</name>
            <t>When stable writes are done to the metadata server or to a single
replica (if allowed by the use of FFV2_FLAGS_WRITE_ONE_MIRROR), it
is the responsibility of the receiving node to propagate the written
data stably, before replying to the client.</t>
            <t>In the corresponding cases in which unstable writes are done, the
receiving node does not have any such obligation, although it may
choose to asynchronously propagate the updates.  However, once a
COMMIT is replied to, all replicas <bcp14>MUST</bcp14> reflect the writes that
have been done, and this data <bcp14>MUST</bcp14> have been committed to stable
storage on all replicas.</t>
            <t>In order to avoid situations in which stale data is read from
replicas to which writes have not been propagated:</t>
            <ul spacing="normal">
              <li>
                <t>A client that has outstanding unstable writes made to single
node (metadata server or storage device) <bcp14>MUST</bcp14> do all reads from
that same node.</t>
              </li>
              <li>
                <t>When writes are flushed to the server (for example, to implement
close-to-open semantics), a COMMIT must be done by the client
to ensure that up-to-date written data will be available
irrespective of the particular replica read.</t>
              </li>
            </ul>
          </section>
        </section>
        <section anchor="sec-mds-resilvering">
          <name>Metadata Server Resilvering of the File</name>
          <t>The metadata server may elect to create a new mirror of the layout
segments at any time.  This might be to resilver a copy on a storage
device that was down for servicing, to provide a copy of the layout
segments on storage with different storage performance characteristics,
etc.  As the client will not be aware of the new mirror and the
metadata server will not be aware of updates that the client is
making to the layout segments, the metadata server <bcp14>MUST</bcp14> recall the
writable layout segment(s) that it is resilvering.  If the client
issues a LAYOUTGET for a writable layout segment that is in the
process of being resilvered, then the metadata server can deny that
request with an NFS4ERR_LAYOUTUNAVAILABLE.</t>
          <t>The client's fallback while the layout is withheld follows the
per-encoding rules in
<xref target="sec-io-error-retry-mirrored"/> and <xref target="sec-io-error-retry-chunked"/>:
for a mirror whose I/O reduces to FFV2_ENCODING_REPLICATED or
FFV2_ENCODING_PASSTHROUGH the client <bcp14>MAY</bcp14> perform the I/O through
the metadata server as an ordinary NFSv4.1+ READ or WRITE; for a
mirror using any chunked encoding the metadata server itself
cannot service that I/O (it does not hold the encoded shards),
so the client's only fallback path is through a proxy server
if one is available for the file.  If no proxy server is available, the
client <bcp14>MUST</bcp14> wait for the metadata server to complete resilvering
and re-issue LAYOUTGET rather than attempt to route the I/O
through the metadata server.</t>
        </section>
      </section>
      <section anchor="client-side-erasure-coding">
        <name>Client-Side Erasure Coding</name>
        <t>Erasure coding takes a data block and transforms it to a payload
to send to the data servers (see <xref target="fig-encoding-data-block"/>).  It
generates a metadata header and transformed block per data server.
The header is metadata information for the transformed block.  From
now on, the metadata is simply referred to as the header and the
transformed block as the chunk.  The payload of a data block is the
set of generated headers and chunks for that data block.</t>
        <t>The chunk header carries four conceptual fields, each stored
on the data server with the chunk and carried on the wire by
every op that reads or writes the chunk.  This document does
not define a single XDR struct for the chunk header; instead
each op names the four fields directly, and the fields
appear on the wire under an op-specific prefix.</t>
        <dl>
          <dt>Guard:</dt>
          <dd>
            <t>an XDR chunk_guard4 (cg_gen_id, cg_client_id) pair
maintained by the data server to serialize concurrent
writers (see <xref target="sec-chunk_guard4"/>).  Each accepted
CHUNK_WRITE advances the target chunk's guard, and readers
observe the accepted guard on the read path.</t>
          </dd>
          <dt>Owner:</dt>
          <dd>
            <t>an XDR chunk_owner4 owner triple
identifying the writer's cohort (see
<xref target="sec-chunk_owner4"/>).  The owner is the identity that
lifecycle operations (CHUNK_FINALIZE, CHUNK_COMMIT,
CHUNK_ROLLBACK) address.</t>
          </dd>
          <dt>Payload identifier:</dt>
          <dd>
            <t>a writer-chosen uint32_t naming the chunk's position
within the payload's shard array.  Unlike the guard and
owner, the payload identifier is not a sub-struct with
named fields; it is a bare scalar carried directly under
an op-specific prefix on each op's wire arguments:
cwa_payload_id on CHUNK_WRITE,
cr_payload_id in the CHUNK_READ result
(<xref target="sec-CHUNK_READ"/>), and cwra_payload_id on
CHUNK_WRITE_REPAIR.  The
value the three carry names the same conceptual header
field; only the wire prefix differs across ops.</t>
          </dd>
          <dt>Checksum:</dt>
          <dd>
            <t>a 32-bit CRC computed over the header and the chunk.
Because the checksum field is itself part of the header,
the computation treats the bytes of that field as zero so
that the result is independent of the field's wire value;
the writer then stores the computed CRC into the checksum
field for transmission.  To validate on the read path, the
receiver saves the received checksum, treats those bytes
as zero, recomputes the CRC over the header and chunk, and
compares against the saved value.  By combining the two
parts of the payload in the CRC, integrity is ensured for
both parts.</t>
          </dd>
        </dl>
        <t>While the data block might have a length of 4kB, that does not
necessarily mean that the length of the chunk is 4kB.  That length
is determined by the erasure encoding type algorithm.  For example,
Reed Solomon might have 4kB chunks with the data integrity being
compromised by parity chunks.  Another example would be the Mojette
Transformation, which might have 1kB chunk lengths.</t>
        <t>The payload contains redundancy which will allow the erasure
encoding type algorithm to repair chunks in the payload as it is
transformed back to a data block (see <xref target="fig-decoding-db"/>).</t>
        <t>The protocol provides two levels of payload integrity, consumed at
different points in the read path:</t>
        <dl>
          <dt>Atomicity:</dt>
          <dd>
            <t>A payload is atomic when all of the chunks that belong
to it carry the same chunk_guard4 value (see
<xref target="sec-chunk_guard4"/>).  Atomicity alone does NOT imply the
bytes are free of corruption; it means only that every chunk in
the payload came from one write transaction.  A reader detects
a non-atomic payload (a torn read across writes) when it
assembles a payload and finds differing chunk_guard4 values
across chunks.</t>
          </dd>
          <dt>Integrity:</dt>
          <dd>
            <t>A payload has integrity when it is atomic AND every
contained chunk passes its checksum check.  Integrity is the
precondition for returning the payload's data block to the
application.</t>
          </dd>
        </dl>
        <t>The separation matters because the two checks detect different
failure modes.  Atomicity detects protocol-level failures (racing
writers, partial writes, rollback windows); the checksum detects
byte-level corruption (network errors, media errors, software bugs
in the erasure transform).  Neither subsumes the other.</t>
        <t>The two-level integrity model also reflects a deeper property of
distributed writes: last-writer-wins does not apply to a payload
spread across independent data servers.  The ordering of writes
arriving at one data server may differ from the ordering arriving
at another; the "last" write on one data server may well be the
"first" on another.  The chunk_guard4 CAS primitive (see
<xref target="sec-chunk_guard4"/>) resolves this by serializing concurrent
writers per chunk rather than by imposing a global order.</t>
        <t>The erasure coding algorithm itself might not be sufficient to
detect all byte-level errors in the chunks.  The checksum checks
allow the data server to detect chunks with integrity issues; the
erasure decoding algorithm can then reconstruct the affected
chunks from the remaining integral chunks in the payload.</t>
        <section anchor="encoding-a-data-block">
          <name>Encoding a Data Block</name>
          <figure anchor="fig-encoding-data-block">
            <name>Encoding a Data Block</name>
            <artwork><![CDATA[
                 +-------------+
                 | data block  |
                 +-------+-----+
                         |
                         |
   +---------------------+-------------------------------+
   |            Erasure Encoding (Transform Forward)     |
   +---+----------------------+---------------------+----+
       |                      |                     |
       |                      |                     |
   +-------------------+  +-------------------+  +-------------------+
   | HEADER            |..| HEADER            |..| HEADER            |
   +-------------------+  +-------------------+  +-------------------+
   | owner:            |..| owner:            |..| owner:            |
   |   co_cohort_id:42 |..|   co_cohort_id:42 |..|   co_cohort_id:42 |
   |   co_client_id: 6 |..|   co_client_id: 6 |..|   co_client_id: 6 |
   |   co_id       : 1 |..|   co_id       : 1 |..|   co_id       : 1 |
   | guard:            |..| guard:            |..| guard:            |
   |   cg_gen_id   : 3 |..|   cg_gen_id   : 3 |..|   cg_gen_id   : 3 |
   |   cg_client_id: 6 |..|   cg_client_id: 6 |..|   cg_client_id: 6 |
   | payload_id    : 0 |..| payload_id    : M |..| payload_id    : 5 |
   | checksum      :   |..| checksum      :   |..| checksum      :   |
   +-------------------+  +-------------------+  +-------------------+
   | CHUNK             |..| CHUNK             |..| CHUNK             |
   +-------------------+  +-------------------+  +-------------------+
   | data: ....        |..| data: ....        |..| data: ....        |
   +-------------------+  +-------------------+  +-------------------+
      Data Server 1          Data Server N          Data Server 6
]]></artwork>
          </figure>
          <t>Each data block of the file resident in the client's cache of the
file will be encoded into N different payloads to be sent to the
data servers as shown in <xref target="fig-encoding-data-block"/>.  As CHUNK_WRITE
(see <xref target="sec-CHUNK_WRITE"/>) can encode multiple write_chunk4 into a
single transaction, a more accurate description of a CHUNK_WRITE
is in <xref target="fig-example-chunk-write-args"/>.</t>
          <figure anchor="fig-example-chunk-write-args">
            <name>Example of CHUNK_WRITE_args</name>
            <sourcecode type="art"><![CDATA[
  +------------------------------------+
  | CHUNK_WRITEargs                    |
  +------------------------------------+
  | cwa_stateid: 0                     |
  | cwa_offset: 1                      |
  | cwa_stable: FILE_SYNC4             |
  | cwa_cohort_id: 0x000000000000002a  |
  | cwa_client_id: 6                   |
  | cwa_co_ids:                        |
  |         [0]:  1                    |
  |         [1]:  2                    |
  |         [2]:  3                    |
  | cwa_payload_id: 0                  |
  | cwa_chunk_size  :  1048            |
  | cwa_checksums:                     |
  |         [0]:  0x32ef89             |
  |         [1]:  0x56fa89             |
  |         [2]:  0x7693af             |
  | cwa_chunks  :  ......              |
  +------------------------------------+
]]></sourcecode>
          </figure>
          <t>This describes a 3 block write of data from an offset of 1 block
in the file.  All three chunks share cwa_cohort_id and
cwa_client_id, so the cohort identity is presented once; each
chunk's writer-chosen opaque co_id appears in the co-indexed
cwa_co_ids array (here the client chose 1, 2, 3, but any
distinct-per-cohort uint32_t values would be equally valid per
<xref target="sec-chunk_owner4"/>).  The data server can construct the cohort
record for the i'th chunk from cwa_chunks using cwa_payload_id,
cwa_cohort_id + cwa_client_id + <tt>cwa_co_ids[i]</tt>, and the i'th
checksum from cwa_checksums.  The cwa_chunks are sent together
as a byte stream to increase performance.</t>
          <t>Assuming that there were no issues, <xref target="fig-example-chunk-write-res"/>
illustrates the results.  The payload sequence id is implicit in
the CHUNK_WRITEargs.</t>
          <figure anchor="fig-example-chunk-write-res">
            <name>Example of CHUNK_WRITE_res</name>
            <sourcecode type="art"><![CDATA[
  +-------------------------------+
  | CHUNK_WRITEresok              |
  +-------------------------------+
  | cwr_count: 3                  |
  | cwr_committed: FILE_SYNC4     |
  | cwr_writeverf: 0xf1234abc     |
  | cwr_owners[0]:                |
  |        co_cohort_id: 0x2a     |
  |        co_client_id: 6        |
  |        co_id: 1               |
  | cwr_owners[1]:                |
  |        co_cohort_id: 0x2a     |
  |        co_client_id: 6        |
  |        co_id: 2               |
  | cwr_owners[2]:                |
  |        co_cohort_id: 0x2a     |
  |        co_client_id: 6        |
  |        co_id: 3               |
  +-------------------------------+
]]></sourcecode>
          </figure>
          <section anchor="worked-example-calculating-the-crc32">
            <name>Worked Example: Calculating the CRC32</name>
            <t>The examples in this section and in
<xref target="sec-checking-crc32"/> illustrate checksum computation
and verification using CHECKSUM_ALG_CRC32 as the worked
algorithm.  The other registered checksum algorithms (see
<xref target="sec-checksum4"/>) follow the same pattern -- the algorithm
names a function over the header and chunk bytes, the writer
fills cs_value with the computed output, and the reader
recomputes and compares.  Only the algorithm and the
cs_value length differ.</t>
            <figure anchor="fig-calc-before">
              <name>CRC32 Before Calculation</name>
              <artwork><![CDATA[
  +--------------------+
  | HEADER             |
  +--------------------+
  | guard:             |
  |   gen_id   : 7     |
  |   client_id: 6     |
  | payload_id : 0     |
  | crc32   : 0        |
  +--------------------+
  | CHUNK              |
  +--------------------+
  | data:  ....        |
  +--------------------+
        Data Server 1
]]></artwork>
            </figure>
            <t>Assuming the header and payload as in <xref target="fig-calc-before"/>, the crc32
needs to be calculated in order to fill in the cwa_checksums entry field.  In
this case, the crc32 is calculated over the 4 fields as shown in
the header and the cw_chunk.  In this example, it is calculated to
be 0x21de8.  The resulting CHUNK_WRITE is shown in <xref target="fig-calc-crc-after"/>.</t>
            <figure anchor="fig-calc-crc-after">
              <name>CRC32 After Calculation</name>
              <sourcecode type="art"><![CDATA[
  +------------------------------------+
  | CHUNK_WRITEargs                    |
  +------------------------------------+
  | cwa_stateid: 0                     |
  | cwa_offset: 1                      |
  | cwa_stable: FILE_SYNC4             |
  | cwa_cohort_id: 0x000000000000002b  |
  | cwa_client_id: 6                   |
  | cwa_co_ids:                        |
  |         [0]:  1                    |
  | cwa_payload_id: 0                  |
  | cwa_chunk_size  :  1048            |
  | cwa_checksums:                     |
  |         [0]:  0x21de8              |
  | cwa_chunks  :  ......              |
  +------------------------------------+
]]></sourcecode>
            </figure>
          </section>
        </section>
        <section anchor="decoding-a-data-block">
          <name>Decoding a Data Block</name>
          <figure anchor="fig-decoding-db">
            <name>Decoding a Data Block</name>
            <artwork><![CDATA[
    Data Server 1          Data Server N          Data Server 6
  +----------------+     +----------------+     +----------------+
  | HEADER         | ... | HEADER         | ... | HEADER         |
  +----------------+     +----------------+     +----------------+
  | guard:         | ... | guard:         | ... | guard:         |
  |   gen_id   : 3 | ... |   gen_id   : 3 | ... |   gen_id   : 3 |
  |   client_id: 6 | ... |   client_id: 6 | ... |   client_id: 6 |
  | payload_id : 0 | ... | payload_id : M | ... | payload_id : 5 |
  | crc32   :      | ... | crc32   :      | ... | crc32   :      |
  +----------------+     +----------------+     +----------------+
  | CHUNK          | ... | CHUNK          | ... | CHUNK          |
  +----------------+     +----------------+     +----------------+
  | data: ....     | ... | data: ....     | ... | data: ....     |
  +---+------------+     +--+-------------+     +-+--------------+
      |                     |                     |
      |                     |                     |
  +---+---------------------+---------------------+-----+
  |            Erasure Decoding (Transform Reverse)     |
  +---------------------+-------------------------------+
                        |
                        |
                +-------+-----+
                | data block  |
                +-------------+
]]></artwork>
          </figure>
          <t>When reading chunks via a CHUNK_READ operation, the client will
decode them into data blocks as shown in <xref target="fig-decoding-db"/>.</t>
          <t>At this time, the client could detect issues in the integrity of
the data.  The handling and repair are out of the scope of this
document and <bcp14>MUST</bcp14> be addressed in the document describing each
erasure encoding type.</t>
          <section anchor="sec-checking-crc32">
            <name>Worked Example: Checking the CRC32</name>
            <figure anchor="fig-example-chunk-read-crc">
              <name>CRC32 on the Wire</name>
              <sourcecode type="art"><![CDATA[
  +------------------------------------+
  | CHUNK_READresok                    |
  +------------------------------------+
  | crr_eof: false                     |
  | crr_chunks[0]:                     |
  |        cr_checksum: 0x21de8        |
  |        cr_owner:                   |
  |            co_cohort_id: 0x2b      |
  |            co_client_id: 6         |
  |            co_id       : 1         |
  |        cr_chunk  :  ......         |
  +------------------------------------+
]]></sourcecode>
            </figure>
            <t>Assuming the CHUNK_READ results as in <xref target="fig-example-chunk-read-crc"/>,
the crc32 needs to be checked in order to detect accidental
corruption.  Conceptually, a header and payload can be built as
shown in <xref target="fig-example-crc-checked"/>.  The crc32 is calculated
over the 4 fields as shown in the header and the cr_chunk.  In
this example, it is calculated to be 0x21de8; because the
calculated value matches the received cr_checksum, no
accidental corruption was detected on this payload.  (Content
authentication -- protection against adversarial modification --
requires a keyed MAC or signature; see
<xref target="sec-security-checksum-scope"/>.)</t>
            <figure anchor="fig-example-crc-checked">
              <name>CRC32 Being Checked</name>
              <artwork><![CDATA[
  +--------------------+
  | HEADER             |
  +--------------------+
  | guard:             |
  |   gen_id   : 7     |
  |   client_id: 6     |
  | payload_id  : 0    |
  | crc32    : 0       |
  +--------------------+
  | CHUNK              |
  +--------------------+
  | data:  ....        |
  +--------------------+
       Data Server 1
]]></artwork>
            </figure>
          </section>
        </section>
        <section anchor="write-modes">
          <name>Write Modes</name>
          <t>There are three writing modes for erasure coding, aligned with
the three workload classes in <xref target="sec-use-cases"/>.  The mode is
selected by the metadata server using FFV2_FLAGS_ONLY_ONE_WRITER
in the ffv2l_flags in the ffv2_layout4 (see <xref target="fig-ffv2_layout4"/>)
to inform the client whether it is the only writer to the file
or not, and by the client's own understanding of its workload
class when the flag is unset.</t>
          <dl>
            <dt>Single writer:</dt>
            <dd>
              <t>When FFV2_FLAGS_ONLY_ONE_WRITER is set, the client is the
only writer to the file.  CHUNK_WRITE with cwa_guard not set
can be used to write chunks.  There is no write contention,
but write holes can occur as the client overwrites old data.
The client does not need guarded writes, but it does need the
ability to rollback writes.  This mode corresponds to Use
Case 1 (single writer, multiple readers) in <xref target="sec-use-cases"/>.</t>
            </dd>
            <dt>Concurrent writers with occasional contention:</dt>
            <dd>
              <t>When FFV2_FLAGS_ONLY_ONE_WRITER is not set, the client is
one of several possible concurrent writers.  CHUNK_WRITE
with cwa_guard set <bcp14>MUST</bcp14> be used to write chunks.  Write holes
can be caused by multiple clients writing to the same chunk,
so the client needs guarded writes to prevent overwrites and
also needs the ability to rollback writes.  Racing writers
that lose the chunk_guard4 CAS receive NFS4ERR_CHUNK_GUARDED
and retry with a refreshed guard.  This mode corresponds to
Use Case 2 (multiple writers without sustained contention) in
<xref target="sec-use-cases"/>.</t>
            </dd>
            <dt>Concurrent writers on disjoint regions:</dt>
            <dd>
              <t>A specialization of the concurrent-writers mode above,
targeting Use Case 3 (multiple writers, disjoint regions --
the HPC checkpoint pattern) in <xref target="sec-use-cases"/>.  The wire
primitives are the same as the concurrent-writers mode
(cwa_guard set, chunk_guard4 CAS), but the deployment relies
on block alignment to keep per-chunk contention rare despite a
high overall writer count.  Contention that does occur is
resolved via the deterministic tiebreaker rule defined in
<xref target="sec-chunk_guard4"/>, so racing writers get a stable winner
across the mirror set without additional round trips.
Deployments that use an XOR-based erasure encoding and
expect frequent small edits from this workload class <bcp14>MAY</bcp14>
additionally use the delta-write protocol defined in
<xref target="I-D.haynes-nfsv4-flexfiles-v2-delta-writes"/>, which lets
the client forward per-projection XOR deltas directly to
each data server, avoiding client-side read-modify-write of
the full stripe on the small-edit path.</t>
            </dd>
          </dl>
          <t>In both modes, clients <bcp14>MUST NOT</bcp14> overwrite payloads which already
contain non-atomicity.  This directly follows from <xref target="sec-reading-chunks"/>
and <bcp14>MUST</bcp14> be handled as discussed there.  Once atomicity in the
payload has been detected, the client can use those chunks as a
basis for read/modify/update.</t>
          <t>CHUNK_WRITE is a two-pass operation in cooperation with
CHUNK_FINALIZE and CHUNK_ROLLBACK.  It writes new bytes into the chunk
and transitions the chunk to the PENDING state; the data
server is responsible for retaining the prior COMMITTED
content until the chunk reaches its next stable state.  While
a chunk is in PENDING or FINALIZED, a subsequent CHUNK_READ
does NOT observe the new content (visibility rules of
<xref target="sec-system-model"/> apply: PENDING and FINALIZED chunks are
not globally visible; CHUNK_READ returns only COMMITTED
content).</t>
          <t>Concurrent CHUNK_WRITE against a PENDING or FINALIZED chunk is
regulated by chunk_guard4 (<xref target="sec-chunk_guard4"/>), not by an
implicit lock.  A racing writer whose guard check fails
receives NFS4ERR_CHUNK_GUARDED; an explicit CHUNK_LOCK holder is signaled by NFS4ERR_CHUNK_LOCKED.
No implicit chunk-write lock is acquired by CHUNK_WRITE.
A client that requires exclusive access to a chunk <bcp14>MUST</bcp14>
invoke CHUNK_LOCK explicitly (<xref target="sec-CHUNK_LOCK"/>).</t>
          <t>If the CHUNK_WRITE results in a atomic data block, then the
client will send a CHUNK_FINALIZE in a subsequent compound to inform
the data server that the chunk is finalized and can be overwritten
by another CHUNK_WRITE.</t>
          <t>If the CHUNK_WRITE results in an non-atomic data block, or if the
data server returns NFS4ERR_CHUNK_LOCKED, the client reports the
condition to the metadata server via LAYOUTERROR with an error code
of NFS4ERR_PAYLOAD_NOT_ATOMIC.</t>
        </section>
        <section anchor="sec-repair-selection">
          <name>Selecting the Repair Actor</name>
          <t>The repair topology involves three actors communicating along
distinct paths, as shown in <xref target="fig-repair-topology"/>.</t>
          <figure anchor="fig-repair-topology">
            <name>Repair topology</name>
            <artwork><![CDATA[
     +-------------+      (1)         +-----------------+
     |  Reporting  | ---------------> |                 |
     |  client     |   LAYOUTERROR    | Metadata Server |
     |  (detects   |                  |                 |
     |  error)     |                  |                 |
     +-------------+                  +--------+--------+
                                               |
                                               | (2b)
                                               | CB_CHUNK_REPAIR
                                               | (RACE or SCRUB)
                                               v
     +-------------+      (4)         +-----------------+
     |  Repair     | ---------------> |  Data Servers   |
     |  actor      |   CHUNK ops      |  (mirror set    |
     |  (selected  |                  |  for affected   |
     |  per (2a),  |                  |  ranges)        |
     |  adopts     |                  |                 |
     |  lock (3))  |                  |                 |
     +-------------+                  +-----------------+

     (1)   Reporting client LAYOUTERRORs to the metadata server.
     (2a)  Metadata server selects a repair actor (may be a
           client -- possibly the reporting client -- a data
           server under tight coupling, or a proxy server).
     (2b)  Metadata server escrows the chunk lock and issues
           CB_CHUNK_REPAIR to the selected repair actor.
     (3)   Repair actor adopts the lock and drives the repair.
     (4)   Repair actor issues CHUNK_LOCK_ADOPT, CHUNK_WRITE_REPAIR,
           CHUNK_FINALIZE, CHUNK_COMMIT, and CHUNK_REPAIRED against
           the mirror set.
]]></artwork>
          </figure>
          <t>The metadata server is the authority that selects the repair
actor for a non-atomic payload.  The candidate set is any
client, any data server (in a tightly coupled deployment), or
the proxy server (in a proxy server deployment); the selection
is analogous to the way the metadata server assigns per-mirror
priority via ffv2ds_efficiency (see <xref target="sec-select-mirror"/>): the
protocol does not prescribe the selection algorithm, and each
deployment <bcp14>MAY</bcp14> tune its policy.</t>
          <t>Implementations <bcp14>MAY</bcp14> consider factors such as:</t>
          <ul spacing="normal">
            <li>
              <t>Whether a client holds an active write layout on the affected
payload (the client most likely to hold surviving shards in
cache).</t>
            </li>
            <li>
              <t>Whether a client has previously reported atomic shards to
the metadata server via LAYOUTSTATS or a prior LAYOUTERROR.</t>
            </li>
            <li>
              <t>Whether the layout exposes a data server carrying
FFV2_DS_FLAGS_REPAIR as a target for reconstructed shards.</t>
            </li>
            <li>
              <t>Network proximity, observed latency, or recent client load --
the same class of information that informs ffv2ds_efficiency.</t>
            </li>
          </ul>
          <t>The selection algorithm is not normative.  What is normative is
that every client <bcp14>MUST</bcp14> be prepared to:</t>
          <ol spacing="normal" type="1"><li>
              <t>Receive a repair request for a payload that the client does
not have an outstanding write layout on, and did not write;
and</t>
            </li>
            <li>
              <t>Continue its own workload after reporting
NFS4ERR_PAYLOAD_NOT_ATOMIC without itself being selected
to repair the payload it reported.</t>
            </li>
          </ol>
          <t>The metadata server signals the selected client via the
CB_CHUNK_REPAIR callback (<xref target="sec-CB_CHUNK_REPAIR"/>), which
identifies the file, the affected ranges (each with its own
triggering nfsstat4), and a wall-clock deadline.  A client that
receives CB_CHUNK_REPAIR for a file for which it does not
already hold a layout <bcp14>MUST</bcp14> acquire a layout via LAYOUTGET before
attempting the repair.</t>
          <t>Operational expectations for CB_CHUNK_REPAIR:
CB_CHUNK_REPAIR is an exceptional path, triggered only by
concurrent writer races or data-server failures.  It is not a
steady-state operation and its frequency is a function of
racing-writer and data-server-failure rates in the deployment
rather than of normal client workload.  Implementations <bcp14>SHOULD</bcp14>
treat the CB_CHUNK_REPAIR handler as rare-path code and avoid
over-optimizing it.  Implementations <bcp14>SHOULD</bcp14>, however, provision
enough client-side compute to handle a repair transaction
without stalling their foreground I/O, because foreground
throughput during repair is the externally observable cost of
this callback.</t>
        </section>
        <section anchor="repair-protocol-normative-vs-informative">
          <name>Repair Protocol: Normative vs. Informative</name>
          <t>The selection algorithm is non-normative and deployment-tunable.
The externally-observable state transitions of the repair flow
are normative.  The line between the two is drawn at what
another party on the wire -- the metadata server, another
client, a reader -- can observe.  What no other party can see
(client-internal ordering, retry policy, whether to CHUNK_READ
first to confirm the failure) is left to implementations.</t>
          <t>The following requirements are normative.  An implementation
that violates any of these can leak inconsistency or write-holes
into the cluster:</t>
          <dl>
            <dt>Final state flat:</dt>
            <dd>
              <t>Every shard in every range identified
in a CB_CHUNK_REPAIR <bcp14>MUST</bcp14> reach either the COMMITTED state
(repaired) or the EMPTY state (rolled back).  No shard is
left in PENDING or FINALIZED indefinitely.</t>
            </dd>
            <dt>Lock before write:</dt>
            <dd>
              <t>The repair actor <bcp14>MUST</bcp14> adopt the
lock on every affected range via CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT (<xref target="sec-CHUNK_LOCK"/>) before issuing
any CHUNK_WRITE_REPAIR, CHUNK_ROLLBACK, or CHUNK_WRITE on a
chunk in that range.  The lock on the affected chunks is
held continuously from the failure that triggered
CB_CHUNK_REPAIR through the adoption; at no point is the
range unlocked.</t>
            </dd>
            <dt>Clear the errored state:</dt>
            <dd>
              <t>On the reconstruction path,
the repair actor <bcp14>MUST</bcp14> issue CHUNK_REPAIRED after CHUNK_COMMIT.  Without it,
readers continue to see holes regardless of on-disk state.</t>
            </dd>
            <dt>Release locks explicitly:</dt>
            <dd>
              <t>CHUNK_ROLLBACK does not
release chunk locks.  On the rollback path the client <bcp14>MUST</bcp14>
issue CHUNK_UNLOCK on each affected
chunk.  A client that walks away without either completing
CHUNK_REPAIRED or issuing CHUNK_UNLOCK holds the locks
until lease expiry, blocking progress for other writers.</t>
            </dd>
            <dt>Deadline honored:</dt>
            <dd>
              <t>The client <bcp14>MUST</bcp14> drive every range to
its final flat state before ccra_deadline, or <bcp14>MUST</bcp14> respond
to the CB_CHUNK_REPAIR with NFS4ERR_DELAY (requesting an
extension), NFS4ERR_ENCODING_NOT_SUPPORTED (declining), or
NFS4ERR_PAYLOAD_LOST (declaring the data unrecoverable).
A deadline that elapses without any of these leaves the
metadata server free to re-select; the client <bcp14>MUST NOT</bcp14>
continue repair-related CHUNK operations after the
deadline without first re-verifying its layout and the
chunk lock state.</t>
            </dd>
            <dt>Terminal return codes:</dt>
            <dd>
              <t>NFS4ERR_ENCODING_NOT_SUPPORTED
<bcp14>MUST</bcp14> mean "decline; select another client."
NFS4ERR_PAYLOAD_LOST <bcp14>MUST</bcp14> mean "the data is not
recoverable; do not retry."  The metadata server relies on
these to decide whether to re-issue.</t>
            </dd>
          </dl>
          <t>The following aspects are informative / implementation-defined:</t>
          <ul spacing="normal">
            <li>
              <t>Choice between the reconstruction path (CHUNK_WRITE_REPAIR)
and the rollback path (CHUNK_ROLLBACK) on a given range.  The
protocol <bcp14>MUST</bcp14> support both; the client <bcp14>MAY</bcp14> use either based
on its local state and whether reconstruction is feasible
from surviving shards.</t>
            </li>
            <li>
              <t>Ordering among multiple affected ranges in a single
CB_CHUNK_REPAIR (parallel or serial).</t>
            </li>
            <li>
              <t>Whether to issue CHUNK_READ to confirm the failure mode
before reconstructing.</t>
            </li>
            <li>
              <t>Retry policy on transient CHUNK_WRITE_REPAIR errors below the
deadline cutoff.</t>
            </li>
            <li>
              <t>How the repair status is surfaced to local filesystem API
callers.</t>
            </li>
          </ul>
        </section>
        <section anchor="carrying-out-the-repair">
          <name>Carrying Out the Repair</name>
          <t>With the normative framing above, the reconstruction path is:</t>
          <ol spacing="normal" type="1"><li>
              <t>CHUNK_LOCK with CHUNK_LOCK_FLAGS_ADOPT on each affected
range (<xref target="sec-CHUNK_LOCK"/>).</t>
            </li>
            <li>
              <t>CHUNK_WRITE_REPAIR with the
reconstructed data for each non-atomic shard.  The
client's chunk_owner4 on this and all subsequent operations
is the one it presented in the CHUNK_LOCK ADOPT above;
prior owners' generation ids are now historical.</t>
            </li>
            <li>
              <t>CHUNK_FINALIZE and CHUNK_COMMIT to persist the repaired shards.</t>
            </li>
            <li>
              <t>CHUNK_REPAIRED to clear the
errored state.</t>
            </li>
          </ol>
          <t>The rollback path, when reconstruction is not possible:</t>
          <ol spacing="normal" type="1"><li>
              <t>CHUNK_LOCK with CHUNK_LOCK_FLAGS_ADOPT on each affected
range.</t>
            </li>
            <li>
              <t>CHUNK_ROLLBACK on each affected
shard to restore the previously committed content.</t>
            </li>
            <li>
              <t>CHUNK_UNLOCK on each shard.</t>
            </li>
          </ol>
          <t>In both paths, the repair actor <bcp14>SHOULD</bcp14> target reconstructed
shards according to the following fallback order: first, any
data server in the layout carrying FFV2_DS_FLAGS_REPAIR; then
the data server that reported the failure (the one carrying the
failing shard at the range identified by ccr_offset and ccr_count
in the CB_CHUNK_REPAIR argument).  If neither is available, the
client <bcp14>MUST</bcp14> return NFS4ERR_PAYLOAD_LOST on the CB_CHUNK_REPAIR
response; the metadata server is then responsible for adding a
new REPAIR-flagged data server to the layout (drawn from its
out-of-band pool) and re-driving the repair.</t>
          <section anchor="single-writer-mode">
            <name>Single Writer Mode</name>
            <t>In single writer mode, the metadata server sets FFV2_FLAGS_ONLY_ONE_WRITER
in ffv2l_flags, indicating that no other client holds a write layout for
the file.  The client sends CHUNK_WRITE with cwa_guard.cwg_check set to
FALSE, omitting the guard value.  Because only one writer is active,
there is no risk of two clients overwriting the same chunk concurrently.</t>
            <t>The single writer write sequence is:</t>
            <ol spacing="normal" type="1"><li>
                <t>The client issues CHUNK_WRITE (cwa_guard.cwg_check = FALSE) for each
shard.  The data server places the written block in the PENDING state
and retains a copy of the previous block for rollback.</t>
              </li>
              <li>
                <t>The client issues CHUNK_FINALIZE to advance the blocks from PENDING
to FINALIZED, validating the per-block checksum.</t>
              </li>
              <li>
                <t>The client issues CHUNK_COMMIT to advance the blocks from FINALIZED
to COMMITTED, persisting the block metadata to stable storage.</t>
              </li>
            </ol>
            <t>If the client detects an error after CHUNK_WRITE but before CHUNK_FINALIZE
(e.g., a CRC mismatch on a subsequent CHUNK_READ), it issues CHUNK_ROLLBACK
to restore the previous block content.  CHUNK_ROLLBACK does not lock the
chunk; the next CHUNK_WRITE is permitted immediately.</t>
          </section>
          <section anchor="repairing-single-writer-payloads">
            <name>Repairing Single Writer Payloads</name>
            <t>In single writer mode, non-atomic blocks arise from a client or data
server failure during a CHUNK_WRITE / CHUNK_FINALIZE sequence.  Because
no other writer is active, the original writer is the typical choice
for repair, but the metadata server <bcp14>MAY</bcp14> designate any client according
to the rules in <xref target="sec-repair-selection"/>.  A designated client that
did not originate the writes <bcp14>MUST</bcp14> follow the rollback path of that
section if it cannot reconstruct the payload from surviving shards.</t>
            <t>The repair sequence when the selected client is the original writer is:</t>
            <ol spacing="normal" type="1"><li>
                <t>The repair actor issues CHUNK_READ to identify which blocks are in a
failed state (PENDING with a CRC mismatch, or in the errored state
set by a prior CHUNK_ERROR).</t>
              </li>
              <li>
                <t>For each errored chunk, the repair actor reconstructs the correct
data using the erasure coding algorithm from the surviving atomic
chunks (treating each chunk's payload as a shard of the stripe).</t>
              </li>
              <li>
                <t>The repair actor issues CHUNK_WRITE_REPAIR
to write the reconstructed data.  CHUNK_WRITE_REPAIR bypasses the guard
check and applies different data server policies (e.g., allowing writes
to blocks in the errored state).</t>
              </li>
              <li>
                <t>The repair actor issues CHUNK_FINALIZE and CHUNK_COMMIT to persist the
repaired blocks.</t>
              </li>
              <li>
                <t>The repair actor issues CHUNK_REPAIRED to
clear the errored state and make the blocks available for normal reads.</t>
              </li>
            </ol>
          </section>
          <section anchor="sec-swm-to-mwm">
            <name>Transitioning from Single Writer Mode to Multiple Writer Mode</name>
            <t>When a second writer requests a write layout for a file currently
covered by a single writer layout (FFV2_FLAGS_ONLY_ONE_WRITER set),
the metadata server recalls the existing layout before granting
the new request.  The sequence is:</t>
            <ol spacing="normal" type="1"><li>
                <t>The metadata server issues CB_LAYOUTRECALL to the single writer
client.</t>
              </li>
              <li>
                <t>The single writer client drains its outstanding I/O issued
under the single writer assumption (CHUNK_WRITE with
cwa_guard.cwg_check = FALSE).  Operations already underway
complete under the layout that authorized them: CHUNK_FINALIZE
and CHUNK_COMMIT proceed normally for blocks already written.</t>
              </li>
              <li>
                <t>Once drained, the single writer client issues LAYOUTRETURN.</t>
              </li>
              <li>
                <t>The metadata server grants the new writer a layout without
FFV2_FLAGS_ONLY_ONE_WRITER set.  When the original writer next
issues LAYOUTGET, it also receives a layout without the flag.
Both clients then operate in multiple writer mode
(<xref target="sec-multi-writer"/>), supplying cwa_guard.cwg_check = TRUE
and a chunk_guard4 on every CHUNK_WRITE.</t>
              </li>
            </ol>
            <t>The transition uses standard NFSv4.1 layout recall semantics
(<xref section="12.5.5" sectionFormat="of" target="RFC8881"/>).  Drained single writer I/O does
not need to be re-issued under multiple writer rules; it
completed under the layout that authorized it.  If the
single writer client fails to return the layout within the
recall window, the metadata server escalates to layout
revocation (<xref section="12.5.5.2.1" sectionFormat="of" target="RFC8881"/>); any single writer
writes that did not complete before revocation are repaired via
the multiple-writer repair path on subsequent access.</t>
          </section>
          <section anchor="sec-multi-writer">
            <name>Multiple Writer Mode</name>
            <t>In multiple writer mode, the metadata server does not set
FFV2_FLAGS_ONLY_ONE_WRITER, indicating that concurrent writers may hold
write layouts for the file.  The client sends CHUNK_WRITE with
cwa_guard.cwg_check set to TRUE, supplying the expected prior
chunk_guard4 in cwa_guard.cwg_guard so the data server can perform
per-chunk CAS.  The client obtains the expected prior chunk_guard4
by observing the chunk's current guard first: either cr_guard from
CHUNK_READ when the payload is also required,
or the corresponding chrr_guards entry from CHUNK_HEADER_READ when only the guard is needed.  The
write transaction is separately identified by the cohort pair
<tt>(cwa_cohort_id, cwa_client_id)</tt> supplied on the same CHUNK_WRITE.</t>
            <t>The multiple writer write sequence is:</t>
            <ol spacing="normal" type="1"><li>
                <t>The client selects a unique cohort pair <tt>(cwa_cohort_id,
cwa_client_id)</tt> for this transaction.  cwa_client_id is the client's
layout-granted ffv2m_client_id (see <xref target="sec-ffv2-mirror4"/>); the
cwa_cohort_id is a per-writer opaque identifier the client picks
distinct per transaction.</t>
              </li>
              <li>
                <t>The client issues CHUNK_WRITE (cwa_guard.cwg_check = TRUE) for each
chunk.  The data server checks that no other client's chunk is in the
PENDING state at this offset.  If another client's chunk is already
pending, the data server returns NFS4ERR_CHUNK_LOCKED with the
clr_owner field identifying the lock holder.</t>
              </li>
              <li>
                <t>On NFS4ERR_CHUNK_LOCKED, the client <bcp14>MUST</bcp14> back off.  It issues
CHUNK_ROLLBACK for any chunks it has already written in this
transaction, then retries after a delay.</t>
              </li>
              <li>
                <t>If all CHUNK_WRITEs succeed, the client issues CHUNK_FINALIZE and
CHUNK_COMMIT as in single writer mode.</t>
              </li>
            </ol>
            <t>The cohort pair ensures that the chunks carrying the shards of an
atomic erasure-coded stripe all carry the same
<tt>(co_cohort_id, co_client_id)</tt>.  A reader that encounters chunks with
different cohort pairs knows the stripe is not yet atomic and <bcp14>MUST</bcp14>
either retry or report NFS4ERR_PAYLOAD_NOT_ATOMIC.</t>
          </section>
          <section anchor="sec-repair-multi-writer">
            <name>Repairing Multiple Writer Payloads</name>
            <t>In multiple writer mode, non-atomic chunks can arise from two sources:
a client failure leaving some chunks in PENDING state, or two clients
writing different data to the same chunk before one has committed.</t>
            <t>The metadata server coordinates repair by designating a repair
client according to the rules in <xref target="sec-repair-selection"/>.  The
FFV2_DS_FLAGS_REPAIR flag, when present on a data server in the
layout, identifies the target data server into which reconstructed
shards should be written; it does not by itself identify the
repair actor.  The repair sequence is:</t>
            <ol spacing="normal" type="1"><li>
                <t>The repair actor issues CHUNK_LOCK on the
affected block range of each data server.  If any lock attempt returns
NFS4ERR_CHUNK_LOCKED, the repair actor records the existing lock
holder's chunk_owner4 and proceeds; the lock holder's data is a
candidate for the winning payload.</t>
              </li>
              <li>
                <t>The repair actor issues CHUNK_READ on all data servers to retrieve
the current payload.  It examines the chunk_owner4 of each shard to
identify which transaction (if any) produced a atomic set across
all k data shards.</t>
              </li>
              <li>
                <t>If a atomic set is found (all k data shards carry the same
chunk_guard4), that payload is the winner.  The repair actor issues
CHUNK_WRITE_REPAIR to copy the winner's data to any data servers whose
shard is non-atomic, followed by CHUNK_FINALIZE and CHUNK_COMMIT.</t>
              </li>
              <li>
                <t>If no atomic set exists (all available payloads are partial), the
repair actor selects one transaction's payload as authoritative
(typically the one with the most complete set of shards, or the most
recent cg_gen_id) and proceeds as above.</t>
              </li>
              <li>
                <t>After all data servers carry atomic, finalized, committed data, the
repair actor issues CHUNK_REPAIRED to clear the errored state and
CHUNK_UNLOCK to release the locks acquired in step 1.</t>
              </li>
              <li>
                <t>The repair actor reports success to the metadata server via
LAYOUTRETURN.</t>
              </li>
            </ol>
          </section>
          <section anchor="sec-mwm-to-swm">
            <name>Transitioning from Multiple Writer Mode to Single Writer Mode</name>
            <t>The reverse transition is optional.  When the metadata server
determines that only one writer holds a write layout for a file
(for example, because other writers' layouts have been returned or
their leases have expired), it <bcp14>MAY</bcp14> recall the remaining writer's
layout and grant a fresh layout with FFV2_FLAGS_ONLY_ONE_WRITER
set, restoring the single writer optimization.  The metadata
server <bcp14>MAY</bcp14> also leave the writer in multiple writer mode
indefinitely; single writer mode is an optimization, not a
correctness requirement.</t>
            <t>The metadata server's choice of when to grant
FFV2_FLAGS_ONLY_ONE_WRITER is policy and is implementation-defined.
A metadata server that aggressively grants single writer mode and
then must recall it each time a second writer appears can produce
recall churn under workloads with irregular concurrent access:
each single writer to multiple writer transition costs a
CB_LAYOUTRECALL round trip and drain time for in-flight I/O.
Strategies to limit churn include withholding
FFV2_FLAGS_ONLY_ONE_WRITER until sustained single writer behavior
is observed, deferring the single writer grant after a recent
recall, or never granting single writer mode for files with a
history of concurrent access.</t>
          </section>
        </section>
        <section anchor="sec-reading-chunks">
          <name>Reading Chunks</name>
          <t>The client reads chunks from the data file via CHUNK_READ.  The
number of chunks in the payload that need to be atomic depend
on both the Erasure Encoding Type and the level of protection selected.
If the client has enough atomic chunks in the payload, then it
can proceed to use them to build a data block.  If it does not have
enough atomic chunks in the payload, then it can either decide
to return a LAYOUTERROR of NFS4ERR_PAYLOAD_NOT_ATOMIC to the
metadata server or it can retry the CHUNK_READ until there are
enough atomic chunks in the payload.</t>
          <t>As another client might be writing to the chunks as they are being
read, it is entirely possible to read the chunks while they are not
atomic.  As such, it might even be the non-atomic chunks
which contain the new data and a better action than building the
data block is to retry the CHUNK_READ to see if new chunks are
overwritten.</t>
        </section>
        <section anchor="whole-file-repair">
          <name>Whole File Repair</name>
          <t>Whole-file repair is the case in which too many data servers have
failed, or too many chunks have been lost, for the per-range repair
flow defined in <xref target="sec-repair-selection"/> to reconstruct the file in
place.  In this case the metadata server <bcp14>MUST</bcp14> either:</t>
          <ol spacing="normal" type="1"><li>
              <t>Construct a new layout backed by replacement data servers and
drive the reconstruction via the proxy server mechanism (a
designated data server acts as the source of truth for client
I/O during the transition, pushing reconstructed content to the
replacement data servers in the background).  The proxy server mechanism also covers the non-repair cases where a file's layout
must change while remaining available to clients -- policy-driven layout transitions, data server maintenance evacuation,
administrative ingest, TLS coverage transition, and
filehandle-backend migration.</t>
            </li>
            <li>
              <t>If the metadata server has no proxy server capable data server
available, or the surviving shards are insufficient to
reconstruct any portion of the file, terminate the affected
byte ranges with NFS4ERR_PAYLOAD_LOST (see
<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>).</t>
            </li>
          </ol>
          <t>Implementations that do not support the proxy server mechanism can
still perform recovery for cases where per-range repair suffices,
using CB_CHUNK_REPAIR and the repair
client selection rules in <xref target="sec-repair-selection"/>.  Such
implementations will surface NFS4ERR_PAYLOAD_LOST on any failure
that exceeds per-range repair's reach, including the multi-data-server failure scenarios the proxy server mechanism is intended to
handle.</t>
        </section>
      </section>
      <section anchor="mixing-of-encoding-types">
        <name>Mixing of Encoding Types</name>
        <t>Multiple encoding types can be present in a Flexible File Version 2
Layout Type layout.  The ffv2_layout4 has an array of ffv2_mirror4,
each of which has a ffv2_encoding_type4.  Mixing encoding types in a single file's mirror set addresses
several use cases:</t>
        <dl>
          <dt>Assimilation and export:</dt>
          <dd>
            <t>assimilation of a non-erasure-coded file into an
erasure-coded representation, or export of an erasure-coded
file to a non-erasure-coded representation.</t>
          </dd>
          <dt>Online migration between encodings:</dt>
          <dd>
            <t>for example, from a Reed-Solomon Vandermonde encoding to a
Mojette systematic encoding when a read-access-pattern change
makes the new encoding a better fit.  Both representations
remain addressable through the layout throughout the
transition.</t>
          </dd>
          <dt>Cross-encoding recovery:</dt>
          <dd>
            <t>when one encoding loses data to a correlated failure mode
(an encoding implementation bug, a memory-corruption pattern
that affects parity shards identically), a second mirror in
a different encoding provides an independent recovery
path.</t>
          </dd>
          <dt>Client-capability routing:</dt>
          <dd>
            <t>a proxy server sees the full mirror set and chooses between
encodings on behalf of clients that do not implement every
encoding the file is represented in.</t>
          </dd>
        </dl>
        <t>Consider a layout that exposes a file in two encodings
simultaneously: a PASSTHROUGH mirror over the original byte
stream and a Reed-Solomon Vandermonde
(FFV2_ENCODING_RS_VANDERMONDE) mirror with 4 active data shards
plus 2 parity data servers.  A layout for such a
file might appear as in <xref target="fig-example_mixing"/>.  Both
representations are active and addressable through the layout
simultaneously.  This is the transition-window pattern: a file
may transiently span encodings while it is being assimilated
from a non-flexible-file-v2 source or migrated between
encodings.  Steady
state is homogeneous; the multi-encoding window is what the
protocol must accommodate.</t>
        <t>The active mirrors serve different access patterns concurrently:</t>
        <ul spacing="normal">
          <li>
            <t>A client that speaks only the file-layout READ path issues
READ (<xref section="18.22" sectionFormat="of" target="RFC8881"/>) calls to index 0 (the
PASSTHROUGH mirror).</t>
          </li>
          <li>
            <t>A client that speaks the chunked path issues CHUNK_READ calls to index 1 (the RS_VANDERMONDE
mirror).</t>
          </li>
          <li>
            <t>A proxy server fronting legacy clients chooses between the two
encodings on the client's behalf.</t>
          </li>
        </ul>
        <t>All three patterns coexist during the transition.</t>
        <figure anchor="fig-example_mixing">
          <name>Example of Mixed Encoding Types in a Layout</name>
          <sourcecode type="art"><![CDATA[
 +-----------------------------------------------------+
 | ffv2_layout4:                                       |
 +-----------------------------------------------------+
 |     ffv2l_mirrors[0]:                               |
 |         ffv2s_data_servers:                         |
 |             ffv2_data_server4[0]                    |
 |                 ffv2ds_flags: 0                     |
 |         ffv2m_coding: FFV2_ENCODING_PASSTHROUGH     |
 +-----------------------------------------------------+
 |     ffv2l_mirrors[1]:                               |
 |         ffv2s_data_servers:                         |
 |             ffv2_data_server4[0]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_ACTIVE  |
 |             ffv2_data_server4[1]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_ACTIVE  |
 |             ffv2_data_server4[2]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_ACTIVE  |
 |             ffv2_data_server4[3]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_ACTIVE  |
 |             ffv2_data_server4[4]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_PARITY  |
 |             ffv2_data_server4[5]                    |
 |                 ffv2ds_flags: FFV2_DS_FLAGS_PARITY  |
 |     ffv2m_coding: FFV2_ENCODING_RS_VANDERMONDE      |
 +-----------------------------------------------------+
]]></sourcecode>
        </figure>
        <t>When performing I/O via a FFV2<em>ENCODING_PASSTHROUGH encoding type,
the non-transformed data will be used; whereas with any of the
chunked encoding types (any FFV2_ENCODING</em>* value other than
FFV2_ENCODING_PASSTHROUGH; see <xref target="tbl-coding-types"/>), a metadata
header and transformed block will be sent.  Further, when reading data from the
instance files, the client <bcp14>MUST</bcp14> be prepared to have one of the
encoding types supply data and the other type not to supply data.
I.e., the CHUNK_READ call to the data servers in mirror 1 might
return rlr_eof set to true (see <xref target="fig-read_chunk4"/>), which
indicates that there is no data, where the READ call to the
data server in mirror 0 might return eof to be false, which
indicates that there is data.  The client <bcp14>MUST</bcp14> determine that
there is in fact data.  An example use case is the active
assimilation of a file to ensure integrity.  As the client is
helping to translate the file to the new coding scheme, it is
actively modifying the file.  As such, it might be sequentially
reading the file in order to translate.  The READ calls to
mirror 0 would be returning data and the CHUNK_READ calls to
mirror 1 would not be returning data.  As the client overwrites
the file, the WRITE call and CHUNK_WRITE call would have data
sent to all of the data servers.  Finally, if the client reads
back a section which had been modified earlier, both the READ
and CHUNK_READ calls would return data.</t>
        <t>The two-mirror layout shown in <xref target="fig-example_mixing"/> is the
file's full mirror set as known to the metadata server.  A
client that arrives during the assimilation or migration window
above does not necessarily receive that layout; per the
proxy server draft, the client gets a single layout naming the
proxy server as a single endpoint, and the proxy server selects
which of the file's
mirrors to read from or write to on the client's behalf.  The
two-mirror view in this section describes the metadata server's
bookkeeping during the transition; the client directs its I/O
to a single endpoint.</t>
        <section anchor="sec-steady-state-heterogeneous">
          <name>Steady-state heterogeneous mirrors</name>
          <t>The transition-window patterns above (assimilation, migration,
repair) are the most visible motivations for heterogeneous
mirror sets, but they are not the only ones.  A file's mirror
set <bcp14>MAY</bcp14> be heterogeneous in steady state -- where no transition
is in progress and no transition is planned -- when the
deployment's storage pools have different encoding capabilities
and the file is too large to fit in any single pool.</t>
          <t>Consider an operator with three 100-TB storage pools.  Pool A
is a set of NFSv3-only data servers, which is a hard capability
constraint: the chunked encodings require NFSv4.2's CHUNK
operations, so an NFSv3-only pool can hold data only under an
FFV2_ENCODING_PASSTHROUGH mirror.  Pools B and C are NFSv4.2
data servers, which are encoding-agnostic at the wire level
(CHUNK_READ and CHUNK_WRITE just move opaque chunk payloads;
the encoding transform is client-side).  The operator, however,
has chosen to write Pool B under FFV2_ENCODING_RS_VANDERMONDE
and Pool C under FFV2_ENCODING_MOJETTE_SYSTEMATIC -- a policy
decision motivated by durability diversity (hedging against a
correlated failure in any single encoder implementation) and by
per-workload fit (each encoding's reconstruction cost and
failure-tolerance profile suits a different tenant on that pool).</t>
          <t>A 250-TB file cannot fit in any single pool.  Striping the file
across all three pools is forced by capacity arithmetic: 250 &gt;
100.  Because bytes in each pool were written under the pool's
chosen encoding, the layout for this file <bcp14>MUST</bcp14> name the actual
per-mirror <tt>ffv2_encoding_type4</tt> so that clients decode each
segment correctly: PASSTHROUGH for the Pool A segment,
RS_VANDERMONDE for the Pool B segment, MOJETTE_SYSTEMATIC for
the Pool C segment.  The heterogeneity is not a transition
window; it is the permanent consequence of striping across
pools whose bytes were written under different operator-chosen
encodings.</t>
          <t>In this steady-state case, no proxy server mediated transition
machinery is involved.  The client receives a layout
enumerating the mirrors at different <tt>ffv2m_coding</tt> values and
routes chunk operations to the appropriate data server per
segment (or, if the client cannot speak one of the encodings,
requests proxy mediation per the proxy server draft's section
"Encoding Translation for Encoding-Ignorant Clients"
(<xref target="I-D.haynes-nfsv4-flexfiles-v2-proxy-server"/>)).  The layout
machinery that supports this case is exactly the per-mirror
encoding naming primitive described above; no additional protocol
elements are required to express it.</t>
          <t>The transient case (one file moving between encodings) and the
steady-state case (one file permanently striped across
heterogeneous pools) share a single wire primitive: an
<tt>ffv2l_mirrors</tt> array that admits mixed <tt>ffv2_encoding_type4</tt>
values.  Removing that primitive would foreclose both cases
and would force one of three workarounds: (a) split the
250-TB file into three independently-named files (loses
single-namespace semantics), (b) require every pool to
implement every encoding (forces a single-vendor or
single-implementation procurement story), or (c) require an
always-on transcoding proxy in front of every read and write
(re-introduces the centralized data-plane that the
proxy server role is scoped to avoid in steady state).  None
of these alternatives address the steady-state case while
preserving the transition-window flexibility this document
specifies.</t>
        </section>
      </section>
      <section anchor="sec-encoding-passthrough">
        <name>FFV2_ENCODING_PASSTHROUGH</name>
        <t>FFV2_ENCODING_PASSTHROUGH is the on-ramp from the flexible file v1 layout (<xref target="RFC8435"/>)
into the flexible file v2 layout.  A PASSTHROUGH mirror points at the
file's bytes as they exist on the data server, without the
chunk envelope, checksum header, or chunk_guard4 fields that the
encoded types use.  Client I/O against a PASSTHROUGH mirror
uses NFSv3 WRITE / READ (<xref target="RFC1813"/>) or NFSv4 READ / WRITE
(<xref target="RFC8881"/>) directly -- not CHUNK_WRITE / CHUNK_READ.</t>
        <t>PASSTHROUGH provides:</t>
        <ul spacing="normal">
          <li>
            <t>Replication of data across N data servers, exactly as flexible file v1 layout
does.  Clients write to every replica; clients read from any
one.  N-way redundancy tolerates up to N-1 replica losses.</t>
          </li>
          <li>
            <t>Zero encoding compute at the client and zero chunk-metadata
overhead at the server.  The on-disk format is the file
itself.</t>
          </li>
          <li>
            <t>Compatibility with files that already exist outside flexible file v2 layout.
A PASSTHROUGH mirror can be created over an existing
file without rewriting it.</t>
          </li>
        </ul>
        <t>PASSTHROUGH does NOT provide:</t>
        <ul spacing="normal">
          <li>
            <t>Per-chunk integrity.  There is no checksum on the data path.
Silent corruption is undetectable without out-of-band
tooling (e.g., comparing checksums across replicas).</t>
          </li>
          <li>
            <t>Chunk-grained repair.  The repair unit is the whole file:
resilvering picks a trusted replica and replicates it end
to end to the affected replica(s).</t>
          </li>
          <li>
            <t>The concurrent writer disambiguation that chunk_guard4
provides for encoded types.</t>
          </li>
        </ul>
        <t>PASSTHROUGH is <bcp14>RECOMMENDED</bcp14> for the assimilation, migration, and
heterogeneous-mirror use cases described in
<xref target="sec-heterogeneous-mirrors"/>.  New deployments that do not
need a flexible file v1 layout on-ramp <bcp14>SHOULD</bcp14> use FFV2_ENCODING_REPLICATED for
the integrity guarantees described in
<xref target="sec-encoding-replicated"/>.</t>
      </section>
      <section anchor="sec-encoding-replicated">
        <name>FFV2_ENCODING_REPLICATED</name>
        <t>FFV2_ENCODING_REPLICATED is the chunked-with-integrity peer of
PASSTHROUGH.  The chunk produced for each replica is the
application data verbatim -- no transform, no parity shards --
but it travels on the wire and is stored on the data server
through CHUNK_WRITE / CHUNK_READ and so carries every integrity
property the encoded encoding types carry.</t>
        <t>What FFV2_ENCODING_REPLICATED keeps from the mirror model:</t>
        <ul spacing="normal">
          <li>
            <t>Zero encoding compute at the client.  Each replica's chunk is
the input bytes; there is no transform to apply on write and
nothing to decode on read.</t>
          </li>
          <li>
            <t>Storage cost of N x payload, where N is the replica count.
Mirroring trades storage for redundancy without the
reconstruction machinery that erasure coding requires.</t>
          </li>
          <li>
            <t>Reading any one intact replica is sufficient.  If a replica
fails to verify (see below), the client tries another.</t>
          </li>
        </ul>
        <t>What FFV2_ENCODING_REPLICATED adds beyond PASSTHROUGH, by virtue
of using CHUNK_WRITE and CHUNK_READ:</t>
        <ul spacing="normal">
          <li>
            <t>Per-chunk checksum on write and on read.  The CRC is computed
by the client over the chunk header and chunk payload with
the checksum field itself treated as zero
(<xref target="sec-checksum4"/>), sent on the wire with the chunk,
recomputed by the data server before storing, and
recomputed again from disk by the data server on every
CHUNK_READ.  Wire-level bit flips are caught before the
chunk is stored; on-disk bit rot is caught the next time
the chunk is read.</t>
          </li>
          <li>
            <t>Per-chunk repair granularity.  When one replica's CRC fails
to verify and another replica's verifies, the repair unit
is the chunk, not the file: CHUNK_READ the good replica,
CHUNK_WRITE to the bad replica, done.  No whole-file
resilvering is required.</t>
          </li>
          <li>
            <t>Per-chunk concurrent writer disambiguation.  Mirrored
writes carry the same chunk_guard4 (<xref target="sec-chunk_guard4"/>)
the erasure encoding types do.  Two clients racing to write
the same offset of the same file fan out to every replica
with a guard pair (generation, owning-client short-id) per
chunk; the CHUNK_FINALIZE step resolves which writer's
chunk wins and the other writer observes a deterministic
loss instead of an unresolved split-mirror.</t>
          </li>
        </ul>
        <t>What FFV2_ENCODING_REPLICATED is for: files where the deployment
wants integrity and replication without the storage savings or
the reconstruction story of erasure coding.  Small files that
do not exceed a single stripe, files whose access pattern is
read-mostly and where the N x storage cost is acceptable, and
files where the operator prefers the simplicity of "any one
replica is the file" over "k of (k + m) shards reconstruct the
file."  The coding choice is per-file; a deployment can mix
mirrored and erasure-coded files in the same namespace and
pick whichever fits each file's profile.</t>
        <t>What FFV2_ENCODING_REPLICATED is not: a substitute for erasure
coding when storage efficiency or multi-replica fault tolerance
matters.  An N-way mirror tolerates up to N-1 replica losses
but costs N x the payload; a (k, m) erasure coding tolerates m
losses at (k + m)/k x the payload.  Both have per-chunk
integrity under this document; the choice is the
cost-vs-tolerance one.</t>
      </section>
      <section anchor="sec-encoding-xor-parity">
        <name>FFV2_ENCODING_XOR_PARITY</name>
        <section anchor="overview">
          <name>Overview</name>
          <t>FFV2_ENCODING_XOR_PARITY is a single-parity, systematic,
RAID-5-shape encoding: k data shards accompanied by one parity
shard computed as the bytewise XOR of every data shard.
Parameters: k in the range 1 to 254, m fixed at 1.</t>
          <t>Unlike Reed-Solomon and Linux md/raid6, XOR_PARITY requires no
finite-field arithmetic.  The "encoding" is a plain XOR
reduction across k shards, so the implementation footprint is
trivial and the compute cost scales at memory bandwidth.  This
makes XOR_PARITY the simplest candidate encoding: any
conformant implementation can support it without a GF(2^8)
library.</t>
        </section>
        <section anchor="encoding">
          <name>Encoding</name>
          <t>Given k data shards, each of shard_len bytes, encoding produces
a single parity shard of shard_len bytes:</t>
          <artwork><![CDATA[
For each byte position j in [0, shard_len):
  parity[j] = data[0][j] XOR data[1][j] XOR ... XOR data[k-1][j]
]]></artwork>
          <t>All shards (data and parity) are the same size.  No table
lookups, no multiplications; a straight bitwise XOR reduction.</t>
        </section>
        <section anchor="recovery">
          <name>Recovery</name>
          <t>XOR_PARITY tolerates the loss of exactly one shard (any one
data shard or the parity shard).</t>
          <ul spacing="normal">
            <li>
              <t>Missing data shard <tt>data[i]</tt>: reconstruct by XOR-ing all
surviving shards (k-1 data shards plus the parity shard):
<tt>data[i][j] = parity[j] XOR data[0][j] XOR ... (skip i) ... XOR data[k-1][j]</tt>.</t>
            </li>
            <li>
              <t>Missing parity shard: recompute from the k intact data
shards using the encoding step above.</t>
            </li>
          </ul>
          <t>Reconstruction cost is a single XOR reduction over shard_len
bytes; memory bandwidth dominates.  No matrix inversion is
required.</t>
          <t>Loss of two or more shards is unrecoverable under XOR_PARITY.
Deployments requiring tolerance of two or more concurrent
losses <bcp14>SHOULD</bcp14> use FFV2_ENCODING_LINUX_MD_RAID (m=2) or
FFV2_ENCODING_RS_VANDERMONDE (configurable m).</t>
        </section>
        <section anchor="interoperability">
          <name>Interoperability</name>
          <t>XOR_PARITY produces a parity shard byte-identical to the P
(first) parity row of Reed-Solomon Vandermonde encoding at m=1
and to the P row of Linux md/raid6, whose m is fixed at 2.
This follows from using the same primitive coefficients:</t>
          <ul spacing="normal">
            <li>
              <t>RS Vandermonde at m=1 uses parity row <tt>[1, 1, ..., 1]</tt> in
GF(2^8), which reduces to bitwise XOR (see
<xref target="sec-rs-encoding"/>).</t>
            </li>
            <li>
              <t>LINUX_MD_RAID's P row is defined as the bitwise XOR of every
data shard, identical to XOR_PARITY's parity by
construction.</t>
            </li>
          </ul>
          <t>A receiver capable of FFV2_ENCODING_RS_VANDERMONDE at m=1 or
FFV2_ENCODING_LINUX_MD_RAID therefore consumes an
XOR_PARITY-encoded chunk without re-encoding, provided the k
matches.  Conversely, an XOR_PARITY receiver consumes the P
row of any GF(2^8) family encoding at m &gt;= 1 unchanged.</t>
        </section>
        <section anchor="xorparity-interoperability-test-vectors">
          <name>XOR_PARITY Interoperability Test Vectors</name>
          <t>Concrete byte-level test vector with <tt>k = 3</tt>, <tt>m = 1</tt>,
<tt>shard_len = 1</tt>:</t>
          <table anchor="tbl-xor-parity-test-vector">
            <name>XOR_PARITY test vector: k=3, m=1</name>
            <thead>
              <tr>
                <th align="left">data[0]</th>
                <th align="left">data[1]</th>
                <th align="left">data[2]</th>
                <th align="left">parity</th>
                <th align="left">Notes</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">zero input</td>
              </tr>
              <tr>
                <td align="left">
                  <tt>0x01</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x01</tt></td>
                <td align="left">single non-zero data shard</td>
              </tr>
              <tr>
                <td align="left">
                  <tt>0x01</tt></td>
                <td align="left">
                  <tt>0x02</tt></td>
                <td align="left">
                  <tt>0x04</tt></td>
                <td align="left">
                  <tt>0x07</tt></td>
                <td align="left">0x01 XOR 0x02 XOR 0x04 = 0x07</td>
              </tr>
              <tr>
                <td align="left">
                  <tt>0x37</tt></td>
                <td align="left">
                  <tt>0x91</tt></td>
                <td align="left">
                  <tt>0xac</tt></td>
                <td align="left">
                  <tt>0x0a</tt></td>
                <td align="left">matches P from <xref target="tbl-rs-test-vector-k3m2"/></td>
              </tr>
              <tr>
                <td align="left">
                  <tt>0xff</tt></td>
                <td align="left">
                  <tt>0xff</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">
                  <tt>0x00</tt></td>
                <td align="left">0xff XOR 0xff XOR 0x00 = 0x00</td>
              </tr>
            </tbody>
          </table>
          <t>The fourth row is byte-identical to the P entry of the same
input in <xref target="tbl-rs-test-vector-k3m2"/> -- the wire-compat
property in action.</t>
        </section>
        <section anchor="xorparity-shard-sizes">
          <name>XOR_PARITY Shard Sizes</name>
          <t>All XOR_PARITY shards (data and parity) are exactly shard_len
bytes.  chunk_size equals shard_len for every mirror in the
layout.  Total storage overhead is <tt>1/k</tt> of payload.</t>
          <table anchor="tbl-xor-parity-shards">
            <name>XOR_PARITY shard sizes for common configurations</name>
            <thead>
              <tr>
                <th align="left">Configuration</th>
                <th align="left">File Size</th>
                <th align="left">Shard Size</th>
                <th align="left">Total Storage</th>
                <th align="left">Overhead</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">3+1</td>
                <td align="left">3 KB</td>
                <td align="left">1 KB</td>
                <td align="left">4 KB</td>
                <td align="left">33%</td>
              </tr>
              <tr>
                <td align="left">3+1</td>
                <td align="left">1 MB</td>
                <td align="left">~342 KB</td>
                <td align="left">~1.33 MB</td>
                <td align="left">33%</td>
              </tr>
              <tr>
                <td align="left">7+1</td>
                <td align="left">7 KB</td>
                <td align="left">1 KB</td>
                <td align="left">8 KB</td>
                <td align="left">14%</td>
              </tr>
              <tr>
                <td align="left">7+1</td>
                <td align="left">1 MB</td>
                <td align="left">~147 KB</td>
                <td align="left">~1.14 MB</td>
                <td align="left">14%</td>
              </tr>
            </tbody>
          </table>
        </section>
      </section>
      <section anchor="sec-encoding-linux-md-raid">
        <name>FFV2_ENCODING_LINUX_MD_RAID</name>
        <section anchor="overview-1">
          <name>Overview</name>
          <t>FFV2_ENCODING_LINUX_MD_RAID is the Linux kernel md/raid6 P + Q
double-parity encoding, evaluated in GF(2^8) with primitive
polynomial <tt>x^8 + x^4 + x^3 + x^2 + 1</tt> (encoded as <tt>0x1d</tt> when
the implicit degree-8 term is dropped, <tt>0x11d</tt> when it is
kept).  Parameters: k in the range 2 to 253, m fixed at 2.</t>
          <t>The encoding produces two parity shards.  P is the bitwise XOR
of every data shard (identical to FFV2_ENCODING_XOR_PARITY's
parity, see <xref target="sec-encoding-xor-parity"/>).  Q is a weighted sum
<tt>sum(g^i * data_i)</tt> in GF(2^8) with <tt>g = 2</tt>.  The construction
is bit-for-bit compatible with Linux kernel <tt>lib/raid6</tt>
            <xref target="LINUX-RAID6"/> and with FFV2_ENCODING_RS_VANDERMONDE at m&lt;=2
(see <xref target="sec-rs-encoding"/>).</t>
          <t>The k=1 case (a single data shard with P and Q) is degenerate
and <bcp14>MUST NOT</bcp14> be used with FFV2_ENCODING_LINUX_MD_RAID.  Callers
who need triple-mirror semantics <bcp14>MUST</bcp14> use
FFV2_ENCODING_REPLICATED with N=3 instead.</t>
        </section>
        <section anchor="linuxmdraid-galois-field-arithmetic">
          <name>LINUX_MD_RAID Galois Field Arithmetic</name>
          <t>All LINUX_MD_RAID operations are performed over GF(2^8), the
Galois field with 256 elements.  Each element is represented
as a byte.</t>
          <dl>
            <dt>Irreducible Polynomial:</dt>
            <dd>
              <t>The field is constructed using <tt>x^8 + x^4 + x^3 + x^2 + 1</tt>,
encoded as <tt>0x1d</tt> when the implicit x^8 term is dropped (Linux
md convention), or <tt>0x11d</tt> when it is kept (RS Vandermonde
convention in <xref target="sec-rs-encoding"/>).  Both encodings refer to
the same field; only the notation differs.</t>
            </dd>
            <dt>Primitive Element:</dt>
            <dd>
              <t><tt>g = 2</tt>.  Powers of <tt>g</tt> cycle through GF(2^8) \ {0} with
period 255.</t>
            </dd>
            <dt>Addition:</dt>
            <dd>
              <t>Bitwise XOR.</t>
            </dd>
            <dt>Multiplication:</dt>
            <dd>
              <t>Via log/antilog tables in the reference implementation, or
SIMD vector multiply in modern kernels.  See the Linux kernel
<tt>lib/raid6/{int.uc, sse2.c, altivec.uc, ...}</tt> sources
<xref target="LINUX-RAID6"/> for the canonical implementation.</t>
            </dd>
          </dl>
        </section>
        <section anchor="linuxmdraid-encoding">
          <name>LINUX_MD_RAID Encoding</name>
          <t>Given k data shards, each of shard_len bytes, encoding
produces two parity shards P and Q, each shard_len bytes:</t>
          <artwork><![CDATA[
For each byte position j in [0, shard_len):
  P[j] = data[0][j] XOR data[1][j] XOR ... XOR data[k-1][j]
  Q[j] =         1 * data[0][j]
           XOR   g * data[1][j]
           XOR g^2 * data[2][j]
           XOR ...
           XOR g^(k-1) * data[k-1][j]
]]></artwork>
          <t>where multiplication is in GF(2^8) and <tt>g = 2</tt>.  All shards
(data, P, and Q) are the same size.</t>
          <t>The P row is identical to FFV2_ENCODING_XOR_PARITY's parity by
construction; the two encodings share the P computation.  The
Q row is the m=2 P + Q construction from <xref target="sec-rs-encoding"/>,
and produces byte-identical output to
FFV2_ENCODING_RS_VANDERMONDE at m=2.</t>
        </section>
        <section anchor="linuxmdraid-recovery">
          <name>LINUX_MD_RAID Recovery</name>
          <t>LINUX_MD_RAID tolerates up to two concurrent shard losses (any
two of the k + 2 shards).</t>
          <dl>
            <dt>Single-shard failure:</dt>
            <dd>
              <t>If only P or only Q is missing, recompute from the k intact
data shards using the encoding step above.</t>
            </dd>
            <dt/>
            <dd>
              <t>If exactly one data shard <tt>data[i]</tt> is missing but both P
and Q are intact, prefer the P-only recovery (cheaper): XOR
all surviving shards (k-1 data plus P) to recover <tt>data[i]</tt>.</t>
            </dd>
            <dt>Dual-shard failure:</dt>
            <dd>
              <t>If two data shards are missing, use both P and Q to solve a
2x2 linear system in GF(2^8) per byte position.  See the Linux
kernel <tt>lib/raid6/recov.c</tt> for the canonical solver.</t>
            </dd>
            <dt/>
            <dd>
              <t>If one data shard and one parity shard are missing, first
recover the data shard using the intact parity row (as in the
single-shard case), then recompute the missing parity from the
reconstructed data.</t>
            </dd>
          </dl>
          <t>Loss of three or more shards is unrecoverable under
LINUX_MD_RAID.  Deployments requiring m &gt;= 3 fault tolerance
<bcp14>MUST</bcp14> use FFV2_ENCODING_RS_VANDERMONDE.</t>
        </section>
        <section anchor="linuxmdraid-interoperability">
          <name>LINUX_MD_RAID Interoperability</name>
          <t>FFV2_ENCODING_LINUX_MD_RAID is wire-compatible with
FFV2_ENCODING_RS_VANDERMONDE at m &lt;= 2 by construction: both
encoders emit byte-identical P and Q for the same (k, data)
input at m &lt;= 2.</t>
          <ul spacing="normal">
            <li>
              <t>At m = 1, LINUX_MD_RAID's P row equals RS_VANDERMONDE's m=1
parity and equals XOR_PARITY's parity (see
<xref target="sec-encoding-xor-parity"/>).</t>
            </li>
            <li>
              <t>At m = 2, LINUX_MD_RAID's P + Q equals RS_VANDERMONDE's m=2
P + Q rows byte-for-byte.</t>
            </li>
          </ul>
          <t>RS_VANDERMONDE joined the m &lt;= 2 wire-compat set as a
wire format revision in this document: its m &lt;= 2 parity rows
are the hand-crafted P/Q construction rather than the
normalized-Vandermonde bottom rows RS uses at m &gt;= 3.  See
<xref target="sec-rs-encoding"/> for the RS construction and its
interoperability parameters.</t>
          <t>A client implementing either LINUX_MD_RAID or RS_VANDERMONDE
at m &lt;= 2 can consume the other without re-encoding, provided
the (k, m) geometry matches.</t>
        </section>
        <section anchor="linuxmdraid-interoperability-test-vectors">
          <name>LINUX_MD_RAID Interoperability Test Vectors</name>
          <t>At <tt>m = 2</tt> the LINUX_MD_RAID P + Q construction produces
byte-identical output to FFV2_ENCODING_RS_VANDERMONDE for the
same input, so the two encodings share one test vector:
<xref target="tbl-rs-test-vector-k3m2"/>, computed with <tt>k = 3</tt>, <tt>m = 2</tt>,
<tt>shard_len = 1</tt>.  This is the wire-compat property in action:
an implementation whose LINUX_MD_RAID output matches those
bytes is producing the same wire encoding as RS_VANDERMONDE
at m=2.</t>
        </section>
        <section anchor="linuxmdraid-shard-sizes">
          <name>LINUX_MD_RAID Shard Sizes</name>
          <t>All LINUX_MD_RAID shards (data, P, Q) are exactly shard_len
bytes.  chunk_size equals shard_len for every mirror in the
layout.  Total storage overhead is <tt>2/k</tt> of payload.  The
worked configurations are those of RS_VANDERMONDE at m = 2:
see <xref target="tbl-rs-shards"/>.</t>
        </section>
      </section>
      <section anchor="sec-rs-encoding">
        <name>Reed-Solomon Vandermonde Encoding (FFV2_ENCODING_RS_VANDERMONDE)</name>
        <section anchor="overview-2">
          <name>Overview</name>
          <t>Reed-Solomon (RS) codes are Maximum Distance Separable codes:
for a (k + m, k) code, any k of the k + m encoded shards suffice to
recover the original data.  The code tolerates the simultaneous loss
of up to m shards.  <xref target="Plank97"/> is a tutorial treatment of RS
coding in RAID-like systems and is the recommended background
reading for implementers unfamiliar with the construction used
here.</t>
        </section>
        <section anchor="galois-field-arithmetic">
          <name>Galois Field Arithmetic</name>
          <t>All RS operations are performed over GF(2^8), the Galois field with
256 elements.  Each element is represented as a byte.</t>
          <dl>
            <dt>Irreducible Polynomial:</dt>
            <dd>
              <t>The field is constructed using the irreducible polynomial
x^8 + x^4 + x^3 + x^2 + 1 (0x11d in hexadecimal).  The primitive
element (generator) is g = 2, which has multiplicative order 255.</t>
            </dd>
            <dt>Addition:</dt>
            <dd>
              <t>Addition in GF(2^8) is bitwise XOR.</t>
            </dd>
            <dt>Multiplication:</dt>
            <dd>
              <t>Multiplication uses log/antilog tables.  For non-zero elements
a and b: a * b = exp(log(a) + log(b)), where the exp table is
doubled to 512 entries to avoid modular reduction on the index sum.</t>
            </dd>
          </dl>
          <t>These are the classical constructions from Berlekamp (1968) and
Peterson &amp; Weldon (1972).  The log/antilog table approach for GF(2^8)
multiplication predates all known patents on SIMD-accelerated GF
arithmetic.  Implementors considering SIMD acceleration of GF(2^8)
operations should be aware of US Patent 8,683,296 (StreamScale),
which covers certain SIMD-based GF multiplication techniques.</t>
        </section>
        <section anchor="encoding-matrix">
          <name>Encoding Matrix</name>
          <t>The systematic encoding matrix E has (k + m) rows and k columns.
The top k rows are always the k x k identity, so data shards pass
through unchanged.  The bottom m parity rows are chosen as
follows.</t>
          <section anchor="at-m-1-single-parity-row">
            <name>At m = 1: single parity row</name>
            <t>The single parity row is <tt>[1, 1, ..., 1]</tt>:</t>
            <artwork><![CDATA[
E[k][j] = 1    for j = 0, 1, ..., k-1
]]></artwork>
            <t>Encoded parity is the bitwise XOR of every data shard.  This
matches the P row of Linux md's RAID6 construction and the sole
parity row of FFV2_ENCODING_XOR_PARITY byte-for-byte; a receiver
that speaks either of those consumes RS_VANDERMONDE at m=1
without re-encoding.</t>
          </section>
          <section anchor="at-m-2-p-q-parity-rows">
            <name>At m = 2: P + Q parity rows</name>
            <t>The two parity rows are:</t>
            <artwork><![CDATA[
E[k][j]     = 1              for j = 0, 1, ..., k-1   (P row)
E[k+1][j]   = g^j            for j = 0, 1, ..., k-1   (Q row)
]]></artwork>
            <t>where g = 2 is the primitive element of GF(2^8) with polynomial
0x11d.  These are exactly the coefficients Linux md RAID6 uses
for its P and Q shards.  A receiver that speaks
FFV2_ENCODING_LINUX_MD_RAID at m &lt;= 2 also consumes
RS_VANDERMONDE at m &lt;= 2 byte-for-byte (and vice versa).</t>
          </section>
          <section anchor="at-m-3-normalized-vandermonde-bottom-rows">
            <name>At m &gt;= 3: normalized Vandermonde bottom rows</name>
            <t>The parity rows are the bottom m rows of a normalized
Vandermonde encoding matrix, constructed as follows.</t>
            <ol spacing="normal" type="1"><li>
                <t>Assign each of the k + m shards a distinct non-zero evaluation
point in GF(2^8): shard i (for i = 0, 1, ..., k + m - 1) is assigned
the point alpha_i = i + 1.  This gives evaluation points
1, 2, ..., k + m, all non-zero and distinct.  The value k + m <bcp14>MUST
NOT</bcp14> exceed 255 so that all points fit in GF(2^8) \ {0}.</t>
              </li>
              <li>
                <t>Construct a (k + m) x k Vandermonde matrix V where the row for
shard i is the geometric progression of alpha_i:  </t>
                <artwork><![CDATA[
V[i][j] = alpha_i^j = (i + 1)^j    for j = 0, 1, ..., k-1
]]></artwork>
                <t>
Row i is (1, alpha_i, alpha_i^2, ..., alpha_i^(k-1)).  The
exponent zero is defined as <tt>x^0 = 1</tt> for all <tt>x</tt> in GF(2^8),
including x = 0 (this is the standard combinatorial
convention; here <tt>alpha_i</tt> is never zero by step 1's
construction, but the convention makes the <tt>V[0][0]</tt> cell
unambiguous).  Any k distinct rows form a k x k Vandermonde
matrix on k distinct non-zero evaluation points, which is
invertible over GF(2^8); this is the property that gives the
code its Maximum Distance Separable (any k of k + m shards
recover the data) guarantee.  The minimum useful geometry
is <tt>k &gt;= 1</tt> and <tt>m &gt;= 1</tt> (<tt>k = 0</tt> gives no data and <tt>m = 0</tt>
gives no redundancy); the maximum is bounded by <tt>k + m &lt;= 255</tt>
as stated in step 1.</t>
              </li>
              <li>
                <t>Extract the top k x k sub-matrix T from V.  T is the Vandermonde
on evaluation points alpha_0 = 1, alpha_1 = 2, ..., alpha_(k-1) = k.</t>
              </li>
              <li>
                <t>Compute T_inv = T^(-1) using Gaussian elimination in GF(2^8).</t>
              </li>
              <li>
                <t>Multiply: E = V * T_inv.  The result has an identity block on top
(rows 0 through k-1) and the parity generation matrix P on the
bottom (rows k through k + m - 1).</t>
              </li>
            </ol>
            <t>The identity block makes the code systematic: data shards pass through
unchanged, and only the parity sub-matrix P is needed during encoding.
These bottom rows do not match any external encoding at m &gt;= 3;
this encoding stands on its own at m &gt;= 3.</t>
          </section>
        </section>
        <section anchor="encoding-1">
          <name>Encoding</name>
          <t>Given k data shards, each of shard_len bytes, encoding produces m
parity shards, each also shard_len bytes:</t>
          <artwork><![CDATA[
For each byte position j in [0, shard_len):
  For each parity shard i in [0, m):
    parity[i][j] = sum over s in [0, k) of P[i][s] * data[s][j]
]]></artwork>
          <t>where the sum and product are in GF(2^8).  All shards (data and
parity) are the same size.</t>
        </section>
        <section anchor="decoding">
          <name>Decoding</name>
          <t>When one or more shards are lost (up to m), reconstruction proceeds
by matrix inversion:</t>
          <ol spacing="normal" type="1"><li>
              <t>Select k available shards (from the k + m total).</t>
            </li>
            <li>
              <t>Form a k x k sub-matrix S of the encoding matrix E by selecting the
rows corresponding to the available shards.</t>
            </li>
            <li>
              <t>Compute S_inv = S^(-1) using Gaussian elimination in GF(2^8).</t>
            </li>
            <li>
              <t>Multiply S_inv by the vector of available shard data at each byte
position to recover the original k data shards.</t>
            </li>
            <li>
              <t>If any parity shards are also missing, regenerate them by
re-encoding from the recovered data shards.</t>
            </li>
          </ol>
          <t>The reconstruction cost is dominated by the matrix inversion, which
is O(k^3) in GF(2^8) multiplications.</t>
        </section>
        <section anchor="rs-interoperability-requirements">
          <name>RS Interoperability Requirements</name>
          <t>For two implementations of FFV2_ENCODING_RS_VANDERMONDE to
interoperate, they <bcp14>MUST</bcp14> agree on all of the following parameters.
Any deviation produces a different encoding matrix and renders
data unrecoverable by a different implementation.</t>
          <dl>
            <dt>Irreducible polynomial:</dt>
            <dd>
              <t><tt>x^8 + x^4 + x^3 + x^2 + 1</tt> (<tt>0x11d</tt>).</t>
            </dd>
            <dt>Primitive element:</dt>
            <dd>
              <t><tt>g = 2</tt>.</t>
            </dd>
            <dt>Evaluation points:</dt>
            <dd>
              <t>shard <tt>i</tt> (<tt>i = 0, 1, ..., k+m-1</tt>) uses
<tt>alpha_i = i + 1</tt> in GF(2^8) (values 1 through <tt>k+m</tt>, all
non-zero and distinct).</t>
            </dd>
            <dt>Vandermonde entries:</dt>
            <dd>
              <t><tt>V[i][j] = alpha_i^j = (i+1)^j</tt> in GF(2^8) for
<tt>i = 0..k+m-1</tt>, <tt>j = 0..k-1</tt>.</t>
            </dd>
            <dt>Matrix normalization:</dt>
            <dd>
              <t><tt>E = V * T^(-1)</tt> where <tt>T</tt> is the top <tt>k x k</tt> sub-matrix
(rows for shards <tt>0..k-1</tt>).</t>
            </dd>
            <dt>Parameter bound:</dt>
            <dd>
              <t><tt>k + m</tt> <bcp14>MUST NOT</bcp14> exceed 255.</t>
            </dd>
          </dl>
          <t>These parameters fully determine the encoding matrix for any
(k, m) configuration in the permitted range.</t>
        </section>
        <section anchor="rs-interoperability-test-vectors">
          <name>RS Interoperability Test Vectors</name>
          <t>The following worked examples pin the encoding matrix and
end-to-end encodings for two representative geometries: k=2 m=1
(exercises the m=1 all-ones parity row) and k=3 m=2 (exercises
the m=2 P + Q parity rows).  An implementation whose encoded
output matches these tables is using the same GF(2^8)
representation and the same parity-row construction as required
by the interoperability parameters above.</t>
          <section anchor="k2-m1">
            <name>k=2, m=1</name>
            <t>Encoding matrix <tt>E</tt>:</t>
            <artwork><![CDATA[
E = [ [0x01, 0x00],    // identity block for data shard 0
      [0x00, 0x01],    // identity block for data shard 1
      [0x01, 0x01] ]   // parity row P = [1, 1]
]]></artwork>
            <t>The parity shard is the bitwise XOR of both data shards:
<tt>parity[j] = data[0][j] XOR data[1][j]</tt>.</t>
            <t>Concrete byte-level test vector with <tt>shard_len = 1</tt>:</t>
            <table anchor="tbl-rs-test-vector-k2m1">
              <name>RS Vandermonde test vector: k=2, m=1</name>
              <thead>
                <tr>
                  <th align="left">data[0]</th>
                  <th align="left">data[1]</th>
                  <th align="left">parity</th>
                  <th align="left">Notes</th>
                </tr>
              </thead>
              <tbody>
                <tr>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">zero input</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">0x01 XOR 0x00 = 0x01</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">0x00 XOR 0x01 = 0x01</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">0x01 XOR 0x01 = 0x00</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">0x80 XOR 0x80 = 0x00</td>
                </tr>
              </tbody>
            </table>
          </section>
          <section anchor="k3-m2">
            <name>k=3, m=2</name>
            <t>Encoding matrix <tt>E</tt>:</t>
            <artwork><![CDATA[
E = [ [0x01, 0x00, 0x00],   // identity block for data shard 0
      [0x00, 0x01, 0x00],   // identity block for data shard 1
      [0x00, 0x00, 0x01],   // identity block for data shard 2
      [0x01, 0x01, 0x01],   // P row = [1, 1, 1]
      [0x01, 0x02, 0x04] ]  // Q row = [g^0, g^1, g^2] with g = 2
]]></artwork>
            <t>The two parity shards are computed byte-wise as:</t>
            <artwork><![CDATA[
P[j] = data[0][j] XOR data[1][j] XOR data[2][j]
Q[j] = 1 * data[0][j] XOR 2 * data[1][j] XOR 4 * data[2][j]
]]></artwork>
            <t>where the multiplication is in GF(2^8) with polynomial <tt>0x11d</tt>.</t>
            <t>Concrete byte-level test vector with <tt>shard_len = 1</tt>:</t>
            <table anchor="tbl-rs-test-vector-k3m2">
              <name>RS Vandermonde test vector: k=3, m=2</name>
              <thead>
                <tr>
                  <th align="left">data[0]</th>
                  <th align="left">data[1]</th>
                  <th align="left">data[2]</th>
                  <th align="left">P</th>
                  <th align="left">Q</th>
                  <th align="left">Notes</th>
                </tr>
              </thead>
              <tbody>
                <tr>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">zero input</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x01</tt></td>
                  <td align="left">
                    <tt>0x02</tt></td>
                  <td align="left">
                    <tt>0x03</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x09</tt></td>
                  <td align="left">1 XOR (2<em>2) XOR (4</em>3) = 1 XOR 4 XOR 12 = 9</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">Q = 1 * 0x80 = 0x80</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x1d</tt></td>
                  <td align="left">Q = 2 * 0x80 = 0x100 -&gt; reduce by 0x11d -&gt; 0x1d</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x00</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x80</tt></td>
                  <td align="left">
                    <tt>0x3a</tt></td>
                  <td align="left">Q = 4 * 0x80 = (2 * 0x1d) = 0x3a</td>
                </tr>
                <tr>
                  <td align="left">
                    <tt>0x37</tt></td>
                  <td align="left">
                    <tt>0x91</tt></td>
                  <td align="left">
                    <tt>0xac</tt></td>
                  <td align="left">
                    <tt>0x0a</tt></td>
                  <td align="left">
                    <tt>0x82</tt></td>
                  <td align="left">general non-degenerate case</td>
                </tr>
              </tbody>
            </table>
            <t>Implementations that produce different values for any row of
either table disagree with this specification and will not
interoperate.  m &gt;= 3 test vectors are not included here because
the normalized-Vandermonde parity rows are not easily
hand-computed; implementations that need m &gt;= 3 verification
<bcp14>SHOULD</bcp14> cross-check against a reference implementation.</t>
          </section>
        </section>
        <section anchor="rs-shard-sizes">
          <name>RS Shard Sizes</name>
          <t>All RS shards (data and parity) are exactly shard_len bytes.  This
simplifies the CHUNK operation protocol: chunk_size is exactly the
shard size for all mirrors.</t>
          <table anchor="tbl-rs-shards">
            <name>RS shard sizes for common configurations</name>
            <thead>
              <tr>
                <th align="left">Configuration</th>
                <th align="left">File Size</th>
                <th align="left">Shard Size</th>
                <th align="left">Total Storage</th>
                <th align="left">Overhead</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">4+2</td>
                <td align="left">4 KB</td>
                <td align="left">1 KB</td>
                <td align="left">6 KB</td>
                <td align="left">50%</td>
              </tr>
              <tr>
                <td align="left">4+2</td>
                <td align="left">1 MB</td>
                <td align="left">256 KB</td>
                <td align="left">1.5 MB</td>
                <td align="left">50%</td>
              </tr>
              <tr>
                <td align="left">8+2</td>
                <td align="left">4 KB</td>
                <td align="left">512 B</td>
                <td align="left">5 KB</td>
                <td align="left">25%</td>
              </tr>
              <tr>
                <td align="left">8+2</td>
                <td align="left">1 MB</td>
                <td align="left">128 KB</td>
                <td align="left">1.25 MB</td>
                <td align="left">25%</td>
              </tr>
            </tbody>
          </table>
        </section>
      </section>
      <section anchor="sec-mojette-encoding">
        <name>Mojette Transform Encoding (FFV2_ENCODING_MOJETTE_SYSTEMATIC, FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC)</name>
        <section anchor="overview-3">
          <name>Overview</name>
          <t>The Mojette Transform is an erasure coding technique based on discrete
geometry rather than algebraic field operations.  It computes 1D
projections of a 2D grid along selected directions.  Given enough
projections, the original grid can be reconstructed exactly.</t>
          <t>The transform operates on fixed-width words combined with bitwise
XOR -- the additive group of <tt>(GF(2))^(W*8)</tt> where W is the
element width in bytes.  Encoders and decoders <bcp14>MUST</bcp14> use XOR;
modular integer addition is not equivalent and is not
interoperable.  XOR has no carry chain, is its own inverse (so
the residual subtraction in reconstruction is identical to the
forward accumulation), and scales straightforwardly to wider
SIMD lanes (NEON, SSE, AVX, AVX-512) without requiring
multiplicative Galois field operations.</t>
          <t>For interoperability, this specification pins the element width
to <tt>W = 8</tt> bytes (64 bits) for both
FFV2_ENCODING_MOJETTE_SYSTEMATIC and
FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC in this revision.  All
implementations <bcp14>MUST</bcp14> use W = 8; a future revision (or a distinct
registered encoding type) may lift the fixed width, at which
point it becomes a wire-visible parameter.  Fixing W in this
revision prevents an interoperability hazard: the same shard
input XOR'd at W = 4 versus W = 8 produces different bin values
that appear "close but wrong" to a mismatched decoder.</t>
        </section>
        <section anchor="grid-structure">
          <name>Grid Structure</name>
          <t>Data is arranged as a P x Q grid of unsigned integer elements,
where P is the number of columns and Q is the number of rows.
For k data shards of S bytes each with W-byte elements:</t>
          <artwork><![CDATA[
P = S / W       (columns per row)
Q = k           (rows = data shards)
]]></artwork>
        </section>
        <section anchor="directions">
          <name>Directions</name>
          <t>A direction is a pair of coprime integers (p_i, q_i).  This
specification pins all directions to q_i = 1 for both Mojette
encoding types (systematic and non-systematic) in this
revision.  Non-unity q_i values may be introduced by a future
distinct registered encoding type.</t>
          <t>For n = k + m total shards (Mojette non-systematic) or m parity
shards (Mojette systematic), the direction set is determined by
the following mandatory rule on the shard count N (N = n for
non-systematic, N = m for systematic).</t>
          <dl>
            <dt>For N even (N = 2t):</dt>
            <dd>
              <t><tt>directions = { (p, 1) : p in {-t, -t+1, ..., -1, 1, 2, ..., t} }</tt>
-- symmetric around zero, giving <tt>|directions| = 2t = N</tt>.</t>
            </dd>
            <dt>For N odd (N = 2t + 1):</dt>
            <dd>
              <t><tt>directions = { (p, 1) : p in {-t, -t+1, ..., -1, 1, 2, ..., t, t+1} }</tt>
-- asymmetric by including one additional positive magnitude
so that <tt>|directions| = 2t + 1 = N</tt>.</t>
            </dd>
          </dl>
          <t>Direction slots are then sorted by <tt>p_i</tt> ascending (most-negative
p first, most-positive p last) to give the canonical direction
order.  The direction in slot i is used to compute the projection
for shard slot (k + i) in systematic form, or for shard slot i in
non-systematic form.  Examples:</t>
          <ul spacing="normal">
            <li>
              <t>N = 4 (even): p = {-2, -1, 1, 2}</t>
            </li>
            <li>
              <t>N = 6 (even): p = {-3, -2, -1, 1, 2, 3}</t>
            </li>
            <li>
              <t>N = 3 (odd):  p = {-1, 1, 2}</t>
            </li>
            <li>
              <t>N = 5 (odd):  p = {-2, -1, 1, 2, 3}</t>
            </li>
          </ul>
          <t>Two implementations that follow this algorithm on the same N
generate identical direction sets in identical slot order and
therefore identical shard layouts.  Implementations <bcp14>MUST NOT</bcp14>
diverge from this algorithm (e.g., by using a different
tie-breaking rule for odd N) without registering a distinct
encoding type.</t>
        </section>
        <section anchor="forward-transform-encoding">
          <name>Forward Transform (Encoding)</name>
          <t>For each direction (p_i, q_i), the forward transform computes a 1D
projection.  Each bin XORs the grid elements that lie on a discrete
line through the grid.  This specification adopts the bin
convention of <xref target="NORMAND"/>: a grid cell at (row, col) maps to bin</t>
          <artwork><![CDATA[
b = row * p + col * q - off
]]></artwork>
          <t>where off is chosen so that the smallest reachable bin index is 0
(off = min over all (row, col) in [0, Q) x [0, P) of row * p + col * q).
All implementations <bcp14>MUST</bcp14> use this convention -- the alternative
"transposed" convention <tt>b = col * p - row * q + off</tt> produces a
different bin ordering and is not interoperable.</t>
          <t>The full forward transform along direction (p, q) is then:</t>
          <artwork><![CDATA[
Projection(b, p, q) = XOR over all (row, col) where
                       row * p + col * q - off = b
                       of Grid[row][col]
]]></artwork>
          <t>The number of bins B in a projection is:</t>
          <artwork><![CDATA[
B(p, q, P, Q) = |p| * (Q - 1) + |q| * (P - 1) + 1
]]></artwork>
          <t>For q = 1, this simplifies to:</t>
          <artwork><![CDATA[
B = abs(p) * (Q - 1) + P
]]></artwork>
          <t>The byte size of the projection is B * W.</t>
        </section>
        <section anchor="katz-reconstruction-criterion">
          <name>Katz Reconstruction Criterion</name>
          <t>Reconstruction from a set of <tt>n</tt> projections is possible if and
only if the Katz criterion <xref target="KATZ"/> holds over those <tt>n</tt>
projections:</t>
          <artwork><![CDATA[
SUM(i=1..n) |q_i| >= Q    OR    SUM(i=1..n) |p_i| >= P
]]></artwork>
          <t>With q_i = 1 pinned for every direction (see the Directions
subsection above), the q-sum simplifies to n &gt;= Q.</t>
          <t>For the non-systematic form, <tt>n = k + m</tt> and every direction
counts toward the criterion.  The criterion holds for the
initial encoding (design-time check on the direction set) and
must continue to hold after any losses; the surviving
projections must satisfy Katz over the same grid dimensions
(P, Q).</t>
          <t>For the systematic form, the raw data rows act as
"projections at direction (p=0, q=1)": row <tt>r</tt> is <tt>Grid[r]</tt> and
contributes <tt>q = 1</tt> toward the q-sum of the Katz criterion.
For an arbitrary loss pattern with <tt>r</tt> data-row losses and <tt>s</tt>
parity-projection losses (with <tt>r + s &lt;= m</tt>), the surviving set
comprises <tt>k - r</tt> data rows (each <tt>q_i = 1</tt>) and <tt>m - s</tt> parity
projections.  Decoding proceeds by:</t>
          <ol spacing="normal" type="1"><li>
              <t>Subtracting the contributions of the <tt>k - r</tt> surviving data
rows from the <tt>m - s</tt> surviving parity projections (the
"residual").</t>
            </li>
            <li>
              <t>Applying the corner-peeling algorithm over the residual to
recover the <tt>r</tt> missing rows.</t>
            </li>
          </ol>
          <t>Step 2 succeeds if and only if the Katz criterion holds over
the <tt>m - s</tt> residual projections against the <tt>r x P</tt> unknown
sub-grid.  Substituting: the criterion reduces to
<tt>m - s &gt;= r</tt> (q-sum, since q_i = 1 for every parity direction
and the unknown-grid Q is r) OR the analogous p-sum condition
over the residual.  Because the mandatory direction algorithm
above generates <tt>m</tt> projections with distinct nonzero p values,
the p-sum condition also holds for any loss pattern with
<tt>r + s &lt;= m</tt>; the systematic form therefore achieves
Maximum-Distance-Separable-like recovery up to <tt>m</tt> combined
data-row and parity-projection losses.</t>
        </section>
        <section anchor="inverse-transform-decoding">
          <name>Inverse Transform (Decoding)</name>
          <t>The choice of inverse algorithm is purely an implementer concern:
all correct inverses produce byte-identical plaintext from the same
shards and bin layout, so the choice has no on-the-wire impact.
Two well-known algorithms apply.</t>
          <t>The corner-peeling algorithm:</t>
          <ol spacing="normal" type="1"><li>
              <t>Count how many unknown elements contribute to each bin.</t>
            </li>
            <li>
              <t>Find any bin with exactly one contributor (singleton).</t>
            </li>
            <li>
              <t>Recover the element, XOR it back through all projections.</t>
            </li>
            <li>
              <t>Repeat until all elements are recovered.</t>
            </li>
          </ol>
          <t>Corner peeling runs in O(n * P * Q) and is the simplest correct
inverse.  Implementations <bcp14>MAY</bcp14> instead use the geometry-driven
inverse of <xref target="NORMAND"/>, which precomputes a recurrence over the
sorted projection slopes and walks each line once: it eliminates
the inner singleton search and runs substantially faster on the
parameter ranges typical of flexible file v2 layout deployments (high redundancy,
wide stripes), with no change to the shards or to the
reconstructed plaintext.</t>
        </section>
        <section anchor="systematic-mojette">
          <name>Systematic Mojette</name>
          <t>In the systematic form (FFV2_ENCODING_MOJETTE_SYSTEMATIC), the first
k shards are the original data rows and the remaining m shards are
projections.  Healthy reads require no decoding.</t>
          <t>Reconstruction of missing data rows proceeds via the
corner-peeling algorithm of <xref target="NORMAND"/>:</t>
          <ol spacing="normal" type="1"><li>
              <t>Load available parity projections.</t>
            </li>
            <li>
              <t>Subtract contributions of present data rows (residual).</t>
            </li>
            <li>
              <t>Corner-peel the residual to recover missing rows.</t>
            </li>
          </ol>
          <t>Reconstruction cost is O(m * k) -- a fundamental advantage over RS
at wide geometries (k &gt;= 8).</t>
        </section>
        <section anchor="non-systematic-mojette">
          <name>Non-Systematic Mojette</name>
          <t>In the non-systematic form (FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC),
all k + m shards are projections.  Every read requires the full
inverse transform.  This provides constant performance regardless of
failure count, but at higher baseline read cost than systematic.</t>
        </section>
        <section anchor="mojette-shard-sizes-and-layout">
          <name>Mojette Shard Sizes and Layout</name>
          <dl>
            <dt>Slot-to-direction mapping:</dt>
            <dd>
              <t>The canonical shard layout for Mojette is:</t>
              <dl>
                <dt>Systematic (FFV2_ENCODING_MOJETTE_SYSTEMATIC):</dt>
                <dd>
                  <t>shard slots <tt>0..k-1</tt> carry the k data rows (row r in slot
r); shard slots <tt>k..k+m-1</tt> carry the m parity projections
in the canonical direction order defined in the Directions
subsection above (direction slot i occupies shard slot
<tt>k + i</tt>).</t>
                </dd>
                <dt>Non-systematic (FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC):</dt>
                <dd>
                  <t>shard slots <tt>0..k+m-1</tt> carry the n = k + m parity
projections in the canonical direction order (direction
slot i occupies shard slot i).</t>
                </dd>
              </dl>
            </dd>
            <dt>Bin ordering within a projection:</dt>
            <dd>
              <t>Within a projection shard the bins are serialized in
ascending bin-index order (bin 0 first, bin B-1 last), with
no gap or header.  Each bin value is <tt>W = 8</tt> bytes wide; the
W-byte element is serialized in big-endian byte order (the
same order the data-row shards present their W-byte grid
elements in).</t>
            </dd>
            <dt>Projection sizes:</dt>
            <dd>
              <t>Unlike Reed-Solomon, Mojette parity shard sizes vary by
direction:</t>
            </dd>
          </dl>
          <table anchor="tbl-mojette-proj-sizes">
            <name>Mojette projection sizes for 4+2, 4KB shards, W=8</name>
            <thead>
              <tr>
                <th align="left">Direction (p, q)</th>
                <th align="left">Bins (B) for P=512, Q=4</th>
                <th align="left">Size (bytes, W=8)</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">(-3, 1)</td>
                <td align="left">521</td>
                <td align="left">4168</td>
              </tr>
              <tr>
                <td align="left">(-2, 1)</td>
                <td align="left">518</td>
                <td align="left">4144</td>
              </tr>
              <tr>
                <td align="left">(-1, 1)</td>
                <td align="left">515</td>
                <td align="left">4120</td>
              </tr>
              <tr>
                <td align="left">(1, 1)</td>
                <td align="left">515</td>
                <td align="left">4120</td>
              </tr>
              <tr>
                <td align="left">(2, 1)</td>
                <td align="left">518</td>
                <td align="left">4144</td>
              </tr>
              <tr>
                <td align="left">(3, 1)</td>
                <td align="left">521</td>
                <td align="left">4168</td>
              </tr>
            </tbody>
          </table>
          <dl>
            <dt>Chunk sizing for variable-length projections:</dt>
            <dd>
              <t>When a projection shard is written via <tt>CHUNK_WRITE</tt> /
<tt>CHUNK_FINALIZE</tt> / <tt>CHUNK_COMMIT</tt>, the shard is divided into
chunks by the following mapping.  Let <tt>shard_bytes = B * W</tt>
be the projection shard's total byte size (where B is the
number of bins per the B formula above
(<xref target="tbl-mojette-proj-sizes"/> uses it) applied to the shard's
direction (p, q) and the grid dimensions (P, Q)):</t>
              <ul spacing="normal">
                <li>
                  <t><tt>num_chunks = ceil(shard_bytes / chunk_size)</tt></t>
                </li>
                <li>
                  <t>Chunk <tt>j</tt> (for j = 0..num_chunks-1) covers the shard byte
range <tt>[j * chunk_size, min((j+1) * chunk_size,
shard_bytes))</tt>.</t>
                </li>
                <li>
                  <t>The final chunk (chunk <tt>num_chunks - 1</tt>) <bcp14>MAY</bcp14> be shorter
than <tt>chunk_size</tt> if <tt>shard_bytes</tt> is not a multiple of
<tt>chunk_size</tt>; all other chunks are exactly <tt>chunk_size</tt>
bytes.</t>
                </li>
              </ul>
            </dd>
          </dl>
          <t>The <tt>chunk_size</tt> value is a per-mirror parameter and does not
vary across the parity projections of a single file, even
though the shard sizes vary.  For a file with parity
projections of sizes <tt>S_i = B_i * W</tt>, the number of chunks per
shard is <tt>ceil(S_i / chunk_size)</tt> per shard; a reader that
requests chunk offset <tt>&gt;= S_i</tt> on shard i receives
<tt>NFS4ERR_PAYLOAD_LOST</tt> (per <xref target="sec-NFS4ERR_PAYLOAD_LOST"/>) with a
short read reporting the shard's true byte length.</t>
        </section>
      </section>
      <section anchor="comparison-of-encoding-types">
        <name>Comparison of Encoding Types</name>
        <table anchor="tbl-encoding-comparison">
          <name>Comparison of erasure encoding types</name>
          <thead>
            <tr>
              <th align="left">Property</th>
              <th align="left">Reed-Solomon</th>
              <th align="left">Mojette Systematic</th>
              <th align="left">Mojette Non-Systematic</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">Maximum Distance Separable guarantee</td>
              <td align="left">Yes</td>
              <td align="left">Yes (Katz)</td>
              <td align="left">Yes (Katz)</td>
            </tr>
            <tr>
              <td align="left">Shard sizes</td>
              <td align="left">Uniform</td>
              <td align="left">Variable</td>
              <td align="left">Variable</td>
            </tr>
            <tr>
              <td align="left">Reconstruction cost</td>
              <td align="left">O(k^3) shard ops<br/>(matrix inversion)</td>
              <td align="left">O(m<em>k</em>P*Q) grid ops (peeling)</td>
              <td align="left">O(m<em>k</em>P*Q) grid ops (peeling)</td>
            </tr>
            <tr>
              <td align="left">Healthy read cost</td>
              <td align="left">Zero</td>
              <td align="left">Zero</td>
              <td align="left">Full decode</td>
            </tr>
            <tr>
              <td align="left">GF operations</td>
              <td align="left">Yes (GF(2^8))</td>
              <td align="left">No</td>
              <td align="left">No</td>
            </tr>
          </tbody>
        </table>
        <t>Reed-Solomon uses uniform shard sizes and GF(2^8) operations.
Mojette systematic provides zero-cost healthy reads with variable
parity shard sizes; reconstruction cost scales as O(m * k) rather
than O(k^3).  Mojette non-systematic encodes all k + m shards as
projections, providing constant decode cost regardless of failure
count at a higher baseline read cost than systematic.  The choice
among these is a deployment decision driven by workload
characteristics and operational priorities.</t>
      </section>
      <section anchor="handling-write-holes">
        <name>Handling write holes</name>
        <t>A write hole occurs when a client begins writing a stripe but does not
successfully write all k + m shards before a failure.  Some data servers
will hold new data while others still hold old data, producing an
non-atomic payload.</t>
        <t>The CHUNK_WRITE / CHUNK_ROLLBACK mechanism addresses this.  When a client
issues CHUNK_WRITE, the data server retains a copy of the previous shard
and places the new data in the PENDING state.  If any shard write fails,
the client issues CHUNK_ROLLBACK to each data server that received a
CHUNK_WRITE, restoring the previous content.  The payload remains
atomic from the reader's perspective throughout, because PENDING
blocks carry the new chunk_guard4 value and CHUNK_READ returns the last
COMMITTED or FINALIZED block when a PENDING block exists.</t>
        <t>A single-shard CHUNK_WRITE failure <bcp14>MAY</bcp14> alternatively be
handled by reporting the failure to the metadata server via
LAYOUTERROR and letting the metadata server initiate the
repair flow at <xref target="sec-repair-selection"/>.  The metadata server
adds a REPAIR-flagged replacement data server to the layout
(from its out-of-band pool) and drives reconstruction of the
missing shard.</t>
        <t>In the multiple writer model, a write hole can also arise when two clients
are racing.  The chunk_guard4 value on each chunk identifies which
transaction wrote it.  A reader that finds chunks with different guard
values detects the non-atomicity and either retries (if a concurrent write
is still in progress) or reports NFS4ERR_PAYLOAD_NOT_ATOMIC to the
metadata server to trigger repair.</t>
        <t>When CHUNK_ROLLBACK and repair are both unavailable, and the
payload cannot be reconstructed because too many shards have
been lost (for example, a catastrophic multi-data server failure
with no reachable replacement data servers), the repair flow
ultimately terminates with NFS4ERR_PAYLOAD_LOST; see
<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>.</t>
      </section>
    </section>
    <section anchor="sec-system-model">
      <name>System Model and Correctness</name>
      <t>The design decisions in this document -- centralized coordination
through the metadata server, CAS semantics via chunk_guard4,
pessimistic lock escrow during repair, and erasure-coded reads
from any sufficient subset -- depart visibly from a classical
distributed-consensus protocol such as Paxos or Raft.  This
section states the system model those decisions rest on, the
consistency and progress guarantees the protocol provides under
that model, and how the protocol relates to (and when it relies
on) classical consensus.  It is intended as the correctness
framing for implementers and reviewers; the normative wire
behavior is defined in the preceding sections.</t>
      <section anchor="sec-system-model-wire">
        <name>Wire Semantics vs Implementation</name>
        <t>The protocol defines wire semantics, not data-server
implementation.  The operations introduced in
<xref target="sec-new-ops"/> (CHUNK_WRITE, CHUNK_FINALIZE, CHUNK_COMMIT,
CHUNK_ROLLBACK, CHUNK_LOCK / CHUNK_UNLOCK, CHUNK_READ,
CHUNK_REPAIRED, CHUNK_ERROR, CHUNK_HEADER_READ,
CHUNK_WRITE_REPAIR) together with the per-chunk state machine
(<xref target="sec-system-model-chunk-state"/>) and the chunk_guard4 CAS
(<xref target="sec-chunk_guard4"/>) are everything a peer observes.
The data server's internal representation of persistent state is
not exposed on the wire, and two data-server implementations
that satisfy the same wire semantics <bcp14>MAY</bcp14> differ arbitrarily in
their internal structure.</t>
        <t>In particular, the protocol does NOT exchange:</t>
        <ul spacing="normal">
          <li>
            <t>which on-disk layout (log-structured, append-only,
in-place-overwrite, external object store, key-value store,
or any other) a data server uses to persist chunks;</t>
          </li>
          <li>
            <t>whether a data server holds PENDING and FINALIZED chunks in
a single blob or in distinct regions;</t>
          </li>
          <li>
            <t>how a data server represents the CHUNK_LOCK table, the guard
epoch, or the escrow owner;</t>
          </li>
          <li>
            <t>whether a data server's chunk retention beyond COMMIT is
implemented via shadow blocks, journals, reference counts,
or copy-on-write.</t>
          </li>
        </ul>
        <t>This decoupling is deliberate.  It lets the protocol accommodate
future smart-data server designs -- including designs that integrate more
closely with storage back-ends that already provide atomic
replace, multi-version concurrency, or internal erasure coding --
without protocol revisions, provided the wire semantics are
preserved.  Conversely, a data server implementer is free to
pick the representation that best fits the underlying storage
stack without fear that some less common implementation choice
is disallowed.</t>
        <t>The counterpart of this rule is that the wire is the entire
contract.  Any behavior a client relies on <bcp14>MUST</bcp14> be observable
via the operations listed above; any behavior that is not
observable (cache state, background scrubbing cadence,
internal retry ordering, on-disk layout) is implementation
detail and <bcp14>MUST NOT</bcp14> be depended upon.</t>
      </section>
      <section anchor="sec-system-model-chunk-not-block">
        <name>Chunks Are Not Blocks</name>
        <t>The chunk is a protocol-level primitive distinct from a block.
Throughout this document, "block" refers to a byte range in the
file's address space (the application's view); "chunk" refers to
the addressable unit carried by the CHUNK operations, which
has an envelope that blocks do not.</t>
        <t>A chunk carries five properties that a block does not:</t>
        <dl>
          <dt>Atomicity:</dt>
          <dd>
            <t>the chunk_guard4 compare-and-swap guard (<xref target="sec-chunk_guard4"/>)
sequences concurrent writers and rejects torn-write attempts.
Block I/O has no comparable primitive; concurrent block
writes either serialize at the storage layer or interleave
unpredictably.</t>
          </dd>
          <dt>Integrity:</dt>
          <dd>
            <t>the checksum in each chunk header is computed over the header
and payload and verified end-to-end on the read path
(<xref target="sec-CHUNK_READ"/>).  Block I/O carries no integrity tag;
data-corruption detection is delegated to the underlying
storage medium or is absent.</t>
          </dd>
          <dt>Provenance:</dt>
          <dd>
            <t>the chunk_owner4 (<xref target="sec-chunk_owner4"/>) records which
transaction produced the chunk.  Block I/O carries no
per-write provenance; a block's bytes have no
protocol-visible producer.</t>
          </dd>
          <dt>Lifecycle state:</dt>
          <dd>
            <t>a chunk progresses through PENDING -&gt; FINALIZED -&gt; COMMITTED
via CHUNK_FINALIZE / CHUNK_COMMIT
(<xref target="sec-system-model-chunk-state"/>).  Block I/O has no
lifecycle states; a block is either present or absent.</t>
          </dd>
          <dt>Lock continuity across revocation:</dt>
          <dd>
            <t>the chunk's lock (<xref target="sec-CHUNK_LOCK"/>) is transferred to the
metadata server in escrow when a holder's stateid is revoked,
and adopted by a repair actor via CHUNK_LOCK_FLAGS_ADOPT.
Block I/O has no per-block locking and no continuity
mechanism; client failure leaves any external lock
indeterminate.</t>
          </dd>
        </dl>
        <t>Each of these properties is load-bearing for some part of the
flexible file v2 layout's consistency story: the chunk_guard4
CAS underlies multi-writer correctness; the checksum underlies
end-to-end integrity; lock escrow underlies repair coordination
across stateid revocation; the state machine underlies the
PENDING / FINALIZED / COMMITTED distinction that enables
rollback and repair.  Removing any one of them would change
what the protocol can guarantee.</t>
        <t>A protocol that exchanges file data as byte ranges with no
envelope -- whether described as "block I/O" or as "generic
data movement" -- is not interoperable with this specification's
CHUNK operations.  The CHUNK operations are not a byte-range
I/O protocol with optional integrity bolted on; they are a
chunk protocol in which the envelope is the primitive.</t>
      </section>
      <section anchor="sec-system-model-roles">
        <name>Actors and Roles</name>
        <t>Three actors participate on behalf of any given file:</t>
        <dl>
          <dt>pNFS client:</dt>
          <dd>
            <t>Issues CHUNK operations to data servers over the data path;
issues LAYOUTGET, LAYOUTRETURN, LAYOUTERROR, and SEQUENCE to
the metadata server on the control path.  Authenticates to the
metadata server via AUTH_SYS, RPCSEC_GSS, or TLS.  <bcp14>MAY</bcp14> be
selected as a repair actor via CB_CHUNK_REPAIR.</t>
          </dd>
          <dt>Metadata server:</dt>
          <dd>
            <t>Is the sole coordinator for the file.  Grants, renews, and
revokes layouts; issues TRUST_STATEID / REVOKE_STATEID /
BULK_REVOKE_STATEID to each tight-coupled data server; selects
the repair actor under the rules in
<xref target="sec-repair-selection"/>; owns the reserved
CHUNK_GUARD_CLIENT_ID_MDS escrow identity for in-flight repair.</t>
          </dd>
          <dt>Data server:</dt>
          <dd>
            <t>Persists chunks and enforces the per-file trust table, the
per-chunk guard CAS (chunk_guard4), the per-chunk lock state
(including the metadata-server escrow owner), and the chunk state machine
(EMPTY / PENDING / FINALIZED / COMMITTED).  Has no
coordinator role.  Has no knowledge of the erasure encoding type
in use for any file: the erasure transform is performed
entirely at the client, and the data server stores the
resulting chunks without interpreting their contents.</t>
          </dd>
        </dl>
        <t>An entity <bcp14>MAY</bcp14> simultaneously hold more than one of these roles
with respect to a given data server, with each role bound to a
distinct session.  A metadata server that opens a control
session to a data server (presenting EXCHGID4_FLAG_USE_PNFS_MDS
at EXCHANGE_ID; see <xref target="sec-tight-coupling-control-session"/>)
issues TRUST_STATEID, REVOKE_STATEID, and BULK_REVOKE_STATEID on
that session; on a separate client-side session (presenting
EXCHGID4_FLAG_USE_NON_PNFS), the same metadata server <bcp14>MAY</bcp14> also
issue CHUNK operations as a data-path client.  A data server
<bcp14>MUST NOT</bcp14> assume that the metadata server is not also one of its
clients; it distinguishes metadata-server-only operations from client-side
operations by the EXCHANGE_ID flags of the session that carries
the operation, not by the requester's IP address or principal.</t>
        <t>A data server <bcp14>MAY</bcp14> likewise act as a client of another data
server -- for example, when selected as the repair actor by an
metadata-server-directed CB_CHUNK_REPAIR.  Independent of the actor role,
any entity may operate as encoding-aware (issuing CHUNK
operations directly against data servers) or encoding-unaware
(operating through the proxy server mediated READ / WRITE path
described in the proxy server draft).  Proxy-server registration
carries the encoding capability
explicitly; direct pNFS clients reveal their encoding posture
implicitly through the operations they issue.</t>
        <t>The protocol does NOT mandate how a data server implements the
chunk state machine or stores PENDING chunks.  An implementation
<bcp14>MAY</bcp14> use per-client staging files, a single append-only instance
file with an index, a separate metadata-header file paired with
a blocks file, a log-structured store, or any other
representation that preserves the normative semantics (the
EMPTY / PENDING / FINALIZED / COMMITTED transitions, the
chunk_guard4 CAS, lock continuity across revocation, and the
integrity checks).  The choice is a data-server implementation
concern and is transparent to clients and the metadata server.</t>
      </section>
      <section anchor="sec-system-model-failures">
        <name>Failure Model</name>
        <t>The protocol assumes:</t>
        <dl>
          <dt>Crash-stop:</dt>
          <dd>
            <t>Clients, metadata servers, and data servers fail by stopping.
A restarted component rejoins the protocol with a fresh epoch
and participates in the grace / reclaim path already defined
in <xref target="RFC8881"/>.  Correct components do not exhibit arbitrary
(Byzantine) behavior.</t>
          </dd>
          <dt>Fail-silent data servers:</dt>
          <dd>
            <t>Data servers report honestly about the state of the data they
hold.  The protocol detects on-disk bit rot via checksum
(see <xref target="sec-CHUNK_WRITE"/>) but does not defend against a data
server that deliberately lies about whether a chunk is
COMMITTED or what its contents are.  Byzantine data servers
are explicitly outside the trust model; see
<xref target="sec-system-model-nongoals"/>.</t>
          </dd>
          <dt>Authenticated writers and their own data:</dt>
          <dd>
            <t>An authenticated client may write arbitrary (even
semantically-invalid) bytes into chunks it owns.  The checksum
check detects transport corruption, not adversarial content.
This matches the existing NFSv4 authorization model: once
you have write access, you may write anything.</t>
          </dd>
          <dt>Network partitions:</dt>
          <dd>
            <t>The protocol is partition-tolerant at the cost of availability
during the partition window.  A client partitioned from a
data server recovers via LAYOUTERROR and may be issued a new
layout (with a REPAIR-flagged replacement data server
added by the metadata server; see
<xref target="sec-repair-selection"/>).  A metadata server partitioned from a data
server eventually renews trust entries on reconnection; in
the interim, the data server returns NFS4ERR_DELAY for
affected stateids (see <xref target="sec-tight-coupling-mds-crash"/>).
Message loss is bounded by RPC retransmit; eventual delivery
is assumed once the partition heals.
</t>
            <t>Split-brain scenarios (in which a partitioned minority of
the data servers in a mirror set attempts to make progress
independently of the majority) cannot drive non-atomic
writes to COMMITTED state.  The chunk_guard4 CAS on each
write requires the guard value from a successor chunk to
strictly advance the guard value of its predecessor; on
partition heal, any writes attempted on the minority side
are detected by the majority because their guard values do
not satisfy the CAS precondition, and those writes are
discarded.  When reconciliation is impossible -- for example,
the erasure coding has lost too many shards across both sides
of the partition to reconstruct any single atomic
generation -- the repair flow terminates with
NFS4ERR_PAYLOAD_LOST (see <xref target="sec-NFS4ERR_PAYLOAD_LOST"/>),
which is terminal for the affected ranges.</t>
          </dd>
          <dt>Lease bound:</dt>
          <dd>
            <t>All state held by a data server on behalf of a metadata server
is bounded by the TRUST_STATEID expiry (see
<xref target="sec-tight-coupling-lease"/>).  An orphaned entry will
eventually expire even if the metadata server never returns.</t>
          </dd>
        </dl>
      </section>
      <section anchor="sec-system-model-escrow">
        <name>Escrow Model</name>
        <t>Chunk locks (<xref target="sec-CHUNK_LOCK"/>) provide the
exclusion primitive that the chunk_guard4 CAS
(<xref target="sec-chunk_guard4"/>) cannot: a client that needs to hold a
chunk against every other writer for the duration of a
multi-step operation (repair, migration, delta-write
coordination) acquires a CHUNK_LOCK.  Once acquired, the lock
is held on the data server's state, not on the metadata
server.  That creates two survivability problems the wire
protocol has to answer:</t>
        <dl>
          <dt>Client failure while holding locks:</dt>
          <dd>
            <t>a client whose stateid is revoked (lease expiry,
CB_LAYOUTRECALL timeout, explicit REVOKE_STATEID) is by
definition no longer authorized to speak to the data server.
If its outstanding chunk locks were simply dropped, the
locked chunks would become writable by any other client
immediately -- mid-way through the operation the lost client
was performing.  That would expose the chunk to concurrent
writers before the operation completes, defeating the point
of taking the lock.</t>
          </dd>
          <dt>Metadata-server instance change:</dt>
          <dd>
            <t>in a highly-available deployment the metadata-server role
can move from one physical host to another (restart, planned
failover, unplanned failover).  If the departing incarnation
had installed placeholder locks on the data server (see
below), the arriving incarnation needs to reclaim them
safely -- reclaim by identity, not by client-connection
state, since the connection is gone -- and must
simultaneously fence the departing incarnation so that a
stale prior host resuming operation cannot double-manage the
same escrows.</t>
          </dd>
        </dl>
        <t>Both problems resolve to the same primitive: chunk locks CAN be
held by an owner other than the client that acquired them, and
OWNERSHIP CAN TRANSFER without releasing the lock.  The escrow
mechanism has three components:</t>
        <dl>
          <dt>Placeholder ownership:</dt>
          <dd>
            <t>when a client's stateid is revoked while it holds chunk
locks, the data server <bcp14>MUST NOT</bcp14> drop the locks.  Instead the
locks transfer to the metadata server as a placeholder
owner, identified on the wire by the reserved value
CHUNK_GUARD_CLIENT_ID_MDS in cg_client_id
(<xref target="sec-chunk_guard_mds"/>).  The chunk stays locked -- no
concurrent writer can win a CAS against the placeholder --
until a repair actor adopts the lock explicitly via
CHUNK_LOCK_FLAGS_ADOPT (<xref target="sec-CHUNK_LOCK"/>) driven by
CB_CHUNK_REPAIR.  This closes the
lock-continuity gap across client failure.</t>
          </dd>
          <dt>Escrow identity:</dt>
          <dd>
            <t>every placeholder-owned lock the metadata server installs on
the data server carries an escrow_id4 (<xref target="sec-escrow_id4"/>),
a 128-bit opaque identifier the metadata server chooses.
escrow_id4 is what a repair actor names when adopting a
specific escrow, what CHUNK_ESCROW_ENUMERATE returns to inventory
outstanding escrows, and what CHUNK_ESCROW_RELEASE names when the metadata
server retires an escrow explicitly.  Without a stable
identity, cross-restart adoption and reclamation could not
name what they were operating on.</t>
          </dd>
          <dt>Incarnation handoff:</dt>
          <dd>
            <t>when the metadata-server role moves to a new host (restart,
HA failover), the new incarnation reclaims escrows the old
incarnation installed via CHUNK_ESCROW_TAKEOVER.  The TAKEOVER carries an
incarnation-lease proof (<xref target="sec-proof-profile"/>) --
cryptographic evidence that the caller is now the
authoritative metadata-server incarnation -- which the data
server verifies.  On acceptance, subsequent escrow
operations from the prior incarnation are rejected with
NFS4ERR_STALE_MDS_EPOCH (<xref target="sec-NFS4ERR_STALE_MDS_EPOCH"/>),
fencing the departed instance.  Only one metadata-server
incarnation is authoritative on any given data server at a
time.</t>
          </dd>
        </dl>
        <t>This mechanism does not support concurrent
multi-metadata-server management of the same file -- see the
single-metadata-server-per-file position in
<xref target="sec-system-model-nongoals"/>.  The escrow control plane
handles the metadata-server role moving between physical hosts
over time (via TAKEOVER), not multiple metadata servers acting
on the same escrow simultaneously.</t>
        <t>Wire mechanics for the operations referenced here
(CHUNK_ESCROW_INSTALL,
CHUNK_ESCROW_RELEASE, CHUNK_ESCROW_ENUMERATE,
CHUNK_ESCROW_TAKEOVER, the incarnation-lease proof format, the
escrow_id4 XDR) live in the New NFSv4.2 Common Data
Structures and New NFSv4.2 Operations sections.</t>
      </section>
      <section anchor="sec-system-model-chunk-state">
        <name>Chunk State Machine</name>
        <t>Each chunk on a data server occupies exactly one of four states.
The transitions below are the complete set; any implementation
of the data server's chunk state table <bcp14>MUST</bcp14> admit these
transitions and no others.</t>
        <figure anchor="fig-chunk-state-machine">
          <name>Chunk lifecycle on the data server</name>
          <artwork><![CDATA[
                            CHUNK_WRITE
                         (fresh cg_gen_id)
        +---------+ -------------------> +-------------+
        |  EMPTY  |                      |   PENDING   |
        +---------+ <------------------- +-------------+
             ^         CHUNK_ROLLBACK            |
             |        (discard PENDING)          |
             |                                   | CHUNK_FINALIZE
             |                                   |  (writer stops
             |                                   |   further writes)
             |                                   v
             |                            +-------------+
             |       CHUNK_ROLLBACK       |  FINALIZED  |
             |      (discard FINALIZED)   +-------------+
             |                                   |
             |                                   | CHUNK_COMMIT
             |                                   |  (make durable
             |                                   |   and globally
             |                                   |   visible)
             |                                   v
             |                            +-------------+
             +--------------------------> |  COMMITTED  |
                   CHUNK_ROLLBACK         +-------------+
                (only via repair;                 |
                 replaces with a newer            | CHUNK_WRITE with
                 COMMITTED generation             | a higher cg_gen_id
                 or discards per the              | begins a new
                 rollback invariant)              | PENDING successor;
                                                  | the prior COMMITTED
                                                  | is retained until
                                                  | its successor is
                                                  | COMMITTED (see the
                                                  v  rollback invariant
                                            (next PENDING
                                             against same chunk)
]]></artwork>
        </figure>
        <t>CHUNK_WRITE against a chunk already in PENDING from the same
writer with the same cg_gen_id is a self-transition on PENDING:
the data server replaces the PENDING payload in place and the
state does not change.  This case is not drawn in
<xref target="fig-chunk-state-machine"/> for clarity.</t>
        <t>States:</t>
        <dl>
          <dt>EMPTY:</dt>
          <dd>
            <t>The chunk has no payload.  CHUNK_READ returns a zero-filled
result; CHUNK_WRITE against an EMPTY chunk is the first write.</t>
          </dd>
          <dt>PENDING:</dt>
          <dd>
            <t>The chunk has payload accepted by CHUNK_WRITE but not yet
finalized.  Not visible to CHUNK_READ (see
<xref target="sec-system-model-consistency"/>).  Further CHUNK_WRITEs from
the same writer <bcp14>MAY</bcp14> replace the payload in place (same
cg_gen_id).</t>
          </dd>
          <dt>FINALIZED:</dt>
          <dd>
            <t>The writer has signalled via CHUNK_FINALIZE that it will send
no more CHUNK_WRITEs for this generation.  Still not visible
to CHUNK_READ, but a candidate for CHUNK_COMMIT.</t>
          </dd>
          <dt>COMMITTED:</dt>
          <dd>
            <t>The chunk is durable and globally visible.  Subsequent
CHUNK_READs return this content until a newer COMMITTED
generation replaces it.  A higher-generation PENDING successor
<bcp14>MAY</bcp14> exist concurrently; the rollback invariant in
<xref target="sec-system-model-consistency"/> requires the data server to
retain the COMMITTED content while that successor exists.</t>
          </dd>
        </dl>
        <t>Transitions are driven by the operations named on the arrows.
CHUNK_ROLLBACK against a COMMITTED chunk is used only on the
repair path (see <xref target="sec-CHUNK_ROLLBACK"/>) and replaces the chunk
with a newer COMMITTED generation chosen by the repair actor,
rather than returning the chunk to EMPTY.</t>
        <t><xref target="fig-chunk-state-machine"/> covers the lifecycle of a chunk's
payload but not the lock that may be held on it.  The lock has
its own state machine, shown in <xref target="fig-chunk-lock-machine"/>.</t>
        <figure anchor="fig-chunk-lock-machine">
          <name>Chunk lock ownership on the data server</name>
          <artwork><![CDATA[
                        CHUNK_LOCK
                     (writer acquires)
      +----------+ ----------------> +-------------------+
      | UNLOCKED |                   | LOCKED by writer  |
      +----------+ <---------------- +-------------------+
           ^           CHUNK_UNLOCK            |
           |          (writer releases)        |
           |                                   | REVOKE_STATEID
           |                                   |  (metadata server
           |                                   |   invalidates writer
           |                                   |   stateid; lock
           |                                   |   transfers to
           |                                   |   metadata-server
           |                                   |   escrow)
           |                                   v
           |        CHUNK_UNLOCK     +-------------------+
           |       or CHUNK_REPAIRED |     LOCKED by     |
           |      (repair actor     |  metadata-server  |
           |       releases after    |      escrow       |
           |       repair completes) +-------------------+
           |                                   |
           |                                   | CHUNK_LOCK with
           |                                   | CHUNK_LOCK_FLAGS_ADOPT
           |                                   |  (repair actor
           |                                   |   adopts metadata-
           |                                   |   server escrow
           |                                   |   ownership per
           |                                   |   CB_CHUNK_REPAIR)
           |                                   v
           |                         +-------------------+
           +------------------------ | LOCKED by repair  |
                                     +-------------------+
]]></artwork>
        </figure>
        <t>The lock state machine is orthogonal to the chunk lifecycle in
<xref target="fig-chunk-state-machine"/>: a chunk in any of EMPTY, PENDING,
FINALIZED, or COMMITTED <bcp14>MAY</bcp14> simultaneously be in any of the
four lock states.  The errored bit (set by CHUNK_ERROR, cleared
by CHUNK_REPAIRED) is a third orthogonal axis and is not drawn;
CHUNK_ERROR may set the bit in any state, and CHUNK_REPAIRED
clears it as part of completing a repair sequence.  A CHUNK_LOCK
that arrives while the chunk is already LOCKED by a different
owner returns NFS4ERR_CHUNK_LOCKED with the existing owner's
chunk_owner4 in clr_owner (<xref target="sec-CHUNK_LOCK"/>).</t>
      </section>
      <section anchor="sec-system-model-read-time-status">
        <name>Read-Time Generation Status</name>
        <t>Independent of the chunk lifecycle state
(<xref target="fig-chunk-state-machine"/>) and the lock state
(<xref target="sec-CHUNK_LOCK"/>), a data server distinguishes three
read-time statuses for any generation the caller names or
observes at a chunk index.  These are the higher-level
categories the CHUNK_READ per-chunk
status codes and the CHUNK_HEADER_READ discovery response classify
into:</t>
        <dl>
          <dt>AVAILABLE:</dt>
          <dd>
            <t>the generation's payload is held by the data server and
its integrity check succeeds at read time.  A
CHUNK_READ returns the payload with NFS4_OK.  A
CHUNK_HEADER_READ that observes an AVAILABLE
predecessor is the input the caller uses to decide
whether CHUNK_ROLLBACK's restore case
(<xref target="sec-CHUNK_ROLLBACK"/> "Rollback of COMMITTED
Chunks") can succeed under the caller's own retention
scope (<xref target="sec-system-model-retention-scope"/>).</t>
          </dd>
          <dt>ERRORED:</dt>
          <dd>
            <t>the owner-to-index association is still recorded but
the payload is not readable -- the persisted checksum
or guard check fails at read time
(<xref target="sec-NFS4ERR_PAYLOAD_NOT_ATOMIC"/>), the underlying
storage is unreachable, or the chunk carries the
errored bit set by an earlier CHUNK_ERROR.  A CHUNK_READ returns
NFS4ERR_PAYLOAD_NOT_ATOMIC (or another per-chunk
status appropriate to the failure); the client
reports the fault via LAYOUTERROR and the metadata
server arranges repair.  An ERRORED generation is
observable -- its owner triple can be discovered -- but
not consumable.</t>
          </dd>
          <dt>ABSENT:</dt>
          <dd>
            <t>the data server holds no generation at the requested
chunk index (the chunk is EMPTY) or holds no
generation matching the requested owner triple.  A
CHUNK_READ returns the synthetic-hole response
(<xref target="sec-CHUNK_READ"/>) or per-chunk NFS4ERR_NOENT.  A
CHUNK_HEADER_READ that names a predecessor and finds
ABSENT returns the absence in its per-chunk response
fields; a CHUNK_ROLLBACK that names such a
predecessor returns NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>) or NFS4ERR_INVAL per
the rules under "Deletion Atomicity and Invalidated
Triples" (<xref target="sec-CHUNK_ROLLBACK"/>).</t>
          </dd>
        </dl>
        <t>The three statuses are exhaustive at read time: any
generation the caller might reference is exactly one of
AVAILABLE, ERRORED, or ABSENT.  A generation can
transition from AVAILABLE to ERRORED (via CHUNK_ERROR
or a checksum failure) and from ERRORED back to
AVAILABLE (via a successful repair sequence).  The
transition from AVAILABLE or ERRORED to ABSENT is a
release under the retention scope rule
(<xref target="sec-system-model-retention-scope"/>) coupled with the
payload/association biconditional
(<xref target="sec-system-model-payload-association-biconditional"/>):
the payload and its owner-to-index association are
released together and the generation vanishes from the
observable set.  There is no transition from ABSENT
back to any observable status for the same owner
triple: the invalidated-triple rule ("Deletion
Atomicity and Invalidated Triples" under
<xref target="sec-CHUNK_ROLLBACK"/>) forbids resurrection.</t>
      </section>
      <section anchor="sec-system-model-consistency">
        <name>Consistency Guarantees</name>
        <t>The protocol provides per-chunk linearizability on COMMITTED
state:</t>
        <ol spacing="normal" type="1"><li>
            <t>Once CHUNK_COMMIT returns success to a writer for a given
chunk, every subsequent CHUNK_READ whose stateid postdates
the COMMIT observes either that writer's data or the data of
a later committed write.  A reader <bcp14>MUST NOT</bcp14> observe a
rolled-back write as if it had committed.</t>
          </li>
          <li>
            <t>Concurrent writers on the same chunk in multi-writer mode
serialize via chunk_guard4.  On guard conflict one writer
succeeds; the other receives NFS4ERR_CHUNK_GUARDED and <bcp14>MUST</bcp14>
either abandon the write or re-read and retry.  At most one
generation becomes COMMITTED per serialized decision.</t>
          </li>
          <li>
            <t>During repair, the chunk's lock is held continuously -- first
by the original writer, then transferred to the metadata-server escrow
owner on REVOKE_STATEID, and finally adopted by the repair
client via CHUNK_LOCK_FLAGS_ADOPT.  No writer that did not
hold the lock may observe or mutate the chunk.  The
invariant "a chunk with a live lock has exactly one logical
owner at any instant" is preserved across revocation.</t>
          </li>
        </ol>
        <t>Across multiple chunks the protocol makes no multi-chunk
atomicity or ordering guarantee.  A reader that reads chunk A
at one offset and chunk B at another <bcp14>MAY</bcp14> observe A's new value
and B's old value simultaneously.  Applications that require
multi-chunk atomicity <bcp14>MUST</bcp14> layer it above this protocol -- for
example, via file-level checksums, application-level generation
fields, or external transaction managers.</t>
        <dl>
          <dt>The chunk is the unit of atomicity:</dt>
          <dd>
            <t>Two properties follow.</t>
          </dd>
        </dl>
        <ol spacing="normal" type="1"><li>
            <t>Chunk-aligned writes do not interfere.  Two concurrent
writers whose writes cover disjoint chunks -- even writes
that cover adjacent chunks -- never race.  Each write
terminates independently at COMMITTED per the per-chunk
linearizability rule above.</t>
          </li>
          <li>
            <t>Sub-chunk overlapping writes from different writers
produce chunk-resolution-granularity contention.  When two
concurrent writers target overlapping byte ranges within a
single chunk, chunk_guard4 resolves them: one writer's
entire chunk-generation wins and becomes COMMITTED; the
other writer sees NFS4ERR_CHUNK_GUARDED and is expected to
re-read and retry if it wishes to apply its change on top
of the winning generation (see
<xref target="sec-NFS4ERR_CHUNK_GUARDED"/>).  The protocol does NOT
produce byte-level merges of overlapping sub-chunk writes:
the losing writer's bytes are not preserved as a partial
update within the winning generation.</t>
          </li>
        </ol>
        <t>Applications that require byte-level write merging or sub-chunk
ordering guarantees <bcp14>MUST</bcp14> serialize such writes externally, for
example via NFSv4 byte range locks (<xref target="RFC8881"/>, Section 12).
The chunk size that bounds the atomicity unit for a given file
is the product of ffv2m_striping_unit_size and the stripe width
W in <xref target="fig-striping-math"/>; applications can query
fattr4_coding_block_size (see <xref target="sec-fattr4_coding_block_size"/>)
to learn the effective chunk size and align their writes
accordingly.</t>
        <t>This choice -- chunk-boundary atomicity rather than stripe- or
block-boundary atomicity -- is load-bearing for the rest of the
consistency story: the chunk_guard4 CAS evaluates at the chunk
level, the PENDING / FINALIZED / COMMITTED state machine is per
chunk, CHUNK_LOCK is per chunk, and repair via CB_CHUNK_REPAIR
operates on chunks.  A different atomicity boundary would
require redefining those primitives.</t>
        <dl>
          <dt>Erasure-coded reads:</dt>
          <dd>
            <t>A reader of an erasure-coded file reconstructs the plaintext
from any sufficient subset of k shards of the (k + m)-shard
stripe; the guard values on those shards <bcp14>MUST</bcp14> agree.  Shards
with stale guards are ignored.  This is not a quorum read in
the Paxos sense -- there is no voting on a value; there is
only reconstruction of the single value identified by the
current guard.</t>
          </dd>
          <dt>Rollback invariant:</dt>
          <dd>
            <t>The data server <bcp14>MUST</bcp14> retain the prior FINALIZED or COMMITTED
content of a chunk while any successor PENDING or FINALIZED
chunk exists.
A corollary of this rule is the lowest-guard-recoverable
property: as long as at least k data servers in the mirror
set retain the chunk at some generation G or lower, the
payload that was COMMITTED at generation G (or earlier) can
be reconstructed.  This is the correctness basis for
CHUNK_ROLLBACK (see <xref target="sec-CHUNK_ROLLBACK"/>): rollback does not
synthesize data, it simply selects the lowest-generation
chunks whose guards agree across the mirror set and discards
the higher-generation PENDING or FINALIZED chunks that
triggered the rollback.  The protocol never relies on locating
or reconstructing data from outside the mirror set.</t>
          </dd>
          <dt>Visibility of non-committed state:</dt>
          <dd>
            <t>PENDING and FINALIZED chunks <bcp14>MUST NOT</bcp14> be globally visible.
CHUNK_READ returns only COMMITTED content; a CHUNK_READ whose
target chunk is currently PENDING or FINALIZED sees the
predecessor COMMITTED content (or an EMPTY chunk if none
exists), not the in-progress successor.  A writer observing
its own PENDING or FINALIZED chunk <bcp14>MAY</bcp14> receive the in-progress
content on the same stateid that produced it, but no other
stateid -- on the same or a different client -- sees it.
The retention window that makes the prior COMMITTED content
available to CHUNK_READ and to CHUNK_ROLLBACK is itself
bounded; see <xref target="sec-system-model-retention-scope"/> for the
normative scoping rule.</t>
          </dd>
        </dl>
      </section>
      <section anchor="sec-system-model-retention-scope">
        <name>Ownership and Scope of Retained Prior Content</name>
        <t>The rollback invariant in <xref target="sec-system-model-consistency"/>
requires a data server to retain the prior FINALIZED or
COMMITTED content of a chunk while any successor PENDING or
FINALIZED chunk exists.  That retained content -- sometimes informally called
the "safe buffer" -- is not global state.  It is scoped to the
stateid that wrote the PENDING successor, and its retention and
visibility are governed by that owning stateid's lease.</t>
        <dl>
          <dt>Owner:</dt>
          <dd>
            <t>The data server <bcp14>MUST</bcp14> record, alongside each PENDING chunk,
the owning stateid (the stateid presented on the CHUNK_WRITE
that produced the PENDING).  This is the owning writer's
stateid; it identifies the client and openowner/lockowner
that the data server will release the PENDING to on
CHUNK_FINALIZE or CHUNK_COMMIT, and that the metadata server will treat
as the authoritative owner for purposes of
<xref target="sec-system-model-progress"/>.</t>
          </dd>
          <dt>Visibility:</dt>
          <dd>
            <t>Before transition to COMMITTED, the PENDING content is
visible only on the owning stateid.  A CHUNK_READ presenting
any other stateid (from the same client or a different
client) <bcp14>MUST</bcp14> observe the predecessor COMMITTED or EMPTY
state, not the PENDING successor.  This is the normative
form of the "non-committed data <bcp14>MUST NOT</bcp14> be globally visible"
rule stated in the "Visibility of non-committed state"
bullet of <xref target="sec-system-model-consistency"/>.</t>
          </dd>
          <dt>Retention window:</dt>
          <dd>
            <t>The data server <bcp14>MUST</bcp14> retain the predecessor COMMITTED (or
FINALIZED) content that the PENDING is superseding for as
long as the owning stateid's lease is valid.  If the owning
stateid's lease expires without the PENDING reaching
COMMITTED, the retention obligation for that PENDING ends
(see <xref target="sec-system-model-progress"/> for the scavenger rule
that drives demotion).  If the PENDING does reach COMMITTED,
the new COMMITTED generation supersedes the prior one under
the standard rollback invariant and its own retention is
governed by any newer PENDING successor.</t>
          </dd>
        </dl>
        <t>The practical effect is that the "safe buffer" for a chunk is
not an unbounded chunk-global state but a per-writer window
bounded by that writer's lease.  The data server always has a
rule for discarding retained prior content -- it is the
owning stateid's lease expiry -- so a chunk cannot accumulate
indefinitely many retained generations even in the presence of
dropped or partitioned writers.</t>
      </section>
      <section anchor="sec-system-model-owner-persistence">
        <name>Owner-to-Index Persistence Coupling</name>
        <t>The wire lifecycle operations (CHUNK_COMMIT, CHUNK_FINALIZE, CHUNK_ROLLBACK) name generations by full
owner triple
(<xref target="sec-chunk_owner4"/>) and require the data server to
locate the chunk-index each triple was written at.  For
that lookup to succeed after a data server restart, the
data server <bcp14>MUST</bcp14> persist the owner-to-index association
with a durability floor that matches the payload's:
without the association the payload can never again be
addressed by a lifecycle operation.</t>
        <dl>
          <dt>Uniqueness invariant (normative):</dt>
          <dd>
            <t>An accepted owner triple is
UNIQUE across the live generations the data server holds
for a given file: at any instant there is at most one
live generation on any chunk of the file that matches
that full triple.  Two writers with distinct co_client_id
values cannot collide.  A single writer that reuses a
co_cohort_id + co_id pair within the same co_client_id
across two distinct chunk indices <bcp14>MUST NOT</bcp14> do so while
the earlier generation remains live; the data server <bcp14>MAY</bcp14>
reject a CHUNK_WRITE that attempts to create such a
collision with NFS4ERR_INVAL in the corresponding
cwr_block_status slot.  The predecessor-retention rule
(<xref target="sec-system-model-consistency"/>) is compatible: a
retained predecessor and its successor on the same
chunk index <bcp14>MUST</bcp14> carry distinct triples (typically
distinct co_cohort_id under a shared co_client_id) so that
CHUNK_ROLLBACK can name each unambiguously.</t>
          </dd>
          <dt>Durability floor (normative, per CHUNK_WRITE <xref target="sec-CHUNK_WRITE"/> "Stability and Activation"):</dt>
          <dd>
            <t>The durability requirement varies by the CHUNK_WRITE
stability level:</t>
            <dl>
              <dt>FILE_SYNC4:</dt>
              <dd>
                <t>both the chunk payload AND its owner-to-index
association <bcp14>MUST</bcp14> survive a data server restart.</t>
              </dd>
              <dt>DATA_SYNC4:</dt>
              <dd>
                <t>both the chunk payload AND its owner-to-index
association <bcp14>MUST</bcp14> survive a data server restart.
(The association is retrieval metadata for the
payload; it shares the payload's durability floor.
An implementation <bcp14>MAY</bcp14> treat DATA_SYNC4 identically
to FILE_SYNC4.)</t>
              </dd>
              <dt>UNSTABLE4:</dt>
              <dd>
                <t>the association <bcp14>MAY</bcp14> be lost on restart, but ONLY if
the payload is also lost.  A data server <bcp14>MUST NOT</bcp14>
retain payload without its associated owner triple;
a payload whose association was lost is
unaddressable by every lifecycle operation and <bcp14>MUST</bcp14>
be treated as destroyed.  cwr_writeverf changes on
any restart that loses UNSTABLE4 state, allowing the
client to detect the loss.</t>
              </dd>
            </dl>
          </dd>
        </dl>
        <t>A data server that cannot honor the durability floor
for a given stability level <bcp14>MUST</bcp14> reject the CHUNK_WRITE
with NFS4ERR_IO rather than accepting the payload without
its association.</t>
        <t>The retention scope rule (<xref target="sec-system-model-retention-scope"/>)
governs WHEN a predecessor generation's payload +
association may be released; the payload/association
biconditional in the next subsection governs the
INVARIANT that whenever the payload survives, the
association survives with it, and vice versa.</t>
      </section>
      <section anchor="sec-system-model-payload-association-biconditional">
        <name>Payload and Association Biconditional</name>
        <t>For every generation the data server holds -- PENDING,
FINALIZED, or COMMITTED, including any predecessor
retained under the rollback invariant
(<xref target="sec-system-model-retention-scope"/>) -- the chunk
payload and its owner-to-index association
(<xref target="sec-system-model-owner-persistence"/>) <bcp14>MUST</bcp14> share a
lifetime.  A conforming data server <bcp14>MUST NOT</bcp14> release
one while retaining the other:</t>
        <dl>
          <dt><bcp14>MUST NOT</bcp14> retain payload without association:</dt>
          <dd>
            <t>A chunk payload whose owner-to-index association has
been released is unaddressable by every lifecycle
operation (CHUNK_COMMIT,
CHUNK_FINALIZE,
CHUNK_ROLLBACK) because
those operations name generations by full owner
triple (<xref target="sec-chunk_owner4"/>).  A data server that
cannot locate the recorded chunk index for a
presented triple returns the appropriate per-entry
error under the release-scope split at
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>: NFS4ERR_INVAL when
the data server holds a concrete invalidation
context that identifies the triple (structurally
invalid, or released by an explicit CHUNK_ROLLBACK
delete case within the session slot's replay-cache
window), NFS4ERR_NO_PREDECESSOR otherwise.
Retaining the payload while making it unaddressable
serves no purpose and is prohibited.  The payload <bcp14>MUST</bcp14> be released
atomically with the association.</t>
          </dd>
          <dt><bcp14>MUST NOT</bcp14> release association while retaining payload:</dt>
          <dd>
            <t>A recorded owner-to-index association refers to a specific
chunk payload; the data server <bcp14>MUST NOT</bcp14> retain the
association after releasing that payload.  A subsequent
CHUNK_READ or lifecycle operation whose recorded index still
points to a released payload would return data whose
provenance the client cannot verify against its own writer
history; forbidding this releases the client from having to
detect such stale associations.</t>
          </dd>
        </dl>
        <t>The biconditional is symmetric: released together,
retained together.  This coupling is what makes
CHUNK_ROLLBACK's delete case (<xref target="sec-CHUNK_ROLLBACK"/>)
atomic -- invalidating a generation drops BOTH the
association and the payload in one step -- and what
makes CHUNK_ROLLBACK's restore case rely on the
predecessor's association surviving with its payload
as a single unit.  Data servers implementing an
on-disk chunk store <bcp14>SHOULD</bcp14> treat the association and
payload as the crash-consistent atomic unit at the
storage layer.</t>
        <t>The retention scope rule
(<xref target="sec-system-model-retention-scope"/>) governs WHEN the
pair may be released (bounded by the owning stateid's
lease and any successor's presence); this
biconditional governs the INVARIANT that whenever the
release happens, the two go together.</t>
      </section>
      <section anchor="sec-system-model-progress">
        <name>Progress and Termination</name>
        <t>Under the failure model above, the protocol guarantees the
following progress properties:</t>
        <dl>
          <dt>Data-path progress:</dt>
          <dd>
            <t>If all mirrors are reachable and none are failed, a
CHUNK_WRITE followed by CHUNK_FINALIZE followed by
CHUNK_COMMIT completes in O(1) round trips independent of
cluster size.  In particular, there is no consensus round,
no leader election, and no quorum voting on the write
itself.  The three operations <bcp14>MAY</bcp14> be amortized across
compounds: a steady-state writer sending a series of
CHUNK_WRITEs can piggyback the CHUNK_FINALIZE of the previous
write on the compound that carries the next write (for
example, <tt>SEQUENCE + PUTFH + CHUNK_FINALIZE + CHUNK_WRITE</tt>),
reducing the data-path happy case to a single round trip per
CHUNK_WRITE rather than three.  The CHUNK_COMMIT for the
final write in a sequence <bcp14>MAY</bcp14> similarly ride on the CLOSE
compound.  These compound-packing optimizations are
permitted by the normal NFSv4.2 compound rules and require
no protocol extensions.</t>
          </dd>
          <dt>Repair termination:</dt>
          <dd>
            <t>Every CB_CHUNK_REPAIR completes in bounded time.  The client
selected as the repair actor either:
</t>
            <ol spacing="normal" type="1"><li>
                <t>returns NFS4_OK for every range in ccra_ranges (repair
succeeded), or</t>
              </li>
              <li>
                <t>returns NFS4ERR_PAYLOAD_LOST for one or more ranges (the
erasure coding lost too many shards to reconstruct; the
data is permanently unrecoverable), or</t>
              </li>
              <li>
                <t>fails to respond within the ccra_deadline, in which case
the metadata server <bcp14>MUST</bcp14> re-select under the rules in
<xref target="sec-repair-selection"/> or <bcp14>MUST</bcp14> declare the ranges lost.</t>
              </li>
            </ol>
            <t>NFS4ERR_PAYLOAD_LOST is terminal for the affected ranges.
The protocol makes no further attempt to recover them.</t>
          </dd>
          <dt>Eventual trust-table convergence:</dt>
          <dd>
            <t>After a metadata server restart, each data server's trust
table converges to the metadata server's view within one
metadata-server lease period.  Entries that the metadata
server does not re-issue expire naturally via tsa_expire;
entries that the metadata server does re-issue transition
from pending-revalidation back to active on the next
TRUST_STATEID (see <xref target="sec-tight-coupling-mds-crash"/>).</t>
          </dd>
          <dt>Orphaned PENDING scavenger:</dt>
          <dd>
            <t>A PENDING chunk whose owning stateid (see
<xref target="sec-system-model-retention-scope"/>) has expired without
transition to FINALIZED or COMMITTED is an orphan.  The
metadata server <bcp14>MUST</bcp14> drive demotion of orphaned PENDINGs so
that no chunk remains in a non-terminal state indefinitely:
</t>
            <ol spacing="normal" type="1"><li>
                <t>When an owning stateid's lease expires, the metadata
server identifies every PENDING chunk owned by that
stateid (either from its own bookkeeping or by query
against the data server) and issues the control-plane
operations needed to demote each PENDING.</t>
              </li>
              <li>
                <t>Demotion replaces the PENDING with the predecessor
COMMITTED (or EMPTY) content that the data server has
been retaining under
<xref target="sec-system-model-retention-scope"/>.  The data server
<bcp14>MUST NOT</bcp14> wait for a separate client action before
performing the demotion.</t>
              </li>
              <li>
                <t>Any CHUNK_LOCK held in escrow on behalf of the expired
stateid (see <xref target="sec-chunk_guard_mds"/>) is released after
a metadata-server-defined grace period.  The grace period exists to
let a recovering client reclaim its lock via the grace /
reclaim path defined in <xref target="RFC8881"/>; on expiry of the
grace period without reclaim, the lock becomes available
for new CHUNK_LOCK_FLAGS_ADOPT acquirers.</t>
              </li>
            </ol>
            <t>The scavenger timeout (the delay between lease expiry and
demotion) is implementation-defined but <bcp14>SHOULD</bcp14> be tied to
the metadata server lease period so that it composes
naturally with existing NFSv4 grace / reclaim semantics.  A
scavenger timeout shorter than the lease risks racing an
in-progress client reclaim; a timeout substantially longer
than the lease extends the retention budget without a
commensurate benefit.</t>
            <t>A late-arriving client op against a demoted PENDING sees
NFS4ERR_BAD_STATEID under trusted-stateid tight coupling
(<xref target="sec-REVOKE_STATEID"/>) or NFS4ERR_NO_PREDECESSOR under
loose coupling (<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>); a
CHUNK_LOCK reclaim after the grace period fails per the
RFC 8881 grace-reclaim semantics.</t>
          </dd>
        </dl>
        <t>The protocol does NOT guarantee progress if the metadata server
is unavailable for longer than its lease period -- this is the
standard NFSv4 lease assumption and is inherited unchanged.</t>
      </section>
      <section anchor="sec-system-model-consensus">
        <name>Relation to Classical Consensus</name>
        <t>Classical consensus protocols (Paxos, Raft, Viewstamped
Replication) solve the problem of reaching agreement among
mutually-distrusting replicas in the absence of a trusted
coordinator.  They typically cost two or three round trips per
decision, require a majority of replicas to be live and
reachable for progress, and impose the overhead of leader
election and log replication.</t>
        <t>This protocol is not a consensus protocol and does not attempt
to be.  Its approach instead is:</t>
        <dl>
          <dt>Designated coordinator:</dt>
          <dd>
            <t>The metadata server is the
coordinator for a file.  Clients accept the metadata server's authority
for layout grants, stateid registration, repair actor
selection, and revocation.  This assumption is the same one
made by <xref target="RFC8434"/> and all pNFS layout types to date.</t>
          </dd>
          <dt>Per-chunk CAS, not per-chunk voting:</dt>
          <dd>
            <t>Concurrent writes
on the same chunk serialize via chunk_guard4 as a CAS
primitive (see <xref target="sec-chunk_guard4"/>).  No replica vote is
required; the data server that owns the chunk evaluates the
guard locally and rejects stale writes with
NFS4ERR_CHUNK_GUARDED.</t>
          </dd>
          <dt>Pessimistic locks off the critical path:</dt>
          <dd>
            <t>CHUNK_LOCK is
used only during repair, never on the normal write path.
Lock escrow (see <xref target="sec-chunk_guard_mds"/>) preserves the
"exactly one owner" invariant across stateid revocation
without requiring a consensus round to elect the next owner.</t>
          </dd>
          <dt>Erasure-coded reads replace quorum reads:</dt>
          <dd>
            <t>A reader
reconstructs from any k of k + m shards with matching guards.
No voting is needed because there is no disagreement to
resolve: the guard identifies the single generation that was
committed.</t>
          </dd>
        </dl>
        <t>The result is a data path with O(1) round-trip cost independent
of the number of replicas, and a repair path whose cost is
bounded by the number of affected chunks rather than by the
cluster size.</t>
        <t>Metadata-server high availability is orthogonal.  Deployments
that require a highly-available metadata server <bcp14>MAY</bcp14> replicate
metadata-server state across multiple metadata server instances
using classical consensus (Raft, Paxos, or equivalent).  Such
replication is implementation-defined; from a pNFS client's
perspective a highly-available metadata server looks like a
single metadata server that occasionally resets its session and
triggers grace-period reclaim, and the client's behavior is
already specified by <xref target="RFC8881"/>.  This protocol neither
requires nor precludes such an implementation.</t>
      </section>
      <section anchor="sec-system-model-nongoals">
        <name>Non-Goals</name>
        <t>For clarity, the protocol explicitly does not provide:</t>
        <dl>
          <dt>Byzantine fault tolerance:</dt>
          <dd>
            <t>A data server that
deliberately misreports its state, or a client that
bypasses its own authentication, is outside the trust model.
Deployments requiring Byzantine tolerance <bcp14>MUST</bcp14> add it in a
layer above or below this protocol.</t>
          </dd>
          <dt>Metadata server high availability:</dt>
          <dd>
            <t>Single-metadata-server-per-file is the protocol model.  Metadata server
high availability, if deployed, is implemented below the wire
protocol and transparent to clients.</t>
          </dd>
          <dt>Cross-file atomicity:</dt>
          <dd>
            <t>Writes to multiple files are not
atomic at the protocol level.  File-system-level transactions
are not defined.</t>
          </dd>
          <dt>Multi-chunk atomicity within a single file:</dt>
          <dd>
            <t>COMMITs on
distinct chunks are independent.  A reader may observe a
partial write across chunks; applications must layer their
own consistency if they need otherwise.</t>
          </dd>
          <dt>Global linearizability across unrelated files:</dt>
          <dd>
            <t>Each
file's COMMITTED state is linearizable in isolation; no
total order is defined across files.</t>
          </dd>
          <dt>Authenticated malicious client protection:</dt>
          <dd>
            <t>An
authenticated client may write garbage into its own chunks
with a correctly computed checksum; see
<xref target="sec-security-checksum-scope"/>.  A bit-flip-class checksum
is a transport-integrity check, not an adversarial-integrity
check; cryptographic-class checksums detect adversarial
modification by anyone other than the authenticated writer.</t>
          </dd>
        </dl>
      </section>
    </section>
    <section anchor="nfsv42-operations-allowed-to-data-files">
      <name>NFSv4.2 Operations Allowed to Data Files</name>
      <t>In the Flexible File Version 1 Layout Type (<xref target="RFC8435"/>), the data path
between client and data server was NFSv3 (<xref target="RFC1813"/>); the
operations a client sent to a data file were limited to READ,
WRITE, and COMMIT, and the operations the metadata server sent on
its control plane to the data server were limited to GETATTR,
SETATTR, CREATE, and REMOVE.  An NFSv4.2 data server, as used by
the Flexible File Version 2 Layout Type, exposes a much larger
operation set.  This section defines which operations a client <bcp14>MAY</bcp14>
send to a data file, which operations the metadata server <bcp14>MAY</bcp14>
send, and which operations a data server <bcp14>MUST</bcp14> reject.</t>
      <t>The restrictions below apply only to operations directed at a data
file on a data server.  Clients retain the full NFSv4.2 operation
set for files visible through the metadata server, including the
operations prohibited below (RENAME, LINK, CLONE, COPY, ACL-scoped
SETATTR, and so on).  The metadata server <bcp14>MAY</bcp14> internally use
operations on data files that clients <bcp14>MUST NOT</bcp14> send, as part of
its control-plane duties for the file (see
<xref target="sec-system-model-roles"/>).</t>
      <section anchor="sec-ops-mds">
        <name>Control Plane: Metadata Server to Data Server</name>
        <t>When the metadata server acts as a client to a data server, it is
managing the data file on behalf of the metadata file's namespace.
A data server <bcp14>MUST</bcp14> support the following operations on data files
when issued by the metadata server:</t>
        <ul spacing="normal">
          <li>
            <t>SEQUENCE, PUTFH, PUTROOTFH, GETFH (<xref target="RFC8881"/> Sections 18.46,
18.19, 18.21, 18.8): session and filehandle plumbing.</t>
          </li>
          <li>
            <t>LOOKUP (<xref section="18.15" sectionFormat="of" target="RFC8881"/>): directory traversal
the metadata server issues when locating data files it has
allocated for its use.</t>
          </li>
          <li>
            <t>GETATTR (<xref section="18.7" sectionFormat="of" target="RFC8881"/>): the metadata server issues
GETATTR against the data file after a write layout is returned,
to pull the post-write size, mtime, and other attributes back
and reconcile its cached view.  Any other attribute queries
the metadata server needs for the same purpose use the same
operation.</t>
          </li>
          <li>
            <t>SETATTR (<xref section="18.30" sectionFormat="of" target="RFC8881"/>): data file truncate for
metadata-server-level SETATTR(size) fan-out, synthetic uid/gid rotation
for fencing, and mode-bit initialization when the metadata
server binds a data file to a new metadata-level file.</t>
          </li>
          <li>
            <t>CREATE (<xref section="18.4" sectionFormat="of" target="RFC8881"/>): the metadata server's own
allocation of data files on the data server.</t>
          </li>
          <li>
            <t>REMOVE (<xref section="18.25" sectionFormat="of" target="RFC8881"/>): cleanup on metadata server file
unlink.</t>
          </li>
          <li>
            <t>OPEN, CLOSE (<xref target="RFC8881"/> Sections 18.16, 18.2): used by the
metadata server when it acts as a client to the data server
for I/O routed through the metadata server or through a
proxy server on the metadata server's behalf.</t>
          </li>
          <li>
            <t>EXCHANGE_ID, CREATE_SESSION, DESTROY_SESSION,
BIND_CONN_TO_SESSION, DESTROY_CLIENTID (<xref target="RFC8881"/> Sections
18.35, 18.36, 18.37, 18.34, 18.50): control-session
management.  The metadata server sets
EXCHGID4_FLAG_USE_PNFS_MDS in its EXCHANGE_ID.  A data
server that supports the tight coupling control protocol
(see <xref target="sec-tight-coupling-control-session"/>) identifies the
metadata server's session by EXCHGID4_FLAG_USE_PNFS_MDS and
accepts TRUST_STATEID, REVOKE_STATEID, and
BULK_REVOKE_STATEID on that session.</t>
          </li>
          <li>
            <t>TRUST_STATEID, REVOKE_STATEID, BULK_REVOKE_STATEID: the metadata-server-to-data-server tight coupling
trust-table control operations.</t>
          </li>
        </ul>
        <t>The metadata server <bcp14>MAY</bcp14> also use other NFSv4.2 operations on data
files as implementation-defined control-plane actions (for
example, COPY or CLONE to migrate a data file between data
servers during a proxy server operation).  The list above is the
minimum set a flexible file v2 layout data server <bcp14>MUST</bcp14> support for the
metadata server's use.</t>
      </section>
      <section anchor="sec-ops-client">
        <name>Data Path: Client to Data Server</name>
        <t>A pNFS client with an active flexible file v2 layout <bcp14>MUST</bcp14> restrict
the operations it issues against data files to the operations
defined below.  A data server that has identified the file as a
chunked data file (see <xref target="sec-data-file-identification"/>) <bcp14>MUST</bcp14>
reject any other operation on that file with NFS4ERR_NOTSUPP.</t>
        <section anchor="sec-data-file-identification">
          <name>Data-File Identification on the Data Server</name>
          <t>The "<bcp14>MUST</bcp14> reject" rules in this section apply on the data server
side only to files the data server has identified as chunked data
files.  A data server identifies a file by any of the following
means, in decreasing order of authority:</t>
          <dl>
            <dt>fattr4_chunked_data_file = TRUE:</dt>
            <dd>
              <t>The metadata server has set this attribute
(<xref target="sec-fattr4_chunked_data_file"/>) when it allocated the
file as a chunked data file.  This is the authoritative
per-file identification and is required for a data server that
supports the attribute.</t>
            </dd>
            <dt>Live TRUST_STATEID entry for the file:</dt>
            <dd>
              <t>Under trusted-stateid tight coupling
(<xref target="sec-tight-coupling-control"/>), a live trust entry for the
file registered via TRUST_STATEID
identifies the file as under flexible file v2 layout
management.  This is a
fallback for data servers that do not yet support
fattr4_chunked_data_file, and it is per-client rather
than per-file, but it is sufficient to trigger the "<bcp14>MUST</bcp14>
reject" rules for that client's operations against the file.</t>
            </dd>
            <dt>Deployment namespace convention:</dt>
            <dd>
              <t>Deployments <bcp14>SHOULD</bcp14> export chunked data files in a namespace
scope not shared with client-accessible file access, as one
means of preventing a misconfigured or malicious client from
reaching data files through a normal NFS mount.  A data server
<bcp14>MAY</bcp14> apply the "<bcp14>MUST</bcp14> reject" rules to every file in a
namespace configured for flexible file v2 layout data-file
service, without
per-file classification.  Note that a separate NFS export
does not close direct filesystem access on the data server
host itself; that is outside the scope of this specification.</t>
            </dd>
          </dl>
          <t>If none of the above identifies the file, the data server cannot
reliably classify it and the client-side "<bcp14>MUST NOT</bcp14>" rules in this
section remain the primary defense.  Client-side compliance is
mandatory in all deployment modes regardless of what the data
server can enforce.</t>
        </section>
        <section anchor="session-and-identity-plumbing">
          <name>Session and Identity Plumbing</name>
          <t>Required for all protection modes:</t>
          <ul spacing="normal">
            <li>
              <t>SEQUENCE, PUTFH, GETFH, PUTROOTFH (<xref target="RFC8881"/> Sections 18.46,
18.19, 18.8, 18.21).</t>
            </li>
            <li>
              <t>EXCHANGE_ID, CREATE_SESSION, DESTROY_SESSION,
BIND_CONN_TO_SESSION, DESTROY_CLIENTID (<xref target="RFC8881"/> Sections
18.35, 18.36, 18.37, 18.34, 18.50).</t>
            </li>
            <li>
              <t>RECLAIM_COMPLETE (<xref section="18.51" sectionFormat="of" target="RFC8881"/>).</t>
            </li>
            <li>
              <t>SECINFO, SECINFO_NO_NAME (<xref target="RFC8881"/> Sections 18.29, 18.45):
discovery of acceptable security flavors on the data
server.</t>
            </li>
          </ul>
          <t>These operations are baseline NFSv4.2 session plumbing and are
supported on data files as on any NFSv4.2 file.</t>
        </section>
        <section anchor="sec-ds-stateid-model">
          <name>Stateid Model on the Data Server</name>
          <t>The stateid presented on a CHUNK operation is a layout
stateid returned by a prior LAYOUTGET against the metadata
server (see <xref section="18.43" sectionFormat="of" target="RFC8881"/>), NOT an open
stateid, byte range lock stateid, or delegation stateid.  A
pNFS client does NOT issue OPEN against the data server.
This is a meaningful departure from the stateid model in
<xref section="18.32" sectionFormat="of" target="RFC8881"/> (which states that the WRITE
stateid "represents a value returned from a previous
byte range LOCK or OPEN request or the stateid associated
with a delegation"), and clients implementing
Flexible File Version 2 <bcp14>MUST NOT</bcp14> carry over those
expectations to the data path.</t>
          <t>The three roles the RFC 8881 stateid plays on a regular
NFSv4 server split apart in the Flexible File Version 2
data-server model:</t>
          <dl>
            <dt>Open and share-mode tracking:</dt>
            <dd>
              <t>Lives at the metadata server, established by OPEN
(<xref section="18.16" sectionFormat="of" target="RFC8881"/>) on the metadata-server
filehandle.  The metadata server's open stateid is NOT
exposed to data servers; share-mode conflicts are
resolved at the metadata server before LAYOUTGET grants
a layout.</t>
            </dd>
            <dt>Byte-range lock tracking:</dt>
            <dd>
              <t>Does not apply at the data server.  Locking on the data
path is chunk-range rather than byte range, expressed
via CHUNK_LOCK, and the lock holder
is identified by chunk_owner4 (the (co_cohort_id,
co_client_id, co_id) triple) rather than by a lock stateid.  A
client wanting byte range locks on a file <bcp14>MUST</bcp14> acquire
them on the metadata-server filehandle, where standard
<xref section="12" sectionFormat="of" target="RFC8881"/> byte range locking applies.</t>
            </dd>
            <dt>I/O authorization on the data server:</dt>
            <dd>
              <t>The layout stateid carried on CHUNK operations.
encodings that use CHUNK operations require tight coupling
(<xref target="sec-ff_device_addr4"/>); the metadata server registers
each issued layout stateid with the data server via
TRUST_STATEID together with the
ffv2m_client_id assigned to the writer, and the data
server validates subsequent CHUNK operation stateids against
the trust table and the presented cwa_client_id
against the trust-table's tsa_client_id.  Loose coupling
applies only to PASSTHROUGH mirrors, which use regular
READ/WRITE authorized by the synthetic uid/gid the layout
carries (see <xref target="sec-Fencing-Clients"/>).</t>
            </dd>
          </dl>
          <t>Because the layout stateid does authorization but does not
identify a per-open or per-lock owner, a single client may
present the same layout stateid on many CHUNK operations
across many parallel writers within the client, without any
of the open-owner ordering constraints <xref section="8.2.2" sectionFormat="of" target="RFC8881"/>
imposes on regular NFSv4 stateids.  Chunk-level write ordering and
contention are resolved by the per-chunk chunk_guard4 CAS
(<xref target="sec-chunk_guard4"/>) and the chunk-range CHUNK_LOCK, not by
stateid-owner sequencing.</t>
        </section>
        <section anchor="getattr-on-a-data-file">
          <name>GETATTR on a Data File</name>
          <t>GETATTR <bcp14>MAY</bcp14> be issued by a client against a data file.  The
primary use case is repair: a repair actor selected by
CB_CHUNK_REPAIR may need to query the
per-server file size or allocation state when reconstructing a
payload, and the proxy server described informally in
<xref target="sec-system-model-roles"/> similarly benefits from attribute
queries on surviving mirrors.  Diagnostic use is also permitted.</t>
          <t>Clients <bcp14>MUST NOT</bcp14> treat GETATTR values returned by a data server as
authoritative for any file attribute (size, timestamps, owner,
mode, ACL, and so on).  The metadata server is the sole authority
for file attributes.  Values returned by a data server reflect the
per-server data file instance only and <bcp14>MAY</bcp14> diverge from the
metadata server's view, particularly during a write layout's
lifetime or during a proxy server transition.  A client that uses a
data-server GETATTR result to determine the file's visible size
will observe inconsistencies.</t>
        </section>
        <section anchor="sec-setattr-on-data-file">
          <name>SETATTR on a Data File</name>
          <t>Clients <bcp14>MUST NOT</bcp14> issue SETATTR against a data file.  A data server
that has identified the file as a chunked data file (see
<xref target="sec-data-file-identification"/>) <bcp14>MUST</bcp14> reject a client SETATTR
with NFS4ERR_NOTSUPP.</t>
          <t>Attribute changes on data files <bcp14>MUST</bcp14> be reconciled with the
metadata server's view and cannot be applied unilaterally by a
client.  A client that wants to truncate, change the mode, change
ownership, or otherwise modify attributes on a file <bcp14>MUST</bcp14> issue
SETATTR to the metadata server for the file's metadata server handle; the
metadata server fans the change out to the data files as a
control-plane operation.</t>
          <t>This rule explicitly covers truncate (SETATTR with size in the
bitmap): a client <bcp14>MUST NOT</bcp14> truncate a data file directly.  See
<xref target="sec-mds-truncate-ec"/> for how the metadata server handles
truncate on chunked files.  Similarly, a client <bcp14>MUST NOT</bcp14>
issue DEALLOCATE against a data file; see the next subsection.</t>
        </section>
        <section anchor="sec-mds-truncate-ec">
          <name>Metadata-Server-Driven Truncate on Chunked Files</name>
          <t>A client that wants to truncate a chunked file <bcp14>MUST</bcp14>
issue SETATTR(FATTR4_SIZE) to the metadata-server filehandle
(see <xref target="sec-setattr-on-data-file"/>).  The metadata server
translates the logical truncate into per-shard size changes
across the data servers in each mirror.  For
FFV2_ENCODING_REPLICATED, per-shard size equals the logical
truncate size; for erasure-coded encodings the per-shard sizes
are derived from the geometry parameters below.</t>
          <dl>
            <dt>Stripe-aligned truncate:</dt>
            <dd>
              <t>When the new size lies on a stripe boundary (including
zero), no chunk re-encoding is required.  The metadata
server computes per-shard sizes from the encoding geometry it
issued in the layout (k, m, and the projection parameters
for Mojette; see <xref target="sec-mojette-encoding"/>) and issues
per-data-server SETATTR(FATTR4_SIZE) with the computed
per-shard size.  Geometry parameters are sufficient
arithmetic; no encoding implementation is required at the
metadata server.</t>
            </dd>
            <dt>Non-stripe-aligned truncate:</dt>
            <dd>
              <t>When the new size falls within a stripe, the data shards
covering the partial stripe must be truncated and the
parity shards re-encoded from the truncated data.  Because
re-encoding requires running the erasure transform, the
metadata server <bcp14>MUST</bcp14> delegate this case to an encoding-aware
actor: either a proxy server for proxy-mediated truncate, or
an encoding-aware client selected per <xref target="sec-repair-selection"/>
via CB_CHUNK_REPAIR with the
affected partial-stripe chunks as the repair target.  If
neither path is available, the metadata server <bcp14>MUST</bcp14> return
NFS4ERR_NOTSUPP to the originating SETATTR.</t>
            </dd>
          </dl>
          <t>The metadata server knows encoding geometry from the layout but
is not required to include an encoding implementation.  The
delegation rule above accommodates a metadata server that has
geometry knowledge only.</t>
        </section>
        <section anchor="passthrough-data-files-ffv2encodingpassthrough">
          <name>PASSTHROUGH Data Files (FFV2_ENCODING_PASSTHROUGH)</name>
          <t>For a mirror whose ffv2m_encoding_type_data is
FFV2_ENCODING_PASSTHROUGH (see <xref target="sec-encoding-passthrough"/>),
client operations on the data file follow the same pattern as
the File Layout Type in <xref section="13.6" sectionFormat="of" target="RFC8881"/> and the
Flexible File Version 1 Layout Type in <xref target="RFC8435"/>:</t>
          <t>Required:</t>
          <ul spacing="normal">
            <li>
              <t>READ (<xref section="18.22" sectionFormat="of" target="RFC8881"/>).</t>
            </li>
            <li>
              <t>WRITE (<xref section="18.32" sectionFormat="of" target="RFC8881"/>).</t>
            </li>
            <li>
              <t>COMMIT (<xref section="18.3" sectionFormat="of" target="RFC8881"/>).</t>
            </li>
          </ul>
          <t>Optional (the client <bcp14>MAY</bcp14> send, and the data server <bcp14>MAY</bcp14> support):</t>
          <ul spacing="normal">
            <li>
              <t>READ_PLUS (<xref section="15.10" sectionFormat="of" target="RFC7862"/>): hole-aware reads.</t>
            </li>
            <li>
              <t>SEEK (<xref section="15.11" sectionFormat="of" target="RFC7862"/>): hole and data detection.</t>
            </li>
            <li>
              <t>ALLOCATE (<xref section="15.1" sectionFormat="of" target="RFC7862"/>): space reservation hint.</t>
            </li>
          </ul>
          <t>The client <bcp14>MUST NOT</bcp14> send:</t>
          <ul spacing="normal">
            <li>
              <t>DEALLOCATE (<xref section="15.4" sectionFormat="of" target="RFC7862"/>): hole punching is a
metadata-server responsibility; the client issues DEALLOCATE
on the metadata-server filehandle, and the metadata server
fans out to the data servers as a control-plane operation.</t>
            </li>
          </ul>
        </section>
        <section anchor="chunked-data-files">
          <name>Chunked Data Files</name>
          <t>For a mirror whose ffv2m_encoding_type_data is any of the chunked
encoding types defined in this document -- i.e., every
FFV2<em>ENCODING</em>* value except FFV2_ENCODING_PASSTHROUGH (see
<xref target="sec-encoding-passthrough"/>) -- client operations use the
CHUNK operations rather than READ / WRITE / COMMIT.  This
includes FFV2_ENCODING_REPLICATED, whose per-shard payload is
the input bytes verbatim but is dispatched via the CHUNK
operations to carry the per-chunk checksum and guard
(<xref target="tbl-ops-allowed"/> legend).</t>
          <t>Required for all chunked clients:</t>
          <ul spacing="normal">
            <li>
              <t>CHUNK_WRITE.</t>
            </li>
            <li>
              <t>CHUNK_READ.</t>
            </li>
            <li>
              <t>CHUNK_FINALIZE.</t>
            </li>
            <li>
              <t>CHUNK_COMMIT.</t>
            </li>
            <li>
              <t>CHUNK_HEADER_READ.</t>
            </li>
            <li>
              <t>CHUNK_LOCK and CHUNK_UNLOCK.</t>
            </li>
            <li>
              <t>CHUNK_ROLLBACK.</t>
            </li>
          </ul>
          <t>Required for clients that participate in repair:</t>
          <ul spacing="normal">
            <li>
              <t>CHUNK_ERROR.</t>
            </li>
            <li>
              <t>CHUNK_REPAIRED.</t>
            </li>
            <li>
              <t>CHUNK_WRITE_REPAIR.</t>
            </li>
          </ul>
          <t>Clients <bcp14>MUST NOT</bcp14> send:</t>
          <ul spacing="normal">
            <li>
              <t>READ, WRITE, COMMIT against a chunked data file.  A
data server <bcp14>MUST</bcp14> reject these with NFS4ERR_NOTSUPP and <bcp14>MAY</bcp14>
log the client for operator attention; this case is almost
always a client bug in which the client did not inspect the
mirror's ffv2m_encoding_type_data before issuing I/O.</t>
            </li>
            <li>
              <t>READ_PLUS, SEEK, ALLOCATE, DEALLOCATE against a chunked
data file.  Chunk-level allocation is a metadata-server
responsibility.</t>
            </li>
            <li>
              <t>SETATTR against a chunked data file (the general
prohibition in <xref target="sec-setattr-on-data-file"/> applies to all
data files; truncate in particular is handled by the
metadata server per <xref target="sec-mds-truncate-ec"/>).</t>
            </li>
          </ul>
        </section>
        <section anchor="operations-that-must-not-be-sent-to-a-data-file">
          <name>Operations That MUST NOT Be Sent to a Data File</name>
          <t>Clients <bcp14>MUST NOT</bcp14> send the following operations to a data server
on a data file, regardless of protection mode.  A data server
that has identified the file as a chunked data file (see
<xref target="sec-data-file-identification"/>) <bcp14>MUST</bcp14> return NFS4ERR_NOTSUPP:</t>
          <ul spacing="normal">
            <li>
              <t>OPEN, CLOSE, OPEN_DOWNGRADE, OPEN_CONFIRM (<xref target="RFC8881"/>
Sections 18.16, 18.2, 18.18, 18.20).  Opens occur on the
metadata server; the stateid obtained there is used on the
data path.</t>
            </li>
            <li>
              <t>LOCK, LOCKU, LOCKT, RELEASE_LOCKOWNER (<xref target="RFC8881"/> Sections
18.10, 18.11, 18.13, 18.24).  Byte-range locks on data files
are not supported; chunked files use CHUNK_LOCK, and
PASSTHROUGH files rely on metadata-server coordination.</t>
            </li>
            <li>
              <t>DELEGPURGE, DELEGRETURN, WANT_DELEGATION (<xref target="RFC8881"/> Sections
18.5, 18.6 and <xref section="15.3" sectionFormat="of" target="RFC7862"/>).  Delegations are
issued by the metadata server.</t>
            </li>
            <li>
              <t>Any operation whose purpose is to manipulate the file's
namespace: RENAME, LINK, SYMLINK, CREATE (at the client's
file-creation use, not the metadata server's own
allocation of data files on the data server described
above), REMOVE.  Namespace
operations belong on the metadata server.</t>
            </li>
            <li>
              <t>Any ACL-scoped SETATTR or GETATTR bit (FATTR4_ACL,
FATTR4_DACL, FATTR4_SACL).  Access control on data files is
delegated to the metadata server.</t>
            </li>
            <li>
              <t>CLONE, COPY, COPY_NOTIFY, OFFLOAD_CANCEL, OFFLOAD_STATUS
(<xref target="RFC7862"/> Sections 15.13, 15.2, 15.3, 15.8, 15.9).
File-level data migration is a metadata-server responsibility.</t>
            </li>
            <li>
              <t>LAYOUTGET, LAYOUTCOMMIT, LAYOUTRETURN, LAYOUTSTATS,
LAYOUTERROR, GETDEVICEINFO, GETDEVICELIST (<xref target="RFC8881"/>
Sections 18.43, 18.42, 18.44, <xref target="RFC7862"/> Sections 15.7,
15.6, <xref target="RFC8881"/> Sections 18.40, 18.41).  Layout operations
belong on the metadata server.</t>
            </li>
            <li>
              <t>TRUST_STATEID, REVOKE_STATEID, BULK_REVOKE_STATEID
(<xref target="sec-TRUST_STATEID"/>, <xref target="sec-REVOKE_STATEID"/>,
<xref target="sec-BULK_REVOKE_STATEID"/>).  These are metadata-server-to-data-server
control-plane operations; a data server rejects them with
NFS4ERR_PERM when received on a client session (see
<xref target="sec-tight-coupling-control-session"/>).</t>
            </li>
            <li>
              <t>NFSv4 READ, WRITE, and COMMIT (<xref target="RFC8881"/> Sections 18.22,
18.32, 18.3).  Chunked data files use CHUNK_READ,
CHUNK_WRITE, and CHUNK_COMMIT respectively; NFSv4
byte-range READ / WRITE / COMMIT bypasses the chunk
envelope (chunk_guard4 CAS, per-chunk checksum, lifecycle
state) that this document's consistency guarantees depend
on.  A data server that has identified the file as a
chunked data file <bcp14>MUST</bcp14> reject NFSv4 READ / WRITE / COMMIT
with NFS4ERR_NOTSUPP.  PASSTHROUGH data files
(<xref target="sec-encoding-passthrough"/>) are non-chunked and continue
to use NFSv4 READ / WRITE / COMMIT normally; their
fattr4_chunked_data_file is FALSE
(<xref target="sec-fattr4_chunked_data_file"/>).</t>
            </li>
          </ul>
        </section>
        <section anchor="chunk-operations-on-non-chunked-data-files">
          <name>CHUNK Operations on Non-Chunked Data Files</name>
          <t>The reciprocal rule: clients <bcp14>MUST NOT</bcp14> send CHUNK operations
(CHUNK_READ, CHUNK_WRITE, CHUNK_FINALIZE, CHUNK_COMMIT,
CHUNK_ROLLBACK, CHUNK_HEADER_READ, CHUNK_LOCK, CHUNK_UNLOCK,
CHUNK_ERROR, CHUNK_REPAIRED, CHUNK_WRITE_REPAIR) to a data
server on a file that is not a chunked data file.  Non-chunked
data files (PASSTHROUGH mirrors, and any file the metadata
server has not marked as chunked) do not carry a chunk envelope
and cannot honor CHUNK operation semantics.  A data server that
has identified the file as non-chunked (fattr4_chunked_data_file
= FALSE) <bcp14>MUST</bcp14> reject CHUNK operations against that file with
NFS4ERR_NOTSUPP.  A data server that cannot identify the file
under any of the paths in <xref target="sec-data-file-identification"/>
relies on the client-side "<bcp14>MUST NOT</bcp14>" as the primary defense; a
client with an active layout will not present a chunked-layout
stateid against a non-chunked file, so standard stateid
validation (<xref section="8.2" sectionFormat="of" target="RFC8881"/>) catches the misdirected
CHUNK operation with NFS4ERR_BAD_STATEID before the chunk-layer
rules apply.</t>
        </section>
      </section>
      <section anchor="callback-path-data-server-to-client">
        <name>Callback Path: Data Server to Client</name>
        <t>A data server does not call back directly to pNFS clients.
Recall notifications and repair coordination flow through the
metadata server's backchannel session with the client.  The
callbacks a client will observe that affect its data files are:</t>
        <ul spacing="normal">
          <li>
            <t>CB_LAYOUTRECALL (<xref section="20.3" sectionFormat="of" target="RFC8881"/>).</t>
          </li>
          <li>
            <t>CB_NOTIFY_DEVICEID (<xref section="20.12" sectionFormat="of" target="RFC8881"/>).</t>
          </li>
          <li>
            <t>CB_RECALL_ANY (<xref section="20.6" sectionFormat="of" target="RFC8881"/>).</t>
          </li>
          <li>
            <t>CB_CHUNK_REPAIR.</t>
          </li>
        </ul>
        <t>A data server influences these callbacks only indirectly, via
LAYOUTERROR reports the client issues to the metadata server or
by returning error codes that prompt the client to report.  A
data server <bcp14>MUST NOT</bcp14> attempt to send CB_* operations to clients
directly.</t>
      </section>
      <section anchor="summary-table">
        <name>Summary Table</name>
        <t>The classification below adapts the operation taxonomy of
<xref section="17" sectionFormat="of" target="RFC8881"/> (<bcp14>REQUIRED</bcp14> / <bcp14>RECOMMENDED</bcp14> / <bcp14>OPTIONAL</bcp14> /
<bcp14>MUST NOT</bcp14> IMPLEMENT) to the two-direction per-operation view a
Flexible File Version 2 data server requires.  Two of the four
labels in the table below match <xref target="RFC8881"/> usage; the other
two are extensions specific to this document.</t>
        <dl>
          <dt><bcp14>REQUIRED</bcp14>:</dt>
          <dd>
            <t>The data server <bcp14>MUST</bcp14> support the operation on this path.
Matches <xref section="17" sectionFormat="of" target="RFC8881"/> REQ.</t>
          </dd>
          <dt><bcp14>OPTIONAL</bcp14>:</dt>
          <dd>
            <t>The data server <bcp14>MAY</bcp14> support the operation; if it does, the
actor in this column <bcp14>MUST</bcp14> tolerate the absence of support.
Matches <xref section="17" sectionFormat="of" target="RFC8881"/> OPT.</t>
          </dd>
          <dt><bcp14>MUST NOT</bcp14>:</dt>
          <dd>
            <t>The actor in this column <bcp14>MUST NOT</bcp14> send the operation, and
the data server <bcp14>MUST</bcp14> reject it with NFS4ERR_NOTSUPP.  This
per-direction prohibition extends <xref section="17" sectionFormat="of" target="RFC8881"/>'s
single-axis <bcp14>MUST NOT</bcp14> IMPLEMENT classification: an operation
may be forbidden on one path (client to data server) while
required on another (metadata server to data server).
SETATTR is the canonical example.</t>
          </dd>
          <dt><bcp14>MAY</bcp14>:</dt>
          <dd>
            <t>The metadata server <bcp14>MAY</bcp14> use the operation as an
implementation-defined control-plane action.  Not in
<xref section="17" sectionFormat="of" target="RFC8881"/>; specific to the metadata-server-to-data-server
path in this document.</t>
          </dd>
        </dl>
        <table anchor="tbl-ops-allowed">
          <name>NFSv4.2 operations allowed on data files</name>
          <thead>
            <tr>
              <th align="left">Operation</th>
              <th align="left">Client -&gt; data server</th>
              <th align="left">metadata server -&gt; data server</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">SEQUENCE, PUTFH, GETFH, PUTROOTFH</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">EXCHANGE_ID, CREATE_SESSION, DESTROY_SESSION, BIND_CONN_TO_SESSION, DESTROY_CLIENTID</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">RECLAIM_COMPLETE</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">SECINFO, SECINFO_NO_NAME</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
              <td align="left">
                <bcp14>MAY</bcp14></td>
            </tr>
            <tr>
              <td align="left">GETATTR</td>
              <td align="left">
                <bcp14>OPTIONAL</bcp14> (non-authoritative)</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">SETATTR</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">LOOKUP, CREATE, REMOVE</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
            <tr>
              <td align="left">READ, WRITE, COMMIT</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14> (PASSTHROUGH); <bcp14>MUST NOT</bcp14> (chunked)</td>
              <td align="left">
                <bcp14>MAY</bcp14></td>
            </tr>
            <tr>
              <td align="left">READ_PLUS, SEEK, ALLOCATE</td>
              <td align="left">
                <bcp14>OPTIONAL</bcp14> (PASSTHROUGH); <bcp14>MUST NOT</bcp14> (chunked)</td>
              <td align="left">
                <bcp14>MAY</bcp14></td>
            </tr>
            <tr>
              <td align="left">DEALLOCATE</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MAY</bcp14></td>
            </tr>
            <tr>
              <td align="left">CHUNK_WRITE, CHUNK_READ, CHUNK_FINALIZE, CHUNK_COMMIT, CHUNK_HEADER_READ, CHUNK_LOCK, CHUNK_UNLOCK, CHUNK_ROLLBACK</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14> (chunked); <bcp14>MUST NOT</bcp14> (PASSTHROUGH)</td>
              <td align="left">not used</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ERROR, CHUNK_REPAIRED, CHUNK_WRITE_REPAIR</td>
              <td align="left">
                <bcp14>REQUIRED</bcp14> (chunked repair actors); <bcp14>MUST NOT</bcp14> (PASSTHROUGH)</td>
              <td align="left">not used</td>
            </tr>
            <tr>
              <td align="left">OPEN, CLOSE, OPEN_DOWNGRADE, OPEN_CONFIRM</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>OPTIONAL</bcp14> (proxy I/O)</td>
            </tr>
            <tr>
              <td align="left">LOCK, LOCKU, LOCKT, RELEASE_LOCKOWNER</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
            </tr>
            <tr>
              <td align="left">DELEGPURGE, DELEGRETURN, WANT_DELEGATION</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
            </tr>
            <tr>
              <td align="left">RENAME, LINK, SYMLINK</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
            </tr>
            <tr>
              <td align="left">CLONE, COPY, COPY_NOTIFY, OFFLOAD_CANCEL, OFFLOAD_STATUS</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MAY</bcp14> (data migration)</td>
            </tr>
            <tr>
              <td align="left">LAYOUTGET, LAYOUTCOMMIT, LAYOUTRETURN, LAYOUTSTATS, LAYOUTERROR, GETDEVICEINFO, GETDEVICELIST</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
            </tr>
            <tr>
              <td align="left">ACL-scoped GETATTR/SETATTR bits</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>MAY</bcp14></td>
            </tr>
            <tr>
              <td align="left">TRUST_STATEID, REVOKE_STATEID, BULK_REVOKE_STATEID</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14> (tight coupling)</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ESCROW_INSTALL, CHUNK_ESCROW_RELEASE, CHUNK_ESCROW_ENUMERATE, CHUNK_ESCROW_TAKEOVER</td>
              <td align="left">
                <bcp14>MUST NOT</bcp14></td>
              <td align="left">
                <bcp14>REQUIRED</bcp14></td>
            </tr>
          </tbody>
        </table>
        <t>The (PASSTHROUGH) and (chunked) qualifiers in the client-to-data-server
column select by the mirror's ffv2m_encoding_type_data value.
FFV2<em>ENCODING_PASSTHROUGH (<xref target="sec-encoding-passthrough"/>) uses
NFSv3 WRITE / READ or NFSv4 READ / WRITE directly and does not
use the CHUNK operations.  Every other standards-track encoding
(any FFV2_ENCODING</em>* value other than FFV2_ENCODING_PASSTHROUGH;
see <xref target="tbl-coding-types"/>) is (chunked): it uses CHUNK_WRITE and CHUNK_READ and
<bcp14>MUST NOT</bcp14> use the RFC 8881 READ / WRITE / COMMIT operations
against the data server.  FFV2_ENCODING_REPLICATED replicates
the payload verbatim across N shards but dispatches via the
CHUNK operations so each shard carries the per-chunk checksum
this version of the layout type relies on for end-to-end
integrity (<xref target="sec-encoding-replicated"/>).</t>
      </section>
    </section>
    <section anchor="sec-layouthint">
      <name>Flexible File Version 2 Layout Type Return</name>
      <t>layoutreturn_file4 is used in the LAYOUTRETURN operation to convey
layout type specific information to the server.  It is defined in
<xref section="18.44.1" sectionFormat="of" target="RFC8881"/> (also shown in <xref target="fig-LAYOUTRETURN"/>).</t>
      <figure anchor="fig-LAYOUTRETURN">
        <name>Layout Return XDR</name>
        <sourcecode type="xdr"><![CDATA[
      /* Constants used for LAYOUTRETURN and CB_LAYOUTRECALL */
      const LAYOUT4_RET_REC_FILE      = 1;
      const LAYOUT4_RET_REC_FSID      = 2;
      const LAYOUT4_RET_REC_ALL       = 3;

      enum layoutreturn_type4 {
              LAYOUTRETURN4_FILE = LAYOUT4_RET_REC_FILE,
              LAYOUTRETURN4_FSID = LAYOUT4_RET_REC_FSID,
              LAYOUTRETURN4_ALL  = LAYOUT4_RET_REC_ALL
      };

   struct layoutreturn_file4 {
           offset4         lrf_offset;
           length4         lrf_length;
           stateid4        lrf_stateid;
           /* layouttype4 specific data */
           opaque          lrf_body<>;
   };

   union layoutreturn4 switch(layoutreturn_type4 lr_returntype) {
           case LAYOUTRETURN4_FILE:
                   layoutreturn_file4      lr_layout;
           default:
                   void;
   };

   struct LAYOUTRETURN4args {
           /* CURRENT_FH: file */
           bool                    lora_reclaim;
           layouttype4             lora_layout_type;
           layoutiomode4           lora_iomode;
           layoutreturn4           lora_layoutreturn;
   };
]]></sourcecode>
      </figure>
      <t>If the lora_layout_type layout type is LAYOUT4_FLEX_FILES_V2 and the
lr_returntype is LAYOUTRETURN4_FILE, then the lrf_body opaque value
is defined by ffv2_layoutreturn4 (see <xref target="sec-ffv2_layoutreturn4"/>).  This
allows the client to report I/O error information or layout usage
statistics back to the metadata server as defined below.  Note that
while the data structures are built on concepts introduced in
NFSv4.2, the effective discriminated union (lora_layout_type combined
with ffv2_layoutreturn4) allows for an NFSv4.1 metadata server to
utilize the data.</t>
      <section anchor="sec-io-error">
        <name>I/O Error Reporting</name>
        <section anchor="sec-ffv2_ioerr4">
          <name>ffv2_ioerr4</name>
          <figure anchor="fig-ffv2_ioerr4">
            <name>ffv2_ioerr4</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_ioerr4 {
   ///         offset4        ffv2ie_offset;
   ///         length4        ffv2ie_length;
   ///         stateid4       ffv2ie_stateid;
   ///         device_error4  ffv2ie_errors<>;
   /// };
   ///
]]></sourcecode>
          </figure>
          <t>Recall that <xref target="RFC7862"/> defines device_error4 as in <xref target="fig-device_error4"/>:</t>
          <figure anchor="fig-device_error4">
            <name>device_error4</name>
            <sourcecode type="xdr"><![CDATA[
   struct device_error4 {
           deviceid4       de_deviceid;
           nfsstat4        de_status;
           nfs_opnum4      de_opnum;
   };
]]></sourcecode>
          </figure>
          <t>The ffv2_ioerr4 structure is used to return error indications for
data files that generated errors during data transfers.  These are
hints to the metadata server that there are problems with that file.
For each error, ffv2ie_errors.de_deviceid, ffv2ie_offset, and ffv2ie_length
represent the storage device and byte range within the file in which
the error occurred; ffv2ie_errors represents the operation and type
of error.  The use of device_error4 is described in <xref section="15.6" sectionFormat="of" target="RFC7862"/>.</t>
          <t>Even though the storage device might be accessed via NFSv3 and
reports back NFSv3 errors to the client, the client is responsible
for mapping these to appropriate NFSv4 status codes as de_status.
Likewise, the NFSv3 operations need to be mapped to equivalent NFSv4
operations.</t>
        </section>
      </section>
      <section anchor="sec-layout-stats">
        <name>Layout Usage Statistics</name>
        <section anchor="ffiolatency4">
          <name>ff_io_latency4</name>
          <figure anchor="fig-ff_io_latency4">
            <name>ff_io_latency4</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_io_latency4 {
   ///         uint64_t       ffv2il_ops_requested;
   ///         uint64_t       ffv2il_bytes_requested;
   ///         uint64_t       ffv2il_ops_completed;
   ///         uint64_t       ffv2il_bytes_completed;
   ///         uint64_t       ffv2il_bytes_not_delivered;
   ///         nfstime4       ffv2il_total_busy_time;
   ///         nfstime4       ffv2il_aggregate_completion_time;
   /// };
   ///
]]></sourcecode>
          </figure>
          <t>Both operation counts and bytes transferred are kept in the
ff_io_latency4 (see <xref target="fig-ff_io_latency4"/>).  As seen in ff_layoutupdate4
(see <xref target="sec-ff_layoutupdate4"/>), READ and WRITE operations are
aggregated separately.  READ operations are used for the ff_io_latency4
ffv2lu_read.  Both WRITE and COMMIT operations are used for the
ff_io_latency4 ffv2lu_write.  "Requested" counters track what the
client is attempting to do, and "completed" counters track what was
done.  There is no requirement that the client only report completed
results that have matching requested results from the reported
period.</t>
          <t>ffv2il_bytes_not_delivered is used to track the aggregate number of
bytes requested but not fulfilled due to error conditions.
ffv2il_total_busy_time is the aggregate time spent with outstanding
RPC calls. ffv2il_aggregate_completion_time is the sum of all round-trip
times for completed RPC calls.</t>
          <t>In <xref section="3.3.1" sectionFormat="of" target="RFC8881"/>, the nfstime4 is defined as the
number of seconds and nanoseconds since midnight or zero hour January
1, 1970 Coordinated Universal Time (UTC).  The use of nfstime4 in
ff_io_latency4 is to store time since the start of the first I/O
from the client after receiving the layout.  In other words, these
are to be decoded as duration and not as a date and time.</t>
          <t>Note that LAYOUTSTATS are cumulative, i.e., not reset each time the
operation is sent.  If two LAYOUTSTATS operations for the same file
and layout stateid originate from the same NFS client and are
processed at the same time by the metadata server, then the one
containing the larger values contains the most recent time series
data.</t>
        </section>
        <section anchor="sec-ff_layoutupdate4">
          <name>ff_layoutupdate4</name>
          <figure anchor="fig-ff_layoutupdate4">
            <name>ff_layoutupdate4</name>
            <sourcecode type="xdr"><![CDATA[
   /// const FFV2_LAYOUTSTATS_FLAGS_LOCAL  = 0x00000001;
   ///
   /// typedef uint32_t   ffv2_layoutstats_flags4;
   ///
   /// struct ffv2_layoutupdate4 {
   ///         netaddr4                ffv2lu_addr;
   ///         nfs_fh4                 ffv2lu_fhandle;
   ///         ffv2_io_latency4        ffv2lu_read;
   ///         ffv2_io_latency4        ffv2lu_write;
   ///         nfstime4                ffv2lu_duration;
   ///         ffv2_layoutstats_flags4 ffv2lu_flags;
   /// };
   ///
]]></sourcecode>
          </figure>
          <t>ffv2lu_addr differentiates which network address the client is connected
to on the storage device.  In the case of multipathing, ffv2lu_fhandle
indicates which read-only copy was selected. ffv2lu_read and ffv2lu_write
convey the latencies for both READ and WRITE operations, respectively.
ffv2lu_duration is used to indicate the time period over which the
statistics were collected.  ffv2lu_flags is a 32-bit bitmask
reporting per-report properties; when FFV2_LAYOUTSTATS_FLAGS_LOCAL
is set, the I/O was serviced by the client's cache.  This flag
allows the client to inform the metadata server about "hot" access
to a file it would not normally be allowed to report on.
Unassigned bits are reserved for future revisions; receivers <bcp14>MUST</bcp14>
ignore bits they do not recognize.</t>
        </section>
        <section anchor="ffiostats4">
          <name>ff_iostats4</name>
          <figure anchor="fig-ff_iostats4">
            <name>ff_iostats4</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_iostats4 {
   ///         offset4            ffv2is_offset;
   ///         length4            ffv2is_length;
   ///         stateid4           ffv2is_stateid;
   ///         io_info4           ffv2is_read;
   ///         io_info4           ffv2is_write;
   ///         deviceid4          ffv2is_deviceid;
   ///         ffv2_layoutupdate4 ffv2is_layoutupdate;
   /// };
   ///
]]></sourcecode>
          </figure>
          <t><xref target="RFC7862"/> defines io_info4 as in <xref target="fig-ff_iostats4"/>.</t>
          <figure anchor="fig-io_info4">
            <name>io_info4</name>
            <sourcecode type="xdr"><![CDATA[
   struct io_info4 {
           uint64_t        ii_count;
           uint64_t        ii_bytes;
   };
]]></sourcecode>
          </figure>
          <t>With pNFS, data transfers are performed directly between the pNFS
client and the storage devices.  Therefore, the metadata server has
no direct knowledge of the I/O operations being done and thus cannot
create on its own statistical information about client I/O to
optimize the data storage location.  ff_iostats4 <bcp14>MAY</bcp14> be used by the
client to report I/O statistics back to the metadata server upon
returning the layout.</t>
          <t>Since it is not feasible for the client to report every I/O that
used the layout, the client <bcp14>MAY</bcp14> identify "hot" byte ranges for which
to report I/O statistics.  The definition and/or configuration
mechanism of what is considered "hot" and the size of the reported
byte range are out of the scope of this document.  For client
implementations, providing reasonable default values and an
optional run-time management interface to control these
parameters is suggested.  For example, a client can define the default byte range
resolution to be 1 MB in size and the thresholds for reporting to
be 1 MB/second or 10 I/O operations per second.</t>
          <t>For each byte range, ffv2is_offset and ffv2is_length represent the
starting offset of the range and the range length in bytes.
ffv2is_read.ii_count, ffv2is_read.ii_bytes, ffv2is_write.ii_count, and
ffv2is_write.ii_bytes represent the number of contiguous READ and
WRITE I/Os and the respective aggregate number of bytes transferred
within the reported byte range.</t>
          <t>The combination of ffv2is_deviceid and ffv2lu_addr uniquely identifies
both the storage path and the network route to it.  Finally,
ffv2lu_fhandle allows the metadata server to differentiate between
multiple read-only copies of the file on the same storage device.</t>
        </section>
      </section>
      <section anchor="sec-ffv2_layoutreturn4">
        <name>ffv2_layoutreturn4</name>
        <figure anchor="fig-ffv2_layoutreturn4">
          <name>ffv2_layoutreturn4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct ffv2_layoutreturn4 {
   ///         ffv2_ioerr4     ffv2lr_ioerr_report<>;
   ///         ffv2_iostats4   ffv2lr_iostats_report<>;
   /// };
   ///
]]></sourcecode>
        </figure>
        <t>When data file I/O operations fail, ffv2lr_ioerr_report&lt;&gt; is used to
report these errors to the metadata server as an array of elements
of type ffv2_ioerr4.  Each element in the array represents an error
that occurred on the data file identified by ffv2ie_errors.de_deviceid.
If no errors are to be reported, the size of the ffv2lr_ioerr_report&lt;&gt;
array is set to zero.  The client <bcp14>MAY</bcp14> also use ffv2lr_iostats_report&lt;&gt;
to report a list of I/O statistics as an array of elements of type
ff_iostats4.  Each element in the array represents statistics for
a particular byte range.  Byte ranges are not guaranteed to be
disjoint and <bcp14>MAY</bcp14> repeat or intersect.</t>
      </section>
    </section>
    <section anchor="sec-LAYOUTERROR">
      <name>Flexible File Version 2 Layout Type LAYOUTERROR</name>
      <t>If the client is using NFSv4.2 to communicate with the metadata
server, then instead of waiting for a LAYOUTRETURN to send error
information to the metadata server (see <xref target="sec-io-error"/>), it <bcp14>MAY</bcp14>
use LAYOUTERROR (see <xref section="15.6" sectionFormat="of" target="RFC7862"/>) to communicate
that information.  For the flexible file v2 layout, this means
that LAYOUTERROR4args is treated the same as ffv2_ioerr4.</t>
    </section>
    <section anchor="flexible-file-version-2-layout-type-layoutstats">
      <name>Flexible File Version 2 Layout Type LAYOUTSTATS</name>
      <t>If the client is using NFSv4.2 to communicate with the metadata
server, then instead of waiting for a LAYOUTRETURN to send I/O
statistics to the metadata server (see <xref target="sec-layout-stats"/>), it
<bcp14>MAY</bcp14> use LAYOUTSTATS (see <xref section="15.7" sectionFormat="of" target="RFC7862"/>) to communicate
that information.  For the flexible file v2 layout, this means
that LAYOUTSTATS4args.lsa_layoutupdate is overloaded with the same
contents as in ffv2is_layoutupdate.</t>
    </section>
    <section anchor="flexible-file-version-2-layout-type-creation-hint">
      <name>Flexible File Version 2 Layout Type Creation Hint</name>
      <t>The layouthint4 type is defined in the <xref target="RFC8881"/> as in
<xref target="fig-layouthint4-v1"/>.</t>
      <figure anchor="fig-layouthint4-v1">
        <name>layouthint4 v1</name>
        <sourcecode type="xdr"><![CDATA[
   struct layouthint4 {
       layouttype4        loh_type;
       opaque             loh_body<>;
   };
]]></sourcecode>
      </figure>
      <t>The layouthint4 structure is used by the client to pass a hint about
the type of layout it would like created for a particular file.  If
the loh_type layout type is LAYOUT4_FLEX_FILES, then the loh_body
opaque value is defined by the ff_layouthint4 type (v1
compatibility).  If the loh_type layout type is
LAYOUT4_FLEX_FILES_V2, then the loh_body opaque value is defined
by the ffv2_layouthint4 type (see <xref target="sec-ffv2-layouthint"/>).</t>
    </section>
    <section anchor="fflayouthint4">
      <name>ff_layouthint4</name>
      <figure anchor="fig-ff_layouthint4-v2">
        <name>ff_layouthint4 (v1 compatibility)</name>
        <sourcecode type="xdr"><![CDATA[
   union ff_mirrors_hint switch (bool ffmc_valid) {
       case TRUE:
           uint32_t    ffmc_mirrors;
       case FALSE:
           void;
   };

   struct ff_layouthint4 {
       ff_mirrors_hint    fflh_mirrors_hint;
   };
]]></sourcecode>
      </figure>
      <t>The ff_layouthint4 is retained for backwards compatibility with
flexible file v1 layouts.  For flexible file v2 layouts, clients
<bcp14>SHOULD</bcp14> use ffv2_layouthint4 (<xref target="fig-ffv2_layouthint4"/>) instead,
which provides encoding type selection and data protection geometry
hints via ffv2_data_protection4 (<xref target="fig-ffv2_data_protection4"/>).</t>
    </section>
    <section anchor="recalling-a-layout">
      <name>Recalling a Layout</name>
      <t>While <xref section="12.5.5" sectionFormat="of" target="RFC8881"/> discusses reasons independent
of layout type for recalling a layout, the flexible file v2 layout
type metadata server should recall outstanding layouts in the
following cases:</t>
      <ul spacing="normal">
        <li>
          <t>When the file's security policy changes, i.e., ACLs or permission
mode bits are set.</t>
        </li>
        <li>
          <t>When the file's layout changes, rendering outstanding layouts
invalid.</t>
        </li>
        <li>
          <t>When existing layouts are inconsistent with the need to enforce
locking constraints.</t>
        </li>
        <li>
          <t>When existing layouts are inconsistent with the requirements
regarding resilvering as described in <xref target="sec-mds-resilvering"/>.</t>
        </li>
      </ul>
      <section anchor="cbrecallany">
        <name>CB_RECALL_ANY</name>
        <t>The metadata server can use the CB_RECALL_ANY callback operation
to notify the client to return some or all of its layouts.  <xref section="22.3" sectionFormat="of" target="RFC8881"/> defines the allowed types of the "NFSv4 Recallable
Object Types Registry".</t>
        <figure anchor="fig-new-rca4">
          <name>RCA4 masks for v2</name>
          <sourcecode type="xdr"><![CDATA[
   /// const RCA4_TYPE_MASK_FF2_LAYOUT_MIN     = 20;
   /// const RCA4_TYPE_MASK_FF2_LAYOUT_MAX     = 21;
   ///
]]></sourcecode>
        </figure>
        <figure anchor="fig-CB_RECALL_ANY4args">
          <name>CB_RECALL_ANY4args XDR</name>
          <sourcecode type="xdr"><![CDATA[
   struct  CB_RECALL_ANY4args      {
       uint32_t        craa_layouts_to_keep;
       bitmap4         craa_type_mask;
   };
]]></sourcecode>
        </figure>
        <t>Typically, CB_RECALL_ANY will be used to recall client state when
the server needs to reclaim resources.  The craa_type_mask bitmap
specifies the type of resources that are recalled, and the
craa_layouts_to_keep value specifies how many of the recalled
flexible file v2 layouts the client is allowed to keep.  The mask flags
for the flexible file v2 layout are defined as in <xref target="fig-mask-flags"/>.</t>
        <figure anchor="fig-mask-flags">
          <name>Recall Mask Flags for v2</name>
          <sourcecode type="xdr"><![CDATA[
   /// enum ffv2_cb_recall_any_mask {
   ///     PNFS_FF_RCA4_TYPE_MASK_READ = 20,
   ///     PNFS_FF_RCA4_TYPE_MASK_RW   = 21
   /// };
   ///
]]></sourcecode>
        </figure>
        <t>The flags represent the iomode of the recalled layouts.  In response,
the client <bcp14>SHOULD</bcp14> return layouts of the recalled iomode that it
needs the least, keeping at most craa_layouts_to_keep flexible file
layouts.</t>
        <t>The PNFS_FF_RCA4_TYPE_MASK_READ flag notifies the client to return
layouts of iomode LAYOUTIOMODE4_READ.  Similarly, the
PNFS_FF_RCA4_TYPE_MASK_RW flag notifies the client to return layouts
of iomode LAYOUTIOMODE4_RW.  When both mask flags are set, the
client is notified to return layouts of either iomode.</t>
      </section>
    </section>
    <section anchor="layout-revocation-and-fencing">
      <name>Layout Revocation and Fencing</name>
      <t>In cases where clients are uncommunicative and their lease has
expired, or when clients fail to return recalled layouts within
a lease period, the metadata server <bcp14>MAY</bcp14> revoke client layouts
and reassign these resources to other clients (see <xref section="12.5.5" sectionFormat="of" target="RFC8881"/>).  To avoid data corruption from a revoked client continuing
to issue I/O, the metadata server <bcp14>MUST</bcp14> fence the revoked client from
the affected data files. The mechanism varies by coupling model and by
whether the client's layout stateid has been registered with the data
servers via TRUST_STATEID:</t>
      <dl>
        <dt>Loosely coupled, untrusted stateid:</dt>
        <dd>
          <t>The metadata server rotates the synthetic uid/gid on the
affected data files per <xref target="sec-Fencing-Clients"/>.  The
revoked client presents stale RPC credentials and receives
NFS4ERR_ACCESS from the data server.  This is the
flexible-file-v1-layout-style fencing mechanism; it operates
per data file and
does not distinguish between clients that hold layouts on
the same file.</t>
        </dd>
        <dt>Tightly coupled, trusted stateid:</dt>
        <dd>
          <t>When the metadata server has registered a client's layout
stateid with the data servers via TRUST_STATEID, it can revoke per-client access
without rotating credentials by issuing REVOKE_STATEID to each affected data server, or
BULK_REVOKE_STATEID when
revoking all stateids belonging to a single clientid4
across a data server.  Subsequent I/O from the revoked
client carrying the revoked stateid receives
NFS4ERR_BAD_STATEID.  This is the preferred mechanism for
chunked layouts because it is per-client and avoids the
flexible file v1 layout's limitation of fencing all clients
on a data file when only one needs to be revoked.</t>
        </dd>
        <dt>Mixed:</dt>
        <dd>
          <t>A metadata server <bcp14>MAY</bcp14> combine the two mechanisms when a
file's layout includes both PASSTHROUGH mirrors (where
stateid registration is not in play) and chunked mirrors
with trusted stateids.  The metadata server rotates
synthetic ids for the PASSTHROUGH mirror's data file and
issues REVOKE_STATEID for the chunked mirror's data
servers.</t>
        </dd>
      </dl>
    </section>
    <section anchor="new-nfsv42-error-values">
      <name>New NFSv4.2 Error Values</name>
      <figure anchor="fig-errors-xdr">
        <name>Errors XDR</name>
        <sourcecode type="xdr"><![CDATA[
   ///
   /// /* Erasure Coding error constants; added to nfsstat4 enum */
   ///
   /// const NFS4ERR_ENCODING_NOT_SUPPORTED         = 10097;
   /// const NFS4ERR_PAYLOAD_NOT_ATOMIC           = 10098;
   /// const NFS4ERR_CHUNK_LOCKED                 = 10099;
   /// const NFS4ERR_CHUNK_GUARDED                = 10100;
   /// const NFS4ERR_PAYLOAD_LOST                 = 10101;
   /// const NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED = 10102;
   /// const NFS4ERR_NO_PREDECESSOR               = 10103;
   /// const NFS4ERR_NO_ADOPTABLE_LOCK            = 10104;
   /// const NFS4ERR_STALE_ESCROW                 = 10105;
   /// const NFS4ERR_STALE_MDS_EPOCH              = 10106;
   /// const NFS4ERR_PARTIAL                      = 10107;
   ///
]]></sourcecode>
      </figure>
      <t>The new error codes are shown in <xref target="fig-errors-xdr"/>.</t>
      <section anchor="error-definitions">
        <name>Error Definitions</name>
        <table anchor="tbl-protocol-errors">
          <name>Error Definitions</name>
          <thead>
            <tr>
              <th align="left">Error</th>
              <th align="left">Number</th>
              <th align="left">Description</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">NFS4ERR_ENCODING_NOT_SUPPORTED</td>
              <td align="left">10097</td>
              <td align="left">
                <xref target="sec-NFS4ERR_ENCODING_NOT_SUPPORTED"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PAYLOAD_NOT_ATOMIC</td>
              <td align="left">10098</td>
              <td align="left">
                <xref target="sec-NFS4ERR_PAYLOAD_NOT_ATOMIC"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_CHUNK_LOCKED</td>
              <td align="left">10099</td>
              <td align="left">
                <xref target="sec-NFS4ERR_CHUNK_LOCKED"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_CHUNK_GUARDED</td>
              <td align="left">10100</td>
              <td align="left">
                <xref target="sec-NFS4ERR_CHUNK_GUARDED"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PAYLOAD_LOST</td>
              <td align="left">10101</td>
              <td align="left">
                <xref target="sec-NFS4ERR_PAYLOAD_LOST"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED</td>
              <td align="left">10102</td>
              <td align="left">
                <xref target="sec-NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_NO_PREDECESSOR</td>
              <td align="left">10103</td>
              <td align="left">
                <xref target="sec-NFS4ERR_NO_PREDECESSOR"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_NO_ADOPTABLE_LOCK</td>
              <td align="left">10104</td>
              <td align="left">
                <xref target="sec-NFS4ERR_NO_ADOPTABLE_LOCK"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_STALE_ESCROW</td>
              <td align="left">10105</td>
              <td align="left">
                <xref target="sec-NFS4ERR_STALE_ESCROW"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_STALE_MDS_EPOCH</td>
              <td align="left">10106</td>
              <td align="left">
                <xref target="sec-NFS4ERR_STALE_MDS_EPOCH"/></td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PARTIAL</td>
              <td align="left">10107</td>
              <td align="left">
                <xref target="sec-NFS4ERR_PARTIAL"/></td>
            </tr>
          </tbody>
        </table>
        <section anchor="sec-NFS4ERR_ENCODING_NOT_SUPPORTED">
          <name>NFS4ERR_ENCODING_NOT_SUPPORTED (Error Code 10097)</name>
          <t>The client requested a ffv2_encoding_type4 which the metadata server
does not support.  I.e., if the client sends a layout_hint requesting
an erasure encoding type that the metadata server does not support,
this error code can be returned.  The client might have to send the
layout_hint several times to determine the overlapping set of
supported erasure encoding types.</t>
        </section>
        <section anchor="sec-NFS4ERR_PAYLOAD_NOT_ATOMIC">
          <name>NFS4ERR_PAYLOAD_NOT_ATOMIC (Error Code 10098)</name>
          <t>The client encountered a payload in which the blocks were non-atomic
and stay non-atomic.  As the client can not tell if another
client is actively writing, it informs the metadata server of this
error via LAYOUTERROR.  The metadata server can then arrange for
repair of the file.</t>
        </section>
        <section anchor="sec-NFS4ERR_CHUNK_LOCKED">
          <name>NFS4ERR_CHUNK_LOCKED (Error Code 10099)</name>
          <t>The client tried an operation on a chunk which resulted in the data
server reporting that the chunk was locked. The client will then
inform the metadata server of this error via LAYOUTERROR.  The
metadata server can then arrange for repair of the file.</t>
        </section>
        <section anchor="sec-NFS4ERR_CHUNK_GUARDED">
          <name>NFS4ERR_CHUNK_GUARDED (Error Code 10100)</name>
          <t>The client tried a guarded CHUNK_WRITE on a chunk which did not match
the guard on the chunk in the data file. As such, the CHUNK_WRITE was
rejected and the client should refresh the chunk it has cached.</t>
        </section>
        <section anchor="sec-NFS4ERR_PAYLOAD_LOST">
          <name>NFS4ERR_PAYLOAD_LOST (Error Code 10101)</name>
          <t>Returned by a repair actor on the CB_CHUNK_REPAIR response
(ccrr_status) to indicate that the identified ranges cannot be
repaired and the underlying data is no longer recoverable.
Causes include: too few surviving shards to meet the
reconstruction threshold (Katz criterion for Mojette, any
k-of-(k + m) subset for Reed-Solomon Vandermonde), inability to
roll back to a previously committed payload because that payload
is also lost, or exhaustion of all FFV2_DS_FLAGS_REPAIR data
servers available in the layout with no additional replacement
reachable from the metadata server's out-of-band pool.</t>
          <t>On receipt of NFS4ERR_PAYLOAD_LOST from a repair actor, the
metadata server <bcp14>MUST NOT</bcp14> retry the repair by selecting a
different client -- the payload is damaged.  Subsequent client
access to the affected ranges <bcp14>MUST</bcp14> fail: a CHUNK_READ (or an
NFSv4 READ against a damaged PASSTHROUGH range) returns
NFS4ERR_PAYLOAD_LOST; a CHUNK_WRITE that overwrites a damaged
range in its entirety <bcp14>MAY</bcp14> succeed and produce a new atomic
generation for that range (the write does not depend on the
damaged prior content), but a partial-range write that would
require reading the damaged bytes returns NFS4ERR_PAYLOAD_LOST
as well.  Client NFSv4 implementations <bcp14>MUST</bcp14> surface
NFS4ERR_PAYLOAD_LOST to the calling application as the POSIX
errno EIO; a client <bcp14>MAY</bcp14> additionally record a more specific
diagnostic (e.g., Linux EMEDIUMTYPE) in an out-of-band log or
attribute, but the application-visible errno is EIO for
portability.  The metadata server <bcp14>MAY</bcp14> additionally reflect the
damage in an attribute-level indicator or operator-facing
notification, but those mechanisms are outside the scope of
this specification.</t>
          <t>NFS4ERR_PAYLOAD_LOST is distinct from NFS4ERR_DELAY (transient;
metadata server <bcp14>MAY</bcp14> extend the deadline or re-select) and from
NFS4ERR_IO (per-operation failure; metadata server <bcp14>MAY</bcp14> retry or
re-select).  Only NFS4ERR_PAYLOAD_LOST is terminal.</t>
        </section>
        <section anchor="sec-NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED">
          <name>NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED (Error Code 10102)</name>
          <t>Returned by the client on LAYOUTRETURN to indicate that the
layout's ffv2m_checksum_algorithm
(<xref target="sec-ffv2-mirror4"/>) names a checksum_algorithm4
(<xref target="sec-checksum4"/>) that the client does not implement.
The client returns the layout with this error code rather
than attempting CHUNK operations it cannot validate.</t>
          <t>On receipt, the metadata server <bcp14>MAY</bcp14>:</t>
          <ul spacing="normal">
            <li>
              <t>issue a new layout for the same file naming a different
checksum_algorithm4 that the client supports (if the
file's policy permits any of the algorithms the client
does support); or</t>
            </li>
            <li>
              <t>deny the layout request, in which case the client <bcp14>MUST</bcp14>
either fall back to metadata-server-mediated I/O or report an I/O
error to the application.</t>
            </li>
          </ul>
          <t>NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED is distinct from
NFS4ERR_BADLAYOUT (generic "this layout shape is unusable"):
the explicit per-checksum-algorithm signal lets the metadata
server discriminate "client can't read this layout because
of the checksum algorithm" from "client can't read this
layout for some other reason" and respond accordingly.</t>
        </section>
        <section anchor="sec-NFS4ERR_NO_PREDECESSOR">
          <name>NFS4ERR_NO_PREDECESSOR (Error Code 10103)</name>
          <t>Returned on a CHUNK_ROLLBACK
against a COMMITTED chunk when the caller names a
predecessor generation whose owner-to-index association
is no longer recorded by the data server, and no other
per-entry error covers the situation.  This is the "no
restorable predecessor" outcome of the restore case
described under "Rollback of COMMITTED Chunks": the
predecessor's payload+association pair was released some
time earlier under the retention scope rule
(<xref target="sec-system-model-retention-scope"/>) -- by lease expiry,
by an earlier CHUNK_ROLLBACK delete case, or by any
other terminal transition -- and the data server cannot
restore what it no longer holds.</t>
          <t>NFS4ERR_NO_PREDECESSOR is a per-entry status (a caller
that names several generations in a single
CHUNK_ROLLBACK <bcp14>MAY</bcp14> receive NFS4ERR_NO_PREDECESSOR on
some slots and NFS4_OK or other per-entry errors on
others).  It is a data-plane result, NOT a
control-plane failure: the caller reached the data
server successfully, was authorized, and the operation
evaluated normally -- the named predecessor simply
does not exist to restore.</t>
          <t>NFS4ERR_NO_PREDECESSOR is distinct from NFS4ERR_INVAL
(the triple was invalidated by an explicit delete case
and cannot be resurrected -- see "Deletion Atomicity and
Invalidated Triples") and from NFS4ERR_PAYLOAD_LOST
(terminal payload loss reported on CB_CHUNK_REPAIR).
The data server distinguishes NFS4ERR_NO_PREDECESSOR
from NFS4ERR_INVAL on the basis of what the data server
can concretely observe about the presented triple, NOT
on historical knowledge the data server may no longer
retain:</t>
          <dl>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>returned in exactly the cases where the data server can
concretely recognize the presented triple as invalid:</t>
              <dl>
                <dt>Structurally invalid:</dt>
                <dd>
                  <t>the triple is malformed or truncated, or names a
different file or a different data server.</t>
                </dd>
                <dt>Within-window release:</dt>
                <dd>
                  <t>a prior explicit CHUNK_ROLLBACK delete case released the
association and the current request falls within the
same session slot's replay-cache window of that
CHUNK_ROLLBACK, so the data server still holds the
concrete invalidation context that identifies this
triple as released-by-delete-case.</t>
                </dd>
              </dl>
            </dd>
            <dt>NFS4ERR_NO_PREDECESSOR:</dt>
            <dd>
              <t>covers every other case in which the data server holds no
association for the presented triple, including:</t>
              <dl>
                <dt>Retention-scope release:</dt>
                <dd>
                  <t>release under the retention scope rule (lease expiry,
storage-pressure release).</t>
                </dd>
                <dt>Post-window release:</dt>
                <dd>
                  <t>the eventual release of a triple invalidated by an
earlier delete case whose replay-cache window has since
elapsed.</t>
                </dd>
                <dt>No surviving record:</dt>
                <dd>
                  <t>a well-formed triple for this file and this data server
for which the data server holds no surviving record and
no concrete invalidation context.</t>
                </dd>
              </dl>
            </dd>
          </dl>
          <t>An implementation that does not retain a per-triple record
after release cannot distinguish "the data server never
recorded this triple" from "the data server recorded and later
released this triple" outside a live invalidation context, and
this specification does not require it to: both cases resolve
to NFS4ERR_NO_PREDECESSOR under the "no surviving record" case
above.  The two errors are
not interchangeable: NFS4ERR_INVAL is a caller-side
signal that the client <bcp14>MUST NOT</bcp14> retry the same
identity, while NFS4ERR_NO_PREDECESSOR is a data-plane
signal that the caller <bcp14>MAY</bcp14> fall back to
best-effort reconstruction via CHUNK_WRITE_REPAIR.</t>
          <t>A client that receives NFS4ERR_NO_PREDECESSOR <bcp14>MAY</bcp14> fall
back to reconstructing authoritative bytes from
surviving shards and writing them via
CHUNK_WRITE_REPAIR under a
new owner triple; that fallback is best-effort and
<bcp14>MAY</bcp14> itself terminate at NFS4ERR_PAYLOAD_LOST if no
authoritative source exists.  A client that requires
the restored generation to retain the predecessor's
original owner triple in cases where the retention
scope (<xref target="sec-system-model-retention-scope"/>) would
otherwise permit release <bcp14>MUST</bcp14> use the metadata-server escrow
control plane (<xref target="sec-CHUNK_ESCROW_INSTALL"/>
through <xref target="sec-CHUNK_ESCROW_TAKEOVER"/>), which pins
the predecessor's payload and its owner-to-index
association jointly against that release rule for as
long as the escrow-lock or a client-owned lock
adopted from it remains in continuous custody (see
<xref target="sec-composed-rollback"/>).</t>
        </section>
        <section anchor="sec-NFS4ERR_NO_ADOPTABLE_LOCK">
          <name>NFS4ERR_NO_ADOPTABLE_LOCK (Error Code 10104)</name>
          <t>Returned by CHUNK_LOCK when a
repair actor attempts to adopt a metadata-server escrow lock
(<xref target="sec-chunk_guard_mds"/>) and no such adoption is
possible on the data server for the requested range.
There are four state-level causes:</t>
          <ul spacing="normal">
            <li>
              <t>no metadata-server escrow lock is installed on the data server
for the requested range;</t>
            </li>
            <li>
              <t>a metadata-server escrow lock is installed but its
escrow_id4 (<xref target="sec-escrow_id4"/>) does not match
the identity the repair actor presents;</t>
            </li>
            <li>
              <t>the range's escrow lock is currently under a
reconciliation hold following a metadata-server
incarnation change (see
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>) and cannot be
adopted until the hold clears; or</t>
            </li>
            <li>
              <t>the escrow was already adopted by a different
repair actor whose adoption remains active.</t>
            </li>
          </ul>
          <t>Authorization-level failures -- the caller is not
the metadata-server-designated repair actor for
this escrow, or the caller lacks credentials for
the escrow's scope -- surface as NFS4ERR_ACCESS
rather than NFS4ERR_NO_ADOPTABLE_LOCK, so that no
data-plane information about the current adopter is
leaked to an unauthorized caller.</t>
          <t>On receipt of NFS4ERR_NO_ADOPTABLE_LOCK, the repair
client <bcp14>MUST</bcp14> report the outcome to the metadata
server via CB_CHUNK_REPAIR's per-range status array
(<xref target="sec-CB_CHUNK_REPAIR"/>) and <bcp14>MUST NOT</bcp14>
unilaterally acquire a fresh CHUNK_LOCK, retry the
adoption, or invoke the discovery/fallback path of
NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>) -- the four causes
above are all control-plane conditions the metadata
server is best placed to resolve (by reissuing the
escrow, waiting for the reconciliation hold to
clear, or abandoning the repair).</t>
        </section>
        <section anchor="sec-NFS4ERR_STALE_ESCROW">
          <name>NFS4ERR_STALE_ESCROW (Error Code 10105)</name>
          <t>Returned by CHUNK_ESCROW_RELEASE when the escrow_id4
the metadata server presents does not match any
escrow currently installed on the data server for
the referenced range.  Two causes lead to the same
wire outcome:</t>
          <ul spacing="normal">
            <li>
              <t>no escrow covers the referenced range at the
data server (whether never installed, released
earlier, or consumed by a repair adoption); or</t>
            </li>
            <li>
              <t>an escrow covers the range but its recorded
escrow_id4 differs from the one presented (the
presented identity is a stale reference to an
earlier installation).</t>
            </li>
          </ul>
          <t>The data server <bcp14>MUST NOT</bcp14> alter any current lock or
escrow state as a side effect of returning
NFS4ERR_STALE_ESCROW: the response reports "the
identity you presented is not what I hold" without
changing what is held.  In particular, if the range
carries a metadata-server escrow lock whose escrow_id4 differs
from the presented identity, that lock survives the
call unchanged; and if the range carries a
client-owned lock that was previously adopted from
an escrow whose identity matches, that adopted
lock is not affected by a release of the presented
(now-stale) identity.</t>
        </section>
        <section anchor="sec-NFS4ERR_STALE_MDS_EPOCH">
          <name>NFS4ERR_STALE_MDS_EPOCH (Error Code 10106)</name>
          <t>Returned by any of the CHUNK_ESCROW operations
(<xref target="sec-CHUNK_ESCROW_INSTALL"/>,
<xref target="sec-CHUNK_ESCROW_RELEASE"/>,
<xref target="sec-CHUNK_ESCROW_ENUMERATE"/>) when the requesting
metadata server presents an epoch value the data
server no longer accepts because a newer metadata-server
incarnation has completed a
CHUNK_ESCROW_TAKEOVER.
The metadata server that receives NFS4ERR_STALE_MDS_EPOCH
has been fenced from continued escrow operations on
this data server; it <bcp14>MUST NOT</bcp14> retry the operation
under the same epoch and <bcp14>MUST</bcp14> obtain a fresh
incarnation-lease token and reissue via
CHUNK_ESCROW_TAKEOVER before resuming.  CHUNK_ESCROW_TAKEOVER itself is
not subject to this rejection -- it is the recovery
path out of an expired epoch and carries its own
compare-and-advance semantics per
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>.</t>
          <t>NFS4ERR_STALE_MDS_EPOCH is distinct from
NFS4ERR_ACCESS (credential-level failure) and from
NFS4ERR_STALE_ESCROW (identity mismatch on a
specific escrow): the stale-epoch response fences
the presenter's entire escrow-control session, not
a single per-escrow operation.</t>
        </section>
        <section anchor="sec-NFS4ERR_PARTIAL">
          <name>NFS4ERR_PARTIAL (Error Code 10107)</name>
          <t>Returned as the top-level status of a
CB_CHUNK_REPAIR response (<xref target="sec-CB_CHUNK_REPAIR"/>)
when the repair actor evaluated every named range
but at least one range's per-range status is not
NFS4_OK.  The per-range status array
(ccrr_range_status) is authoritative for the
outcome of each range; NFS4ERR_PARTIAL is the
top-level signal that the metadata server <bcp14>MUST</bcp14>
consume the per-range array rather than treating
the response as uniformly successful or uniformly
failed.</t>
          <t>NFS4ERR_PARTIAL is distinct from operation-wide
errors (decode failures, authorization failures,
session state failures) that fail every range at
once: those return the operation-wide error at the
top level with an EMPTY per-range array.
NFS4ERR_PARTIAL requires a co-indexed array with
one entry per named range and <bcp14>MAY</bcp14> carry any mix
of NFS4_OK and per-range failure codes.</t>
        </section>
      </section>
      <section anchor="operations-and-their-valid-errors">
        <name>Operations and Their Valid Errors</name>
        <t>The operations and their valid errors are presented in
<xref target="tbl-ops-and-errors"/>.  All error codes not defined in this document
are defined in <xref section="15" sectionFormat="of" target="RFC8881"/> and <xref section="11" sectionFormat="of" target="RFC7862"/>.</t>
        <table anchor="tbl-ops-and-errors">
          <name>Operations and Their Valid Errors</name>
          <thead>
            <tr>
              <th align="left">Operation</th>
              <th align="left">Errors</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">CHUNK_COMMIT</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_INVAL, NFS4ERR_IO, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ERROR</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_FINALIZE</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_INVAL, NFS4ERR_IO, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">CHUNK_HEADER_READ</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_INVAL, NFS4ERR_IO, NFS4ERR_NOTSUPP, NFS4ERR_PAYLOAD_LOST, NFS4ERR_REP_TOO_BIG, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">CHUNK_LOCK</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_CHUNK_LOCKED, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_NO_ADOPTABLE_LOCK, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_READ</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_IO, NFS4ERR_NOTSUPP, NFS4ERR_PAYLOAD_LOST, NFS4ERR_PAYLOAD_NOT_ATOMIC, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">CHUNK_REPAIRED</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ROLLBACK</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_NO_PREDECESSOR, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_UNLOCK</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_WRITE</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_CHUNK_GUARDED, NFS4ERR_CHUNK_LOCKED, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_IO, NFS4ERR_NOSPC, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">CHUNK_WRITE_REPAIR</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_FHEXPIRED, NFS4ERR_IO, NFS4ERR_NOSPC, NFS4ERR_NOTSUPP, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
            <tr>
              <td align="left">TRUST_STATEID</td>
              <td align="left">NFS4_OK, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_INVAL, NFS4ERR_NOFILEHANDLE, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">REVOKE_STATEID</td>
              <td align="left">NFS4_OK, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DELAY, NFS4ERR_INVAL, NFS4ERR_NOFILEHANDLE, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">BULK_REVOKE_STATEID</td>
              <td align="left">NFS4_OK, NFS4ERR_BADXDR, NFS4ERR_DELAY, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ESCROW_INSTALL</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_CHUNK_LOCKED, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT, NFS4ERR_STALE_MDS_EPOCH</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ESCROW_RELEASE</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT, NFS4ERR_STALE_ESCROW, NFS4ERR_STALE_MDS_EPOCH</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ESCROW_ENUMERATE</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT, NFS4ERR_STALE_MDS_EPOCH</td>
            </tr>
            <tr>
              <td align="left">CHUNK_ESCROW_TAKEOVER</td>
              <td align="left">NFS4_OK, NFS4ERR_ACCESS, NFS4ERR_BADXDR, NFS4ERR_INVAL, NFS4ERR_NOTSUPP, NFS4ERR_PERM, NFS4ERR_SERVERFAULT, NFS4ERR_STALE_MDS_EPOCH</td>
            </tr>
          </tbody>
        </table>
      </section>
      <section anchor="callback-operations-and-their-valid-errors">
        <name>Callback Operations and Their Valid Errors</name>
        <t>The callback operations and their valid errors are presented in
<xref target="tbl-cb-ops-and-errors"/>.  All error codes not defined in this document
are defined in <xref section="15" sectionFormat="of" target="RFC8881"/> and <xref section="11" sectionFormat="of" target="RFC7862"/>.</t>
        <table anchor="tbl-cb-ops-and-errors">
          <name>Callback Operations and Their Valid Errors</name>
          <thead>
            <tr>
              <th align="left">Callback Operation</th>
              <th align="left">Errors</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">CB_CHUNK_REPAIR</td>
              <td align="left">NFS4_OK, NFS4ERR_BADXDR, NFS4ERR_BAD_STATEID, NFS4ERR_DEADSESSION, NFS4ERR_DELAY, NFS4ERR_ENCODING_NOT_SUPPORTED, NFS4ERR_INVAL, NFS4ERR_IO, NFS4ERR_ISDIR, NFS4ERR_LOCKED, NFS4ERR_NOTSUPP, NFS4ERR_OLD_STATEID, NFS4ERR_PARTIAL, NFS4ERR_PAYLOAD_LOST, NFS4ERR_SERVERFAULT, NFS4ERR_STALE</td>
            </tr>
          </tbody>
        </table>
      </section>
      <section anchor="errors-and-the-operations-that-use-them">
        <name>Errors and the Operations That Use Them</name>
        <t>The errors and the operations that use them are presented in
<xref target="tbl-errors-and-ops"/>.  All operations not defined in this document
are defined in <xref section="18" sectionFormat="of" target="RFC8881"/> and <xref section="15" sectionFormat="of" target="RFC7862"/>.</t>
        <table anchor="tbl-errors-and-ops">
          <name>Errors and the Operations That Use Them</name>
          <thead>
            <tr>
              <th align="left">Error</th>
              <th align="left">Operations</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">NFS4ERR_ENCODING_NOT_SUPPORTED</td>
              <td align="left">CB_CHUNK_REPAIR, LAYOUTGET</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PAYLOAD_NOT_ATOMIC</td>
              <td align="left">CHUNK_READ</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_CHUNK_LOCKED</td>
              <td align="left">CHUNK_LOCK, CHUNK_WRITE, CHUNK_ESCROW_INSTALL</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_CHUNK_GUARDED</td>
              <td align="left">CHUNK_WRITE</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PAYLOAD_LOST</td>
              <td align="left">CHUNK_HEADER_READ, CHUNK_READ, CB_CHUNK_REPAIR</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED</td>
              <td align="left">LAYOUTGET</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_NO_PREDECESSOR</td>
              <td align="left">CHUNK_ROLLBACK</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_NO_ADOPTABLE_LOCK</td>
              <td align="left">CHUNK_LOCK</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_STALE_ESCROW</td>
              <td align="left">CHUNK_ESCROW_RELEASE</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_STALE_MDS_EPOCH</td>
              <td align="left">CHUNK_ESCROW_INSTALL, CHUNK_ESCROW_RELEASE, CHUNK_ESCROW_ENUMERATE, CHUNK_ESCROW_TAKEOVER</td>
            </tr>
            <tr>
              <td align="left">NFS4ERR_PARTIAL</td>
              <td align="left">CB_CHUNK_REPAIR</td>
            </tr>
          </tbody>
        </table>
      </section>
    </section>
    <section anchor="exchgid4flaguseerasureds">
      <name>EXCHGID4_FLAG_USE_ERASURE_DS</name>
      <figure anchor="fig-EXCHGID4_FLAG_USE_ERASURE_DS">
        <name>The EXCHGID4_FLAG_USE_ERASURE_DS</name>
        <sourcecode type="xdr"><![CDATA[
   /// const EXCHGID4_FLAG_USE_ERASURE_DS      = 0x00100000;
]]></sourcecode>
      </figure>
      <t>When a data server connects to a metadata server it can via
EXCHANGE_ID (see <xref section="18.35" sectionFormat="of" target="RFC8881"/>) state its pNFS role.
The data server can use EXCHGID4_FLAG_USE_ERASURE_DS (see
<xref target="fig-EXCHGID4_FLAG_USE_ERASURE_DS"/>) to indicate that it supports the
new NFSv4.2 operations introduced in this document.  <xref section="13.1" sectionFormat="of" target="RFC8881"/> describes the interaction of the various pNFS roles masked
by EXCHGID4_FLAG_MASK_PNFS.  However, that does not mask out
EXCHGID4_FLAG_USE_ERASURE_DS.  I.e., EXCHGID4_FLAG_USE_ERASURE_DS can
be used in combination with all of the pNFS flags.</t>
      <t>If the data server sets EXCHGID4_FLAG_USE_ERASURE_DS during the
EXCHANGE_ID operation, then it <bcp14>MUST</bcp14> support all of the operations
in <xref target="tbl-protocol-ops"/>.  Further, this support is orthogonal to the
Erasure Encoding Type selected.  The data server is unaware of which type
is driving the I/O.</t>
    </section>
    <section anchor="new-nfsv42-attributes">
      <name>New NFSv4.2 Attributes</name>
      <section anchor="sec-fattr4_coding_block_size">
        <name>Attribute 89: fattr4_coding_block_size</name>
        <figure anchor="fig-fattr4_coding_block_size">
          <name>XDR for fattr4_coding_block_size</name>
          <sourcecode type="xdr"><![CDATA[
   /// typedef uint64_t                  fattr4_coding_block_size;
   ///
   /// const FATTR4_CODING_BLOCK_SIZE  = 89;
   ///
]]></sourcecode>
        </figure>
        <t>The new attribute fattr4_coding_block_size (see
<xref target="fig-fattr4_coding_block_size"/>) is an <bcp14>OPTIONAL</bcp14> to NFSv4.2 attribute
which <bcp14>MUST</bcp14> be supported if the metadata server supports the Flexible
File Version 2 Layout Type.  By querying it, the client can determine
the data block size it is to use when coding the data blocks to
chunks.</t>
      </section>
      <section anchor="sec-fattr4_chunked_data_file">
        <name>Attribute 90: fattr4_chunked_data_file</name>
        <figure anchor="fig-fattr4_chunked_data_file">
          <name>XDR for fattr4_chunked_data_file</name>
          <sourcecode type="xdr"><![CDATA[
   /// typedef bool                      fattr4_chunked_data_file;
   ///
   /// const FATTR4_CHUNKED_DATA_FILE  = 90;
   ///
]]></sourcecode>
        </figure>
        <t>The new attribute fattr4_chunked_data_file (see
<xref target="fig-fattr4_chunked_data_file"/>) is an <bcp14>OPTIONAL</bcp14> to NFSv4.2
attribute a data server uses to classify a data file as a
chunked-encoding data file for the purpose of enforcing the client
restrictions in <xref target="sec-ops-client"/>.  When set to TRUE, the file is
under flexible file v2 layout chunked-encoding management by a
metadata server; the
data server <bcp14>MUST</bcp14> apply the "<bcp14>MUST</bcp14> reject" rules on client operations
against such files (see <xref target="sec-data-file-identification"/>).  When
FALSE or absent, no such enforcement is triggered by this attribute
alone.</t>
        <t>Only the metadata server sets this attribute; the metadata server
sets it as part of allocating a chunked-encoding data file on the
data server.  Clients <bcp14>MUST NOT</bcp14> SETATTR this attribute; a data
server <bcp14>MUST</bcp14> reject a client SETATTR of FATTR4_CHUNKED_DATA_FILE
with NFS4ERR_INVAL.  A data server that does not support this
attribute falls back to the other identification methods described
in <xref target="sec-data-file-identification"/>.</t>
        <t>The attribute describes the format of the file's content rather
than a property that can be applied to content already written:
when TRUE, the file holds chunks; when FALSE, it holds the data as
the writer supplied it.  Changing the attribute on a file that is
not empty would reinterpret existing content under a format it was
not written in, in either direction, and the resulting
misinterpretation is not detectable from the attribute alone.</t>
        <t>The value is therefore fixed once the file holds data.  The
metadata server <bcp14>MUST NOT</bcp14> change the attribute on a file that is
not empty, and a data server <bcp14>MUST</bcp14> reject a SETATTR of
FATTR4_CHUNKED_DATA_FILE against a file that is not empty with
NFS4ERR_INVAL, whether the request arrives from a client or over
the metadata server's control session.  A metadata server that
allocates a data file before it has selected the encoding for that
file <bcp14>MAY</bcp14> set the attribute to its final value at any point while
the file remains empty.  How a data server determines that a file
is not empty is an implementation matter.</t>
      </section>
    </section>
    <section anchor="new-nfsv42-common-data-structures">
      <name>New NFSv4.2 Common Data Structures</name>
      <section anchor="sec-chunk_cohort_id4">
        <name>chunk_cohort_id4</name>
        <figure anchor="fig-chunk_cohort_id4">
          <name>XDR for chunk_cohort_id4</name>
          <sourcecode type="xdr"><![CDATA[
   /// typedef uint64_t   chunk_cohort_id4;
]]></sourcecode>
        </figure>
        <t>The chunk_cohort_id4 is a 64-bit writer-chosen opaque identifier
that names a single write transaction (a "cohort" of chunks written
together in one CHUNK_WRITE batch, or across several CHUNK_WRITEs
that a single writer chooses to associate as one logical
transaction).  Under the shared-cohort model
(<xref target="sec-CHUNK_WRITE"/>), every chunk in a batch carries the same
chunk_cohort_id4 so that lifecycle operations (CHUNK_FINALIZE,
CHUNK_COMMIT, CHUNK_ROLLBACK) can name the transaction as a
whole.  The data server treats chunk_cohort_id4 opaquely: it does
NOT interpret the value beyond equality comparison, and it is NOT
required to be monotonic, dense, or ordered in any way.  Writers
<bcp14>MUST</bcp14> choose a new chunk_cohort_id4 per distinct write transaction
so that transactions can be distinguished on the data server; the
uniqueness scope required is per-(writer, file), not global.  A
writer with sufficient state <bcp14>MAY</bcp14> generate chunk_cohort_id4 values
from a counter, a random 64-bit source, a hashed transaction
identifier, or any other locally convenient scheme, subject to
the per-writer uniqueness rule.</t>
        <t>On the wire, a single CHUNK_WRITE carries a 12-byte cohort
header (chunk_cohort_id4 + writer's cg_client_id) once for
the batch, followed by, per chunk in the batch, the tagged
checksum4 and the opaque chunk payload, as shown in
<xref target="fig-chunk-wire-layout"/>.  The payload length is carried
separately in the CHUNK_WRITE4args cwa_chunks&lt;&gt; slot; the
diagram shows the header once and the per-chunk framing
that repeats.</t>
        <figure anchor="fig-chunk-wire-layout">
          <name>CHUNK_WRITE wire framing: cohort header + per-chunk chunks</name>
          <artwork><![CDATA[
    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    cwa_cohort_id (hi 32)                      |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    cwa_cohort_id (lo 32)                      |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                       cwa_client_id                           |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                       cs_algorithm                            |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                        cs_value_len                           |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    cs_value ... (variable)                    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    opaque payload ...                         |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   Bytes 0-7:    cwa_cohort_id   (chunk_cohort_id4; 64-bit opaque
                                  writer-chosen cohort identifier;
                                  once per CHUNK_WRITE)
   Bytes 8-11:   cwa_client_id   (writer's layout-granted 32-bit
                                  client id; once per CHUNK_WRITE)
   Bytes 12-15:  cs_algorithm    (checksum_algorithm4; per chunk)
   Bytes 16-19:  cs_value_len    (XDR opaque length prefix; per chunk)
   Bytes 20-N:   cs_value        (checksum bytes; length per
                                  cs_algorithm's registered output;
                                  per chunk)
   Bytes N+1-M:  opaque payload  (encoded shard; variable length;
                                  per chunk)

   The checksum block (cs_algorithm + cs_value_len + cs_value)
   is the XDR encoding of one checksum4.
   For CHECKSUM_ALG_NONE the cs_value_len is zero and the
   payload follows immediately after byte 19.  The per-chunk
   framing (bytes 12 onward) repeats for each chunk in the
   batch; the cohort header (bytes 0-11) appears once per
   CHUNK_WRITE.  The per-chunk co_id values live in
   CHUNK_WRITE4args cwa_co_ids<> and are not part of this
   framing.
]]></artwork>
        </figure>
      </section>
      <section anchor="sec-chunk_guard4">
        <name>chunk_guard4</name>
        <figure anchor="fig-chunk_guard4">
          <name>XDR for chunk_guard4</name>
          <sourcecode type="xdr"><![CDATA[
   /// const CHUNK_GUARD_CLIENT_ID_NONE = 0x00000000;
   /// const CHUNK_GUARD_CLIENT_ID_MDS  = 0xFFFFFFFF;
   ///
   /// struct chunk_guard4 {
   ///     uint32_t   cg_gen_id;
   ///     uint32_t   cg_client_id;
   /// };
]]></sourcecode>
        </figure>
        <t>The chunk_guard4 (see <xref target="fig-chunk_guard4"/>) is the per-chunk
compare-and-swap (CAS) state used by CHUNK_WRITE to detect concurrent updates.  It is state
that the data server MAINTAINS per chunk; the writer transaction
identity (the "cohort") is carried separately by
chunk_cohort_id4 (<xref target="sec-chunk_cohort_id4"/>) and is NOT part of
chunk_guard4.  chunk_guard4 has two fields:</t>
        <dl>
          <dt>cg_gen_id:</dt>
          <dd>
            <t>A per-chunk monotonic generation counter, tracked by the data
server.  Each chunk's gen_id starts at 0 when the chunk is
first written and is incremented on each successful CHUNK_WRITE
by any client.  cg_gen_id is NOT a timestamp -- the protocol
does not rely on a global clock, and no interpretation of
cg_gen_id as a wall-clock value is supported.  cg_gen_id
values are NOT comparable across distinct chunks; a given
cg_gen_id is only meaningful within the scope of a single
chunk on a single file.  cg_gen_id is NOT a transaction
identifier and <bcp14>MUST NOT</bcp14> be interpreted as naming or ordering
write transactions: transaction identity is chunk_cohort_id4
(<xref target="sec-chunk_cohort_id4"/>).</t>
          </dd>
          <dt>cg_client_id:</dt>
          <dd>
            <t>A 32-bit value established by the metadata server at the time
the client's layout is granted (see <xref target="sec-ffv2-mirror4"/> and
ffv2m_client_id).  The metadata server <bcp14>MUST</bcp14> assign distinct
cg_client_id values to distinct clients that hold concurrent
write layouts on the same file.  cg_client_id is opaque with
respect to client identity -- a data server <bcp14>MUST NOT</bcp14>
interpret its bits as naming or ordering clients in any
external sense.  The value supports two operations only:
equality comparison (to detect whether the current writer is
the client that last wrote a chunk) and numeric comparison
(to implement the tiebreaker rule below).  The same
cg_client_id value appears in the cohort record
(<xref target="sec-chunk_owner4"/>) as co_client_id; the two are
redundant carriers of the same layout-granted writer identity
so that both CAS state and cohort records remain
self-contained.</t>
          </dd>
          <dt>Uniqueness contract:</dt>
          <dd>
            <t>The chunk_guard4 pair (cg_gen_id, cg_client_id) identifies the
MOST RECENT successful writer of a chunk plus that chunk's
generation counter; it does NOT identify a specific write
transaction (that role is filled by chunk_cohort_id4).
Neither field alone is globally unique; two clients <bcp14>MAY</bcp14>
observe the same cg_gen_id on distinct chunks (each chunk's
counter is independent), and the cg_client_id is what makes
concurrent writers distinguishable at the CAS layer.</t>
          </dd>
          <dt>Observability:</dt>
          <dd>
            <t>The data server exposes the chunk's current chunk_guard4 on
the read path so that a client preparing a CAS update in
multiple writer mode (<xref target="sec-multi-writer"/>) can obtain the
expected prior value without racing.  Two operations return
it: CHUNK_READ carries cr_guard in each read_chunk4
(<xref target="sec-CHUNK_READ"/>), and CHUNK_HEADER_READ returns a
chrr_guards&lt;&gt; array co-indexed with the other per-chunk
arrays (<xref target="sec-CHUNK_HEADER_READ"/>).  A client places the
observed pair into cwa_guard.cwg_guard and sets
cwa_guard.cwg_check = TRUE on the subsequent CHUNK_WRITE; the data server compares against its
currently-held chunk_guard4 and returns NFS4ERR_CHUNK_GUARDED
on mismatch.</t>
          </dd>
          <dt>Deterministic contention resolution for concurrent writers:</dt>
          <dd>
            <t>When two or more clients race on the same chunk in the
multi-writer mode, the losing writer -- the one whose CAS
fails at any affected data server -- <bcp14>MUST</bcp14> roll back the
chunks it already wrote for the affected transaction and
retry under a fresh cohort id.  Convergence is achieved
by making losing writers back off, not by having the data
server pick a winner from the losing writer's state.
This is the wire-level mechanism that implements the
consistency invariant in <xref target="sec-system-model-consistency"/>
("one writer's entire chunk-generation wins and becomes
COMMITTED; the other writer sees NFS4ERR_CHUNK_GUARDED and
is expected to re-read and retry"); <xref target="sec-system-model-progress"/>
documents the progress guarantee this rule underwrites.
</t>
            <dl>
              <dt>At CHUNK_WRITE (per data server, arrival-order):</dt>
              <dd>
                <t>the data server accepts the first CHUNK_WRITE whose
chunk_guard4 CAS check succeeds against the chunk's
current chunk_guard4 value.  Later writers whose CAS
fails receive NFS4ERR_CHUNK_GUARDED for that chunk.
Because arrival order can differ between data servers,
different subsets of the mirror set <bcp14>MAY</bcp14> initially accept
different clients' writes for different chunks; that is
transient divergence, resolved by the client-driven
rollback below.</t>
              </dd>
              <dt>At NFS4ERR_CHUNK_GUARDED (client-driven rollback and retry):</dt>
              <dd>
                <t>a client that observes NFS4ERR_CHUNK_GUARDED on any
chunk of an in-flight transaction <bcp14>MUST</bcp14> treat the entire
transaction as lost.  It <bcp14>MUST</bcp14> issue CHUNK_ROLLBACK against every data server that
accepted a CHUNK_WRITE under this transaction's cohort
pair, so that the data server can release the PENDING
state and revert cg_gen_id to the value it held before
the losing writer's CAS succeeded.  The client then
re-reads the chunks with CHUNK_READ, applies its intended
change to the as-observed data, chooses a fresh
cwa_cohort_id, and re-issues CHUNK_WRITE with
cwa_guard.cwg_check = TRUE supplying the refreshed prior
chunk_guard4.</t>
              </dd>
              <dt>At CHUNK_FINALIZE (single winner already established):</dt>
              <dd>
                <t>by the time the mirror set converges, only one writer's
cohort remains as the PENDING state for each affected
chunk (all others have rolled back).  CHUNK_FINALIZE
against that PENDING state succeeds; there is no
tiebreaker comparison against the caller's co_client_id
at FINALIZE.  A caller that attempts CHUNK_FINALIZE
against a chunk whose current PENDING state carries a
cohort pair not matching the caller's transaction <bcp14>MUST</bcp14>
receive NFS4ERR_CHUNK_GUARDED and <bcp14>MUST</bcp14> proceed with the
rollback-and-retry flow above.  A caller whose own
PENDING state was overwritten by a different writer
<bcp14>SHOULD</bcp14> also receive NFS4ERR_CHUNK_GUARDED (the caller no
longer has a PENDING chunk to finalize).</t>
              </dd>
            </dl>
            <t>A client that has rolled back and retried but continues
to observe NFS4ERR_CHUNK_GUARDED without forward
progress after a bounded number of retries <bcp14>MUST</bcp14>
escalate via LAYOUTERROR and the repair coordination
flow in <xref target="sec-repair-selection"/>.  Bounded retry is a
client-implementation matter; the protocol does not
mandate a specific count, only that unbounded retry is
forbidden so that a contentious workload cannot livelock
without surfacing the contention to the metadata server.</t>
            <t>Client cg_client_id ordering is NOT used to pick a
winner: the numeric ordering of cg_client_id values is
arbitrary with respect to clients' external identities
and <bcp14>MUST NOT</bcp14> be interpreted as a preference ordering
over the clients themselves.  The arrival-order
arbitration at each data server, combined with mandatory
client rollback on CAS failure, is what makes the mirror
set converge; the metadata server <bcp14>MAY</bcp14> still arrange
cg_client_id assignment to influence diagnosis but <bcp14>MUST
NOT</bcp14> rely on numeric ordering for correctness.</t>
          </dd>
        </dl>
        <section anchor="metadata-server-assignment-rules-for-cgclientid">
          <name>Metadata-Server Assignment Rules for cg_client_id</name>
          <t>To uphold the uniqueness contract, the metadata server <bcp14>MUST</bcp14>
follow these rules when assigning cg_client_id (that is, when
populating ffv2m_client_id at layout-grant time):</t>
          <ul spacing="normal">
            <li>
              <t>Two clients holding concurrent write layouts on the same
file <bcp14>MUST</bcp14> receive distinct cg_client_id values.  A client
that holds only a read layout need not be assigned a
distinct value.</t>
            </li>
            <li>
              <t>The reserved sentinel CHUNK_GUARD_CLIENT_ID_NONE (0x00000000)
<bcp14>MUST NOT</bcp14> be assigned to any client; <xref target="sec-chunk_guard_none"/>
gives the reason 0 is reserved.</t>
            </li>
            <li>
              <t>The reserved sentinel CHUNK_GUARD_CLIENT_ID_MDS (0xFFFFFFFF)
<bcp14>MUST NOT</bcp14> be assigned to any client.</t>
            </li>
            <li>
              <t>A cg_client_id <bcp14>MAY</bcp14> be reused by the metadata server after
the prior holder's layout has been fully returned (via
LAYOUTRETURN or revocation).  The metadata server <bcp14>SHOULD</bcp14>
avoid reusing a cg_client_id within a single lease period
to simplify diagnosis of stale writes.</t>
            </li>
            <li>
              <t>cg_client_id values do not persist across metadata-server
restart.  Clients reclaiming layouts during the grace period
receive freshly assigned values; the protocol does not rely
on any pre-restart assignment surviving.</t>
            </li>
          </ul>
        </section>
        <section anchor="data-server-collision-handling">
          <name>Data-Server Collision Handling</name>
          <t>A (cg_gen_id, cg_client_id) pair that the uniqueness contract
would otherwise render unique can nonetheless collide if a
client and the metadata server disagree about which
cg_client_id the client currently holds, or if a client
presents a spoofed cg_client_id.  The data server enforces the
contract locally:</t>
          <ul spacing="normal">
            <li>
              <t>If the data server receives a CHUNK_WRITE whose
chunk_guard4 has the same (cg_gen_id, cg_client_id) as a
chunk already in PENDING, FINALIZED, or COMMITTED state
AND the presented payload differs from the retained
payload, the data server <bcp14>MUST</bcp14> reject the write with
NFS4ERR_CHUNK_GUARDED and <bcp14>SHOULD</bcp14> report the collision to
the metadata server via LAYOUTERROR.  This situation is a
protocol violation on one side of the conversation; the
metadata server resolves it by revoking the offending
client's layout and selecting a repair actor under
<xref target="sec-repair-selection"/>.</t>
            </li>
            <li>
              <t>If a client presents CHUNK_GUARD_CLIENT_ID_MDS as
cg_client_id in any client-originated operation, the data
server <bcp14>MUST</bcp14> reject the operation with NFS4ERR_INVAL (see
<xref target="sec-chunk_guard_mds"/>).</t>
            </li>
            <li>
              <t>A cg_client_id that does not match the tsa_client_id
recorded for the layout stateid under which the
CAS operation is issued <bcp14>MUST</bcp14> be rejected with
NFS4ERR_BAD_STATEID.  This (stateid, client_id) binding is
registered by the metadata server via TRUST_STATEID; an unmatched cg_client_id is
treated as a stale-layout condition, see
<xref target="sec-tight-coupling-control"/>.</t>
            </li>
          </ul>
        </section>
        <section anchor="sec-chunk_guard_none">
          <name>Reserved cg_client_id Value: CHUNK_GUARD_CLIENT_ID_NONE</name>
          <t>The value <tt>CHUNK_GUARD_CLIENT_ID_NONE</tt> (0x00000000) is reserved.
It does not denote any client.  Reserving 0 prevents an
uninitialized cg_client_id field from passing as a real client
and ensures the deterministic tiebreaker (numerically lowest
wins, see <xref target="sec-chunk_guard4"/>) does not encode an implicit
priority via assignment of 0.</t>
          <t>Clients <bcp14>MUST NOT</bcp14> present CHUNK_GUARD_CLIENT_ID_NONE as the
cg_client_id of any client-originated chunk_guard4 or
chunk_owner4.  A data server that receives such a value from
a client <bcp14>MUST</bcp14> reject the operation with NFS4ERR_INVAL.</t>
        </section>
        <section anchor="sec-chunk_guard_mds">
          <name>CHUNK_GUARD_CLIENT_ID_MDS and the Metadata-Server Escrow Lock</name>
          <t>The value <tt>CHUNK_GUARD_CLIENT_ID_MDS</tt> (0xFFFFFFFF) is reserved.
It denotes that the chunk lock is held by the metadata server
itself, in escrow during a repair coordination sequence (see
<xref target="sec-repair-selection"/>).  The data server produces a
chunk_guard4 with this cg_client_id when the metadata server
revokes the prior holder's stateid while that holder still holds
chunk locks; the locks <bcp14>MUST NOT</bcp14> be dropped and are transferred to
the metadata-server escrow owner instead.</t>
          <t>The metadata server does not originate CHUNK_LOCK or CHUNK_WRITE
traffic on its own session.  Clients <bcp14>MUST NOT</bcp14> present
CHUNK_GUARD_CLIENT_ID_MDS as the cg_client_id of any
client-originated chunk_guard4 or chunk_owner4.  A data server
that receives such a value from a client <bcp14>MUST</bcp14> reject the
operation with NFS4ERR_INVAL.</t>
          <t>The metadata-server escrow owner is released only by a CHUNK_LOCK from the
client selected via CB_CHUNK_REPAIR, carrying
CHUNK_LOCK_FLAGS_ADOPT.  See <xref target="sec-CHUNK_LOCK"/>.</t>
          <t>Each metadata-server escrow lock carries an escrow_id4
(<xref target="sec-escrow_id4"/>) the metadata server chose at
CHUNK_ESCROW_INSTALL (<xref target="sec-CHUNK_ESCROW_INSTALL"/>) time
and presents on every subsequent operation that refers
to that lock (CHUNK_ESCROW_RELEASE, CB_CHUNK_REPAIR,
CHUNK_LOCK adoption via cla_adopt).  When a repair
client adopts the metadata-server escrow lock (CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT), the data server <bcp14>MUST</bcp14> retain
the adopted escrow_id4 as durable custody metadata on
the resulting client-owned lock, for as long as a
subsequent revocation-transfer can occur that would
convert the client-owned lock back to a metadata-server escrow
lock (for example, when the client's lease later
expires while the lock is still held).  If such a
revocation-transfer occurs, the resulting new
metadata-server escrow lock <bcp14>MUST</bcp14> be installed with the SAME
escrow_id4 that was preserved as custody metadata,
not a fresh identity: this preserves the full durable
key <tt>(file, escrow_id, data-server set)</tt> across the entire
custody chain so that a metadata server's tuple
records can re-associate with the reappeared escrow
across an incarnation change (see
<xref target="sec-CHUNK_ESCROW_ENUMERATE"/> discovery).</t>
        </section>
      </section>
      <section anchor="sec-chunk_owner4">
        <name>chunk_owner4</name>
        <figure anchor="fig-chunk_owner4">
          <name>XDR for chunk_owner4</name>
          <sourcecode type="xdr"><![CDATA[
   /// struct chunk_owner4 {
   ///     chunk_cohort_id4  co_cohort_id;
   ///     uint32_t          co_client_id;
   ///     uint32_t          co_id;
   /// };
]]></sourcecode>
        </figure>
        <t>The chunk_owner4 (see <xref target="fig-chunk_owner4"/>) is the "cohort
record" for a chunk: it identifies the write transaction that
produced the chunk and which of that transaction's chunks the
record refers to.  It is separate from chunk_guard4
(<xref target="sec-chunk_guard4"/>), which is the per-chunk CAS state.  The
three fields together form the full owner triple.</t>
        <t>co_cohort_id is the chunk_cohort_id4 shared by every chunk
written together in a single logical transaction (see
<xref target="sec-CHUNK_WRITE"/> and the discussion of chunk_cohort_id4
above).  Two chunks are members of the same write transaction
iff their (co_cohort_id, co_client_id) pairs are equal.
Lifecycle operations (CHUNK_FINALIZE, CHUNK_COMMIT,
CHUNK_ROLLBACK) name transactions by co_cohort_id + co_client_id.</t>
        <t>co_client_id is the writer's layout-granted 32-bit identity, the
same value that appears as cg_client_id in the chunk_guard4 CAS
state (see <xref target="sec-chunk_guard4"/>).  It supports equality
comparison (matching cohort records to lifecycle operations) and
numeric comparison (implementing the multi-writer tiebreaker
described in <xref target="sec-chunk_guard4"/>).</t>
        <t>co_id is a writer-supplied opaque per-chunk identifier the client
chooses at CHUNK_WRITE time (see <xref target="sec-CHUNK_WRITE"/>).  It is
NOT required to equal the chunk's file index; the client <bcp14>MAY</bcp14>
choose any uint32_t value, subject only to the uniqueness
constraint that within a single (co_cohort_id, co_client_id) all
co_id values <bcp14>MUST</bcp14> be distinct so that a subsequent lifecycle
operation can name individual chunks unambiguously.  The data
server treats co_id opaquely; it does NOT interpret the value
beyond equality comparison against the co_id values it previously
accepted from the client for this cohort.  Writers that would
otherwise choose file-index values <bcp14>MAY</bcp14> do so, but the wire
semantics do not privilege that choice.</t>
        <t>Each distinct chunk-write transaction from a given client <bcp14>MUST</bcp14>
carry a unique co_cohort_id, so lifecycle operations can be
correlated with the transactions that produced them across all
data files.  The uniqueness scope required is per-(co_client_id,
file); different clients <bcp14>MAY</bcp14> independently pick colliding
co_cohort_id values because co_client_id disambiguates them.</t>
      </section>
      <section anchor="sec-escrow_id4">
        <name>escrow_id4</name>
        <t>For the design rationale of the escrow control plane -- what
problem it solves and how the components compose -- see
<xref target="sec-system-model-escrow"/>.  This section defines the
identifier only.</t>
        <figure anchor="fig-escrow_id4">
          <name>XDR for escrow_id4</name>
          <sourcecode type="xdr"><![CDATA[
   /// typedef opaque   escrow_id4[16];
]]></sourcecode>
        </figure>
        <t>The escrow_id4 is a 128-bit opaque identifier the
metadata server chooses for each metadata-server escrow lock
(<xref target="sec-chunk_guard_mds"/>) it installs on a data
server.  It is distinct from the chunk_owner4 owner
triple (<xref target="sec-chunk_owner4"/>) that identifies a chunk
generation: the escrow identity refers to the
custody of a repair-scope lock, while the owner
triple refers to a specific generation's bytes.  The
two namespaces do not overlap and are compared only
within their own contexts (an escrow_id4 is never
matched against a chunk_owner4 field).</t>
        <t>The escrow identity is threaded through the
metadata-server operations that manage escrow
custody: it appears in each escrow-family operation
this specification defines (CHUNK_ESCROW_INSTALL /
CHUNK_ESCROW_RELEASE / CHUNK_ESCROW_ENUMERATE /
CHUNK_ESCROW_TAKEOVER), in the callback that carries
the repair instruction (CB_CHUNK_REPAIR), and in the
CHUNK_LOCK argument variant that adopts an escrow
lock (see <xref target="sec-CHUNK_LOCK"/>).  A conforming
metadata server <bcp14>MUST</bcp14> choose escrow_id4 values that
are unique across every escrow it has ever installed
on any data server that might still recognize a
prior installation -- sufficient uniqueness is
provided by a 128-bit identifier drawn from a
metadata-server-incarnation prefix and a
per-incarnation monotonic counter, or by any
mechanism whose collision probability is negligible
across the lifetime of the deployment.  The metadata
server <bcp14>MUST NOT</bcp14> reuse an escrow_id4 whose lifecycle
is not provably complete.</t>
        <t>The data server treats escrow_id4 opaquely: it
compares two escrow_id4 values for equality when
matching a CHUNK_LOCK adoption against an
installed escrow, or when reconciling an escrow
tuple against a discovery response, and does not
interpret the internal structure.</t>
      </section>
      <section anchor="sec-chunk_state_flags4">
        <name>chunk_state_flags4</name>
        <figure anchor="fig-chunk_state_flags4">
          <name>XDR for chunk_state_flags4</name>
          <sourcecode type="xdr"><![CDATA[
   /// const CHUNK_STATE_FLAGS_LOCKED  = 0x00000001;
   ///
   /// typedef uint32_t   chunk_state_flags4;
]]></sourcecode>
        </figure>
        <t>The chunk_state_flags4 is a 32-bit bitmask carried in per-chunk
result arrays (chrr_locked in CHUNK_HEADER_READ4resok, cr_locked
in read_chunk4) to report the read-time state of a chunk on the
data server.  The value 0 means "no state flags set"; each
defined bit indicates a specific state property.  Unassigned
bits are reserved for future revisions of this specification;
receivers <bcp14>MUST</bcp14> ignore bits they do not recognize so that
additions are additive on the wire.</t>
        <dl>
          <dt>CHUNK_STATE_FLAGS_LOCKED:</dt>
          <dd>
            <t>the chunk currently has a CHUNK_LOCK held by some
chunk_owner4.  This state is reported orthogonally to the
per-chunk chrr_status / cr_status so that a locked chunk
still surfaces its lifecycle state and chunk_owner4 to the
inspector.</t>
          </dd>
        </dl>
      </section>
      <section anchor="sec-proof-profile">
        <name>Incarnation-Lease Proof</name>
        <t>CHUNK_ESCROW_TAKEOVER accepts a bounded
opaque proof payload identified by a proof profile
identifier.  The proof is not the metadata server's
own machine credential (which would only prove the
role, not the current exclusive incarnation): it is
an assertion issued by a single writer authority
external to the metadata server (a high-availability
manager, a cluster-consensus service, or an
operator-mediated recovery workflow) that only one
metadata-server instance currently holds the
incarnation lease.  The data server verifies the
proof before it will compare-and-advance its
recorded metadata-server epoch to the value the
takeover names.</t>
        <figure anchor="fig-proof-profile-typedef">
          <name>XDR for proof_profile_id4</name>
          <sourcecode type="xdr"><![CDATA[
   /// /* Registered proof profile identifier.  Values
   ///  * are allocated from the flexible file v2 layout
   ///  * proof-profile registry (see IANA Considerations,
   ///  * "Proof-Profile Registry").
   ///  */
   /// typedef uint32_t   proof_profile_id4;
   ///
   /// /* Reserved sentinel; MUST NOT appear on the wire. */
   /// const PROOF_PROFILE_UNSPECIFIED           = 0;
   ///
   /// /* Mandatory-to-implement profile:
   ///  * HA-authority-signed COSE_Sign1 lease token
   ///  * (see "Mandatory-to-Implement Profile" below).
   ///  */
   /// const PROOF_PROFILE_HA_AUTHORITY_ED25519  = 1;
   ///
   /// /* Upper bound (in bytes) on the proof payload
   ///  * a metadata server MAY present.
   ///  */
   /// const CETA_INCARNATION_PROOF_MAX4         = 4096;
]]></sourcecode>
        </figure>
        <section anchor="mandatory-to-implement-profile">
          <name>Mandatory-to-Implement Profile</name>
          <t>A conforming implementation <bcp14>MUST</bcp14> support at least
one proof profile so that two independent
implementations can verify each other's takeover
proofs at the wire level without prior out-of-band
negotiation.  This specification designates the
following profile as mandatory-to-implement.</t>
          <t>The mandatory profile carries a signed token whose
signer is the incarnation-lease authority (NOT the
metadata server itself).  The envelope is a
COSE_Sign1 structure (Section 4.2 of <xref target="RFC9052"/>)
over a deterministic CBOR payload (Section 4.2 of
<xref target="RFC8949"/>) with the following normative choices:</t>
          <dl>
            <dt>Signature algorithm (mandatory-to-implement):</dt>
            <dd>
              <t>Ed25519 (algorithm identifier -8 per <xref target="RFC9053"/>).  A
conforming signer <bcp14>MUST</bcp14> use
Ed25519; a conforming verifier <bcp14>MUST</bcp14> accept
Ed25519.  Other signature algorithms (e.g.,
ECDSA-P256 with identifier -7, RSASSA-PSS-SHA256
with identifier -37) <bcp14>MAY</bcp14> be registered as
additional profiles per the IANA Considerations.</t>
            </dd>
            <dt>kid header parameter:</dt>
            <dd>
              <t><bcp14>OPTIONAL</bcp14>.  A deployment
with a single trust anchor <bcp14>MAY</bcp14> omit it; a
deployment supporting key rotation or multiple
trust anchors <bcp14>SHOULD</bcp14> include it so a data server
can select the correct verification key.  Absent
kid, the data server attempts verification
against each configured trust anchor and accepts
on the first match.</t>
            </dd>
            <dt>Payload map fields:</dt>
            <dd>
              <t>the signed CBOR payload is a map with integer-keyed fields
(per <xref target="RFC9053"/> convention for compact wire size).
The mandatory-profile keys are:
 - 1 = principal (CBOR text string): the
   metadata-server principal that holds this
   incarnation.  Comparison is byte-for-byte
   against the RPCSEC_GSS authenticated name of
   the presenter (Section 5 of <xref target="RFC7861"/>),
   with no Unicode normalization or case
   folding; a deployment <bcp14>MUST</bcp14> provision the
   authority to sign tokens whose principal
   field is exactly the RPC-authenticated name
   the data server will observe.
 - 2 = epoch (CBOR uint): the metadata-server
   epoch value being claimed.  On presentation in
   CHUNK_ESCROW_TAKEOVER the data server
   <bcp14>MUST</bcp14> verify that this field equals
   ceta_new_epoch in the operation arguments; any
   mismatch is a signature-and-payload check
   failure at step 4 of "Presentation and
   Verification" below and returns NFS4ERR_ACCESS.
 - 3 = scope (CBOR text string): identifier of
   the data server or data-server set the token
   is valid for.  Comparison is byte-for-byte
   against the data-server-side value the
   deployment provisions at trust-anchor setup
   (see "Trust Anchor Provisioning" below); a
   data server accepts a token whose scope
   field exactly matches any scope identifier
   it has been provisioned to serve, and
   rejects any other value.  The scope
   namespace is deployment-local -- this
   specification neither defines a format nor
   constrains the character set beyond
   requiring UTF-8 CBOR text.
 - 4 = issued_at (CBOR tag-1 epoch-based
   date/time per <xref target="RFC8949"/> Section 3.4.2):
   the instant the authority signed the token.
   A conforming issuer <bcp14>MUST</bcp14> encode this as a
   CBOR unsigned integer number of seconds
   since the POSIX epoch; a verifier <bcp14>MUST</bcp14>
   reject a token whose issued_at is not an
   unsigned integer under tag 1 (fractional or
   negative values are rejected).
 - 5 = expires_at (CBOR tag-1 epoch-based
   date/time per <xref target="RFC8949"/> Section 3.4.2):
   the instant the token ceases to be
   admissible.  Same encoding constraints as
   issued_at.
 - 6 = token_id (CBOR byte string, 16 bytes):
   a nonce for replay detection.</t>
            </dd>
          </dl>
        </section>
        <section anchor="presentation-and-verification">
          <name>Presentation and Verification</name>
          <t>The metadata server presents the profile identifier
and the proof bytes together in the takeover
arguments (see <xref target="sec-CHUNK_ESCROW_TAKEOVER"/>).  The
data server <bcp14>MUST</bcp14> evaluate the takeover in a fixed
order so that no failure discloses state that a
prior check would have denied:</t>
          <ol spacing="normal" type="1"><li>
              <t>session replay-cache lookup: retransmission of a
prior request in the current session slot
returns the cached response;</t>
            </li>
            <li>
              <t>presenter authorization: RPCSEC_GSS presenter
authentication and credential check
(NFS4ERR_ACCESS if the caller lacks metadata-server
role);</t>
            </li>
            <li>
              <t>profile support: unknown proof_profile_id4
returns NFS4ERR_NOTSUPP;</t>
            </li>
            <li>
              <t>proof verification: the profile's signature and
payload checks are applied (NFS4ERR_ACCESS on
any failure -- bad signature, mismatched
principal, mismatched epoch, mismatched scope,
token past expires_at, or token_id already in
the data server's replay cache);</t>
            </li>
            <li>
              <t>epoch compare-and-advance: NFS4ERR_STALE_MDS_EPOCH
on mismatch, otherwise the epoch and
epoch_expires_at are advanced atomically per
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>.</t>
            </li>
          </ol>
          <t>The strict ordering ensures an unauthenticated
caller learns nothing about which profiles the data
server supports or which epoch it currently holds.</t>
          <t>Replay-cache scoping (both layers): the NFSv4.1
session replay cache in step 1 is scoped to the
session slot and its lifetime is bounded by session
liveness.  The token_id replay cache in step 4 is
scoped to the (proof_profile_id4, verified issuer)
pair and <bcp14>MUST</bcp14> be sized and expired coherently with
the token's own expires_at, so that a valid token
cannot be replayed after its natural expiry and a
recently-observed token cannot be inadvertently
retired while still admissible.  A data server <bcp14>MAY</bcp14>
persist the token_id replay cache across restart.
Loss of a cache entry (eviction, non-persisted
restart) does not permanently defeat lost-response
recovery: the byte-identical uncertain-completion
recovery path in
<xref target="sec-CHUNK_ESCROW_TAKEOVER-uncertain-completion"/>
covers the cache-miss form and returns the same
postcondition-equivalent NFS4_OK when the operation
had already completed.</t>
        </section>
        <section anchor="sec-CHUNK_ESCROW_TAKEOVER-uncertain-completion">
          <name>Uncertain-Completion Recovery for TAKEOVER</name>
          <t>CHUNK_ESCROW_TAKEOVER is the recovery
path a metadata server uses after an incarnation
change; the compare-and-advance semantics make the
successful case observable to the data server, but
the metadata server <bcp14>MAY</bcp14> lose the response to a
successful TAKEOVER (network drop, RPC
retransmission timeout, session loss).  The bare
strict-ordering rules above would rebuff a
byte-identical reissue: either the token_id
replay-cache check at step 4 rejects with
NFS4ERR_ACCESS (the cache still holds the entry) or
the epoch compare-and-advance at step 5 rejects
with NFS4ERR_STALE_MDS_EPOCH (the ordinary path,
because the reissue's ceta_expected_prior_epoch
names the pre-advance epoch that the earlier
successful TAKEOVER has already moved past).  In
either case the metadata server has no way to
distinguish "the prior TAKEOVER succeeded and the
response was lost" from "the proof is invalid."</t>
          <t>To close that recovery gap, a data server <bcp14>MUST</bcp14>
accept a byte-identical CHUNK_ESCROW_TAKEOVER
reissue as postcondition-equivalent success when
step 4's signature and payload checks succeed
(signature verifies against the deployment-provisioned
trust anchor; the signed principal,
scope, and epoch match; the token is within its
expires_at window; all per <xref target="sec-proof-profile"/>
"Payload map fields"), with the ordinary step-4
"token_id already in the replay cache" rejection
overridden as stated below, and both of the
following hold:</t>
          <ul spacing="normal">
            <li>
              <t>the reissue's ceta_new_epoch equals the data
server's currently-recorded metadata-server
epoch (the takeover the token authorized has
already completed); and</t>
            </li>
            <li>
              <t>the reissue's ceta_expected_prior_epoch is
strictly less than the reissue's ceta_new_epoch
(the token names a genuine advance, not a
no-op).</t>
            </li>
          </ul>
          <t>The recovery rule takes two forms distinguished by
the state of the token_id replay cache at the data
server:</t>
          <dl>
            <dt>Cache-hit form (ordinary lost-response case):</dt>
            <dd>
              <t>the token_id is present in the token_id replay cache.  The
data server recognizes the
cached byte-identical decision and returns the
cached NFS4_OK result; step 5 is not re-executed.
Cache-miss form (applies after eviction or non-persisted restart):</t>
            </dd>
            <dt/>
            <dd>
              <t>the token_id is not present in the replay cache.  The data
server
treats the presentation as a fresh byte-identical
proof under the two epoch predicates
above and does NOT execute step 5 (the epoch is
already at the post-advance state).</t>
            </dd>
          </dl>
          <t>Under these predicates the data server returns
NFS4_OK without side effect: the epoch and
epoch_expires_at are already at the post-advance
state, no state changes, and the second observation
is idempotent.  The rule is safe against a fresh
presentation of an already-used token by a
different party -- a different party would not
present the same proof bytes without stealing the
signer's key material, the token was issued to a
specific principal matched by step 4's principal
check, expiry admissibility windows for successor
principals do not overlap (<xref target="sec-proof-profile"/>
"Time-Related Bounds"), and a subsequent
successful TAKEOVER by any party advances the
current epoch past ceta_new_epoch and
disqualifies the reissue on the first predicate
above.</t>
          <t>When any predicate fails the data server returns
NFS4ERR_ACCESS or NFS4ERR_STALE_MDS_EPOCH per the
ordinary strict-ordering rule and the metadata
server <bcp14>MUST</bcp14> obtain a fresh incarnation-lease token
from the authority.  A fresh token has a new
token_id and does not collide with the replay
cache; the fresh takeover uses the ordinary
advance form.</t>
        </section>
        <section anchor="trust-anchor-provisioning">
          <name>Trust Anchor Provisioning</name>
          <t>The verification trust anchor (the public key or
key set the authority's signatures verify against)
is provisioned at each data server at deployment
time.  Key distribution mechanisms (X.509 chain,
JWK set fetch, raw public key push) are deployment
concerns outside the scope of this specification;
rotation is likewise deployment-local.  The wire
format is fully specified so that two independent
implementations sharing the same trust anchor can
interoperate; the trust-anchor bootstrap itself is
not a wire-negotiated step.</t>
        </section>
        <section anchor="time-related-bounds">
          <name>Time-Related Bounds</name>
          <t>The token's issued_at <bcp14>MUST NOT</bcp14> be more than
<tt>skew_tolerance</tt> in the future when the data server
evaluates it (deployment-configured; recommend
NTP-consistent, roughly 10 s).  The token's
expires_at is compared strictly: the token becomes
inadmissible at the first instant <tt>now &gt;=
expires_at</tt>.  No skew tolerance is added to the
right edge; the incarnation-lease authority <bcp14>MUST
NOT</bcp14> issue a successor token to a different
metadata-server principal until at least
<tt>prior.expires_at + max_ds_skew_tolerance</tt>, where
max_ds_skew_tolerance is a deployment-configured
bound that <bcp14>MUST</bcp14> equal or exceed the largest
skew_tolerance any data server in the scope is
allowed to use.  This ordering ensures that no
data server admits the prior holder at any instant
after the successor's token becomes admissible.</t>
        </section>
      </section>
      <section anchor="sec-checksum4">
        <name>checksum4</name>
        <figure anchor="fig-checksum4">
          <name>XDR for checksum4</name>
          <sourcecode type="xdr"><![CDATA[
   /// typedef uint32_t   checksum_algorithm4;
   ///
   /// const CHECKSUM_ALG_NONE      = 0;
   /// const CHECKSUM_ALG_CRC32     = 1;
   /// const CHECKSUM_ALG_CRC32C    = 2;
   /// const CHECKSUM_ALG_FLETCHER4 = 3;
   /// const CHECKSUM_ALG_SHA256    = 4;
   /// const CHECKSUM_ALG_SHA512    = 5;
   /// const CHECKSUM_ALG_BLAKE3    = 6;
   /// /* Additional values registered with IANA;
   ///    see Section "Checksum Algorithm Registry" in
   ///    the IANA Considerations. */
   ///
   /// struct checksum4 {
   ///     checksum_algorithm4   cs_algorithm;
   ///     opaque                cs_value<64>;
   /// };
]]></sourcecode>
        </figure>
        <t>The checksum4 (see <xref target="fig-checksum4"/>) is a tagged
checksum value used to detect transport corruption and
on-disk bit rot of chunk payloads.  Every chunk on the
wire and at rest carries a checksum4 alongside its
chunk_owner4.</t>
        <dl>
          <dt>cs_algorithm:</dt>
          <dd>
            <t>identifies the checksum algorithm.  The values
listed above are registered by this document; additional
values are managed by the IANA registry (see
"Checksum Algorithm Registry" in the IANA
Considerations section).  CHECKSUM_ALG_NONE indicates
the deployment relies on transport-layer (TLS, IPsec)
or storage-layer integrity instead of a protocol-level
per-chunk checksum.</t>
          </dd>
          <dt>cs_value:</dt>
          <dd>
            <t>the checksum bytes.  The length is fixed per registered
algorithm:
</t>
            <ul spacing="normal">
              <li>
                <t>CHECKSUM_ALG_NONE: 0 bytes.</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_CRC32: 4 bytes.</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_CRC32C: 4 bytes.</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_FLETCHER4: 32 bytes (four 64-bit
accumulators, matching the ZFS Fletcher4 layout).</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_SHA256: 32 bytes.</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_SHA512: 64 bytes.</t>
              </li>
              <li>
                <t>CHECKSUM_ALG_BLAKE3: 32 bytes (BLAKE3 standard
output length).</t>
              </li>
            </ul>
            <t>A checksum4 whose cs_value length does not match the
registered length for cs_algorithm <bcp14>MUST</bcp14> be rejected
with NFS4ERR_INVAL.</t>
          </dd>
          <dt>Coverage:</dt>
          <dd>
            <t>Every registered algorithm covers the same input
bytes: the chunk's header immediately followed by the
chunk payload, in wire-transmission order, with the
bytes of the header's own checksum field (<tt>cs_value</tt>)
treated as zero for the duration of the computation.
After computing, the writer stores the resulting bytes
into <tt>cs_value</tt> for transmission and at-rest storage;
the reader saves the received <tt>cs_value</tt>, treats those
bytes as zero, recomputes over the same input, and
compares against the saved value.  Including the header
in coverage protects the per-chunk metadata
(<tt>payload_id</tt>, guard, owner, length fields) as well as
the payload; treating the checksum field as zero makes
the computation independent of the field's wire value
so the same input produces the same output on both
ends.  This coverage rule applies uniformly to every
registered <tt>cs_algorithm</tt>; individual registry entries
name the function and any function-specific parameters,
but do not restate the covered-bytes rule.</t>
          </dd>
        </dl>
        <t>The checksum algorithm for a given file is selected by
the metadata server at LAYOUTGET time and carried in
the layout (see <xref target="sec-ffv2-mirror4"/>).  A client that
does not implement the algorithm a layout names returns
the layout with NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED
(<xref target="sec-NFS4ERR_LAYOUT_CHECKSUM_NOT_SUPPORTED"/>); the
metadata server may then offer a layout with a
different algorithm.</t>
      </section>
    </section>
    <section anchor="sec-new-ops">
      <name>New NFSv4.2 Operations</name>
      <figure anchor="fig-ops-xdr">
        <name>Operations XDR</name>
        <sourcecode type="xdr"><![CDATA[
   ///
   /// /* New operations for Erasure Coding start here */
   ///
   ///  OP_CHUNK_COMMIT        = 78,
   ///  OP_CHUNK_ERROR         = 79,
   ///  OP_CHUNK_FINALIZE      = 80,
   ///  OP_CHUNK_HEADER_READ   = 81,
   ///  OP_CHUNK_LOCK          = 82,
   ///  OP_CHUNK_READ          = 83,
   ///  OP_CHUNK_REPAIRED      = 84,
   ///  OP_CHUNK_ROLLBACK      = 85,
   ///  OP_CHUNK_UNLOCK        = 86,
   ///  OP_CHUNK_WRITE         = 87,
   ///  OP_CHUNK_WRITE_REPAIR  = 88,
   ///
   /// /* metadata-server-to-data-server control-plane
   ///  * operations for tight coupling
   ///  */
   ///
   ///  OP_TRUST_STATEID       = 89,
   ///  OP_REVOKE_STATEID      = 90,
   ///  OP_BULK_REVOKE_STATEID = 91,
   ///
   /// /* metadata-server-side escrow control-plane operations */
   ///
   ///  OP_CHUNK_ESCROW_INSTALL   = 92,
   ///  OP_CHUNK_ESCROW_RELEASE   = 93,
   ///  OP_CHUNK_ESCROW_ENUMERATE = 94,
   ///  OP_CHUNK_ESCROW_TAKEOVER  = 95,
   ///
]]></sourcecode>
      </figure>
      <t>The following amendment blocks extend the nfs_argop4 and
nfs_resop4 dispatch unions defined in <xref target="RFC7863"/> with arms for
each of the new operations defined in this document.  A consumer
that combines this document's extracted XDR with the RFC 7863
XDR applies these amendments at the union's extension point.</t>
      <figure anchor="fig-nfs_argop4-amend">
        <name>nfs_argop4 amendment block</name>
        <sourcecode type="xdr"><![CDATA[
   /// /* nfs_argop4 amendment block */
   ///
   /// case OP_CHUNK_COMMIT: CHUNK_COMMIT4args opchunkcommit;
   /// case OP_CHUNK_ERROR: CHUNK_ERROR4args opchunkerror;
   /// case OP_CHUNK_FINALIZE: CHUNK_FINALIZE4args opchunkfinalize;
   /// case OP_CHUNK_HEADER_READ:
   ///     CHUNK_HEADER_READ4args opchunkheaderread;
   /// case OP_CHUNK_LOCK: CHUNK_LOCK4args opchunklock;
   /// case OP_CHUNK_READ: CHUNK_READ4args opchunkread;
   /// case OP_CHUNK_REPAIRED: CHUNK_REPAIRED4args opchunkrepaired;
   /// case OP_CHUNK_ROLLBACK: CHUNK_ROLLBACK4args opchunkrollback;
   /// case OP_CHUNK_UNLOCK: CHUNK_UNLOCK4args opchunkunlock;
   /// case OP_CHUNK_WRITE: CHUNK_WRITE4args opchunkwrite;
   /// case OP_CHUNK_WRITE_REPAIR:
   ///     CHUNK_WRITE_REPAIR4args opchunkwriterepair;
   /// case OP_TRUST_STATEID: TRUST_STATEID4args optruststateid;
   /// case OP_REVOKE_STATEID: REVOKE_STATEID4args oprevokestateid;
   /// case OP_BULK_REVOKE_STATEID:
   ///     BULK_REVOKE_STATEID4args opbulkrevokestateid;
   /// case OP_CHUNK_ESCROW_INSTALL:
   ///     CHUNK_ESCROW_INSTALL4args opchunkescrowinstall;
   /// case OP_CHUNK_ESCROW_RELEASE:
   ///     CHUNK_ESCROW_RELEASE4args opchunkescrowrelease;
   /// case OP_CHUNK_ESCROW_ENUMERATE:
   ///     CHUNK_ESCROW_ENUMERATE4args opchunkescrowenumerate;
   /// case OP_CHUNK_ESCROW_TAKEOVER:
   ///     CHUNK_ESCROW_TAKEOVER4args opchunkescrowtakeover;
]]></sourcecode>
      </figure>
      <figure anchor="fig-nfs_resop4-amend">
        <name>nfs_resop4 amendment block</name>
        <sourcecode type="xdr"><![CDATA[
   /// /* nfs_resop4 amendment block */
   ///
   /// case OP_CHUNK_COMMIT: CHUNK_COMMIT4res opchunkcommit;
   /// case OP_CHUNK_ERROR: CHUNK_ERROR4res opchunkerror;
   /// case OP_CHUNK_FINALIZE: CHUNK_FINALIZE4res opchunkfinalize;
   /// case OP_CHUNK_HEADER_READ:
   ///     CHUNK_HEADER_READ4res opchunkheaderread;
   /// case OP_CHUNK_LOCK: CHUNK_LOCK4res opchunklock;
   /// case OP_CHUNK_READ: CHUNK_READ4res opchunkread;
   /// case OP_CHUNK_REPAIRED: CHUNK_REPAIRED4res opchunkrepaired;
   /// case OP_CHUNK_ROLLBACK: CHUNK_ROLLBACK4res opchunkrollback;
   /// case OP_CHUNK_UNLOCK: CHUNK_UNLOCK4res opchunkunlock;
   /// case OP_CHUNK_WRITE: CHUNK_WRITE4res opchunkwrite;
   /// case OP_CHUNK_WRITE_REPAIR:
   ///     CHUNK_WRITE_REPAIR4res opchunkwriterepair;
   /// case OP_TRUST_STATEID: TRUST_STATEID4res optruststateid;
   /// case OP_REVOKE_STATEID: REVOKE_STATEID4res oprevokestateid;
   /// case OP_BULK_REVOKE_STATEID:
   ///     BULK_REVOKE_STATEID4res opbulkrevokestateid;
   /// case OP_CHUNK_ESCROW_INSTALL:
   ///     CHUNK_ESCROW_INSTALL4res opchunkescrowinstall;
   /// case OP_CHUNK_ESCROW_RELEASE:
   ///     CHUNK_ESCROW_RELEASE4res opchunkescrowrelease;
   /// case OP_CHUNK_ESCROW_ENUMERATE:
   ///     CHUNK_ESCROW_ENUMERATE4res opchunkescrowenumerate;
   /// case OP_CHUNK_ESCROW_TAKEOVER:
   ///     CHUNK_ESCROW_TAKEOVER4res opchunkescrowtakeover;
]]></sourcecode>
      </figure>
      <t>Operations 78 through 88 (the CHUNK operations) are sent by
clients to storage devices on the data path.  Operations 89
through 91 (TRUST_STATEID, REVOKE_STATEID, BULK_REVOKE_STATEID)
and operations 92 through 95 (CHUNK_ESCROW_INSTALL,
CHUNK_ESCROW_RELEASE, CHUNK_ESCROW_ENUMERATE,
CHUNK_ESCROW_TAKEOVER) are sent by the metadata server to
storage devices on the metadata-server-to-data-server control session (see
<xref target="sec-tight-coupling-control-session"/>); they <bcp14>MUST NOT</bcp14> be sent by
pNFS clients.  The escrow control-plane operations (92 through
95) are available on the metadata-server-to-data-server control session under either
loose- or tight coupling deployment; the tight coupling section
is cited for its description of the session itself, not to
restrict availability to the tight coupling profile.</t>
      <t>All CHUNK operations <bcp14>MUST</bcp14> be issued under an active flexible
file v2 layout obtained via LAYOUTGET against the metadata
server.  Because encodings that use CHUNK operations require tight coupling (see
the three constraints in <xref target="sec-ff_device_addr4"/>), the presented
stateid is the tight coupling registered layout stateid, and the
data server <bcp14>MUST</bcp14> validate it against its per-file trust table:
a stateid not present in the trust table <bcp14>MUST</bcp14> be rejected with
NFS4ERR_BAD_STATEID per <xref target="sec-TRUST_STATEID"/>.  The anonymous
stateid is reserved for PASSTHROUGH mirrors under loose coupling
(<xref target="sec-encoding-negotiation"/>) and <bcp14>MUST NOT</bcp14> appear on a CHUNK
operation; a data server receiving a CHUNK operation with the
anonymous stateid <bcp14>MUST</bcp14> reject it with NFS4ERR_BAD_STATEID.</t>
      <t>The chunk envelope's safety properties (atomicity via
chunk_guard4 CAS, integrity via checksum, lock continuity across
revocation) depend on metadata-server coordination of layout
grants, guard generation, and lock escrow.  A client that
issues CHUNK operations without an active chunked-encoding
layout has no chunked-layout stateid to present; whatever
stateid it does send (anonymous, open, lock, forged, expired)
is rejected by the data server's normal stateid validation
per <xref section="8.2" sectionFormat="of" target="RFC8881"/>, typically with NFS4ERR_BAD_STATEID
(or NFS4ERR_STALE_STATEID or NFS4ERR_OLD_STATEID as
appropriate).  See <xref target="sec-system-model-chunk-not-block"/> for the
distinction between the CHUNK operations and a generic block I/O
interface.</t>
      <table anchor="tbl-protocol-ops">
        <name>Protocol OPs</name>
        <thead>
          <tr>
            <th align="left">Operation</th>
            <th align="left">Number</th>
            <th align="left">Target Server</th>
            <th align="left">Description</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">CHUNK_COMMIT</td>
            <td align="left">78</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_COMMIT"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ERROR</td>
            <td align="left">79</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_ERROR"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_FINALIZE</td>
            <td align="left">80</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_FINALIZE"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_HEADER_READ</td>
            <td align="left">81</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_HEADER_READ"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_LOCK</td>
            <td align="left">82</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_LOCK"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_READ</td>
            <td align="left">83</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_READ"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_REPAIRED</td>
            <td align="left">84</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_REPAIRED"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ROLLBACK</td>
            <td align="left">85</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_ROLLBACK"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_UNLOCK</td>
            <td align="left">86</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_UNLOCK"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_WRITE</td>
            <td align="left">87</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_WRITE"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_WRITE_REPAIR</td>
            <td align="left">88</td>
            <td align="left">data server (client)</td>
            <td align="left">
              <xref target="sec-CHUNK_WRITE_REPAIR"/></td>
          </tr>
          <tr>
            <td align="left">TRUST_STATEID</td>
            <td align="left">89</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-TRUST_STATEID"/></td>
          </tr>
          <tr>
            <td align="left">REVOKE_STATEID</td>
            <td align="left">90</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-REVOKE_STATEID"/></td>
          </tr>
          <tr>
            <td align="left">BULK_REVOKE_STATEID</td>
            <td align="left">91</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-BULK_REVOKE_STATEID"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ESCROW_INSTALL</td>
            <td align="left">92</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-CHUNK_ESCROW_INSTALL"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ESCROW_RELEASE</td>
            <td align="left">93</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-CHUNK_ESCROW_RELEASE"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ESCROW_ENUMERATE</td>
            <td align="left">94</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-CHUNK_ESCROW_ENUMERATE"/></td>
          </tr>
          <tr>
            <td align="left">CHUNK_ESCROW_TAKEOVER</td>
            <td align="left">95</td>
            <td align="left">data server (metadata server control)</td>
            <td align="left">
              <xref target="sec-CHUNK_ESCROW_TAKEOVER"/></td>
          </tr>
        </tbody>
      </table>
      <section anchor="sec-chunk-op-bounds">
        <name>Bounds on Chunk-Operation Arrays</name>
        <t>The chunk-lifecycle operations (CHUNK_WRITE, CHUNK_WRITE_REPAIR,
CHUNK_READ, CHUNK_FINALIZE, CHUNK_COMMIT, CHUNK_ROLLBACK,
CHUNK_LOCK, CHUNK_UNLOCK, CHUNK_ERROR, CHUNK_REPAIRED,
CHUNK_HEADER_READ) carry variable-length arrays of chunks,
owners, status codes, checksums, and payloads.  To bound
allocation and to guarantee that a valid request always has an
encodable response, this document defines the following
protocol maxima:</t>
        <figure anchor="fig-chunk-op-bounds">
          <name>Chunk-operation array maxima</name>
          <sourcecode type="xdr"><![CDATA[
   ///
   /// const CHUNK_MAX_CHUNKS_PER_OP     = 4096;
   /// const CHUNK_MAX_PAYLOAD_BYTES     = 4194304;
   /// const CHUNK_MAX_CHECKSUMS_PER_OP  = 4096;
   /// const CHUNK_MAX_OWNERS_PER_OP     = 4096;
   /// const CHUNK_MAX_STATUS_PER_OP     = 4096;
   ///
]]></sourcecode>
        </figure>
        <t><tt>CHUNK_MAX_CHUNKS_PER_OP</tt> is the maximum number of chunks
addressed by a single CHUNK_WRITE, CHUNK_WRITE_REPAIR,
CHUNK_READ, CHUNK_FINALIZE, CHUNK_COMMIT, CHUNK_ROLLBACK, or
CHUNK_LOCK request; it bounds cwa_co_ids, cra_ranges, cca_chunks,
cfa_chunks, cra_chunks (CHUNK_ROLLBACK), and the equivalent
arrays in the other operations.  <tt>CHUNK_MAX_PAYLOAD_BYTES</tt>
bounds the aggregate opaque payload (cwa_chunks, cwra_chunks,
and the concatenated cr_chunk bytes returned in
CHUNK_READ4resok).  <tt>CHUNK_MAX_CHECKSUMS_PER_OP</tt>,
<tt>CHUNK_MAX_OWNERS_PER_OP</tt>, and <tt>CHUNK_MAX_STATUS_PER_OP</tt> bound
the co-indexed result and argument arrays with matching
cardinality; each <bcp14>MUST</bcp14> equal the request's chunk count on
success, and <bcp14>MUST</bcp14> be present with the requested cardinality on
failures for positional correlation.</t>
        <t>A data server <bcp14>MUST</bcp14> reject a request whose array length exceeds
any of these maxima with NFS4ERR_INVAL before performing any
mutation.  A data server <bcp14>MUST</bcp14> also verify, before performing
any mutation, that the response it will construct fits within
the session's negotiated <tt>ca_maxresponsesize</tt> (<xref section="18.36" sectionFormat="of" target="RFC8881"/>); if the mandatory response arrays (per-chunk status,
per-chunk owner, per-chunk checksum, and payload where applicable)
would exceed <tt>ca_maxresponsesize</tt>, the data server <bcp14>MUST</bcp14> reject with
NFS4ERR_TOOSMALL and <bcp14>MUST NOT</bcp14> partially process the request.  The
client is expected to split the request across multiple compounds when
either bound is reached.</t>
        <t>Short processing (a data server returning fewer chunks than
requested at its discretion) is NOT permitted for the
lifecycle operations because the co-indexed result arrays would
lose positional correlation.  A data server that cannot process
all requested chunks <bcp14>MUST</bcp14> reject the entire request rather than
partially serve it.  The rejection uses one of the errors
already defined for the two capacity-limit paths above --
NFS4ERR_INVAL when the request array length exceeds a
CHUNK_MAX_* bound, NFS4ERR_TOOSMALL when the response would
exceed the session-negotiated ca_maxresponsesize
(<xref section="18.36" sectionFormat="of" target="RFC8881"/>), or NFS4ERR_DELAY when the data
server is out of transient resources to process the requested
batch -- and the entire request is a no-op with respect to
mutation.</t>
        <t>On receiving any of these rejections, a client that wishes to
retry <bcp14>SHOULD</bcp14> halve the batch size and retry, subject to the
static maxima in <xref target="fig-chunk-op-bounds"/> and the session's
ca_maxresponsesize.  A client that has already reduced the
batch to a single chunk and continues to see the rejection
<bcp14>MUST</bcp14> escalate via LAYOUTERROR rather than retry unbounded.</t>
      </section>
      <section anchor="sec-CHUNK_COMMIT">
        <name>Operation 78: CHUNK_COMMIT - Activate Cached Chunk Data</name>
        <section anchor="arguments">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_COMMIT4args">
            <name>XDR for CHUNK_COMMIT4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_COMMIT4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cca_stateid;
   ///     offset4         cca_offset;
   ///     count4          cca_count;
   ///     chunk_owner4    cca_chunks<>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_COMMIT4resok">
            <name>XDR for CHUNK_COMMIT4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_COMMIT4resok {
   ///     verifier4       ccr_writeverf;
   ///     nfsstat4        ccr_status<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_COMMIT4res">
            <name>XDR for CHUNK_COMMIT4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_COMMIT4res switch (nfsstat4 ccr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_COMMIT4resok   ccr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description">
          <name>DESCRIPTION</name>
          <t>The CHUNK_COMMIT operation is based upon the NFSv4.1 COMMIT
operation (see <xref section="18.3" sectionFormat="of" target="RFC8881"/>) and similarly
commits previously written data to stable storage on the
regular file identified by the current filehandle, with the
difference that CHUNK_COMMIT operates on the chunk
coordinate system used by Flexible File Version 2 layouts
rather than on the byte coordinate system, and that
CHUNK_COMMIT advances each named chunk through the chunk
state machine from FINALIZED to COMMITTED
(<xref target="fig-chunk-state-machine"/>) rather than acting on a byte
range without a state-machine context.</t>
          <t>The client provides cca_offset and cca_count to bound the
chunk range, and cca_chunks to name the specific
(chunk_owner4) generations within that range to commit:</t>
          <dl>
            <dt>cca_offset:</dt>
            <dd>
              <t>starting chunk index in the file (not a byte offset).</t>
            </dd>
            <dt>cca_count:</dt>
            <dd>
              <t>number of chunks the range covers, starting at
cca_offset.  When cca_count is zero, the client <bcp14>MUST</bcp14>
also supply an empty cca_chunks array, and the data
server returns NFS4_OK with an empty ccr_status array.
A cca_offset beyond the data server's highest chunk
with a non-zero cca_count is not itself an error at the
operation level: the data server evaluates each
cca_chunks entry per its normal per-entry rules and
returns the co-indexed ccr_status.</t>
            </dd>
            <dt>cca_chunks:</dt>
            <dd>
              <t>an array of chunk_owner4 entries
(<xref target="fig-chunk_owner4"/>) naming the specific generations to
commit.  For each entry the data server looks up the
chunk index it associated with the complete
owner triple when the
client wrote it via CHUNK_WRITE or
CHUNK_WRITE_REPAIR.  That recorded chunk index <bcp14>MUST</bcp14>
lie in [cca_offset, cca_offset + cca_count); if the
triple does not match any recorded owner association
on this data server for this file, or the recorded
chunk index lies outside the requested range, the
entry is rejected with NFS4ERR_INVAL in the
corresponding ccr_status slot.  The reserved sentinels
CHUNK_GUARD_CLIENT_ID_NONE and CHUNK_GUARD_CLIENT_ID_MDS
<bcp14>MUST NOT</bcp14> appear as the co_client_id of any cca_chunks
entry; see <xref target="sec-chunk_guard_none"/> and
<xref target="sec-chunk_guard_mds"/>.</t>
            </dd>
          </dl>
          <t>cca_offset and cca_count are NOT redundant with
cca_chunks: the owner triples in cca_chunks name specific
generations (which the data server correlates via its
recorded owner-to-index association), while cca_offset
and cca_count bound the intended chunk-index scope of the
operation.  A chunk index <bcp14>MAY</bcp14> have multiple persisted
generations at the moment CHUNK_COMMIT arrives -- an
older COMMITTED generation retained for the rollback
invariant (<xref target="sec-system-model-consistency"/>) alongside a
newer FINALIZED successor.  cca_chunks selects which
owner triple to advance to
COMMITTED at each affected index; cca_offset and
cca_count let the data server reject malformed requests
that name generations whose recorded chunk index lies
outside the intended commit window.</t>
          <t>The CHUNK_COMMIT result reports the outcome per chunk in
the same order as cca_chunks:</t>
          <dl>
            <dt>ccr_writeverf:</dt>
            <dd>
              <t>a verifier identifying the data server's incarnation
at the time the commit completed.  A client compares
ccr_writeverf to the cwr_writeverf returned by the
prior CHUNK_WRITE to detect a
data server restart that lost UNSTABLE4 writes
between the write and the commit; on a mismatch the
client <bcp14>MUST</bcp14> re-issue the CHUNK_WRITE before any
committed bytes are considered durable.
ccr_writeverf changes on every data server restart
that loses uncommitted state.</t>
            </dd>
            <dt>ccr_status:</dt>
            <dd>
              <t>per-chunk commit status, one entry per cca_chunks
entry, co-indexed.  NFS4_OK indicates that the named
chunk is COMMITTED on return.  Other per-entry
failure codes are described in
"Interaction with CHUNK_FINALIZE" and "Interaction
with a Locked Chunk" below.  The top-level
CHUNK_COMMIT status is NFS4_OK as long as the data
server could evaluate each cca_chunks entry;
per-chunk failures are reported in ccr_status rather
than by failing the whole operation.  The top-level
status returns a non-OK code only when the request
could not be evaluated at all.</t>
            </dd>
          </dl>
          <t>Like CHUNK_READ and CHUNK_WRITE, CHUNK_COMMIT carries an explicit
layout stateid in cca_stateid.  The data server authorizes
CHUNK_COMMIT by validating cca_stateid against the file
identified by the current filehandle: cca_stateid <bcp14>MUST</bcp14> be
the layout stateid the metadata server issued to the
caller for the current filehandle, or the special anonymous
stateid (see below).  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), the data server rejects
CHUNK_COMMIT with NFS4ERR_BAD_STATEID unless cca_stateid
is present in the data server's trust table for the
current filehandle.  The explicit field ensures that a
CHUNK_COMMIT in its own standalone compound (typical for
recovery and pipelined lifecycle operations) carries the
authorization the data server needs without depending on
any prior operation's implicit state.  Passing the special
anonymous stateid is permitted only when the underlying
security regime authorizes an unattributed writer (that is,
when tight coupling is not in force and the deployment's
access-control policy permits it).</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          <section anchor="interaction-with-chunkfinalize">
            <name>Interaction with CHUNK_FINALIZE</name>
            <t>CHUNK_COMMIT transitions a chunk from FINALIZED to COMMITTED
(see <xref target="sec-system-model-chunk-state"/>).  A chunk <bcp14>MUST</bcp14> have
previously been transitioned from PENDING to FINALIZED via
CHUNK_FINALIZE before CHUNK_COMMIT is accepted:</t>
            <ul spacing="normal">
              <li>
                <t>If the target chunk is PENDING (i.e., the writer never
issued CHUNK_FINALIZE), the data server <bcp14>MUST</bcp14> reject the
CHUNK_COMMIT entry for that chunk with
NFS4ERR_PAYLOAD_NOT_ATOMIC in the corresponding
ccr_status slot.  The writer is expected to either issue
CHUNK_FINALIZE to advance the state or CHUNK_ROLLBACK to
abandon the PENDING generation.</t>
              </li>
              <li>
                <t>If the target chunk is EMPTY (no generation to commit), the
data server <bcp14>MUST</bcp14> reject with NFS4ERR_PAYLOAD_NOT_ATOMIC
for that chunk.</t>
              </li>
            </ul>
            <t>The two rejection cases above share the error code because
the client's local bookkeeping distinguishes them without
requiring the data server to differentiate.  A client with
intact local state that recognizes it holds a PENDING
generation for the chunk calls CHUNK_FINALIZE; a client with
no local record calls CHUNK_HEADER_READ to inspect the
chunk's actual state (owner triple, disposition) and
reconcile from there.</t>
            <ul spacing="normal">
              <li>
                <t>If the target chunk is already COMMITTED at the generation
identified by the cca_chunks entry's owner triple, the
CHUNK_COMMIT is idempotent and <bcp14>MUST</bcp14> succeed.  Idempotence
preserves the NFSv4 COMMIT contract for duplicate-request
retransmission.</t>
              </li>
              <li>
                <t>If the target chunk is FINALIZED at a different generation
than the one named in the cca_chunks entry, the data server
<bcp14>MUST</bcp14> reject with NFS4ERR_CHUNK_GUARDED.  A client that sees
this has lost a race and <bcp14>SHOULD</bcp14> re-read the chunk (see
<xref target="sec-chunk_guard4"/>).</t>
              </li>
            </ul>
          </section>
          <section anchor="pipelining-considerations">
            <name>Pipelining Considerations</name>
            <t>The three-step CHUNK_WRITE -&gt; CHUNK_FINALIZE -&gt; CHUNK_COMMIT
sequence <bcp14>MAY</bcp14> be pipelined within a single NFSv4.2 compound
(see <xref section="12.8" sectionFormat="of" target="RFC8881"/>) in single writer mode, where
no other writer can race the client's per-chunk transitions
and the CHUNK_WRITE per-block status array reports only
local-failure cases (NFS4ERR_NOSPC, NFS4ERR_IO, and so on).</t>
            <t>Same-compound pipelining is <bcp14>NOT RECOMMENDED</bcp14> in multiple-writer
mode.  CHUNK_WRITE reports per-block outcomes in cwr_block_status
(<xref target="sec-CHUNK_WRITE"/>); a partial-success outcome (some chunks
accepted, others rejected with NFS4ERR_CHUNK_GUARDED on a lost
race) leaves the client without an opportunity to react before
a same-compound CHUNK_FINALIZE / CHUNK_COMMIT proceeds against
whichever chunks happen to be PENDING.  The compound-level
status is NFS4_OK in this case because per-block failures are
reported in the per-op status array rather than as a compound-level
error, so NFSv4 compound short-circuit (<xref section="2.10.6.4" sectionFormat="of" target="RFC8881"/>) does not stop the trailing ops.  A client that wants
atomic-or-none semantics across multiple chunks <bcp14>MUST</bcp14> examine the
per-block status returned by each CHUNK_WRITE before issuing the
corresponding CHUNK_FINALIZE.</t>
            <t>For multi-chunk pipelines in multiple-writer mode, the
recommended pattern is to stagger the three steps across
compounds so each trailing operation acts only on chunks whose
preceding operation's status the client has already inspected:</t>
            <figure anchor="fig-staggered-chunk-pipeline">
              <name>Staggered three-stage chunk pipeline (multiple-writer mode)</name>
              <artwork><![CDATA[
Compound A:  SEQUENCE PUTFH CHUNK_WRITE(a)
Compound B:  SEQUENCE PUTFH CHUNK_WRITE(b) CHUNK_FINALIZE(a)
Compound C:  SEQUENCE PUTFH CHUNK_WRITE(c) CHUNK_FINALIZE(b)
                              CHUNK_COMMIT(a)
Compound D:  SEQUENCE PUTFH CHUNK_WRITE(d) CHUNK_FINALIZE(c)
                              CHUNK_COMMIT(b)
...
]]></artwork>
            </figure>
            <t>In each compound, the CHUNK_WRITE acts on the trailing chunk
the client wants to enqueue next; the CHUNK_FINALIZE operates
on a chunk whose CHUNK_WRITE the client has already inspected
in a previous compound; the CHUNK_COMMIT operates on a chunk
whose CHUNK_FINALIZE the client has already inspected.  If
any per-block status in compound N reports a guard loss or
other failure, the client abandons the affected chunk (via
CHUNK_ROLLBACK in compound N + 1 or later) without ever issuing
the trailing FINALIZE / COMMIT for it.</t>
            <t>This pattern adds two compounds of latency between a chunk's
write and its commit (one for the FINALIZE wait, one for the
COMMIT wait), but provides the client with the per-step
inspection point required for atomic-or-none multi-chunk
writes under contention.</t>
          </section>
          <section anchor="interaction-with-a-locked-chunk">
            <name>Interaction with a Locked Chunk</name>
            <t>When a chunk is locked via CHUNK_LOCK (see <xref target="sec-CHUNK_LOCK"/>),
CHUNK_COMMIT is permitted only when the submitter owns the
lock -- that is, when the stateid carried on the compound
matches the lock holder's stateid (or is an
CHUNK_LOCK_FLAGS_ADOPT-transferred continuation):</t>
            <ul spacing="normal">
              <li>
                <t>The owning writer <bcp14>MAY</bcp14> issue CHUNK_COMMIT; the chunk
transitions from FINALIZED to COMMITTED normally.</t>
              </li>
              <li>
                <t>A non-owning client <bcp14>MUST</bcp14> receive NFS4ERR_CHUNK_LOCKED in
the corresponding ccr_status slot.  The chunk's state is
not changed.</t>
              </li>
              <li>
                <t>During repair, the metadata-server escrow owner
(CHUNK_GUARD_CLIENT_ID_MDS, see <xref target="sec-chunk_guard_mds"/>)
holds the lock while the repair actor adopts it via
CHUNK_LOCK_FLAGS_ADOPT.  CHUNK_COMMIT during the escrow
window is permitted only to the holder of the adopted
lock.</t>
              </li>
            </ul>
            <t>This rule is what <xref target="sec-system-model-consistency"/> calls
"lock continuity across revocation": the COMMIT privilege
follows the lock without gaps in which a non-owner could race.</t>
          </section>
        </section>
        <section anchor="response-codes">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>every named chunk transitioned to COMMITTED.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to commit on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>arguments named chunks outside the file's mirror
set or in a non-atomic state.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while persisting the commit.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement CHUNK_COMMIT.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ERROR">
        <name>Operation 79: CHUNK_ERROR - Report Error on Cached Chunk Data</name>
        <section anchor="arguments-1">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ERROR4args">
            <name>XDR for CHUNK_ERROR4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ERROR4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cea_stateid;
   ///     offset4         cea_offset;
   ///     count4          cea_count;
   ///     nfsstat4        cea_error;
   ///     chunk_owner4    cea_owner;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-1">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ERROR4res">
            <name>XDR for CHUNK_ERROR4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ERROR4res {
   ///     nfsstat4        cer_status;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-1">
          <name>DESCRIPTION</name>
          <t>CHUNK_ERROR allows a client that has detected corruption or
inconsistency in a chunk to report the condition to the data
server, so that the data server can mark the affected chunks
as errored.  Errored chunks are excluded from subsequent
CHUNK_READ responses until they are repaired via
CHUNK_WRITE_REPAIR and the
repair is confirmed via CHUNK_REPAIRED.</t>
          <t>CHUNK_ERROR has no direct analog in <xref target="RFC8881"/>.  The closest
parallel is LAYOUTERROR (<xref section="15.6" sectionFormat="of" target="RFC7862"/>), which
reports layout-level errors to the metadata server.
CHUNK_ERROR is the data-path counterpart: it reports a
chunk-level integrity finding directly to the data server so
that the corrupted chunks are quarantined before the
metadata server has had time to coordinate repair.  A client
<bcp14>SHOULD</bcp14> issue CHUNK_ERROR to the data server holding the bad
chunks before issuing LAYOUTERROR to the metadata server.</t>
          <t>The client provides:</t>
          <dl>
            <dt>cea_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted for
this file.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>cea_offset:</dt>
            <dd>
              <t>starting chunk index of the affected range (not a byte
offset).</t>
            </dd>
            <dt>cea_count:</dt>
            <dd>
              <t>number of chunks the affected range covers, starting at
cea_offset.</t>
            </dd>
            <dt>cea_error:</dt>
            <dd>
              <t>the nfsstat4 error code that describes the integrity
finding.  Typical values include
NFS4ERR_PAYLOAD_NOT_ATOMIC (the chunk's persisted checksum
or guard did not match the value the client expected),
NFS4ERR_IO (the client's CHUNK_READ returned an I/O
error from this data server), and NFS4ERR_INVAL (the
chunk's chunk_owner4 did not match the expected
generation across mirrors).  The data server <bcp14>MAY</bcp14> record
the supplied error code in operator logs but does not
otherwise interpret it; the chunk-level effect (mark
errored) is the same for any cea_error value.</t>
            </dd>
            <dt>cea_owner:</dt>
            <dd>
              <t>the chunk_owner4 (<xref target="fig-chunk_owner4"/>) the client read
when it observed the error, so the data server can
record which owner triple generation was
reported as corrupted.  The reserved sentinels
CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear in
cea_owner; see <xref target="sec-chunk_guard_none"/> and
<xref target="sec-chunk_guard_mds"/>.</t>
            </dd>
          </dl>
          <t>CHUNK_ERROR returns a single top-level status in cer_status;
there is no per-chunk status array because the data server
either accepts the report for the whole range or returns a
top-level error.  Once a CHUNK_ERROR has been accepted, the
affected chunks transition into the errored state described
in <xref target="sec-system-model-chunk-state"/>; subsequent CHUNK_READ
operations against those chunks return
NFS4ERR_PAYLOAD_NOT_ATOMIC in the per-chunk cr_status slot
until a successful CHUNK_REPAIRED sequence clears the
errored flag.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-1">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the client's chunk error report has been recorded.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to report errors on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>the reported chunk range or error code was not
recognized.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement CHUNK_ERROR.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_FINALIZE">
        <name>Operation 80: CHUNK_FINALIZE - Transition Chunks from Pending to Finalized</name>
        <section anchor="arguments-2">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_FINALIZE4args">
            <name>XDR for CHUNK_FINALIZE4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_FINALIZE4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cfa_stateid;
   ///     offset4         cfa_offset;
   ///     count4          cfa_count;
   ///     chunk_owner4    cfa_chunks<>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-2">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_FINALIZE4resok">
            <name>XDR for CHUNK_FINALIZE4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_FINALIZE4resok {
   ///     verifier4       cfr_writeverf;
   ///     nfsstat4        cfr_status<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_FINALIZE4res">
            <name>XDR for CHUNK_FINALIZE4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_FINALIZE4res switch (nfsstat4 cfr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_FINALIZE4resok   cfr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-2">
          <name>DESCRIPTION</name>
          <t>CHUNK_FINALIZE transitions chunks from the PENDING state (set
by CHUNK_WRITE, see <xref target="sec-CHUNK_WRITE"/>) to the FINALIZED
state in the chunk state machine (<xref target="fig-chunk-state-machine"/>).
A FINALIZED chunk is visible on the owning stateid for reads
(<xref target="sec-system-model-consistency"/>) and is eligible for
CHUNK_COMMIT; the FINALIZED transition
is the writer's signal that it will issue no further
CHUNK_WRITEs for the named owner triple
generation of each chunk.</t>
          <t>CHUNK_FINALIZE has no direct analog in <xref target="RFC8881"/>: the COMMIT
operation in <xref section="18.3" sectionFormat="of" target="RFC8881"/> combines the "no more
writes" signal and the "make durable and globally visible"
step into one operation; the Flexible File Version 2 chunk
lifecycle separates them so a writer in multiple-writer mode
can validate the per-chunk acceptance status reported by
CHUNK_WRITE before committing any chunk to durable storage
(see "Pipelining Considerations" in
<xref target="sec-CHUNK_COMMIT"/>).</t>
          <t>The client provides cfa_offset and cfa_count to bound the
chunk range, and cfa_chunks to name the specific
(chunk_owner4) generations within that range to finalize:</t>
          <dl>
            <dt>cfa_offset:</dt>
            <dd>
              <t>starting chunk index in the file (not a byte offset).</t>
            </dd>
            <dt>cfa_count:</dt>
            <dd>
              <t>number of chunks the range covers, starting at
cfa_offset.  When cfa_count is zero, the client <bcp14>MUST</bcp14>
also supply an empty cfa_chunks array, and the data
server returns NFS4_OK with an empty cfr_status array.
A cfa_offset beyond the data server's highest chunk
with a non-zero cfa_count is not itself an error at the
operation level: the data server evaluates each
cfa_chunks entry per its normal per-entry rules and
returns the co-indexed cfr_status.</t>
            </dd>
            <dt>cfa_chunks:</dt>
            <dd>
              <t>an array of chunk_owner4 entries
(<xref target="fig-chunk_owner4"/>) naming the specific generations to
finalize.  For each entry the data server looks up
the chunk index it associated with the complete
owner triple when the
client wrote it via CHUNK_WRITE or
CHUNK_WRITE_REPAIR.  That recorded chunk index <bcp14>MUST</bcp14>
lie in [cfa_offset, cfa_offset + cfa_count); if the
triple does not match any recorded owner association
on this data server for this file, or the recorded
chunk index lies outside the requested range, the
entry is rejected with NFS4ERR_INVAL in the
corresponding cfr_status slot.  The reserved sentinels
CHUNK_GUARD_CLIENT_ID_NONE and CHUNK_GUARD_CLIENT_ID_MDS
<bcp14>MUST NOT</bcp14> appear as the co_client_id of any cfa_chunks
entry; see <xref target="sec-chunk_guard_none"/> and
<xref target="sec-chunk_guard_mds"/>.</t>
            </dd>
          </dl>
          <t>The CHUNK_FINALIZE result reports the outcome per chunk in
the same order as cfa_chunks:</t>
          <dl>
            <dt>cfr_writeverf:</dt>
            <dd>
              <t>a verifier identifying the data server's incarnation
at the time the finalization completed.  Semantics
match cwr_writeverf in CHUNK_WRITE: a client that observes a
different writeverf on a subsequent CHUNK_COMMIT <bcp14>MUST</bcp14>
re-issue the CHUNK_WRITE before treating any of the
finalized chunks as durable.</t>
            </dd>
            <dt>cfr_status:</dt>
            <dd>
              <t>per-chunk finalization status, one entry per
cfa_chunks entry, co-indexed.  NFS4_OK indicates that
the named chunk is FINALIZED on return.  Other
per-entry failure cases:
</t>
              <ul spacing="normal">
                <li>
                  <t>NFS4ERR_INVAL -- the named generation is not in the
PENDING state at its recorded chunk index (the
chunk is EMPTY, FINALIZED at a different generation,
or COMMITTED), or the triple does not match any
recorded owner association, or the recorded chunk
index lies outside [cfa_offset, cfa_offset +
cfa_count).</t>
                </li>
                <li>
                  <t>NFS4ERR_CHUNK_GUARDED -- the chunk is PENDING but
the current PENDING owner is a different
(co_cohort_id, co_client_id) than the one named in
the cfa_chunks entry.  A client that sees this has
lost a race with another writer; see
<xref target="sec-chunk_guard4"/>.</t>
                </li>
                <li>
                  <t>NFS4ERR_CHUNK_LOCKED -- the chunk is locked by a
CHUNK_LOCK held by a different
stateid; the finalize is rejected.</t>
                </li>
              </ul>
              <t>The top-level CHUNK_FINALIZE status is NFS4_OK as long
as the data server could evaluate each cfa_chunks
entry; per-chunk failures are reported in cfr_status
rather than by failing the whole operation.  The
top-level status returns a non-OK code only when the
request could not be evaluated at all.</t>
            </dd>
          </dl>
          <t>CHUNK_FINALIZE serves as the CRC validation checkpoint for
the chunk lifecycle.  The data server <bcp14>SHOULD</bcp14> have validated
each chunk's checksum against the value supplied in cwa_checksums
at CHUNK_WRITE time; the FINALIZE transition persists the
chunk metadata (CRC, owner, state) to stable storage so it
survives a data server restart.  An implementation <bcp14>MAY</bcp14>
defer some metadata persistence to CHUNK_COMMIT instead of
CHUNK_FINALIZE; in that case the FINALIZED state is
recovered by replay of the data server's local journal on
restart.</t>
          <t>A chunk that has been FINALIZED but not yet COMMITTED <bcp14>MAY</bcp14>
be rolled back via CHUNK_ROLLBACK,
which returns the chunk to the EMPTY state (or to the
prior COMMITTED generation, if one exists).</t>
          <t>Like CHUNK_COMMIT, CHUNK_FINALIZE
carries an explicit layout stateid in cfa_stateid.  The
data server authorizes CHUNK_FINALIZE by validating
cfa_stateid against the file identified by the current
filehandle: cfa_stateid <bcp14>MUST</bcp14> be the layout stateid the
metadata server issued to the caller for the current
filehandle, or the special anonymous stateid (see below).
Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), the data server rejects
CHUNK_FINALIZE with NFS4ERR_BAD_STATEID unless
cfa_stateid is present in the data server's trust table
for the current filehandle.  The explicit field ensures
that a CHUNK_FINALIZE in its own standalone compound
(typical for pipelined and recovery cases) carries the
authorization the data server needs.  Passing the
special anonymous stateid is permitted only when the
underlying security regime authorizes an unattributed
writer.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-2">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>every named chunk transitioned from PENDING to
FINALIZED.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to finalize on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>arguments named chunks not in PENDING or outside
the file's mirror set.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while persisting the
transition.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_FINALIZE.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_HEADER_READ">
        <name>Operation 81: CHUNK_HEADER_READ - Read Chunk Header from File</name>
        <section anchor="arguments-3">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_HEADER_READ4args">
            <name>XDR for CHUNK_HEADER_READ4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_HEADER_READ4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4    chra_stateid;
   ///     offset4     chra_offset;
   ///     count4      chra_count;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-3">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_HEADER_READ4resok">
            <name>XDR for CHUNK_HEADER_READ4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// /* Upper bound on both chra_count and each of the
   ///  * four co-indexed response arrays.  Bounds argument
   ///  * range width and response-array width together so
   ///  * that a caller cannot request an unbounded scan
   ///  * and a data server cannot construct an unbounded
   ///  * response.
   ///  */
   /// const CHUNK_HEADER_READ_MAX4 = 1024;
   ///
   /// struct retained_predecessor4 {
   ///     chunk_owner4  rp_owner;
   /// };
   ///
   /// enum retained_generation_disposition4 {
   ///     RETAINED_GENERATION_DISPOSITION_ABSENT   = 0,
   ///     RETAINED_GENERATION_DISPOSITION_PRESENT  = 1,
   ///     RETAINED_GENERATION_DISPOSITION_ERRORED  = 2
   /// };
   ///
   /// union optional_retained4
   ///     switch (retained_generation_disposition4
   ///             disposition) {
   /// case RETAINED_GENERATION_DISPOSITION_ABSENT:
   ///     void;
   /// case RETAINED_GENERATION_DISPOSITION_PRESENT:
   ///     retained_predecessor4  restorable;
   /// case RETAINED_GENERATION_DISPOSITION_ERRORED:
   ///     retained_predecessor4  errored;
   /// };
   ///
   /// struct CHUNK_HEADER_READ4resok {
   ///     bool                chrr_eof;
   ///     nfsstat4
   ///         chrr_status<CHUNK_HEADER_READ_MAX4>;
   ///     chunk_state_flags4
   ///         chrr_locked<CHUNK_HEADER_READ_MAX4>;
   ///     chunk_owner4
   ///         chrr_owners<CHUNK_HEADER_READ_MAX4>;
   ///     chunk_guard4
   ///         chrr_guards<CHUNK_HEADER_READ_MAX4>;
   ///     optional_retained4
   ///         chrr_predecessors<CHUNK_HEADER_READ_MAX4>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_HEADER_READ4res">
            <name>XDR for CHUNK_HEADER_READ4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_HEADER_READ4res switch (nfsstat4 chrr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_HEADER_READ4resok     chrr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-3">
          <name>DESCRIPTION</name>
          <t>CHUNK_HEADER_READ returns the per-chunk metadata
(chunk_owner4, chunk_guard4, lock state, and per-chunk
status) for a range of chunks in the target data file
without returning the chunk payloads.  The operation enables clients and
repair coordinators to inspect chunk lifecycle and
ownership cheaply, without the data-transfer cost of
CHUNK_READ.  CHUNK_HEADER_READ has
no direct analog in <xref target="RFC8881"/>; it is the chunk-protocol
counterpart of a stat-like fast probe and exists because
chunks are first-class state-bearing objects whose
ownership, lock state, and lifecycle status are not
recoverable from a byte-offset query.</t>
          <t>The client provides:</t>
          <dl>
            <dt>chra_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted for
this file.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>chra_offset:</dt>
            <dd>
              <t>starting chunk index of the range to inspect (not a
byte offset).</t>
            </dd>
            <dt>chra_count:</dt>
            <dd>
              <t>number of chunks the inspection range covers,
starting at chra_offset.  chra_count <bcp14>MUST NOT</bcp14>
exceed CHUNK_HEADER_READ_MAX4; a request that
exceeds the bound is rejected with NFS4ERR_INVAL.
The bound protects the data server against
arbitrarily large response construction.</t>
            </dd>
          </dl>
          <t>The CHUNK_HEADER_READ result returns five co-indexed
arrays, one entry per chunk in the requested range in
chunk-offset order from chra_offset:</t>
          <dl>
            <dt>chrr_eof:</dt>
            <dd>
              <t>TRUE if the requested range extended at or past the
data server's last chunk for this file.  Same
per-data-server semantics as crr_eof in CHUNK_READ.</t>
            </dd>
            <dt>chrr_status:</dt>
            <dd>
              <t>per-chunk lifecycle state encoded as an nfsstat4
(see "Per-Chunk Status Encoding" below).</t>
            </dd>
            <dt>chrr_locked:</dt>
            <dd>
              <t>per-chunk chunk_state_flags4
(<xref target="sec-chunk_state_flags4"/>).  CHUNK_STATE_FLAGS_LOCKED
set indicates the chunk currently has a CHUNK_LOCK held
by some chunk_owner4.  Lock state is reported
orthogonally to chrr_status so that a locked chunk
still surfaces its lifecycle state and chunk_owner4 to
the inspector.</t>
            </dd>
            <dt>chrr_owners:</dt>
            <dd>
              <t>per-chunk chunk_owner4 (<xref target="fig-chunk_owner4"/>).  For a
chunk whose chrr_status is NFS4_OK the field is the
COMMITTED generation's owner.  For
NFS4ERR_PAYLOAD_NOT_ATOMIC the field is the writer of
the in-progress (PENDING or FINALIZED) generation.
For NFS4ERR_NOENT (EMPTY chunk) the chunk_owner4 is
unspecified.</t>
            </dd>
            <dt>chrr_guards:</dt>
            <dd>
              <t>per-chunk chunk_guard4 (<xref target="fig-chunk_guard4"/>) -- the
(cg_gen_id, cg_client_id) pair the data server holds
as the chunk's current guard at CHUNK_HEADER_READ
time.  A caller that intends to update the chunk in
multiple writer mode uses the corresponding chrr_guards
entry as the expected prior value for the guard CAS
(<xref target="sec-multi-writer"/>), avoiding the payload cost of
CHUNK_READ.  For a chunk whose chrr_status is
NFS4ERR_NOENT (EMPTY) the chunk_guard4 is the
all-zeros pair (cg_gen_id = 0 and cg_client_id =
CHUNK_GUARD_CLIENT_ID_NONE, see
<xref target="sec-chunk_guard_none"/>).  chrr_guards is a read-time
observation; a concurrent writer <bcp14>MAY</bcp14> advance the
guard between the CHUNK_HEADER_READ response and the
subsequent CHUNK_WRITE, in which case the CAS returns
NFS4ERR_CHUNK_GUARDED and the caller re-observes the
guard per the rollback-and-retry flow in
<xref target="sec-chunk_guard4"/>.</t>
            </dd>
            <dt>chrr_predecessors:</dt>
            <dd>
              <t>per-chunk immediate-predecessor disposition, one
optional_retained4 entry per chunk in the returned
range, co-indexed with chrr_status, chrr_locked, and
chrr_owners.  Each entry names the read-time state
of the single most recent retained predecessor of
the current generation the data server holds for
that chunk index under the retention scope rule
(<xref target="sec-system-model-retention-scope"/>); the entry's
discriminant is exactly one of:
</t>
              <dl>
                <dt>RETAINED_GENERATION_DISPOSITION_ABSENT:</dt>
                <dd>
                  <t>the data server holds no retained predecessor at that
index (either the current chrr_owners generation is the
only one, or the chunk is EMPTY).  The arm carries no
owner triple.</t>
                </dd>
                <dt>RETAINED_GENERATION_DISPOSITION_PRESENT:</dt>
                <dd>
                  <t>the data server retains an immediate predecessor whose
owner triple is carried in the restorable arm and whose
payload is in the AVAILABLE read-time state
(<xref target="sec-system-model-read-time-status"/>).  A
CHUNK_ROLLBACK naming this owner triple satisfies
"Rollback of COMMITTED Chunks" case (a)
(<xref target="sec-CHUNK_ROLLBACK"/>).</t>
                </dd>
                <dt>RETAINED_GENERATION_DISPOSITION_ERRORED:</dt>
                <dd>
                  <t>the data server retains the immediate predecessor's
owner triple (in the errored arm) but its payload is in
the ERRORED read-time state and cannot be restored by
CHUNK_ROLLBACK.  A CHUNK_ROLLBACK naming this owner
triple <bcp14>MUST</bcp14> return NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>); the client falls back
to best-effort reconstruction via CHUNK_WRITE_REPAIR with an
authoritative source of its own choosing.
The owner triple is disclosed so a caller can
coordinate reconstruction from surviving
shards.</t>
                </dd>
              </dl>
              <t>The list is informational and <bcp14>MAY</bcp14> change between
successive CHUNK_HEADER_READ calls -- the data
server <bcp14>MAY</bcp14> release a predecessor between calls
under the retention scope rule.  A caller that
observes a PRESENT disposition and issues
CHUNK_ROLLBACK before that release remains
guaranteed by the composed rollback guarantee
(<xref target="sec-composed-rollback"/>) when it holds a
qualifying lock or escrow; without such a lock,
the retention scope <bcp14>MAY</bcp14> release the predecessor
at any time and a subsequent CHUNK_ROLLBACK <bcp14>MAY</bcp14>
return NFS4ERR_NO_PREDECESSOR even though a
previous CHUNK_HEADER_READ observed PRESENT.</t>
            </dd>
            <dt>Cardinality and short responses:</dt>
            <dd>
              <t>All five response arrays are the same length; the data
server <bcp14>MUST NOT</bcp14> sparsify or truncate one array independently
of the others.</t>
              <t>The response array length N <bcp14>MAY</bcp14> be smaller than chra_count
when the requested range extends past the data server's last
chunk (chrr_eof = TRUE, N = the number of chunks the data
server holds within the requested range) or when the
fully-populated response would exceed the session-negotiated
ca_maxresponsesize (<xref section="18.36.3" sectionFormat="of" target="RFC8881"/>).  In the
response-size case the data server returns a short response
with chrr_eof = FALSE containing as many entries N as fit
under ca_maxresponsesize minus COMPOUND/RPC overhead; the
client resumes at chra_offset + N.  If even the minimum
useful response (a single entry) will not fit, the data
server returns NFS4ERR_REP_TOO_BIG per <xref target="RFC8881"/>; the
client <bcp14>MUST NOT</bcp14> retry with a smaller chra_count and
instead uses a session or COMPOUND with more available
response budget.</t>
            </dd>
          </dl>
          <t>The operation has several uses:</t>
          <dl>
            <dt>Whole-file repair scan:</dt>
            <dd>
              <t>A repair actor selected via CB_CHUNK_REPAIR walks the affected chunk
range and uses the per-chunk chunk_owner4 returned by
each mirror's data server to identify which chunks
carry an atomic stripe (all k data shards share the
same chunk_guard4) and which require reconstruction.
CHUNK_HEADER_READ is the discovery primitive that
drives the per-chunk decisions described in
<xref target="sec-repair-multi-writer"/>; without it, a repair
client would have to issue CHUNK_READ to retrieve the
full payload of every chunk merely to inspect its
guard.</t>
            </dd>
            <dt>Client-side recovery from partial writes:</dt>
            <dd>
              <t>After a network disruption or client restart, a writer
that holds the file's layout <bcp14>MAY</bcp14> issue
CHUNK_HEADER_READ to learn which of its prior
CHUNK_WRITEs reached the data server.  Chunks whose
chunk_owner4 reports the writer's own (co_cohort_id,
co_client_id) pair are PENDING or FINALIZED and
recoverable; chunks absent from the response or
carrying another writer's owner are not.  The writer
can then re-issue CHUNK_WRITE for the missing chunks
or CHUNK_ROLLBACK for the abandoned ones without
reading payloads it has already committed locally.</t>
            </dd>
            <dt>Read-side atomicity check:</dt>
            <dd>
              <t>Before issuing a multi-chunk CHUNK_READ in
multiple-writer mode, a client <bcp14>MAY</bcp14> issue
CHUNK_HEADER_READ to verify that the chunks in the
target range share a common <tt>(co_cohort_id,
co_client_id)</tt> pair in chrr_owners (the cohort-atomicity
property in
<xref target="sec-system-model-consistency"/>) and <bcp14>MAY</bcp14> additionally
inspect chrr_guards as a cheaper generation-level
corroboration.  If the cohort pairs diverge, the
client knows the read will not be atomic and can
wait for a writer to commit, retry, or report
NFS4ERR_PAYLOAD_NOT_ATOMIC via LAYOUTERROR.  This is
a hint rather than a guarantee: a concurrent writer
<bcp14>MAY</bcp14> advance a chunk's state between the
CHUNK_HEADER_READ response and the subsequent
CHUNK_READ.</t>
            </dd>
            <dt>Predecessor-guided rollback discovery:</dt>
            <dd>
              <t>A caller preparing a CHUNK_ROLLBACK against a COMMITTED
chunk inspects the corresponding chrr_predecessors entry
to decide whether CHUNK_ROLLBACK will succeed.</t>
              <dl>
                <dt>PRESENT:</dt>
                <dd>
                  <t>name the disclosed owner triple in the cra_chunks entry
of the subsequent CHUNK_ROLLBACK.  "Rollback of
COMMITTED Chunks" case (a) will succeed subject to the
composed rollback guarantee's continuous-custody
condition (<xref target="sec-composed-rollback"/>).</t>
                </dd>
                <dt>ERRORED:</dt>
                <dd>
                  <t>do NOT issue CHUNK_ROLLBACK against the disclosed owner
triple.  The data server <bcp14>MUST</bcp14> return
NFS4ERR_NO_PREDECESSOR for that owner; use
CHUNK_WRITE_REPAIR directly with a reconstructed
authoritative source.  The disclosed owner triple lets
the caller coordinate reconstruction from other sources.</t>
                </dd>
                <dt>ABSENT:</dt>
                <dd>
                  <t>no restorable predecessor exists.  Skip CHUNK_ROLLBACK;
use CHUNK_WRITE_REPAIR if reconstruction is possible, or
defer to a guaranteed-pinning mechanism when the caller
requires the original owner triple be preserved.</t>
                </dd>
              </dl>
              <t>As with the atomicity check, a subsequent lifecycle event
<bcp14>MAY</bcp14> change a chunk's disposition between the
CHUNK_HEADER_READ response and the CHUNK_ROLLBACK (a
PRESENT observation <bcp14>MAY</bcp14> become ABSENT if the retention
scope releases the predecessor and the caller does not
hold a qualifying lock or escrow).</t>
            </dd>
            <dt>Lock probe before write:</dt>
            <dd>
              <t>A client <bcp14>MAY</bcp14> issue CHUNK_HEADER_READ and inspect the
chrr_locked array to discover whether any chunk in
the target range is currently held by a CHUNK_LOCK before attempting CHUNK_WRITE,
avoiding the round-trip cost of receiving
NFS4ERR_CHUNK_LOCKED.  As above, this is a hint; a
lock <bcp14>MAY</bcp14> be acquired between the header read and the
write.</t>
            </dd>
          </dl>
          <t>CHUNK_HEADER_READ does not change any chunk state.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          <section anchor="per-chunk-status-encoding">
            <name>Per-Chunk Status Encoding</name>
            <t>The per-chunk chrr_status field reports the chunk's
lifecycle state encoded as an nfsstat4:</t>
            <dl>
              <dt>NFS4_OK:</dt>
              <dd>
                <t>the chunk is COMMITTED and the chunk_owner4 in the
corresponding chrr_owners slot is the COMMITTED
generation's owner.</t>
              </dd>
              <dt>NFS4ERR_PAYLOAD_NOT_ATOMIC:</dt>
              <dd>
                <t>the chunk is PENDING or FINALIZED (a non-globally-visible
generation is in progress).  The
chunk_owner4 in the corresponding chrr_owners slot
names the writer of that in-progress generation.</t>
              </dd>
              <dt>NFS4ERR_NOENT:</dt>
              <dd>
                <t>the chunk is EMPTY (no COMMITTED generation has been
written at this offset).  The chunk_owner4 in the
corresponding chrr_owners slot is unspecified.</t>
              </dd>
              <dt>NFS4ERR_PAYLOAD_LOST:</dt>
              <dd>
                <t>the chunk is terminally lost or tombstoned and cannot be
reconstructed.  The corresponding metadata entries identify
the last retained generation where available; the payload is
not returned and the client <bcp14>MUST</bcp14> treat the condition as
terminal rather than retrying repair on another data server.</t>
              </dd>
            </dl>
            <t>CHUNK_HEADER_READ never returns NFS4ERR_CHUNK_LOCKED in
chrr_status; lock state is reported orthogonally via
chrr_locked so that locked chunks still surface their
chunk_owner4 to the inspector.</t>
          </section>
        </section>
        <section anchor="response-codes-3">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the chunk headers have been returned.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to read chunk headers on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while reading chunk headers.</t>
            </dd>
            <dt>NFS4ERR_PAYLOAD_LOST:</dt>
            <dd>
              <t>the requested header range is terminally lost or
tombstoned and no header result can be returned.  For a
partially affected range, the operation returns NFS4_OK
with NFS4ERR_PAYLOAD_LOST in the corresponding chrr_status
entries instead.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_HEADER_READ.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_LOCK">
        <name>Operation 82: CHUNK_LOCK - Lock Cached Chunk Data</name>
        <section anchor="arguments-4">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_LOCK4args">
            <name>XDR for CHUNK_LOCK4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// const CHUNK_LOCK_FLAGS_ADOPT    = 0x00000001;
   /// const CHUNK_LOCK_FLAGS_TAKEOVER = 0x00000002;
   ///
   /// union chunk_lock_adopt4 switch (bool cla_adopt) {
   ///     case TRUE:
   ///         escrow_id4      cla_escrow_id;
   ///     case FALSE:
   ///         void;
   /// };
   ///
   /// struct CHUNK_LOCK4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4            cla_stateid;
   ///     offset4             cla_offset;
   ///     count4              cla_count;
   ///     uint32_t            cla_flags;
   ///     chunk_owner4        cla_owner;
   ///     chunk_lock_adopt4   cla_adopt;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-4">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_LOCK4res">
            <name>XDR for CHUNK_LOCK4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_LOCK4res switch (nfsstat4 clr_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     case NFS4ERR_CHUNK_LOCKED:
   ///         chunk_owner4    clr_owner;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-4">
          <name>DESCRIPTION</name>
          <t>CHUNK_LOCK acquires an exclusive chunk-range lock on the
range specified by cla_offset and cla_count.  While the
lock is held, CHUNK_WRITE, CHUNK_WRITE_REPAIR,
CHUNK_FINALIZE, CHUNK_COMMIT, CHUNK_ROLLBACK, and
CHUNK_UNLOCK operations on any of
the locked chunks from any other chunk_owner4 receive
NFS4ERR_CHUNK_LOCKED in the corresponding per-chunk
status slot.  The lock is associated with the
chunk_owner4 in cla_owner.</t>
          <t>CHUNK_LOCK is loosely analogous to LOCK (<xref section="18.10" sectionFormat="of" target="RFC8881"/>)
in that it acquires an exclusive guard against concurrent
modification, but the two operate on different coordinate systems and
use different naming: LOCK is byte range and stateid-based; CHUNK_LOCK
is chunk-range and chunk_owner4-based. CHUNK_LOCK is used in
multiple-writer mode (<xref target="sec-multi-writer"/>) to serialize racing
writers on a common chunk range, and in the repair flow
(<xref target="sec-repair-selection"/>) to transfer lock ownership to a repair
actor via CHUNK_LOCK_FLAGS_ADOPT.</t>
          <t>The client provides:</t>
          <dl>
            <dt>cla_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted for
this file.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>cla_offset:</dt>
            <dd>
              <t>starting chunk index of the lock range (not a byte
offset).</t>
            </dd>
            <dt>cla_count:</dt>
            <dd>
              <t>number of chunks the lock range covers, starting at
cla_offset.</t>
            </dd>
            <dt>cla_flags:</dt>
            <dd>
              <t>bitmask of CHUNK_LOCK_FLAGS_* values.  Defined:
CHUNK_LOCK_FLAGS_ADOPT (adopt a metadata-server escrow lock;
see "Lock Transfer via CHUNK_LOCK_FLAGS_ADOPT" below);
CHUNK_LOCK_FLAGS_TAKEOVER (transfer ownership of a
live client-held lock, distinct from adoption; see
"Live-Client Lock Takeover via
CHUNK_LOCK_FLAGS_TAKEOVER" below).  The two flags
are mutually exclusive; a request with both bits set
<bcp14>MUST</bcp14> be rejected with NFS4ERR_INVAL.  Unknown bits
<bcp14>MUST</bcp14> be rejected with NFS4ERR_INVAL.</t>
            </dd>
            <dt>cla_owner:</dt>
            <dd>
              <t>the chunk_owner4 (<xref target="fig-chunk_owner4"/>) that will hold
the lock on success.  The reserved sentinel values
CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear as the
co_client_id of cla_owner; see
<xref target="sec-chunk_guard_none"/> and <xref target="sec-chunk_guard_mds"/>.
(A client requesting CHUNK_LOCK_FLAGS_ADOPT <bcp14>MUST</bcp14> use
its own co_client_id, not the metadata-server escrow sentinel,
even when adopting from a metadata-server escrow holder.)</t>
            </dd>
            <dt>cla_adopt:</dt>
            <dd>
              <t>a discriminated union carrying the escrow_id4
(<xref target="sec-escrow_id4"/>) that identifies the specific
metadata-server escrow lock the caller is adopting.  When
cla_flags carries CHUNK_LOCK_FLAGS_ADOPT, cla_adopt
<bcp14>MUST</bcp14> be the TRUE arm and cla_escrow_id <bcp14>MUST</bcp14> match
the escrow_id4 the metadata server installed on
this data server for the requested range (identity
mismatch is one of the state-level causes of
NFS4ERR_NO_ADOPTABLE_LOCK per
<xref target="sec-NFS4ERR_NO_ADOPTABLE_LOCK"/>).  When cla_flags
does not carry CHUNK_LOCK_FLAGS_ADOPT, cla_adopt
<bcp14>MUST</bcp14> be the FALSE arm.  The two conditions
(bit-flag value and discriminant value) <bcp14>MUST</bcp14> agree;
a mismatch is rejected with NFS4ERR_INVAL.</t>
            </dd>
          </dl>
          <t>The CHUNK_LOCK result returns:</t>
          <dl>
            <dt>clr_status:</dt>
            <dd>
              <t>NFS4_OK if the lock was acquired (or transferred via
ADOPT).  NFS4ERR_CHUNK_LOCKED if one or more chunks
in the range are already locked and the request does
not carry CHUNK_LOCK_FLAGS_ADOPT.</t>
            </dd>
            <dt>clr_owner (NFS4ERR_CHUNK_LOCKED case only):</dt>
            <dd>
              <t>the chunk_owner4 of the current lock holder, so the
caller can identify the blocking writer.</t>
            </dd>
          </dl>
          <t>The lock is released by CHUNK_UNLOCK or implicitly when the holder's
lease expires; on lease expiry without explicit
release, the data server transitions the lock to the
metadata-server escrow owner if the metadata server has revoked
the holder's stateid via REVOKE_STATEID, per the lock-continuity-across-revocation
invariant in
<xref target="sec-system-model-consistency"/>.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          <section anchor="lock-transfer-via-chunklockflagsadopt">
            <name>Lock Transfer via CHUNK_LOCK_FLAGS_ADOPT</name>
            <t>The CHUNK_LOCK_FLAGS_ADOPT flag in cla_flags requests an atomic
transfer of lock ownership to cla_owner for every chunk in
[cla_offset, cla_offset+cla_count).  The data server <bcp14>MUST</bcp14> perform
the transfer as a single atomic step per chunk: there is no window
in which the chunk is unlocked.  After a successful ADOPT, subsequent
CHUNK_WRITE, CHUNK_WRITE_REPAIR, CHUNK_ROLLBACK, and CHUNK_UNLOCK
operations <bcp14>MUST</bcp14> present cla_owner as their chunk_owner4.</t>
            <t>CHUNK_LOCK_FLAGS_ADOPT is the sole mechanism by which a chunk lock
can change hands without first being released.  The lock ordering
invariant -- that every chunk in a payload transitioning through
repair is held by exactly one owner continuously from failure
detection to repair completion -- depends on it.</t>
            <t>CHUNK_LOCK_FLAGS_ADOPT is valid only when the caller has been
selected as the repair actor for the range by the metadata server,
typically via CB_CHUNK_REPAIR.  A data
server that receives CHUNK_LOCK with the ADOPT flag from a client
that has not been so designated <bcp14>MAY</bcp14> reject the operation with
NFS4ERR_ACCESS.  Because CHUNK_LOCK is a CHUNK operation and
encodings that use CHUNK operations require tight coupling
(<xref target="sec-ff_device_addr4"/>), the metadata server notifies the data
server of the ADOPT designation via the control protocol (e.g.,
TRUST_STATEID with the new client's stateid or a similar
facility); no loose coupling ADOPT path exists.</t>
            <t>The current lock holder at the moment of ADOPT <bcp14>MAY</bcp14> be:</t>
            <ol spacing="normal" type="1"><li>
                <t>Another client whose stateid remains valid (for example, a
client that has stopped making progress but has not yet lost
its lease).  The prior owner's PENDING or FINALIZED shards
remain on disk until the new owner issues CHUNK_WRITE_REPAIR,
CHUNK_ROLLBACK, or CHUNK_COMMIT.</t>
              </li>
              <li>
                <t>The metadata server itself, acting through the
CHUNK_GUARD_CLIENT_ID_MDS escrow owner
(<xref target="sec-chunk_guard_mds"/>).  This occurs when the metadata
server has revoked the prior holder's stateid in a tightly
coupled deployment.</t>
              </li>
            </ol>
            <t>In either case, ADOPT's effect from the repair actor's
perspective is the same: after the successful return the caller
holds the lock and may drive the range to consistency.</t>
            <t>The data server <bcp14>MUST</bcp14> reject CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT if cla_owner's co_client_id equals
CHUNK_GUARD_CLIENT_ID_MDS -- that value is reserved for server
production and <bcp14>MUST NOT</bcp14> be presented by a client.  The operation
returns NFS4ERR_INVAL in that case.</t>
          </section>
          <section anchor="live-client-lock-takeover-via-chunklockflagstakeover">
            <name>Live-Client Lock Takeover via CHUNK_LOCK_FLAGS_TAKEOVER</name>
            <t>The CHUNK_LOCK_FLAGS_TAKEOVER flag in cla_flags requests
an atomic transfer of lock ownership from a currently
live client-held lock to cla_owner, distinct from
CHUNK_LOCK_FLAGS_ADOPT which transfers from an
metadata-server escrow lock.  The two flags are mutually exclusive:
ADOPT names the metadata server's escrow identity via
cla_adopt, while TAKEOVER names another client's
already-held lock and is used only when the metadata
server has designated cla_owner as the successor to a
displaced live client (for example, when a repair
sequence must proceed while the prior writer's session
remains valid).</t>
            <t>Under CHUNK_LOCK_FLAGS_TAKEOVER, cla_adopt <bcp14>MUST</bcp14> be the
FALSE arm (there is no escrow identity being adopted);
the metadata server's designation is what authorizes
the transfer, and the data server verifies the
designation by the same coupling-model-dependent
mechanism used for ADOPT above.  A data server that
receives TAKEOVER from a client not designated as
successor <bcp14>MAY</bcp14> reject with NFS4ERR_ACCESS.  As with
ADOPT, TAKEOVER is atomic: no window exists in which
the chunk is unlocked, and after a successful
TAKEOVER subsequent operations on the range <bcp14>MUST</bcp14>
present cla_owner as their chunk_owner4.</t>
          </section>
        </section>
        <section anchor="response-codes-4">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the requested chunk range has been locked.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to lock chunks on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_CHUNK_LOCKED:</dt>
            <dd>
              <t>one or more chunks in the requested
range are already locked by another writer.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>the requested range was malformed or outside
the file's mirror set.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement CHUNK_LOCK.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_READ">
        <name>Operation 83: CHUNK_READ - Read Chunks from File</name>
        <section anchor="arguments-5">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_READ4args">
            <name>XDR for CHUNK_READ4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_READ4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4    cra_stateid;
   ///     offset4     cra_offset;
   ///     count4      cra_count;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-5">
          <name>RESULTS</name>
          <figure anchor="fig-read_chunk4">
            <name>XDR for read_chunk4</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct read_chunk4 {
   ///     checksum4          cr_checksum;
   ///     uint32_t           cr_effective_len;
   ///     chunk_owner4       cr_owner;
   ///     chunk_guard4       cr_guard;
   ///     uint32_t           cr_payload_id;
   ///     chunk_state_flags4 cr_locked;
   ///     nfsstat4           cr_status;
   ///     opaque             cr_chunk<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_READ4resok">
            <name>XDR for CHUNK_READ4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_READ4resok {
   ///     bool        crr_eof;
   ///     read_chunk4 crr_chunks<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_READ4res">
            <name>XDR for CHUNK_READ4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_READ4res switch (nfsstat4 crr_status) {
   ///     case NFS4_OK:
   ///          CHUNK_READ4resok     crr_resok4;
   ///     default:
   ///          void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-5">
          <name>DESCRIPTION</name>
          <t>The CHUNK_READ operation is based upon the NFSv4.1 READ
operation (see <xref section="18.22" sectionFormat="of" target="RFC8881"/>) and similarly
reads data from the regular file identified by the current
filehandle, with the difference that CHUNK_READ operates on
the chunk coordinate system used by Flexible File Version 2
layouts rather than on the byte coordinate system.</t>
          <t>The client provides a cra_offset of where the CHUNK_READ is
to start and a cra_count of how many chunks are to be read.
cra_offset is the starting chunk index in the file (not a
byte offset); the chunk at index N occupies the bytes
[N * chunk_size, (N + 1) * chunk_size) for encodings with a
uniform chunk size, where chunk_size is taken from
ffv2m_striping_unit_size in the file's layout
(<xref target="sec-ffv2-mirror4"/>).  For encodings whose parity shards
have variable sizes (the Mojette family), the parity-shard
chunks on a given data server may use a smaller per-shard
chunk size; see <xref target="sec-mojette-encoding"/>.  cra_count is a
count of chunks to read and not bytes to read.</t>
          <t>A cra_offset of zero starts reading at the first chunk of
the file.  If cra_offset is greater than or equal to the
number of chunks the data server holds for this file, the
status NFS4_OK is returned with crr_chunks empty and
crr_eof set to TRUE.</t>
          <t>If cra_count is zero, the CHUNK_READ succeeds and returns
zero chunks.  In all situations the data server <bcp14>MAY</bcp14> choose
to return fewer chunks than the client requested; the
client must be prepared to handle a short read and reissue
CHUNK_READ for the remaining chunks.</t>
          <t>The CHUNK_READ result is comprised of an array of
read_chunk4, each describing the metadata and payload of
one chunk.  The array entries are in chunk-index order
starting from cra_offset.  Within each read_chunk4
(<xref target="fig-read_chunk4"/>):</t>
          <dl>
            <dt>cr_checksum:</dt>
            <dd>
              <t>the checksum4 (<xref target="sec-checksum4"/>) the data server
recomputed over the chunk header and cr_chunk (with the
checksum field's bytes treated as zero, per the uniform
coverage rule in <xref target="sec-checksum4"/>) at CHUNK_READ time,
from the persisted value it recorded at CHUNK_FINALIZE
or CHUNK_COMMIT time.  The cs_algorithm field matches
the layout's ffv2m_checksum_algorithm
(<xref target="sec-ffv2-mirror4"/>); the cs_value carries the
computed bytes at the length registered for that
algorithm.  The client uses cr_checksum to detect
transport corruption between the data server and the
client; see <xref target="sec-security-checksum-scope"/> for the
scope and limits of checksum protection per algorithm
class.</t>
            </dd>
            <dt>cr_effective_len:</dt>
            <dd>
              <t>the byte length of cr_chunk.  This may be smaller than
the layout's chunk_size when the chunk is the final
chunk of a file whose size is not chunk-aligned, or
when the chunk belongs to a variable-size Mojette
parity shard.</t>
            </dd>
            <dt>cr_owner:</dt>
            <dd>
              <t>the full owner triple
of the COMMITTED generation being returned (see
<xref target="sec-chunk_owner4"/>); co_id is the opaque writer-supplied
per-chunk identifier the client provided at
CHUNK_WRITE or CHUNK_WRITE_REPAIR time, not a chunk
index.  A client reading from multiple data servers in
an erasure-coded layout <bcp14>MUST</bcp14> compare the pair
<tt>(cr_owner.co_cohort_id, cr_owner.co_client_id)</tt> across
data servers; agreement of the cohort pair across the k
data shards is the atomicity invariant on which
reconstruction depends.  See
<xref target="sec-system-model-consistency"/>.</t>
            </dd>
            <dt>cr_guard:</dt>
            <dd>
              <t>the (cg_gen_id, cg_client_id) pair the data server holds
as the chunk's current chunk_guard4 (<xref target="sec-chunk_guard4"/>)
at CHUNK_READ time.  A client that intends to update this
chunk in multiple writer mode uses cr_guard as the
expected prior value for the guard CAS: it supplies
cwa_guard.cwg_check = TRUE with cwa_guard.cwg_guard set
to the observed cr_guard on the subsequent CHUNK_WRITE
(<xref target="sec-CHUNK_WRITE"/>, <xref target="sec-multi-writer"/>).  A client
reading from multiple data servers in an erasure-coded
layout <bcp14>MAY</bcp14> also compare cr_guard values across shards as
an auxiliary check on payload atomicity; the cr_owner
cohort-pair comparison (see the bullet above and
<xref target="sec-system-model-consistency"/>) is the normative
atomicity invariant and cr_guard adds a cheaper
generation-level check.  For the
NFS4ERR_NOENT synthetic zero-filled chunk the cr_guard is
set to the all-zeros pair (cg_client_id =
CHUNK_GUARD_CLIENT_ID_NONE, see <xref target="sec-chunk_guard_none"/>).</t>
            </dd>
            <dt>cr_payload_id:</dt>
            <dd>
              <t>the payload-id the writer associated with the chunk at
CHUNK_WRITE time, used by repair coordinators to
correlate chunks across mirrors.</t>
            </dd>
            <dt>cr_locked:</dt>
            <dd>
              <t>chunk_state_flags4 (<xref target="sec-chunk_state_flags4"/>).
CHUNK_STATE_FLAGS_LOCKED set indicates the chunk
currently has a CHUNK_LOCK held against it.  Lock
state does not block the read.</t>
            </dd>
            <dt>cr_status:</dt>
            <dd>
              <t>per-chunk status.  NFS4_OK indicates that cr_chunk is
the COMMITTED payload.  NFS4ERR_PAYLOAD_NOT_ATOMIC
indicates the chunk's persisted checksum or guard check
failed at read time, in which case cr_chunk content
is undefined; see <xref target="sec-NFS4ERR_PAYLOAD_NOT_ATOMIC"/>.
NFS4ERR_NOENT indicates the chunk is EMPTY (no
COMMITTED generation has been written at this offset).
NFS4ERR_PAYLOAD_LOST indicates that the chunk is
terminally lost or tombstoned; cr_chunk is empty and the
client <bcp14>MUST</bcp14> surface a terminal error rather than retrying
repair on another data server.</t>
            </dd>
            <dt>cr_chunk:</dt>
            <dd>
              <t>the chunk payload bytes.  Empty for cr_status values
other than NFS4_OK.</t>
            </dd>
          </dl>
          <t>A chunk that is EMPTY at the requested offset is returned
as a synthetic zero-filled chunk: cr_status is
NFS4ERR_NOENT, cr_chunk is zero-filled to the layout's
chunk_size, cr_owner is set to all-zeros (with co_client_id
= CHUNK_GUARD_CLIENT_ID_NONE, see <xref target="sec-chunk_guard_none"/>),
cr_guard is set to the all-zeros pair (cg_gen_id = 0 and
cg_client_id = CHUNK_GUARD_CLIENT_ID_NONE), and
cr_checksum is the checksum of the synthetic zero-filled
payload.  This lets a client reconstruct holes without a
special-casing path.</t>
          <t>The data server <bcp14>MAY</bcp14> signal end-of-file by setting crr_eof
to TRUE.  If the CHUNK_READ ended at the last chunk that
exists on this data server (the read returned chunks up to
and including the data server's last chunk) or extended
beyond it, crr_eof <bcp14>MUST</bcp14> be TRUE.  Otherwise crr_eof is
FALSE.  A successful CHUNK_READ of an empty file always
returns crr_eof as TRUE with crr_chunks empty.  Note that
crr_eof reflects the state at the data server only; in a
multi-data-server erasure-coded layout the file's logical
size is reconstructed at the client from the chunk-index
positions at which surviving shards hold non-EMPTY chunks
(observed via successive CHUNK_READs at known offsets),
not from any single data server's crr_eof.  Because co_id
is opaque per <xref target="sec-chunk_owner4"/>, the reconstructing
client <bcp14>MUST NOT</bcp14> derive positional information from the
chunk_owner4 values themselves.</t>
          <t>Except when special stateids are used, the cra_stateid
value represents a layout stateid returned by a prior
LAYOUTGET against the metadata server (see <xref section="18.43" sectionFormat="of" target="RFC8881"/>).  The data server uses cra_stateid to verify that the
client holds a valid layout that authorizes reading this file.  Under
trusted stateid tight coupling (<xref target="sec-TRUST_STATEID"/>), the data
server additionally checks that the metadata server has registered the
stateid via TRUST_STATEID; an unregistered stateid (other than a
special stateid) returns NFS4ERR_BAD_STATEID.</t>
          <t>For a CHUNK_READ with a cra_stateid value of all bits
equal to zero, the data server <bcp14>MAY</bcp14> allow the CHUNK_READ
to be serviced subject to the chunk-lock state recorded in
cr_locked.  For a CHUNK_READ with a cra_stateid value of
all bits equal to one, the data server <bcp14>MAY</bcp14> allow CHUNK_READ
to bypass lock-state reporting at the data server.  These
special-stateid behaviors mirror the corresponding READ
semantics in <xref target="RFC8881"/> adapted to the chunk-locking
model (<xref target="sec-CHUNK_LOCK"/>) rather than the byte range
locking model of <xref section="12." sectionFormat="of" target="RFC8881"/></t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          <t><xref target="fig-example-CHUNK_READ4args"/> shows a client requesting
4 chunks starting at chunk index 2.  Data Server 2
responds as in <xref target="fig-example-CHUNK_READ4resok"/>: there is
valid data for chunks 2 and 4, a synthetic zero-filled
hole at chunk 3, and no data for chunk 5 (the data server's
last chunk is chunk 4, so crr_eof is TRUE).  The data
server calculates a valid cr_checksum for chunk 3 based on the
synthetic zero-filled payload.</t>
          <figure anchor="fig-example-CHUNK_READ4args">
            <name>Example: CHUNK_READ4args parameters</name>
            <artwork><![CDATA[
        Data Server 2
  +--------------------------------+
  | CHUNK_READ4args                |
  +--------------------------------+
  | cra_stateid: 0                 |
  | cra_offset: 2                  |
  | cra_count: 4                   |
  +--------------------------------+
]]></artwork>
          </figure>
          <figure anchor="fig-example-CHUNK_READ4resok">
            <name>Example: Resulting CHUNK_READ4resok reply</name>
            <sourcecode type="art"><![CDATA[
        Data Server 2
  +--------------------------------+
  | CHUNK_READ4resok               |
  +--------------------------------+
  | crr_eof: true                  |
  | crr_chunks[0]:                 |
  |     cr_checksum: 0x3faddace    |
  |     cr_owner:                  |
  |         co_cohort_id: 0x2a     |
  |         co_client_id: 6        |
  |         co_id: 2               |
  |     cr_payload_id: 1           |
  |     cr_chunk: ....             |
  | crr_chunks[1]:                 |
  |     cr_checksum: 0xdeade4e5    |
  |     cr_owner:                  |
  |         co_cohort_id: 0x0      |
  |         co_client_id: 0        |
  |         co_id: 0               |
  |     cr_payload_id: 1           |
  |     cr_chunk: 0000...00000     |
  | crr_chunks[2]:                 |
  |     cr_checksum: 0x7778abcd    |
  |     cr_owner:                  |
  |         co_cohort_id: 0x2a     |
  |         co_client_id: 6        |
  |         co_id: 4               |
  |     cr_payload_id: 1           |
  |     cr_chunk: ....             |
  +--------------------------------+
]]></sourcecode>
          </figure>
        </section>
        <section anchor="response-codes-5">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the requested chunks have been returned.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to read this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while reading the chunks.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement CHUNK_READ.</t>
            </dd>
            <dt>NFS4ERR_PAYLOAD_NOT_ATOMIC:</dt>
            <dd>
              <t>one or more chunks failed their
persisted guard or CRC check.  See <xref target="sec-NFS4ERR_PAYLOAD_NOT_ATOMIC"/>.</t>
            </dd>
            <dt>NFS4ERR_PAYLOAD_LOST:</dt>
            <dd>
              <t>one or more requested chunks are terminally lost or
tombstoned.  The operation returns no payload for those
entries; the client <bcp14>MUST</bcp14> surface the terminal condition and
<bcp14>MUST NOT</bcp14> treat it as a transient retry or ordinary I/O error.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_REPAIRED">
        <name>Operation 84: CHUNK_REPAIRED - Confirm Repair of Errored Chunk Data</name>
        <section anchor="arguments-6">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_REPAIRED4args">
            <name>XDR for CHUNK_REPAIRED4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_REPAIRED4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cra_stateid;
   ///     offset4         cra_offset;
   ///     count4          cra_count;
   ///     chunk_owner4    cra_owner;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-6">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_REPAIRED4res">
            <name>XDR for CHUNK_REPAIRED4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_REPAIRED4res switch (nfsstat4 crr_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-6">
          <name>DESCRIPTION</name>
          <t>CHUNK_REPAIRED signals that chunks previously marked as
errored (via CHUNK_ERROR, see <xref target="sec-CHUNK_ERROR"/>) have been
repaired and the errored state can be cleared.  The repair
client writes replacement data via CHUNK_WRITE_REPAIR, advances the new chunks
through CHUNK_FINALIZE and
CHUNK_COMMIT, and only then issues
CHUNK_REPAIRED to make the repaired chunks visible to
normal CHUNK_READ traffic again.</t>
          <t>CHUNK_REPAIRED has no direct analog in <xref target="RFC8881"/>; it is
the chunk-protocol equivalent of clearing a "needs scrub"
flag after a RAID controller has rewritten a parity stripe.
Together with CHUNK_ERROR it forms the data-server-side
state-bit pair that quarantines damaged chunks from
ordinary reads during the repair window.</t>
          <t>The client provides:</t>
          <dl>
            <dt>cra_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted to the
repair actor.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>cra_offset:</dt>
            <dd>
              <t>starting chunk index of the repaired range (not a byte
offset).</t>
            </dd>
            <dt>cra_count:</dt>
            <dd>
              <t>number of chunks the repaired range covers, starting
at cra_offset.  The cra_offset / cra_count range <bcp14>MUST</bcp14>
match the range named in the original CHUNK_ERROR that
marked these chunks errored; mismatched ranges are
rejected with NFS4ERR_INVAL.</t>
            </dd>
            <dt>cra_owner:</dt>
            <dd>
              <t>the chunk_owner4 (<xref target="fig-chunk_owner4"/>) identifying the
repair actor.  The data server uses this to record
which actor cleared the errored state.  The reserved
sentinels CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear in cra_owner;
see <xref target="sec-chunk_guard_none"/> and <xref target="sec-chunk_guard_mds"/>.</t>
            </dd>
          </dl>
          <t>CHUNK_REPAIRED returns a single top-level status; there is
no per-chunk status array because the data server either
accepts the confirmation for the whole range or returns a
top-level error.</t>
          <t>The data server <bcp14>MUST</bcp14> verify before accepting the
confirmation that:</t>
          <ul spacing="normal">
            <li>
              <t>every chunk in [cra_offset, cra_offset + cra_count) is
currently in the errored state, and</t>
            </li>
            <li>
              <t>every chunk in the range has been advanced to COMMITTED
by a CHUNK_WRITE_REPAIR / CHUNK_FINALIZE / CHUNK_COMMIT
sequence since the CHUNK_ERROR that marked them errored.</t>
            </li>
          </ul>
          <t>If either precondition fails, the data server returns
NFS4ERR_INVAL and the errored state is left in place.  A
repair actor that sees NFS4ERR_INVAL <bcp14>SHOULD</bcp14> verify the
chunks via CHUNK_HEADER_READ
before retrying.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-6">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the repair confirmation has been recorded.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to confirm repair on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>the chunks named were not in an errored state,
or the repair did not match the recorded error.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_REPAIRED.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ROLLBACK">
        <name>Operation 85: CHUNK_ROLLBACK - Rollback Changes on Cached Chunk Data</name>
        <section anchor="arguments-7">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ROLLBACK4args">
            <name>XDR for CHUNK_ROLLBACK4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ROLLBACK4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cra_stateid;
   ///     offset4         cra_offset;
   ///     count4          cra_count;
   ///     chunk_owner4    cra_chunks<>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-7">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ROLLBACK4resok">
            <name>XDR for CHUNK_ROLLBACK4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ROLLBACK4resok {
   ///     verifier4       crr_writeverf;
   ///     nfsstat4        crr_chunk_status<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_ROLLBACK4res">
            <name>XDR for CHUNK_ROLLBACK4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_ROLLBACK4res switch (nfsstat4 crr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_ROLLBACK4resok   crr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-7">
          <name>DESCRIPTION</name>
          <t>CHUNK_ROLLBACK reverts chunks from the PENDING or
FINALIZED state to their previous state, effectively
undoing a CHUNK_WRITE that has not
yet reached COMMITTED via CHUNK_COMMIT.  The reversion target is the
prior COMMITTED generation, if one exists for the
affected chunk; otherwise the chunk returns to the EMPTY
state (<xref target="fig-chunk-state-machine"/>).  CHUNK_ROLLBACK
against a chunk already in the COMMITTED state is
permitted only on the repair path; see "Rollback of
COMMITTED Chunks" below.</t>
          <t>CHUNK_ROLLBACK has no direct analog in <xref target="RFC8881"/>: NFS
WRITE has no separate finalization or commit step that a
client could undo without contacting other components.
CHUNK_ROLLBACK exists because the chunk state machine
exposes the PENDING and FINALIZED states explicitly, and
the writer needs a way to abandon a non-committed
generation without committing it.</t>
          <t>The client provides cra_offset and cra_count to bound the
chunk range, and cra_chunks to name the specific
(chunk_owner4) generations within that range to roll back:</t>
          <dl>
            <dt>cra_offset:</dt>
            <dd>
              <t>starting chunk index in the file (not a byte offset).</t>
            </dd>
            <dt>cra_count:</dt>
            <dd>
              <t>number of chunks the range covers, starting at
cra_offset.</t>
            </dd>
            <dt>cra_chunks:</dt>
            <dd>
              <t>an array of chunk_owner4 entries
(<xref target="fig-chunk_owner4"/>) naming the specific generations to roll
back.  For each entry the data server looks up the
chunk index it associated with the complete
owner triple when the
client wrote it via CHUNK_WRITE or
CHUNK_WRITE_REPAIR.  That recorded chunk index <bcp14>MUST</bcp14>
lie in [cra_offset, cra_offset + cra_count); if the
triple does not match any recorded owner association
on this data server for this file, or the recorded
chunk index lies outside the requested range, the
entry is rejected with NFS4ERR_INVAL in the
corresponding crr_chunk_status slot.  The reserved
sentinels CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear as the
co_client_id of any cra_chunks entry; see
<xref target="sec-chunk_guard_none"/> and <xref target="sec-chunk_guard_mds"/>.</t>
            </dd>
          </dl>
          <t>The CHUNK_ROLLBACK result returns:</t>
          <dl>
            <dt>crr_writeverf:</dt>
            <dd>
              <t>a verifier identifying the data server's incarnation.
Semantics match cwr_writeverf in CHUNK_WRITE.</t>
            </dd>
            <dt>crr_chunk_status:</dt>
            <dd>
              <t>per-chunk rollback status, one entry per cra_chunks
entry, co-indexed.  NFS4_OK indicates that the named
generation was reverted (either to a retained
predecessor COMMITTED or FINALIZED generation, or to
EMPTY when no predecessor exists).  NFS4ERR_INVAL
indicates the data server holds a concrete
invalidation context that identifies the presented
triple (structurally invalid, or released by an
explicit CHUNK_ROLLBACK delete case within the
session slot's replay-cache window), or the recorded
chunk index lies outside [cra_offset, cra_offset +
cra_count).  NFS4ERR_NO_PREDECESSOR indicates the
data server holds no association for the presented
triple and no concrete invalidation context -- the
release-scope split is defined normatively at
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>.  Other per-entry
failures use the appropriate error code; the
top-level operation status is NFS4_OK as long as the
data server could evaluate each entry.</t>
            </dd>
          </dl>
          <t>CHUNK_ROLLBACK has two principal scenarios:</t>
          <ol spacing="normal" type="1"><li>
              <t>A writer in multiple-writer mode that observed
per-chunk failures in the CHUNK_WRITE response (e.g.,
NFS4ERR_CHUNK_GUARDED on a subset of chunks) needs to
abandon the partial write before issuing CHUNK_FINALIZE
on the chunks that did succeed.  CHUNK_ROLLBACK on the
abandoned chunks releases their PENDING generation
cleanly.</t>
            </li>
            <li>
              <t>A repair actor that wrote reconstructed data via
CHUNK_WRITE_REPAIR and
subsequently discovered the reconstruction was wrong
(for example, a CRC mismatch detected during
cross-mirror verification) needs to abandon the
repair before any client commits it.</t>
            </li>
          </ol>
          <t>The data server effects the rollback as follows:</t>
          <dl>
            <dt>Chunks in PENDING with a matching chunk_owner4:</dt>
            <dd>
              <t>the data server deletes the PENDING payload and restores
the chunk to its prior state (EMPTY, or the prior COMMITTED
generation if the rollback invariant in
<xref target="sec-system-model-consistency"/> required retention).</t>
            </dd>
            <dt>Chunks in FINALIZED with a matching chunk_owner4:</dt>
            <dd>
              <t>the data server deletes the FINALIZED payload and the
persisted finalization metadata, restoring the chunk to its
prior state.</t>
            </dd>
            <dt>Chunks not in PENDING or FINALIZED at the named generation, or whose chunk_owner4 does not match:</dt>
            <dd>
              <t>the corresponding crr_chunk_status slot reports
NFS4ERR_INVAL or NFS4ERR_NO_PREDECESSOR per the
release-scope split at <xref target="sec-NFS4ERR_NO_PREDECESSOR"/>, and
the chunk is left unchanged.</t>
            </dd>
          </dl>
          <section anchor="deletion-atomicity-and-invalidated-triples">
            <name>Deletion Atomicity and Invalidated Triples</name>
            <t>CHUNK_ROLLBACK's delete case (successful rollback of a
PENDING or FINALIZED generation, or the abandonment sub-case
of the rollback of COMMITTED chunks below where a displaced
successor is discarded) removes BOTH the payload AND the
recorded owner-to-index association for that generation, in
one atomic step, per the payload/association biconditional
(<xref target="sec-system-model-payload-association-biconditional"/>).
The generation's owner triple
is then INVALIDATED at that chunk index: it names no
generation the data server holds, and no future CHUNK_WRITE
recreates an association under the same triple.</t>
            <t>A subsequent lifecycle operation (CHUNK_COMMIT, CHUNK_FINALIZE, CHUNK_ROLLBACK) that names an
invalidated triple <bcp14>MUST NOT</bcp14> be treated as resurrecting
the deleted generation; the data server <bcp14>MUST NOT</bcp14> attempt
to match the triple against any other record.  The error
returned in the corresponding per-chunk slot depends on
the release scope observable to the caller:</t>
            <ul spacing="normal">
              <li>
                <t>Within the session slot's replay-cache window of the
CHUNK_ROLLBACK that performed the delete case (or an
equivalent slotted retransmission of it), the slot
reports NFS4ERR_INVAL -- the caller could have observed
the specific invalidating operation.</t>
              </li>
              <li>
                <t>After that replay-cache window has elapsed, or for
release under any other terminal transition (lease
expiry, storage-pressure release, retention-scope
release of an already-invalidated triple), the slot
reports NFS4ERR_NO_PREDECESSOR -- the data server holds
no association for the presented triple and cannot
distinguish it from any other released generation.</t>
              </li>
            </ul>
            <t>Both errors carry the same non-resurrection guarantee
above; they differ only in what the caller can observe
about how the association was released (see
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>).</t>
            <t>The invalidation is on the FULL owner triple, not on any
sub-part.  A client that legitimately reuses the same
co_id value under a different co_cohort_id (or against a
different co_client_id) creates a distinct triple and
therefore a distinct generation identity; that new triple
is unaffected by the earlier deletion.  This is what
allows a writer that abandoned a generation via
CHUNK_ROLLBACK to retry with a fresh co_cohort_id -- the
retry is a new generation, not a resurrection of the
deleted one.</t>
            <t>The uncertain-replay carve-out
(the CHUNK_ROLLBACK "Idempotence and Uncertain-Replay
Carve-Out" text below) is a narrow exception:
an EXACT reissue of the same CHUNK_ROLLBACK op whose
prior completion was uncertain <bcp14>MAY</bcp14> be treated as
postcondition-equivalent success when the client
independently verifies the deletion postcondition
holds.  This is separate from -- and does NOT resurrect --
the invalidated triple; it merely acknowledges that the
prior op already achieved the deletion the caller
requested.</t>
          </section>
          <section anchor="rollback-of-committed-chunks">
            <name>Rollback of COMMITTED Chunks</name>
            <t>CHUNK_ROLLBACK against a COMMITTED chunk is permitted
ONLY on the repair path, when a repair actor is
restoring a prior COMMITTED generation that another
client incorrectly advanced.  Two cases separate by
whether the predecessor generation the caller wants to
restore is still present on the data server:</t>
            <section anchor="case-a-retained-predecessor">
              <name>Case (a) -- Retained Predecessor</name>
              <t>The predecessor generation named in the cra_chunks entry is
still held by the data server (typically the prior COMMITTED
retained under the rollback invariant
(<xref target="sec-system-model-retention-scope"/>) alongside the displaced
successor, and <bcp14>MUST</bcp14> have survived with its payload+association
pair intact per the biconditional
(<xref target="sec-system-model-payload-association-biconditional"/>)).  The
data server:</t>
              <ul spacing="normal">
                <li>
                  <t>restores the retained predecessor as the current COMMITTED
generation UNDER ITS ORIGINAL owner triple (the owner triple
the predecessor was written with) -- its owner-to-index
association is preserved, so the restored generation <bcp14>MUST</bcp14>
remain recognizable to subsequent lifecycle operations by
the same triple; AND</t>
                </li>
                <li>
                  <t>atomically invalidates the displaced successor's triple via
the delete case above ("Deletion Atomicity and Invalidated
Triples") -- the displaced successor's payload+association
pair is released as one unit; a subsequent lifecycle op
naming the displaced triple returns NFS4ERR_INVAL within the
session slot's replay-cache window of this CHUNK_ROLLBACK,
and NFS4ERR_NO_PREDECESSOR after that window has elapsed,
per the release-scope split at
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>.</t>
                </li>
              </ul>
              <t>The restore is atomic with the delete: no intermediate state
exposes both generations as current, and no intermediate state
exposes neither.</t>
            </section>
            <section anchor="case-b-predecessor-no-longer-retained">
              <name>Case (b) -- Predecessor No Longer Retained</name>
              <t>If the predecessor generation named in the cra_chunks entry is
NOT held by the data server -- its payload+association pair
was released some time earlier under the retention scope rule
(lease expiry, an earlier CHUNK_ROLLBACK delete case, or any
other terminal transition) -- the CHUNK_ROLLBACK CANNOT
restore it.  The deleted association is not recreated by any
operation defined in this document.</t>
              <t>The corresponding crr_chunk_status slot reports:</t>
              <dl>
                <dt>NFS4ERR_INVAL:</dt>
                <dd>
                  <t>when the caller has named a triple released by an explicit
CHUNK_ROLLBACK delete case within the current session slot's
replay-cache window.</t>
                </dd>
                <dt>NFS4ERR_NO_PREDECESSOR:</dt>
                <dd>
                  <t>in the ordinary case -- release under the retention scope
rule, or eventual release of an already-invalidated triple
after the delete case's replay-cache window has elapsed.
See <xref target="sec-NFS4ERR_NO_PREDECESSOR"/> for the choice between
the two codes.</t>
                </dd>
              </dl>
              <t>The caller then consults whatever fallback the deployment
provides.  A repair actor <bcp14>MAY</bcp14> reconstruct authoritative bytes
from surviving shards and issue CHUNK_WRITE_REPAIR to write a
new generation carrying those bytes under a new owner triple.
That new generation is a distinct generation for lifecycle
purposes; it is not the deleted predecessor resurrected.</t>
              <t>A client that requires the restored generation to retain the
predecessor's original owner triple, in cases where the
retention scope (<xref target="sec-system-model-retention-scope"/>) would
otherwise permit release, <bcp14>MUST</bcp14> use the metadata-server escrow
control plane (<xref target="sec-CHUNK_ESCROW_INSTALL"/> through
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>).  Escrow pins the predecessor's
payload and its owner-to-index association jointly against
that release rule for as long as the escrow-lock or a
client-owned lock adopted from it remains in continuous
custody (see <xref target="sec-composed-rollback"/>).</t>
              <t>A non-repair CHUNK_ROLLBACK against a COMMITTED chunk is
rejected with NFS4ERR_INVAL regardless of case.</t>
            </section>
          </section>
          <section anchor="stateid-and-authorization">
            <name>Stateid and Authorization</name>
            <t>Like CHUNK_COMMIT, CHUNK_ROLLBACK
carries an explicit layout stateid in cra_stateid.  The
data server authorizes CHUNK_ROLLBACK by validating
cra_stateid against the file identified by the current
filehandle: cra_stateid <bcp14>MUST</bcp14> be the layout stateid the
metadata server issued to the caller for the current
filehandle, or the special anonymous stateid (see below).
Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), the data server rejects
CHUNK_ROLLBACK with NFS4ERR_BAD_STATEID unless
cra_stateid is present in the data server's trust table
for the current filehandle.  The explicit field ensures
that a CHUNK_ROLLBACK in its own standalone compound
(typical for retry after a failed CHUNK_WRITE cohort)
carries the authorization the data server needs.
Passing the special anonymous stateid is permitted only
when the underlying security regime authorizes an
unattributed writer.</t>
            <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          </section>
          <section anchor="idempotence-and-uncertain-replay-carve-out">
            <name>Idempotence and Uncertain-Replay Carve-Out</name>
            <t>CHUNK_ROLLBACK is idempotent on its target: a second
CHUNK_ROLLBACK naming the same generations after the
first has succeeded finds those generations already in
the state the first produced.  Under the ordinary
per-entry rules the second call returns NFS4ERR_INVAL in
each crr_chunk_status slot within the session slot's
replay-cache window of the first call (the first call's
delete case invalidated the triples per "Deletion
Atomicity and Invalidated Triples" above, or the
retained-predecessor restore invalidated the displaced
successor's triple per "Rollback of COMMITTED Chunks"
above); after that window has elapsed the second call
returns NFS4ERR_NO_PREDECESSOR per the release-scope
split at <xref target="sec-NFS4ERR_NO_PREDECESSOR"/>.</t>
            <dl>
              <dt>Uncertain-replay carve-out:</dt>
              <dd>
                <t>When the first
CHUNK_ROLLBACK completed at the data server but its
response was lost (network error, dropped connection,
data server restart before the reply was received), the
client cannot distinguish "the op did not run" from
"the op ran and its reply was lost."  A client that
issues an EXACT REISSUE of the same CHUNK_ROLLBACK op
under these conditions <bcp14>MAY</bcp14> treat the resulting
per-chunk NFS4ERR_INVAL (within the replay-cache
window) or NFS4ERR_NO_PREDECESSOR (after the window has
elapsed) as POSTCONDITION-EQUIVALENT SUCCESS on a
slot-by-slot basis, PROVIDED all of the following hold
for that slot:</t>
              </dd>
            </dl>
            <ul spacing="normal">
              <li>
                <t>the reissue is byte-identical to the original op
(same cra_offset, same cra_count, same cra_chunks
array entry) -- a fresh op with an accidentally-matching
triple does NOT qualify;</t>
              </li>
              <li>
                <t>the prior completion is genuinely uncertain (the
client never observed a per-entry response for that
slot); AND</t>
              </li>
              <li>
                <t>the client INDEPENDENTLY verifies that the target
postcondition holds.  For the delete case, this
means observing that the named generation is absent
at the target chunk index (via CHUNK_HEADER_READ or CHUNK_READ with the retention-scope rules
understood).  For the retained-predecessor restore
case, this means observing that the predecessor's
original triple is now the current COMMITTED
generation.</t>
              </li>
            </ul>
            <t>The carve-out is narrow by construction: a fresh op
receiving NFS4ERR_INVAL or NFS4ERR_NO_PREDECESSOR never
qualifies, and a reissue that cannot verify the
postcondition also does not qualify -- the client <bcp14>MUST</bcp14>
treat the error as a terminal per-entry failure in
either case.  This prevents the carve-out from being
conflated with the underlying non-resurrection
guarantee, which is unconditional and prohibits the
data server from resurrecting any deleted generation
("Deletion Atomicity and Invalidated Triples" above).
Similar reasoning applies
to exact uncertain reissues of CHUNK_COMMIT and CHUNK_FINALIZE, which are also idempotent on
their targets under the same three predicates.</t>
          </section>
        </section>
        <section anchor="response-codes-7">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the named chunks have been rolled back.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to roll back chunks on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>arguments named chunks not eligible for rollback
or outside the file's mirror set.</t>
            </dd>
            <dt>NFS4ERR_NO_PREDECESSOR:</dt>
            <dd>
              <t>the named predecessor has no recorded owner-to-index
association on the data server (retention scope
released it, or the delete case's replay-cache window
has elapsed).  See <xref target="sec-NFS4ERR_NO_PREDECESSOR"/> for
the split against NFS4ERR_INVAL.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_ROLLBACK.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_UNLOCK">
        <name>Operation 86: CHUNK_UNLOCK - Unlock Cached Chunk Data</name>
        <section anchor="arguments-8">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_UNLOCK4args">
            <name>XDR for CHUNK_UNLOCK4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_UNLOCK4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        cua_stateid;
   ///     offset4         cua_offset;
   ///     count4          cua_count;
   ///     chunk_owner4    cua_owner;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-8">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_UNLOCK4res">
            <name>XDR for CHUNK_UNLOCK4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_UNLOCK4res switch (nfsstat4 cur_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-8">
          <name>DESCRIPTION</name>
          <t>CHUNK_UNLOCK releases the exclusive chunk-range lock
previously acquired by CHUNK_LOCK.
CHUNK_UNLOCK is loosely analogous to LOCKU (<xref section="18.12" sectionFormat="of" target="RFC8881"/>) in that it releases an exclusive guard, but it operates on
chunk-range coordinates and is matched against the chunk_owner4 that
acquired the lock rather than against an open / lock stateid.</t>
          <t>The client provides:</t>
          <dl>
            <dt>cua_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted for
this file.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>cua_offset:</dt>
            <dd>
              <t>starting chunk index of the range to unlock (not a
byte offset).</t>
            </dd>
            <dt>cua_count:</dt>
            <dd>
              <t>number of chunks the unlock range covers, starting at
cua_offset.  The range <bcp14>MUST</bcp14> match exactly the range
of an outstanding CHUNK_LOCK held by cua_owner;
partial-range unlock is not supported.</t>
            </dd>
            <dt>cua_owner:</dt>
            <dd>
              <t>the chunk_owner4 (<xref target="fig-chunk_owner4"/>) that holds
the lock.  The co_client_id <bcp14>MUST</bcp14> match the
chunk_owner4 that was supplied on the CHUNK_LOCK that
acquired the lock (including the case of a lock
transferred via CHUNK_LOCK_FLAGS_ADOPT, in which the
adopter's chunk_owner4 is the current holder).  The
reserved sentinel values CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear as the
co_client_id of cua_owner; see
<xref target="sec-chunk_guard_none"/> and <xref target="sec-chunk_guard_mds"/>.
In particular, a repair actor releasing a lock it
adopted from the metadata-server escrow owner uses its own
co_client_id in cua_owner, not
CHUNK_GUARD_CLIENT_ID_MDS.</t>
            </dd>
          </dl>
          <t>The CHUNK_UNLOCK result returns a single top-level
status; there is no per-chunk status array because the
unlock either succeeds for the whole range or returns a
top-level error.</t>
          <t>CHUNK_UNLOCK is idempotent in the sense that releasing
chunks that are not currently locked returns NFS4_OK
without effect.  Releasing chunks that are locked by a
different cua_owner returns NFS4ERR_INVAL and leaves the
lock in place.</t>
          <t>A client <bcp14>SHOULD</bcp14> issue CHUNK_UNLOCK promptly after
completing the write, write-repair, or commit sequence
that the lock guarded.  Locks not explicitly released
are released implicitly when the holder's lease expires;
if the metadata server has revoked the holder's stateid
via REVOKE_STATEID before the
lease lapses, the lock transitions to the metadata-server escrow
owner per the lock-continuity invariant in
<xref target="sec-system-model-consistency"/> rather than being
released outright.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-8">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the named chunks have been unlocked, or no lock was
held (idempotent).</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to unlock chunks on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>arguments named chunks not in a locked state
owned by this caller.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_UNLOCK.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_WRITE">
        <name>Operation 87: CHUNK_WRITE - Write Chunks to File</name>
        <section anchor="arguments-9">
          <name>ARGUMENTS</name>
          <figure anchor="fig-write_chunk_guard4">
            <name>XDR for write_chunk_guard4</name>
            <sourcecode type="xdr"><![CDATA[
   /// union write_chunk_guard4 switch (bool cwg_check) {
   ///     case TRUE:
   ///         chunk_guard4   cwg_guard;
   ///     case FALSE:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_WRITE4args">
            <name>XDR for CHUNK_WRITE4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// const CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY = 0x00000001;
   ///
   /// struct CHUNK_WRITE4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4           cwa_stateid;
   ///     offset4            cwa_offset;
   ///     stable_how4        cwa_stable;
   ///     chunk_cohort_id4   cwa_cohort_id;
   ///     uint32_t           cwa_client_id;
   ///     uint32_t           cwa_co_ids<>;
   ///     uint32_t           cwa_payload_id;
   ///     uint32_t           cwa_flags;
   ///     write_chunk_guard4 cwa_guard;
   ///     uint32_t           cwa_chunk_size;
   ///     checksum4          cwa_checksums<>;
   ///     opaque             cwa_chunks<>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-9">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_WRITE4resok">
            <name>XDR for CHUNK_WRITE4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_WRITE4resok {
   ///     count4          cwr_count;
   ///     stable_how4     cwr_committed;
   ///     verifier4       cwr_writeverf;
   ///     nfsstat4        cwr_block_status<>;
   ///     bool            cwr_block_activated<>;
   ///     chunk_owner4    cwr_owners<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_WRITE4res">
            <name>XDR for CHUNK_WRITE4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_WRITE4res switch (nfsstat4 cwr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_WRITE4resok    cwr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-9">
          <name>DESCRIPTION</name>
          <t>The CHUNK_WRITE operation is based upon the NFSv4.1 WRITE
operation (see <xref section="18.32" sectionFormat="of" target="RFC8881"/>) and similarly
writes data to the regular file identified by the current
filehandle, with the difference that CHUNK_WRITE operates
on the chunk coordinate system used by Flexible File
Version 2 layouts rather than on the byte coordinate
system.  Successful chunk writes initially enter the
PENDING state in the chunk state machine
(<xref target="fig-chunk-state-machine"/>); a subsequent CHUNK_FINALIZE and CHUNK_COMMIT (or the activation shortcut
described below) progress them to COMMITTED.</t>
          <t>The client provides a cwa_offset of where the CHUNK_WRITE
is to start and a payload consisting of one or more chunks
packed into the cwa_chunks opaque field.  cwa_offset is
the starting chunk index in the file (not a byte offset);
each chunk occupies cwa_chunk_size bytes within cwa_chunks
except the last, which <bcp14>MAY</bcp14> be shorter when the file size
is not chunk-aligned or when the payload encodes a
variable-size Mojette parity shard
(<xref target="sec-mojette-encoding"/>).  The number of chunks in the
payload is ceil(len(cwa_chunks) / cwa_chunk_size).</t>
          <t>The writer supplies the cohort identity of the payload in
compact form: cwa_cohort_id carries the shared
chunk_cohort_id4 for every chunk in the batch, cwa_client_id
carries the writer's layout-granted identity, and cwa_co_ids
is an array of writer-chosen opaque per-chunk co_id values,
one per chunk in the payload (see <xref target="sec-chunk_owner4"/>).
The full cohort triple recorded on the data server for the
chunk at zero-based position i within the payload is
<tt>(cwa_cohort_id, cwa_client_id, cwa_co_ids[i])</tt>.</t>
          <t><tt>cwa_client_id</tt> identifies the writer.  It is
client-presented, metadata-server-assigned: the client presents the
32-bit layout-granted identity that the metadata server
established in ffv2m_client_id (see <xref target="sec-ffv2-mirror4"/>) at
layout-grant time; the client <bcp14>MUST NOT</bcp14> substitute any other
value.  Because encodings that use CHUNK operations require tight coupling
(<xref target="sec-ff_device_addr4"/>), the data server always has an
authoritative binding for this identity: the metadata server
registers it via tsa_client_id in TRUST_STATEID alongside the layout stateid.  The
data server <bcp14>MUST</bcp14> compare cwa_client_id against the
tsa_client_id recorded in its trust table for the presented
layout stateid, and <bcp14>MUST</bcp14> reject a mismatch with
NFS4ERR_BAD_STATEID: a client that presents a cwa_client_id
different from its layout's ffv2m_client_id is spoofing
another writer's identity.  <tt>cwa_client_id</tt> <bcp14>MUST NOT</bcp14> be the
reserved sentinels CHUNK_GUARD_CLIENT_ID_NONE or
CHUNK_GUARD_CLIENT_ID_MDS (see <xref target="sec-chunk_guard_none"/> and
<xref target="sec-chunk_guard_mds"/>); those sentinels are reserved for
data-server-observed cg_client_id values in chunk_guard4
CAS state, not for use as a writer's own identity.
<tt>cwa_cohort_id</tt> is the writer's opaque per-transaction
identifier, shared by every chunk in the payload; the
writer chooses a new <tt>cwa_cohort_id</tt> per distinct write
transaction so that lifecycle operations can distinguish
transactions across all data files (see the discussion of
chunk_cohort_id4 in <xref target="sec-chunk_guard4"/>).  The
per-chunk CAS state (chunk_guard4) is carried separately
via cwa_guard.cwg_guard when compare-and-swap is required
(<xref target="sec-multi-writer"/>).</t>
          <t><tt>cwa_co_ids&lt;&gt;</tt> contains exactly one entry per chunk in the
payload (i.e., <tt>cwa_co_ids_len</tt> <bcp14>MUST</bcp14> equal
<tt>ceil(len(cwa_chunks) / cwa_chunk_size)</tt>); the data server
rejects any other length with NFS4ERR_INVAL.  Within a
single <tt>(cwa_cohort_id, cwa_client_id)</tt>, the <tt>cwa_co_ids</tt>
values in this request <bcp14>MUST</bcp14> be distinct so that lifecycle
operations (CHUNK_FINALIZE, CHUNK_COMMIT, CHUNK_ROLLBACK)
can name individual chunks unambiguously by full triple.  The data
server treats each <tt>cwa_co_ids[i]</tt> as opaque; it does NOT
interpret the value beyond equality comparison, and it <bcp14>MUST
NOT</bcp14> require <tt>cwa_co_ids[i]</tt> to equal <tt>cwa_offset + i</tt> or
any other derived index.  A writer that finds it convenient
to use monotonic per-writer serials or file-index-derived
values <bcp14>MAY</bcp14> do so, but the wire semantics do not privilege
that choice.</t>
          <t>cwa_payload_id is a writer-chosen identifier that lets a
repair coordinator correlate chunks of the same logical
write across data servers.</t>
          <t>cwa_checksums, when non-empty, <bcp14>MUST</bcp14> contain one checksum
entry per chunk in the payload.  Each entry's cs_algorithm
<bcp14>MUST</bcp14> match ffv2m_checksum_algorithm of the mirror named in
the layout (see <xref target="sec-ffv2-mirror4"/>); a mismatch is rejected
with NFS4ERR_INVAL.  The data server validates each chunk's
checksum at CHUNK_WRITE time and rejects mismatched chunks
with NFS4ERR_IO in the corresponding cwr_block_status slot.
An empty cwa_checksums array (cwa_checksums_len = 0)
indicates the client did not supply per-chunk checksums; the
data server still computes and persists per-chunk checksums
from the payload bytes for later integrity verification but
cannot detect transport corruption at CHUNK_WRITE time
without the client's
reference values.</t>
          <t>cwa_flags carries CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY (see
"Stability and Activation" below).</t>
          <t>cwa_guard (<xref target="fig-write_chunk_guard4"/>) controls the chunk-guard
CAS check (see "Guarding the Write" below).</t>
          <t>A cwa_offset of zero starts writing at the first chunk of
the file.  Unlike READ in <xref target="RFC8881"/>, a CHUNK_WRITE whose
cwa_offset extends beyond the current end of the file is
not an error: the data server extends the file's chunk
store to cover the new chunks, with intervening offsets
remaining EMPTY (<xref target="sec-system-model-chunk-state"/>) until
they too are written.  If the cwa_chunks payload is empty
(zero bytes), the CHUNK_WRITE succeeds and writes zero
chunks (cwr_count = 0).</t>
          <t>In all situations the data server <bcp14>MAY</bcp14> choose to write
fewer chunks than the client requested; the client must be
prepared to handle a short write and reissue CHUNK_WRITE
for the remaining chunks.</t>
          <t>The CHUNK_WRITE result includes per-chunk outcomes in
cwr_block_status, cwr_block_activated, and cwr_owners, all
co-indexed and one entry per chunk in the payload:</t>
          <dl>
            <dt>cwr_count:</dt>
            <dd>
              <t>the number of chunks the data server successfully
accepted.  Chunks that failed their guard check, checksum
check, or any other local precondition do not
contribute to cwr_count.</t>
            </dd>
            <dt>cwr_committed:</dt>
            <dd>
              <t>the stable_how4 level the data server actually applied
for accepted chunks.  This <bcp14>MUST</bcp14> be at least as durable
as cwa_stable; see "Stability and Activation" below.</t>
            </dd>
            <dt>cwr_writeverf:</dt>
            <dd>
              <t>a verifier identifying the data server's incarnation.
A client uses cwr_writeverf to detect a data server
restart that lost UNSTABLE4 writes: if the client's
subsequent CHUNK_COMMIT returns a different writeverf
than was returned by an UNSTABLE4 CHUNK_WRITE earlier,
the chunks may have been lost and the client <bcp14>SHOULD</bcp14>
re-issue CHUNK_WRITE.  cwr_writeverf changes on every
data server restart that loses uncommitted state.</t>
            </dd>
            <dt>cwr_block_status:</dt>
            <dd>
              <t>per-chunk acceptance status; see "Per-Block Acceptance
Semantics" below.</t>
            </dd>
            <dt>cwr_block_activated:</dt>
            <dd>
              <t>per-chunk activation flag.  TRUE indicates that the
chunk is COMMITTED on return from CHUNK_WRITE -- the
activation shortcut described under "Stability and
Activation" below.  FALSE indicates that the chunk is
in the PENDING state and requires a subsequent
CHUNK_FINALIZE and CHUNK_COMMIT to become COMMITTED.</t>
            </dd>
            <dt>cwr_owners:</dt>
            <dd>
              <t>per-chunk chunk_owner4 the data server recorded, one
entry per chunk in the payload (co-indexed with
cwa_co_ids and cwr_block_status).  Each entry is the
complete cohort triple <tt>(cwa_cohort_id, cwa_client_id,
cwa_co_ids[i])</tt> that the data server recorded (or, for
a rejected slot, the requested triple echoed for
positional correlation with the failure status in
<tt>cwr_block_status[i]</tt>).  The data server does NOT
synthesize per-chunk identity by modifying the writer's
cohort; the returned triple is the value the client
supplied, so a client that lost track of its own
transmitted co_ids array can recover the data server's
view.  Under the compact carrier the cohort pair
(cwa_cohort_id, cwa_client_id) is shared across every
returned entry -- the per-chunk distinction is carried
entirely by the co_id.</t>
            </dd>
          </dl>
          <t>Except when special stateids are used, cwa_stateid
represents a layout stateid returned by a prior LAYOUTGET
against the metadata server (see <xref section="18.43" sectionFormat="of" target="RFC8881"/>) that
authorizes write access to this file. Under trusted stateid tight
coupling (<xref target="sec-TRUST_STATEID"/>), the data server additionally checks
that the metadata server has registered the stateid via TRUST_STATEID;
an unregistered stateid (other than a special stateid) returns
NFS4ERR_BAD_STATEID.</t>
          <t>For a CHUNK_WRITE with a cwa_stateid value of all bits
equal to zero, the data server <bcp14>MAY</bcp14> allow the CHUNK_WRITE
to be serviced subject to any CHUNK_LOCK currently held
on the target chunks.  For a CHUNK_WRITE with a
cwa_stateid value of all bits equal to one, the data
server <bcp14>MAY</bcp14> allow CHUNK_WRITE to bypass lock-state
checking at the data server.  These special-stateid
behaviors mirror the corresponding WRITE semantics in
<xref target="RFC8881"/> adapted to the chunk-locking model
(<xref target="sec-CHUNK_LOCK"/>) rather than the byte range locking
model of <xref section="12." sectionFormat="of" target="RFC8881"/></t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
          <section anchor="stability-and-activation">
            <name>Stability and Activation</name>
            <t>The cwa_stable field controls the durability level the
data server guarantees before returning.  The durability
floor for each level covers BOTH the chunk payload AND
its owner-to-index association, so a subsequent
lifecycle operation naming the full owner triple can
locate the recorded chunk index; see
<xref target="sec-system-model-owner-persistence"/> for the normative
coupling rule and the "<bcp14>MUST NOT</bcp14> retain payload without
association" invariant.</t>
            <dl>
              <dt>FILE_SYNC4:</dt>
              <dd>
                <t>The data server <bcp14>MUST</bcp14> commit all written chunks plus
all chunk-store metadata to stable storage before
returning.</t>
              </dd>
              <dt>DATA_SYNC4:</dt>
              <dd>
                <t>The data server <bcp14>MUST</bcp14> commit all written chunk payloads
to stable storage and enough of the chunk-store
metadata to retrieve the data before returning.  An
implementation <bcp14>MAY</bcp14> treat DATA_SYNC4 identically to
FILE_SYNC4 at a possible performance cost.</t>
              </dd>
              <dt>UNSTABLE4:</dt>
              <dd>
                <t>The data server is free to commit any portion of the
chunk payload and metadata to stable storage before
returning, including all or none.  The data server
makes only two guarantees: it will not destroy any
chunk payload it accepted without changing
cwr_writeverf, and the durability level it ultimately
applies will not be less than that requested.</t>
              </dd>
            </dl>
            <t>The CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY flag in cwa_flags
requests an activation shortcut for first-time writes: a
chunk that was EMPTY before the CHUNK_WRITE and whose
write reaches FILE_SYNC4 or DATA_SYNC4 durability <bcp14>MAY</bcp14> be
transitioned directly to COMMITTED by the data server,
with the corresponding cwr_block_activated entry set to
TRUE in the response.
Without the flag, or for chunks that were not EMPTY
before the write, or for writes at UNSTABLE4 durability,
the chunk enters the PENDING state and reaches COMMITTED
only after a subsequent CHUNK_FINALIZE and CHUNK_COMMIT.</t>
            <t>The activation shortcut interacts with concurrent writers
and unstable writes in subtle ways:</t>
            <ul spacing="normal">
              <li>
                <t>A chunk written with cwa_stable = UNSTABLE4 cannot be
activated by CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY
because the payload has not been committed to stable
storage; the chunk enters the PENDING state regardless
of the flag.</t>
              </li>
              <li>
                <t>In the multi-writer mode (<xref target="sec-multi-writer"/>) a
client <bcp14>MUST NOT</bcp14> set CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY
on any CHUNK_WRITE.  The activation shortcut bypasses
CHUNK_FINALIZE, so a chunk that reached COMMITTED via
the shortcut cannot be reverted by the loser's
CHUNK_ROLLBACK flow described in
<xref target="sec-chunk_guard4"/>; two racing writers whose EMPTY
activations landed on disjoint subsets of the mirror set
would leave the stripe permanently non-atomic with no
protocol path to recovery.  A data server that receives
a multi-writer-mode CHUNK_WRITE with
CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY set <bcp14>MUST</bcp14> reject the
request with NFS4ERR_INVAL in the corresponding
cwr_block_status slot; the client <bcp14>MUST</bcp14> re-issue without
the flag, allowing the chunk to enter PENDING and
proceed through the standard CHUNK_FINALIZE +
CHUNK_COMMIT path.  The shortcut remains available in
single writer mode where CAS contention cannot arise.</t>
              </li>
              <li>
                <t>A client that issues an UNSTABLE4 CHUNK_WRITE and
observes a FALSE entry in cwr_block_activated for a
chunk <bcp14>MAY</bcp14> still find that chunk COMMITTED on a
subsequent CHUNK_READ -- another client could have
activated it via the shortcut after this one's
response was sent.  cwr_block_activated reflects the
state at the moment the CHUNK_WRITE result was
constructed, not a commitment to that state's
persistence.</t>
              </li>
            </ul>
          </section>
          <section anchor="guarding-the-write">
            <name>Guarding the Write</name>
            <t>A guarded CHUNK_WRITE is when the writing of a block <bcp14>MUST</bcp14> fail if
cwa_guard.cwg_check is TRUE and the target chunk does not have the
same cg_gen_id as cwa_guard.cwg_guard.cg_gen_id.  This is
useful in read-update-write scenarios.  The client reads a block,
updates it, and is prepared to write it back.  It guards the write
such that if another writer has modified the block, the data server
will reject the modification.</t>
            <t>As the chunk_guard4 (see <xref target="fig-chunk_guard4"/>) does not have a
chunk_id and the CHUNK_WRITE applies to all blocks in the range of
cwa_offset to the length of cwa_data, then each of the target blocks
<bcp14>MUST</bcp14> have the same cg_gen_id and cg_client_id.  The client <bcp14>SHOULD</bcp14>
present the smallest set of blocks as possible to meet this
requirement.</t>
          </section>
          <section anchor="per-block-acceptance-semantics">
            <name>Per-Block Acceptance Semantics</name>
            <t>A CHUNK_WRITE targets a contiguous range of blocks on a single
data server.  The data server evaluates each block independently
and reports the outcome per block in cwr_block_status (see
<xref target="fig-CHUNK_WRITE4resok"/>):</t>
            <ul spacing="normal">
              <li>
                <t>Each block is subjected to the guard check (when
cwa_guard.cwg_check is TRUE), the cg_client_id validation
(see <xref target="sec-chunk_guard4"/>), and any other local preconditions
(storage-space limits, tight coupling trust-table state,
etc.).</t>
              </li>
              <li>
                <t>Blocks that pass their preconditions are written and their
cwr_block_status entry is NFS4_OK.  Blocks that fail produce
the appropriate error code
(NFS4ERR_CHUNK_GUARDED, NFS4ERR_NOSPC, etc.) in the
corresponding cwr_block_status slot, and their data is
NOT persisted.</t>
              </li>
              <li>
                <t>cwr_count reflects only the blocks that were written
successfully; failed blocks do not contribute.</t>
              </li>
              <li>
                <t>The top-level cwr_status is NFS4_OK when the call itself was
structurally valid and the data server could evaluate each
block.  Per-block failures are reported in cwr_block_status,
not by failing the whole operation.  The data server returns
a top-level error only if it could not evaluate the request
at all.</t>
              </li>
            </ul>
            <t>This is the "continue and report" discipline.  It is
intentionally not all-or-none: atomicity is already per-chunk
(see <xref target="sec-system-model-consistency"/>), so there is no
file-level correctness reason to reject the entire compound
because of a single chunk guard failure.  Per-block reporting
gives the client the information it needs to construct a
targeted CHUNK_ROLLBACK or CHUNK_WRITE retry that covers only
the blocks that failed.</t>
            <t>The data server does not hold a file-wide lock across the
per-block evaluation.  The chunk_guard4 CAS is evaluated
atomically per chunk at the point the data server updates that
chunk's state, so an interleaving CHUNK_WRITE from a different
client that arrives mid-compound will either win its own CAS
race (and the losing client sees NFS4ERR_CHUNK_GUARDED for the
contested block) or be rejected itself, without introducing
data-server-level locking beyond the per-chunk scope.</t>
          </section>
        </section>
        <section anchor="response-codes-9">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the chunks have been written and are in the PENDING
state.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to write to this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_CHUNK_GUARDED:</dt>
            <dd>
              <t>the chunk_guard4 condition supplied by
the client did not match the persisted state.</t>
            </dd>
            <dt>NFS4ERR_CHUNK_LOCKED:</dt>
            <dd>
              <t>one or more chunks in the requested
range are locked by another writer.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while persisting the chunks.</t>
            </dd>
            <dt>NFS4ERR_NOSPC:</dt>
            <dd>
              <t>there is insufficient space at the data server.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement CHUNK_WRITE.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_WRITE_REPAIR">
        <name>Operation 88: CHUNK_WRITE_REPAIR - Write Repaired Cached Chunk Data</name>
        <section anchor="arguments-10">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_WRITE_REPAIR4args">
            <name>XDR for CHUNK_WRITE_REPAIR4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_WRITE_REPAIR4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4           cwra_stateid;
   ///     offset4            cwra_offset;
   ///     stable_how4        cwra_stable;
   ///     chunk_cohort_id4   cwra_cohort_id;
   ///     uint32_t           cwra_client_id;
   ///     uint32_t           cwra_co_ids<>;
   ///     uint32_t           cwra_payload_id;
   ///     uint32_t           cwra_chunk_size;
   ///     checksum4          cwra_checksums<>;
   ///     opaque             cwra_chunks<>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-10">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_WRITE_REPAIR4resok">
            <name>XDR for CHUNK_WRITE_REPAIR4resok</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_WRITE_REPAIR4resok {
   ///     count4          cwrr_count;
   ///     stable_how4     cwrr_committed;
   ///     verifier4       cwrr_writeverf;
   ///     nfsstat4        cwrr_block_status<>;
   ///     chunk_owner4    cwrr_owners<>;
   /// };
]]></sourcecode>
          </figure>
          <figure anchor="fig-CHUNK_WRITE_REPAIR4res">
            <name>XDR for CHUNK_WRITE_REPAIR4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_WRITE_REPAIR4res switch (nfsstat4 cwrr_status) {
   ///     case NFS4_OK:
   ///         CHUNK_WRITE_REPAIR4resok   cwrr_resok4;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-10">
          <name>DESCRIPTION</name>
          <t>CHUNK_WRITE_REPAIR is the repair-path variant of CHUNK_WRITE.  It writes reconstructed chunk data
to a data server whose chunks have been reported errored
(via CHUNK_ERROR, see <xref target="sec-CHUNK_ERROR"/>) or to a
replacement data server selected during whole-file repair.
The data server applies repair-specific policies to the
write that are not appropriate for normal client writes:
the chunk_guard4 CAS check is bypassed (the repair actor
is writing a reconstructed value rather than competing in
a multiple-writer race), and the data server <bcp14>MAY</bcp14> log the
repair separately for operator audit.</t>
          <t>CHUNK_WRITE_REPAIR has no direct analog in <xref target="RFC8881"/>; it
is the chunk-protocol equivalent of writing reconstructed
data into a RAID stripe whose other members are known
healthy.  The reconstructed data is produced by the repair
client from surviving shards via the erasure-coding
algorithm of the file's layout.</t>
          <t>The repair workflow that invokes CHUNK_WRITE_REPAIR is:</t>
          <ol spacing="normal" type="1"><li>
              <t>The repair actor (selected per
<xref target="sec-repair-selection"/>) reads surviving chunks from
the remaining data servers via CHUNK_READ.</t>
            </li>
            <li>
              <t>The repair actor reconstructs the missing chunks
using the erasure-coding algorithm of the file's
layout.</t>
            </li>
            <li>
              <t>The repair actor acquires a CHUNK_LOCK on the target data server to
prevent concurrent writes during repair.  For repair
that adopts a metadata-server escrow lock, the CHUNK_LOCK
carries CHUNK_LOCK_FLAGS_ADOPT
(<xref target="sec-chunk_guard_mds"/>).</t>
            </li>
            <li>
              <t>The repair actor writes the reconstructed data via
CHUNK_WRITE_REPAIR.</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_FINALIZE and CHUNK_COMMIT to persist the repair.</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_REPAIRED to clear the errored state.</t>
            </li>
            <li>
              <t>The repair actor releases the lock via CHUNK_UNLOCK.</t>
            </li>
          </ol>
          <t>CHUNK_WRITE_REPAIR is also the fallback path used by a
client that received NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>) from CHUNK_ROLLBACK's
restore case (<xref target="sec-CHUNK_ROLLBACK"/> "Rollback of
COMMITTED Chunks", case (b)) -- the named predecessor was
released under the retention scope
(<xref target="sec-system-model-retention-scope"/>) and CHUNK_ROLLBACK
cannot restore it.  Under this fallback the client
reconstructs authoritative bytes from surviving shards
(or from any other authoritative source it holds) and
writes them via CHUNK_WRITE_REPAIR under a new owner
triple of its own choosing.  The result is a distinct
generation for lifecycle purposes: it carries the
repair actor's own owner triple,
NOT the released predecessor's triple.  The released
predecessor is not resurrected by any operation defined
in this document, including this fallback; a subsequent
lifecycle operation naming the released predecessor's
triple returns NFS4ERR_NO_PREDECESSOR under the release-scope
split at <xref target="sec-NFS4ERR_NO_PREDECESSOR"/> -- the
predecessor was released under the retention scope, not
by an explicit CHUNK_ROLLBACK delete case within a live
replay-cache window.  A client that requires the
restored generation to carry the released predecessor's
original triple <bcp14>MUST</bcp14> use a guaranteed-pinning mechanism
as noted in <xref target="sec-NFS4ERR_NO_PREDECESSOR"/>, since
CHUNK_WRITE_REPAIR's semantics only produce a new
generation.  When no authoritative source exists for
reconstruction, the fallback itself may terminate at
NFS4ERR_PAYLOAD_LOST (<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>)
via CB_CHUNK_REPAIR.</t>
          <t>The arguments mirror CHUNK_WRITE except that
CHUNK_WRITE_REPAIR has no cwa_flags field (the
activation-shortcut behavior is not offered on the repair
path) and no cwa_guard field (the guard CAS is bypassed
by construction):</t>
          <dl>
            <dt>cwra_stateid:</dt>
            <dd>
              <t>the layout stateid the metadata server granted to the
repair actor.  Under trusted stateid tight coupling
(<xref target="sec-TRUST_STATEID"/>), this stateid <bcp14>MUST</bcp14> be in the
data server's trust table; otherwise the data server
rejects the operation with NFS4ERR_BAD_STATEID.</t>
            </dd>
            <dt>cwra_offset:</dt>
            <dd>
              <t>starting chunk index in the file (not a byte offset).</t>
            </dd>
            <dt>cwra_stable:</dt>
            <dd>
              <t>the stable_how4 durability level the data server <bcp14>MUST</bcp14>
apply before returning.  Semantics match cwa_stable in
CHUNK_WRITE (see <xref target="sec-CHUNK_WRITE"/> "Stability and
Activation").</t>
            </dd>
            <dt>cwra_cohort_id / cwra_client_id / cwra_co_ids:</dt>
            <dd>
              <t>the compact cohort-identity carrier the repair actor
uses for the reconstructed payload, mirroring
CHUNK_WRITE's cwa_cohort_id + cwa_client_id + cwa_co_ids
per <xref target="sec-CHUNK_WRITE"/>.  cwra_cohort_id carries the
shared chunk_cohort_id4 for every reconstructed chunk
in the batch; cwra_client_id is the repair actor's
layout-granted identity; cwra_co_ids is a co-indexed
array of writer-chosen opaque co_id values, one per
chunk in cwra_chunks (exactly <tt>ceil(len(cwra_chunks) /
cwra_chunk_size)</tt> entries; a length mismatch is
rejected with NFS4ERR_INVAL).  The full cohort triple
for reconstructed chunk position i is
<tt>(cwra_cohort_id, cwra_client_id, cwra_co_ids[i])</tt>.
cwra_client_id <bcp14>MUST</bcp14> be the repair actor's own
ffv2m_client_id (not CHUNK_GUARD_CLIENT_ID_MDS); the
cwra_cohort_id is the repair actor's locally chosen
per-transaction opaque identifier.  The reserved
sentinels CHUNK_GUARD_CLIENT_ID_NONE and
CHUNK_GUARD_CLIENT_ID_MDS <bcp14>MUST NOT</bcp14> appear in
cwra_client_id; see <xref target="sec-chunk_guard_none"/> and
<xref target="sec-chunk_guard_mds"/>.  Within a single
(cwra_cohort_id, cwra_client_id), the cwra_co_ids
values <bcp14>MUST</bcp14> be distinct so that lifecycle operations
can name individual reconstructed chunks unambiguously
by full triple.</t>
            </dd>
            <dt>cwra_payload_id:</dt>
            <dd>
              <t>the payload-id the repair actor associates with the
reconstructed payload, used by the repair coordinator
to correlate this repair across mirrors.</t>
            </dd>
            <dt>cwra_chunk_size:</dt>
            <dd>
              <t>the nominal chunk size of the reconstructed payload,
in bytes.</t>
            </dd>
            <dt>cwra_checksums:</dt>
            <dd>
              <t>per-chunk checksum4 (<xref target="sec-checksum4"/>) array.  Semantics
match cwa_checksums in CHUNK_WRITE: each entry's
cs_algorithm <bcp14>MUST</bcp14> match ffv2m_checksum_algorithm of the
mirror named in the layout
(<xref target="sec-ffv2-mirror4"/>), with NFS4ERR_INVAL on mismatch.</t>
            </dd>
            <dt>cwra_chunks:</dt>
            <dd>
              <t>the reconstructed chunk payload as an opaque blob,
packed identically to cwa_chunks in CHUNK_WRITE.</t>
            </dd>
          </dl>
          <t>The CHUNK_WRITE_REPAIR result reports per-chunk outcomes:</t>
          <dl>
            <dt>cwrr_count:</dt>
            <dd>
              <t>the number of chunks the data server successfully
accepted.</t>
            </dd>
            <dt>cwrr_committed:</dt>
            <dd>
              <t>the stable_how4 level the data server actually applied.
<bcp14>MUST</bcp14> be at least as durable as cwra_stable.</t>
            </dd>
            <dt>cwrr_writeverf:</dt>
            <dd>
              <t>a verifier identifying the data server's incarnation.
Semantics match cwr_writeverf in CHUNK_WRITE.</t>
            </dd>
            <dt>cwrr_block_status:</dt>
            <dd>
              <t>per-chunk acceptance status, one entry per chunk in
the payload, co-indexed with cwra_co_ids and
cwrr_owners.  The top-level CHUNK_WRITE_REPAIR status
is NFS4_OK as long as the data server could evaluate
each chunk; per-chunk failures are reported in
cwrr_block_status rather than by failing the whole
operation.</t>
            </dd>
            <dt>cwrr_owners:</dt>
            <dd>
              <t>per-chunk chunk_owner4 the data server recorded, one
entry per chunk in the payload (co-indexed with
cwra_co_ids and cwrr_block_status).  Each entry is
the complete cohort triple
<tt>(cwra_cohort_id, cwra_client_id, cwra_co_ids[i])</tt>
that the data server recorded (or, for a rejected
slot, the requested triple echoed for positional
correlation with the failure status in
<tt>cwrr_block_status[i]</tt>).  The data server does NOT
synthesize per-chunk identity by modifying the
repair actor's cohort.</t>
            </dd>
          </dl>
          <t>The target chunks <bcp14>SHOULD</bcp14> be in the errored state (set by
a prior CHUNK_ERROR) or EMPTY.  If a target chunk is
COMMITTED with valid data, the data server <bcp14>MAY</bcp14> reject the
repair-write with NFS4ERR_INVAL in the corresponding
cwrr_block_status slot to prevent overwriting good data;
the repair actor <bcp14>SHOULD</bcp14> re-verify the chunk before
attempting another repair-write on the same range.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-10">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the repair-write succeeded.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the layout stateid or credentials are not
permitted to write repair data to this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>no active layout stateid for this file (or, in trusted stateid
tight coupling, the stateid is not in the trust table).  See
<xref target="sec-new-ops"/>.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_FHEXPIRED:</dt>
            <dd>
              <t>the current filehandle has expired.</t>
            </dd>
            <dt>NFS4ERR_IO:</dt>
            <dd>
              <t>an I/O error occurred while persisting the repair
data.</t>
            </dd>
            <dt>NFS4ERR_NOSPC:</dt>
            <dd>
              <t>there is insufficient space at the data server.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_WRITE_REPAIR.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
            <dt>NFS4ERR_STALE:</dt>
            <dd>
              <t>the current filehandle no longer identifies a
valid file.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-TRUST_STATEID">
        <name>Operation 89: TRUST_STATEID - Register Layout Stateid on Data Server</name>
        <section anchor="arguments-11">
          <name>ARGUMENTS</name>
          <figure anchor="fig-TRUST_STATEID4args">
            <name>XDR for TRUST_STATEID4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct TRUST_STATEID4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        tsa_layout_stateid;
   ///     clientid4       tsa_pnfs_clientid;
   ///     uint32_t        tsa_client_id;
   ///     layoutiomode4   tsa_iomode;
   ///     nfstime4        tsa_expire;
   ///     utf8str_cs      tsa_principal;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-11">
          <name>RESULTS</name>
          <figure anchor="fig-TRUST_STATEID4res">
            <name>XDR for TRUST_STATEID4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union TRUST_STATEID4res switch (nfsstat4 tsr_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-11">
          <name>DESCRIPTION</name>
          <t>TRUST_STATEID registers a layout stateid with the data
server so that subsequent CHUNK operations presenting that
stateid can be validated against the data server's per-file
trust table.  The registration binds the stateid to both the
NFSv4 clientid4 whose layout is being authorized
(tsa_pnfs_clientid) and the ffv2m_client_id (tsa_client_id)
assigned to that client in the layout.  The data server keeps
those identities distinct from the metadata-server identity
that owns the control session and uses tsa_client_id to authorize
cwa_client_id on CHUNK_WRITE and cg_client_id in any
chunk_guard4 CAS (<xref target="sec-chunk_guard4"/>).  A mismatch is rejected
with NFS4ERR_BAD_STATEID.  TRUST_STATEID is the mechanism by which
tight coupling (see <xref target="sec-tight-coupling-control"/>) is established
between the metadata server and the data server for a particular
layout.</t>
          <t>TRUST_STATEID has no analog in <xref target="RFC8881"/>: pNFS layouts in
<xref target="RFC8881"/> do not register the layout stateid with data
servers; data servers in the loose coupling model trust the
synthetic uid/gid the metadata server inserts on each I/O
(<xref target="sec-Fencing-Clients"/>).  TRUST_STATEID is the new
metadata-server-to-data-server control-plane operation
that replaces synthetic-uid
fencing with per-client stateid-table validation for
deployments that opt into tight coupling.</t>
          <t>TRUST_STATEID is a metadata-server-to-data-server operation;
pNFS clients <bcp14>MUST NOT</bcp14> send it.  The data server rejects any
TRUST_STATEID received on a session whose owning client did
not present EXCHGID4_FLAG_USE_PNFS_MDS at EXCHANGE_ID with
NFS4ERR_PERM.  The flag is self-declared, so this wire-level
check is a hint, not authentication; the deployment-level
requirement -- that only entities considered legitimate
metadata servers can establish such a session -- is stated in
<xref target="sec-tight-coupling-control-session"/>.  TRUST_STATEID
operates on the current filehandle; a PUTFH naming the data
server's file <bcp14>MUST</bcp14> precede it in the same compound (except in
the capability probe case, where the current filehandle is
the root).</t>
          <t>The metadata server provides:</t>
          <dl>
            <dt>tsa_layout_stateid:</dt>
            <dd>
              <t>the stateid the metadata server issued in the
LAYOUTGET that produced this layout.  <bcp14>MUST NOT</bcp14> be a
special stateid (anonymous, invalid, read-bypass, or
current).  The sole exception is the capability probe
described in <xref target="sec-tight-coupling-probe"/>: when the
metadata server sends TRUST_STATEID with
tsa_layout_stateid set to the anonymous stateid
against the root filehandle, the data server <bcp14>MUST</bcp14>
reject the request with NFS4ERR_INVAL -- that
rejection is the positive response to the probe.</t>
            </dd>
            <dt>tsa_pnfs_clientid:</dt>
            <dd>
              <t>the NFSv4 clientid4 of the pNFS client whose layout stateid
is being registered.  The data server records this value
separately from the metadata-server clientid4 that owns the
control session.  BULK_REVOKE_STATEID uses its brsa_clientid
argument to match this target identity; a zero brsa_clientid
selects all target clients belonging to the issuing metadata
server.  For a normal registration this field <bcp14>MUST</bcp14> be non-zero;
in the capability probe it <bcp14>MUST</bcp14> be zero.</t>
            </dd>
            <dt>tsa_client_id:</dt>
            <dd>
              <t>the ffv2m_client_id (<xref target="sec-ffv2-mirror4"/>) the
metadata server assigned to the client in the
layout that produced tsa_layout_stateid.  The data
server records tsa_client_id alongside
tsa_layout_stateid in the trust-table entry and
uses it as the authoritative writer identity for
subsequent CHUNK operations: cwa_client_id on
CHUNK_WRITE <bcp14>MUST</bcp14> equal the
trust-table's tsa_client_id, and cg_client_id in
any chunk_guard4 CAS submitted with the same
stateid <bcp14>MUST</bcp14> also match.  A mismatch <bcp14>MUST</bcp14> be
rejected with NFS4ERR_BAD_STATEID.  In the
capability probe the metadata server <bcp14>SHOULD</bcp14> set
tsa_client_id to zero (which is the reserved
CHUNK_GUARD_CLIENT_ID_NONE, see
<xref target="sec-chunk_guard_none"/>); the data server's
NFS4ERR_INVAL response to the probe is unaffected
by the field's value.</t>
            </dd>
            <dt>tsa_iomode:</dt>
            <dd>
              <t>the iomode of the layout (LAYOUTIOMODE4_READ or
LAYOUTIOMODE4_RW).  The data server <bcp14>MAY</bcp14> enforce this
against the CHUNK operation presented later: a
READ-iomode trust entry does not authorize
CHUNK_WRITE.</t>
            </dd>
            <dt>tsa_expire:</dt>
            <dd>
              <t>the absolute time at which the trust entry becomes
invalid if not renewed; see
<xref target="sec-tight-coupling-lease"/> for the clock-synchronization
assumption and lease-computation rule.  The data server
<bcp14>MUST</bcp14> reject a TRUST_STATEID whose tsa_expire has
tv_nseconds &gt;= 10^9 with NFS4ERR_INVAL.</t>
            </dd>
            <dt>tsa_principal:</dt>
            <dd>
              <t>the client's authenticated identity as verified by
the metadata server at LAYOUTGET time.  For
RPCSEC_GSS clients this is the GSS display name
(e.g., "alice@REALM").  For AUTH_SYS and TLS
clients, tsa_principal <bcp14>MUST</bcp14> be the empty string,
indicating that no principal binding is enforced on
subsequent CHUNK operations.  See
<xref target="sec-tight-coupling-principal"/>.</t>
            </dd>
          </dl>
          <t>If a trust entry already exists for the same
tsa_layout_stateid on the same current filehandle and with the
same issuer, target, and writer identities, TRUST_STATEID
atomically updates tsa_expire and tsa_principal; this is the
renewal path (see
<xref target="sec-tight-coupling-lease"/>).</t>
          <t>At registration time the data server tags the new trust
entry with the identity of the metadata server, derived
from the clientid4 of the owning client of the control
session on which TRUST_STATEID arrived.  This issuer tag and
tsa_pnfs_clientid are distinct fields.  REVOKE_STATEID
matches the issuer tag together with the current filehandle
and stateid; BULK_REVOKE_STATEID matches the issuer tag and
its brsa_clientid target.  In a multi-metadata-server
deployment sharing a single data server, each metadata server
registers and revokes only its own entries; neither identity is
inferred from or folded into tsa_client_id.</t>
          <t>TRUST_STATEID returns only a top-level status; there is
no result body beyond the nfsstat4 discriminant.</t>
          <t>If the current filehandle is not an ordinary file
(except in the capability-probe case, where the current
filehandle is the root and the operation is expected to
be rejected with NFS4ERR_INVAL), an error <bcp14>MUST</bcp14> be
returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-11">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the trust entry is registered (or updated).</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>tsa_layout_stateid was a special stateid
other than the anonymous stateid on the root filehandle.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request; the metadata server <bcp14>SHOULD</bcp14> retry.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>tsa_layout_stateid was the anonymous stateid
and the current filehandle is not the root filehandle;
tsa_expire is malformed; or the current filehandle is a
directory (except in the capability-probe case).</t>
            </dd>
            <dt>NFS4ERR_NOFILEHANDLE:</dt>
            <dd>
              <t>no current filehandle is set.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
TRUST_STATEID.  This is the capability-probe response (see
<xref target="sec-tight-coupling-probe"/>).</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-REVOKE_STATEID">
        <name>Operation 90: REVOKE_STATEID - Revoke Registered Stateid on Data Server</name>
        <section anchor="arguments-12">
          <name>ARGUMENTS</name>
          <figure anchor="fig-REVOKE_STATEID4args">
            <name>XDR for REVOKE_STATEID4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct REVOKE_STATEID4args {
   ///     /* CURRENT_FH: file */
   ///     stateid4        rsa_layout_stateid;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-12">
          <name>RESULTS</name>
          <figure anchor="fig-REVOKE_STATEID4res">
            <name>XDR for REVOKE_STATEID4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union REVOKE_STATEID4res switch (nfsstat4 rsr_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-12">
          <name>DESCRIPTION</name>
          <t>REVOKE_STATEID invalidates a single trust entry on the
data server.  Subsequent CHUNK operations that present
the revoked stateid <bcp14>MUST</bcp14> fail with NFS4ERR_BAD_STATEID.
REVOKE_STATEID is the per-file revoke counterpart to
TRUST_STATEID -- registration and
revocation form the matched pair that drives the per-file
trust table for a tightly coupled deployment.</t>
          <t>REVOKE_STATEID has no analog in <xref target="RFC8881"/>.  <xref target="RFC8881"/>
revokes pNFS layouts via LAYOUTRETURN with a special
all-files marker or via implicit lease expiry;
REVOKE_STATEID is the new metadata-server-to-data-server operation
that lets the metadata server force per-client invalidation at the
data
server without waiting for tsa_expire and without
unsetting other clients' trust entries.</t>
          <t>REVOKE_STATEID is a metadata-server-to-data-server operation;
pNFS clients <bcp14>MUST NOT</bcp14> send it.  The data server rejects any
REVOKE_STATEID received on a session whose owning client did
not present EXCHGID4_FLAG_USE_PNFS_MDS at EXCHANGE_ID with
NFS4ERR_PERM.  The flag is self-declared, so this wire-level
check is a hint, not authentication; the deployment-level
requirement is stated in
<xref target="sec-tight-coupling-control-session"/>.  REVOKE_STATEID
operates on the current filehandle; a PUTFH naming the data
server's file <bcp14>MUST</bcp14> precede it in the same compound.</t>
          <t>The metadata server provides:</t>
          <dl>
            <dt>rsa_layout_stateid:</dt>
            <dd>
              <t>the stateid to revoke.  Together with the current
filehandle this identifies the trust entry to remove.
<bcp14>MUST NOT</bcp14> be a special stateid; the anonymous stateid
is rejected with NFS4ERR_INVAL and other special
stateids with NFS4ERR_BAD_STATEID.</t>
            </dd>
          </dl>
          <t>The metadata server calls REVOKE_STATEID in any of the
following situations:</t>
          <dl>
            <dt>CB_LAYOUTRECALL timeout:</dt>
            <dd>
              <t>the client did not return the layout within the recall
timeout.  REVOKE_STATEID terminates the client's ability
to issue further I/O to the data server without waiting
for tsa_expire.</t>
            </dd>
            <dt>LAYOUTERROR with NFS4ERR_ACCESS or NFS4ERR_PERM:</dt>
            <dd>
              <t>the data server rejected the client's I/O; the trust entry
is stale and must be removed.  This mirrors the fencing
case in the loose-coupled model (<xref target="sec-Fencing-Clients"/>).</t>
            </dd>
            <dt>Explicit LAYOUTRETURN:</dt>
            <dd>
              <t>the client returned the layout cleanly.  The metadata
server <bcp14>MAY</bcp14> issue REVOKE_STATEID at this time or <bcp14>MAY</bcp14> rely
on tsa_expire; either is correct.</t>
            </dd>
          </dl>
          <t>In-flight CHUNK operations that arrived before
REVOKE_STATEID completes <bcp14>MAY</bcp14> be allowed to finish.  The
data server <bcp14>MUST NOT</bcp14> process new CHUNK operations
presenting rsa_layout_stateid after REVOKE_STATEID
returns.</t>
          <t>Lock state (see <xref target="sec-CHUNK_LOCK"/>) held by the revoked
stateid is NOT released as part of REVOKE_STATEID; the
data server <bcp14>MUST</bcp14> transfer each held lock to the
metadata-server escrow owner (see <xref target="sec-chunk_guard_mds"/>).
Dropping a chunk lock during revocation would permit a
write hole and is prohibited; the repair coordination
sequence in <xref target="sec-repair-selection"/> assumes that locks
held by a revoked writer remain held until a repair
client adopts them via CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT.</t>
          <t>REVOKE_STATEID is scoped to the issuing metadata
server's entries (see the tagging rule in
<xref target="sec-TRUST_STATEID"/>).  The data server <bcp14>MUST NOT</bcp14>
remove an entry that was registered by a different
metadata server, even if rsa_layout_stateid happens to
match.  In a multi-metadata-server deployment, one
metadata server therefore cannot revoke another
metadata server's entries.</t>
          <t>REVOKE_STATEID is idempotent: revoking a stateid that
has no matching trust entry (either no entry exists, or
the entry was registered by a different metadata
server) returns NFS4_OK.  The metadata server therefore
does not need to track precisely which entries are
currently live on which data server in order to revoke
safely.</t>
          <t>REVOKE_STATEID returns only a top-level status; there
is no result body beyond the nfsstat4 discriminant.</t>
          <t>If the current filehandle is not an ordinary file, an
error <bcp14>MUST</bcp14> be returned (NFS4ERR_ISDIR / NFS4ERR_SYMLINK /
NFS4ERR_WRONG_TYPE for non-regular; NFS4ERR_NOTSUPP if
the file is a regular file but not a chunked data file,
per <xref target="sec-ops-client"/>).</t>
        </section>
        <section anchor="response-codes-12">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the trust entry was removed, or no matching entry
existed (idempotent).</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_BAD_STATEID:</dt>
            <dd>
              <t>rsa_layout_stateid was a special stateid.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>rsa_layout_stateid was the anonymous stateid.</t>
            </dd>
            <dt>NFS4ERR_NOFILEHANDLE:</dt>
            <dd>
              <t>no current filehandle is set.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
REVOKE_STATEID.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-BULK_REVOKE_STATEID">
        <name>Operation 91: BULK_REVOKE_STATEID - Revoke All Stateids for a Client</name>
        <section anchor="arguments-13">
          <name>ARGUMENTS</name>
          <figure anchor="fig-BULK_REVOKE_STATEID4args">
            <name>XDR for BULK_REVOKE_STATEID4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct BULK_REVOKE_STATEID4args {
   ///     clientid4       brsa_clientid;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-13">
          <name>RESULTS</name>
          <figure anchor="fig-BULK_REVOKE_STATEID4res">
            <name>XDR for BULK_REVOKE_STATEID4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union BULK_REVOKE_STATEID4res switch (nfsstat4 brsr_status) {
   ///     case NFS4_OK:
   ///         void;
   ///     default:
   ///         void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-13">
          <name>DESCRIPTION</name>
          <t>BULK_REVOKE_STATEID removes every trust entry on the data
server that was registered on behalf of a single named
client.  Unlike REVOKE_STATEID,
which removes one entry identified by a (filehandle,
stateid) pair, BULK_REVOKE_STATEID does not target a
specific filehandle or stateid; it instructs the data
server to scan its trust table and remove every entry
whose owning pNFS client matches brsa_clientid (and whose
issuing metadata server matches the calling metadata server).</t>
          <t>BULK_REVOKE_STATEID has no analog in <xref target="RFC8881"/>.  <xref target="RFC8881"/>
recall-all is expressed at the layout layer
(CB_LAYOUTRECALL with LAYOUTRECALL4_ALL); the per-client
trust-table sweep introduced here is the data-server-side
complement, replacing the N per-file REVOKE_STATEID
compounds that per-entry revocation would require with a
single round-trip.</t>
          <t>BULK_REVOKE_STATEID is a metadata-server-to-data-server
operation; pNFS clients <bcp14>MUST NOT</bcp14> send it.  The data server
rejects any BULK_REVOKE_STATEID received on a session whose
owning client did not present EXCHGID4_FLAG_USE_PNFS_MDS at
EXCHANGE_ID with NFS4ERR_PERM.  The flag is self-declared, so
this wire-level check is a hint, not authentication; the
deployment-level requirement is stated in
<xref target="sec-tight-coupling-control-session"/>.  BULK_REVOKE_STATEID
does not operate on the current filehandle; no PUTFH is
required in the compound.</t>
          <t>The metadata server provides:</t>
          <dl>
            <dt>brsa_clientid:</dt>
            <dd>
              <t>the clientid of the pNFS client whose trust entries
are to be removed.  The special all-zeros value means
"remove every trust entry owned by the calling
metadata server, regardless of which pNFS client
registered it"; the data server <bcp14>MUST</bcp14> interpret this
value as a sweep of its own entries only, NOT as the
pNFS client whose clientid happens to be zero and NOT
as a global cross-metadata-server table clear.</t>
            </dd>
          </dl>
          <t>The metadata server calls BULK_REVOKE_STATEID in any of
the following situations:</t>
          <dl>
            <dt>Client lease expiry:</dt>
            <dd>
              <t>when a client's lease on the metadata server expires, the
metadata server revokes all of that client's layouts.  A
single BULK_REVOKE_STATEID with brsa_clientid set to the
expired client's clientid sweeps every per-file trust entry
the metadata server had registered for that client.</t>
            </dd>
            <dt>CB_LAYOUTRECALL with LAYOUTRECALL4_ALL:</dt>
            <dd>
              <t>the metadata server is recalling all layouts for a client.
BULK_REVOKE_STATEID is the data-server-side complement.</t>
            </dd>
            <dt>Metadata server restart cleanup:</dt>
            <dd>
              <t>after the metadata server reconnects to a data server, it
<bcp14>MAY</bcp14> issue BULK_REVOKE_STATEID with brsa_clientid set to
all-zeros to clear the prior trust table before re-issuing
TRUST_STATEID as clients reclaim.  See
<xref target="sec-tight-coupling-mds-crash"/>.</t>
            </dd>
          </dl>
          <t>BULK_REVOKE_STATEID is scoped to the issuing metadata
server's entries (see the tagging rule in
<xref target="sec-TRUST_STATEID"/>).  The data server <bcp14>MUST NOT</bcp14> affect
entries registered by a different metadata server.
Consequently, in a multi-metadata-server deployment
sharing a single data server, one metadata server cannot
clear another metadata server's entries via
BULK_REVOKE_STATEID.</t>
          <t>Like REVOKE_STATEID, BULK_REVOKE_STATEID is idempotent
(no error is returned if there are no matching entries)
and preserves chunk locks held under any revoked stateid
by transferring them to the metadata-server escrow owner (see
<xref target="sec-chunk_guard_mds"/>), rather than dropping them.
Subsequent CHUNK operations from the revoked client
fail with NFS4ERR_BAD_STATEID; locks held under those
revoked stateids remain until adopted by a repair
client via CHUNK_LOCK with CHUNK_LOCK_FLAGS_ADOPT
(<xref target="sec-CHUNK_LOCK"/>).</t>
          <t>BULK_REVOKE_STATEID returns only a top-level status;
there is no result body beyond the nfsstat4 discriminant.</t>
        </section>
        <section anchor="response-codes-13">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the matching entries were removed, or there were
none (idempotent).</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>the data server is temporarily unable to process
the request.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
BULK_REVOKE_STATEID.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS.</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing
the request.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ESCROW_INSTALL">
        <name>Operation 92: CHUNK_ESCROW_INSTALL - Install a metadata-server escrow lock</name>
        <section anchor="arguments-14">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ESCROW_INSTALL4args">
            <name>XDR for CHUNK_ESCROW_INSTALL4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ESCROW_INSTALL4args {
   ///     /* CURRENT_FH: file */
   ///     uint64_t        ceia_mds_epoch;
   ///     offset4         ceia_offset;
   ///     count4          ceia_count;
   ///     escrow_id4      ceia_escrow_id;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-14">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ESCROW_INSTALL4res">
            <name>XDR for CHUNK_ESCROW_INSTALL4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_ESCROW_INSTALL4res
   ///     switch (nfsstat4 ceir_status) {
   /// case NFS4_OK:
   ///     escrow_id4      ceir_escrow_id;
   /// default:
   ///     void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-14">
          <name>DESCRIPTION</name>
          <t>CHUNK_ESCROW_INSTALL is sent by the metadata server
to a data server on the metadata-server-to-data-server control session to
install a metadata-server escrow lock (<xref target="sec-chunk_guard_mds"/>)
over the chunk range [ceia_offset,
ceia_offset+ceia_count) on the file selected by
CURRENT_FH.  The lock is created with the specified
ceia_escrow_id, which the metadata server will later
present to reference this specific installation on
CHUNK_ESCROW_RELEASE,
in CB_CHUNK_REPAIR, and in
the corresponding CHUNK_LOCK adoption
(<xref target="sec-CHUNK_LOCK"/>).</t>
          <t>ceia_mds_epoch is the metadata server's current
epoch on this data server; the data server rejects
the operation with NFS4ERR_STALE_MDS_EPOCH
(<xref target="sec-NFS4ERR_STALE_MDS_EPOCH"/>) if the epoch does
not match its recorded value or if the current
epoch's expires_at has passed.</t>
          <t>The install is all-or-nothing across the range: if
any chunk in [ceia_offset, ceia_offset+ceia_count)
carries an incompatible existing lock, the operation
fails with the corresponding per-chunk error at the
operation level (typically NFS4ERR_CHUNK_LOCKED).</t>
          <t>On success, ceir_escrow_id echoes ceia_escrow_id
to confirm the identity the data server recorded.
The metadata server <bcp14>MUST</bcp14> retain this identity in
its durable escrow-tuple set before issuing the
call and <bcp14>MUST NOT</bcp14> reuse an escrow_id4 whose
lifecycle is not provably complete
(<xref target="sec-escrow_id4"/>).</t>
        </section>
        <section anchor="response-codes-14">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the metadata-server escrow lock has been installed
over the requested range with the specified escrow_id4.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the metadata server is not authorized to install
escrows on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_CHUNK_LOCKED:</dt>
            <dd>
              <t>a chunk in [ceia_offset, ceia_offset + ceia_count)
carries an incompatible existing lock; the install
is all-or-nothing across the range.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>ceia_offset or ceia_count is malformed, or
ceia_escrow_id is the reserved all-zeros value.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_ESCROW_INSTALL.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS
(see <xref target="sec-tight-coupling-control-session"/>).</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing the
request.</t>
            </dd>
            <dt>NFS4ERR_STALE_MDS_EPOCH:</dt>
            <dd>
              <t>ceia_mds_epoch does not match the data server's
recorded value, or the current epoch's
epoch_expires_at has passed.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ESCROW_RELEASE">
        <name>Operation 93: CHUNK_ESCROW_RELEASE - Release a metadata-server escrow lock</name>
        <section anchor="arguments-15">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ESCROW_RELEASE4args">
            <name>XDR for CHUNK_ESCROW_RELEASE4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ESCROW_RELEASE4args {
   ///     /* CURRENT_FH: file */
   ///     uint64_t        cera_mds_epoch;
   ///     offset4         cera_offset;
   ///     count4          cera_count;
   ///     escrow_id4      cera_escrow_id;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-15">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ESCROW_RELEASE4res">
            <name>XDR for CHUNK_ESCROW_RELEASE4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_ESCROW_RELEASE4res
   ///     switch (nfsstat4 cerr_status) {
   /// case NFS4_OK:
   ///     void;
   /// default:
   ///     void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-15">
          <name>DESCRIPTION</name>
          <t>CHUNK_ESCROW_RELEASE is sent by the metadata server
to release a metadata-server escrow lock it previously
installed with CHUNK_ESCROW_INSTALL.  The release is
compare-and-release: the operation succeeds only
when an escrow lock covering the requested range
exists on the data server AND its escrow_id4
matches cera_escrow_id.  If no escrow covers the
range, or the covering escrow's identity differs,
the data server returns NFS4ERR_STALE_ESCROW
(<xref target="sec-NFS4ERR_STALE_ESCROW"/>) and <bcp14>MUST NOT</bcp14> alter
any current lock or escrow state as a side effect.</t>
          <t>The compare-and-release rule ensures that a
metadata server which has been superseded by a
newer incarnation cannot release an escrow the
newer incarnation has since re-installed under a
different identity.</t>
          <t>cera_mds_epoch is treated as in
<xref target="sec-CHUNK_ESCROW_INSTALL"/>; a stale epoch returns
NFS4ERR_STALE_MDS_EPOCH.</t>
          <t>Interaction with adopted locks (see
<xref target="sec-chunk_guard_mds"/>): if a repair actor has
already adopted this escrow via CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT (<xref target="sec-CHUNK_LOCK"/>), the
escrow no longer exists on the data server as a
distinct lock (the adoption consumes it and
transfers ownership to the client); a subsequent
CHUNK_ESCROW_RELEASE naming that identity returns
NFS4ERR_STALE_ESCROW and <bcp14>MUST NOT</bcp14> affect the
client-owned adopted lock.  The metadata server
interprets NFS4ERR_STALE_ESCROW after possible
adoption as "the escrow was consumed by ADOPT;
wait for the CB_CHUNK_REPAIR response or a
subsequent revocation-transfer signal before
removing durable escrow-tuple bookkeeping."</t>
        </section>
        <section anchor="response-codes-15">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the metadata-server escrow lock matching
cera_escrow_id has been released.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the metadata server is not authorized to release
escrows on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>cera_offset or cera_count is malformed.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_ESCROW_RELEASE.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS
(see <xref target="sec-tight-coupling-control-session"/>).</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing the
request.</t>
            </dd>
            <dt>NFS4ERR_STALE_ESCROW:</dt>
            <dd>
              <t>no escrow covers the requested range, or the
covering escrow's identity differs from
cera_escrow_id (which may indicate the escrow
was consumed by CHUNK_LOCK adoption); the data
server <bcp14>MUST NOT</bcp14> alter any current lock or
escrow state as a side effect.</t>
            </dd>
            <dt>NFS4ERR_STALE_MDS_EPOCH:</dt>
            <dd>
              <t>cera_mds_epoch does not match the data server's
recorded value, or the current epoch's
epoch_expires_at has passed.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ESCROW_ENUMERATE">
        <name>Operation 94: CHUNK_ESCROW_ENUMERATE - Enumerate metadata-server escrow locks on a file</name>
        <section anchor="arguments-16">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ESCROW_ENUMERATE4args">
            <name>XDR for CHUNK_ESCROW_ENUMERATE4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// /* Upper bound on the ENUMERATE pagination
   ///  * cookie length, applied to both the request
   ///  * ceea_cookie and the response ceer_cookie.
   ///  */
   /// const CHUNK_ESCROW_ENUMERATE_COOKIE_MAX4 = 256;
   ///
   /// struct CHUNK_ESCROW_ENUMERATE4args {
   ///     /* CURRENT_FH: file */
   ///     uint64_t        ceea_mds_epoch;
   ///     offset4         ceea_offset;
   ///     count4          ceea_count;
   ///     uint32_t        ceea_maxcount;
   ///     opaque
   ///         ceea_cookie<CHUNK_ESCROW_ENUMERATE_COOKIE_MAX4>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-16">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ESCROW_ENUMERATE4res">
            <name>XDR for CHUNK_ESCROW_ENUMERATE4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// /* Upper bound on the number of escrow_enum_entry4
   ///  * values returned in a single ENUMERATE call.
   ///  * Bounds ceer_entries; the caller may still page
   ///  * via ceer_cookie for larger snapshots.
   ///  */
   /// const CHUNK_ESCROW_ENUMERATE_MAX4 = 256;
   ///
   /// struct escrow_enum_entry4 {
   ///     offset4         eee_offset;
   ///     count4          eee_count;
   ///     escrow_id4      eee_escrow_id;
   /// };
   ///
   /// struct CHUNK_ESCROW_ENUMERATE4resok {
   ///     bool                 ceer_eof;
   ///     opaque
   ///         ceer_cookie<CHUNK_ESCROW_ENUMERATE_COOKIE_MAX4>;
   ///     escrow_enum_entry4
   ///         ceer_entries<CHUNK_ESCROW_ENUMERATE_MAX4>;
   /// };
   ///
   /// union CHUNK_ESCROW_ENUMERATE4res
   ///     switch (nfsstat4 ceer_status) {
   /// case NFS4_OK:
   ///     CHUNK_ESCROW_ENUMERATE4resok ceer_resok4;
   /// default:
   ///     void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-16">
          <name>DESCRIPTION</name>
          <t>CHUNK_ESCROW_ENUMERATE is sent by the metadata
server to discover which metadata-server escrow locks the
data server currently holds on the file selected
by CURRENT_FH.  Each returned entry names an
installed escrow's range and identity.</t>
          <t>ceea_offset and ceea_count bound the inspection
range; ceea_maxcount is the maximum number of
entries the caller is willing to receive
(ceea_maxcount = 0 is legal and is the
op-family capability probe: the data server <bcp14>MUST</bcp14>
return NFS4_OK with an empty ceer_entries array
and ceer_eof = TRUE when it implements the
operation, regardless of any escrows present.
A data server that does not implement the
operation returns NFS4ERR_OP_ILLEGAL at COMPOUND
decode time per <xref section="16.2" sectionFormat="of" target="RFC8881"/>, which is
distinct from NFS4ERR_NOTSUPP).</t>
          <t>Pagination uses ceea_cookie: on the first call the
caller supplies an empty cookie; the data server
returns a snapshot verifier-plus-cursor in
ceer_cookie that the caller supplies on the next
call to continue enumeration.  The data server
<bcp14>MUST</bcp14> return a verifier-consistent snapshot: no
escrow installed after the first call in a
pagination sequence appears in subsequent calls,
and no escrow released after the first call
disappears from subsequent calls (implementations
may achieve this by snapshotting the escrow set
at first-call time and streaming from the
snapshot).  ceer_eof = TRUE signals the end of
the enumeration.</t>
          <t>Non-mutating: the operation observes but does not
modify escrow state.</t>
          <t>ceea_mds_epoch is treated as in the sibling
operations; a stale epoch returns
NFS4ERR_STALE_MDS_EPOCH.</t>
        </section>
        <section anchor="response-codes-16">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the requested escrow enumeration entries have
been returned; ceer_eof indicates whether more
remain.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>the metadata server is not authorized to
enumerate escrows on this file.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded, or ceea_cookie
is malformed.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>ceea_offset, ceea_count, or ceea_maxcount is
malformed, or ceea_cookie references a snapshot
the data server no longer holds.</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_ESCROW_ENUMERATE.  See the
ceea_maxcount = 0 op-family capability probe in
the description for the distinction from
NFS4ERR_OP_ILLEGAL at COMPOUND decode time.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS
(see <xref target="sec-tight-coupling-control-session"/>).</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing the
request.</t>
            </dd>
            <dt>NFS4ERR_STALE_MDS_EPOCH:</dt>
            <dd>
              <t>ceea_mds_epoch does not match the data server's
recorded value, or the current epoch's
epoch_expires_at has passed.</t>
            </dd>
          </dl>
        </section>
      </section>
      <section anchor="sec-CHUNK_ESCROW_TAKEOVER">
        <name>Operation 95: CHUNK_ESCROW_TAKEOVER - Advance metadata-server epoch after incarnation change</name>
        <section anchor="arguments-17">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CHUNK_ESCROW_TAKEOVER4args">
            <name>XDR for CHUNK_ESCROW_TAKEOVER4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CHUNK_ESCROW_TAKEOVER4args {
   ///     /* CURRENT_FH: file (implementation-defined;
   ///      * the operation is per-data-server, not
   ///      * per-file; CURRENT_FH is provided per
   ///      * NFSv4.2 COMPOUND convention). */
   ///     uint64_t             ceta_expected_prior_epoch;
   ///     uint64_t             ceta_new_epoch;
   ///     proof_profile_id4    ceta_proof_profile;
   ///     opaque
   ///         ceta_proof_data<CETA_INCARNATION_PROOF_MAX4>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-17">
          <name>RESULTS</name>
          <figure anchor="fig-CHUNK_ESCROW_TAKEOVER4res">
            <name>XDR for CHUNK_ESCROW_TAKEOVER4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// union CHUNK_ESCROW_TAKEOVER4res
   ///     switch (nfsstat4 cetar_status) {
   /// case NFS4_OK:
   ///     void;
   /// default:
   ///     void;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-17">
          <name>DESCRIPTION</name>
          <t>CHUNK_ESCROW_TAKEOVER is the recovery path a
metadata server uses to assume the escrow-control
role on a data server after an incarnation change
(a failover, a restart, or an operator-mediated
recovery).  It carries an incarnation-lease proof
issued by an authority external to the metadata
server (see <xref target="sec-proof-profile"/>) which the data
server verifies before advancing its recorded
metadata-server epoch.</t>
          <t>The operation is a compare-and-advance:</t>
          <ul spacing="normal">
            <li>
              <t>ceta_expected_prior_epoch <bcp14>MUST</bcp14> equal the data
server's currently-recorded metadata-server
epoch;</t>
            </li>
            <li>
              <t>ceta_new_epoch <bcp14>MUST</bcp14> either exceed the prior
epoch (ordinary takeover / advance) or equal the
prior epoch when the caller is renewing the
lease under the same incarnation (renewal
form; both values equal the data server's
current epoch, and only the epoch_expires_at
field is refreshed);</t>
            </li>
            <li>
              <t>ceta_proof_profile <bcp14>MUST</bcp14> name a profile the data
server supports; and</t>
            </li>
            <li>
              <t>ceta_proof_data <bcp14>MUST</bcp14> verify under that profile
per <xref target="sec-proof-profile"/>.</t>
            </li>
          </ul>
          <t>All four conditions are evaluated atomically; on
success the data server updates its recorded
epoch and epoch_expires_at values in a single
step, and subsequent CHUNK_ESCROW_INSTALL,
CHUNK_ESCROW_RELEASE, and CHUNK_ESCROW_ENUMERATE
operations from the new epoch are accepted.
Concurrent takeovers serialize: exactly one
same-expected-prior request wins, and any other
sees NFS4ERR_STALE_MDS_EPOCH on its second
attempt because the prior has advanced.</t>
          <t>The strict evaluation order per
<xref target="sec-proof-profile"/> is followed:
session-replay-cache lookup first, then
presenter authorization (NFS4ERR_ACCESS on
failure), then profile support (NFS4ERR_NOTSUPP
on unknown profile), then proof verification
(NFS4ERR_ACCESS on failure), then epoch
compare-and-advance (NFS4ERR_STALE_MDS_EPOCH on
mismatch).  This ordering ensures unauthenticated
callers learn nothing about supported profiles
or current epoch state.</t>
          <t>Unlike the other CHUNK_ESCROW operations,
CHUNK_ESCROW_TAKEOVER is EXEMPT from the
ongoing epoch_expires_at check applied to
INSTALL, RELEASE, and ENUMERATE: TAKEOVER is
itself the recovery path out of an expired
epoch and carries its own compare-and-advance +
proof-verification semantics.  A metadata server
that has been fenced by a superseding takeover
cannot recover by presenting another
CHUNK_ESCROW_TAKEOVER unless it obtains a valid
fresh incarnation-lease proof from the
authority.</t>
          <t>Older escrow state is NOT invalidated by an
epoch advance: escrows installed under the prior
epoch survive; the new incarnation reconciles
them via CHUNK_ESCROW_ENUMERATE and adopts,
releases, or reissues each per its durable
recovery state.  Fencing applies to control
traffic on old epochs, not to the state those
epochs installed.</t>
        </section>
        <section anchor="response-codes-17">
          <name>RESPONSE CODES</name>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>the metadata server epoch has been advanced to
ceta_new_epoch, or refreshed under the renewal
form.</t>
            </dd>
            <dt>NFS4ERR_ACCESS:</dt>
            <dd>
              <t>presenter authorization or incarnation-lease
proof verification failed.  Per
<xref target="sec-proof-profile"/>, this outcome is returned
both for authorization failure and for proof
failure so that unauthenticated callers learn
nothing about supported profiles or current
epoch state.</t>
            </dd>
            <dt>NFS4ERR_BADXDR:</dt>
            <dd>
              <t>arguments could not be decoded, or ceta_proof_data
is structurally malformed.</t>
            </dd>
            <dt>NFS4ERR_INVAL:</dt>
            <dd>
              <t>ceta_expected_prior_epoch or ceta_new_epoch is
malformed (for example, ceta_new_epoch precedes
ceta_expected_prior_epoch and does not equal it
under the renewal form).</t>
            </dd>
            <dt>NFS4ERR_NOTSUPP:</dt>
            <dd>
              <t>the data server does not implement
CHUNK_ESCROW_TAKEOVER, or the presented
ceta_proof_profile is unknown to the data
server.</t>
            </dd>
            <dt>NFS4ERR_PERM:</dt>
            <dd>
              <t>the request arrived on a session whose owning
client did not present EXCHGID4_FLAG_USE_PNFS_MDS
(see <xref target="sec-tight-coupling-control-session"/>).</t>
            </dd>
            <dt>NFS4ERR_SERVERFAULT:</dt>
            <dd>
              <t>the data server failed while processing the
request.</t>
            </dd>
            <dt>NFS4ERR_STALE_MDS_EPOCH:</dt>
            <dd>
              <t>ceta_expected_prior_epoch does not match the
data server's recorded value; a concurrent
TAKEOVER has already advanced past it, or the
caller has been fenced by a superseding
takeover.</t>
            </dd>
          </dl>
        </section>
      </section>
    </section>
    <section anchor="new-nfsv42-callback-operations">
      <name>New NFSv4.2 Callback Operations</name>
      <figure anchor="fig-cb-ops-xdr">
        <name>Callback Operations XDR</name>
        <sourcecode type="xdr"><![CDATA[
   ///
   /// /* New callback operations for Erasure Coding start here */
   ///
   ///  OP_CB_CHUNK_REPAIR     = 16,
   ///
]]></sourcecode>
      </figure>
      <t>The following amendment blocks extend the nfs_cb_argop4 and
nfs_cb_resop4 dispatch unions defined in <xref target="RFC7863"/> with arms
for the new callback operation defined in this document.</t>
      <figure anchor="fig-nfs_cb_argop4-amend">
        <name>nfs_cb_argop4 amendment block</name>
        <sourcecode type="xdr"><![CDATA[
   /// /* nfs_cb_argop4 amendment block */
   ///
   /// case OP_CB_CHUNK_REPAIR: CB_CHUNK_REPAIR4args opcbchunkrepair;
]]></sourcecode>
      </figure>
      <figure anchor="fig-nfs_cb_resop4-amend">
        <name>nfs_cb_resop4 amendment block</name>
        <sourcecode type="xdr"><![CDATA[
   /// /* nfs_cb_resop4 amendment block */
   ///
   /// case OP_CB_CHUNK_REPAIR: CB_CHUNK_REPAIR4res opcbchunkrepair;
]]></sourcecode>
      </figure>
      <section anchor="sec-CB_CHUNK_REPAIR">
        <name>Callback Operation 16: CB_CHUNK_REPAIR - Request Repair of Inconsistent Chunk Ranges</name>
        <section anchor="arguments-18">
          <name>ARGUMENTS</name>
          <figure anchor="fig-CB_CHUNK_REPAIR4args">
            <name>XDR for CB_CHUNK_REPAIR4args</name>
            <sourcecode type="xdr"><![CDATA[
   /// enum cb_chunk_repair_reason4 {
   ///     CB_REPAIR_REASON_RACE  = 1,
   ///     CB_REPAIR_REASON_SCRUB = 2
   /// };
   ///
   /// struct cb_chunk_range4 {
   ///     offset4         ccr_offset;
   ///     count4          ccr_count;
   ///     nfsstat4        ccr_error;
   /// };
   ///
   /// /* Upper bound on the number of ranges named in a
   ///  * single CB_CHUNK_REPAIR (bounds both ccra_ranges
   ///  * and its co-indexed ccrr_range_status).  A repair
   ///  * batch that exceeds this bound is split across
   ///  * multiple callbacks.
   ///  */
   /// const CB_CHUNK_REPAIR_MAX_RANGES4 = 64;
   ///
   /// struct CB_CHUNK_REPAIR4args {
   ///     nfs_fh4                     ccra_fh;
   ///     stateid4                    ccra_layout_stateid;
   ///     nfstime4                    ccra_deadline;
   ///     cb_chunk_repair_reason4     ccra_reason;
   ///     escrow_id4                  ccra_escrow_id;
   ///     cb_chunk_range4
   ///         ccra_ranges<CB_CHUNK_REPAIR_MAX_RANGES4>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="results-18">
          <name>RESULTS</name>
          <figure anchor="fig-CB_CHUNK_REPAIR4res">
            <name>XDR for CB_CHUNK_REPAIR4res</name>
            <sourcecode type="xdr"><![CDATA[
   /// struct CB_CHUNK_REPAIR4res {
   ///     nfsstat4        ccrr_status;
   ///     nfsstat4
   ///         ccrr_range_status<CB_CHUNK_REPAIR_MAX_RANGES4>;
   /// };
]]></sourcecode>
          </figure>
        </section>
        <section anchor="description-18">
          <name>DESCRIPTION</name>
          <t>CB_CHUNK_REPAIR is the back-channel by which the metadata
server delivers a repair work item to a repair actor it has
selected per <xref target="sec-repair-selection"/>.  The work item names
one or more non-atomic chunk ranges on the file's data
servers for the repair actor to reconstruct or roll back.
The selection rules in <xref target="sec-repair-selection"/> are
normative for how a client <bcp14>MUST</bcp14> respond on receipt of this
callback.</t>
          <t>CB_CHUNK_REPAIR has no analog in <xref target="RFC8881"/>.  <xref target="RFC8881"/>
back-channel callbacks operate at the layout layer
(CB_LAYOUTRECALL) or the file-state layer (CB_RECALL,
CB_NOTIFY); CB_CHUNK_REPAIR is the new chunk-layer
callback that drives reconstruction or rollback of
non-atomic chunks without requiring a full layout return.</t>
          <t>The metadata server provides:</t>
          <dl>
            <dt>ccra_fh:</dt>
            <dd>
              <t>the filehandle of the file whose chunks are non-atomic.
The callback compound carries the filehandle directly;
there is no preceding PUTFH in callback compounds.</t>
            </dd>
            <dt>ccra_layout_stateid:</dt>
            <dd>
              <t>the recipient client's current layout stateid for the
file if one is held.  A client that does not hold a
layout on ccra_fh <bcp14>MUST</bcp14> ignore ccra_layout_stateid (it
will be the anonymous stateid in that case) and <bcp14>MUST</bcp14>
acquire one via LAYOUTGET before issuing any CHUNK
operation on the ranges.</t>
            </dd>
            <dt>ccra_deadline:</dt>
            <dd>
              <t>an absolute nfstime4 (seconds and nanoseconds since
the epoch, as defined in <xref section="3.3.1" sectionFormat="of" target="RFC8881"/>)
by which the client is expected to have driven every
range to completion (CHUNK_REPAIRED on the
reconstruction path, or CHUNK_UNLOCK on the rollback
path).  As with <tt>tsa_expire</tt>
(<xref target="sec-tight-coupling-lease"/>), the wall-clock
representation assumes the metadata server and the
repair actor maintain clock synchronization within one
metadata-server lease period (see the clock-sync
paragraph in <xref target="sec-tight-coupling-lease"/> for the
deployment options when this cannot be guaranteed);
under skew, missing the deadline is not
safety-critical because state cannot be corrupted, but
spurious deadline expiry <bcp14>SHOULD</bcp14> be avoided by setting
<tt>ccra_deadline</tt> to at least (current-wall-clock +
deadline-budget + expected-skew).
Missing the deadline does not corrupt state -- the
metadata server <bcp14>MAY</bcp14> re-select another repair actor
after the deadline elapses -- but a client that has
missed the deadline <bcp14>MUST</bcp14> re-verify its layout and the
chunk lock state before continuing any repair-related
CHUNK operation.</t>
            </dd>
            <dt>ccra_reason:</dt>
            <dd>
              <t>distinguishes the two flows that cause the metadata
server to issue a repair callback:
</t>
              <dl>
                <dt>CB_REPAIR_REASON_RACE:</dt>
                <dd>
                  <t>A live-race repair.  A client (not necessarily the
recipient of this callback) detected a chunk-level
non-atomicity at write or read time and reported it
via LAYOUTERROR.  The metadata server is driving
repair synchronously because the affected chunk is
on the critical path of some I/O.  The recipient
<bcp14>SHOULD</bcp14> prioritize the callback over background
work.</t>
                </dd>
                <dt>CB_REPAIR_REASON_SCRUB:</dt>
                <dd>
                  <t>A background scrub.  The metadata server has
detected stale or non-atomic payloads during a
scheduled integrity sweep and is opportunistically
driving repair.  No client is currently blocked on
these ranges.  The recipient <bcp14>MAY</bcp14> schedule the
callback at lower priority than
CB_REPAIR_REASON_RACE, and <bcp14>MAY</bcp14> return NFS4ERR_DELAY
to defer repair to a more convenient time; the
metadata server will retry.</t>
                </dd>
              </dl>
              <t>The two reasons share all other semantics: the same
ccra_ranges encoding, the same response codes, the same
deadline contract.  Only the priority and retry
behavior differs.</t>
            </dd>
            <dt>ccra_escrow_id:</dt>
            <dd>
              <t>the escrow_id4 (<xref target="sec-escrow_id4"/>) of the metadata-server escrow
lock the metadata server installed to cover every
range in this callback.  The client presents this
same escrow_id4 in the cla_adopt discriminant of the
CHUNK_LOCK request that adopts the escrow (see
<xref target="sec-CHUNK_LOCK"/> "Lock Transfer via
CHUNK_LOCK_FLAGS_ADOPT"); the data server matches on
full identity, so a callback ranges over a single
escrow identity.  If the repair spans ranges the
metadata server installed under distinct escrow
identities (for example, when a multi-data-server
repair needs its own escrow per data server), the
metadata server <bcp14>MUST</bcp14> issue one CB_CHUNK_REPAIR per
escrow identity rather than mixing them into a
single callback.</t>
            </dd>
            <dt>ccra_ranges:</dt>
            <dd>
              <t>the list of every chunk range the metadata server
requests the client to repair.  Each entry carries its
own ccr_error describing the failure mode the client
is being asked to remedy.  The repair strategy depends
on the error code; see <xref target="sec-repair-selection"/> for
the normative and guidance split.  The array is
bounded by CB_CHUNK_REPAIR_MAX_RANGES4; if a repair
set exceeds that bound, the metadata server splits
it across multiple callbacks.</t>
            </dd>
          </dl>
          <t>The metadata server <bcp14>SHOULD</bcp14> keep each CB_CHUNK_REPAIR
compound within the back-channel maximum
(ca_maxrequestsize) negotiated in CREATE_SESSION (see
<xref section="18.36.3" sectionFormat="of" target="RFC8881"/>).  If the set of affected
ranges would exceed that maximum, the metadata server <bcp14>MAY</bcp14>
issue multiple CB_CHUNK_REPAIR callbacks to the same
client.  Each callback is independent; the client drives
each to completion before the deadline on that callback's
ranges.</t>
          <t>The metadata server <bcp14>MUST NOT</bcp14> name a range in ccra_ranges
unless the data server holds a chunk lock on that range at
the time the callback is issued (the failure occurred in
or around a PENDING or FINALIZED state that established
the lock).  The repair actor <bcp14>MUST</bcp14> use CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT (<xref target="sec-CHUNK_LOCK"/>) to take
ownership of the lock before issuing CHUNK_WRITE_REPAIR,
CHUNK_ROLLBACK, or CHUNK_WRITE on any chunk in a requested
range.  Because callback delivery and lock state can race,
a repair actor that receives NFS4ERR_NO_ADOPTABLE_LOCK on
the adoption <bcp14>MUST</bcp14> report the mismatch via
ccrr_range_status per
<xref target="sec-NFS4ERR_NO_ADOPTABLE_LOCK"/> rather than attempt
recovery.</t>
          <t>CB_CHUNK_REPAIR returns a top-level ccrr_status plus a
co-indexed per-range status array ccrr_range_status.</t>
          <t>When the entire callback fails at once -- decode failure,
authorization failure, session-stale, and other conditions
that fail every range -- the operation-wide error is placed
in ccrr_status and ccrr_range_status <bcp14>MUST</bcp14> be empty (zero
entries).</t>
          <t>When the callback is well-formed and evaluated per range,
ccrr_range_status carries exactly one nfsstat4 per entry in
ccra_ranges, co-indexed, and ccrr_status is one of:</t>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>every range reached CHUNK_REPAIRED or CHUNK_UNLOCK per
the completion contract; every ccrr_range_status entry is
NFS4_OK.</t>
            </dd>
            <dt>NFS4ERR_PARTIAL (<xref target="sec-NFS4ERR_PARTIAL"/>):</dt>
            <dd>
              <t>at least one range did not reach the completion state.
The metadata server <bcp14>MUST</bcp14> consume the ccrr_range_status
array to determine per-range outcome; the array is
authoritative.  An NFS4ERR_PARTIAL response with an empty
array is malformed and <bcp14>MUST</bcp14> be rejected.</t>
            </dd>
          </dl>
          <t>A non-empty ccrr_range_status pairs only with NFS4_OK or
NFS4ERR_PARTIAL at the top level; every other top-level
nfsstat4 carries an empty ccrr_range_status.</t>
          <t>See "RESPONSE CODES" below for the normative
meanings the metadata server attaches to each
returned top-level nfsstat4.</t>
        </section>
        <section anchor="response-codes-18">
          <name>RESPONSE CODES</name>
          <t>The ccrr_status value returned by the client has the following
normative meanings to the metadata server:</t>
          <dl>
            <dt>NFS4_OK:</dt>
            <dd>
              <t>The client has accepted the request and driven every range in
this callback to completion (CHUNK_REPAIRED or CHUNK_UNLOCK on
every affected chunk).  The metadata server clears the repair
queue entry.</t>
            </dd>
            <dt>NFS4ERR_DELAY:</dt>
            <dd>
              <t>The client has accepted the request but requires more time.
The metadata server <bcp14>MAY</bcp14> extend the deadline by issuing a new
CB_CHUNK_REPAIR with a later ccra_deadline, or <bcp14>MAY</bcp14> re-select
another client.  The client continues to hold any locks it has
adopted until the original or extended deadline.</t>
            </dd>
            <dt>NFS4ERR_ENCODING_NOT_SUPPORTED:</dt>
            <dd>
              <t>The client does not implement the encoding type of the layout
and cannot reconstruct.  The metadata server <bcp14>MUST NOT</bcp14> retry with
the same client and <bcp14>SHOULD</bcp14> select a different client.</t>
            </dd>
            <dt>NFS4ERR_PAYLOAD_LOST:</dt>
            <dd>
              <t>The client has concluded that the identified ranges cannot
be repaired -- there are not enough surviving shards to
reconstruct and rollback is also impossible.  The metadata
server <bcp14>MUST NOT</bcp14> retry the repair and transitions the affected
ranges into an implementation-defined damaged state.  See
<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>.</t>
            </dd>
            <dt>NFS4ERR_PARTIAL:</dt>
            <dd>
              <t>At least one range in the callback did not reach the
completion contract.  The metadata server <bcp14>MUST</bcp14> consume the
co-indexed ccrr_range_status array to determine the per-range
outcome; NFS4ERR_PARTIAL is not a whole-callback retriable
error and <bcp14>MUST NOT</bcp14> be treated as one.  The array is
authoritative: each ccrr_range_status entry maps directly to
the co-indexed entry in ccra_ranges and is evaluated on its
own terms (NFS4_OK, NFS4ERR_DELAY, NFS4ERR_ENCODING_NOT_SUPPORTED,
NFS4ERR_PAYLOAD_LOST, or another per-range disposition) per
the result contract above.  An NFS4ERR_PARTIAL response with an
empty ccrr_range_status array is malformed and the metadata
server <bcp14>MUST</bcp14> reject the callback response.  See
<xref target="sec-NFS4ERR_PARTIAL"/>.</t>
            </dd>
          </dl>
          <t>All other error codes listed in <xref target="tbl-cb-ops-and-errors"/> are
treated by the metadata server as retriable: the metadata server
<bcp14>MAY</bcp14> issue a subsequent CB_CHUNK_REPAIR to the same or a
different client.  If the client becomes unreachable (no
response within the deadline), the metadata server re-selects
per <xref target="sec-repair-selection"/>.</t>
        </section>
      </section>
    </section>
    <section anchor="sec-composed-rollback">
      <name>Composed Rollback Guarantee and Error Decision Tree</name>
      <t>The flexible file v2 layout chunk protocol combines three
related mechanisms -- writer-supplied opaque owner identity
(<xref target="sec-chunk_owner4"/>), best-effort predecessor
discovery (<xref target="sec-CHUNK_HEADER_READ"/> /
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>), and metadata-server escrow
control-plane pinning (<xref target="sec-CHUNK_ESCROW_INSTALL"/> /
<xref target="sec-CHUNK_ESCROW_RELEASE"/> /
<xref target="sec-CHUNK_ESCROW_ENUMERATE"/> /
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>,
<xref target="sec-chunk_guard_mds"/>) -- that together deliver a
CONDITIONAL rollback guarantee.  This section states the
guarantee scope precisely and specifies the client-side
decision tree over the composed error set.</t>
      <section anchor="sec-composed-rollback-scope">
        <name>Guarantee Scope</name>
        <t>The composed guarantee is against protocol-level
garbage collection and owner-association release only,
NOT against storage or integrity failures.  It applies
only when three conditions all hold at the moment a
CHUNK_ROLLBACK is issued
against the named predecessor:</t>
        <ol spacing="normal" type="1"><li>
            <t>Present at acquisition.  The predecessor
generation must have existed on the data server at
the time the qualifying CHUNK_LOCK or metadata-server escrow
was acquired.  Predecessors that had already been
released under the retention scope
(<xref target="sec-system-model-retention-scope"/>) before any
qualifying lock or escrow was acquired are not
covered.</t>
          </li>
          <li>
            <t>Continuous custody.  The lock or escrow
custody chain must have remained uninterrupted
through the rollback decision window.  Custody
handoffs are permitted (a client-owned lock
adopted from a metadata-server escrow lock preserves the
escrow_id4 per <xref target="sec-chunk_guard_mds"/>, and a
subsequent revocation-transfer re-emits the same
escrow_id4 to a new metadata-server escrow lock, keeping the
custody chain continuous), but any interval in
which the predecessor was covered by neither a
qualifying lock nor a metadata-server escrow lock breaks
continuity.</t>
          </li>
          <li>
            <t>Payload remains AVAILABLE.  The predecessor's
payload <bcp14>MUST</bcp14> be in the AVAILABLE read-time state
(<xref target="sec-system-model-read-time-status"/>).  A
predecessor whose payload has become ERRORED
through media loss, unrecoverable corruption,
loss of all redundant data servers, or non-conforming
data-server behavior is not covered
-- an ERRORED predecessor follows the best-effort
reconstruction path
(<xref target="sec-CHUNK_WRITE_REPAIR"/>) and <bcp14>MAY</bcp14> terminate
at NFS4ERR_PAYLOAD_LOST via CB_CHUNK_REPAIR.</t>
          </li>
        </ol>
        <t>When all three conditions hold, a CHUNK_ROLLBACK
that names the predecessor's original owner triple
is guaranteed to restore the predecessor as the
current COMMITTED generation with its original
triple intact
(<xref target="sec-CHUNK_ROLLBACK"/> "Rollback of COMMITTED
Chunks", case (a)).  When any condition fails, the
call may return NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>) or NFS4ERR_INVAL
and the caller falls back to best-effort
reconstruction as described in
<xref target="sec-CHUNK_WRITE_REPAIR"/> -- best-effort
reconstruction into a NEW generation under a NEW
owner triple, or terminal NFS4ERR_PAYLOAD_LOST
when no authoritative source exists.</t>
        <t>The guarantee is a protocol-level protection against
premature release: flexible file v2 layout implementations
<bcp14>MUST NOT</bcp14> release the payload or owner-to-index association of
a predecessor covered by an active qualifying lock or
metadata-server escrow lock, per the payload/association
biconditional
(<xref target="sec-system-model-payload-association-biconditional"/>)
and the retention scope
(<xref target="sec-system-model-retention-scope"/>) as extended
by the escrow-pin mechanism.  It is not a
guarantee against exogenous failures of the
storage substrate.</t>
      </section>
      <section anchor="sec-composed-rollback-tree">
        <name>Client-Side Error Decision Tree</name>
        <t>A client operating over the composed error set
distinguishes control-plane failures (which the
metadata server must resolve) from data-plane
failures (which the client can address via
fallback).  Ordering matters: control-plane
failures must be resolved before data-plane
recovery is attempted.</t>
        <dl>
          <dt>CHUNK_LOCK with CHUNK_LOCK_FLAGS_ADOPT -&gt; NFS4ERR_NO_ADOPTABLE_LOCK (<xref target="sec-NFS4ERR_NO_ADOPTABLE_LOCK"/>):</dt>
          <dd>
            <t>custody / control-plane failure BEFORE any usable lock is
in hand.  The four state causes (no escrow / identity
mismatch / reconciliation hold / already-adopted) are all
conditions the metadata server is best placed to resolve.
The client <bcp14>MUST</bcp14> report the outcome via the
ccrr_range_status array (<xref target="sec-CB_CHUNK_REPAIR"/>) and <bcp14>MUST
NOT</bcp14> unilaterally retry the adoption or begin the
CHUNK_WRITE_REPAIR fallback path
(<xref target="sec-CHUNK_WRITE_REPAIR"/>); that fallback assumes a
usable lock, and no lock exists here to fall back under.</t>
          </dd>
          <dt>CHUNK_LOCK -&gt; NFS4ERR_ACCESS:</dt>
          <dd>
            <t>presenter authorization failure.  Report to the metadata
server; do not retry.</t>
          </dd>
          <dt>After successful CHUNK_LOCK / ADOPT -&gt; CHUNK_HEADER_READ:</dt>
          <dd>
            <t>read the primary owner and chrr_predecessors array.  If the
intended predecessor's triple appears in the list, proceed
to CHUNK_ROLLBACK.  If absent, the CHUNK_WRITE_REPAIR
fallback path may begin directly (do not issue
CHUNK_ROLLBACK against a predecessor known-absent).</t>
          </dd>
          <dt>CHUNK_ROLLBACK -&gt; NFS4ERR_NO_PREDECESSOR (<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>):</dt>
          <dd>
            <t>data-plane result AFTER a usable lock is in hand.  The
actor has the lock; there is simply no restorable
predecessor.  The client <bcp14>MAY</bcp14> invoke best-effort
reconstruction via CHUNK_WRITE_REPAIR under a new owner
triple (<xref target="sec-CHUNK_WRITE_REPAIR"/>); fallback <bcp14>MAY</bcp14> terminate
at NFS4ERR_PAYLOAD_LOST (<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>) if
no authoritative source exists.</t>
          </dd>
          <dt>CHUNK_ROLLBACK -&gt; NFS4ERR_INVAL or NFS4ERR_NO_PREDECESSOR for a fresh op naming a released triple:</dt>
          <dd>
            <t>terminal per-entry failure.  Caller holds a stale
reference; no operation defined in this document
resurrects the deleted generation.  The data server
returns NFS4ERR_INVAL within the delete case's
session-slot replay-cache window and NFS4ERR_NO_PREDECESSOR
after the window has elapsed or for any other terminal
release (per the release-scope split at
<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>).  Compare either code to
the uncertain-replay carve-out (<xref target="sec-CHUNK_ROLLBACK"/>
"Idempotence and Uncertain-Replay Carve-Out") which
permits an EXACT reissue after uncertain prior completion
to treat NFS4ERR_INVAL or NFS4ERR_NO_PREDECESSOR as
postcondition-equivalent success, but ONLY when the caller
independently verifies the postcondition holds.</t>
          </dd>
          <dt>Any CHUNK_ESCROW operation -&gt; NFS4ERR_STALE_ESCROW (<xref target="sec-NFS4ERR_STALE_ESCROW"/>):</dt>
          <dd>
            <t>control-plane identity mismatch or no covering escrow on
the metadata server's own CHUNK_ESCROW_RELEASE.  The
response never authorizes tuple removal by itself when
adoption may have consumed the escrow (see
<xref target="sec-CHUNK_ESCROW_RELEASE"/>).</t>
          </dd>
          <dt>Any CHUNK_ESCROW operation -&gt; NFS4ERR_STALE_MDS_EPOCH (<xref target="sec-NFS4ERR_STALE_MDS_EPOCH"/>):</dt>
          <dd>
            <t>the metadata server has been fenced by a superseding
CHUNK_ESCROW_TAKEOVER.  The metadata server <bcp14>MUST</bcp14> obtain a
fresh incarnation-lease token and reissue via
CHUNK_ESCROW_TAKEOVER;
TAKEOVER is exempt from this rejection.</t>
          </dd>
          <dt>CB_CHUNK_REPAIR response -&gt; NFS4ERR_PARTIAL (<xref target="sec-NFS4ERR_PARTIAL"/>):</dt>
          <dd>
            <t>at least one named range did not reach completion; the
metadata server <bcp14>MUST</bcp14> consume the per-range
ccrr_range_status array (<xref target="sec-CB_CHUNK_REPAIR"/>) to
determine per-range outcome.</t>
          </dd>
        </dl>
        <t>The essential distinction is that
NFS4ERR_NO_ADOPTABLE_LOCK and
NFS4ERR_NO_PREDECESSOR both prevent the direct
rollback path, but at different lifecycle stages
and with different recovery authorities:
NFS4ERR_NO_ADOPTABLE_LOCK is a custody / control-plane
failure BEFORE the actor obtains usable
custody (unrecoverable unilaterally), while
NFS4ERR_NO_PREDECESSOR is a data-plane result
AFTER successful adoption where the actor
already holds the lock but finds no restorable
predecessor data (the actor <bcp14>MAY</bcp14> invoke
best-effort reconstruction via
CHUNK_WRITE_REPAIR).  A client that receives one <bcp14>MUST NOT</bcp14>
treat it as the other.</t>
      </section>
      <section anchor="sec-composed-rollback-trace">
        <name>Worked Example: Composed Rollback and Fallback</name>
        <t>The following worked example exercises the three
composed conditions.  A single file has chunk index
5 previously written by client 7 with co_cohort_id
41 and co_id 100 (owner triple (41, 7, 100)) and then
overwritten by client 7 with co_cohort_id 42 and co_id
101 (owner triple (42, 7, 101)), which reached the
COMMITTED state.  The metadata server determines
that the (42, 7, 101) commit was incorrect and
initiates rollback.  The trace shows the happy
path, the lost-callback branch, and the fallback
contrast.</t>
        <t>Note that the owner triple is (co_cohort_id,
co_client_id, co_id) throughout, per
<xref target="sec-chunk_owner4"/>; per-chunk CAS state
(cg_gen_id, cg_client_id) is data-server-managed and is
distinct from these owner-identity numbers.</t>
        <section anchor="sec-composed-rollback-happy">
          <name>Happy Path (all three conditions hold)</name>
          <ol spacing="normal" type="1"><li>
              <t>The metadata server proactively installs an
metadata-server escrow lock over chunk index 5 by sending
CHUNK_ESCROW_INSTALL with escrow_id4 E1 while
the (41, 7, 100) predecessor is still
AVAILABLE on the data server.  The data server
accepts and echoes E1 in ceir_escrow_id.  Per
<xref target="sec-composed-rollback-scope"/> conditions 1
and 3, the predecessor is now under continuous
metadata-server escrow custody and remains AVAILABLE.</t>
            </li>
            <li>
              <t>The metadata server sends CB_CHUNK_REPAIR to a
selected repair actor with ccra_escrow_id =
E1 and a range naming chunk index 5.</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_LOCK with
CHUNK_LOCK_FLAGS_ADOPT and cla_adopt = { TRUE,
cla_escrow_id = E1 }.  The data server
validates identity and atomically transfers
custody: E1 dissolves as a metadata-server escrow lock,
the client owns the lock, the predecessor's
payload and owner association survive intact,
and E1 is retained as durable custody metadata
on the client-owned lock (per
<xref target="sec-chunk_guard_mds"/>).  Condition 2
(continuous custody) is preserved through the
adoption.</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_HEADER_READ over
chunk index 5.  The response shows chrr_owners
as the (42, 7, 101) current generation and
<tt>chrr_predecessors[0]</tt> as the (41, 7, 100)
retained predecessor
(<xref target="sec-CHUNK_HEADER_READ"/>).</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_ROLLBACK naming
the predecessor's triple (41, 7, 100).  The
data server executes "Rollback of COMMITTED
Chunks" case (a)
(<xref target="sec-CHUNK_ROLLBACK"/>): the retained
predecessor is restored as the current
COMMITTED generation under its original triple
(41, 7, 100), and the displaced successor's
triple (42, 7, 101) is atomically invalidated
("Deletion Atomicity and Invalidated
Triples").</t>
            </li>
            <li>
              <t>The repair actor issues CHUNK_UNLOCK.  The
client-owned lock is released; the preserved
escrow_id4 custody metadata is cleared.</t>
            </li>
            <li>
              <t>The repair actor returns NFS4_OK on the
CB_CHUNK_REPAIR response with a co-indexed
NFS4_OK in ccrr_range_status.  The metadata
server issues CHUNK_ESCROW_RELEASE with
cera_escrow_id = E1.  Because E1 was consumed
by the adoption in step 3, the data server
returns NFS4ERR_STALE_ESCROW; the metadata
server interprets this as "the escrow was
consumed by ADOPT and the callback response
confirms completion," and clears its
durable escrow-tuple record for (file, E1,
{this data server}).</t>
            </li>
          </ol>
        </section>
        <section anchor="sec-composed-rollback-lost">
          <name>Lost-Callback Branch</name>
          <t>Steps 1-6 proceed as above but the CB_CHUNK_REPAIR
response is lost in transit (data server restart or
network failure before the metadata server receives the
reply).  The metadata server never observes step-7
confirmation.  The repair actor's lock lease eventually
expires without an explicit release, and the data server
transitions the lock through the revocation-transfer path
(see <xref target="sec-chunk_guard_mds"/>): a new metadata-server escrow
lock is installed on the same range with the same
preserved escrow_id4 = E1.  On the next
CHUNK_ESCROW_ENUMERATE the metadata server observes the
reappeared E1 and reissues repair under it.</t>
        </section>
        <section anchor="sec-composed-rollback-fallback">
          <name>Fallback Contrast (condition 1 fails)</name>
          <t>Under an alternative setup where the metadata server did
NOT install a metadata-server escrow before the retention
scope (<xref target="sec-system-model-retention-scope"/>) released the
(41, 7, 100) predecessor, condition 1 fails.  By the time
repair is initiated the predecessor is ABSENT on the data
server, and the escrow the metadata server installs pins
only what still exists (there is no predecessor to pin).
The repair actor's CHUNK_LOCK / CHUNK_HEADER_READ sequence
discovers no retained predecessor for index 5.  A
subsequent CHUNK_ROLLBACK against the (41, 7, 100) triple
returns NFS4ERR_NO_PREDECESSOR
(<xref target="sec-NFS4ERR_NO_PREDECESSOR"/>).  The client falls back
to CHUNK_WRITE_REPAIR, reconstructing authoritative bytes
from surviving data-server shards and writing them under
a new owner triple of its own choosing -- for example
(43, 7, 102).  The resulting COMMITTED generation carries
the new triple, NOT the released (41, 7, 100).</t>
          <t>Any subsequent lifecycle operation that names the
released (41, 7, 100) triple returns NFS4ERR_NO_PREDECESSOR
-- the (41, 7, 100) association was released under the
retention scope, not by an explicit CHUNK_ROLLBACK delete
case within a live replay-cache window, so the
release-scope split at <xref target="sec-NFS4ERR_NO_PREDECESSOR"/>
routes to the NO_PREDECESSOR arm consistent with the
previous CHUNK_ROLLBACK outcome in this trace: the
fallback creates a new generation, it does not resurrect
the released predecessor.  When no authoritative source
exists for reconstruction, the fallback itself terminates
at NFS4ERR_PAYLOAD_LOST (<xref target="sec-NFS4ERR_PAYLOAD_LOST"/>)
via CB_CHUNK_REPAIR.</t>
        </section>
      </section>
    </section>
    <section anchor="security-considerations">
      <name>Security Considerations</name>
      <t>The combination of components in a pNFS system is required to
preserve the security properties of NFSv4.1+ with respect to an
entity accessing data via a client.  The pNFS feature partitions
the NFSv4.1+ file system protocol into two parts: the control
protocol and the data protocol.  As the control protocol in this
document is NFS, the security properties are equivalent to the
version of NFS being used.  The flexible file v2 layout further divides
the data protocol into metadata and data paths.  The security
properties of the metadata path are equivalent to those of NFSv4.1x
(see Sections 1.7.1 and 2.2.1 of <xref target="RFC8881"/>).  And the security
properties of the data path are equivalent to those of the version
of NFS used to access the storage device, with the provision that
the metadata server is responsible for authenticating client access
to the data file.  The metadata server provides appropriate credentials
to the client to access data files on the storage device.  It is
also responsible for revoking access for a client to the storage
device.</t>
      <t>The metadata server enforces the file access control policy at
LAYOUTGET time.  The client <bcp14>MUST</bcp14> use RPC authorization credentials
for getting the layout for the requested iomode (LAYOUTIOMODE4_READ
or LAYOUTIOMODE4_RW), and the server verifies the permissions and
ACL for these credentials, possibly returning NFS4ERR_ACCESS if the
client is not allowed the requested iomode.  If the LAYOUTGET
operation succeeds, the client receives, as part of the layout, a
set of credentials allowing it I/O access to the specified data
files corresponding to the requested iomode.  When the client acts
on I/O operations on behalf of its local users, it <bcp14>MUST</bcp14> authenticate
and authorize the user by issuing respective OPEN and ACCESS calls
to the metadata server, similar to having NFSv4 data delegations.</t>
      <t>Under loose coupling, the combination of filehandle,
synthetic uid, and gid in the layout is the way that the
metadata server enforces access control to the data server.
The client only has access to filehandles of file objects
and not directory objects.  Thus, given a filehandle in a
layout, it is not possible to guess the parent directory
filehandle.  Further, as the data file permissions only
allow the given synthetic uid read/write permission and
the given synthetic gid read permission, knowing the
synthetic ids of one file does not necessarily allow
access to any other data file on the storage device.</t>
      <t>Under loose coupling, the metadata server can also deny
access at any time by fencing the data file, which means
changing the synthetic ids.  In turn, that forces the
client to return its current layout and get a new layout
if it wants to continue I/O to the data file.</t>
      <t>Under tight coupling
(<xref target="sec-tight-coupling-control-session"/>), the metadata
server does not rely on synthetic uid and gid values to
enforce access at the data server.  Instead, the metadata
server injects a per-stateid trust entry into the data
server via TRUST_STATEID (<xref target="sec-TRUST_STATEID"/>); the data
server validates each CHUNK operation against the
registered trust entry and rejects operations that do not
present a registered stateid.  The metadata server rescinds
that authorization via REVOKE_STATEID
(<xref target="sec-REVOKE_STATEID"/>) for a single stateid or
BULK_REVOKE_STATEID (<xref target="sec-BULK_REVOKE_STATEID"/>) for
every stateid a client currently holds; both are the
tight-coupling equivalent of a synthetic-id change and
achieve the same effect (the client <bcp14>MUST</bcp14> return its
current layout and obtain a new one to continue I/O to
the data file).  The security implications of the
trust-stateid channel are covered in
<xref target="sec-security-trust-stateid"/>.</t>
      <t>If access is allowed, the client uses the corresponding (read-only
or read/write) credentials to perform the I/O operations at the
data file's storage devices.  When the metadata server receives a
request to change a file's permissions or ACL, it <bcp14>SHOULD</bcp14> recall all
layouts for that file and then <bcp14>MUST</bcp14> fence off any clients still
holding outstanding layouts for the respective files by implicitly
invalidating the previously distributed credential on all data file
comprising the file in question.  It is <bcp14>REQUIRED</bcp14> that this be done
before committing to the new permissions and/or ACL.  By requesting
new layouts, the clients will reauthorize access against the modified
access control metadata.  Recalling the layouts in this case is
intended to prevent clients from getting an error on I/Os done after
the client was fenced off.</t>
      <section anchor="sec-security-checksum-scope">
        <name>Checksum Integrity Scope</name>
        <t>The checksum values carried in CHUNK_WRITE and returned from
CHUNK_READ defend against accidental data corruption during
storage or transmission -- bit flips on storage media, network
errors, software bugs in the erasure transform.  The threat
model an individual deployment achieves depends on which
checksum_algorithm4 (<xref target="sec-checksum4"/>) the metadata server
selects for the file's mirrors via ffv2m_checksum_algorithm
(<xref target="sec-ffv2-mirror4"/>):</t>
        <dl>
          <dt>Bit-flip-class algorithms (CRC32, CRC32C, Fletcher4):</dt>
          <dd>
            <t>Detect accidental bit-level corruption with high
probability.  Do NOT defend against an adversary who can
modify the payload and recompute a valid checksum, because
these algorithms are not cryptographic and the algorithm
identifier and parameters are public.  Suitable when the
threat model excludes adversaries on the wire and at rest.</t>
          </dd>
          <dt>Cryptographic-strength algorithms (SHA-256, SHA-512, BLAKE3):</dt>
          <dd>
            <t>Detect accidental corruption with cryptographic-strength
collision resistance.  These are UNKEYED hashes carried
alongside the payload on the wire, so they do NOT by
themselves defend against an adversary who can modify a
chunk and recompute a valid hash: the attacker knows the
algorithm and can substitute a matching digest.  Content
authentication against active adversaries requires a keyed
MAC or signature scheme (e.g., RPCSEC_GSS_KRB5I,
RPC-over-TLS with mutual authentication, or an
application-layer signed manifest) applied at the trust
boundary; the checksum mechanism defined here provides
corruption detection, not content authentication.
Suitable when chunks may be at rest on storage the
deployment does not fully control and the deployment
layers cryptographic transport or storage integrity on
top of the checksum for adversarial protection.</t>
          </dd>
          <dt>CHECKSUM_ALG_NONE:</dt>
          <dd>
            <t>No protocol-level integrity check.  The deployment is
relying on transport-layer integrity (RPC-over-TLS
<xref target="RFC9289"/>, RPCSEC_GSS_KRB5I) or storage-layer integrity
(filesystem checksums on the data server, RAID-level
integrity) instead.  Suitable when those other layers are
reliably present end-to-end and the per-chunk wire
protection would be redundant.</t>
          </dd>
        </dl>
        <t>Deployments requiring protection against active attackers
<bcp14>SHOULD</bcp14> select one of the cryptographic algorithms, OR use
CHECKSUM_ALG_NONE in conjunction with RPC-over-TLS
(<xref target="sec-tls"/>) or RPCSEC_GSS, whichever fits the deployment's
existing security architecture.</t>
        <t>An authenticated client is in the "active attacker" role with
respect to its own chunks, in a restricted sense.  The data
server validates the checksum against the bytes the client
provided, so an authenticated client that chooses to send
semantically-invalid bytes with a correctly computed checksum will
have those bytes accepted.  The residual risk differs per
authentication model:</t>
        <ul spacing="normal">
          <li>
            <t>Under AUTH_SYS with loose coupling, the residual risk is
essentially the pre-existing attack surface of NFSv3 writes:
any host that can reach the data server with a valid uid can
write nonsense to chunks that uid owns.  This is the Flex
Files v1 authorization model, which flexible file v2 layout inherits
without modification for this path.</t>
          </li>
          <li>
            <t>Under RPCSEC_GSS or TLS with mutual authentication, the
residual risk reduces to: only the authenticated client
can write nonsense into chunks it owns.  Cross-client
corruption is prevented because the data server verifies the
principal before accepting the write.  The remaining
exposure is at the client's own integrity: any deployment
that relies on data integrity above the wire <bcp14>MUST</bcp14> apply
application-level content validation.</t>
          </li>
        </ul>
        <t>Flexible file v2 layout does not attempt to defend against this
authenticated-but-malicious case.  The checksum mechanism is a
transport-integrity check, not a content-integrity check; the
system trust model assumes that an authenticated principal is
entitled to destroy the content of chunks it owns.</t>
      </section>
      <section anchor="chunk-lock-and-lease-expiry">
        <name>Chunk Lock and Lease Expiry</name>
        <t>When a client holds a chunk lock (acquired via CHUNK_LOCK) and its
lease expires or the client crashes, the lock is released implicitly
by the data server.  This opens a window in which another client
may write to the previously locked range before the original client's
repair is complete.  Implementations <bcp14>SHOULD</bcp14> ensure that the lease
period for chunk locks is sufficient to complete repair operations,
and <bcp14>SHOULD</bcp14> implement CHUNK_UNLOCK explicitly on abort paths.  The
metadata server's LAYOUTERROR and LAYOUTRETURN mechanisms provide
the coordination point for detecting and resolving such races.</t>
      </section>
      <section anchor="error-code-information-disclosure">
        <name>Error Code Information Disclosure</name>
        <t>The new error codes NFS4ERR_CHUNK_LOCKED (10099) and
NFS4ERR_PAYLOAD_NOT_ATOMIC (10098) convey information about
chunk state to the caller.  Both of these errors <bcp14>MAY</bcp14> be returned
to callers whose credentials have not been verified by the data
server (e.g., when the AUTH_SYS uid presented does not match the
synthetic uid on the data file).  The information they reveal --
that a chunk is locked, or that a CRC mismatch occurred -- does
not directly disclose file contents but may indicate concurrent
write activity.  Implementations that are concerned about this
level of disclosure <bcp14>SHOULD</bcp14> require that CHUNK operations
only succeed after credential verification and return
NFS4ERR_ACCESS for unverified callers rather than the more
specific error codes.</t>
        <t>This document adds NFS4ERR_NO_PREDECESSOR (10103),
NFS4ERR_NO_ADOPTABLE_LOCK (10104), NFS4ERR_STALE_ESCROW (10105),
NFS4ERR_STALE_MDS_EPOCH (10106), and NFS4ERR_PARTIAL (10107).
All five reveal control-plane or discovery state that a
compromised or curious caller could aggregate into a picture of
which files are under repair, which are pinned, and which epoch
is current.  A data server <bcp14>SHOULD</bcp14> enforce presenter
authorization before returning any of these codes so that an
unauthorized caller receives NFS4ERR_ACCESS rather than the
specific state indicator.  In particular, NFS4ERR_STALE_MDS_EPOCH
and unknown-profile NFS4ERR_NOTSUPP on CHUNK_ESCROW_TAKEOVER are
gated behind presenter authorization by the strict evaluation
order in <xref target="sec-proof-profile"/>; that ordering is a security
requirement, not merely a diagnostic preference.</t>
      </section>
      <section anchor="sec-security-escrow">
        <name>Escrow Control Plane and Incarnation Proofs</name>
        <t>This document's escrow control plane introduces four operations
(CHUNK_ESCROW_INSTALL, CHUNK_ESCROW_RELEASE,
CHUNK_ESCROW_ENUMERATE, CHUNK_ESCROW_TAKEOVER --
<xref target="sec-CHUNK_ESCROW_INSTALL"/> through
<xref target="sec-CHUNK_ESCROW_TAKEOVER"/>) and one proof envelope
(<xref target="sec-proof-profile"/>) whose security properties merit
dedicated treatment.</t>
        <section anchor="authorization-scope">
          <name>Authorization scope</name>
          <t>CHUNK_ESCROW_INSTALL, CHUNK_ESCROW_RELEASE, and
CHUNK_ESCROW_ENUMERATE <bcp14>MUST</bcp14> be invoked only by the metadata
server currently holding the incarnation lease.  A data server
<bcp14>MUST</bcp14> authenticate the presenter via RPCSEC_GSS
(<xref target="RFC7861"/>) and verify the presenter's principal against
the deployment-configured metadata-server principal(s) for
the file's device before accepting any escrow-family
operation; presenter authorization failure returns
NFS4ERR_ACCESS with no side effect on escrow state.  This
authorization is orthogonal to the ordinary client-facing
NFSv4 access controls: an authenticated pNFS client's
credentials <bcp14>MUST NOT</bcp14> authorize an escrow-family operation
even if the client is otherwise permitted to read or write
the file.  A data server that receives any escrow-family
operation on a session belonging to a non-metadata-server
principal <bcp14>MUST</bcp14> reject with NFS4ERR_ACCESS or NFS4ERR_PERM
per the ordinary NFSv4 rules.</t>
        </section>
        <section anchor="trust-anchor-lifecycle">
          <name>Trust anchor lifecycle</name>
          <t>The proof profile depends on a deployment-provisioned trust
anchor at each data server (<xref target="sec-proof-profile"/> "Trust
Anchor Provisioning").  Anchor compromise permits an
adversary to forge incarnation-lease tokens and stage
takeovers of the escrow control plane; anchor
unavailability blocks legitimate takeovers and inhibits
recovery from an incarnation failure.  Deployments <bcp14>SHOULD</bcp14>:</t>
          <ul spacing="normal">
            <li>
              <t>provision separate anchors per proof profile so revocation
of one profile does not require replacing keys for others;</t>
            </li>
            <li>
              <t>rotate anchors on a schedule consistent with the
authority's own key-management posture (this specification
does not mandate a rotation interval); and</t>
            </li>
            <li>
              <t>retain the ability to revoke an anchor out-of-band without
requiring a wire-level protocol message, because a
compromised anchor's tokens will otherwise satisfy the
data server's strict-ordering checks by construction.</t>
            </li>
          </ul>
          <t>An incarnation-lease authority <bcp14>MUST NOT</bcp14> delegate signing to
any component the metadata server can spoof; the security of
the proof mechanism rests on the assumption that the
authority is a distinct entity from any metadata server and
can independently attest current single writer ownership.</t>
        </section>
        <section anchor="replay-cache-exhaustion-and-durability">
          <name>Replay-cache exhaustion and durability</name>
          <t>The token_id replay cache at the data server
(<xref target="sec-proof-profile"/> "Presentation and Verification") is a
finite resource.  A hostile presenter that can obtain many
valid tokens for the same profile <bcp14>MAY</bcp14> attempt to grow the
cache without bound.  A data server <bcp14>SHOULD</bcp14> bound the cache
size and expire entries no later than their token's
expires_at; entries older than the longest admissible
issued_at-to-expires_at window <bcp14>MAY</bcp14> be evicted.  Eviction
does not sacrifice lost-response recovery: the byte-identical
uncertain-completion recovery path
(<xref target="sec-CHUNK_ESCROW_TAKEOVER-uncertain-completion"/>)
recognizes both the cache-hit and the cache-miss form of
the same reissue, so a token whose replay entry has aged
out still resolves to NFS4_OK when its ceta_new_epoch
equals the data server's currently-recorded epoch and its
ceta_expected_prior_epoch is strictly prior.  A hostile
presenter cannot exploit the cache-miss form to advance
the epoch: proof verification still gates on the token's
signature and principal, and once a subsequent successful
TAKEOVER advances past ceta_new_epoch the reissue no
longer satisfies the postcondition-equivalent predicates.</t>
          <t>Data servers that persist the token_id cache across restart
<bcp14>MUST</bcp14> persist and evict entries coherently with expires_at
values.  A data server that does not persist the cache
returns to the freshly-initialized state after restart;
lost-response reissues still resolve through the cache-miss
form of the uncertain-completion recovery path.</t>
        </section>
        <section anchor="discovery-information-disclosure">
          <name>Discovery information disclosure</name>
          <t>CHUNK_ESCROW_ENUMERATE and the CHUNK_HEADER_READ
predecessor arm (<xref target="sec-CHUNK_HEADER_READ"/>) disclose
control-plane and discovery information.
CHUNK_ESCROW_ENUMERATE is gated behind the escrow-role
authorization above; CHUNK_HEADER_READ's predecessor list is
available to any pNFS client holding a valid layout for the
file.  A deployment where predecessor identity is itself
sensitive (for example, because owner triples encode
information about the writer's identity that ordinary read
authorization does not disclose) <bcp14>SHOULD</bcp14> scope the layout so
that only appropriately-authorized clients can obtain it.
The specification does not require the data server to
suppress predecessor disclosure on a per-client basis; where
that is required, deploy at the layout-authorization layer.</t>
        </section>
        <section anchor="resource-exhaustion-via-long-lived-escrows">
          <name>Resource exhaustion via long-lived escrows</name>
          <t>A compromised or faulty metadata server can install an
arbitrary number of long-lived metadata-server escrow locks via
CHUNK_ESCROW_INSTALL, each of which forces retention of a
predecessor generation the data server would otherwise
release under the retention scope rule
(<xref target="sec-system-model-retention-scope"/>).  Sustained abuse
could exhaust data-server storage.  A data server <bcp14>MAY</bcp14> apply
implementation-defined admission control on the total number
of metadata-server escrow locks it holds concurrently, rejecting further
CHUNK_ESCROW_INSTALL with NFS4ERR_SERVERFAULT or a
resource-exhaustion error when the bound is reached; the
metadata server can then release older escrows or wait for
their natural completion before retrying.  This
specification does not prescribe a concrete bound; the
choice is deployment-local and interacts with the
data-server's storage-management policy.</t>
        </section>
        <section anchor="consequence-of-losing-durable-adopted-lock-escrow-identity">
          <name>Consequence of losing durable adopted-lock escrow identity</name>
          <t>The client-owned lock that adopted a metadata-server escrow retains the
adopted escrow_id4 as durable custody metadata per
<xref target="sec-chunk_guard_mds"/>; on data-server restart this
metadata must survive so a subsequent revocation-transfer
re-emits the same identity.  A data server that fails to
persist the adopted escrow_id4 (whether by implementation
defect or storage corruption) forces the metadata server's
tuple bookkeeping into an unresolvable state: the recovered
metadata-server escrow appears with a fresh identity that no durable
tuple matches, and the composed rollback guarantee
(<xref target="sec-composed-rollback"/>) is broken for repairs that
crossed the restart.  A deployment <bcp14>SHOULD</bcp14> monitor for
missing-adopted-id events and treat them as a data-server
failure requiring operator investigation.</t>
        </section>
      </section>
      <section anchor="sec-tls">
        <name>Transport Layer Security</name>
        <t>RPC-over-TLS <xref target="RFC9289"/> <bcp14>MAY</bcp14> be used to protect traffic between the
client and the metadata server and between the client and data servers.
When RPC-over-TLS is in use on the data server path, the synthetic
uid/gid credentials carried in AUTH_SYS remain the access control
mechanism; TLS provides confidentiality and integrity for the transport
but does not replace the fencing model described in <xref target="sec-Fencing-Clients"/>.
Servers that require transport security <bcp14>SHOULD</bcp14> advertise this via the
SECINFO mechanism rather than silently dropping connections.</t>
        <t>This permission covers the client-facing paths only.  The
metadata-server-to-storage-device control session is not optional in
this respect: <xref target="sec-tight-coupling-control-session"/> requires that
session to be mutually authenticated and integrity protected.</t>
      </section>
      <section anchor="rpcsecgss-and-security-services">
        <name>RPCSEC_GSS and Security Services</name>
        <t>This document does not specify how RPCSEC_GSS <xref target="RFC7861"/> is
used between the client and a storage device in the loosely
coupled model, and the reasons differ between the two coupling
models.  Because the loosely coupled model uses synthetic
credentials that are managed by the metadata server rather than
shared with the storage device, a full RPCSEC_GSS integration
would require protocol work (RPCSEC_GSSv3 structured privilege
assertions, per <xref target="RFC7861"/>) on all three of the metadata
server, the storage device, and the client.  In the tightly
coupled model the principal used to access the data file is the
same as the one used to access the metadata file, so
RPCSEC_GSS applies unchanged.  The two subsections below treat
each model in turn.</t>
        <section anchor="loosely-coupled">
          <name>Loosely Coupled</name>
          <t>RPCSEC_GSS version 3 (RPCSEC_GSSv3) <xref target="RFC7861"/> contains facilities
that would allow it to be used to authorize the client to the storage
device on behalf of the metadata server.  Doing so would require
that each of the metadata server, storage device, and client would
need to implement RPCSEC_GSSv3 using an RPC-application-defined
structured privilege assertion in a manner described in <xref section="4.9.1" sectionFormat="of" target="RFC7862"/>.  The specifics necessary to do so are not
described in this document.  This is principally because any such
specification would require extensive implementation work on a wide
range of storage devices, which would be unlikely to result in a
widely usable specification for a considerable time.</t>
          <t>As a result, the layout type described in this document will not
provide support for use of RPCSEC_GSS together with the loosely
coupled model.  However, future layout types could be specified,
which would allow such support, either through the use of RPCSEC_GSSv3
or in other ways.</t>
        </section>
        <section anchor="tightly-coupled">
          <name>Tightly Coupled</name>
          <t>With tight coupling, the principal used to access the metadata file
is exactly the same as used to access the data file.  The storage
device can use the control protocol to validate any RPC credentials.
As a result, there are no security issues related to using RPCSEC_GSS
with a tightly coupled system.  For example, if Kerberos V5 Generic
Security Service Application Program Interface (GSS-API) <xref target="RFC4121"/>
is used as the security mechanism, then the storage device could
use a control protocol to validate the RPC credentials to the
metadata server.</t>
        </section>
      </section>
      <section anchor="sec-security-trust-stateid">
        <name>Trusted Stateids</name>
        <t>The TRUST_STATEID, REVOKE_STATEID, and BULK_REVOKE_STATEID
operations (<xref target="sec-TRUST_STATEID"/>, <xref target="sec-REVOKE_STATEID"/>,
<xref target="sec-BULK_REVOKE_STATEID"/>) introduce a per-stateid
authorization channel between the metadata server and the
data server.  The security implications of that channel are
distinct from those of the loosely coupled synthetic-uid
model (<xref target="sec-Fencing-Clients"/>) and warrant their own
treatment.</t>
        <section anchor="interaction-with-kerberos-and-rpcsecgss">
          <name>Interaction with Kerberos and RPCSEC_GSS</name>
          <t>Trusted stateids decouple the credential the data server
uses to authorize I/O from the credential the client uses
to authenticate to the data server.  Under loose coupling
(<xref target="sec-Fencing-Clients"/>), the metadata server inserts a
synthetic uid/gid into the layout and the client presents
that synthetic credential on every data-server RPC; the
data server has no independent verification of the
client's identity, and a client that learns another
client's synthetic uid/gid can impersonate it on the data
path.  Tight coupling via TRUST_STATEID changes this in
three ways:</t>
          <ul spacing="normal">
            <li>
              <t>The metadata server records the client's authenticated
principal in the trust entry via tsa_principal at
TRUST_STATEID time (<xref target="sec-TRUST_STATEID"/>).  Under
RPCSEC_GSS (typically Kerberos V5 GSS-API per
<xref target="RFC4121"/>), tsa_principal is the GSS display name
(for example, "alice@REALM"); under AUTH_SYS and TLS,
tsa_principal is the empty string.</t>
            </li>
            <li>
              <t>The client presents its own RPCSEC_GSS context on each
CHUNK operation against the data server.  Under
tight coupling with GSS, the data server <bcp14>MUST</bcp14> verify
that the principal carried in the inbound RPC's
RPCSEC_GSS context matches the tsa_principal recorded
for the stateid in its trust table; a mismatch returns
NFS4ERR_ACCESS.  A client that learned another
client's layout stateid (from a log file, a packet
capture of cleartext RPC, or any other leak) cannot
use it because their own GSS principal would not
match.</t>
            </li>
            <li>
              <t>The data server needs a service principal and keytab
for each session on which it accepts RPCSEC_GSS: the
control session, and, where the deployment runs the
data path under RPCSEC_GSS, the client's context on
each CHUNK compound.  It is the acceptor in both
cases.  What tight coupling removes is not that key
but the need for an identity for the client.  In a
loose coupling Kerberos deployment the data server
resolves the authenticated name to a local uid and
evaluates the file's mode or ACL against it, which
means name-mapping configuration and an account or
directory lookup for every user it serves.  Under
tight coupling the metadata server made the
authorization decision at LAYOUTGET time and the data
server compares the context's display name against
tsa_principal (<xref target="sec-tight-coupling-principal"/>)
without resolving it.  A client in another realm still
requires a cross-realm trust path to the data server's
realm, as it does for any Kerberos-protected NFS
service.</t>
            </li>
          </ul>
          <t>A deployment that runs the data path under AUTH_SYS or TLS
needs no client-facing Kerberos at the data server at all,
and may protect the control session with RPC-over-TLS rather
than RPCSEC_GSS (<xref target="sec-tight-coupling-control-session"/>).
That choice sets tsa_principal to the empty string and so
disables the principal check
(<xref target="sec-tight-coupling-principal"/>), leaving the stateid as
the sole authorization for the I/O;
<xref target="sec-security-trust-stateid"/> states what a leaked stateid
can then do.  This document does not prefer one
configuration over the other.  They differ in what they
require of the deployment and in what they protect: the
RPCSEC_GSS data path closes the flexible file v1 layout's
Kerberos gap (<xref target="sec-tight-coupling-principal"/>) and costs a
service principal and cross-realm trust at each data server;
the AUTH_SYS or TLS data path costs neither and leaves the
gap open.</t>
          <t>The mechanism does not authenticate the metadata server
to the client; it authenticates the client to the data
server using credentials the metadata server vouched for
at LAYOUTGET time.  Compromise of the metadata server
allows an attacker to register arbitrary trust entries;
the metadata server is the trust anchor for the layout
grant, unchanged from the existing pNFS layout-issuance
model.</t>
        </section>
        <section anchor="attack-surfaces-and-mitigations">
          <name>Attack Surfaces and Mitigations</name>
          <dl>
            <dt>Compromised metadata server:</dt>
            <dd>
              <t>An attacker controlling the metadata server can issue
TRUST_STATEID for any (layout stateid, principal)
pair.  This is the same trust assumption pNFS already
makes -- the metadata server grants layouts and the
data servers honor them.  Deployment defense is the
same: restrict administrative access to the metadata
server, authenticate the control session as
<xref target="sec-tight-coupling-control-session"/> requires, and
monitor for anomalous TRUST_STATEID volume.</t>
            </dd>
            <dt>Compromised data server:</dt>
            <dd>
              <t>A compromised data server sees plaintext chunk
payloads at rest and on the wire (subject to whatever
the deployment uses for at-rest encryption and
transport security).  It can return arbitrary content
on CHUNK_READ with a correctly computed checksum; the
checksum protects against transport corruption, not
adversarial content (<xref target="sec-security-checksum-scope"/>).
This is the same as the RAID-stripe trust model:
each shard host can lie about its shard.  Deployment
defenses are encryption at rest, an integrity-protected
transport (RPCSEC_GSS_KRB5I or TLS), and
physical or logical isolation of data servers.</t>
            </dd>
            <dt>Stateid leak from client to attacker:</dt>
            <dd>
              <t>Under tight coupling with RPCSEC_GSS, a leaked
stateid is not exploitable: the attacker's own RPC
principal will not match tsa_principal in the trust
table, and the data server returns NFS4ERR_ACCESS.
Under tight coupling with AUTH_SYS over TLS (where
tsa_principal is empty), a leaked stateid is
exploitable by any attacker who can also forge the
source-address binding the data server's TLS session
expects; this is the standard AUTH_SYS-over-TLS
trust model, unchanged.</t>
            </dd>
            <dt>Replay of revoked stateid:</dt>
            <dd>
              <t>After REVOKE_STATEID or BULK_REVOKE_STATEID the data
server removes the trust entry and subsequent CHUNK
operations presenting the revoked stateid fail with
NFS4ERR_BAD_STATEID (<xref target="sec-REVOKE_STATEID"/>).  An
in-flight CHUNK operation that arrived before the
revoke completed <bcp14>MAY</bcp14> be allowed to finish; the
chunk_guard4 CAS (<xref target="sec-chunk_guard4"/>) bounds the
worst-case damage from such in-flight I/O to the
chunks already PENDING at revocation time, and the
lock-transfer-to-metadata-server escrow rule
(<xref target="sec-chunk_guard_mds"/>) prevents a write hole from
opening during revocation.</t>
            </dd>
            <dt>Compromised control session:</dt>
            <dd>
              <t>An attacker who controls the metadata-server-to-data-server
control session can register or revoke
arbitrary trust entries.  The control session is the
most security-sensitive element introduced by tight
coupling, which is why
<xref target="sec-tight-coupling-control-session"/> requires it to be
mutually authenticated and integrity protected.  The
data server enforces that TRUST_STATEID,
REVOKE_STATEID, and BULK_REVOKE_STATEID only arrive
on sessions whose owning client presented
EXCHGID4_FLAG_USE_PNFS_MDS at EXCHANGE_ID
(<xref target="sec-TRUST_STATEID"/>), but that flag alone does not
authenticate the metadata server.</t>
            </dd>
            <dt>Downgrade to loose coupling:</dt>
            <dd>
              <t>Two paths let a storage device's reply turn tight
coupling off for a file.  At the capability probe
(<xref target="sec-tight-coupling-probe"/>) NFS4ERR_NOTSUPP leaves
the FFV2_COUPLING_TRUSTED_STATEID bit clear, and at
LAYOUTGET (<xref target="sec-tight-coupling-layoutget"/>) the same
error requires the metadata server to clear a bit it
had already set.  Either way the metadata server falls
back to the synthetic-uid model
(<xref target="sec-Fencing-Clients"/>), which provides a level of
security equivalent to AUTH_SYS, and the client is told
nothing is wrong.  An on-path attacker that can inject
one reply on an unprotected control session therefore
selects the weaker of the two coupling models; repeated
NFS4ERR_DELAY reaches the same result by exhausting the
metadata server's LAYOUTGET-response budget.  The
integrity protection
<xref target="sec-tight-coupling-control-session"/> requires is what
closes both paths: it is the only mechanism here that
distinguishes a storage device which does not implement
the TRUST_STATEID family from an attacker that says so.</t>
            </dd>
            <dt>Resource exhaustion via trust-table flood:</dt>
            <dd>
              <t>A misbehaving metadata server could register an
unbounded number of TRUST_STATEID entries to exhaust
the data server's trust-table memory.  The mechanism
defending against this is the tsa_expire lease on
each entry: trust entries that are not renewed
before expiry are reaped by the data server.  A data
server under memory pressure <bcp14>MAY</bcp14> also return
NFS4ERR_DELAY on new TRUST_STATEID requests, forcing
the metadata server to back off.</t>
            </dd>
            <dt>Cross-metadata-server isolation:</dt>
            <dd>
              <t>In a deployment where two metadata servers share a
single data server, the per-entry metadata-server
tag (derived from the control session's owning
client; see <xref target="sec-TRUST_STATEID"/>) ensures that
REVOKE_STATEID and BULK_REVOKE_STATEID from one
metadata server cannot remove entries registered by
the other.  A compromised metadata server can,
however, register entries against any filehandle the
data server exposes to it.  Deployments concerned
about cross-metadata-server isolation <bcp14>MUST</bcp14> partition
the data server's filesystem namespace into
per-metadata-server exports at the data server,
rather than rely on the trust table alone to enforce
file-level boundaries between metadata servers.</t>
            </dd>
          </dl>
          <t>A repair actor reconstructs and writes shards on behalf of other
clients via CHUNK_WRITE_REPAIR.  A malicious or buggy repair actor
is therefore a write path into data it did not originate; the
metadata server <bcp14>MUST</bcp14> validate repaired shards against the file's
registered checksum before accepting them, and integrity against a
malicious data server (as opposed to bit-flips) requires a
cryptographic checksum_algorithm together with transport security.
CHECKSUM_ALG_NONE and the CRC variants provide bit-flip detection
only.</t>
        </section>
      </section>
    </section>
    <section anchor="iana-considerations">
      <name>IANA Considerations</name>
      <t><xref target="RFC8881"/> introduced the "pNFS Layout Types Registry"; new layout
type numbers in this registry need to be assigned by IANA.  This
document defines a new layout type number: LAYOUT4_FLEX_FILES_V2
(see <xref target="tbl_layout_types"/>).</t>
      <table anchor="tbl_layout_types">
        <name>Layout Type Assignments</name>
        <thead>
          <tr>
            <th align="left">Layout Type Name</th>
            <th align="left">Value</th>
            <th align="left">RFC</th>
            <th align="left">How</th>
            <th align="left">Minor Versions</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">LAYOUT4_FLEX_FILES_V2</td>
            <td align="left">0x6</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">1</td>
          </tr>
        </tbody>
      </table>
      <t><xref target="RFC8881"/> also introduced the "NFSv4 Recallable Object Types
Registry".  This document defines new recallable objects for
RCA4_TYPE_MASK_FF2_LAYOUT_MIN and RCA4_TYPE_MASK_FF2_LAYOUT_MAX
(see <xref target="tbl_recallables"/>).</t>
      <table anchor="tbl_recallables">
        <name>Recallable Object Type Assignments</name>
        <thead>
          <tr>
            <th align="left">Recallable Object Type Name</th>
            <th align="left">Value</th>
            <th align="left">RFC</th>
            <th align="left">How</th>
            <th align="left">Minor Versions</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">RCA4_TYPE_MASK_FF2_LAYOUT_MIN</td>
            <td align="left">20</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">1</td>
          </tr>
          <tr>
            <td align="left">RCA4_TYPE_MASK_FF2_LAYOUT_MAX</td>
            <td align="left">21</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">1</td>
          </tr>
        </tbody>
      </table>
      <t>This document also requests IANA to register a new bit in the
"EXCHGID4<em>FLAG</em>*" flag space for the ExchangeID operation from
<xref section="18.35.3." sectionFormat="of" target="RFC8881"/>  The requested value is
<tt>0x00100000</tt>, outside the existing MASK_PNFS block (0x00070000);
IANA <bcp14>MAY</bcp14> assign a different value at its discretion, in which
case the numeric value in <xref target="fig-EXCHGID4_FLAG_USE_ERASURE_DS"/>
and its uses throughout the document are updated to match the
assignment.</t>
      <table anchor="tbl_exchgid_flags">
        <name>EXCHGID4 Flag Assignments</name>
        <thead>
          <tr>
            <th align="left">Flag Name</th>
            <th align="left">Value</th>
            <th align="left">RFC</th>
            <th align="left">Reference</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">EXCHGID4_FLAG_USE_ERASURE_DS</td>
            <td align="left">0x00100000</td>
            <td align="left">RFCTBD10</td>
            <td align="left">
              <xref target="fig-EXCHGID4_FLAG_USE_ERASURE_DS"/>, this doc</td>
          </tr>
        </tbody>
      </table>
      <t>This document requests IANA to allocate two attribute numbers in
the NFSv4 attribute-number registry (see <xref section="20" sectionFormat="of" target="RFC8881"/>).</t>
      <table anchor="tbl_attribute_assignments">
        <name>NFSv4 Attribute Assignments</name>
        <thead>
          <tr>
            <th align="left">Attribute Number</th>
            <th align="left">Attribute Name</th>
            <th align="left">RFC</th>
            <th align="left">Reference</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">89</td>
            <td align="left">FATTR4_CODING_BLOCK_SIZE</td>
            <td align="left">RFCTBD10</td>
            <td align="left">
              <xref target="sec-fattr4_coding_block_size"/></td>
          </tr>
          <tr>
            <td align="left">90</td>
            <td align="left">FATTR4_CHUNKED_DATA_FILE</td>
            <td align="left">RFCTBD10</td>
            <td align="left">
              <xref target="sec-fattr4_chunked_data_file"/></td>
          </tr>
        </tbody>
      </table>
      <t>This document introduces the 'Flexible File Version 2 Layout Type
Erasure Encoding Type Registry'.  The registry uses a 32-bit value
space partitioned into ranges based on the intended scope of the
encoding type (see <xref target="tbl-coding-ranges"/>).</t>
      <table anchor="tbl-coding-ranges">
        <name>Erasure Encoding Type Value Ranges (32-bit space)</name>
        <thead>
          <tr>
            <th align="left">Range</th>
            <th align="left">Purpose</th>
            <th align="left">Allocation Policy</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">0x0000</td>
            <td align="left">Reserved (uninitialized)</td>
            <td align="left">--</td>
          </tr>
          <tr>
            <td align="left">0x0001-0x00FF</td>
            <td align="left">Standards Track</td>
            <td align="left">IETF Review</td>
          </tr>
          <tr>
            <td align="left">0x0100-0x0FFF</td>
            <td align="left">Experimental</td>
            <td align="left">Expert Review</td>
          </tr>
          <tr>
            <td align="left">0x1000-0x7FFF</td>
            <td align="left">Vendor (open)</td>
            <td align="left">First Come First Served</td>
          </tr>
          <tr>
            <td align="left">0x8000-0xFFFE</td>
            <td align="left">Private/proprietary</td>
            <td align="left">No registration required</td>
          </tr>
          <tr>
            <td align="left">0xFFFF</td>
            <td align="left">Reserved</td>
            <td align="left">--</td>
          </tr>
          <tr>
            <td align="left">0x00010000-0xFFFFFFFF</td>
            <td align="left">Reserved (upper range)</td>
            <td align="left">Reserved for future partition</td>
          </tr>
        </tbody>
      </table>
      <t>The upper 16 bits of the 32-bit value space (0x00010000 through
0xFFFFFFFF) are reserved for future range extensions.  A receiver
that observes an <tt>ffv2_encoding_type4</tt> value in the reserved
region <bcp14>MUST</bcp14> treat it as an unsupported encoding type
(NFS4ERR_ENCODING_NOT_SUPPORTED).  Value 0x0000 is reserved as the
uninitialized-field sentinel and <bcp14>MUST NOT</bcp14> be allocated to an
encoding.</t>
      <dl>
        <dt>Standards Track (0x0000-0x00FF):</dt>
        <dd>
          <t>Encoding types intended for broad interoperability.  The
specification <bcp14>MUST</bcp14> include a complete mathematical description
sufficient for independent interoperable implementations (see
<xref target="encoding-type-interoperability"/>).  Allocated by IETF Review.</t>
        </dd>
        <dt>Experimental (0x0100-0x0FFF):</dt>
        <dd>
          <t>Encoding types under development or evaluation.  An Internet-Draft
is sufficient for allocation.  The specification <bcp14>SHOULD</bcp14> include
enough detail for interoperability testing.  Allocated by Expert
Review.</t>
        </dd>
        <dt>Vendor (open) (0x1000-0x7FFF):</dt>
        <dd>
          <t>Encoding types with a published specification or patent reference.
Interoperability is expected among implementations that license or
implement the specification.  The registration <bcp14>MUST</bcp14> include either a
math specification or a patent reference.  Allocated First Come
First Served.</t>
        </dd>
        <dt>Private/proprietary (0x8000-0xFFFE):</dt>
        <dd>
          <t>Encoding types for use within a single vendor's ecosystem.
No IANA registration is required.  Interoperability with other
implementations is not expected; accidental codepoint collisions
between independent vendors are possible and are managed
operationally rather than by protocol mechanism.  The encoding
type name <bcp14>SHOULD</bcp14> include an organizational identifier (e.g.,
<tt>FFV2_ENCODING_ACME_FOOBAR</tt>).  A client that encounters a
value in this range from an unrecognized server <bcp14>SHOULD</bcp14> treat
it as an unsupported encoding type
(<tt>NFS4ERR_ENCODING_NOT_SUPPORTED</tt>).</t>
        </dd>
      </dl>
      <t>This partitioning prevents contention for small numbers in the
Standards Track range and provides a clear signal to clients about
what level of interoperability to expect.</t>
      <t>This document defines seven encoding types: the flexible file v1 layout-compatible
PASSTHROUGH (see <xref target="sec-encoding-passthrough"/>), the chunked
MIRRORED (see <xref target="sec-encoding-replicated"/>), and five chunked
erasure encoding types (see <xref target="tbl-coding-types"/>).</t>
      <table anchor="tbl-coding-types">
        <name>Flexible File Version 2 Layout Type Encoding Type Assignments</name>
        <thead>
          <tr>
            <th align="left">Encoding Type Name</th>
            <th align="left">Value</th>
            <th align="left">RFC</th>
            <th align="left">How</th>
            <th align="left">Minor Versions</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">FFV2_ENCODING_PASSTHROUGH</td>
            <td align="left">1</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_MOJETTE_SYSTEMATIC</td>
            <td align="left">2</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC</td>
            <td align="left">3</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_RS_VANDERMONDE</td>
            <td align="left">4</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_REPLICATED</td>
            <td align="left">5</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_XOR_PARITY</td>
            <td align="left">6</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
          <tr>
            <td align="left">FFV2_ENCODING_LINUX_MD_RAID</td>
            <td align="left">7</td>
            <td align="left">RFCTBD10</td>
            <td align="left">L</td>
            <td align="left">2</td>
          </tr>
        </tbody>
      </table>
      <section anchor="iana-checksum-algorithms">
        <name>Checksum Algorithm Registry</name>
        <t>This document introduces the "Flexible File Version 2
Layout Type Checksum Algorithm Registry".  Values in this
registry name the checksum_algorithm4
(<xref target="sec-checksum4"/>) carried in checksum4 on the wire and
selected per-mirror via ffv2m_checksum_algorithm
(<xref target="sec-ffv2-mirror4"/>).</t>
        <t>The registry uses a 32-bit value space.  Registration
policy is Specification Required <xref target="RFC8126"/>; the Designated
Expert reviews each request for:</t>
        <ul spacing="normal">
          <li>
            <t>a complete and publicly available specification of the
algorithm sufficient for independent interoperable
implementations;</t>
          </li>
          <li>
            <t>the exact length of the cs_value field for this
algorithm (a single registered length per algorithm;
variable-length variants register separately);</t>
          </li>
          <li>
            <t>collision risk against existing registrations (the
Expert <bcp14>MAY</bcp14> decline to register an algorithm whose
output overlaps substantially with an existing
registration).</t>
          </li>
        </ul>
        <t>Initial registrations are listed in
<xref target="tbl-checksum-algorithms"/>.</t>
        <table anchor="tbl-checksum-algorithms">
          <name>Initial Checksum Algorithm Registrations</name>
          <thead>
            <tr>
              <th align="left">Name</th>
              <th align="left">Value</th>
              <th align="left">cs_value bytes</th>
              <th align="left">Class</th>
              <th align="left">RFC</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">CHECKSUM_ALG_NONE</td>
              <td align="left">0</td>
              <td align="left">0</td>
              <td align="left">none</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_CRC32</td>
              <td align="left">1</td>
              <td align="left">4</td>
              <td align="left">bit-flip</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_CRC32C</td>
              <td align="left">2</td>
              <td align="left">4</td>
              <td align="left">bit-flip</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_FLETCHER4</td>
              <td align="left">3</td>
              <td align="left">32</td>
              <td align="left">bit-flip</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_SHA256</td>
              <td align="left">4</td>
              <td align="left">32</td>
              <td align="left">cryptographic</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_SHA512</td>
              <td align="left">5</td>
              <td align="left">64</td>
              <td align="left">cryptographic</td>
              <td align="left">RFCTBD10</td>
            </tr>
            <tr>
              <td align="left">CHECKSUM_ALG_BLAKE3</td>
              <td align="left">6</td>
              <td align="left">32</td>
              <td align="left">cryptographic</td>
              <td align="left">RFCTBD10</td>
            </tr>
          </tbody>
        </table>
        <t>CHECKSUM_ALG_NONE (value 0) indicates that no
protocol-level checksum is computed.  The deployment relies
on transport-layer integrity (RPC-over-TLS, RPCSEC_GSS_KRB5I)
or storage-layer integrity instead; see
<xref target="sec-security-checksum-scope"/>.</t>
        <t>CHECKSUM_ALG_CRC32 (value 1) is the CRC-32 algorithm
specified in <xref target="ITU-V42"/> Section 8.1.1.6.2 (the same CRC
used in Ethernet <xref target="IEEE802-3"/> Section 3.2.9, PNG
<xref target="RFC2083"/> Annex D, and zlib <xref target="RFC1950"/>).  Concrete
parameters, which two independent implementations <bcp14>MUST</bcp14>
agree on to interoperate: generator polynomial
<tt>0x04C11DB7</tt> (equivalently, the reflected form
<tt>0xEDB88320</tt>); initial register value <tt>0xFFFFFFFF</tt>; final
XOR value <tt>0xFFFFFFFF</tt>; input reflected; output reflected.
The 4-byte <tt>cs_value</tt> carries the CRC as a big-endian
integer.  Covered bytes follow the uniform coverage rule
in <xref target="sec-checksum4"/> (chunk header + chunk payload with
the checksum field's bytes treated as zero, in
wire-transmission order).  Deployments <bcp14>SHOULD</bcp14> prefer
CHECKSUM_ALG_CRC32C for new files since CRC32C is
hardware-accelerated on every modern CPU.</t>
        <t>CHECKSUM_ALG_CRC32C (value 2) is the CRC-32 with the
Castagnoli polynomial specified in <xref section="12.1" sectionFormat="of" target="RFC3720"/> and
adopted by <xref section="6.4" sectionFormat="of" target="RFC4960"/> (SCTP), and also as the SSE4.2 /
ARMv8 / RISC-V CRC-32C hardware-acceleration instructions.  Concrete
parameters: generator polynomial <tt>0x1EDC6F41</tt> (equivalently, the
reflected form <tt>0x82F63B78</tt>); initial register value <tt>0xFFFFFFFF</tt>;
final XOR value <tt>0xFFFFFFFF</tt>; input reflected; output reflected.  The
4-byte <tt>cs_value</tt> carries the CRC as a big-endian integer.  Covered
bytes follow the uniform coverage rule in <xref target="sec-checksum4"/>.</t>
        <t>CHECKSUM_ALG_FLETCHER4 (value 3) is the ZFS Fletcher4
variant as documented in the OpenZFS on-disk format
specification <xref target="OPENZFS-FLETCHER4"/>.  Covered bytes
follow the uniform coverage rule in <xref target="sec-checksum4"/>;
this algorithm additionally requires the covered input
(header + chunk with the checksum field's bytes treated
as zero) to be a multiple of 4 bytes, since the input is
processed as a sequence of little-endian 32-bit words.
Implementations that need to checksum a chunk whose
covered input is not a multiple of 4 bytes pad with zero
bytes and register the padded variant separately.
Concrete parameters: the four 64-bit accumulators <tt>A</tt>,
<tt>B</tt>, <tt>C</tt>, <tt>D</tt> are updated per word <tt>wi</tt> as
<tt>A += wi; B += A; C += B; D += C</tt> with 64-bit unsigned
wrap-around; the 32-byte <tt>cs_value</tt> is the concatenation
<tt>A || B || C || D</tt> with each accumulator serialized in
big-endian byte order.  Other Fletcher4 implementations
(different word width, different endianness, truncated
output) register separately.</t>
        <t>CHECKSUM_ALG_SHA256 (value 4) and CHECKSUM_ALG_SHA512
(value 5) are the SHA-256 and SHA-512 hash algorithms
specified in <xref target="FIPS-180-4"/>, with output byte lengths 32
and 64 respectively.  The <tt>cs_value</tt> carries the hash
output in the byte order defined by <xref target="FIPS-180-4"/> Section
3.1 (most-significant word first, each word serialized
big-endian).  Covered bytes follow the uniform coverage
rule in <xref target="sec-checksum4"/>.</t>
        <t>CHECKSUM_ALG_BLAKE3 (value 6) is the BLAKE3 hash algorithm
specified in <xref target="BLAKE3-SPEC"/> at its standard 32-byte
output length (BLAKE3 in its default mode, no keyed hash,
no key-derivation context, no XOF output at other
lengths).  Extended-output BLAKE3, keyed BLAKE3, and the
key-derivation mode register as separate algorithms.
Covered bytes follow the uniform coverage rule in
<xref target="sec-checksum4"/>; <tt>cs_value</tt> is the 32-byte hash output
in the byte order defined by <xref target="BLAKE3-SPEC"/> Section 2.4.</t>
        <t>A checksum4 whose cs_value length does not match the
registered cs_value bytes for its cs_algorithm <bcp14>MUST</bcp14> be
rejected with NFS4ERR_INVAL.</t>
        <t>The "Class" column in <xref target="tbl-checksum-algorithms"/> is
informational and indicates the threat model the algorithm
supports; see <xref target="sec-security-checksum-scope"/>.</t>
      </section>
      <section anchor="iana-proof-profile">
        <name>Proof-Profile Registry</name>
        <t>This document introduces the "Flexible File Version 2
Proof-Profile Registry".  Values in this registry name
the proof_profile_id4 (<xref target="sec-proof-profile"/>) that a
metadata server presents in CHUNK_ESCROW_TAKEOVER to identify which
incarnation-lease proof format the accompanying
ceta_proof_data carries.</t>
        <t>The registry uses a 32-bit value space.  Registration
policy is Specification Required <xref target="RFC8126"/>; the
Designated Expert reviews each request for:</t>
        <ul spacing="normal">
          <li>
            <t>a complete and publicly available specification of
the proof format sufficient for independent
interoperable implementations (envelope, signature
algorithm, payload field set, replay-cache
semantics, and expiry handling);</t>
          </li>
          <li>
            <t>compatibility with the strict evaluation ordering
specified in <xref target="sec-proof-profile"/> (session replay
-&gt; presenter authorization -&gt; profile support -&gt;
proof verification -&gt; epoch compare-and-advance);
a registration whose verification cannot be
evaluated after presenter authorization <bcp14>MUST</bcp14> be
declined;</t>
          </li>
          <li>
            <t>a clear statement of the trust anchor the profile
relies on (deployment-provisioned public key set,
Kerberos KDC, etc.), and whether the profile
requires wire negotiation of any parameter (a
profile that requires wire negotiation not
defined in this document or its cited references
<bcp14>MUST</bcp14> be declined).</t>
          </li>
        </ul>
        <t>Initial registrations are listed in
<xref target="tbl-proof-profiles"/>.</t>
        <table anchor="tbl-proof-profiles">
          <name>Initial Proof-Profile Registrations</name>
          <thead>
            <tr>
              <th align="left">Name</th>
              <th align="left">Value</th>
              <th align="left">Reference</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">PROOF_PROFILE_UNSPECIFIED</td>
              <td align="left">0</td>
              <td align="left">Reserved sentinel; see <xref target="sec-proof-profile"/></td>
            </tr>
            <tr>
              <td align="left">PROOF_PROFILE_HA_AUTHORITY_ED25519</td>
              <td align="left">1</td>
              <td align="left">
                <xref target="sec-proof-profile"/> "Mandatory-to-Implement Profile"</td>
            </tr>
          </tbody>
        </table>
        <t>Additional profiles named in
<xref target="sec-proof-profile"/> (ECDSA-P256 alg -7,
RSASSA-PSS-SHA256 alg -37) <bcp14>MAY</bcp14> be added later per
the Specification Required policy above.</t>
        <t>The value range 0xC0000000 to 0xFFFFFFFF is
reserved for Private Use per <xref section="4.1" sectionFormat="of" target="RFC8126"/>; deployments
<bcp14>MAY</bcp14> assign values from this range for experimental, vendor-specific,
or private profiles without IANA registration, but such values <bcp14>MUST
NOT</bcp14> be presented on interoperability boundaries and this specification
makes no compatibility guarantees for them.</t>
      </section>
    </section>
    <section anchor="xdr-description-of-the-flexible-file-version-2-layout-type">
      <name>XDR Description of the Flexible File Version 2 Layout Type</name>
      <t>This document contains the External Data Representation (XDR)
<xref target="RFC4506"/> description of the flexible file v2 layout.  The XDR
description is embedded in this document in a way that makes it simple
for the reader to extract into a ready-to-compile form.  The reader can
feed this document into the shell script in <xref target="fig-extract"/>, which
relies on the sh, grep, and sed utilities as specified by <xref target="POSIX"/>,
to produce the machine-readable XDR description of the flexible file
v2 layout.</t>
      <figure anchor="fig-extract">
        <name>extract.sh</name>
        <sourcecode type="shell"><![CDATA[
#!/bin/sh
grep '^ *///' $* | sed 's?^ */// ??' | sed 's?^ *///$??'
]]></sourcecode>
      </figure>
      <t>That is, if the above script is stored in a file called "extract.sh"
and this document is in a file called "spec.txt", then the reader can
run the script as in <xref target="fig-extract-example"/>.</t>
      <figure anchor="fig-extract-example">
        <name>Example use of extract.sh</name>
        <sourcecode type="shell"><![CDATA[
sh extract.sh < spec.txt > flex_files2_prot.x
]]></sourcecode>
      </figure>
      <t>The effect of the script is to remove leading blank space from each
line, plus a sentinel sequence of "///".</t>
      <t>XDR descriptions with the sentinel sequence are embedded throughout
the document.</t>
      <t>Note that the XDR code contained in this document depends on types
from the NFSv4.2 nfs4_prot.x file <xref target="RFC7863"/> (which itself builds on
<xref target="RFC5662"/>).  This includes both nfs types that end with a 4, such
as offset4, length4, etc., as well as more generic types such as
uint32_t and uint64_t.</t>
      <t>While the XDR can be appended to that from <xref target="RFC7863"/>, the various
code snippets belong in their respective areas of that XDR.</t>
    </section>
  </middle>
  <back>
    <references anchor="sec-combined-references">
      <name>References</name>
      <references anchor="sec-normative-references">
        <name>Normative References</name>
        <reference anchor="I-D.haynes-nfsv4-flexfiles-v2-delta-writes">
          <front>
            <title>Delta-Write Extension for the Flexible File Version 2 Layout Type</title>
            <author fullname="Thomas Haynes" initials="T." surname="Haynes">
              <organization>Hammerspace</organization>
            </author>
            <date day="7" month="August" year="2026"/>
            <abstract>
              <t>   The Flexible File Version 2 pNFS layout type defines a chunk-oriented
   data-server protocol in which every write is a full-chunk payload.
   For workloads that make small edits to files protected by an XOR-
   based erasure encoding, this forces client-side stripe fetch, re-
   encode, and transmit on every edit, with wire amplification of three
   to four orders of magnitude per byte edited.  This document defines
   an optional extension, CHUNK_XOR_DELTA, that lets a client transmit a
   per-projection XOR delta directly to each data server holding a
   projection of the affected stripe; the data server applies the delta
   locally.  The extension is restricted to XOR-linear systematic
   encodings and XOR-affine checksums, using the existing chunk state
   machine with no new commit protocol.

              </t>
            </abstract>
          </front>
          <seriesInfo name="Internet-Draft" value="draft-haynes-nfsv4-flexfiles-v2-delta-writes-00"/>
        </reference>
        <reference anchor="RFC4121">
          <front>
            <title>The Kerberos Version 5 Generic Security Service Application Program Interface (GSS-API) Mechanism: Version 2</title>
            <author fullname="L. Zhu" initials="L." surname="Zhu"/>
            <author fullname="K. Jaganathan" initials="K." surname="Jaganathan"/>
            <author fullname="S. Hartman" initials="S." surname="Hartman"/>
            <date month="July" year="2005"/>
            <abstract>
              <t>This document defines protocols, procedures, and conventions to be employed by peers implementing the Generic Security Service Application Program Interface (GSS-API) when using the Kerberos Version 5 mechanism.</t>
              <t>RFC 1964 is updated and incremental changes are proposed in response to recent developments such as the introduction of Kerberos cryptosystem framework. These changes support the inclusion of new cryptosystems, by defining new per-message tokens along with their encryption and checksum algorithms based on the cryptosystem profiles. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="4121"/>
          <seriesInfo name="DOI" value="10.17487/RFC4121"/>
        </reference>
        <reference anchor="RFC4506">
          <front>
            <title>XDR: External Data Representation Standard</title>
            <author fullname="M. Eisler" initials="M." role="editor" surname="Eisler"/>
            <date month="May" year="2006"/>
            <abstract>
              <t>This document describes the External Data Representation Standard (XDR) protocol as it is currently deployed and accepted. This document obsoletes RFC 1832. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="67"/>
          <seriesInfo name="RFC" value="4506"/>
          <seriesInfo name="DOI" value="10.17487/RFC4506"/>
        </reference>
        <reference anchor="RFC5531">
          <front>
            <title>RPC: Remote Procedure Call Protocol Specification Version 2</title>
            <author fullname="R. Thurlow" initials="R." surname="Thurlow"/>
            <date month="May" year="2009"/>
            <abstract>
              <t>This document describes the Open Network Computing (ONC) Remote Procedure Call (RPC) version 2 protocol as it is currently deployed and accepted. This document obsoletes RFC 1831. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="5531"/>
          <seriesInfo name="DOI" value="10.17487/RFC5531"/>
        </reference>
        <reference anchor="RFC5662">
          <front>
            <title>Network File System (NFS) Version 4 Minor Version 1 External Data Representation Standard (XDR) Description</title>
            <author fullname="S. Shepler" initials="S." role="editor" surname="Shepler"/>
            <author fullname="M. Eisler" initials="M." role="editor" surname="Eisler"/>
            <author fullname="D. Noveck" initials="D." role="editor" surname="Noveck"/>
            <date month="January" year="2010"/>
            <abstract>
              <t>This document provides the External Data Representation Standard (XDR) description for Network File System version 4 (NFSv4) minor version 1. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="5662"/>
          <seriesInfo name="DOI" value="10.17487/RFC5662"/>
        </reference>
        <reference anchor="RFC7530">
          <front>
            <title>Network File System (NFS) Version 4 Protocol</title>
            <author fullname="T. Haynes" initials="T." role="editor" surname="Haynes"/>
            <author fullname="D. Noveck" initials="D." role="editor" surname="Noveck"/>
            <date month="March" year="2015"/>
            <abstract>
              <t>The Network File System (NFS) version 4 protocol is a distributed file system protocol that builds on the heritage of NFS protocol version 2 (RFC 1094) and version 3 (RFC 1813). Unlike earlier versions, the NFS version 4 protocol supports traditional file access while integrating support for file locking and the MOUNT protocol. In addition, support for strong security (and its negotiation), COMPOUND operations, client caching, and internationalization has been added. Of course, attention has been applied to making NFS version 4 operate well in an Internet environment.</t>
              <t>This document, together with the companion External Data Representation (XDR) description document, RFC 7531, obsoletes RFC 3530 as the definition of the NFS version 4 protocol.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="7530"/>
          <seriesInfo name="DOI" value="10.17487/RFC7530"/>
        </reference>
        <reference anchor="RFC7861">
          <front>
            <title>Remote Procedure Call (RPC) Security Version 3</title>
            <author fullname="A. Adamson" initials="A." surname="Adamson"/>
            <author fullname="N. Williams" initials="N." surname="Williams"/>
            <date month="November" year="2016"/>
            <abstract>
              <t>This document specifies version 3 of the Remote Procedure Call (RPC) security protocol (RPCSEC_GSS). This protocol provides support for multi-principal authentication of client hosts and user principals to a server (constructed by generic composition), security label assertions for multi-level security and type enforcement, structured privilege assertions, and channel bindings. This document updates RFC 5403.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="7861"/>
          <seriesInfo name="DOI" value="10.17487/RFC7861"/>
        </reference>
        <reference anchor="RFC7862">
          <front>
            <title>Network File System (NFS) Version 4 Minor Version 2 Protocol</title>
            <author fullname="T. Haynes" initials="T." surname="Haynes"/>
            <date month="November" year="2016"/>
            <abstract>
              <t>This document describes NFS version 4 minor version 2; it describes the protocol extensions made from NFS version 4 minor version 1. Major extensions introduced in NFS version 4 minor version 2 include the following: Server-Side Copy, Application Input/Output (I/O) Advise, Space Reservations, Sparse Files, Application Data Blocks, and Labeled NFS.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="7862"/>
          <seriesInfo name="DOI" value="10.17487/RFC7862"/>
        </reference>
        <reference anchor="RFC7863">
          <front>
            <title>Network File System (NFS) Version 4 Minor Version 2 External Data Representation Standard (XDR) Description</title>
            <author fullname="T. Haynes" initials="T." surname="Haynes"/>
            <date month="November" year="2016"/>
            <abstract>
              <t>This document provides the External Data Representation (XDR) description for NFS version 4 minor version 2.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="7863"/>
          <seriesInfo name="DOI" value="10.17487/RFC7863"/>
        </reference>
        <reference anchor="RFC8126">
          <front>
            <title>Guidelines for Writing an IANA Considerations Section in RFCs</title>
            <author fullname="M. Cotton" initials="M." surname="Cotton"/>
            <author fullname="B. Leiba" initials="B." surname="Leiba"/>
            <author fullname="T. Narten" initials="T." surname="Narten"/>
            <date month="June" year="2017"/>
            <abstract>
              <t>Many protocols make use of points of extensibility that use constants to identify various protocol parameters. To ensure that the values in these fields do not have conflicting uses and to promote interoperability, their allocations are often coordinated by a central record keeper. For IETF protocols, that role is filled by the Internet Assigned Numbers Authority (IANA).</t>
              <t>To make assignments in a given registry prudently, guidance describing the conditions under which new values should be assigned, as well as when and how modifications to existing values can be made, is needed. This document defines a framework for the documentation of these guidelines by specification authors, in order to assure that the provided guidance for the IANA Considerations is clear and addresses the various issues that are likely in the operation of a registry.</t>
              <t>This is the third edition of this document; it obsoletes RFC 5226.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="26"/>
          <seriesInfo name="RFC" value="8126"/>
          <seriesInfo name="DOI" value="10.17487/RFC8126"/>
        </reference>
        <reference anchor="RFC8178">
          <front>
            <title>Rules for NFSv4 Extensions and Minor Versions</title>
            <author fullname="D. Noveck" initials="D." surname="Noveck"/>
            <date month="July" year="2017"/>
            <abstract>
              <t>This document describes the rules relating to the extension of the NFSv4 family of protocols. It covers the creation of minor versions, the addition of optional features to existing minor versions, and the correction of flaws in features already published as Proposed Standards. The rules relating to the construction of minor versions and the interaction of minor version implementations that appear in this document supersede the minor versioning rules in RFC 5661 and other RFCs defining minor versions.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="8178"/>
          <seriesInfo name="DOI" value="10.17487/RFC8178"/>
        </reference>
        <reference anchor="RFC8434">
          <front>
            <title>Requirements for Parallel NFS (pNFS) Layout Types</title>
            <author fullname="T. Haynes" initials="T." surname="Haynes"/>
            <date month="August" year="2018"/>
            <abstract>
              <t>This document defines the requirements that individual Parallel NFS (pNFS) layout types need to meet in order to work within the pNFS framework as defined in RFC 5661. In so doing, this document aims to clearly distinguish between requirements for pNFS as a whole and those specifically directed to the pNFS file layout. The lack of a clear separation between the two sets of requirements has been troublesome for those specifying and evaluating new layout types. In this regard, this document updates RFC 5661.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="8434"/>
          <seriesInfo name="DOI" value="10.17487/RFC8434"/>
        </reference>
        <reference anchor="RFC8435">
          <front>
            <title>Parallel NFS (pNFS) Flexible File Layout</title>
            <author fullname="B. Halevy" initials="B." surname="Halevy"/>
            <author fullname="T. Haynes" initials="T." surname="Haynes"/>
            <date month="August" year="2018"/>
            <abstract>
              <t>Parallel NFS (pNFS) allows a separation between the metadata (onto a metadata server) and data (onto a storage device) for a file. The flexible file layout type is defined in this document as an extension to pNFS that allows the use of storage devices that require only a limited degree of interaction with the metadata server and use already-existing protocols. Client-side mirroring is also added to provide replication of files.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="8435"/>
          <seriesInfo name="DOI" value="10.17487/RFC8435"/>
        </reference>
        <reference anchor="RFC8881">
          <front>
            <title>Network File System (NFS) Version 4 Minor Version 1 Protocol</title>
            <author fullname="D. Noveck" initials="D." role="editor" surname="Noveck"/>
            <author fullname="C. Lever" initials="C." surname="Lever"/>
            <date month="August" year="2020"/>
            <abstract>
              <t>This document describes the Network File System (NFS) version 4 minor version 1, including features retained from the base protocol (NFS version 4 minor version 0, which is specified in RFC 7530) and protocol extensions made subsequently. The later minor version has no dependencies on NFS version 4 minor version 0, and is considered a separate protocol.</t>
              <t>This document obsoletes RFC 5661. It substantially revises the treatment of features relating to multi-server namespace, superseding the description of those features appearing in RFC 5661.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="8881"/>
          <seriesInfo name="DOI" value="10.17487/RFC8881"/>
        </reference>
        <reference anchor="RFC9289">
          <front>
            <title>Towards Remote Procedure Call Encryption by Default</title>
            <author fullname="T. Myklebust" initials="T." surname="Myklebust"/>
            <author fullname="C. Lever" initials="C." role="editor" surname="Lever"/>
            <date month="September" year="2022"/>
            <abstract>
              <t>This document describes a mechanism that, through the use of opportunistic Transport Layer Security (TLS), enables encryption of Remote Procedure Call (RPC) transactions while they are in transit. The proposed mechanism interoperates with Open Network Computing (ONC) RPC implementations that do not support it. This document updates RFC 5531.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9289"/>
          <seriesInfo name="DOI" value="10.17487/RFC9289"/>
        </reference>
        <reference anchor="RFC2119">
          <front>
            <title>Key words for use in RFCs to Indicate Requirement Levels</title>
            <author fullname="S. Bradner" initials="S." surname="Bradner"/>
            <date month="March" year="1997"/>
            <abstract>
              <t>In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="2119"/>
          <seriesInfo name="DOI" value="10.17487/RFC2119"/>
        </reference>
        <reference anchor="RFC8174">
          <front>
            <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
            <author fullname="B. Leiba" initials="B." surname="Leiba"/>
            <date month="May" year="2017"/>
            <abstract>
              <t>RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="8174"/>
          <seriesInfo name="DOI" value="10.17487/RFC8174"/>
        </reference>
        <reference anchor="RFC9052">
          <front>
            <title>CBOR Object Signing and Encryption (COSE): Structures and Process</title>
            <author fullname="J. Schaad" initials="J." surname="Schaad"/>
            <date month="August" year="2022"/>
            <abstract>
              <t>Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines the CBOR Object Signing and Encryption (COSE) protocol. This specification describes how to create and process signatures, message authentication codes, and encryption using CBOR for serialization. This specification additionally describes how to represent cryptographic keys using CBOR.</t>
              <t>This document, along with RFC 9053, obsoletes RFC 8152.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="96"/>
          <seriesInfo name="RFC" value="9052"/>
          <seriesInfo name="DOI" value="10.17487/RFC9052"/>
        </reference>
        <reference anchor="RFC8949">
          <front>
            <title>Concise Binary Object Representation (CBOR)</title>
            <author fullname="C. Bormann" initials="C." surname="Bormann"/>
            <author fullname="P. Hoffman" initials="P." surname="Hoffman"/>
            <date month="December" year="2020"/>
            <abstract>
              <t>The Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. These design goals make it different from earlier binary serializations such as ASN.1 and MessagePack.</t>
              <t>This document obsoletes RFC 7049, providing editorial improvements, new details, and errata fixes while keeping full compatibility with the interchange format of RFC 7049. It does not create a new version of the format.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="94"/>
          <seriesInfo name="RFC" value="8949"/>
          <seriesInfo name="DOI" value="10.17487/RFC8949"/>
        </reference>
        <reference anchor="RFC9053">
          <front>
            <title>CBOR Object Signing and Encryption (COSE): Initial Algorithms</title>
            <author fullname="J. Schaad" initials="J." surname="Schaad"/>
            <date month="August" year="2022"/>
            <abstract>
              <t>Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines a set of algorithms that can be used with the CBOR Object Signing and Encryption (COSE) protocol (RFC 9052).</t>
              <t>This document, along with RFC 9052, obsoletes RFC 8152.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9053"/>
          <seriesInfo name="DOI" value="10.17487/RFC9053"/>
        </reference>
      </references>
      <references anchor="sec-informative-references">
        <name>Informative References</name>
        <reference anchor="POSIX" target="https://standards.ieee.org/ieee/1003.1/7700/">
          <front>
            <title>IEEE Standard for Information Technology--Portable Operating System Interface (POSIX) Base Specifications, Issue 8</title>
            <author>
              <organization>IEEE</organization>
            </author>
            <author>
              <organization>The Open Group</organization>
            </author>
            <date year="2024"/>
          </front>
          <seriesInfo name="IEEE" value="Std 1003.1-2024"/>
        </reference>
        <reference anchor="Plank97" target="http://web.eecs.utk.edu/~jplank/plank/papers/CS-96-332.htm">
          <front>
            <title>A Tutorial on Reed-Solomon Coding for Fault-Tolerance in RAID-like System</title>
            <author initials="J." surname="Plank" fullname="J. Plank">
              <organization/>
            </author>
            <date year="1997" month="September"/>
          </front>
        </reference>
        <reference anchor="IANA-PEN" target="https://www.iana.org/assignments/enterprise-numbers/">
          <front>
            <title>Private Enterprise Numbers</title>
            <author>
              <organization>IANA</organization>
            </author>
            <date/>
          </front>
        </reference>
        <reference anchor="RFC1813" xml:base="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.1813.xml">
          <front>
            <title>NFS Version 3 Protocol Specification</title>
            <author fullname="B. Callaghan" initials="B." surname="Callaghan"/>
            <author fullname="B. Pawlowski" initials="B." surname="Pawlowski"/>
            <author fullname="P. Staubach" initials="P." surname="Staubach"/>
            <date month="June" year="1995"/>
            <abstract>
              <t>This paper describes the NFS version 3 protocol. This paper is provided so that people can write compatible implementations. This memo provides information for the Internet community. This memo does not specify an Internet standard of any kind.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="1813"/>
          <seriesInfo name="DOI" value="10.17487/RFC1813"/>
        </reference>
        <reference anchor="RFC1950">
          <front>
            <title>ZLIB Compressed Data Format Specification version 3.3</title>
            <author fullname="P. Deutsch" initials="P." surname="Deutsch"/>
            <author fullname="J-L. Gailly" surname="J-L. Gailly"/>
            <date month="May" year="1996"/>
            <abstract>
              <t>This specification defines a lossless compressed data format. This memo provides information for the Internet community. This memo does not specify an Internet standard of any kind.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="1950"/>
          <seriesInfo name="DOI" value="10.17487/RFC1950"/>
        </reference>
        <reference anchor="RFC2083">
          <front>
            <title>PNG (Portable Network Graphics) Specification Version 1.0</title>
            <author fullname="T. Boutell" initials="T." surname="Boutell"/>
            <date month="March" year="1997"/>
            <abstract>
              <t>This document describes PNG (Portable Network Graphics), an extensible file format for the lossless, portable, well-compressed storage of raster images. PNG provides a patent-free replacement for GIF and can also replace many common uses of TIFF. Indexed-color, grayscale, and truecolor images are supported, plus an optional alpha channel. Sample depths range from 1 to 16 bits.</t>
              <t>PNG is designed to work well in online viewing applications, such as the World Wide Web, so it is fully streamable with a progressive display option. PNG is robust, providing both full file integrity checking and simple detection of common transmission errors. Also, PNG can store gamma and chromaticity data for improved color matching on heterogeneous platforms.</t>
              <t>This specification defines the Internet Media Type image/png.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="2083"/>
          <seriesInfo name="DOI" value="10.17487/RFC2083"/>
        </reference>
        <reference anchor="RFC2743">
          <front>
            <title>Generic Security Service Application Program Interface Version 2, Update 1</title>
            <author fullname="J. Linn" initials="J." surname="Linn"/>
            <date month="January" year="2000"/>
            <abstract>
              <t>This memo obsoletes [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="2743"/>
          <seriesInfo name="DOI" value="10.17487/RFC2743"/>
        </reference>
        <reference anchor="RFC3720">
          <front>
            <title>Internet Small Computer Systems Interface (iSCSI)</title>
            <author fullname="J. Satran" initials="J." surname="Satran"/>
            <author fullname="K. Meth" initials="K." surname="Meth"/>
            <author fullname="C. Sapuntzakis" initials="C." surname="Sapuntzakis"/>
            <author fullname="M. Chadalapaka" initials="M." surname="Chadalapaka"/>
            <author fullname="E. Zeidner" initials="E." surname="Zeidner"/>
            <date month="April" year="2004"/>
            <abstract>
              <t>This document describes a transport protocol for Internet Small Computer Systems Interface (iSCSI) that works on top of TCP. The iSCSI protocol aims to be fully compliant with the standardized SCSI architecture model. SCSI is a popular family of protocols that enable systems to communicate with I/O devices, especially storage devices. SCSI protocols are request/response application protocols with a common standardized architecture model and basic command set, as well as standardized command sets for different device classes (disks, tapes, media-changers etc.). As system interconnects move from the classical bus structure to a network structure, SCSI has to be mapped to network transport protocols. IP networks now meet the performance requirements of fast system interconnects and as such are good candidates to "carry" SCSI. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="3720"/>
          <seriesInfo name="DOI" value="10.17487/RFC3720"/>
        </reference>
        <reference anchor="RFC4519">
          <front>
            <title>Lightweight Directory Access Protocol (LDAP): Schema for User Applications</title>
            <author fullname="A. Sciberras" initials="A." role="editor" surname="Sciberras"/>
            <date month="June" year="2006"/>
            <abstract>
              <t>This document is an integral part of the Lightweight Directory Access Protocol (LDAP) technical specification. It provides a technical specification of attribute types and object classes intended for use by LDAP directory clients for many directory services, such as White Pages. These objects are widely used as a basis for the schema in many LDAP directories. This document does not cover attributes used for the administration of directory servers, nor does it include directory objects defined for specific uses in other documents. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="4519"/>
          <seriesInfo name="DOI" value="10.17487/RFC4519"/>
        </reference>
        <reference anchor="RFC4960">
          <front>
            <title>Stream Control Transmission Protocol</title>
            <author fullname="R. Stewart" initials="R." role="editor" surname="Stewart"/>
            <date month="September" year="2007"/>
            <abstract>
              <t>This document obsoletes RFC 2960 and RFC 3309. It describes the Stream Control Transmission Protocol (SCTP). SCTP is designed to transport Public Switched Telephone Network (PSTN) signaling messages over IP networks, but is capable of broader applications.</t>
              <t>SCTP is a reliable transport protocol operating on top of a connectionless packet network such as IP. It offers the following services to its users:</t>
              <t>-- acknowledged error-free non-duplicated transfer of user data,</t>
              <t>-- data fragmentation to conform to discovered path MTU size,</t>
              <t>-- sequenced delivery of user messages within multiple streams, with an option for order-of-arrival delivery of individual user messages,</t>
              <t>-- optional bundling of multiple user messages into a single SCTP packet, and</t>
              <t>-- network-level fault tolerance through supporting of multi-homing at either or both ends of an association.</t>
              <t>The design of SCTP includes appropriate congestion avoidance behavior and resistance to flooding and masquerade attacks. [STANDARDS-TRACK]</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="4960"/>
          <seriesInfo name="DOI" value="10.17487/RFC4960"/>
        </reference>
        <reference anchor="RFC5905">
          <front>
            <title>Network Time Protocol Version 4: Protocol and Algorithms Specification</title>
            <author fullname="D. Mills" initials="D." surname="Mills"/>
            <author fullname="J. Martin" initials="J." role="editor" surname="Martin"/>
            <author fullname="J. Burbank" initials="J." surname="Burbank"/>
            <author fullname="W. Kasch" initials="W." surname="Kasch"/>
            <date month="June" year="2010"/>
            <abstract>
              <t>The Network Time Protocol (NTP) is widely used to synchronize computer clocks in the Internet. This document describes NTP version 4 (NTPv4), which is backwards compatible with NTP version 3 (NTPv3), described in RFC 1305, as well as previous versions of the protocol. NTPv4 includes a modified protocol header to accommodate the Internet Protocol version 6 address family. NTPv4 includes fundamental improvements in the mitigation and discipline algorithms that extend the potential accuracy to the tens of microseconds with modern workstations and fast LANs. It includes a dynamic server discovery scheme, so that in many cases, specific server configuration is not required. It corrects certain errors in the NTPv3 design and implementation and includes an optional extension mechanism.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="5905"/>
          <seriesInfo name="DOI" value="10.17487/RFC5905"/>
        </reference>
        <reference anchor="RFC7942">
          <front>
            <title>Improving Awareness of Running Code: The Implementation Status Section</title>
            <author fullname="Y. Sheffer" initials="Y." surname="Sheffer"/>
            <author fullname="A. Farrel" initials="A." surname="Farrel"/>
            <date month="July" year="2016"/>
            <abstract>
              <t>This document describes a simple process that allows authors of Internet-Drafts to record the status of known implementations by including an Implementation Status section. This will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature.</t>
              <t>This process is not mandatory. Authors of Internet-Drafts are encouraged to consider using the process for their documents, and working groups are invited to think about applying the process to all of their protocol specifications. This document obsoletes RFC 6982, advancing it to a Best Current Practice.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="205"/>
          <seriesInfo name="RFC" value="7942"/>
          <seriesInfo name="DOI" value="10.17487/RFC7942"/>
        </reference>
        <reference anchor="FIPS-180-4" target="https://doi.org/10.6028/NIST.FIPS.180-4">
          <front>
            <title>Secure Hash Standard (SHS)</title>
            <author>
              <organization>National Institute of Standards and Technology</organization>
            </author>
            <date year="2015" month="August"/>
          </front>
          <seriesInfo name="NIST" value="FIPS PUB 180-4"/>
        </reference>
        <reference anchor="BLAKE3-SPEC" target="https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf">
          <front>
            <title>BLAKE3: one function, fast everywhere</title>
            <author initials="J." surname="O'Connor" fullname="J. O'Connor">
              <organization/>
            </author>
            <author initials="J.-P." surname="Aumasson" fullname="J.-P. Aumasson">
              <organization/>
            </author>
            <author initials="S." surname="Neves" fullname="S. Neves">
              <organization/>
            </author>
            <author initials="Z." surname="Wilcox-O'Hearn" fullname="Z. Wilcox-O'Hearn">
              <organization/>
            </author>
            <date year="2020" month="January"/>
          </front>
        </reference>
        <reference anchor="ITU-V42">
          <front>
            <title>Error-correcting Procedures for DCEs Using Asynchronous-to-Synchronous Conversion</title>
            <author>
              <organization>International Telecommunication Union</organization>
            </author>
            <date year="2002" month="March"/>
          </front>
          <seriesInfo name="ITU-T" value="Recommendation V.42"/>
        </reference>
        <reference anchor="IEEE802-3">
          <front>
            <title>IEEE Standard for Ethernet</title>
            <author>
              <organization>IEEE</organization>
            </author>
            <date year="2022"/>
          </front>
          <seriesInfo name="IEEE" value="802.3-2022"/>
        </reference>
        <reference anchor="OPENZFS-FLETCHER4" target="https://openzfs.github.io/openzfs-docs/Basic%20Concepts/Checksums.html">
          <front>
            <title>OpenZFS On-Disk Format Specification, Section 2.2.4: Fletcher</title>
            <author>
              <organization>OpenZFS</organization>
            </author>
            <date/>
          </front>
        </reference>
        <reference anchor="PARREIN">
          <front>
            <title>Multiple Description Coding Using Exact Discrete Radon Transform</title>
            <author initials="B." surname="Parrein" fullname="B. Parrein">
              <organization/>
            </author>
            <author initials="N." surname="Normand" fullname="N. Normand">
              <organization/>
            </author>
            <author initials="J.-P." surname="Guedon" fullname="J.-P. Guedon">
              <organization/>
            </author>
            <date year="2001"/>
          </front>
          <seriesInfo name="IEEE" value="Data Compression Conference (DCC)"/>
        </reference>
        <reference anchor="NORMAND">
          <front>
            <title>A Geometry Driven Reconstruction Algorithm for the Mojette Transform</title>
            <author initials="N." surname="Normand" fullname="N. Normand">
              <organization/>
            </author>
            <author initials="A." surname="Kingston" fullname="A. Kingston">
              <organization/>
            </author>
            <author initials="P." surname="Evenou" fullname="P. Evenou">
              <organization/>
            </author>
            <date year="2006"/>
          </front>
          <seriesInfo name="LNCS" value="4245, pp. 122-133, DGCI 2006"/>
        </reference>
        <reference anchor="KATZ">
          <front>
            <title>Questions of Uniqueness and Resolution in Reconstruction from Projections</title>
            <author initials="M." surname="Katz" fullname="M. Katz">
              <organization/>
            </author>
            <date year="1978"/>
          </front>
          <seriesInfo name="Springer" value=""/>
        </reference>
        <reference anchor="LINUX-RAID6" target="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/lib/raid6">
          <front>
            <title>Linux kernel software RAID (md/raid6) -- lib/raid6</title>
            <author initials="H. P." surname="Anvin" fullname="H. P. Anvin">
              <organization/>
            </author>
            <author>
              <organization>Linux kernel contributors</organization>
            </author>
            <date/>
          </front>
        </reference>
        <reference anchor="DCACHE" target="https://dcache.org/">
          <front>
            <title>dCache -- a distributed storage system</title>
            <author>
              <organization>dCache collaboration (DESY, Fermilab, NDGF)</organization>
            </author>
            <date/>
          </front>
        </reference>
        <reference anchor="I-D.haynes-nfsv4-flexfiles-v2-proxy-server">
          <front>
            <title>Proxy-Driven Server for Flexible Files Version 2</title>
            <author fullname="Thomas Haynes" initials="T." surname="Haynes">
              <organization>Hammerspace</organization>
            </author>
            <date day="7" month="August" year="2026"/>
            <abstract>
              <t>   Parallel NFS (pNFS) with the Flexible Files Version 2 layout type
   supports client-side erasure coding and per-chunk repair between
   clients and data servers.  This document extends that architecture
   with a proxy server role: a registered peer of the metadata server
   that polls the metadata server for work assignments and carries them
   out -- moving a file from one layout to another, reconstructing a
   whole file from surviving shards, or translating between encodings
   for clients that cannot participate in the file's native encoding
   (including NFSv3 clients).  All proxy-server-to-metadata-server
   coordination is fore-channel: the metadata server returns work
   assignments inline in the response to a proxy-server-initiated
   PROXY_PROGRESS poll, and the proxy server reports completion via a
   fore-channel PROXY_DONE.  No callback operations are required for the
   proxy server protocol.

              </t>
            </abstract>
          </front>
          <seriesInfo name="Internet-Draft" value="draft-haynes-nfsv4-flexfiles-v2-proxy-server-04"/>
        </reference>
      </references>
    </references>
    <?line 15292?>

<section numbered="false" removeInRFC="true" anchor="sec-implementation-status">
      <name>Implementation Status</name>
      <t>This appendix records the implementation status of this
specification at the time of writing.  The purpose, per
<xref target="RFC7942"/>, is to help reviewers evaluate the protocol
against running code and to document which parts have
been validated end-to-end versus specified on paper.
This appendix is reviewer-aid material and is removed
from the final RFC.</t>
      <section numbered="false" anchor="reffs-metadata-server-data-server-and-ecdemo-client">
        <name>reffs (metadata server, data server, and ec_demo client)</name>
        <dl>
          <dt>Organization:</dt>
          <dd>
            <t>Independent / open source.</t>
          </dd>
          <dt>License:</dt>
          <dd>
            <t>AGPL-3.0-or-later.</t>
          </dd>
          <dt>Source:</dt>
          <dd>
            <t><eref target="https://github.com/loghyr/reffs">https://github.com/loghyr/reffs</eref>.</t>
          </dd>
          <dt>Implementation:</dt>
          <dd>
            <t><tt>reffs</tt> is an NFSv4.2 server written in C that acts as both a
metadata server and a data server in a flexible file v2 layout
deployment.  A separate binary implements the proxy server role
defined in the proxy server draft.  <tt>ec_demo</tt> is a client-side
library with a demonstration driver that
exercises the flexible file v2 layout data path over NFSv4.2.</t>
          </dd>
        </dl>
        <t>Coverage:</t>
        <ul spacing="normal">
          <li>
            <t>CHUNK_WRITE, CHUNK_READ, CHUNK_FINALIZE, and CHUNK_COMMIT (the
happy-path data-plane operations) are implemented end-to-end
and have been exercised against multiple encoding families.</t>
          </li>
          <li>
            <t>CHUNK_WRITE_REPAIR and CHUNK_REPAIRED (client-driven single-shard
reconstruction with server-side layout-flag clearing)
are implemented end-to-end and have been exercised across four
file sizes, two encoding families, and one- and two-shard-loss
patterns; end-to-end integrity verification passes on
substantially all measured cells.</t>
          </li>
          <li>
            <t>The chunk_guard4 CAS primitive, including the conflict-detection
and deterministic-tiebreaker rules in <xref target="sec-chunk_guard4"/>, is
implemented on both the client and the data server.</t>
          </li>
          <li>
            <t>Per-chunk checksum integrity checking (see
<xref target="sec-security-checksum-scope"/>) is implemented end-to-end.</t>
          </li>
          <li>
            <t>Per-inode persistent storage of chunk state (PENDING /
FINALIZED / COMMITTED) is implemented using write-temp /
fdatasync / rename for crash safety.</t>
          </li>
          <li>
            <t>Encoders for FFV2_ENCODING_REPLICATED, FFV2_ENCODING_PASSTHROUGH,
FFV2_ENCODING_XOR_PARITY, FFV2_ENCODING_LINUX_MD_RAID,
FFV2_ENCODING_RS_VANDERMONDE, FFV2_ENCODING_MOJETTE_SYSTEMATIC,
and FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC are all implemented
and cross-verified against the wire-compatibility relationships
described in the per-encoding sections of this document.</t>
          </li>
          <li>
            <t>The tight coupling control protocol (TRUST_STATEID,
REVOKE_STATEID, BULK_REVOKE_STATEID) is specified but not
yet implemented.  Data servers currently advertise
<tt>ffv2dv_coupling = FFV2_COUPLING_SYNTHETIC_UIDS</tt>, and
synthetic
AUTH_SYS credentials with fencing are used for access
control.</t>
          </li>
          <li>
            <t>The proxy server mediated repair callback CB_PROXY_REPAIR is
specified but not yet implemented.  Single-shard repair is
currently client-driven via <tt>ec_demo</tt>.</t>
          </li>
        </ul>
        <dl>
          <dt>Level of maturity:</dt>
          <dd>
            <t>Research-quality prototype.  The implementation demonstrates
the protocol and has produced the benchmark data summarized
below.  It is not production-ready.</t>
          </dd>
          <dt>Contact:</dt>
          <dd>
            <t>loghyr@gmail.com.</t>
          </dd>
          <dt>Last update:</dt>
          <dd>
            <t>August 2026.</t>
          </dd>
        </dl>
      </section>
      <section numbered="false" anchor="linux-kernel-flexible-file-v2-client">
        <name>Linux kernel flexible file v2 client</name>
        <dl>
          <dt>Organization:</dt>
          <dd>
            <t>Independent / open source.  Out-of-tree kernel module built
against a mainline Linux release candidate.</t>
          </dd>
          <dt>License:</dt>
          <dd>
            <t>GPL-2.0.</t>
          </dd>
          <dt>Source:</dt>
          <dd>
            <t>Topic branch tracked against a mainline Linux release
candidate; contact the author for the current tree pointer.</t>
          </dd>
          <dt>Implementation:</dt>
          <dd>
            <t>A native pNFS layout driver at <tt>fs/nfs/flexfilesv2/</tt>
implementing the flexible file v2 layout for the Linux
NFS client.  Layout registration, XDR decode of
<tt>ffv2_layout4</tt>, device-info discovery, striped and mirrored
read and write, and the CHUNK operation wire path are implemented as
a peer layout driver alongside the existing flexible file v1
driver.</t>
          </dd>
        </dl>
        <t>Coverage:</t>
        <ul spacing="normal">
          <li>
            <t>CHUNK_WRITE, CHUNK_READ, CHUNK_FINALIZE, and CHUNK_COMMIT are
implemented end-to-end and wire-verified against the <tt>reffs</tt>
metadata server + data server on a 64-bit ARM Linux host at
the 7.2-rc series.</t>
          </li>
          <li>
            <t>Per-chunk checksum integrity, chunk_guard4 CAS,
writeback-chain sequencing (CHUNK_WRITE -&gt; CHUNK_FINALIZE -&gt;
CHUNK_COMMIT), and DENSE per-shard offset canonicalization
are implemented.</t>
          </li>
          <li>
            <t>Encoders for FFV2_ENCODING_REPLICATED, FFV2_ENCODING_XOR_PARITY,
FFV2_ENCODING_LINUX_MD_RAID, and FFV2_ENCODING_RS_VANDERMONDE
are present.  FFV2_ENCODING_MOJETTE_SYSTEMATIC is scaffolded
(returns -EOPNOTSUPP; native kernel implementation deferred).</t>
          </li>
          <li>
            <t>NFSv3 and NFSv4.2 data-server dispatch are both implemented.</t>
          </li>
          <li>
            <t>NFS4ERR_DELAY retry-with-backoff for concurrent writer
contention on CHUNK_WRITE is not yet implemented; multi-writer
workloads fall back to routing writes through the metadata
server.</t>
          </li>
          <li>
            <t>Client-side single-shard repair write-back is not yet
implemented in the kernel client.  Reconstruction is
available via <tt>ec_demo</tt> against the same metadata server.</t>
          </li>
        </ul>
        <dl>
          <dt>Level of maturity:</dt>
          <dd>
            <t>Developer preview.  Wire-verified on the CHUNK operation happy path
against the <tt>reffs</tt> server.</t>
          </dd>
          <dt>Contact:</dt>
          <dd>
            <t>loghyr@gmail.com.</t>
          </dd>
          <dt>Last update:</dt>
          <dd>
            <t>August 2026.</t>
          </dd>
        </dl>
      </section>
      <section numbered="false" anchor="interoperability-and-benchmarks">
        <name>Interoperability and Benchmarks</name>
        <t>Two independent implementations of the client role now exist
(the <tt>ec_demo</tt> userspace library and the Linux kernel layout
driver above), and wire-compatibility between them on the
CHUNK operation data path has been demonstrated against the <tt>reffs</tt>
metadata server.  In addition, the Mojette encoders in this
document have been cross-verified against an independent
Mojette implementation with byte-identical output for
FFV2_ENCODING_MOJETTE_SYSTEMATIC and
FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC.</t>
        <t>The benchmark suite is now organized to distinguish two costs
that were previously conflated in a single-host Docker
measurement:</t>
        <dl>
          <dt>Algorithm cost:</dt>
          <dd>
            <t>the CPU + memory-bandwidth cost of
encoding and decoding, measured against pre-allocated RAM
buffers with no I/O and no network.  This is the encoder
ceiling on a given host.</t>
          </dd>
          <dt>Transmit cost:</dt>
          <dd>
            <t>the end-to-end cost of a write or read
on a real NFSv4.2 mount across three hosts on a LAN,
including RPC round-trips, fsync commits, and network
serialization.</t>
          </dd>
        </dl>
        <t>The two-axis measurement makes explicit what the previous
single-host measurement obscured: on a real network, encoder
algorithm cost is a small fraction of end-to-end transmit
cost at typical operating points.</t>
        <section numbered="false" anchor="algorithm-cost">
          <name>Algorithm cost</name>
          <t>Algorithm cost has been measured at k=4, m=2, 64 KiB shards
across the encoders defined in this document.  Reference hosts
spanned four CPU classes: Apple silicon (aarch64, NEON), Intel
x86_64 (SSE+AVX2), AMD Zen 2 mobile (SSE+AVX2), and ten uniform
AMD Zen 3 virtual machines (variance across the fleet under 5%
on all encoders).</t>
          <t>Across these encoders and the four host classes, algorithm-cost
spread on the same host reaches approximately two orders of
magnitude at k=4, m=2 (the fastest SIMD-vectorized encoders
approach the memory-bandwidth ceiling in the tens of GB/s; the
slowest scalar encoders are compute-bound in the low hundreds
of MB/s).</t>
          <t>Two hand-tuning passes on the Reed-Solomon Vandermonde encoder
in this document, performed without any change to the wire
format or test vectors, compounded to roughly 17x on aarch64
NEON and roughly 39x on x86_64 SSSE3 -- a precomputed field-multiplication
table pass followed by a SIMD byte-shuffle field
arithmetic pass (<tt>vqtbl1q_u8</tt> / <tt>pshufb</tt>).  A similar
implementation-only optimization pass on the Mojette encoder
wrapper yielded roughly 4.85x on x86_64 AVX2, again with
byte-identical output.</t>
          <t>The generalization is that a naive per-encoder microbenchmark
cell measures implementation quality on that host, not the
encoding algorithm.  Wide reported spreads across encoders in
the literature reflect this in large part.</t>
        </section>
        <section numbered="false" anchor="wire-compatibility-across-encoders">
          <name>Wire compatibility across encoders</name>
          <t>Cross-encoder byte-identity holds among the GF(2^8) encoders
defined in this document at low parity counts, verified by
encoding on one implementation and decoding on another
byte-for-byte:</t>
          <ul spacing="normal">
            <li>
              <t>At m = 1: FFV2_ENCODING_XOR_PARITY, the P row of
FFV2_ENCODING_LINUX_MD_RAID, and the m=1 parity row of
FFV2_ENCODING_RS_VANDERMONDE all emit byte-identical output
for the same (k, data) input.</t>
            </li>
            <li>
              <t>At m = 2: FFV2_ENCODING_LINUX_MD_RAID and
FFV2_ENCODING_RS_VANDERMONDE emit byte-identical output for
the same (k, data) input, provided RS_VANDERMONDE uses the
hand-crafted P + Q parity rows this document defines (see
<xref target="sec-encoding-linux-md-raid"/>).</t>
            </li>
            <li>
              <t>At m &gt;= 3: the encoders diverge; RS_VANDERMONDE reverts to
normalized-Vandermonde bottom rows and no cross-encoder
byte-identity holds.</t>
            </li>
          </ul>
          <t>The practical consequence is that a receiver that supports any
one of the m &lt;= 2 members consumes bytes emitted by any of the
others without re-encoding.</t>
        </section>
        <section numbered="false" anchor="transmit-cost-three-host-real-network-sweep">
          <name>Transmit cost -- three-host real-network sweep</name>
          <t>A three-host LAN measurement distributes the roles: one client
host (kernel NFSv4.2 mount), one proxy server host, and one
host running both the metadata server and the data servers.
Four wire-path variants are distinguished:</t>
          <table>
            <thead>
              <tr>
                <th align="left">Variant</th>
                <th align="left">Client wire</th>
                <th align="left">Encoder location</th>
                <th align="left">Path hops</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">a</td>
                <td align="left">FFv1 -&gt; 1 DS</td>
                <td align="left">none (baseline)</td>
                <td align="left">1</td>
              </tr>
              <tr>
                <td align="left">b</td>
                <td align="left">FFv1 striped</td>
                <td align="left">none (fan-out only)</td>
                <td align="left">1</td>
              </tr>
              <tr>
                <td align="left">c</td>
                <td align="left">FFv2 -&gt; DSes</td>
                <td align="left">client</td>
                <td align="left">1</td>
              </tr>
              <tr>
                <td align="left">d</td>
                <td align="left">FFv2 -&gt; PS -&gt; DSes</td>
                <td align="left">proxy server</td>
                <td align="left">2</td>
              </tr>
            </tbody>
          </table>
          <t>A 180-cell sweep across five encoders x four variants x three
file sizes x three iterations verified end-to-end data
integrity in every cell.</t>
          <t>Median write throughput at 1 MiB was:</t>
          <ul spacing="normal">
            <li>
              <t>Variant a (FFv1, single data server): approximately
3.2 to 5.1 MB/s across encoders.</t>
            </li>
            <li>
              <t>Variant b (FFv1, striped): approximately
9.3 to 13.0 MB/s across encoders.</t>
            </li>
            <li>
              <t>Variant c (FFv2, client-direct): approximately
10.0 to 13.5 MB/s across encoders.</t>
            </li>
            <li>
              <t>Variant d (FFv2, via proxy server): approximately
1.1 to 2.2 MB/s across encoders.</t>
            </li>
          </ul>
          <t>The key finding: an approximately three-order-of-magnitude
algorithm-cost spread across encoders collapses to
approximately 1.15x wire spread at the client-direct FFv2
variant (variant c) at 1 MiB.  End-to-end throughput on this
topology is dominated by RPC round-trips, fsync commits, and
network serialization; encoder algorithm cost is a rounding-error
contributor at these operating points.</t>
          <t>The approximately seven-fold variant d penalty (1.1-2.2 MB/s
vs 10.0-13.5 MB/s) is the extra client to proxy server hop,
not the encoder.</t>
          <t>Decomposing a 1 MiB write on this topology into cost
components:</t>
          <table>
            <thead>
              <tr>
                <th align="left">Cost item</th>
                <th align="right">ms/MiB</th>
              </tr>
            </thead>
            <tbody>
              <tr>
                <td align="left">Fastest SIMD encode (algorithm only)</td>
                <td align="right">0.05</td>
              </tr>
              <tr>
                <td align="left">Reed-Solomon Vandermonde SSSE3 encode</td>
                <td align="right">1.7</td>
              </tr>
              <tr>
                <td align="left">Reed-Solomon Vandermonde scalar encode (pre-opt)</td>
                <td align="right">66</td>
              </tr>
              <tr>
                <td align="left">Variant a: FFv1 to 1 DS (no EC, baseline)</td>
                <td align="right">215</td>
              </tr>
              <tr>
                <td align="left">Variant b: FFv1 striped (no EC, fan-out)</td>
                <td align="right">95</td>
              </tr>
              <tr>
                <td align="left">Variant c: FFv2 direct to DSes (client EC)</td>
                <td align="right">92</td>
              </tr>
              <tr>
                <td align="left">Variant d: FFv2 via PS (PS EC)</td>
                <td align="right">610-910</td>
              </tr>
            </tbody>
          </table>
          <t>The variant c wire floor of approximately 92 ms/MiB is where
end-to-end throughput lives; encoder algorithm cost accounts
for well under 2 ms of that budget for every SIMD-tuned
implementation measured.</t>
        </section>
        <section numbered="false" anchor="cost-of-fault-tolerance-single-shard-repair">
          <name>Cost of fault tolerance -- single-shard repair</name>
          <t>Client-driven single-shard reconstruction, using the wire-level
<tt>OP_CHUNK_WRITE_REPAIR</tt> + <tt>OP_CHUNK_REPAIRED</tt> operations
this document defines, was benchmarked on a colocated topology
across the following axes:</t>
          <ul spacing="normal">
            <li>
              <t>File sizes: 4 KB, 64 KB, 1 MB, 16 MB</t>
            </li>
            <li>
              <t>Encoding families: Reed-Solomon Vandermonde and Mojette
systematic (both at k=4, m=2)</t>
            </li>
            <li>
              <t>Loss patterns: one shard missing, two shards missing</t>
            </li>
            <li>
              <t>Five iterations per cell (80 cells total)</t>
            </li>
          </ul>
          <t>Substantially all cells passed end-to-end integrity
verification.  Median repair time at 1 MB, RS 4+2, one shard
lost was approximately 80 ms; at 16 MB, approximately 990 ms.
Mojette systematic at the same operating points was
approximately 72 ms and 900 ms respectively.  Repair cost
decomposes as <tt>degraded-read cost + write-back cost per lost
shard</tt> (not (k + m) writes -- CHUNK_WRITE_REPAIR is targeted).</t>
          <t>At file sizes &gt;= 64 KB, repair cost is within one order of
magnitude of a healthy write of the same size -- not the
catastrophic overhead the phrase "erasure coding repair" might
imply.  Healthy no-loss reads on any systematic encoding pay
zero decode cost (the shard is copied through unchanged).</t>
        </section>
        <section numbered="false" anchor="encoder-family-trade-offs">
          <name>Encoder-family trade-offs</name>
          <t>The wire-spread convergence does not mean encoder choice is
irrelevant.  It means encoder choice is decided by properties
other than raw algorithm speed at typical operating points:</t>
          <dl>
            <dt>Fault tolerance and geometry:</dt>
            <dd>
              <t>FFV2_ENCODING_RS_VANDERMONDE and the Mojette family support
arbitrary (k, m); FFV2_ENCODING_XOR_PARITY is m = 1 only;
FFV2_ENCODING_LINUX_MD_RAID is m = 2 only.</t>
            </dd>
            <dt>Interoperability:</dt>
            <dd>
              <t>the m &lt;= 2 byte-identical set described above lets a
deployment mix implementations of different encoders at the
same k and m without cross-encoding.</t>
            </dd>
            <dt>Reconstruction cost:</dt>
            <dd>
              <t>systematic encodings (FFV2_ENCODING_RS_VANDERMONDE,
FFV2_ENCODING_MOJETTE_SYSTEMATIC, FFV2_ENCODING_XOR_PARITY,
FFV2_ENCODING_LINUX_MD_RAID) short-circuit no-loss reads at
wire speed; FFV2_ENCODING_MOJETTE_NON_SYSTEMATIC transforms
every shard on every read.</t>
            </dd>
            <dt>Wide-geometry scaling:</dt>
            <dd>
              <t>at k &gt;= 8, m &gt;= 4, the Mojette back-projection reconstruction
cost scales with m (parity count) rather than k (data count),
so its reconstruction overhead does not exhibit the O(k^3)
growth Reed-Solomon matrix inversion incurs at wider
geometries.</t>
            </dd>
            <dt>Implementation availability:</dt>
            <dd>
              <t>FFV2_ENCODING_XOR_PARITY has no external dependency;
FFV2_ENCODING_LINUX_MD_RAID's reference construction is
present in every Linux kernel at <tt>lib/raid6/</tt>
(<xref target="LINUX-RAID6"/>).  The remaining encoders in this document
have reference implementations in the sources cited above.</t>
            </dd>
          </dl>
          <t>A full benchmark report with per-cell tables, per-host medians,
and per-variant transmit decompositions is available alongside
the source code.</t>
        </section>
      </section>
      <section numbered="false" anchor="sec-architectural-implication">
        <name>Architectural Implication: Cost of Fault Tolerance</name>
        <t>The headline question every storage audience asks of an
erasure-coding protocol is: "what does it cost when something goes
wrong?"  At the systematic-encoding operating points measured
(Mojette systematic at 4+2 and 8+2), the benchmark answer is
essentially zero.  Mojette systematic at 4+2 reconstructs a
missing data shard with read-latency overhead within run-to-run
noise of healthy operation.  Mojette systematic at 8+2 holds at
approximately +4%.</t>
        <t>This shifts the deployment conversation away from "is erasure
coding cheap enough to enable" and toward "which encoding and
geometry minimize the compromise."  The compromise that remains is
not the cost of fault tolerance; it is the cost of write-time
encoding, which is bounded (under 60% at 1 MB, under 25% at 64 KB),
and the cost of crash-safe durability via the chunk state machine
(see <xref target="sec-system-model-consistency"/>), which is +7% to +22% on
writes and +2% to +10% on reads.</t>
        <t>Wire-format performance objections raised earlier in the working
group's review of this work are addressed in
<xref target="sec-rejected-alternatives"/>: the per-RPC byte-shuffling cost of
the original Mojette-specific projection header has been replaced
with XDR-encoded chunk metadata (see <xref target="sec-chunk_guard4"/>), so the
remaining wire format cost is the XDR-encoded chunk header itself,
which is identical for every encoding and is part of the +7% to +22%
v2 write overhead measured above.</t>
      </section>
    </section>
    <section numbered="false" anchor="sec-rejected-alternatives">
      <name>Design Rationale: Rejected Alternatives</name>
      <t>This appendix records design alternatives that were
considered and rejected during the development of this
specification.  It is reviewer-aid material in this draft
and is retained in the final RFC as design-history
context for future implementers; the alternatives below
are not part of the normative specification.</t>
      <t>The design of flexible file v2 layout went through several iterations between
2024 and 2026 that are recorded here for the benefit of future
reviewers and implementers.  Each alternative below was considered
and rejected, with the specific concern that led to its rejection.
Understanding why these approaches were rejected may help reviewers
evaluate the current design against a fuller space of possibilities
and may guide future extensions or replacements.</t>
      <section numbered="false" anchor="proprietary-projection-header-inside-opaque-payload">
        <name>Proprietary Projection Header Inside Opaque Payload</name>
        <t>The earliest iteration placed a 16-byte Mojette-specific header at
the start of the READ/WRITE opaque payload, interpreted in the
endianness of the writer's host.  The motivation was concrete:
NFSv3 READ and WRITE arguments carry data as <tt>opaque data&lt;&gt;</tt> and
provide no XDR room for per-write structured metadata such as
encoding geometry, integrity, or write-ordering tiebreakers.  An
NFSv3 server cannot be extended; if a flexible file v2 layout deployment
wanted an NFSv3 server to participate as a data server in an
erasure-coded layout, the only place to put encoding metadata was
inside that opaque payload, prepended to the data bytes.  The data server
stored the entire opaque blob without interpreting it; the reader
peeled the 16-byte prefix off and acted on it.</t>
        <t>This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>It embedded a specific erasure encoding type (Mojette) into the
generic replication-method framework, preventing alternate
codings from reusing the same wire format.</t>
          </li>
          <li>
            <t>The header bytes were not XDR-aligned, which required every
implementation to handle endianness explicitly rather than
relying on XDR's natural byte order.</t>
          </li>
          <li>
            <t>Carrying integrity and identification data inside an opaque
disrespected the XDR self-description model that the rest of
NFSv4 relies on.  A generic NFSv3 inspector watching the wire
could not tell those bytes apart from application data, which
among other things made debugging, traffic analysis, and
middlebox processing rely on out-of-band knowledge.</t>
          </li>
        </ul>
        <t>The endianness objection raised at IETF 120 (July 2024) was the
surface complaint; the structural objection -- that smuggling
structured fields through an opaque type bypasses XDR's
self-description -- was the deeper reason the working group
declined the approach.  Once the design accepted that data
servers in a flexible file v2 layout deployment would speak
NFSv4.2 (with new ops in this document), the constraint that
forced the smuggling disappeared: chunk metadata could be
expressed as proper XDR fields in CHUNK_WRITE / CHUNK_READ /
chunk_guard4, visible to every observer of the wire.</t>
      </section>
      <section numbered="false" anchor="per-client-swap-files-with-metadata-server-mappingrecall">
        <name>Per-Client Swap Files with metadata server MAPPING_RECALL</name>
        <t>One proposal split logical and physical chunk addressing: the
metadata server maintained a mapping from logical offset to
physical location, and the client appended new chunks to a
per-client staging file on each data server before asking the
metadata server to atomically remap the file to the new chunks.
This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>The MAPPING_RECALL operation required to atomically update the
mapping would, in a multi-writer deployment, have to recall all
outstanding read/write layouts on the file -- grinding the
application to a halt during every remap.</t>
          </li>
          <li>
            <t>Each client required its own staging file on every data server,
producing N clients * M data servers staging files that had to
be reconciled on client restart.</t>
          </li>
          <li>
            <t>The approach was biased toward correctness at the expense of
throughput, which inverted the expected workload mix where
single writer cases dominate.</t>
          </li>
        </ul>
      </section>
      <section numbered="false" anchor="server-side-byte-range-lock-manager-per-file">
        <name>Server-Side Byte-Range Lock Manager per File</name>
        <t>Another proposal relied on byte range locks obtained by clients
before writing, with the lock manager state spread across the data
servers.  This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>A failed lock holder required a lock manager to arbitrate
recovery, effectively reintroducing a centralized decision
point for each chunk.</t>
          </li>
          <li>
            <t>The lock recall path for HPC checkpoint workloads (many ranks
writing disjoint regions) would have required thousands of
locks per file, with recall storms on every phase transition.</t>
          </li>
          <li>
            <t>The design did not specify how the lock manager itself would
be replicated for high availability, deferring the hardest
part of the problem.</t>
          </li>
        </ul>
        <t>The current design uses CHUNK_LOCK (see <xref target="sec-CHUNK_LOCK"/>) but
only on the repair path, not on the normal write path.</t>
      </section>
      <section numbered="false" anchor="modified-two-touch-paxos-on-each-chunk">
        <name>Modified Two-Touch Paxos on Each Chunk</name>
        <t>A fully distributed-consensus proposal placed a lightweight
(modified two-touch) Paxos round on each chunk write, reaching
agreement among the data servers holding the mirror set.  This was
rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>The constant-factor cost per write (two or three round trips,
leader election overhead, majority quorum requirement) was
unacceptable for workloads where single writer throughput
dominates the deployment mix.</t>
          </li>
          <li>
            <t>The approach demanded that data servers be peers in a
consensus protocol, which is a substantially heavier
requirement than being independent chunk stores.</t>
          </li>
          <li>
            <t>A majority of (k + m) data servers must be reachable for any
progress, which is a strictly stronger availability requirement
than the k-of-(k + m) needed for erasure-coded reads.</t>
          </li>
        </ul>
        <t>Working-group feedback on this proposal was uniformly negative.
The current design retains the option -- nothing in this
specification prevents an implementation from running classical
consensus internally among metadata server replicas (see
<xref target="sec-system-model-consensus"/>) -- but does not require it per
write.</t>
      </section>
      <section numbered="false" anchor="automatic-commit-of-empty-chunks">
        <name>Automatic Commit of Empty Chunks</name>
        <t>An earlier version included a WRITE_BLOCK_FLAGS_COMMIT_IF_EMPTY
flag (later renamed CHUNK_WRITE_FLAGS_ACTIVATE_IF_EMPTY) that
automatically committed a write to a previously-empty chunk
without a separate CHUNK_COMMIT round trip.  The flag is retained
in the current design but its scope was narrowed: it is
performant in the exclusive-writer case but produces blocks that
cannot be rolled back if a racing writer appears concurrently,
requiring either hole-punching or an extension of CHUNK_ROLLBACK
to work on committed blocks.  The narrow scope is documented in
the flag's definition; a broader version was rejected because it
created rollback liabilities that were disproportionate to the
single-RTT savings.</t>
      </section>
      <section numbered="false" anchor="global-clock-or-wall-clock-based-generation-counter">
        <name>Global Clock or Wall-Clock-Based Generation Counter</name>
        <t>An early design used a wall-clock timestamp as the cg_gen_id.
This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>No global clock exists among the many clients of a
multi-rack deployment.  Clock skew can cause a newer write
to appear to have an earlier timestamp than an older one.</t>
          </li>
          <li>
            <t>Timestamps at millisecond or microsecond resolution are not
fine-grained enough to disambiguate bursty writes from the
same client.</t>
          </li>
          <li>
            <t>Mixing client identity bits into the low-order bits of a
timestamp (to make it unique) reduces effective timestamp
resolution without providing a useful total ordering.</t>
          </li>
        </ul>
        <t>The current design uses a per-chunk monotonic counter scoped to
the chunk on the data server, with cg_client_id as the
disambiguator across clients.  See <xref target="sec-chunk_guard4"/>.</t>
      </section>
      <section numbered="false" anchor="layout-level-generation-counter">
        <name>Layout-Level Generation Counter</name>
        <t>An alternative raised at IETF 122 (March 2025) was adding a
generation counter to the layout itself, transmitted to the
data servers alongside each I/O, so that the metadata server
could redirect writes to new data servers without issuing a
full CB_LAYOUTRECALL storm across every holder of the file.
This is a natural extension of the per-chunk cg_gen_id: where
cg_gen_id disambiguates successive writes to the same chunk, a
layout-level counter would disambiguate successive placements
of the same data.  This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>The use case is already covered.  CB_CHUNK_REPAIR (see
<xref target="sec-CB_CHUNK_REPAIR"/>) and the proxy server mechanism
together handle mid-layout remap without requiring a
layout-level epoch on the wire.  CB_CHUNK_REPAIR reaches the specific
chunks that need redirection; the proxy server reaches the
broader re-placement case; between them the full remap
space is covered.</t>
          </li>
          <li>
            <t>Adding a layout-level counter introduces a second,
potentially-conflicting epoch alongside cg_gen_id.  The CAS
semantics on the data server would have to compose the two
generations (per-chunk and per-layout), which multiplies
the states the data server must reason about without
strengthening any guarantee the protocol offers today.</t>
          </li>
          <li>
            <t>The CB_LAYOUTRECALL storm that motivated the proposal is a
worst-case cost that the current design pays only during a
genuine data-server retirement or full re-placement.
Partial remaps -- the common case -- already flow through
CB_CHUNK_REPAIR + layout refresh on LAYOUTGET without
disturbing other holders.</t>
          </li>
        </ul>
        <t>If a future revision determines that layout-level generation is
needed, it can be added as a protocol extension: the on-wire
change is additive rather than a replacement, because
cg_gen_id's semantics are independent of any outer layout
epoch.</t>
      </section>
      <section numbered="false" anchor="declustered-raid-with-dynamic-parity-mapping">
        <name>Declustered RAID with Dynamic Parity Mapping</name>
        <t>An alternative raised at IETF 121 (November 2024) was
borrowing from declustered RAID designs: the
metadata server maintains, for every fixed-size region of each
file, a mapping from logical address to the specific data
servers that currently hold that region's data and parity
shards; writes do not update chunks in place but instead produce
a new parity stripe on a freshly allocated set of data servers,
and the mapping is atomically swapped on the metadata server
once the new stripe is durable.  The attraction is that
overwrite is replaced by remap, eliminating the write-hole
problem entirely at the cost of moving consistency into the
mapping table.  This was rejected because:</t>
        <ul spacing="normal">
          <li>
            <t>The mapping load scales with the file's chunk count, not with
the file count.  A single large file with billions of chunks
produces a billion-entry mapping that the metadata server
must maintain with transactional semantics; the overhead is
inverted from the usual "a few large files" regime that
pNFS is designed for.</t>
          </li>
          <li>
            <t>Remapping storms during rebalancing, data-server addition, or
data-server failure require atomic updates to many mapping
entries at once.  Providing those updates with the
reasonable-latency bounds required by HPC checkpoint
workloads is an open research problem, not a specifiable
protocol.</t>
          </li>
          <li>
            <t>The approach reintroduces the metadata-server scale bottleneck
that client-side erasure coding is designed to avoid: every
write traverses the mapping table, and the mapping table is
the hot-spot under concurrent writes.</t>
          </li>
          <li>
            <t>The mapping table becomes the single point of failure that
the rest of the flexible file v2 layout architecture works hard to avoid;
replicating it with strong consistency requires a consensus
protocol on the metadata server, which the current design
deliberately does not require (see <xref target="sec-system-model-consensus"/>).</t>
          </li>
        </ul>
        <t>The current design uses fixed per-file chunk placement decided
at LAYOUTGET time plus chunk_guard4 CAS for writes, which
localizes consistency decisions to the chunks being written
rather than to a global mapping table.</t>
      </section>
    </section>
    <section numbered="false" removeInRFC="true" anchor="sec-wg-concern-encoding-on-client">
      <name>Working Group Concern: Encoding on Every Client</name>
      <t>This appendix captures a working-group concern raised
during the review of an earlier revision of this draft:
the source of the concern, the question as the working
group asked it, the authors' understanding of what was
being asked, and how the current specification addresses
it.  This appendix is reviewer-aid material and is
removed from the final RFC.</t>
      <section numbered="false" anchor="source">
        <name>Source</name>
        <t>Christoph Hellwig, IETF 120, NFSv4 Working Group session, during the
discussion of the original Flexible File Version 2 erasure-coding
proposal.</t>
      </section>
      <section numbered="false" anchor="the-question-as-asked">
        <name>The Question as Asked</name>
        <t>Christoph stated that he was "very scared of the implications of
having every client be a full participant in a distributed storage
system."  He pointed out that any erasure-coding or replication
protocol that runs at the client requires every client implementation
to understand the encoding, and that encodings evolve over time as new
algorithms appear in the storage research literature.  He observed
that the same problem appears with replication ("simple two-, three-,
four-way replication"): a client power-failure event mid-write leaves
the participating data servers in inconsistent states, and the
recovery machinery (mirrored logs, write-ahead replay, partial-write
detection) is "a bit of overkill for simple replication."</t>
        <t>David Black seconded the concern in the same session, stating that
"it's better to have the data protection algorithm be inside the
boundary of what you think the storage system is than outside."</t>
      </section>
      <section numbered="false" anchor="what-we-believe-is-being-asked">
        <name>What We Believe Is Being Asked</name>
        <t>Two coupled requirements:</t>
        <ol spacing="normal" type="1"><li>
            <t>Encoding correctness and encoding evolution must not be a per-client
burden.  An ecosystem in which every client must ship and update
every supported encoding does not interoperate at scale: an
organization cannot upgrade its storage system's encoding without
coordinating an upgrade across every client.</t>
          </li>
          <li>
            <t>The expensive recovery paths (partial writes, durable shard
placement, mirrored logging) must not live at the client either.
A protocol that exposes those paths to the client forces every
client implementation to carry the failure-recovery machinery,
which is precisely what RAID controllers and distributed storage
systems put behind a service boundary so that hosts do not have
to reason about it.</t>
          </li>
        </ol>
        <t>In short: the data-protection algorithm and its recovery story
belong inside a storage boundary, not at the client.</t>
      </section>
      <section numbered="false" anchor="how-the-proxy-server-addresses-this">
        <name>How the Proxy Server Addresses This</name>
        <t>The proxy server role is the storage boundary that Christoph
and David asked for.</t>
        <t>A proxy server is a peer of the metadata server and the data servers that:</t>
        <ul spacing="normal">
          <li>
            <t>speaks the encoding on behalf of clients that cannot;</t>
          </li>
          <li>
            <t>receives whole-stripe operations from an encoding-ignorant client;</t>
          </li>
          <li>
            <t>encodes (or decodes) using whatever the layout's
 <xref target="fig-ffv2_encoding_type4"/> demands;</t>
          </li>
          <li>
            <t>drives the CHUNK operations to the participating data servers;</t>
          </li>
          <li>
            <t>carries the partial-write / FINALIZE / COMMIT recovery machinery
 that the encoding requires.</t>
          </li>
        </ul>
        <t>Three properties follow:</t>
        <ul spacing="normal">
          <li>
            <t>A legacy NFSv4.2 (or even NFSv3) client gets erasure-coded
 durability without speaking erasure coding.  The proxy server is where
 the encoding lives; the client does not have to be upgraded when
 the encoding is upgraded.</t>
          </li>
          <li>
            <t>Encoding evolution is a server-side concern.  Adding a new entry
 to <xref target="fig-ffv2_encoding_type4"/> requires updating the proxy servers and data servers,
 not every client in the deployment.  This matches the operational
 pattern of every other distributed-storage protocol on the wire.</t>
          </li>
          <li>
            <t>The recovery machinery (PENDING -&gt; FINALIZED -&gt; COMMITTED, the
 chunk-state machine, partial-write detection via
 <xref target="sec-chunk_guard4"/>) executes on the proxy server, not the client.  Clients
 see ordinary NFSv4.2 semantics; the proxy server is responsible for
 converting those semantics into the chunk state-machine the
 data servers implement.</t>
          </li>
        </ul>
        <t>An encoding-aware NFSv4.2 client is still permitted (and is the fast
path: no proxy hop, no double bandwidth on the proxy's link).  The
proxy server is the answer for clients that either cannot speak the encoding
or are too old to be upgraded.  In Christoph's framing, the proxy server is
the inside of the storage boundary; encoding-aware clients are
implementations that have been admitted into that boundary by
design.</t>
        <t>The proxy server does carry a data-plane cost: client bytes traverse the
proxy on the way to the data servers, so the proxy's link sees roughly
twice the bandwidth of a direct client-to-data server path, and the proxy server pays
the encode/decode CPU.  This is the price of admission for clients
that do not speak the encoding; it is the same store-and-forward cost
any storage gateway pays.  It does not affect encoding-aware clients,
which talk to the data servers directly.</t>
      </section>
    </section>
    <section numbered="false" removeInRFC="true" anchor="sec-wg-concern-recall-storms">
      <name>Working Group Concern: Coherent Multi-data server Writes Without Recall Storms</name>
      <t>This appendix captures a working-group concern raised
during the review of an earlier revision of this draft:
the source of the concern, the question as the working
group asked it, the authors' understanding of what was
being asked, and how the current specification addresses
it.  This appendix is reviewer-aid material and is
removed from the final RFC.</t>
      <section numbered="false" anchor="source-1">
        <name>Source</name>
        <t>Christoph Hellwig, IETF 122, NFSv4 Working Group session, during
the flexible file v2 layout erasure-coding discussion.</t>
      </section>
      <section numbered="false" anchor="the-question-as-asked-1">
        <name>The Question as Asked</name>
        <t>Christoph observed that performing erasure coding across a set of
data servers, where clients need a coherent view of the encoded
data while writes are in flight, is "just really complicated,
especially without recalling layouts."  He continued: "maybe we
need a more efficient network operation that doesn't recall layout
but updates layouts in a different way, and that might reduce
the overhead.  Basically any scheme would require either a fair
amount of intelligence on the data servers or some form of updating
outstanding layouts to point to a new right-out-of-place location."
He explicitly noted he was "leaning to updating the data servers
to be smarter."</t>
        <t>The same conversation introduced the idea of a "generation counter
that gets sent over the wire to the data servers, which means the
data server now needs to look for a new location for the same
existing layout."</t>
      </section>
      <section numbered="false" anchor="what-we-believe-is-being-asked-1">
        <name>What We Believe Is Being Asked</name>
        <t>Two coupled requirements:</t>
        <ol spacing="normal" type="1"><li>
            <t>The metadata server must be able to mutate where data lives -- replace a
failing data server, redirect to a spare, rebalance, repair --
without serializing every layout-holding client through a
CB_LAYOUTRECALL round-trip.  A recall is global with respect
to the layout: every client holding it must drain in-flight I/O
and DELEGRETURN before the metadata server can mutate.  In an erasure-coded
workload with many concurrent clients, this turns a localized
data server hiccup into a global stall.</t>
          </li>
          <li>
            <t>The data servers must be smart enough to enforce per-client
access on a finer grain than "the file is reachable from the
network."  Anonymous-stateid I/O combined with synthetic-uid
fencing is a coarse instrument: fencing one client's access
to a file affects every client's access to that file.  The
only way to selectively revoke is to teach the data server who is
permitted, on which file, with which iomode -- which is the
"smarter data server" Christoph was asking for.</t>
          </li>
        </ol>
      </section>
      <section numbered="false" anchor="how-truststateid-revokestateid-and-bulkrevokestateid-address-this">
        <name>How TRUST_STATEID, REVOKE_STATEID, and BULK_REVOKE_STATEID Address This</name>
        <t>Sections <xref target="sec-TRUST_STATEID"/>, <xref target="sec-REVOKE_STATEID"/>, and
<xref target="sec-BULK_REVOKE_STATEID"/> of this document define exactly the
"smarter data server" the working group asked for.</t>
        <t>The mechanism:</t>
        <ul spacing="normal">
          <li>
            <t>At LAYOUTGET, the metadata server issues a real layout stateid and fans out
 TRUST_STATEID to each data server in the mirror set, registering
 <tt>(stateid.other, fh, clientid, iomode, expire)</tt> in a per-data server
 trust table.  CHUNK_WRITE and CHUNK_READ on the data server now validate
 against the trust table; an unknown, expired, or revoked
 stateid yields NFS4ERR_BAD_STATEID.</t>
          </li>
          <li>
            <t>When the metadata server needs to mutate the layout for a particular client
 -- because that client misbehaved, because a data server the layout
 points at is being drained, because the file is being repaired
 -- it issues REVOKE_STATEID to the affected data server.  Other clients'
 trust entries on the same file are untouched.</t>
          </li>
          <li>
            <t>When the metadata server needs to mutate at client-scope (lease expiry,
 client eviction), it issues BULK_REVOKE_STATEID, which removes
 every trust entry the named client has on the data server without
 affecting other clients.</t>
          </li>
        </ul>
        <t>The control-plane cost reshapes accordingly:</t>
        <ul spacing="normal">
          <li>
            <t>Layout mutation is no longer global.  The metadata server reroutes data to a
 spare data server, rebuilds shards from surviving copies, and revokes
 only the trust entries that pointed at the failing location.
 The other clients holding the layout are not contacted.</t>
          </li>
          <li>
            <t>The revoked client only learns of the mutation lazily, on its
 next CHUNK_WRITE or CHUNK_READ to the affected stripe.  That
 operation returns NFS4ERR_BAD_STATEID; the client responds with
 LAYOUTERROR; the metadata server replies with a refreshed layout pointing
 at the new location; the client re-trusts and resumes.  A
 client that never touches the affected stripe never pays the
 cost at all.</t>
          </li>
          <li>
            <t>With warm spares known to the metadata server, the entire repair can complete
 before any client notices.  The metadata server reconstructs onto a spare
 using server-to-server traffic, atomically swaps the layout slot
 in its in-memory state, and revokes only the trust entries on
 the now-evacuated data server.  Reading clients see no interruption (any
 k of the surviving shards reconstructs); writing clients pay
 one round-trip to refresh the layout when they next write the
 affected stripe.</t>
          </li>
        </ul>
        <t>The combination of TRUST_STATEID and a warm-spare data server pool is the
"more efficient network operation that updates layouts" Christoph
asked for.  It is not literally a layout update on the wire; it is
a primitive that makes layout updates a local event the metadata server can
resolve before the client has to pay a recall round-trip.</t>
        <t>The chunk state machine (PENDING -&gt; FINALIZED -&gt; COMMITTED) and
<xref target="sec-chunk_guard4"/> address the orthogonal concern of partial-write
recovery, ensuring that even when the metadata server reroutes mid-write the
data servers can detect non-atomic stripes via per-chunk generation
checks rather than via a global wall-clock or consensus protocol.</t>
      </section>
      <section numbered="false" anchor="combined-effect-on-the-cluster-tax">
        <name>Combined Effect on the "Cluster Tax"</name>
        <t>The proxy server addresses the encoding-distribution cost; the trust
stateid mechanism addresses the layout-mutation cost.  Together,
they confine the residual cluster overhead to:</t>
        <ul spacing="normal">
          <li>
            <t>the store-and-forward bandwidth on the proxy server link, paid only by
 clients that route through a proxy server rather than going data-server-direct;
 and</t>
          </li>
          <li>
            <t>one LAYOUTERROR/LAYOUTGET round-trip per client per affected
 stripe, paid only by clients that actually try to use a stripe
 whose backing has changed.</t>
          </li>
        </ul>
        <t>Neither cost scales with the number of layout-holding clients,
which is the property the working group asked for.</t>
      </section>
    </section>
    <section numbered="false" anchor="acknowledgments">
      <name>Acknowledgments</name>
      <t>The following from Hammerspace were instrumental in driving Flexible
File Version 2 Layout Type: David Flynn, Trond Myklebust, Didier
Feron, Jean-Pierre Monchanin, Pierre Evenou, and Brian Pawlowski.</t>
      <t>The Mojette Transform encoding type specification in
<xref target="sec-mojette-encoding"/> -- including the algebra, the bin
convention, the projection sizing, and the reconstruction
algorithms -- was contributed by Pierre Evenou, drawing on the
work of Nicolas Normand, Benoit Parrein, and the discrete
geometry research group at the University of Nantes.</t>
      <t>Christoph Hellwig was instrumental in making sure the Flexible File
Version 2 Layout Type was applicable to more than the Mojette
Transformation.</t>
      <t>David Black clarified at IETF 124 that the consistency goal of
flexible file v2 layout is RAID consistency across the shards of a stripe
rather than POSIX write ordering across application writes; that
framing is reflected in <xref target="sec-motivation"/> and in the Non-Goals
of <xref target="sec-system-model-consistency"/>.</t>
      <t>Lucheng Bao asked how a trusted stateid registration is
protected against an on-path attacker, and why a data server
under tight coupling would not need its own Kerberos keytab.</t>
      <t>The authors thank Dave Noveck, Chuck Lever, Tigran
Mkrtchyan, Rick Macklem, Christoph Hellwig, and Sorin
Faibish for their detailed review of earlier revisions of
this draft.  Their comments shaped the system model
presentation, the chunk lifecycle and guard semantics, the
trusted stateid design, and many smaller choices recorded
throughout the
document.</t>
      <t>Chris Inacio, Brian Pawlowski, Chuck Lever, Zahed Sarker, and
Gorry Fairhurst guided this process.</t>
    </section>
  </back>
  <!-- ##markdown-source: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-->

</rfc>
