LU-12462 osc: layout and chunkbits alignment mismatch

In the discard case, the OSC fsync/writeback code asserts
that each OSC extent is fully covered by the fsync request.

It may happen that a start(or an end) of a component does not match
the first (the last) osc object extent start (end), which is aligned
by the cl_chunkbits which depends on the OST block size.

The requirement for the component alignment is LOV_MIN_STRIPE_SIZE
which is 64K, the ZFS block size could be in MBs.

Use an aligned by chunk size the fsync reqion in the assertion.

Fixes: 092ecd6612 ("LU-12462 osc: Do not assert for first extent")

Signed-off-by: Vitaly Fertman <c17818@cray.com>
Change-Id: I2ff47fc87c838239142ffc63bebafce3e9403f4e
Cray-bug-id: LUS-7498
Reviewed-on: https://review.whamcloud.com/35733
Reviewed-by: Mike Pershin <mpershin@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Patrick Farrell <pfarrell@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/osc/osc_cache.c b/lustre/osc/osc_cache.c
index 041abf5..431df82 100644 (file)
--- a/lustre/osc/osc_cache.c
+++ b/lustre/osc/osc_cache.c
@@ -3037,17 +3037,25 @@ int osc_cache_writeback_range(const struct lu_env *env, struct osc_object *obj,
                                        list_move_tail(&ext->oe_link, list);
                                unplug = true;
                        } else {
                                        list_move_tail(&ext->oe_link, list);
                                unplug = true;
                        } else {

+                               struct client_obd *cli = osc_cli(obj);
+                               int pcc_bits = cli->cl_chunkbits - PAGE_SHIFT;
+                               pgoff_t align_by = (1 << pcc_bits);
+                               pgoff_t a_start = round_down(start, align_by);
+                               pgoff_t a_end = round_up(end, align_by);
+
+                               /* overflow case */
+                               if (end && !a_end)
+                                       a_end = CL_PAGE_EOF;

                                /* the only discarder is lock cancelling, so
                                /* the only discarder is lock cancelling, so

-                                * [start, end] must contain this extent.
-                                * However, with DOM, osc extent alignment may
-                                * cause the first extent to start before the
-                                * OST portion of the layout.  This is never
-                                * accessed for i/o, but the unused portion
-                                * will not be covered by the sync request,
-                                * so we cannot assert in that case. */
-                               EASSERT(ergo(!(ext == first_extent(obj)),
-                                       ext->oe_start >= start &&
-                                       ext->oe_end <= end), ext);
+                                * [start, end], aligned by chunk size, must
+                                * contain this extent */
+                               LASSERTF(ext->oe_start >= a_start &&
+                                        ext->oe_end <= a_end,
+                                        "ext [%lu, %lu] reg [%lu, %lu] "
+                                        "orig [%lu %lu] align %lu bits "
+                                        "%d\n", ext->oe_start, ext->oe_end,
+                                        a_start, a_end, start, end,
+                                        align_by, pcc_bits);

                                osc_extent_state_set(ext, OES_LOCKING);
                                ext->oe_owner = current;
                                list_move_tail(&ext->oe_link,
                                osc_extent_state_set(ext, OES_LOCKING);
                                ext->oe_owner = current;
                                list_move_tail(&ext->oe_link,