diff --git a/bsc-1202600_01-remove-QUEUE_FLAG_DISCARD.patch b/bsc-1202600_01-remove-QUEUE_FLAG_DISCARD.patch new file mode 100644 index 0000000..a045a1d --- /dev/null +++ b/bsc-1202600_01-remove-QUEUE_FLAG_DISCARD.patch @@ -0,0 +1,156 @@ +/* + This patch is related with following upstream kernel commit. + This patch uses QUEUE_FLAG_STABLE_WRITES to replace QUEUE_FLAG_DISCARD. + */ + +commit 70200574cc229f6ba038259e8142af2aa09e6976 +Author: Christoph Hellwig +Date: Fri Apr 15 06:52:55 2022 +0200 + + block: remove QUEUE_FLAG_DISCARD + + Just use a non-zero max_discard_sectors as an indicator for discard + support, similar to what is done for write zeroes. + + The only places where needs special attention is the RAID5 driver, + which must clear discard support for security reasons by default, + even if the default stacking rules would allow for it. + + Signed-off-by: Christoph Hellwig + Reviewed-by: Martin K. Petersen + Acked-by: Christoph Böhmwalder [drbd] + Acked-by: Jan Höppner [s390] + Acked-by: Coly Li [bcache] + Acked-by: David Sterba [btrfs] + Reviewed-by: Chaitanya Kulkarni + Link: https://lore.kernel.org/r/20220415045258.199825-25-hch@lst.de + Signed-off-by: Jens Axboe +--- + +diff -Nupr a/drbd/drbd-kernel-compat/tests/have_blk_queue_flag_set.c b/drbd/drbd-kernel-compat/tests/have_blk_queue_flag_set.c +--- a/drbd/drbd-kernel-compat/tests/have_blk_queue_flag_set.c 2022-08-22 18:14:20.639382230 +0800 ++++ b/drbd/drbd-kernel-compat/tests/have_blk_queue_flag_set.c 2022-08-22 18:14:43.819285373 +0800 +@@ -3,5 +3,5 @@ + + void dummy(struct request_queue *q) + { +- blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); ++ blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, q); + } +diff -Nupr a/drbd/drbd_main.c b/drbd/drbd_main.c +--- a/drbd/drbd_main.c 2022-08-23 08:04:26.097721587 +0800 ++++ b/drbd/drbd_main.c 2022-08-23 08:04:41.449655955 +0800 +@@ -1574,7 +1574,7 @@ static void assign_p_sizes_qlim(struct d + p->qlim->alignment_offset = cpu_to_be32(queue_alignment_offset(q)); + p->qlim->io_min = cpu_to_be32(queue_io_min(q)); + p->qlim->io_opt = cpu_to_be32(queue_io_opt(q)); +- p->qlim->discard_enabled = blk_queue_discard(q); ++ p->qlim->discard_enabled = !!bdev_max_discard_sectors(device->ldev->backing_bdev); + p->qlim->discard_zeroes_data = queue_discard_zeroes_data(q); + p->qlim->write_same_capable = !!q->limits.max_write_same_sectors; + } else { +diff -Nupr a/drbd/drbd_nl.c b/drbd/drbd_nl.c +--- a/drbd/drbd_nl.c 2022-08-23 08:04:26.101721570 +0800 ++++ b/drbd/drbd_nl.c 2022-08-23 08:04:41.453655938 +0800 +@@ -1967,13 +1967,14 @@ static unsigned int drbd_max_discard_sec + static void decide_on_discard_support(struct drbd_device *device, + struct request_queue *q, + struct request_queue *b, +- bool discard_zeroes_if_aligned) ++ bool discard_zeroes_if_aligned, ++ struct drbd_backing_dev *bdev) + { + /* q = drbd device queue (device->rq_queue) + * b = backing device queue (device->ldev->backing_bdev->bd_disk->queue), + * or NULL if diskless + */ +- bool can_do = b ? blk_queue_discard(b) : true; ++ bool can_do = b ? bdev_max_discard_sectors(bdev->backing_bdev) : true; + + if (can_do && b && !queue_discard_zeroes_data(b) && !discard_zeroes_if_aligned) { + can_do = false; +@@ -1992,23 +1993,12 @@ static void decide_on_discard_support(st + * topology on all peers. */ + blk_queue_discard_granularity(q, 512); + q->limits.max_discard_sectors = drbd_max_discard_sectors(device->resource); +- blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); ++ q->limits.max_write_zeroes_sectors = ++ drbd_max_discard_sectors(device->resource); + } else { +- blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); + blk_queue_discard_granularity(q, 0); + q->limits.max_discard_sectors = 0; +- } +-} +- +-static void fixup_discard_if_not_supported(struct request_queue *q) +-{ +- /* To avoid confusion, if this queue does not support discard, clear +- * max_discard_sectors, which is what lsblk -D reports to the user. +- * Older kernels got this wrong in "stack limits". +- * */ +- if (!blk_queue_discard(q)) { +- blk_queue_max_discard_sectors(q, 0); +- blk_queue_discard_granularity(q, 0); ++ q->limits.max_write_zeroes_sectors = 0; + } + } + +@@ -2116,7 +2106,7 @@ static void drbd_setup_queue_param(struc + blk_queue_max_hw_sectors(q, max_hw_sectors); + /* This is the workaround for "bio would need to, but cannot, be split" */ + blk_queue_segment_boundary(q, PAGE_SIZE-1); +- decide_on_discard_support(device, q, b, discard_zeroes_if_aligned); ++ decide_on_discard_support(device, q, b, discard_zeroes_if_aligned, bdev); + decide_on_write_same_support(device, q, b, o, disable_write_same); + + if (b) { +@@ -2127,7 +2117,6 @@ static void drbd_setup_queue_param(struc + blk_queue_update_readahead(q); + #endif + } +- fixup_discard_if_not_supported(q); + fixup_write_zeroes(device, q); + } + +@@ -2233,13 +2222,14 @@ static void sanitize_disk_conf(struct dr + struct drbd_backing_dev *nbc) + { + struct request_queue * const q = nbc->backing_bdev->bd_disk->queue; ++ struct block_device *bdev = nbc->backing_bdev; + + if (disk_conf->al_extents < DRBD_AL_EXTENTS_MIN) + disk_conf->al_extents = DRBD_AL_EXTENTS_MIN; + if (disk_conf->al_extents > drbd_al_extents_max(nbc)) + disk_conf->al_extents = drbd_al_extents_max(nbc); + +- if (!blk_queue_discard(q) || ++ if (!bdev_max_discard_sectors(bdev) || + (!queue_discard_zeroes_data(q) && !disk_conf->discard_zeroes_if_aligned)) { + if (disk_conf->rs_discard_granularity) { + disk_conf->rs_discard_granularity = 0; /* disable feature */ +@@ -2261,7 +2251,7 @@ static void sanitize_disk_conf(struct dr + /* compat: + * old kernel has 0 granularity means "unknown" means one sector. + * current kernel has 0 granularity means "discard not supported". +- * Not supported is checked above already with !blk_queue_discard(q). ++ * Not supported is checked above already with !blk_max_discard_sectors(). + */ + unsigned int ql_dg = q->limits.discard_granularity ?: 512; + +diff -Nupr a/drbd/drbd_receiver.c b/drbd/drbd_receiver.c +--- a/drbd/drbd_receiver.c 2022-08-23 08:04:26.105721553 +0800 ++++ b/drbd/drbd_receiver.c 2022-08-23 08:25:31.188262629 +0800 +@@ -1686,11 +1686,10 @@ int drbd_issue_discard_or_zero_out(struc + + static bool can_do_reliable_discards(struct drbd_device *device) + { +- struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); + struct disk_conf *dc; + bool can_do; + +- if (!blk_queue_discard(q)) ++ if (!bdev_max_discard_sectors(device->ldev->backing_bdev)) + return false; + + if (queue_discard_zeroes_data(q)) diff --git a/bsc-1202600_02-dax-introduce-DAX_RECOVERY_WRITE-dax-access-mode.patch b/bsc-1202600_02-dax-introduce-DAX_RECOVERY_WRITE-dax-access-mode.patch new file mode 100644 index 0000000..a2ee265 --- /dev/null +++ b/bsc-1202600_02-dax-introduce-DAX_RECOVERY_WRITE-dax-access-mode.patch @@ -0,0 +1,47 @@ +/* This patch is related with following upstream kernel commit. */ + +From e511c4a3d2a1f64aafc1f5df37a2ffcf7ef91b55 Mon Sep 17 00:00:00 2001 +From: Jane Chu +Date: Fri, 13 May 2022 15:10:58 -0700 +Subject: [PATCH] dax: introduce DAX_RECOVERY_WRITE dax access mode + +Up till now, dax_direct_access() is used implicitly for normal +access, but for the purpose of recovery write, dax range with +poison is requested. To make the interface clear, introduce + enum dax_access_mode { + DAX_ACCESS, + DAX_RECOVERY_WRITE, + } +where DAX_ACCESS is used for normal dax access, and +DAX_RECOVERY_WRITE is used for dax recovery write. + +Suggested-by: Dan Williams +Signed-off-by: Jane Chu +Reviewed-by: Christoph Hellwig +Cc: Mike Snitzer +Reviewed-by: Vivek Goyal +Link: https://lore.kernel.org/r/165247982851.52965.11024212198889762949.stgit@dwillia2-desk3.amr.corp.intel.com +Signed-off-by: Dan Williams +--- + +diff -Nupr a/drbd/drbd_dax_pmem.c b/drbd/drbd_dax_pmem.c +--- a/drbd/drbd_dax_pmem.c 2022-08-22 16:26:24.786369807 +0800 ++++ b/drbd/drbd_dax_pmem.c 2022-08-22 16:26:47.706276429 +0800 +@@ -86,7 +86,7 @@ static int map_superblock_for_dax(struct + int id; + + id = dax_read_lock(); +- len = dax_direct_access(dax_dev, pgoff, want, &kaddr, &pfn_unused); ++ len = dax_direct_access(dax_dev, pgoff, want, DAX_ACCESS, &kaddr, &pfn_unused); + dax_read_unlock(id); + + if (len < want) +@@ -147,7 +147,7 @@ int drbd_dax_map(struct drbd_backing_dev + int id; + + id = dax_read_lock(); +- len = dax_direct_access(dax_dev, pgoff, want, &kaddr, &pfn_unused); ++ len = dax_direct_access(dax_dev, pgoff, want, DAX_ACCESS, &kaddr, &pfn_unused); + dax_read_unlock(id); + + if (len < want) diff --git a/bsc-1202600_03-block-decouple-REQ_OP_SECURE_ERASE-from-REQ_OP_DISCA.patch b/bsc-1202600_03-block-decouple-REQ_OP_SECURE_ERASE-from-REQ_OP_DISCA.patch new file mode 100644 index 0000000..83c2888 --- /dev/null +++ b/bsc-1202600_03-block-decouple-REQ_OP_SECURE_ERASE-from-REQ_OP_DISCA.patch @@ -0,0 +1,49 @@ +/* This patch is related with following upstream kernel commit. */ + +From 44abff2c0b970ae3d310b97617525dc01f248d7c Mon Sep 17 00:00:00 2001 +From: Christoph Hellwig +Date: Fri, 15 Apr 2022 06:52:57 +0200 +Subject: [PATCH] block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Secure erase is a very different operation from discard in that it is +a data integrity operation vs hint. Fully split the limits and helper +infrastructure to make the separation more clear. + +Signed-off-by: Christoph Hellwig +Reviewed-by: Martin K. Petersen +Acked-by: Christoph Böhmwalder [drbd] +Acked-by: Ryusuke Konishi [nifs2] +Acked-by: Jaegeuk Kim [f2fs] +Acked-by: Coly Li [bcache] +Acked-by: David Sterba [btrfs] +Acked-by: Chao Yu +Reviewed-by: Chaitanya Kulkarni +Link: https://lore.kernel.org/r/20220415045258.199825-27-hch@lst.de +Signed-off-by: Jens Axboe +--- + +diff -Nupr a/drbd/drbd_receiver.c b/drbd/drbd_receiver.c +--- a/drbd/drbd_receiver.c 2022-08-22 16:34:38.332333231 +0800 ++++ b/drbd/drbd_receiver.c 2022-08-22 16:36:22.651901537 +0800 +@@ -1658,7 +1658,8 @@ int drbd_issue_discard_or_zero_out(struc + start = tmp; + } + while (nr_sectors >= max_discard_sectors) { +- err |= blkdev_issue_discard(bdev, start, max_discard_sectors, GFP_NOIO, 0); ++ err |= blkdev_issue_discard(bdev, start, max_discard_sectors, ++ GFP_NOIO); + nr_sectors -= max_discard_sectors; + start += max_discard_sectors; + } +@@ -1670,7 +1671,7 @@ int drbd_issue_discard_or_zero_out(struc + nr = nr_sectors; + nr -= (unsigned int)nr % granularity; + if (nr) { +- err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, 0); ++ err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO); + nr_sectors -= nr; + start += nr; + } diff --git a/bsc-1202600_04-remove-assign_p_sizes_qlim.patch b/bsc-1202600_04-remove-assign_p_sizes_qlim.patch new file mode 100644 index 0000000..66f627d --- /dev/null +++ b/bsc-1202600_04-remove-assign_p_sizes_qlim.patch @@ -0,0 +1,99 @@ +/* This patch is related with following upstream kernel commit. */ + +From 40349d0e16cedd0de561f59752c3249780fb749b Mon Sep 17 00:00:00 2001 +From: Christoph Hellwig +Date: Fri, 15 Apr 2022 06:52:35 +0200 +Subject: [PATCH] drbd: remove assign_p_sizes_qlim +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Fold each branch into its only caller. + +Signed-off-by: Christoph Hellwig +Acked-by: Christoph Böhmwalder +Link: https://lore.kernel.org/r/20220415045258.199825-5-hch@lst.de +Signed-off-by: Jens Axboe +--- + +diff -Nupr a/drbd/drbd_main.c b/drbd/drbd_main.c +--- a/drbd/drbd_main.c 2022-08-22 23:16:08.082402396 +0800 ++++ b/drbd/drbd_main.c 2022-08-22 23:22:31.292772570 +0800 +@@ -1565,31 +1565,6 @@ int drbd_attach_peer_device(struct drbd_ + return err; + } + +-/* communicated if (agreed_features & DRBD_FF_WSAME) */ +-static void assign_p_sizes_qlim(struct drbd_device *device, struct p_sizes *p, struct request_queue *q) +-{ +- if (q) { +- p->qlim->physical_block_size = cpu_to_be32(queue_physical_block_size(q)); +- p->qlim->logical_block_size = cpu_to_be32(queue_logical_block_size(q)); +- p->qlim->alignment_offset = cpu_to_be32(queue_alignment_offset(q)); +- p->qlim->io_min = cpu_to_be32(queue_io_min(q)); +- p->qlim->io_opt = cpu_to_be32(queue_io_opt(q)); +- p->qlim->discard_enabled = !!bdev_max_discard_sectors(device->ldev->backing_bdev); +- p->qlim->discard_zeroes_data = queue_discard_zeroes_data(q); +- p->qlim->write_same_capable = !!q->limits.max_write_same_sectors; +- } else { +- q = device->rq_queue; +- p->qlim->physical_block_size = cpu_to_be32(queue_physical_block_size(q)); +- p->qlim->logical_block_size = cpu_to_be32(queue_logical_block_size(q)); +- p->qlim->alignment_offset = 0; +- p->qlim->io_min = cpu_to_be32(queue_io_min(q)); +- p->qlim->io_opt = cpu_to_be32(queue_io_opt(q)); +- p->qlim->discard_enabled = 0; +- p->qlim->discard_zeroes_data = 0; +- p->qlim->write_same_capable = 0; +- } +-} +- + int drbd_send_sizes(struct drbd_peer_device *peer_device, + uint64_t u_size_diskless, enum dds_flags flags) + { +@@ -1610,7 +1585,9 @@ int drbd_send_sizes(struct drbd_peer_dev + + memset(p, 0, packet_size); + if (get_ldev_if_state(device, D_NEGOTIATING)) { +- struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); ++ struct block_device *bdev = device->ldev->backing_bdev; ++ struct request_queue *q = bdev_get_queue(bdev); ++ + d_size = drbd_get_max_capacity(device, device->ldev, false); + rcu_read_lock(); + u_size = rcu_dereference(device->ldev->disk_conf)->disk_size; +@@ -1618,14 +1595,32 @@ int drbd_send_sizes(struct drbd_peer_dev + q_order_type = drbd_queue_order_type(device); + max_bio_size = queue_max_hw_sectors(q) << 9; + max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE); +- assign_p_sizes_qlim(device, p, q); ++ p->qlim->physical_block_size = ++ cpu_to_be32(bdev_physical_block_size(bdev)); ++ p->qlim->logical_block_size = ++ cpu_to_be32(bdev_logical_block_size(bdev)); ++ p->qlim->alignment_offset = ++ cpu_to_be32(bdev_alignment_offset(bdev)); ++ p->qlim->io_min = cpu_to_be32(bdev_io_min(bdev)); ++ p->qlim->io_opt = cpu_to_be32(bdev_io_opt(bdev)); ++ p->qlim->discard_enabled = !!bdev_max_discard_sectors(bdev); + put_ldev(device); + } else { ++ struct request_queue *q = device->rq_queue; ++ ++ p->qlim->physical_block_size = ++ cpu_to_be32(queue_physical_block_size(q)); ++ p->qlim->logical_block_size = ++ cpu_to_be32(queue_logical_block_size(q)); ++ p->qlim->alignment_offset = 0; ++ p->qlim->io_min = cpu_to_be32(queue_io_min(q)); ++ p->qlim->io_opt = cpu_to_be32(queue_io_opt(q)); ++ p->qlim->discard_enabled = 0; ++ + d_size = 0; + u_size = u_size_diskless; + q_order_type = QUEUE_ORDERED_NONE; + max_bio_size = DRBD_MAX_BIO_SIZE; /* ... multiple BIOs per peer_request */ +- assign_p_sizes_qlim(device, p, NULL); + } + + if (peer_device->connection->agreed_pro_version <= 94) diff --git a/drbd.changes b/drbd.changes index 192c319..33c7321 100644 --- a/drbd.changes +++ b/drbd.changes @@ -1,3 +1,15 @@ +------------------------------------------------------------------- +Tue Aug 23 00:13:00 UTC 2022 - Heming Zhao + +- drbd: build error against kernel v5.19 (bsc#1202600) + - add patch: + + bsc-1202600_01-remove-QUEUE_FLAG_DISCARD.patch + + bsc-1202600_02-dax-introduce-DAX_RECOVERY_WRITE-dax-access-mode.patch + + bsc-1202600_03-block-decouple-REQ_OP_SECURE_ERASE-from-REQ_OP_DISCA.patch + + bsc-1202600_04-remove-assign_p_sizes_qlim.patch + - For rpmbuild warning, modify symlink /usr/sbin/rcdrbd to relative path + + drbd.spec + ------------------------------------------------------------------- Fri Jul 08 12:47:00 UTC 2022 - Heming Zhao diff --git a/drbd.spec b/drbd.spec index dcc45c4..d40578e 100644 --- a/drbd.spec +++ b/drbd.spec @@ -52,6 +52,10 @@ Patch15: bsc-1201335_05-bio_alloc.patch Patch16: bsc-1201335_06-bdi.patch Patch17: bsc-1201335_07-write-same.patch Patch18: bsc-1201335_08-bio_clone_fast.patch +Patch19: bsc-1202600_01-remove-QUEUE_FLAG_DISCARD.patch +Patch20: bsc-1202600_02-dax-introduce-DAX_RECOVERY_WRITE-dax-access-mode.patch +Patch21: bsc-1202600_03-block-decouple-REQ_OP_SECURE_ERASE-from-REQ_OP_DISCA.patch +Patch22: bsc-1202600_04-remove-assign_p_sizes_qlim.patch Patch99: suse-coccinelle.patch #https://github.com/openSUSE/rpmlint-checks/blob/master/KMPPolicyCheck.py BuildRequires: coccinelle >= 1.0.8 @@ -103,6 +107,10 @@ installed kernel. %patch16 -p1 %patch17 -p1 %patch18 -p1 +%patch19 -p1 +%patch20 -p1 +%patch21 -p1 +%patch22 -p1 %patch99 -p1 mkdir source @@ -142,7 +150,7 @@ for flavor in %{flavors_to_build}; do done mkdir -p %{buildroot}/%{_sbindir} -ln -s -f %{_sbindir}/service %{buildroot}/%{_sbindir}/rc%{name} +ln -s service %{buildroot}/%{_sbindir}/rc%{name} rm -f drbd.conf %files