Merge tag 'for-7.3/block-20260819' of git://git.kernel.org/pub/scm/linux/kernel/git...

Pull block updates from Jens Axboe:

 - NVMe updates via Keith:
     - Enable Clang context analysis for the nvme host driver, adding
       context annotations across core, fabrics, rdma, tcp and pci
     - nvmet reservation state exposed through a new namespace-level
       debugfs directory, plus ABI documentation for the host sysfs and
       target configfs interfaces
     - nvme-tcp host memory disclosure fixes on the read path: reject a
       read that transferred too few bytes, don't accept C2HData based
       on blk_rq_payload_bytes() alone, and fix the R2T case for a read
       command
     - Parallelize nvme-rdma I/O queue allocation and startup (Surabhi)
     - Apple nvme fixes and quirks: page aligned admin queue buffers,
       destroy the admin queue on removal, and various DMA/NVMMU
       correctness fixes
     - A large pile of nvmet and host fixes for out-of-bounds reads,
       refcount/resource leaks, and NULL derefs across auth, zns,
       passthru, pci-epf, rdma and configfs
     - Various other fixes and cleanups

 - MD updates via Yu Kuai:
     - llbitmap reshape support, the large series wiring exact bitmap
       mapping and reshape lifecycle through raid5 and raid10, growing
       the page cache in place, and remapping checkpointed bits as
       reshape progresses
     - raid5 fixes for lockless max_nr_stripes and recovery_offset
       accesses, a reshape deadlock with more failed devices than max
       degraded, and bitmap batch counter consistency
     - Atomic write handling for raid1/raid10, and removal of the
       REQ_NOWAIT support from raid1/10/456
     - raid5-ppl use-after-free fix in ppl_do_flush()
     - A batch of smaller fixes across md core and the bitmap code

 - s390/dasd ESE full-track write support and the surrounding
   infrastructure, plus enabling CONTEXT_ANALYSIS for s390/block

 - RWF_DONTCACHE support for block devices, built on new task-context
   bio completion infrastructure, and wiring it up for the iomap and
   buffer dropbehind writeback paths

 - Async io_uring zone reset all, plus zone management command cleanups
   allowing REQ_NOWAIT and tightening conventional zone rejection

 - Block integrity refactoring: lift BIP_CHECK_FLAGS to the shared
   header, handle nogenerate/noverify properly in fs-integrity, and drop
   the blk-integrity.h include from bdev.c

 - Split out a new blk_plug.h header

 - ublk improvements: add UBLK_F_IO_DESC_SIZE, split request validation
   from io_desc init, reject non-power-of-2 zone sizes in SET_PARAMS,
   and a series of hardening fixes around map/unmap and auto buf reg

 - null_blk cleanups and configfs serialization fixes

 - nbd queue freeze removal on the setup paths, and a new
   pre_defined_connections module parameter for pre-created devices

 - blk-cgroup fixes for the race between policy activation and blkg
   destruction, and accounting per-cpu stats over possible CPUs across
   blk-stat, iolatency, iocost and kyber

 - Various dio fixes: leak on metadata mapping error, validate user
   space vectors during extraction, and set dma_alignment from the
   backing file for loop and zloop direct I/O

 - bio cleanups

 - Various other fixes and cleanups all over

* tag 'for-7.3/block-20260819' of git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux: (241 commits)
  nbd: add pre_defined_connections module parameter for pre-created devices
  nbd: remove queue freeze for newly created nbd from netlink path
  nbd: factor out a nbd_genl_foreach_sock
  nbd: skip queue freeze when setting size at device startup
  nbd: remove queue freeze in nbd_add_socket
  nbd: clear queue limits on disconnect
  nbd: disallow NBD_SET_SOCK on an active device
  nbd: simplify find_fallback() by removing redundant logic
  blk-mq: add missing call to srcu_barrier() in blk_mq_free_tag_set()
  block: mtip32xx: synchronize ioctls with device removal
  ublk: avoid teardown retry loop on xarray allocation failure
  null_blk: fix UBSAN shift-out-of-bounds when zone_size is 0 or overflows
  block: don't include blk-integrity.h in bdev.c
  xfs: avoid double deferrals for RWF_DONTCACHE writes
  loop: Fix recently introduced lock inversion
  block: set QUEUE_FLAG_DYING unconditionally in blk_mark_disk_dead()
  swim3: Add missing MODULE_DESCRIPTION
  selftests: ublk: add SET_PARAMS validation test
  selftests: ublk: add helper for SET_PARAMS
  ublk: reject non-power-of-2 zone sizes in SET_PARAMS
  ...

diff --cc MAINTAINERS
Simple merge

diff --cc block/bdev.c
Simple merge

diff --cc block/fops.c
Simple merge

diff --cc block/genhd.c
Simple merge

diff --cc drivers/block/ublk_drv.c
Simple merge

diff --cc drivers/nvdimm/btt.c
Simple merge

diff --cc drivers/s390/block/dasd.c
Simple merge

diff --cc drivers/s390/block/dasd_eckd.c
index d356a9f,b4dcef0..8d976dd
--- 1/drivers/s390/block/dasd_eckd.c
--- 2/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@@ -19,8 -19,8 +19,9 @@@
  #include <linux/init.h>
  #include <linux/seq_file.h>
  #include <linux/uaccess.h>
+ #include <linux/utsname.h>
  #include <linux/io.h>
 +#include <linux/overflow.h>
  
  #include <asm/css_chars.h>
  #include <asm/machine.h>

diff --cc fs/buffer.c
Simple merge

diff --cc fs/erofs/zdata.c
Simple merge

diff --cc fs/fs-writeback.c
Simple merge

diff --cc fs/iomap/direct-io.c
index b3368d6,01daed3..8b4039d
--- 1/fs/iomap/direct-io.c
--- 2/fs/iomap/direct-io.c
+++ b/fs/iomap/direct-io.c
@@@ -913,173 -908,3 +914,175 @@@ iomap_dio_rw(struct kiocb *iocb, struc
        return iomap_dio_complete(dio);
  }
  EXPORT_SYMBOL_GPL(iomap_dio_rw);
-       ret = bio_iov_iter_get_pages(bio, iter, alignment - 1);
 +
 +struct iomap_dio_simple {
 +      struct kiocb            *iocb;
 +      size_t                  size;
 +      unsigned int            dio_flags;
 +      struct work_struct      work;
 +      /*
 +       * Align @bio to a cacheline boundary so that, combined with the
 +       * front_pad passed to bioset_init(), the bio sits at the start of
 +       * a cacheline in memory returned by the (HWCACHE-aligned) bio
 +       * slab.  This keeps the hot fields block layer touches on submit
 +       * and completion (bi_iter, bi_status, ...) within a single line.
 +       */
 +      struct bio              bio ____cacheline_aligned_in_smp;
 +};
 +
 +static struct bio_set iomap_dio_simple_pool;
 +
 +static ssize_t iomap_dio_simple_complete(struct iomap_dio_simple *sr)
 +{
 +      struct bio *bio = &sr->bio;
 +      struct kiocb *iocb = sr->iocb;
 +      struct inode *inode = file_inode(iocb->ki_filp);
 +      ssize_t ret;
 +
 +      if (unlikely(bio->bi_status)) {
 +              ret = blk_status_to_errno(bio->bi_status);
 +              if (should_report_dio_fserror(ret))
 +                      fserror_report_io(inode, FSERR_DIRECTIO_READ,
 +                                        iocb->ki_pos, sr->size, ret,
 +                                        GFP_NOFS);
 +      } else {
 +              ret = sr->size;
 +              iocb->ki_pos += ret;
 +      }
 +
 +      if (sr->dio_flags & IOMAP_DIO_USER_BACKED) {
 +              bio_check_pages_dirty(bio);
 +      } else {
 +              bio_release_pages(bio, false);
 +              bio_put(bio);
 +      }
 +      inode_dio_end(inode);
 +      trace_iomap_dio_complete(iocb, ret < 0 ? ret : 0, ret);
 +      return ret;
 +}
 +
 +static void iomap_dio_simple_complete_work(struct work_struct *work)
 +{
 +      struct iomap_dio_simple *sr =
 +              container_of(work, struct iomap_dio_simple, work);
 +      struct kiocb *iocb = sr->iocb;
 +
 +      WRITE_ONCE(iocb->private, NULL);
 +      iocb->ki_complete(iocb, iomap_dio_simple_complete(sr));
 +}
 +
 +static void iomap_dio_simple_end_io(struct bio *bio)
 +{
 +      struct iomap_dio_simple *sr =
 +              container_of(bio, struct iomap_dio_simple, bio);
 +      struct kiocb *iocb = sr->iocb;
 +
 +      if (unlikely(sr->bio.bi_status)) {
 +              struct inode *inode = file_inode(iocb->ki_filp);
 +
 +              INIT_WORK(&sr->work, iomap_dio_simple_complete_work);
 +              queue_work(inode->i_sb->s_dio_done_wq, &sr->work);
 +              return;
 +      }
 +
 +      WRITE_ONCE(iocb->private, NULL);
 +      iocb->ki_complete(iocb, iomap_dio_simple_complete(sr));
 +}
 +
 +ssize_t __iomap_dio_read_simple(struct kiocb *iocb, struct iov_iter *iter,
 +              struct iomap_iter *iomi)
 +{
 +      gfp_t gfp = (iomi->flags & IOMAP_NOWAIT) ? GFP_NOWAIT : GFP_KERNEL;
 +      struct iomap_dio_simple *sr;
 +      unsigned int alignment;
 +      struct bio *bio;
 +      ssize_t ret;
 +
 +      if (iomi->iomap.type != IOMAP_MAPPED ||
 +          iomi->iomap.offset + iomi->iomap.length < iomi->pos + iomi->len ||
 +          (iomi->iomap.flags & IOMAP_F_INTEGRITY)) {
 +              ret = -ENOTBLK;
 +              goto out_dio_end;
 +      }
 +
 +      alignment = iomap_dio_alignment(iomi->inode, iomi->iomap.bdev, 0);
 +      if ((iomi->pos | iomi->len) & (alignment - 1)) {
 +              ret = -EINVAL;
 +              goto out_dio_end;
 +      }
 +
 +      if (unlikely(!iomi->inode->i_sb->s_dio_done_wq &&
 +                      !is_sync_kiocb(iocb))) {
 +              ret = sb_init_dio_done_wq(iomi->inode->i_sb);
 +              if (ret < 0)
 +                      goto out_dio_end;
 +      }
 +
 +      trace_iomap_dio_rw_begin(iocb, iter, 0, 0);
 +
 +      bio = bio_alloc_bioset(iomi->iomap.bdev,
 +                             bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS),
 +                             REQ_OP_READ, gfp, &iomap_dio_simple_pool);
 +      if (!bio) {
 +              ret = -EAGAIN;
 +              goto out_dio_end;
 +      }
 +      sr = container_of(bio, struct iomap_dio_simple, bio);
 +      sr->iocb = iocb;
 +      sr->dio_flags = 0;
 +
 +      bio->bi_iter.bi_sector = iomap_sector(&iomi->iomap, iomi->pos);
 +      bio->bi_ioprio = iocb->ki_ioprio;
 +
++      ret = bio_iov_iter_get_pages(bio, iter,
++                              bdev_dma_alignment(bio->bi_bdev),
++                              alignment - 1);
 +      if (unlikely(ret))
 +              goto out_bio_put;
 +
 +      if (bio->bi_iter.bi_size != iomi->len) {
 +              iov_iter_revert(iter, bio->bi_iter.bi_size);
 +              ret = -ENOTBLK;
 +              goto out_bio_release_pages;
 +      }
 +
 +      sr->size = bio->bi_iter.bi_size;
 +      if (user_backed_iter(iter)) {
 +              bio_set_pages_dirty(bio);
 +              sr->dio_flags |= IOMAP_DIO_USER_BACKED;
 +      }
 +
 +      if (iocb->ki_flags & IOCB_NOWAIT)
 +              bio->bi_opf |= REQ_NOWAIT;
 +
 +      if (is_sync_kiocb(iocb)) {
 +              submit_bio_wait(bio);
 +              return iomap_dio_simple_complete(sr);
 +      }
 +
 +      if ((iocb->ki_flags & IOCB_HIPRI)) {
 +              bio->bi_opf |= REQ_POLLED;
 +              WRITE_ONCE(iocb->private, bio);
 +      }
 +      bio->bi_end_io = iomap_dio_simple_end_io;
 +      submit_bio(bio);
 +      trace_iomap_dio_rw_queued(iomi->inode, iocb->ki_pos, iomi->len);
 +      return -EIOCBQUEUED;
 +
 +out_bio_release_pages:
 +      bio_release_pages(bio, false);
 +out_bio_put:
 +      bio_put(bio);
 +out_dio_end:
 +      inode_dio_end(iomi->inode);
 +      return ret;
 +}
 +EXPORT_SYMBOL_GPL(__iomap_dio_read_simple);
 +
 +static int __init iomap_dio_init(void)
 +{
 +      return bioset_init(&iomap_dio_simple_pool, 4,
 +                         offsetof(struct iomap_dio_simple, bio),
 +                         BIOSET_NEED_BVECS | BIOSET_PERCPU_CACHE);
 +}
 +fs_initcall(iomap_dio_init);

diff --cc fs/iomap/ioend.c
Simple merge

diff --cc include/linux/blk_types.h
Simple merge

diff --cc include/linux/blkdev.h
Simple merge

diff --cc include/linux/io_uring_types.h
Simple merge

diff --cc include/linux/iomap.h
Simple merge

diff --cc io_uring/io_uring.h
Simple merge

diff --cc io_uring/kbuf.c
Simple merge

diff --cc io_uring/net.c
Simple merge

diff --cc kernel/exit.c
Simple merge

diff --cc kernel/sched/core.c
Simple merge

diff --cc mm/vmscan.c
Simple merge