tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

block: add a queue_limits_commit_update_frozen helper

Add a helper that freezes the queue, updates the queue limits and
unfreezes the queue and convert all open coded versions of that to the
new helper.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: John Garry <john.g.garry@oracle.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Nilay Shroff <nilay@linux.ibm.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Link: https://lore.kernel.org/r/20250110054726.1499538-3-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>

authored by

Christoph Hellwig and committed by
Jens Axboe aa427d7b 9c96821b

+35 -28
+1 -3
block/blk-integrity.c
··· 218 218 else 219 219 lim.integrity.flags |= flag; 220 220 221 - blk_mq_freeze_queue(q); 222 - err = queue_limits_commit_update(q, &lim); 223 - blk_mq_unfreeze_queue(q); 221 + err = queue_limits_commit_update_frozen(q, &lim); 224 222 if (err) 225 223 return err; 226 224 return count;
+24
block/blk-settings.c
··· 445 445 EXPORT_SYMBOL_GPL(queue_limits_commit_update); 446 446 447 447 /** 448 + * queue_limits_commit_update_frozen - commit an atomic update of queue limits 449 + * @q: queue to update 450 + * @lim: limits to apply 451 + * 452 + * Apply the limits in @lim that were obtained from queue_limits_start_update() 453 + * and updated with the new values by the caller to @q. Freezes the queue 454 + * before the update and unfreezes it after. 455 + * 456 + * Returns 0 if successful, else a negative error code. 457 + */ 458 + int queue_limits_commit_update_frozen(struct request_queue *q, 459 + struct queue_limits *lim) 460 + { 461 + int ret; 462 + 463 + blk_mq_freeze_queue(q); 464 + ret = queue_limits_commit_update(q, lim); 465 + blk_mq_unfreeze_queue(q); 466 + 467 + return ret; 468 + } 469 + EXPORT_SYMBOL_GPL(queue_limits_commit_update_frozen); 470 + 471 + /** 448 472 * queue_limits_set - apply queue limits to queue 449 473 * @q: queue to update 450 474 * @lim: limits to apply
+1 -6
block/blk-zoned.c
··· 1444 1444 unsigned int nr_seq_zones, nr_conv_zones; 1445 1445 unsigned int pool_size; 1446 1446 struct queue_limits lim; 1447 - int ret; 1448 1447 1449 1448 disk->nr_zones = args->nr_zones; 1450 1449 disk->zone_capacity = args->zone_capacity; ··· 1494 1495 } 1495 1496 1496 1497 commit: 1497 - blk_mq_freeze_queue(q); 1498 - ret = queue_limits_commit_update(q, &lim); 1499 - blk_mq_unfreeze_queue(q); 1500 - 1501 - return ret; 1498 + return queue_limits_commit_update_frozen(q, &lim); 1502 1499 } 1503 1500 1504 1501 static int blk_revalidate_conv_zone(struct blk_zone *zone, unsigned int idx,
+1 -3
drivers/block/virtio_blk.c
··· 1105 1105 lim.features |= BLK_FEAT_WRITE_CACHE; 1106 1106 else 1107 1107 lim.features &= ~BLK_FEAT_WRITE_CACHE; 1108 - blk_mq_freeze_queue(disk->queue); 1109 - i = queue_limits_commit_update(disk->queue, &lim); 1110 - blk_mq_unfreeze_queue(disk->queue); 1108 + i = queue_limits_commit_update_frozen(disk->queue, &lim); 1111 1109 if (i) 1112 1110 return i; 1113 1111 return count;
+5 -12
drivers/scsi/sd.c
··· 177 177 178 178 lim = queue_limits_start_update(sdkp->disk->queue); 179 179 sd_set_flush_flag(sdkp, &lim); 180 - blk_mq_freeze_queue(sdkp->disk->queue); 181 - ret = queue_limits_commit_update(sdkp->disk->queue, &lim); 182 - blk_mq_unfreeze_queue(sdkp->disk->queue); 180 + ret = queue_limits_commit_update_frozen(sdkp->disk->queue, 181 + &lim); 183 182 if (ret) 184 183 return ret; 185 184 return count; ··· 482 483 483 484 lim = queue_limits_start_update(sdkp->disk->queue); 484 485 sd_config_discard(sdkp, &lim, mode); 485 - blk_mq_freeze_queue(sdkp->disk->queue); 486 - err = queue_limits_commit_update(sdkp->disk->queue, &lim); 487 - blk_mq_unfreeze_queue(sdkp->disk->queue); 486 + err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim); 488 487 if (err) 489 488 return err; 490 489 return count; ··· 591 594 592 595 lim = queue_limits_start_update(sdkp->disk->queue); 593 596 sd_config_write_same(sdkp, &lim); 594 - blk_mq_freeze_queue(sdkp->disk->queue); 595 - err = queue_limits_commit_update(sdkp->disk->queue, &lim); 596 - blk_mq_unfreeze_queue(sdkp->disk->queue); 597 + err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim); 597 598 if (err) 598 599 return err; 599 600 return count; ··· 3798 3803 sd_config_write_same(sdkp, &lim); 3799 3804 kfree(buffer); 3800 3805 3801 - blk_mq_freeze_queue(sdkp->disk->queue); 3802 - err = queue_limits_commit_update(sdkp->disk->queue, &lim); 3803 - blk_mq_unfreeze_queue(sdkp->disk->queue); 3806 + err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim); 3804 3807 if (err) 3805 3808 return err; 3806 3809
+1 -4
drivers/scsi/sr.c
··· 797 797 798 798 lim = queue_limits_start_update(q); 799 799 lim.logical_block_size = sector_size; 800 - blk_mq_freeze_queue(q); 801 - err = queue_limits_commit_update(q, &lim); 802 - blk_mq_unfreeze_queue(q); 803 - return err; 800 + return queue_limits_commit_update_frozen(q, &lim); 804 801 } 805 802 806 803 static int get_capabilities(struct scsi_cd *cd)
+2
include/linux/blkdev.h
··· 952 952 mutex_lock(&q->limits_lock); 953 953 return q->limits; 954 954 } 955 + int queue_limits_commit_update_frozen(struct request_queue *q, 956 + struct queue_limits *lim); 955 957 int queue_limits_commit_update(struct request_queue *q, 956 958 struct queue_limits *lim); 957 959 int queue_limits_set(struct request_queue *q, struct queue_limits *lim);