Keguang Xu kxu · review.whamcloud.com

LU-20690 ec: store EC parity like RAID10

The k >= p restriction is not a Cauchy/ISA-L limit. It comes from
storing parity as RAID0|PARITY: the p parity objects of a raidset are
concatenated along the file offset, so raidset_count * p * stripe_size
does not fit in a finite PFL extent when p > k (for example
--ec 2+3 -E 2M). This patch changes the parity layout; the p <= k
checks in lfs and llapi stay until a following patch removes them.

Store EC parity as LOV_PATTERN_PARITY instead. A raidset is an EC
split of the stripe set, and the layout is like RAID10 in that it has
the same two axes:

  - across the raidsets of one stripe set: like RAID0, one
    stripe_size per raidset;
  - within one raidset: like RAID1, the p parity stripes share one
    file offset (the same object_off).

The RAID1 axis comes from recovery. A raidset of k data and p parity
stripes survives the loss of any p of its k + p stripes, just as a
RAID1 of p + 1 copies survives the loss of any p copies. RAID1 is the
k == 1 case, where each parity is a copy of the data (--ec 1+N). The
p parities protect the same data, so they share its offset: the
offset says which data is protected, the parity index says which
redundancy unit it is.

What differs from RAID1 is I/O, not the role. For k > 1 the parities
are not replicas: each holds a different parity, and a lost stripe is
rebuilt from any k survivors rather than copied from one. The parity
uses the extent of the data component.

RAID0 places data rows from file offset 0, whereas counting EC rows
and raidsets from e_start groups the wrong k stripes when e_start is
not a multiple of the data stripe width: the stripes EC groups as one
raidset are not the objects lod paired with that raidset's parity
OSTs, and a degraded read rebuilds a lost stripe from the wrong
parity. For example -E 4M -c 1 -E eof -S 1M -c 8 --ec 4+1 puts offset
4M on object 4 (raidset 1), which counting from e_start encodes into
the parity of raidset 0. When e_start is not a multiple of
stripe_size, as after a 64K DoM component, counting stripe_size
parity slots from e_start also splits stripes at
e_start + n * stripe_size and overflows e_end.

Count rows and raidsets from file offset 0, as RAID0 maps the data
objects:

  row = off / (stripe_count * stripe_size)
  ec_off = O
      + (row - row of e_start) * raidset_count * stripe_size
      + raidset * stripe_size + off % stripe_size

Data before e_start is taken as zero, and so is its parity, which is
not stored: the origin O moves back from e_start over the raidsets of
the first row that end before e_start, and over the part of the
raidset of e_start below e_start % stripe_size when e_start is in its
last data stripe. slot % raidset_count stays the raidset, so the
parity OSTs lod pairs are unchanged, and every stored parity byte has
data in the component. Common DoM and PFL layouts with an unaligned
e_start are supported and keep their parity within [e_start, e_end),
such as:
- -E 64K -L mdt -E 1M -c 1 -S 1M -E eof -c 4 -S 4M --ec 4+2;
- -E 64K -L mdt -E 16M -c 2 -S 1M -E eof -c 4 -S 4M --ec 2+2;
- -E 64K -L mdt -E eof -c 4 -S 1M --ec 2+2;
- -E 1M -c 1 -S 1M -E 64M -c 1 -S 4M -E eof -c 4 -S 4M --ec 4+2.
When every raidset has one data stripe (--ec 1+N, or one data
stripe), there is one parity slot per data stripe and nothing to
pack, so rows and O count from file offset 0, as RAID0 does: ec_off
is the data offset, and each parity object is a copy of its data
object at the same object offsets, so it can stand in for it.
Otherwise O depends only on e_start, the data stripe count, k and the
stripe size, not on e_end, and when e_start is a multiple of the
stripe width, O is e_start.

Add ec_raidset_count(), ec_raidset_first(), ec_stripe_to_raidset()
and ec_off_to_raidset_offset() next to ec_split_stripes() in
lustre_user.h, and struct ec_parity_geom with ec_parity_geom_init(),
ec_data_to_parity() and its inverse ec_parity_to_data(), with
ec_parity_width() for the parity bytes of one stripe set, and use
them in lov, lod and llapi instead of open-coding the k0 * n0 split.
ec_parity_geom_init() also records the data row of parity slot 0 in
epg_row0 (0 for 1-data raidsets).
lov caches O in lsme_parity_origin when the layout is unpacked and
returns it from lsme_stripe_origin(), and lov_parity_geom_init()
fails a degraded read whose pair does not match in stripe size,
raidsets or origin; the parity mirror EOF of such a pair is also
bounded by one parity row per stripe set from e_start. Raidset
objects before e_start read as zero in degraded reads and resync.
A read is widened to whole raid sets, but not past the e_end of its
component, so a read ending there does not start an empty recovery
cycle for the next component's first raid set, which may begin before
its e_start.
lsme_parity_raid10() now just returns lsme_is_parity(), as every
parity component is LOV_PATTERN_PARITY, and
lsme_parity_slots_per_raidset() is dropped.

A component shorter than one stripe (e_end < e_start + stripe_size)
whose raidset continues past e_end (e.g. [64K, 1M) with -S 1M -c 2
--ec 2+2, or [1M, 4M) with -S 4M -c 2 --ec 2+2, where the second
stripe is never reached) still has no room for a full stripe_size
parity slot from e_start. ec_parity_fits() detects it:
llapi_layout_sanity() refuses it with LSE_EC_PARITY_FIT,
llapi_ec_check_comp_match() refuses to resync or verify it, and
lod_comp_prep_create() checks it again with the final data stripe
count, also for lfs mirror extend --ec.

The lov slot geometry, the STRIPE I/O scope and the per-stripe llapi
helpers were added by the previous patches and only take effect for
LOV_PATTERN_PARITY. This patch switches the encoding so they apply:
llapi_pattern_to_lov() and llapi_layout_to_lum() emit
LOV_PATTERN_PARITY, lov_pattern_supported() accepts it in place of
RAID0|PARITY (and lov_pattern_available() via that), and lod allocates
and verifies parity components with it. EC has not shipped, so the old
combination is not kept. Finite-extent stripe-count shrinking, now in
one lod_comp_shrink_to_extent() helper instead of three copies, is
skipped for parity components. lsm_unpackmd_comp_md_v1() and
lod_verify_striping() reject a component whose LCME_FL_PARITY flag and
LOV_PATTERN_PARITY disagree, since the parity geometry follows the
flag.

vvp_prep_size() no longer writes KMS into i_size for parity I/O.
ci_parity_eof is derived from i_size, and KMS is only a lower bound
of the data size, so a parity read within KMS shrank ci_parity_eof
for later parity I/O.

Userspace resync and verify move to the RAID10 offsets: one
stripe_size per raidset, each parity addressed by its stripe index,
leaving the part of the first parity slot below e_start alone. The
punch, zero-fill and hole verify of a parity slot are bounded by the
e_end of its component; no slot runs past e_end while
ec_parity_fits() holds, so this is only a defensive bound. Hole
punch-or-clear and hole verify loop over the p parity stripes that
share an offset when they fall back to zero-fill or zero-content
reads.

lfs setstripe --yaml parses the pattern as the comma-separated flags
lfs getstripe -y prints, so "parity,overstriped" keeps overstriping.

lfs mirror read of a parity mirror still dumps every parity object in
RAID0 order, through mirror_dump_parity() in lfs, from e_start.  The
dump of a component stops at its e_end: when the extent is not a
multiple of the data stripe set, the raid sets of the last row past
e_end hold the data of the next component.  The glimpse lock of such
a read spans every component, so lov_lock_sub_init() no longer
rejects a glimpse because a component the I/O does not cover has
fewer parity stripes than the designated one; lov_io_iter_init()
checks the components the I/O covers.

Example: -E 128M -c 11 -S 1M --ec 4+2

  data/parity extent [0, 128M)
  raidsets [4,2], [4,2], [3,2] (raidset_count=3)
  parity has 6 OST objects
  one data stripe set = 11M
  one parity stripe set = 3M (not 1M flat, not 6M concat)

  stripeset raidset data_pos    ec_off  concat  objects
  --------- ------- ----------- ------- ------- -------
  0         0       [0, 4M)     0       0       0,1
  0         1       [4M, 8M)    1M      2M      2,3
  0         2       [8M, 11M)   2M      4M      4,5
  1         0       [11M, 15M)  3M      6M      0,1
  1         1       [15M, 19M)  4M      8M      2,3
  1         2       [19M, 22M)  5M      10M     4,5

The concat column is what RAID0|PARITY would have used, and is what
overflows a finite extent when p > k.

Tests: sanity-ec 12c/12d/34c cover
holes and multi-raidset offsets, 30d and 31b-31e check the parity dump
size, 34d dumps a mixed-p mirror whose first extent is not a multiple
of the stripe set, 63d recovers reads from parity of raidset 1 in a
PFL component that does not start at 0, 301 covers an e_start that
stripe_size does not divide and checks that a component whose parity
would pass e_end is refused for that reason, 302 resyncs, verifies and
reads degraded common PFL layouts with an unaligned e_start, 303
recovers reads when e_start is not a multiple of the stripe width,
with equal and unequal raidsets, 304 covers zero-fill before e_start,
305 truncates at raidset and unaligned component boundaries, and 306
reads degraded across a component boundary where the raid set of the
first component runs into the next one.
llapi_layout_test asserts the component pattern is LLAPI_LAYOUT_PARITY
and 68 checks the parity placement over a range of geometries and
extents, and that 1-data raidset copies are at the data object
offsets.

Test-Parameters: testlist=sanity-ec ostcount=8
Test-Parameters: testlist=sanity-ec ostcount=8 fstype=zfs
Signed-off-by: Keguang Xu <kxu@ddn.com>
Signed-off-by: Ronnie Sahlberg <rsahlberg@whamcloud.com>
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: Cursor:Composer/Opus5.5 llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-fable-5-1 llm_code_and_review_tools
Change-Id: I9574df44969ddd40776f028b3c326d150ea08eb5

LU-20690 ec: verify parity against data, allow p > k

With the RAID10-like parity layout the p parities of a raidset share
one offset, so the parity of a component fits in its extent whatever
p is. Remove the p <= k checks in lfs and llapi; k+p <= 256 and
p <= 15 remain. Also drop the mirror-extend stripe_count < p guard
in ec_check_data_comp() so --ec 2+3 works on a two-stripe target.

An instantiated parity is checked against its data component in
lod_verify_ec_parity_comps(), using lod_comp_find_linked() for the
same pairing rule as the allocator. A parity with linked data needs a
bidirectional link, matching k/p and stripe size, and parity stripe
count ec_raidset_count() * p. A parity whose data mirror was split
off or deleted has no linked data and is skipped. A mismatch fails a
layout from the user or replay in lod_use_defined_striping(), but is
only logged for a layout loaded from disk by lod_parse_striping(), so
an existing file with a bad parity can still be opened and removed.
lod_verify_striping() checks k/p and rejects an instantiated parity
with stripe_count == 0 before DEFINED object init.

Also skip instantiating a parity in
lod_declare_instantiate_components() when its linked data is still
uninit and not in the same instantiate list. A mirror-targeted
RESYNC lease walks every component of the named mirror, and would
otherwise leave INIT parity over uninit PFL data that
lod_verify_ec_parity_comps() then rejects.

Tests: sanity-ec 4a and 10 accept p > k, and 4b rejects k == 0 and
k > 255. 8d no longer expects narrow components or -c 5 --ec 4+3 to
be refused. 8m covers mirror extend --ec 2+3 on a two-stripe target.
8n covers a mirror-targeted RESYNC lease that must not INIT parity
over uninit PFL data. 8o covers PFL -E 2M --ec 2+3
create/resync/verify, and 8p covers p > k multi-raidset
create/resync/verify. llapi_layout_test test47 allows 3+4.

Test-Parameters: testlist=sanity-ec ostcount=8
Signed-off-by: Keguang Xu <kxu@ddn.com>
Assisted-by: Cursor:Composer llm_code_and_review_tools
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Change-Id: I3878502e8ff739cb5ed420ff359e2008376303e7

LU-20690 ec: store EC parity like RAID10

The k >= p restriction is not a Cauchy/ISA-L limit. It comes from
storing parity as RAID0|PARITY: the p parity objects of a raidset are
concatenated along the file offset, so raidset_count * p * stripe_size
does not fit in a finite PFL extent when p > k (for example
--ec 2+3 -E 2M). This patch changes the parity layout; the p <= k
checks in lfs and llapi stay until a following patch removes them.

Store EC parity as LOV_PATTERN_PARITY instead. A raidset is an EC
split of the stripe set, and the layout is like RAID10 in that it has
the same two axes:

  - across the raidsets of one stripe set: like RAID0, one
    stripe_size per raidset;
  - within one raidset: like RAID1, the p parity stripes share one
    file offset (the same object_off).

The RAID1 axis comes from recovery. A raidset of k data and p parity
stripes survives the loss of any p of its k + p stripes, just as a
RAID1 of p + 1 copies survives the loss of any p copies. RAID1 is the
k == 1 case, where each parity is a copy of the data (--ec 1+N). The
p parities protect the same data, so they share its offset: the
offset says which data is protected, the parity index says which
redundancy unit it is.

What differs from RAID1 is I/O, not the role. For k > 1 the parities
are not replicas: each holds a different parity, and a lost stripe is
rebuilt from any k survivors rather than copied from one. The parity
uses the extent of the data component.

RAID0 places data rows from file offset 0, whereas counting EC rows
and raidsets from e_start groups the wrong k stripes when e_start is
not a multiple of the data stripe width: the stripes EC groups as one
raidset are not the objects lod paired with that raidset's parity
OSTs, and a degraded read rebuilds a lost stripe from the wrong
parity. For example -E 4M -c 1 -E eof -S 1M -c 8 --ec 4+1 puts offset
4M on object 4 (raidset 1), which counting from e_start encodes into
the parity of raidset 0. When e_start is not a multiple of
stripe_size, as after a 64K DoM component, counting stripe_size
parity slots from e_start also splits stripes at
e_start + n * stripe_size and overflows e_end.

Count rows and raidsets from file offset 0, as RAID0 maps the data
objects:

  row = off / (stripe_count * stripe_size)
  ec_off = O
      + (row - row of e_start) * raidset_count * stripe_size
      + raidset * stripe_size + off % stripe_size

Data before e_start is taken as zero, and so is its parity, which is
not stored: the origin O moves back from e_start over the raidsets of
the first row that end before e_start, and over the part of the
raidset of e_start below e_start % stripe_size when e_start is in its
last data stripe. slot % raidset_count stays the raidset, so the
parity OSTs lod pairs are unchanged, and every stored parity byte has
data in the component. Common DoM and PFL layouts with an unaligned
e_start are supported and keep their parity within [e_start, e_end),
such as:
- -E 64K -L mdt -E 1M -c 1 -S 1M -E eof -c 4 -S 4M --ec 4+2;
- -E 64K -L mdt -E 16M -c 2 -S 1M -E eof -c 4 -S 4M --ec 2+2;
- -E 64K -L mdt -E eof -c 4 -S 1M --ec 2+2;
- -E 1M -c 1 -S 1M -E 64M -c 1 -S 4M -E eof -c 4 -S 4M --ec 4+2.
When every raidset has one data stripe (--ec 1+N, or one data
stripe), there is one parity slot per data stripe and nothing to
pack, so rows and O count from file offset 0, as RAID0 does: ec_off
is the data offset, and each parity object is a copy of its data
object at the same object offsets, so it can stand in for it.
Otherwise O depends only on e_start, the data stripe count, k and the
stripe size, not on e_end, and when e_start is a multiple of the
stripe width, O is e_start.

Add ec_raidset_count(), ec_raidset_first(), ec_stripe_to_raidset()
and ec_off_to_raidset_offset() next to ec_split_stripes() in
lustre_user.h, and struct ec_parity_geom with ec_parity_geom_init(),
ec_data_to_parity() and its inverse ec_parity_to_data(), with
ec_parity_width() for the parity bytes of one stripe set, and use
them in lov, lod and llapi instead of open-coding the k0 * n0 split.
ec_parity_geom_init() also records the data row of parity slot 0 in
epg_row0 (0 for 1-data raidsets).
lov caches O in lsme_parity_origin when the layout is unpacked and
returns it from lsme_stripe_origin(), and lov_parity_geom_init()
fails a degraded read whose pair does not match in stripe size,
raidsets or origin; the parity mirror EOF of such a pair is also
bounded by one parity row per stripe set from e_start. Raidset
objects before e_start read as zero in degraded reads and resync.
A read is widened to whole raid sets, but not past the e_end of its
component, so a read ending there does not start an empty recovery
cycle for the next component's first raid set, which may begin before
its e_start.
lsme_parity_raid10() now just returns lsme_is_parity(), as every
parity component is LOV_PATTERN_PARITY, and
lsme_parity_slots_per_raidset() is dropped.

A component shorter than one stripe (e_end < e_start + stripe_size)
whose raidset continues past e_end (e.g. [64K, 1M) with -S 1M -c 2
--ec 2+2, or [1M, 4M) with -S 4M -c 2 --ec 2+2, where the second
stripe is never reached) still has no room for a full stripe_size
parity slot from e_start. ec_parity_fits() detects it:
llapi_layout_sanity() refuses it with LSE_EC_PARITY_FIT,
llapi_ec_check_comp_match() refuses to resync or verify it, and
lod_comp_prep_create() checks it again with the final data stripe
count, also for lfs mirror extend --ec.

The lov slot geometry, the STRIPE I/O scope and the per-stripe llapi
helpers were added by the previous patches and only take effect for
LOV_PATTERN_PARITY. This patch switches the encoding so they apply:
llapi_pattern_to_lov() and llapi_layout_to_lum() emit
LOV_PATTERN_PARITY, lov_pattern_supported() accepts it in place of
RAID0|PARITY (and lov_pattern_available() via that), and lod allocates
and verifies parity components with it. EC has not shipped, so the old
combination is not kept. Finite-extent stripe-count shrinking, now in
one lod_comp_shrink_to_extent() helper instead of three copies, is
skipped for parity components. lsm_unpackmd_comp_md_v1() and
lod_verify_striping() reject a component whose LCME_FL_PARITY flag and
LOV_PATTERN_PARITY disagree, since the parity geometry follows the
flag.

vvp_prep_size() no longer writes KMS into i_size for parity I/O.
ci_parity_eof is derived from i_size, and KMS is only a lower bound
of the data size, so a parity read within KMS shrank ci_parity_eof
for later parity I/O.

Userspace resync and verify move to the RAID10 offsets: one
stripe_size per raidset, each parity addressed by its stripe index,
leaving the part of the first parity slot below e_start alone. The
punch, zero-fill and hole verify of a parity slot are bounded by the
e_end of its component; no slot runs past e_end while
ec_parity_fits() holds, so this is only a defensive bound. Hole
punch-or-clear and hole verify loop over the p parity stripes that
share an offset when they fall back to zero-fill or zero-content
reads.

lfs setstripe --yaml parses the pattern as the comma-separated flags
lfs getstripe -y prints, so "parity,overstriped" keeps overstriping.

lfs mirror read of a parity mirror still dumps every parity object in
RAID0 order, through mirror_dump_parity() in lfs, from e_start.  The
dump of a component stops at its e_end: when the extent is not a
multiple of the data stripe set, the raid sets of the last row past
e_end hold the data of the next component.  The glimpse lock of such
a read spans every component, so lov_lock_sub_init() no longer
rejects a glimpse because a component the I/O does not cover has
fewer parity stripes than the designated one; lov_io_iter_init()
checks the components the I/O covers.

Example: -E 128M -c 11 -S 1M --ec 4+2

  data/parity extent [0, 128M)
  raidsets [4,2], [4,2], [3,2] (raidset_count=3)
  parity has 6 OST objects
  one data stripe set = 11M
  one parity stripe set = 3M (not 1M flat, not 6M concat)

  stripeset raidset data_pos    ec_off  concat  objects
  --------- ------- ----------- ------- ------- -------
  0         0       [0, 4M)     0       0       0,1
  0         1       [4M, 8M)    1M      2M      2,3
  0         2       [8M, 11M)   2M      4M      4,5
  1         0       [11M, 15M)  3M      6M      0,1
  1         1       [15M, 19M)  4M      8M      2,3
  1         2       [19M, 22M)  5M      10M     4,5

The concat column is what RAID0|PARITY would have used, and is what
overflows a finite extent when p > k.

Tests: sanity-ec 12c/12d/34c cover
holes and multi-raidset offsets, 30d and 31b-31e check the parity dump
size, 34d dumps a mixed-p mirror whose first extent is not a multiple
of the stripe set, 63d recovers reads from parity of raidset 1 in a
PFL component that does not start at 0, 301 covers an e_start that
stripe_size does not divide and checks that a component whose parity
would pass e_end is refused for that reason, 302 resyncs, verifies and
reads degraded common PFL layouts with an unaligned e_start, 303
recovers reads when e_start is not a multiple of the stripe width,
with equal and unequal raidsets, 304 covers zero-fill before e_start,
305 truncates at raidset and unaligned component boundaries, and 306
reads degraded across a component boundary where the raid set of the
first component runs into the next one.
llapi_layout_test asserts the component pattern is LLAPI_LAYOUT_PARITY
and 68 checks the parity placement over a range of geometries and
extents, and that 1-data raidset copies are at the data object
offsets.

Test-Parameters: testlist=sanity-ec ostcount=8
Test-Parameters: testlist=sanity-ec ostcount=8 fstype=zfs
Signed-off-by: Keguang Xu <kxu@ddn.com>
Signed-off-by: Ronnie Sahlberg <rsahlberg@whamcloud.com>
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: Cursor:Composer/Opus5.5 llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-fable-5-1 llm_code_and_review_tools
Change-Id: I9574df44969ddd40776f028b3c326d150ea08eb5

LU-20690 lov: check designated stripe in mirror init

Designated-stripe validation for RAID10-like EC parity was
repeated in lov_io_iter_init(), lov_io_lru_reserve() and
lov_lock_sub_init(), and rejected CIT_FAULT wholesale.

Check covered components once in lov_io_mirror_init().
Reject buffered designated parity I/O in lov_page_init_composite()
because the page cache is shared with data.

Test-Parameters: testlist=sanity-ec ostcount=8
Assisted-by: Cursor:Composer
Signed-off-by: Keguang Xu <kxu@ddn.com>
Change-Id: Ie52af72d7afbf4943259c2c8e84078ee73c8942a

LU-20690 ec: verify parity against data, allow p > k

With the RAID10-like parity layout the p parities of a raidset share
one offset, so the parity of a component fits in its extent whatever
p is. Remove the p <= k checks in lfs and llapi; k+p <= 256 and
p <= 15 remain. Also drop the mirror-extend stripe_count < p guard
in ec_check_data_comp() so --ec 2+3 works on a two-stripe target.

An instantiated parity is checked against its data component in
lod_verify_ec_parity_comps(), using lod_comp_find_linked() for the
same pairing rule as the allocator. A parity with linked data needs a
bidirectional link, matching k/p and stripe size, and parity stripe
count ec_raidset_count() * p. A parity whose data mirror was split
off or deleted has no linked data and is skipped. A mismatch fails a
layout from the user or replay in lod_use_defined_striping(), but is
only logged for a layout loaded from disk by lod_parse_striping(), so
an existing file with a bad parity can still be opened and removed.
lod_verify_striping() checks k/p and rejects an instantiated parity
with stripe_count == 0 before DEFINED object init.

Also skip instantiating a parity in
lod_declare_instantiate_components() when its linked data is still
uninit and not in the same instantiate list. A mirror-targeted
RESYNC lease walks every component of the named mirror, and would
otherwise leave INIT parity over uninit PFL data that
lod_verify_ec_parity_comps() then rejects.

Tests: sanity-ec 4a and 10 accept p > k, and 4b rejects k == 0 and
k > 255. 8d no longer expects narrow components or -c 5 --ec 4+3 to
be refused. 8m covers mirror extend --ec 2+3 on a two-stripe target.
8n covers a mirror-targeted RESYNC lease that must not INIT parity
over uninit PFL data. 8o covers PFL -E 2M --ec 2+3
create/resync/verify, and 8p covers p > k multi-raidset
create/resync/verify. llapi_layout_test test47 allows 3+4.

Test-Parameters: testlist=sanity-ec ostcount=8
Signed-off-by: Keguang Xu <kxu@ddn.com>
Assisted-by: Cursor:Composer llm_code_and_review_tools
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Change-Id: I3878502e8ff739cb5ed420ff359e2008376303e7

LU-20690 ec: store EC parity like RAID10

The k >= p restriction is not a Cauchy/ISA-L limit. It comes from
storing parity as RAID0|PARITY: the p parity objects of a raidset are
concatenated along the file offset, so raidset_count * p * stripe_size
does not fit in a finite PFL extent when p > k (for example
--ec 2+3 -E 2M). This patch changes the parity layout; the p <= k
checks in lfs and llapi stay until a following patch removes them.

Store EC parity as LOV_PATTERN_PARITY instead. A raidset is an EC
split of the stripe set, and the layout is like RAID10 in that it has
the same two axes:

  - across the raidsets of one stripe set: like RAID0, one
    stripe_size per raidset;
  - within one raidset: like RAID1, the p parity stripes share one
    file offset (the same object_off).

The RAID1 axis comes from recovery. A raidset of k data and p parity
stripes survives the loss of any p of its k + p stripes, just as a
RAID1 of p + 1 copies survives the loss of any p copies. RAID1 is the
k == 1 case, where each parity is a copy of the data (--ec 1+N). The
p parities protect the same data, so they share its offset: the
offset says which data is protected, the parity index says which
redundancy unit it is.

What differs from RAID1 is I/O, not the role. For k > 1 the parities
are not replicas: each holds a different parity, and a lost stripe is
rebuilt from any k survivors rather than copied from one. The parity
uses the extent of the data component.

RAID0 places data rows from file offset 0, whereas counting EC rows
and raidsets from e_start groups the wrong k stripes when e_start is
not a multiple of the data stripe width: the stripes EC groups as one
raidset are not the objects lod paired with that raidset's parity
OSTs, and a degraded read rebuilds a lost stripe from the wrong
parity. For example -E 4M -c 1 -E eof -S 1M -c 8 --ec 4+1 puts offset
4M on object 4 (raidset 1), which counting from e_start encodes into
the parity of raidset 0. When e_start is not a multiple of
stripe_size, as after a 64K DoM component, counting stripe_size
parity slots from e_start also splits stripes at
e_start + n * stripe_size and overflows e_end.

Count rows and raidsets from file offset 0, as RAID0 maps the data
objects:

  row = off / (stripe_count * stripe_size)
  ec_off = O
      + (row - row of e_start) * raidset_count * stripe_size
      + raidset * stripe_size + off % stripe_size

Data before e_start is taken as zero, and so is its parity, which is
not stored: the origin O moves back from e_start over the raidsets of
the first row that end before e_start, and over the part of the
raidset of e_start below e_start % stripe_size when e_start is in its
last data stripe. slot % raidset_count stays the raidset, so the
parity OSTs lod pairs are unchanged, and every stored parity byte has
data in the component. Common DoM and PFL layouts with an unaligned
e_start are supported and keep their parity within [e_start, e_end),
such as:
- -E 64K -L mdt -E 1M -c 1 -S 1M -E eof -c 4 -S 4M --ec 4+2;
- -E 64K -L mdt -E 16M -c 2 -S 1M -E eof -c 4 -S 4M --ec 2+2;
- -E 64K -L mdt -E eof -c 4 -S 1M --ec 2+2;
- -E 1M -c 1 -S 1M -E 64M -c 1 -S 4M -E eof -c 4 -S 4M --ec 4+2.
When every raidset has one data stripe (--ec 1+N, or one data
stripe), there is one parity slot per data stripe and nothing to
pack, so rows and O count from file offset 0, as RAID0 does: ec_off
is the data offset, and each parity object is a copy of its data
object at the same object offsets, so it can stand in for it.
Otherwise O depends only on e_start, the data stripe count, k and the
stripe size, not on e_end, and when e_start is a multiple of the
stripe width, O is e_start.

Add ec_raidset_count(), ec_raidset_first(), ec_stripe_to_raidset()
and ec_off_to_raidset_offset() next to ec_split_stripes() in
lustre_user.h, and struct ec_parity_geom with ec_parity_geom_init(),
ec_data_to_parity() and its inverse ec_parity_to_data(), with
ec_parity_width() for the parity bytes of one stripe set, and use
them in lov, lod and llapi instead of open-coding the k0 * n0 split.
ec_parity_geom_init() also records the data row of parity slot 0 in
epg_row0 (0 for 1-data raidsets).
lov caches O in lsme_parity_origin when the layout is unpacked and
returns it from lsme_stripe_origin(), and lov_parity_geom_init()
fails a degraded read whose pair does not match in stripe size,
raidsets or origin; the parity mirror EOF of such a pair is also
bounded by one parity row per stripe set from e_start. Raidset
objects before e_start read as zero in degraded reads and resync.
A read is widened to whole raid sets, but not past the e_end of its
component, so a read ending there does not start an empty recovery
cycle for the next component's first raid set, which may begin before
its e_start.
lsme_parity_raid10() now just returns lsme_is_parity(), as every
parity component is LOV_PATTERN_PARITY, and
lsme_parity_slots_per_raidset() is dropped.

A component shorter than one stripe (e_end < e_start + stripe_size)
whose raidset continues past e_end (e.g. [64K, 1M) with -S 1M -c 2
--ec 2+2, or [1M, 4M) with -S 4M -c 2 --ec 2+2, where the second
stripe is never reached) still has no room for a full stripe_size
parity slot from e_start. ec_parity_fits() detects it:
llapi_layout_sanity() refuses it with LSE_EC_PARITY_FIT,
llapi_ec_check_comp_match() refuses to resync or verify it, and
lod_comp_prep_create() checks it again with the final data stripe
count, also for lfs mirror extend --ec.

The lov slot geometry, the STRIPE I/O scope and the per-stripe llapi
helpers were added by the previous patches and only take effect for
LOV_PATTERN_PARITY. This patch switches the encoding so they apply:
llapi_pattern_to_lov() and llapi_layout_to_lum() emit
LOV_PATTERN_PARITY, lov_pattern_supported() accepts it in place of
RAID0|PARITY (and lov_pattern_available() via that), and lod allocates
and verifies parity components with it. EC has not shipped, so the old
combination is not kept. Finite-extent stripe-count shrinking, now in
one lod_comp_shrink_to_extent() helper instead of three copies, is
skipped for parity components. lsm_unpackmd_comp_md_v1() and
lod_verify_striping() reject a component whose LCME_FL_PARITY flag and
LOV_PATTERN_PARITY disagree, since the parity geometry follows the
flag.

vvp_prep_size() no longer writes KMS into i_size for parity I/O.
ci_parity_eof is derived from i_size, and KMS is only a lower bound
of the data size, so a parity read within KMS shrank ci_parity_eof
for later parity I/O.

Userspace resync and verify move to the RAID10 offsets: one
stripe_size per raidset, each parity addressed by its stripe index,
leaving the part of the first parity slot below e_start alone. The
punch, zero-fill and hole verify of a parity slot are bounded by the
e_end of its component; no slot runs past e_end while
ec_parity_fits() holds, so this is only a defensive bound. Hole
punch-or-clear and hole verify loop over the p parity stripes that
share an offset when they fall back to zero-fill or zero-content
reads.

lfs setstripe --yaml parses the pattern as the comma-separated flags
lfs getstripe -y prints, so "parity,overstriped" keeps overstriping.

lfs mirror read of a parity mirror still dumps every parity object in
RAID0 order, through mirror_dump_parity() in lfs, from e_start.  The
dump of a component stops at its e_end: when the extent is not a
multiple of the data stripe set, the raid sets of the last row past
e_end hold the data of the next component.  The glimpse lock of such
a read spans every component, so lov_lock_sub_init() no longer
rejects a glimpse because a component the I/O does not cover has
fewer parity stripes than the designated one; lov_io_iter_init()
checks the components the I/O covers.

Example: -E 128M -c 11 -S 1M --ec 4+2

  data/parity extent [0, 128M)
  raidsets [4,2], [4,2], [3,2] (raidset_count=3)
  parity has 6 OST objects
  one data stripe set = 11M
  one parity stripe set = 3M (not 1M flat, not 6M concat)

  stripeset raidset data_pos    ec_off  concat  objects
  --------- ------- ----------- ------- ------- -------
  0         0       [0, 4M)     0       0       0,1
  0         1       [4M, 8M)    1M      2M      2,3
  0         2       [8M, 11M)   2M      4M      4,5
  1         0       [11M, 15M)  3M      6M      0,1
  1         1       [15M, 19M)  4M      8M      2,3
  1         2       [19M, 22M)  5M      10M     4,5

The concat column is what RAID0|PARITY would have used, and is what
overflows a finite extent when p > k.

Tests: sanity-ec 12c/12d/34c cover
holes and multi-raidset offsets, 30d and 31b-31e check the parity dump
size, 34d dumps a mixed-p mirror whose first extent is not a multiple
of the stripe set, 63d recovers reads from parity of raidset 1 in a
PFL component that does not start at 0, 301 covers an e_start that
stripe_size does not divide and checks that a component whose parity
would pass e_end is refused for that reason, 302 resyncs, verifies and
reads degraded common PFL layouts with an unaligned e_start, 303
recovers reads when e_start is not a multiple of the stripe width,
with equal and unequal raidsets, 304 covers zero-fill before e_start,
305 truncates at raidset and unaligned component boundaries, and 306
reads degraded across a component boundary where the raid set of the
first component runs into the next one.
llapi_layout_test asserts the component pattern is LLAPI_LAYOUT_PARITY
and 68 checks the parity placement over a range of geometries and
extents, and that 1-data raidset copies are at the data object
offsets.

Test-Parameters: testlist=sanity-ec ostcount=8
Test-Parameters: testlist=sanity-ec ostcount=8 fstype=zfs
Signed-off-by: Keguang Xu <kxu@ddn.com>
Signed-off-by: Ronnie Sahlberg <rsahlberg@whamcloud.com>
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: Cursor:Composer/Opus5.5 llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-fable-5-1 llm_code_and_review_tools
Change-Id: I9574df44969ddd40776f028b3c326d150ea08eb5

LU-20690 ec: verify parity against data, allow p > k

With the RAID10-like parity layout the p parities of a raidset share
one offset, so the parity of a component fits in its extent whatever
p is. Remove the p <= k checks in lfs and llapi; k+p <= 256 and
p <= 15 remain. Also drop the mirror-extend stripe_count < p guard
in ec_check_data_comp() so --ec 2+3 works on a two-stripe target.

An instantiated parity is checked against its data component in
lod_verify_ec_parity_comps(), using lod_comp_find_linked() for the
same pairing rule as the allocator. A parity with linked data needs a
bidirectional link, matching k/p and stripe size, and parity stripe
count ec_raidset_count() * p. A parity whose data mirror was split
off or deleted has no linked data and is skipped. A mismatch fails a
layout from the user or replay in lod_use_defined_striping(), but is
only logged for a layout loaded from disk by lod_parse_striping(), so
an existing file with a bad parity can still be opened and removed.
lod_verify_striping() checks k/p and rejects an instantiated parity
with stripe_count == 0 before DEFINED object init.

Also skip instantiating a parity in
lod_declare_instantiate_components() when its linked data is still
uninit and not in the same instantiate list. A mirror-targeted
RESYNC lease walks every component of the named mirror, and would
otherwise leave INIT parity over uninit PFL data that
lod_verify_ec_parity_comps() then rejects.

Tests: sanity-ec 4a and 10 accept p > k, and 4b rejects k == 0 and
k > 255. 8d no longer expects narrow components or -c 5 --ec 4+3 to
be refused. 8m covers mirror extend --ec 2+3 on a two-stripe target.
8n covers a mirror-targeted RESYNC lease that must not INIT parity
over uninit PFL data. 8o covers PFL -E 2M --ec 2+3
create/resync/verify, and 8p covers p > k multi-raidset
create/resync/verify. llapi_layout_test test47 allows 3+4.

Test-Parameters: testlist=sanity-ec ostcount=8
Signed-off-by: Keguang Xu <kxu@ddn.com>
Assisted-by: Cursor:Composer llm_code_and_review_tools
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Change-Id: I3878502e8ff739cb5ed420ff359e2008376303e7

LU-20690 ec: store EC parity like RAID10

The k >= p restriction is not a Cauchy/ISA-L limit. It comes from
storing parity as RAID0|PARITY: the p parity objects of a raidset are
concatenated along the file offset, so raidset_count * p * stripe_size
does not fit in a finite PFL extent when p > k (for example
--ec 2+3 -E 2M). This patch changes the parity layout; the p <= k
checks in lfs and llapi stay until a following patch removes them.

Store EC parity as LOV_PATTERN_PARITY instead. A raidset is an EC
split of the stripe set, and the layout is like RAID10 in that it has
the same two axes:

  - across the raidsets of one stripe set: like RAID0, one
    stripe_size per raidset;
  - within one raidset: like RAID1, the p parity stripes share one
    file offset (the same object_off).

The RAID1 axis comes from recovery. A raidset of k data and p parity
stripes survives the loss of any p of its k + p stripes, just as a
RAID1 of p + 1 copies survives the loss of any p copies. RAID1 is the
k == 1 case, where each parity is a copy of the data (--ec 1+N). The
p parities protect the same data, so they share its offset: the
offset says which data is protected, the parity index says which
redundancy unit it is.

What differs from RAID1 is I/O, not the role. For k > 1 the parities
are not replicas: each holds a different parity, and a lost stripe is
rebuilt from any k survivors rather than copied from one. The parity
uses the extent of the data component.

RAID0 places data rows from file offset 0, whereas counting EC rows
and raidsets from e_start groups the wrong k stripes when e_start is
not a multiple of the data stripe width: the stripes EC groups as one
raidset are not the objects lod paired with that raidset's parity
OSTs, and a degraded read rebuilds a lost stripe from the wrong
parity. For example -E 4M -c 1 -E eof -S 1M -c 8 --ec 4+1 puts offset
4M on object 4 (raidset 1), which counting from e_start encodes into
the parity of raidset 0. When e_start is not a multiple of
stripe_size, as after a 64K DoM component, counting stripe_size
parity slots from e_start also splits stripes at
e_start + n * stripe_size and overflows e_end.

Count rows and raidsets from file offset 0, as RAID0 maps the data
objects:

  row = off / (stripe_count * stripe_size)
  ec_off = O
      + (row - row of e_start) * raidset_count * stripe_size
      + raidset * stripe_size + off % stripe_size

Data before e_start is taken as zero, and so is its parity, which is
not stored: the origin O moves back from e_start over the raidsets of
the first row that end before e_start, and over the part of the
raidset of e_start below e_start % stripe_size when e_start is in its
last data stripe. slot % raidset_count stays the raidset, so the
parity OSTs lod pairs are unchanged, and every stored parity byte has
data in the component. Common DoM and PFL layouts with an unaligned
e_start are supported and keep their parity within [e_start, e_end),
such as:
- -E 64K -L mdt -E 1M -c 1 -S 1M -E eof -c 4 -S 4M --ec 4+2;
- -E 64K -L mdt -E 16M -c 2 -S 1M -E eof -c 4 -S 4M --ec 2+2;
- -E 64K -L mdt -E eof -c 4 -S 1M --ec 2+2;
- -E 1M -c 1 -S 1M -E 64M -c 1 -S 4M -E eof -c 4 -S 4M --ec 4+2.
When every raidset has one data stripe (--ec 1+N, or one data
stripe), there is one parity slot per data stripe and nothing to
pack, so rows and O count from file offset 0, as RAID0 does: ec_off
is the data offset, and each parity object is a copy of its data
object at the same object offsets, so it can stand in for it.
Otherwise O depends only on e_start, the data stripe count, k and the
stripe size, not on e_end, and when e_start is a multiple of the
stripe width, O is e_start.

Add ec_raidset_count(), ec_raidset_first(), ec_stripe_to_raidset()
and ec_off_to_raidset_offset() next to ec_split_stripes() in
lustre_user.h, and struct ec_parity_geom with ec_parity_geom_init(),
ec_data_to_parity() and its inverse ec_parity_to_data(), with
ec_parity_width() for the parity bytes of one stripe set, and use
them in lov, lod and llapi instead of open-coding the k0 * n0 split.
ec_parity_geom_init() also records the data row of parity slot 0 in
epg_row0 (0 for 1-data raidsets).
lov caches O in lsme_parity_origin when the layout is unpacked and
returns it from lsme_stripe_origin(), and lov_parity_geom_init()
fails a degraded read whose pair does not match in stripe size,
raidsets or origin; the parity mirror EOF of such a pair is also
bounded by one parity row per stripe set from e_start. Raidset
objects before e_start read as zero in degraded reads and resync.
A read is widened to whole raid sets, but not past the e_end of its
component, so a read ending there does not start an empty recovery
cycle for the next component's first raid set, which may begin before
its e_start.
lsme_parity_raid10() now just returns lsme_is_parity(), as every
parity component is LOV_PATTERN_PARITY, and
lsme_parity_slots_per_raidset() is dropped.

A component shorter than one stripe (e_end < e_start + stripe_size)
whose raidset continues past e_end (e.g. [64K, 1M) with -S 1M -c 2
--ec 2+2, or [1M, 4M) with -S 4M -c 2 --ec 2+2, where the second
stripe is never reached) still has no room for a full stripe_size
parity slot from e_start. ec_parity_fits() detects it:
llapi_layout_sanity() refuses it with LSE_EC_PARITY_FIT,
llapi_ec_check_comp_match() refuses to resync or verify it, and
lod_comp_prep_create() checks it again with the final data stripe
count, also for lfs mirror extend --ec.

The lov slot geometry, the STRIPE I/O scope and the per-stripe llapi
helpers were added by the previous patches and only take effect for
LOV_PATTERN_PARITY. This patch switches the encoding so they apply:
llapi_pattern_to_lov() and llapi_layout_to_lum() emit
LOV_PATTERN_PARITY, lov_pattern_supported() accepts it in place of
RAID0|PARITY (and lov_pattern_available() via that), and lod allocates
and verifies parity components with it. EC has not shipped, so the old
combination is not kept. Finite-extent stripe-count shrinking, now in
one lod_comp_shrink_to_extent() helper instead of three copies, is
skipped for parity components. lsm_unpackmd_comp_md_v1() and
lod_verify_striping() reject a component whose LCME_FL_PARITY flag and
LOV_PATTERN_PARITY disagree, since the parity geometry follows the
flag.

vvp_prep_size() no longer writes KMS into i_size for parity I/O.
ci_parity_eof is derived from i_size, and KMS is only a lower bound
of the data size, so a parity read within KMS shrank ci_parity_eof
for later parity I/O.

Userspace resync and verify move to the RAID10 offsets: one
stripe_size per raidset, each parity addressed by its stripe index,
leaving the part of the first parity slot below e_start alone. The
punch, zero-fill and hole verify of a parity slot are bounded by the
e_end of its component; no slot runs past e_end while
ec_parity_fits() holds, so this is only a defensive bound. Hole
punch-or-clear and hole verify loop over the p parity stripes that
share an offset when they fall back to zero-fill or zero-content
reads.

lfs setstripe --yaml parses the pattern as the comma-separated flags
lfs getstripe -y prints, so "parity,overstriped" keeps overstriping.

lfs mirror read of a parity mirror still dumps every parity object in
RAID0 order, through mirror_dump_parity() in lfs, from e_start.  The
dump of a component stops at its e_end: when the extent is not a
multiple of the data stripe set, the raid sets of the last row past
e_end hold the data of the next component.  The glimpse lock of such
a read spans every component, so lov_lock_sub_init() no longer
rejects a glimpse because a component the I/O does not cover has
fewer parity stripes than the designated one; lov_io_iter_init()
checks the components the I/O covers.

Example: -E 128M -c 11 -S 1M --ec 4+2

  data/parity extent [0, 128M)
  raidsets [4,2], [4,2], [3,2] (raidset_count=3)
  parity has 6 OST objects
  one data stripe set = 11M
  one parity stripe set = 3M (not 1M flat, not 6M concat)

  stripeset raidset data_pos    ec_off  concat  objects
  --------- ------- ----------- ------- ------- -------
  0         0       [0, 4M)     0       0       0,1
  0         1       [4M, 8M)    1M      2M      2,3
  0         2       [8M, 11M)   2M      4M      4,5
  1         0       [11M, 15M)  3M      6M      0,1
  1         1       [15M, 19M)  4M      8M      2,3
  1         2       [19M, 22M)  5M      10M     4,5

The concat column is what RAID0|PARITY would have used, and is what
overflows a finite extent when p > k.

Tests: sanity-ec 12c/12d/34c cover
holes and multi-raidset offsets, 30d and 31b-31e check the parity dump
size, 34d dumps a mixed-p mirror whose first extent is not a multiple
of the stripe set, 63d recovers reads from parity of raidset 1 in a
PFL component that does not start at 0, 301 covers an e_start that
stripe_size does not divide and checks that a component whose parity
would pass e_end is refused for that reason, 302 resyncs, verifies and
reads degraded common PFL layouts with an unaligned e_start, 303
recovers reads when e_start is not a multiple of the stripe width,
with equal and unequal raidsets, 304 covers zero-fill before e_start,
305 truncates at raidset and unaligned component boundaries, and 306
reads degraded across a component boundary where the raid set of the
first component runs into the next one.
llapi_layout_test asserts the component pattern is LLAPI_LAYOUT_PARITY
and 68 checks the parity placement over a range of geometries and
extents, and that 1-data raidset copies are at the data object
offsets.

Test-Parameters: testlist=sanity-ec ostcount=8
Test-Parameters: testlist=sanity-ec ostcount=8 fstype=zfs
Signed-off-by: Keguang Xu <kxu@ddn.com>
Signed-off-by: Ronnie Sahlberg <rsahlberg@whamcloud.com>
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: Cursor:Composer/Opus5.5 llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Assisted-by: ClaudeCode:claude-fable-5-1 llm_code_and_review_tools
Change-Id: I9574df44969ddd40776f028b3c326d150ea08eb5

LU-20690 ec: verify parity against data, allow p > k

With the RAID10-like parity layout the p parities of a raidset share
one offset, so the parity of a component fits in its extent whatever
p is. Remove the p <= k checks in lfs and llapi; k+p <= 256 and
p <= 15 remain. Also drop the mirror-extend stripe_count < p guard
in ec_check_data_comp() so --ec 2+3 works on a two-stripe target.

An instantiated parity is checked against its data component in
lod_verify_ec_parity_comps(), using lod_comp_find_linked() for the
same pairing rule as the allocator. A parity with linked data needs a
bidirectional link, matching k/p and stripe size, and parity stripe
count ec_raidset_count() * p. A parity whose data mirror was split
off or deleted has no linked data and is skipped. A mismatch fails a
layout from the user or replay in lod_use_defined_striping(), but is
only logged for a layout loaded from disk by lod_parse_striping(), so
an existing file with a bad parity can still be opened and removed.
lod_verify_striping() checks k/p and rejects an instantiated parity
with stripe_count == 0 before DEFINED object init.

Also skip instantiating a parity in
lod_declare_instantiate_components() when its linked data is still
uninit and not in the same instantiate list. A mirror-targeted
RESYNC lease walks every component of the named mirror, and would
otherwise leave INIT parity over uninit PFL data that
lod_verify_ec_parity_comps() then rejects.

Tests: sanity-ec 4a and 10 accept p > k, and 4b rejects k == 0 and
k > 255. 8d no longer expects narrow components or -c 5 --ec 4+3 to
be refused. 8m covers mirror extend --ec 2+3 on a two-stripe target.
8n covers a mirror-targeted RESYNC lease that must not INIT parity
over uninit PFL data. 8o covers PFL -E 2M --ec 2+3
create/resync/verify, and 8p covers p > k multi-raidset
create/resync/verify. llapi_layout_test test47 allows 3+4.

Test-Parameters: testlist=sanity-ec ostcount=8
Signed-off-by: Keguang Xu <kxu@ddn.com>
Assisted-by: Cursor:Composer llm_code_and_review_tools
Signed-off-by: Andreas Dilger <adilger@thelustrecollective.com>
Assisted-by: ClaudeCode:claude-opus-5-5 ltvm llm_code_and_review_tools
Change-Id: I3878502e8ff739cb5ed420ff359e2008376303e7

LU-21103 lov: move EC raid set code out of lov_io.c

The policy that decides which stripes of an erasure coded read to
avoid is spread through lov_io_mirror_init() and
lov_ecio_add_data_sub(), and the raid set helpers it uses sit in
lov_io.c with the rest of the IO code.  Later patches give the raid
set decision a single implementation and let mirror selection use
the same OST availability checks, so move the code they build on to
where it can be shared first.

Move the OST availability predicates lov_sub_unreachable(),
lov_sub_slow(), lov_sub_unavailable() and lov_sub_loaded() to
lovsub_object.c, next to the sub-object they query.  Move the raid
set helpers and lov_ec_io_route() to a new file lov_ec.c, and
enum lov_ec_route to lov_cl_internal.h.  Functions still used from
lov_io.c are no longer static; the others stay static in their new
file.

No functional change.

Test-Parameters: testlist=sanity-ec ostcount=8
Test-Parameters: testlist=sanity-flr ostcount=8
Signed-off-by: Keguang Xu <kxu@ddn.com>
Assisted-by: Augment Agent:Claude Opus 5.5
Change-Id: I916aca81ede957bd1f317b0b36575e7aa1ff1c4e