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.

Merge tag 'block-6.14-20250131' of git://git.kernel.dk/linux

Pull more block updates from Jens Axboe:

- MD pull request via Song:
- Fix a md-cluster regression introduced

- More sysfs race fixes

- Mark anything inside queue freezing as not being able to do IO for
memory allocations

- Fix for a regression introduced in loop in this merge window

- Fix for a regression in queue mapping setups introduced in this merge
window

- Fix for the block dio fops attempting an iov_iter revert upton
getting -EIOCBQUEUED on the read side. This one is going to stable as
well

* tag 'block-6.14-20250131' of git://git.kernel.dk/linux:
block: force noio scope in blk_mq_freeze_queue
block: fix nr_hw_queue update racing with disk addition/removal
block: get rid of request queue ->sysfs_dir_lock
loop: don't clear LO_FLAGS_PARTSCAN on LOOP_SET_STATUS{,64}
md/md-bitmap: Synchronize bitmap_get_stats() with bitmap lifetime
blk-mq: create correct map for fallback case
block: don't revert iter for -EIOCBQUEUED

Linus Torvalds 9755ffd9 c82da38b

+164 -130
+6 -4
block/blk-cgroup.c
··· 1546 1546 struct request_queue *q = disk->queue; 1547 1547 struct blkg_policy_data *pd_prealloc = NULL; 1548 1548 struct blkcg_gq *blkg, *pinned_blkg = NULL; 1549 + unsigned int memflags; 1549 1550 int ret; 1550 1551 1551 1552 if (blkcg_policy_enabled(q, pol)) ··· 1561 1560 return -EINVAL; 1562 1561 1563 1562 if (queue_is_mq(q)) 1564 - blk_mq_freeze_queue(q); 1563 + memflags = blk_mq_freeze_queue(q); 1565 1564 retry: 1566 1565 spin_lock_irq(&q->queue_lock); 1567 1566 ··· 1625 1624 spin_unlock_irq(&q->queue_lock); 1626 1625 out: 1627 1626 if (queue_is_mq(q)) 1628 - blk_mq_unfreeze_queue(q); 1627 + blk_mq_unfreeze_queue(q, memflags); 1629 1628 if (pinned_blkg) 1630 1629 blkg_put(pinned_blkg); 1631 1630 if (pd_prealloc) ··· 1669 1668 { 1670 1669 struct request_queue *q = disk->queue; 1671 1670 struct blkcg_gq *blkg; 1671 + unsigned int memflags; 1672 1672 1673 1673 if (!blkcg_policy_enabled(q, pol)) 1674 1674 return; 1675 1675 1676 1676 if (queue_is_mq(q)) 1677 - blk_mq_freeze_queue(q); 1677 + memflags = blk_mq_freeze_queue(q); 1678 1678 1679 1679 mutex_lock(&q->blkcg_mutex); 1680 1680 spin_lock_irq(&q->queue_lock); ··· 1699 1697 mutex_unlock(&q->blkcg_mutex); 1700 1698 1701 1699 if (queue_is_mq(q)) 1702 - blk_mq_unfreeze_queue(q); 1700 + blk_mq_unfreeze_queue(q, memflags); 1703 1701 } 1704 1702 EXPORT_SYMBOL_GPL(blkcg_deactivate_policy); 1705 1703
-1
block/blk-core.c
··· 430 430 refcount_set(&q->refs, 1); 431 431 mutex_init(&q->debugfs_mutex); 432 432 mutex_init(&q->sysfs_lock); 433 - mutex_init(&q->sysfs_dir_lock); 434 433 mutex_init(&q->limits_lock); 435 434 mutex_init(&q->rq_qos_mutex); 436 435 spin_lock_init(&q->queue_lock);
-4
block/blk-ia-ranges.c
··· 111 111 struct request_queue *q = disk->queue; 112 112 int i, ret; 113 113 114 - lockdep_assert_held(&q->sysfs_dir_lock); 115 114 lockdep_assert_held(&q->sysfs_lock); 116 115 117 116 if (!iars) ··· 154 155 struct blk_independent_access_ranges *iars = disk->ia_ranges; 155 156 int i; 156 157 157 - lockdep_assert_held(&q->sysfs_dir_lock); 158 158 lockdep_assert_held(&q->sysfs_lock); 159 159 160 160 if (!iars) ··· 287 289 { 288 290 struct request_queue *q = disk->queue; 289 291 290 - mutex_lock(&q->sysfs_dir_lock); 291 292 mutex_lock(&q->sysfs_lock); 292 293 if (iars && !disk_check_ia_ranges(disk, iars)) { 293 294 kfree(iars); ··· 310 313 disk_register_independent_access_ranges(disk); 311 314 unlock: 312 315 mutex_unlock(&q->sysfs_lock); 313 - mutex_unlock(&q->sysfs_dir_lock); 314 316 } 315 317 EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges);
+8 -6
block/blk-iocost.c
··· 3224 3224 u32 qos[NR_QOS_PARAMS]; 3225 3225 bool enable, user; 3226 3226 char *body, *p; 3227 + unsigned int memflags; 3227 3228 int ret; 3228 3229 3229 3230 blkg_conf_init(&ctx, input); ··· 3248 3247 ioc = q_to_ioc(disk->queue); 3249 3248 } 3250 3249 3251 - blk_mq_freeze_queue(disk->queue); 3250 + memflags = blk_mq_freeze_queue(disk->queue); 3252 3251 blk_mq_quiesce_queue(disk->queue); 3253 3252 3254 3253 spin_lock_irq(&ioc->lock); ··· 3348 3347 wbt_enable_default(disk); 3349 3348 3350 3349 blk_mq_unquiesce_queue(disk->queue); 3351 - blk_mq_unfreeze_queue(disk->queue); 3350 + blk_mq_unfreeze_queue(disk->queue, memflags); 3352 3351 3353 3352 blkg_conf_exit(&ctx); 3354 3353 return nbytes; ··· 3356 3355 spin_unlock_irq(&ioc->lock); 3357 3356 3358 3357 blk_mq_unquiesce_queue(disk->queue); 3359 - blk_mq_unfreeze_queue(disk->queue); 3358 + blk_mq_unfreeze_queue(disk->queue, memflags); 3360 3359 3361 3360 ret = -EINVAL; 3362 3361 err: ··· 3415 3414 { 3416 3415 struct blkg_conf_ctx ctx; 3417 3416 struct request_queue *q; 3417 + unsigned int memflags; 3418 3418 struct ioc *ioc; 3419 3419 u64 u[NR_I_LCOEFS]; 3420 3420 bool user; ··· 3443 3441 ioc = q_to_ioc(q); 3444 3442 } 3445 3443 3446 - blk_mq_freeze_queue(q); 3444 + memflags = blk_mq_freeze_queue(q); 3447 3445 blk_mq_quiesce_queue(q); 3448 3446 3449 3447 spin_lock_irq(&ioc->lock); ··· 3495 3493 spin_unlock_irq(&ioc->lock); 3496 3494 3497 3495 blk_mq_unquiesce_queue(q); 3498 - blk_mq_unfreeze_queue(q); 3496 + blk_mq_unfreeze_queue(q, memflags); 3499 3497 3500 3498 blkg_conf_exit(&ctx); 3501 3499 return nbytes; ··· 3504 3502 spin_unlock_irq(&ioc->lock); 3505 3503 3506 3504 blk_mq_unquiesce_queue(q); 3507 - blk_mq_unfreeze_queue(q); 3505 + blk_mq_unfreeze_queue(q, memflags); 3508 3506 3509 3507 ret = -EINVAL; 3510 3508 err:
+4 -2
block/blk-iolatency.c
··· 749 749 */ 750 750 enabled = atomic_read(&blkiolat->enable_cnt); 751 751 if (enabled != blkiolat->enabled) { 752 - blk_mq_freeze_queue(blkiolat->rqos.disk->queue); 752 + unsigned int memflags; 753 + 754 + memflags = blk_mq_freeze_queue(blkiolat->rqos.disk->queue); 753 755 blkiolat->enabled = enabled; 754 - blk_mq_unfreeze_queue(blkiolat->rqos.disk->queue); 756 + blk_mq_unfreeze_queue(blkiolat->rqos.disk->queue, memflags); 755 757 } 756 758 } 757 759
+1 -2
block/blk-mq-cpumap.c
··· 87 87 return; 88 88 89 89 fallback: 90 - WARN_ON_ONCE(qmap->nr_queues > 1); 91 - blk_mq_clear_mq_map(qmap); 90 + blk_mq_map_queues(qmap); 92 91 } 93 92 EXPORT_SYMBOL_GPL(blk_mq_map_hw_queues);
+14 -26
block/blk-mq-sysfs.c
··· 223 223 unsigned long i, j; 224 224 int ret; 225 225 226 - lockdep_assert_held(&q->sysfs_dir_lock); 227 - 228 226 ret = kobject_add(q->mq_kobj, &disk_to_dev(disk)->kobj, "mq"); 229 227 if (ret < 0) 230 - goto out; 228 + return ret; 231 229 232 230 kobject_uevent(q->mq_kobj, KOBJ_ADD); 233 231 232 + mutex_lock(&q->tag_set->tag_list_lock); 234 233 queue_for_each_hw_ctx(q, hctx, i) { 235 234 ret = blk_mq_register_hctx(hctx); 236 235 if (ret) 237 - goto unreg; 236 + goto out_unreg; 238 237 } 238 + mutex_unlock(&q->tag_set->tag_list_lock); 239 + return 0; 239 240 240 - q->mq_sysfs_init_done = true; 241 - 242 - out: 243 - return ret; 244 - 245 - unreg: 241 + out_unreg: 246 242 queue_for_each_hw_ctx(q, hctx, j) { 247 243 if (j < i) 248 244 blk_mq_unregister_hctx(hctx); 249 245 } 246 + mutex_unlock(&q->tag_set->tag_list_lock); 250 247 251 248 kobject_uevent(q->mq_kobj, KOBJ_REMOVE); 252 249 kobject_del(q->mq_kobj); ··· 256 259 struct blk_mq_hw_ctx *hctx; 257 260 unsigned long i; 258 261 259 - lockdep_assert_held(&q->sysfs_dir_lock); 260 - 262 + mutex_lock(&q->tag_set->tag_list_lock); 261 263 queue_for_each_hw_ctx(q, hctx, i) 262 264 blk_mq_unregister_hctx(hctx); 265 + mutex_unlock(&q->tag_set->tag_list_lock); 263 266 264 267 kobject_uevent(q->mq_kobj, KOBJ_REMOVE); 265 268 kobject_del(q->mq_kobj); 266 - 267 - q->mq_sysfs_init_done = false; 268 269 } 269 270 270 271 void blk_mq_sysfs_unregister_hctxs(struct request_queue *q) ··· 270 275 struct blk_mq_hw_ctx *hctx; 271 276 unsigned long i; 272 277 273 - mutex_lock(&q->sysfs_dir_lock); 274 - if (!q->mq_sysfs_init_done) 275 - goto unlock; 278 + if (!blk_queue_registered(q)) 279 + return; 276 280 277 281 queue_for_each_hw_ctx(q, hctx, i) 278 282 blk_mq_unregister_hctx(hctx); 279 - 280 - unlock: 281 - mutex_unlock(&q->sysfs_dir_lock); 282 283 } 283 284 284 285 int blk_mq_sysfs_register_hctxs(struct request_queue *q) ··· 283 292 unsigned long i; 284 293 int ret = 0; 285 294 286 - mutex_lock(&q->sysfs_dir_lock); 287 - if (!q->mq_sysfs_init_done) 288 - goto unlock; 295 + if (!blk_queue_registered(q)) 296 + goto out; 289 297 290 298 queue_for_each_hw_ctx(q, hctx, i) { 291 299 ret = blk_mq_register_hctx(hctx); ··· 292 302 break; 293 303 } 294 304 295 - unlock: 296 - mutex_unlock(&q->sysfs_dir_lock); 297 - 305 + out: 298 306 return ret; 299 307 }
+13 -8
block/blk-mq.c
··· 210 210 } 211 211 EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait_timeout); 212 212 213 - void blk_mq_freeze_queue(struct request_queue *q) 213 + void blk_mq_freeze_queue_nomemsave(struct request_queue *q) 214 214 { 215 215 blk_freeze_queue_start(q); 216 216 blk_mq_freeze_queue_wait(q); 217 217 } 218 - EXPORT_SYMBOL_GPL(blk_mq_freeze_queue); 218 + EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_nomemsave); 219 219 220 220 bool __blk_mq_unfreeze_queue(struct request_queue *q, bool force_atomic) 221 221 { ··· 236 236 return unfreeze; 237 237 } 238 238 239 - void blk_mq_unfreeze_queue(struct request_queue *q) 239 + void blk_mq_unfreeze_queue_nomemrestore(struct request_queue *q) 240 240 { 241 241 if (__blk_mq_unfreeze_queue(q, false)) 242 242 blk_unfreeze_release_lock(q); 243 243 } 244 - EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue); 244 + EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue_nomemrestore); 245 245 246 246 /* 247 247 * non_owner variant of blk_freeze_queue_start ··· 4223 4223 bool shared) 4224 4224 { 4225 4225 struct request_queue *q; 4226 + unsigned int memflags; 4226 4227 4227 4228 lockdep_assert_held(&set->tag_list_lock); 4228 4229 4229 4230 list_for_each_entry(q, &set->tag_list, tag_set_list) { 4230 - blk_mq_freeze_queue(q); 4231 + memflags = blk_mq_freeze_queue(q); 4231 4232 queue_set_hctx_shared(q, shared); 4232 - blk_mq_unfreeze_queue(q); 4233 + blk_mq_unfreeze_queue(q, memflags); 4233 4234 } 4234 4235 } 4235 4236 ··· 4993 4992 struct request_queue *q; 4994 4993 LIST_HEAD(head); 4995 4994 int prev_nr_hw_queues = set->nr_hw_queues; 4995 + unsigned int memflags; 4996 4996 int i; 4997 4997 4998 4998 lockdep_assert_held(&set->tag_list_lock); ··· 5005 5003 if (set->nr_maps == 1 && nr_hw_queues == set->nr_hw_queues) 5006 5004 return; 5007 5005 5006 + memflags = memalloc_noio_save(); 5008 5007 list_for_each_entry(q, &set->tag_list, tag_set_list) 5009 - blk_mq_freeze_queue(q); 5008 + blk_mq_freeze_queue_nomemsave(q); 5009 + 5010 5010 /* 5011 5011 * Switch IO scheduler to 'none', cleaning up the data associated 5012 5012 * with the previous scheduler. We will switch back once we are done ··· 5056 5052 blk_mq_elv_switch_back(&head, q); 5057 5053 5058 5054 list_for_each_entry(q, &set->tag_list, tag_set_list) 5059 - blk_mq_unfreeze_queue(q); 5055 + blk_mq_unfreeze_queue_nomemrestore(q); 5056 + memalloc_noio_restore(memflags); 5060 5057 5061 5058 /* Free the excess tags when nr_hw_queues shrink. */ 5062 5059 for (i = set->nr_hw_queues; i < prev_nr_hw_queues; i++)
+1 -1
block/blk-pm.c
··· 89 89 if (percpu_ref_is_zero(&q->q_usage_counter)) 90 90 ret = 0; 91 91 /* Switch q_usage_counter back to per-cpu mode. */ 92 - blk_mq_unfreeze_queue(q); 92 + blk_mq_unfreeze_queue_nomemrestore(q); 93 93 94 94 if (ret < 0) { 95 95 spin_lock_irq(&q->queue_lock);
+7 -5
block/blk-rq-qos.c
··· 299 299 const struct rq_qos_ops *ops) 300 300 { 301 301 struct request_queue *q = disk->queue; 302 + unsigned int memflags; 302 303 303 304 lockdep_assert_held(&q->rq_qos_mutex); 304 305 ··· 311 310 * No IO can be in-flight when adding rqos, so freeze queue, which 312 311 * is fine since we only support rq_qos for blk-mq queue. 313 312 */ 314 - blk_mq_freeze_queue(q); 313 + memflags = blk_mq_freeze_queue(q); 315 314 316 315 if (rq_qos_id(q, rqos->id)) 317 316 goto ebusy; 318 317 rqos->next = q->rq_qos; 319 318 q->rq_qos = rqos; 320 319 321 - blk_mq_unfreeze_queue(q); 320 + blk_mq_unfreeze_queue(q, memflags); 322 321 323 322 if (rqos->ops->debugfs_attrs) { 324 323 mutex_lock(&q->debugfs_mutex); ··· 328 327 329 328 return 0; 330 329 ebusy: 331 - blk_mq_unfreeze_queue(q); 330 + blk_mq_unfreeze_queue(q, memflags); 332 331 return -EBUSY; 333 332 } 334 333 ··· 336 335 { 337 336 struct request_queue *q = rqos->disk->queue; 338 337 struct rq_qos **cur; 338 + unsigned int memflags; 339 339 340 340 lockdep_assert_held(&q->rq_qos_mutex); 341 341 342 - blk_mq_freeze_queue(q); 342 + memflags = blk_mq_freeze_queue(q); 343 343 for (cur = &q->rq_qos; *cur; cur = &(*cur)->next) { 344 344 if (*cur == rqos) { 345 345 *cur = rqos->next; 346 346 break; 347 347 } 348 348 } 349 - blk_mq_unfreeze_queue(q); 349 + blk_mq_unfreeze_queue(q, memflags); 350 350 351 351 mutex_lock(&q->debugfs_mutex); 352 352 blk_mq_debugfs_unregister_rqos(rqos);
+3 -2
block/blk-settings.c
··· 461 461 int queue_limits_commit_update_frozen(struct request_queue *q, 462 462 struct queue_limits *lim) 463 463 { 464 + unsigned int memflags; 464 465 int ret; 465 466 466 - blk_mq_freeze_queue(q); 467 + memflags = blk_mq_freeze_queue(q); 467 468 ret = queue_limits_commit_update(q, lim); 468 - blk_mq_unfreeze_queue(q); 469 + blk_mq_unfreeze_queue(q, memflags); 469 470 470 471 return ret; 471 472 }
+3 -10
block/blk-sysfs.c
··· 681 681 struct queue_sysfs_entry *entry = to_queue(attr); 682 682 struct gendisk *disk = container_of(kobj, struct gendisk, queue_kobj); 683 683 struct request_queue *q = disk->queue; 684 - unsigned int noio_flag; 684 + unsigned int memflags; 685 685 ssize_t res; 686 686 687 687 if (!entry->store_limit && !entry->store) ··· 711 711 } 712 712 713 713 mutex_lock(&q->sysfs_lock); 714 - blk_mq_freeze_queue(q); 715 - noio_flag = memalloc_noio_save(); 714 + memflags = blk_mq_freeze_queue(q); 716 715 res = entry->store(disk, page, length); 717 - memalloc_noio_restore(noio_flag); 718 - blk_mq_unfreeze_queue(q); 716 + blk_mq_unfreeze_queue(q, memflags); 719 717 mutex_unlock(&q->sysfs_lock); 720 718 return res; 721 719 } ··· 762 764 struct request_queue *q = disk->queue; 763 765 int ret; 764 766 765 - mutex_lock(&q->sysfs_dir_lock); 766 767 kobject_init(&disk->queue_kobj, &blk_queue_ktype); 767 768 ret = kobject_add(&disk->queue_kobj, &disk_to_dev(disk)->kobj, "queue"); 768 769 if (ret < 0) ··· 802 805 if (q->elevator) 803 806 kobject_uevent(&q->elevator->kobj, KOBJ_ADD); 804 807 mutex_unlock(&q->sysfs_lock); 805 - mutex_unlock(&q->sysfs_dir_lock); 806 808 807 809 /* 808 810 * SCSI probing may synchronously create and destroy a lot of ··· 826 830 mutex_unlock(&q->sysfs_lock); 827 831 out_put_queue_kobj: 828 832 kobject_put(&disk->queue_kobj); 829 - mutex_unlock(&q->sysfs_dir_lock); 830 833 return ret; 831 834 } 832 835 ··· 856 861 blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q); 857 862 mutex_unlock(&q->sysfs_lock); 858 863 859 - mutex_lock(&q->sysfs_dir_lock); 860 864 /* 861 865 * Remove the sysfs attributes before unregistering the queue data 862 866 * structures that can be modified through sysfs. ··· 872 878 /* Now that we've deleted all child objects, we can delete the queue. */ 873 879 kobject_uevent(&disk->queue_kobj, KOBJ_REMOVE); 874 880 kobject_del(&disk->queue_kobj); 875 - mutex_unlock(&q->sysfs_dir_lock); 876 881 877 882 blk_debugfs_remove(disk); 878 883 }
+3 -2
block/blk-throttle.c
··· 1202 1202 { 1203 1203 struct request_queue *q = disk->queue; 1204 1204 struct throtl_data *td; 1205 + unsigned int memflags; 1205 1206 int ret; 1206 1207 1207 1208 td = kzalloc_node(sizeof(*td), GFP_KERNEL, q->node); ··· 1216 1215 * Freeze queue before activating policy, to synchronize with IO path, 1217 1216 * which is protected by 'q_usage_counter'. 1218 1217 */ 1219 - blk_mq_freeze_queue(disk->queue); 1218 + memflags = blk_mq_freeze_queue(disk->queue); 1220 1219 blk_mq_quiesce_queue(disk->queue); 1221 1220 1222 1221 q->td = td; ··· 1240 1239 1241 1240 out: 1242 1241 blk_mq_unquiesce_queue(disk->queue); 1243 - blk_mq_unfreeze_queue(disk->queue); 1242 + blk_mq_unfreeze_queue(disk->queue, memflags); 1244 1243 1245 1244 return ret; 1246 1245 }
+3 -2
block/blk-zoned.c
··· 1717 1717 else 1718 1718 pr_warn("%s: failed to revalidate zones\n", disk->disk_name); 1719 1719 if (ret) { 1720 - blk_mq_freeze_queue(q); 1720 + unsigned int memflags = blk_mq_freeze_queue(q); 1721 + 1721 1722 disk_free_zone_resources(disk); 1722 - blk_mq_unfreeze_queue(q); 1723 + blk_mq_unfreeze_queue(q, memflags); 1723 1724 } 1724 1725 1725 1726 return ret;
+10 -6
block/elevator.c
··· 570 570 void elevator_init_mq(struct request_queue *q) 571 571 { 572 572 struct elevator_type *e; 573 + unsigned int memflags; 573 574 int err; 574 575 575 576 WARN_ON_ONCE(blk_queue_registered(q)); ··· 591 590 * 592 591 * Disk isn't added yet, so verifying queue lock only manually. 593 592 */ 594 - blk_mq_freeze_queue(q); 593 + memflags = blk_mq_freeze_queue(q); 595 594 596 595 blk_mq_cancel_work_sync(q); 597 596 598 597 err = blk_mq_init_sched(q, e); 599 598 600 - blk_mq_unfreeze_queue(q); 599 + blk_mq_unfreeze_queue(q, memflags); 601 600 602 601 if (err) { 603 602 pr_warn("\"%s\" elevator initialization failed, " ··· 615 614 */ 616 615 int elevator_switch(struct request_queue *q, struct elevator_type *new_e) 617 616 { 617 + unsigned int memflags; 618 618 int ret; 619 619 620 620 lockdep_assert_held(&q->sysfs_lock); 621 621 622 - blk_mq_freeze_queue(q); 622 + memflags = blk_mq_freeze_queue(q); 623 623 blk_mq_quiesce_queue(q); 624 624 625 625 if (q->elevator) { ··· 641 639 642 640 out_unfreeze: 643 641 blk_mq_unquiesce_queue(q); 644 - blk_mq_unfreeze_queue(q); 642 + blk_mq_unfreeze_queue(q, memflags); 645 643 646 644 if (ret) { 647 645 pr_warn("elv: switch to \"%s\" failed, falling back to \"none\"\n", ··· 653 651 654 652 void elevator_disable(struct request_queue *q) 655 653 { 654 + unsigned int memflags; 655 + 656 656 lockdep_assert_held(&q->sysfs_lock); 657 657 658 - blk_mq_freeze_queue(q); 658 + memflags = blk_mq_freeze_queue(q); 659 659 blk_mq_quiesce_queue(q); 660 660 661 661 elv_unregister_queue(q); ··· 668 664 blk_add_trace_msg(q, "elv switch: none"); 669 665 670 666 blk_mq_unquiesce_queue(q); 671 - blk_mq_unfreeze_queue(q); 667 + blk_mq_unfreeze_queue(q, memflags); 672 668 } 673 669 674 670 /*
+3 -2
block/fops.c
··· 783 783 file_accessed(iocb->ki_filp); 784 784 785 785 ret = blkdev_direct_IO(iocb, to); 786 - if (ret >= 0) { 786 + if (ret > 0) { 787 787 iocb->ki_pos += ret; 788 788 count -= ret; 789 789 } 790 - iov_iter_revert(to, count - iov_iter_count(to)); 790 + if (ret != -EIOCBQUEUED) 791 + iov_iter_revert(to, count - iov_iter_count(to)); 791 792 if (ret < 0 || !count) 792 793 goto reexpand; 793 794 }
+3 -2
drivers/block/aoe/aoedev.c
··· 226 226 /* fast fail all pending I/O */ 227 227 if (d->blkq) { 228 228 /* UP is cleared, freeze+quiesce to insure all are errored */ 229 - blk_mq_freeze_queue(d->blkq); 229 + unsigned int memflags = blk_mq_freeze_queue(d->blkq); 230 + 230 231 blk_mq_quiesce_queue(d->blkq); 231 232 blk_mq_unquiesce_queue(d->blkq); 232 - blk_mq_unfreeze_queue(d->blkq); 233 + blk_mq_unfreeze_queue(d->blkq, memflags); 233 234 } 234 235 235 236 if (d->gd)
+3 -2
drivers/block/ataflop.c
··· 746 746 unsigned char *p; 747 747 int sect, nsect; 748 748 unsigned long flags; 749 + unsigned int memflags; 749 750 int ret; 750 751 751 752 if (type) { ··· 759 758 } 760 759 761 760 q = unit[drive].disk[type]->queue; 762 - blk_mq_freeze_queue(q); 761 + memflags = blk_mq_freeze_queue(q); 763 762 blk_mq_quiesce_queue(q); 764 763 765 764 local_irq_save(flags); ··· 818 817 ret = FormatError ? -EIO : 0; 819 818 out: 820 819 blk_mq_unquiesce_queue(q); 821 - blk_mq_unfreeze_queue(q); 820 + blk_mq_unfreeze_queue(q, memflags); 822 821 return ret; 823 822 } 824 823
+13 -10
drivers/block/loop.c
··· 586 586 { 587 587 struct file *file = fget(arg); 588 588 struct file *old_file; 589 + unsigned int memflags; 589 590 int error; 590 591 bool partscan; 591 592 bool is_loop; ··· 624 623 625 624 /* and ... switch */ 626 625 disk_force_media_change(lo->lo_disk); 627 - blk_mq_freeze_queue(lo->lo_queue); 626 + memflags = blk_mq_freeze_queue(lo->lo_queue); 628 627 mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask); 629 628 lo->lo_backing_file = file; 630 629 lo->old_gfp_mask = mapping_gfp_mask(file->f_mapping); 631 630 mapping_set_gfp_mask(file->f_mapping, 632 631 lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS)); 633 632 loop_update_dio(lo); 634 - blk_mq_unfreeze_queue(lo->lo_queue); 633 + blk_mq_unfreeze_queue(lo->lo_queue, memflags); 635 634 partscan = lo->lo_flags & LO_FLAGS_PARTSCAN; 636 635 loop_global_unlock(lo, is_loop); 637 636 ··· 1256 1255 int err; 1257 1256 bool partscan = false; 1258 1257 bool size_changed = false; 1258 + unsigned int memflags; 1259 1259 1260 1260 err = mutex_lock_killable(&lo->lo_mutex); 1261 1261 if (err) ··· 1274 1272 } 1275 1273 1276 1274 /* I/O needs to be drained before changing lo_offset or lo_sizelimit */ 1277 - blk_mq_freeze_queue(lo->lo_queue); 1275 + memflags = blk_mq_freeze_queue(lo->lo_queue); 1278 1276 1279 1277 err = loop_set_status_from_info(lo, info); 1280 1278 if (err) ··· 1283 1281 partscan = !(lo->lo_flags & LO_FLAGS_PARTSCAN) && 1284 1282 (info->lo_flags & LO_FLAGS_PARTSCAN); 1285 1283 1286 - lo->lo_flags &= ~(LOOP_SET_STATUS_SETTABLE_FLAGS | 1287 - LOOP_SET_STATUS_CLEARABLE_FLAGS); 1284 + lo->lo_flags &= ~LOOP_SET_STATUS_CLEARABLE_FLAGS; 1288 1285 lo->lo_flags |= (info->lo_flags & LOOP_SET_STATUS_SETTABLE_FLAGS); 1289 1286 1290 1287 if (size_changed) { ··· 1296 1295 loop_update_dio(lo); 1297 1296 1298 1297 out_unfreeze: 1299 - blk_mq_unfreeze_queue(lo->lo_queue); 1298 + blk_mq_unfreeze_queue(lo->lo_queue, memflags); 1300 1299 if (partscan) 1301 1300 clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state); 1302 1301 out_unlock: ··· 1448 1447 static int loop_set_dio(struct loop_device *lo, unsigned long arg) 1449 1448 { 1450 1449 bool use_dio = !!arg; 1450 + unsigned int memflags; 1451 1451 1452 1452 if (lo->lo_state != Lo_bound) 1453 1453 return -ENXIO; ··· 1462 1460 vfs_fsync(lo->lo_backing_file, 0); 1463 1461 } 1464 1462 1465 - blk_mq_freeze_queue(lo->lo_queue); 1463 + memflags = blk_mq_freeze_queue(lo->lo_queue); 1466 1464 if (use_dio) 1467 1465 lo->lo_flags |= LO_FLAGS_DIRECT_IO; 1468 1466 else 1469 1467 lo->lo_flags &= ~LO_FLAGS_DIRECT_IO; 1470 - blk_mq_unfreeze_queue(lo->lo_queue); 1468 + blk_mq_unfreeze_queue(lo->lo_queue, memflags); 1471 1469 return 0; 1472 1470 } 1473 1471 1474 1472 static int loop_set_block_size(struct loop_device *lo, unsigned long arg) 1475 1473 { 1476 1474 struct queue_limits lim; 1475 + unsigned int memflags; 1477 1476 int err = 0; 1478 1477 1479 1478 if (lo->lo_state != Lo_bound) ··· 1489 1486 lim = queue_limits_start_update(lo->lo_queue); 1490 1487 loop_update_limits(lo, &lim, arg); 1491 1488 1492 - blk_mq_freeze_queue(lo->lo_queue); 1489 + memflags = blk_mq_freeze_queue(lo->lo_queue); 1493 1490 err = queue_limits_commit_update(lo->lo_queue, &lim); 1494 1491 loop_update_dio(lo); 1495 - blk_mq_unfreeze_queue(lo->lo_queue); 1492 + blk_mq_unfreeze_queue(lo->lo_queue, memflags); 1496 1493 1497 1494 return err; 1498 1495 }
+4 -3
drivers/block/nbd.c
··· 1234 1234 struct socket *sock; 1235 1235 struct nbd_sock **socks; 1236 1236 struct nbd_sock *nsock; 1237 + unsigned int memflags; 1237 1238 int err; 1238 1239 1239 1240 /* Arg will be cast to int, check it to avoid overflow */ ··· 1248 1247 * We need to make sure we don't get any errant requests while we're 1249 1248 * reallocating the ->socks array. 1250 1249 */ 1251 - blk_mq_freeze_queue(nbd->disk->queue); 1250 + memflags = blk_mq_freeze_queue(nbd->disk->queue); 1252 1251 1253 1252 if (!netlink && !nbd->task_setup && 1254 1253 !test_bit(NBD_RT_BOUND, &config->runtime_flags)) ··· 1289 1288 INIT_WORK(&nsock->work, nbd_pending_cmd_work); 1290 1289 socks[config->num_connections++] = nsock; 1291 1290 atomic_inc(&config->live_connections); 1292 - blk_mq_unfreeze_queue(nbd->disk->queue); 1291 + blk_mq_unfreeze_queue(nbd->disk->queue, memflags); 1293 1292 1294 1293 return 0; 1295 1294 1296 1295 put_socket: 1297 - blk_mq_unfreeze_queue(nbd->disk->queue); 1296 + blk_mq_unfreeze_queue(nbd->disk->queue, memflags); 1298 1297 sockfd_put(sock); 1299 1298 return err; 1300 1299 }
+3 -2
drivers/block/rbd.c
··· 7281 7281 * Prevent new IO from being queued and wait for existing 7282 7282 * IO to complete/fail. 7283 7283 */ 7284 - blk_mq_freeze_queue(rbd_dev->disk->queue); 7284 + unsigned int memflags = blk_mq_freeze_queue(rbd_dev->disk->queue); 7285 + 7285 7286 blk_mark_disk_dead(rbd_dev->disk); 7286 - blk_mq_unfreeze_queue(rbd_dev->disk->queue); 7287 + blk_mq_unfreeze_queue(rbd_dev->disk->queue, memflags); 7287 7288 } 7288 7289 7289 7290 del_gendisk(rbd_dev->disk);
+3 -2
drivers/block/sunvdc.c
··· 1113 1113 static void vdc_queue_drain(struct vdc_port *port) 1114 1114 { 1115 1115 struct request_queue *q = port->disk->queue; 1116 + unsigned int memflags; 1116 1117 1117 1118 /* 1118 1119 * Mark the queue as draining, then freeze/quiesce to ensure ··· 1122 1121 port->drain = 1; 1123 1122 spin_unlock_irq(&port->vio.lock); 1124 1123 1125 - blk_mq_freeze_queue(q); 1124 + memflags = blk_mq_freeze_queue(q); 1126 1125 blk_mq_quiesce_queue(q); 1127 1126 1128 1127 spin_lock_irq(&port->vio.lock); 1129 1128 port->drain = 0; 1130 - blk_mq_unquiesce_queue(q); 1129 + blk_mq_unquiesce_queue(q, memflags); 1131 1130 blk_mq_unfreeze_queue(q); 1132 1131 } 1133 1132
+3 -2
drivers/block/swim3.c
··· 840 840 static void release_drive(struct floppy_state *fs) 841 841 { 842 842 struct request_queue *q = disks[fs->index]->queue; 843 + unsigned int memflags; 843 844 unsigned long flags; 844 845 845 846 swim3_dbg("%s", "-> release drive\n"); ··· 849 848 fs->state = idle; 850 849 spin_unlock_irqrestore(&swim3_lock, flags); 851 850 852 - blk_mq_freeze_queue(q); 851 + memflags = blk_mq_freeze_queue(q); 853 852 blk_mq_quiesce_queue(q); 854 853 blk_mq_unquiesce_queue(q); 855 - blk_mq_unfreeze_queue(q); 854 + blk_mq_unfreeze_queue(q, memflags); 856 855 } 857 856 858 857 static int fd_eject(struct floppy_state *fs)
+3 -2
drivers/block/virtio_blk.c
··· 1583 1583 { 1584 1584 struct virtio_blk *vblk = vdev->priv; 1585 1585 struct request_queue *q = vblk->disk->queue; 1586 + unsigned int memflags; 1586 1587 1587 1588 /* Ensure no requests in virtqueues before deleting vqs. */ 1588 - blk_mq_freeze_queue(q); 1589 + memflags = blk_mq_freeze_queue(q); 1589 1590 blk_mq_quiesce_queue_nowait(q); 1590 - blk_mq_unfreeze_queue(q); 1591 + blk_mq_unfreeze_queue(q, memflags); 1591 1592 1592 1593 /* Ensure we don't receive any more interrupts */ 1593 1594 virtio_reset_device(vdev);
+4 -1
drivers/md/md-bitmap.c
··· 2355 2355 2356 2356 if (!bitmap) 2357 2357 return -ENOENT; 2358 - 2358 + if (bitmap->mddev->bitmap_info.external) 2359 + return -ENOENT; 2360 + if (!bitmap->storage.sb_page) /* no superblock */ 2361 + return -EINVAL; 2359 2362 sb = kmap_local_page(bitmap->storage.sb_page); 2360 2363 stats->sync_size = le64_to_cpu(sb->sync_size); 2361 2364 kunmap_local(sb);
+5
drivers/md/md.c
··· 8376 8376 return 0; 8377 8377 8378 8378 spin_unlock(&all_mddevs_lock); 8379 + 8380 + /* prevent bitmap to be freed after checking */ 8381 + mutex_lock(&mddev->bitmap_info.mutex); 8382 + 8379 8383 spin_lock(&mddev->lock); 8380 8384 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) { 8381 8385 seq_printf(seq, "%s : ", mdname(mddev)); ··· 8455 8451 seq_printf(seq, "\n"); 8456 8452 } 8457 8453 spin_unlock(&mddev->lock); 8454 + mutex_unlock(&mddev->bitmap_info.mutex); 8458 8455 spin_lock(&all_mddevs_lock); 8459 8456 8460 8457 if (mddev == list_last_entry(&all_mddevs, struct mddev, all_mddevs))
+3 -2
drivers/mtd/mtd_blkdevs.c
··· 404 404 int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old) 405 405 { 406 406 unsigned long flags; 407 + unsigned int memflags; 407 408 408 409 lockdep_assert_held(&mtd_table_mutex); 409 410 ··· 421 420 spin_unlock_irqrestore(&old->queue_lock, flags); 422 421 423 422 /* freeze+quiesce queue to ensure all requests are flushed */ 424 - blk_mq_freeze_queue(old->rq); 423 + memflags = blk_mq_freeze_queue(old->rq); 425 424 blk_mq_quiesce_queue(old->rq); 426 425 blk_mq_unquiesce_queue(old->rq); 427 - blk_mq_unfreeze_queue(old->rq); 426 + blk_mq_unfreeze_queue(old->rq, memflags); 428 427 429 428 /* If the device is currently open, tell trans driver to close it, 430 429 then put mtd device, and don't touch it again */
+10 -7
drivers/nvme/host/core.c
··· 2132 2132 struct nvme_ns_info *info) 2133 2133 { 2134 2134 struct queue_limits lim; 2135 + unsigned int memflags; 2135 2136 int ret; 2136 2137 2137 2138 lim = queue_limits_start_update(ns->disk->queue); 2138 2139 nvme_set_ctrl_limits(ns->ctrl, &lim); 2139 2140 2140 - blk_mq_freeze_queue(ns->disk->queue); 2141 + memflags = blk_mq_freeze_queue(ns->disk->queue); 2141 2142 ret = queue_limits_commit_update(ns->disk->queue, &lim); 2142 2143 set_disk_ro(ns->disk, nvme_ns_is_readonly(ns, info)); 2143 - blk_mq_unfreeze_queue(ns->disk->queue); 2144 + blk_mq_unfreeze_queue(ns->disk->queue, memflags); 2144 2145 2145 2146 /* Hide the block-interface for these devices */ 2146 2147 if (!ret) ··· 2156 2155 struct nvme_id_ns_nvm *nvm = NULL; 2157 2156 struct nvme_zone_info zi = {}; 2158 2157 struct nvme_id_ns *id; 2158 + unsigned int memflags; 2159 2159 sector_t capacity; 2160 2160 unsigned lbaf; 2161 2161 int ret; ··· 2188 2186 2189 2187 lim = queue_limits_start_update(ns->disk->queue); 2190 2188 2191 - blk_mq_freeze_queue(ns->disk->queue); 2189 + memflags = blk_mq_freeze_queue(ns->disk->queue); 2192 2190 ns->head->lba_shift = id->lbaf[lbaf].ds; 2193 2191 ns->head->nuse = le64_to_cpu(id->nuse); 2194 2192 capacity = nvme_lba_to_sect(ns->head, le64_to_cpu(id->nsze)); ··· 2221 2219 2222 2220 ret = queue_limits_commit_update(ns->disk->queue, &lim); 2223 2221 if (ret) { 2224 - blk_mq_unfreeze_queue(ns->disk->queue); 2222 + blk_mq_unfreeze_queue(ns->disk->queue, memflags); 2225 2223 goto out; 2226 2224 } 2227 2225 ··· 2237 2235 ns->head->features |= NVME_NS_DEAC; 2238 2236 set_disk_ro(ns->disk, nvme_ns_is_readonly(ns, info)); 2239 2237 set_bit(NVME_NS_READY, &ns->flags); 2240 - blk_mq_unfreeze_queue(ns->disk->queue); 2238 + blk_mq_unfreeze_queue(ns->disk->queue, memflags); 2241 2239 2242 2240 if (blk_queue_is_zoned(ns->queue)) { 2243 2241 ret = blk_revalidate_disk_zones(ns->disk); ··· 2293 2291 if (!ret && nvme_ns_head_multipath(ns->head)) { 2294 2292 struct queue_limits *ns_lim = &ns->disk->queue->limits; 2295 2293 struct queue_limits lim; 2294 + unsigned int memflags; 2296 2295 2297 2296 lim = queue_limits_start_update(ns->head->disk->queue); 2298 - blk_mq_freeze_queue(ns->head->disk->queue); 2297 + memflags = blk_mq_freeze_queue(ns->head->disk->queue); 2299 2298 /* 2300 2299 * queue_limits mixes values that are the hardware limitations 2301 2300 * for bio splitting with what is the device configuration. ··· 2328 2325 set_disk_ro(ns->head->disk, nvme_ns_is_readonly(ns, info)); 2329 2326 nvme_mpath_revalidate_paths(ns); 2330 2327 2331 - blk_mq_unfreeze_queue(ns->head->disk->queue); 2328 + blk_mq_unfreeze_queue(ns->head->disk->queue, memflags); 2332 2329 } 2333 2330 2334 2331 return ret;
+1 -1
drivers/nvme/host/multipath.c
··· 60 60 lockdep_assert_held(&subsys->lock); 61 61 list_for_each_entry(h, &subsys->nsheads, entry) 62 62 if (h->disk) 63 - blk_mq_unfreeze_queue(h->disk->queue); 63 + blk_mq_unfreeze_queue_nomemrestore(h->disk->queue); 64 64 } 65 65 66 66 void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
+3 -2
drivers/scsi/scsi_lib.c
··· 2736 2736 scsi_device_quiesce(struct scsi_device *sdev) 2737 2737 { 2738 2738 struct request_queue *q = sdev->request_queue; 2739 + unsigned int memflags; 2739 2740 int err; 2740 2741 2741 2742 /* ··· 2751 2750 2752 2751 blk_set_pm_only(q); 2753 2752 2754 - blk_mq_freeze_queue(q); 2753 + memflags = blk_mq_freeze_queue(q); 2755 2754 /* 2756 2755 * Ensure that the effect of blk_set_pm_only() will be visible 2757 2756 * for percpu_ref_tryget() callers that occur after the queue ··· 2759 2758 * was called. See also https://lwn.net/Articles/573497/. 2760 2759 */ 2761 2760 synchronize_rcu(); 2762 - blk_mq_unfreeze_queue(q); 2761 + blk_mq_unfreeze_queue(q, memflags); 2763 2762 2764 2763 mutex_lock(&sdev->state_mutex); 2765 2764 err = scsi_device_set_state(sdev, SDEV_QUIESCE);
+3 -2
drivers/scsi/scsi_scan.c
··· 220 220 int new_shift = sbitmap_calculate_shift(depth); 221 221 bool need_alloc = !sdev->budget_map.map; 222 222 bool need_free = false; 223 + unsigned int memflags; 223 224 int ret; 224 225 struct sbitmap sb_backup; 225 226 ··· 241 240 * and here disk isn't added yet, so freezing is pretty fast 242 241 */ 243 242 if (need_free) { 244 - blk_mq_freeze_queue(sdev->request_queue); 243 + memflags = blk_mq_freeze_queue(sdev->request_queue); 245 244 sb_backup = sdev->budget_map; 246 245 } 247 246 ret = sbitmap_init_node(&sdev->budget_map, ··· 257 256 else 258 257 sbitmap_free(&sb_backup); 259 258 ret = 0; 260 - blk_mq_unfreeze_queue(sdev->request_queue); 259 + blk_mq_unfreeze_queue(sdev->request_queue, memflags); 261 260 } 262 261 return ret; 263 262 }
+5 -2
drivers/ufs/core/ufs-sysfs.c
··· 1439 1439 struct ufs_hba *hba = dev_get_drvdata(dev); 1440 1440 struct ufs_dev_info *dev_info = &hba->dev_info; 1441 1441 struct scsi_device *sdev; 1442 + unsigned int memflags; 1442 1443 unsigned int rtt; 1443 1444 int ret; 1444 1445 ··· 1459 1458 1460 1459 ufshcd_rpm_get_sync(hba); 1461 1460 1461 + memflags = memalloc_noio_save(); 1462 1462 shost_for_each_device(sdev, hba->host) 1463 - blk_mq_freeze_queue(sdev->request_queue); 1463 + blk_mq_freeze_queue_nomemsave(sdev->request_queue); 1464 1464 1465 1465 ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR, 1466 1466 QUERY_ATTR_IDN_MAX_NUM_OF_RTT, 0, 0, &rtt); 1467 1467 1468 1468 shost_for_each_device(sdev, hba->host) 1469 - blk_mq_unfreeze_queue(sdev->request_queue); 1469 + blk_mq_unfreeze_queue_nomemrestore(sdev->request_queue); 1470 + memalloc_noio_restore(memflags); 1470 1471 1471 1472 ufshcd_rpm_put_sync(hba); 1472 1473
+16 -2
include/linux/blk-mq.h
··· 900 900 void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset, 901 901 busy_tag_iter_fn *fn, void *priv); 902 902 void blk_mq_tagset_wait_completed_request(struct blk_mq_tag_set *tagset); 903 - void blk_mq_freeze_queue(struct request_queue *q); 904 - void blk_mq_unfreeze_queue(struct request_queue *q); 903 + void blk_mq_freeze_queue_nomemsave(struct request_queue *q); 904 + void blk_mq_unfreeze_queue_nomemrestore(struct request_queue *q); 905 + static inline unsigned int __must_check 906 + blk_mq_freeze_queue(struct request_queue *q) 907 + { 908 + unsigned int memflags = memalloc_noio_save(); 909 + 910 + blk_mq_freeze_queue_nomemsave(q); 911 + return memflags; 912 + } 913 + static inline void 914 + blk_mq_unfreeze_queue(struct request_queue *q, unsigned int memflags) 915 + { 916 + blk_mq_unfreeze_queue_nomemrestore(q); 917 + memalloc_noio_restore(memflags); 918 + } 905 919 void blk_freeze_queue_start(struct request_queue *q); 906 920 void blk_mq_freeze_queue_wait(struct request_queue *q); 907 921 int blk_mq_freeze_queue_wait_timeout(struct request_queue *q,
-3
include/linux/blkdev.h
··· 561 561 struct list_head flush_list; 562 562 563 563 struct mutex sysfs_lock; 564 - struct mutex sysfs_dir_lock; 565 564 struct mutex limits_lock; 566 565 567 566 /* ··· 604 605 * Serializes all debugfs metadata operations using the above dentries. 605 606 */ 606 607 struct mutex debugfs_mutex; 607 - 608 - bool mq_sysfs_init_done; 609 608 }; 610 609 611 610 /* Keep blk_queue_flag_name[] in sync with the definitions below */