Commit a3b111b0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-6.4/block-2023-05-06' of git://git.kernel.dk/linux 

Pull more block updates from Jens Axboe:

 - MD pull request via Song:
      - Improve raid5 sequential IO performance on spinning disks, which
        fixes a regression since v6.0 (Jan Kara)
      - Fix bitmap offset types, which fixes an issue introduced in this
        merge window (Jonathan Derrick)

 - Cleanup of hweight type used for cgroup writeback (Maxim)

 - Fix a regression with the "has_submit_bio" changes across partitions
   (Ming)

 - Cleanup of QUEUE_FLAG_ADD_RANDOM clearing.

   We used to set this flag on queues non blk-mq queues, and hence some
   drivers clear it unconditionally. Since all of these have since been
   converted to true blk-mq drivers, drop the useless clear as the bit
   is not set (Chaitanya)

 - Fix the flags being set in a bio for a flush for drbd (Christoph)

 - Cleanup and deduplication of the code handling setting block device
   capacity (Damien)

 - Fix for ublk handling IO timeouts (Ming)

 - Fix for a regression in blk-cgroup teardown (Tao)

 - NBD documentation and code fixes (Eric)

 - Convert blk-integrity to using device_attributes rather than a second
   kobject to manage lifetimes (Thomas)

* tag 'for-6.4/block-2023-05-06' of git://git.kernel.dk/linux:
  ublk: add timeout handler
  drbd: correctly submit flush bio on barrier
  mailmap: add mailmap entries for Jens Axboe
  block: Skip destroyed blkg when restart in blkg_destroy_all()
  writeback: fix call of incorrect macro
  md: Fix bitmap offset type in sb writer
  md/raid5: Improve performance for sequential IO
  docs nbd: userspace NBD now favors github over sourceforge
  block nbd: use req.cookie instead of req.handle
  uapi nbd: add cookie alias to handle
  uapi nbd: improve doc links to userspace spec
  blk-integrity: register sysfs attributes on struct device
  blk-integrity: convert to struct device_attribute
  blk-integrity: use sysfs_emit
  block/drivers: remove dead clear of random flag
  block: sync part's ->bd_has_submit_bio with disk's
  block: Cleanup set_capacity()/bdev_set_nr_sectors()
parents 7644c823 c0b79b0f

.mailmap

+4 −1
Original line number Diff line number Diff line
@@ -213,7 +213,10 @@ Jeff Garzik <jgarzik@pretzel.yyz.us> 
Jeff Layton <jlayton@kernel.org> <jlayton@poochiereds.net>

Jeff Layton <jlayton@kernel.org> <jlayton@primarydata.com>

Jeff Layton <jlayton@kernel.org> <jlayton@redhat.com>

Jens Axboe <axboe@suse.de>

Jens Axboe <axboe@kernel.dk> <axboe@suse.de>

Jens Axboe <axboe@kernel.dk> <jens.axboe@oracle.com>

Jens Axboe <axboe@kernel.dk> <axboe@fb.com>

Jens Axboe <axboe@kernel.dk> <axboe@meta.com>

Jens Osterkamp <Jens.Osterkamp@de.ibm.com>

Jernej Skrabec <jernej.skrabec@gmail.com> <jernej.skrabec@siol.net>

Jessica Zhang <quic_jesszhan@quicinc.com> <jesszhan@codeaurora.org>

Documentation/admin-guide/blockdev/nbd.rst

+1 −1
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ to borrow disk space from another computer. 
Unlike NFS, it is possible to put any filesystem on it, etc.



For more information, or to download the nbd-client and nbd-server

tools, go to http://nbd.sf.net/.

tools, go to https://github.com/NetworkBlockDevice/nbd.



The nbd kernel module need only be installed on the client

system, as the nbd-server is completely in userspace. In fact,

block/bdev.c

+12 −1
Original line number Diff line number Diff line
@@ -418,8 +418,11 @@ struct block_device *bdev_alloc(struct gendisk *disk, u8 partno) 
	bdev->bd_partno = partno;

	bdev->bd_inode = inode;

	bdev->bd_queue = disk->queue;

	bdev->bd_stats = alloc_percpu(struct disk_stats);

	if (partno)

		bdev->bd_has_submit_bio = disk->part0->bd_has_submit_bio;

	else

		bdev->bd_has_submit_bio = false;

	bdev->bd_stats = alloc_percpu(struct disk_stats);

	if (!bdev->bd_stats) {

		iput(inode);

		return NULL;
@@ -428,6 +431,14 @@ struct block_device *bdev_alloc(struct gendisk *disk, u8 partno) 
	return bdev;

}



void bdev_set_nr_sectors(struct block_device *bdev, sector_t sectors)

{

	spin_lock(&bdev->bd_size_lock);

	i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);

	bdev->bd_nr_sectors = sectors;

	spin_unlock(&bdev->bd_size_lock);

}



void bdev_add(struct block_device *bdev, dev_t dev)

{

	bdev->bd_dev = dev;

block/blk-cgroup.c

+3 −0
Original line number Diff line number Diff line
@@ -567,6 +567,9 @@ static void blkg_destroy_all(struct gendisk *disk) 
	list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {

		struct blkcg *blkcg = blkg->blkcg;



		if (hlist_unhashed(&blkg->blkcg_node))

			continue;



		spin_lock(&blkcg->lock);

		blkg_destroy(blkg);

		spin_unlock(&blkcg->lock);

block/blk-integrity.c

+61 −114
Original line number Diff line number Diff line
@@ -212,61 +212,44 @@ bool blk_integrity_merge_bio(struct request_queue *q, struct request *req, 
	return true;

}



struct integrity_sysfs_entry {

	struct attribute attr;

	ssize_t (*show)(struct blk_integrity *, char *);

	ssize_t (*store)(struct blk_integrity *, const char *, size_t);

};



static ssize_t integrity_attr_show(struct kobject *kobj, struct attribute *attr,

				   char *page)

static inline struct blk_integrity *dev_to_bi(struct device *dev)

{

	struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);

	struct blk_integrity *bi = &disk->queue->integrity;

	struct integrity_sysfs_entry *entry =

		container_of(attr, struct integrity_sysfs_entry, attr);



	return entry->show(bi, page);

	return &dev_to_disk(dev)->queue->integrity;

}



static ssize_t integrity_attr_store(struct kobject *kobj,

				    struct attribute *attr, const char *page,

				    size_t count)

static ssize_t format_show(struct device *dev, struct device_attribute *attr,

			   char *page)

{

	struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);

	struct blk_integrity *bi = &disk->queue->integrity;

	struct integrity_sysfs_entry *entry =

		container_of(attr, struct integrity_sysfs_entry, attr);

	ssize_t ret = 0;



	if (entry->store)

		ret = entry->store(bi, page, count);

	struct blk_integrity *bi = dev_to_bi(dev);



	return ret;

}



static ssize_t integrity_format_show(struct blk_integrity *bi, char *page)

{

	if (bi->profile && bi->profile->name)

		return sprintf(page, "%s\n", bi->profile->name);

	else

		return sprintf(page, "none\n");

		return sysfs_emit(page, "%s\n", bi->profile->name);

	return sysfs_emit(page, "none\n");

}



static ssize_t integrity_tag_size_show(struct blk_integrity *bi, char *page)

static ssize_t tag_size_show(struct device *dev, struct device_attribute *attr,

			     char *page)

{

	return sprintf(page, "%u\n", bi->tag_size);

	struct blk_integrity *bi = dev_to_bi(dev);



	return sysfs_emit(page, "%u\n", bi->tag_size);

}



static ssize_t integrity_interval_show(struct blk_integrity *bi, char *page)

static ssize_t protection_interval_bytes_show(struct device *dev,

					      struct device_attribute *attr,

					      char *page)

{

	return sprintf(page, "%u\n",

	struct blk_integrity *bi = dev_to_bi(dev);



	return sysfs_emit(page, "%u\n",

			  bi->interval_exp ? 1 << bi->interval_exp : 0);

}



static ssize_t integrity_verify_store(struct blk_integrity *bi,

static ssize_t read_verify_store(struct device *dev,

				 struct device_attribute *attr,

				 const char *page, size_t count)

{

	struct blk_integrity *bi = dev_to_bi(dev);

	char *p = (char *) page;

	unsigned long val = simple_strtoul(p, &p, 10);
@@ -278,14 +261,20 @@ static ssize_t integrity_verify_store(struct blk_integrity *bi, 
	return count;

}



static ssize_t integrity_verify_show(struct blk_integrity *bi, char *page)

static ssize_t read_verify_show(struct device *dev,

				struct device_attribute *attr, char *page)

{

	return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_VERIFY) != 0);

	struct blk_integrity *bi = dev_to_bi(dev);



	return sysfs_emit(page, "%d\n", !!(bi->flags & BLK_INTEGRITY_VERIFY));

}



static ssize_t integrity_generate_store(struct blk_integrity *bi,

static ssize_t write_generate_store(struct device *dev,

				    struct device_attribute *attr,

				    const char *page, size_t count)

{

	struct blk_integrity *bi = dev_to_bi(dev);



	char *p = (char *) page;

	unsigned long val = simple_strtoul(p, &p, 10);
@@ -297,68 +286,44 @@ static ssize_t integrity_generate_store(struct blk_integrity *bi, 
	return count;

}



static ssize_t integrity_generate_show(struct blk_integrity *bi, char *page)

static ssize_t write_generate_show(struct device *dev,

				   struct device_attribute *attr, char *page)

{

	return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_GENERATE) != 0);

}

	struct blk_integrity *bi = dev_to_bi(dev);



static ssize_t integrity_device_show(struct blk_integrity *bi, char *page)

{

	return sprintf(page, "%u\n",

		       (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) != 0);

	return sysfs_emit(page, "%d\n", !!(bi->flags & BLK_INTEGRITY_GENERATE));

}



static struct integrity_sysfs_entry integrity_format_entry = {

	.attr = { .name = "format", .mode = 0444 },

	.show = integrity_format_show,

};



static struct integrity_sysfs_entry integrity_tag_size_entry = {

	.attr = { .name = "tag_size", .mode = 0444 },

	.show = integrity_tag_size_show,

};



static struct integrity_sysfs_entry integrity_interval_entry = {

	.attr = { .name = "protection_interval_bytes", .mode = 0444 },

	.show = integrity_interval_show,

};



static struct integrity_sysfs_entry integrity_verify_entry = {

	.attr = { .name = "read_verify", .mode = 0644 },

	.show = integrity_verify_show,

	.store = integrity_verify_store,

};

static ssize_t device_is_integrity_capable_show(struct device *dev,

						struct device_attribute *attr,

						char *page)

{

	struct blk_integrity *bi = dev_to_bi(dev);



static struct integrity_sysfs_entry integrity_generate_entry = {

	.attr = { .name = "write_generate", .mode = 0644 },

	.show = integrity_generate_show,

	.store = integrity_generate_store,

};

	return sysfs_emit(page, "%u\n",

			  !!(bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE));

}



static struct integrity_sysfs_entry integrity_device_entry = {

	.attr = { .name = "device_is_integrity_capable", .mode = 0444 },

	.show = integrity_device_show,

};

static DEVICE_ATTR_RO(format);

static DEVICE_ATTR_RO(tag_size);

static DEVICE_ATTR_RO(protection_interval_bytes);

static DEVICE_ATTR_RW(read_verify);

static DEVICE_ATTR_RW(write_generate);

static DEVICE_ATTR_RO(device_is_integrity_capable);



static struct attribute *integrity_attrs[] = {

	&integrity_format_entry.attr,

	&integrity_tag_size_entry.attr,

	&integrity_interval_entry.attr,

	&integrity_verify_entry.attr,

	&integrity_generate_entry.attr,

	&integrity_device_entry.attr,

	NULL,

};

ATTRIBUTE_GROUPS(integrity);



static const struct sysfs_ops integrity_ops = {

	.show	= &integrity_attr_show,

	.store	= &integrity_attr_store,

	&dev_attr_format.attr,

	&dev_attr_tag_size.attr,

	&dev_attr_protection_interval_bytes.attr,

	&dev_attr_read_verify.attr,

	&dev_attr_write_generate.attr,

	&dev_attr_device_is_integrity_capable.attr,

	NULL

};



static const struct kobj_type integrity_ktype = {

	.default_groups = integrity_groups,

	.sysfs_ops	= &integrity_ops,

const struct attribute_group blk_integrity_attr_group = {

	.name = "integrity",

	.attrs = integrity_attrs,

};



static blk_status_t blk_integrity_nop_fn(struct blk_integrity_iter *iter)
@@ -437,21 +402,3 @@ void blk_integrity_unregister(struct gendisk *disk) 
	memset(bi, 0, sizeof(*bi));

}

EXPORT_SYMBOL(blk_integrity_unregister);
 


int blk_integrity_add(struct gendisk *disk)

{

	int ret;



	ret = kobject_init_and_add(&disk->integrity_kobj, &integrity_ktype,

				   &disk_to_dev(disk)->kobj, "%s", "integrity");

	if (!ret)

		kobject_uevent(&disk->integrity_kobj, KOBJ_ADD);

	return ret;

}



void blk_integrity_del(struct gendisk *disk)

{

	kobject_uevent(&disk->integrity_kobj, KOBJ_REMOVE);

	kobject_del(&disk->integrity_kobj);

	kobject_put(&disk->integrity_kobj);

}