Merge branch 'for-linus' of git://git.kernel.dk/linux-block

+12

block/blk-core.c

··· 3405 3405 { 3406 3406 int ret = 0; 3407 3407 3408 + if (!q->dev) 3409 + return ret; 3410 + 3408 3411 spin_lock_irq(q->queue_lock); 3409 3412 if (q->nr_pending) { 3410 3413 ret = -EBUSY; ··· 3435 3432 */ 3436 3433 void blk_post_runtime_suspend(struct request_queue *q, int err) 3437 3434 { 3435 + if (!q->dev) 3436 + return; 3437 + 3438 3438 spin_lock_irq(q->queue_lock); 3439 3439 if (!err) { 3440 3440 q->rpm_status = RPM_SUSPENDED; ··· 3462 3456 */ 3463 3457 void blk_pre_runtime_resume(struct request_queue *q) 3464 3458 { 3459 + if (!q->dev) 3460 + return; 3461 + 3465 3462 spin_lock_irq(q->queue_lock); 3466 3463 q->rpm_status = RPM_RESUMING; 3467 3464 spin_unlock_irq(q->queue_lock); ··· 3487 3478 */ 3488 3479 void blk_post_runtime_resume(struct request_queue *q, int err) 3489 3480 { 3481 + if (!q->dev) 3482 + return; 3483 + 3490 3484 spin_lock_irq(q->queue_lock); 3491 3485 if (!err) { 3492 3486 q->rpm_status = RPM_ACTIVE;

+23 -13

drivers/block/null_blk.c

··· 444 444 blk_put_request(rq); 445 445 } 446 446 447 - static int null_lnvm_submit_io(struct request_queue *q, struct nvm_rq *rqd) 447 + static int null_lnvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd) 448 448 { 449 + struct request_queue *q = dev->q; 449 450 struct request *rq; 450 451 struct bio *bio = rqd->bio; 451 452 ··· 471 470 return 0; 472 471 } 473 472 474 - static int null_lnvm_id(struct request_queue *q, struct nvm_id *id) 473 + static int null_lnvm_id(struct nvm_dev *dev, struct nvm_id *id) 475 474 { 476 475 sector_t size = gb * 1024 * 1024 * 1024ULL; 477 476 sector_t blksize; ··· 524 523 return 0; 525 524 } 526 525 527 - static void *null_lnvm_create_dma_pool(struct request_queue *q, char *name) 526 + static void *null_lnvm_create_dma_pool(struct nvm_dev *dev, char *name) 528 527 { 529 528 mempool_t *virtmem_pool; 530 529 ··· 542 541 mempool_destroy(pool); 543 542 } 544 543 545 - static void *null_lnvm_dev_dma_alloc(struct request_queue *q, void *pool, 544 + static void *null_lnvm_dev_dma_alloc(struct nvm_dev *dev, void *pool, 546 545 gfp_t mem_flags, dma_addr_t *dma_handler) 547 546 { 548 547 return mempool_alloc(pool, mem_flags); ··· 766 765 767 766 static int __init null_init(void) 768 767 { 768 + int ret = 0; 769 769 unsigned int i; 770 + struct nullb *nullb; 770 771 771 772 if (bs > PAGE_SIZE) { 772 773 pr_warn("null_blk: invalid block size\n"); ··· 810 807 0, 0, NULL); 811 808 if (!ppa_cache) { 812 809 pr_err("null_blk: unable to create ppa cache\n"); 813 - return -ENOMEM; 814 - } 815 - } 816 - 817 - for (i = 0; i < nr_devices; i++) { 818 - if (null_add_dev()) { 819 - unregister_blkdev(null_major, "nullb"); 810 + ret = -ENOMEM; 820 811 goto err_ppa; 821 812 } 822 813 } 823 814 815 + for (i = 0; i < nr_devices; i++) { 816 + ret = null_add_dev(); 817 + if (ret) 818 + goto err_dev; 819 + } 820 + 824 821 pr_info("null: module loaded\n"); 825 822 return 0; 826 - err_ppa: 823 + 824 + err_dev: 825 + while (!list_empty(&nullb_list)) { 826 + nullb = list_entry(nullb_list.next, struct nullb, list); 827 + null_del_dev(nullb); 828 + } 827 829 kmem_cache_destroy(ppa_cache); 828 - return -EINVAL; 830 + err_ppa: 831 + unregister_blkdev(null_major, "nullb"); 832 + return ret; 829 833 } 830 834 831 835 static void __exit null_exit(void)

+1

drivers/lightnvm/Kconfig

··· 18 18 19 19 config NVM_DEBUG 20 20 bool "Open-Channel SSD debugging support" 21 + default n 21 22 ---help--- 22 23 Exposes a debug management interface to create/remove targets at: 23 24

+42 -43

drivers/lightnvm/core.c

··· 74 74 void *nvm_dev_dma_alloc(struct nvm_dev *dev, gfp_t mem_flags, 75 75 dma_addr_t *dma_handler) 76 76 { 77 - return dev->ops->dev_dma_alloc(dev->q, dev->ppalist_pool, mem_flags, 77 + return dev->ops->dev_dma_alloc(dev, dev->ppalist_pool, mem_flags, 78 78 dma_handler); 79 79 } 80 80 EXPORT_SYMBOL(nvm_dev_dma_alloc); ··· 97 97 return NULL; 98 98 } 99 99 100 + struct nvmm_type *nvm_init_mgr(struct nvm_dev *dev) 101 + { 102 + struct nvmm_type *mt; 103 + int ret; 104 + 105 + lockdep_assert_held(&nvm_lock); 106 + 107 + list_for_each_entry(mt, &nvm_mgrs, list) { 108 + ret = mt->register_mgr(dev); 109 + if (ret < 0) { 110 + pr_err("nvm: media mgr failed to init (%d) on dev %s\n", 111 + ret, dev->name); 112 + return NULL; /* initialization failed */ 113 + } else if (ret > 0) 114 + return mt; 115 + } 116 + 117 + return NULL; 118 + } 119 + 100 120 int nvm_register_mgr(struct nvmm_type *mt) 101 121 { 122 + struct nvm_dev *dev; 102 123 int ret = 0; 103 124 104 125 down_write(&nvm_lock); 105 - if (nvm_find_mgr_type(mt->name)) 126 + if (nvm_find_mgr_type(mt->name)) { 106 127 ret = -EEXIST; 107 - else 128 + goto finish; 129 + } else { 108 130 list_add(&mt->list, &nvm_mgrs); 131 + } 132 + 133 + /* try to register media mgr if any device have none configured */ 134 + list_for_each_entry(dev, &nvm_devices, devices) { 135 + if (dev->mt) 136 + continue; 137 + 138 + dev->mt = nvm_init_mgr(dev); 139 + } 140 + finish: 109 141 up_write(&nvm_lock); 110 142 111 143 return ret; ··· 154 122 up_write(&nvm_lock); 155 123 } 156 124 EXPORT_SYMBOL(nvm_unregister_mgr); 157 - 158 - /* register with device with a supported manager */ 159 - static int register_mgr(struct nvm_dev *dev) 160 - { 161 - struct nvmm_type *mt; 162 - int ret = 0; 163 - 164 - list_for_each_entry(mt, &nvm_mgrs, list) { 165 - ret = mt->register_mgr(dev); 166 - if (ret > 0) { 167 - dev->mt = mt; 168 - break; /* successfully initialized */ 169 - } 170 - } 171 - 172 - if (!ret) 173 - pr_info("nvm: no compatible nvm manager found.\n"); 174 - 175 - return ret; 176 - } 177 125 178 126 static struct nvm_dev *nvm_find_nvm_dev(const char *name) 179 127 { ··· 258 246 if (!dev->q || !dev->ops) 259 247 return ret; 260 248 261 - if (dev->ops->identity(dev->q, &dev->identity)) { 249 + if (dev->ops->identity(dev, &dev->identity)) { 262 250 pr_err("nvm: device could not be identified\n"); 263 251 goto err; 264 252 } ··· 282 270 pr_err("nvm: could not initialize core structures.\n"); 283 271 goto err; 284 272 } 285 - 286 - down_write(&nvm_lock); 287 - ret = register_mgr(dev); 288 - up_write(&nvm_lock); 289 - if (ret < 0) 290 - goto err; 291 - if (!ret) 292 - return 0; 293 273 294 274 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n", 295 275 dev->name, dev->sec_per_pg, dev->nr_planes, ··· 330 326 } 331 327 332 328 if (dev->ops->max_phys_sect > 1) { 333 - dev->ppalist_pool = dev->ops->create_dma_pool(dev->q, 334 - "ppalist"); 329 + dev->ppalist_pool = dev->ops->create_dma_pool(dev, "ppalist"); 335 330 if (!dev->ppalist_pool) { 336 331 pr_err("nvm: could not create ppa pool\n"); 337 332 ret = -ENOMEM; ··· 338 335 } 339 336 } 340 337 338 + /* register device with a supported media manager */ 341 339 down_write(&nvm_lock); 340 + dev->mt = nvm_init_mgr(dev); 342 341 list_add(&dev->devices, &nvm_devices); 343 342 up_write(&nvm_lock); 344 343 ··· 385 380 struct nvm_tgt_type *tt; 386 381 struct nvm_target *t; 387 382 void *targetdata; 388 - int ret = 0; 389 383 390 - down_write(&nvm_lock); 391 384 if (!dev->mt) { 392 - ret = register_mgr(dev); 393 - if (!ret) 394 - ret = -ENODEV; 395 - if (ret < 0) { 396 - up_write(&nvm_lock); 397 - return ret; 398 - } 385 + pr_info("nvm: device has no media manager registered.\n"); 386 + return -ENODEV; 399 387 } 400 388 389 + down_write(&nvm_lock); 401 390 tt = nvm_find_target_type(create->tgttype); 402 391 if (!tt) { 403 392 pr_err("nvm: target type %s not found\n", create->tgttype);

+11 -9

drivers/lightnvm/gennvm.c

··· 195 195 } 196 196 197 197 if (dev->ops->get_l2p_tbl) { 198 - ret = dev->ops->get_l2p_tbl(dev->q, 0, dev->total_pages, 198 + ret = dev->ops->get_l2p_tbl(dev, 0, dev->total_pages, 199 199 gennvm_block_map, dev); 200 200 if (ret) { 201 201 pr_err("gennvm: could not read L2P table.\n"); ··· 218 218 { 219 219 struct gen_nvm *gn; 220 220 int ret; 221 + 222 + if (!try_module_get(THIS_MODULE)) 223 + return -ENODEV; 221 224 222 225 gn = kzalloc(sizeof(struct gen_nvm), GFP_KERNEL); 223 226 if (!gn) ··· 245 242 return 1; 246 243 err: 247 244 gennvm_free(dev); 245 + module_put(THIS_MODULE); 248 246 return ret; 249 247 } 250 248 251 249 static void gennvm_unregister(struct nvm_dev *dev) 252 250 { 253 251 gennvm_free(dev); 252 + module_put(THIS_MODULE); 254 253 } 255 254 256 255 static struct nvm_block *gennvm_get_blk(struct nvm_dev *dev, ··· 267 262 if (list_empty(&lun->free_list)) { 268 263 pr_err_ratelimited("gennvm: lun %u have no free pages available", 269 264 lun->vlun.id); 270 - spin_unlock(&vlun->lock); 271 265 goto out; 272 266 } 273 267 274 - while (!is_gc && lun->vlun.nr_free_blocks < lun->reserved_blocks) { 275 - spin_unlock(&vlun->lock); 268 + if (!is_gc && lun->vlun.nr_free_blocks < lun->reserved_blocks) 276 269 goto out; 277 - } 278 270 279 271 blk = list_first_entry(&lun->free_list, struct nvm_block, list); 280 272 list_move_tail(&blk->list, &lun->used_list); ··· 280 278 lun->vlun.nr_free_blocks--; 281 279 lun->vlun.nr_inuse_blocks++; 282 280 283 - spin_unlock(&vlun->lock); 284 281 out: 282 + spin_unlock(&vlun->lock); 285 283 return blk; 286 284 } 287 285 ··· 351 349 gennvm_generic_to_addr_mode(dev, rqd); 352 350 353 351 rqd->dev = dev; 354 - return dev->ops->submit_io(dev->q, rqd); 352 + return dev->ops->submit_io(dev, rqd); 355 353 } 356 354 357 355 static void gennvm_blk_set_type(struct nvm_dev *dev, struct ppa_addr *ppa, ··· 387 385 if (!dev->ops->set_bb_tbl) 388 386 return; 389 387 390 - if (dev->ops->set_bb_tbl(dev->q, rqd, 1)) 388 + if (dev->ops->set_bb_tbl(dev, rqd, 1)) 391 389 return; 392 390 393 391 gennvm_addr_to_generic_mode(dev, rqd); ··· 455 453 456 454 gennvm_generic_to_addr_mode(dev, &rqd); 457 455 458 - ret = dev->ops->erase_block(dev->q, &rqd); 456 + ret = dev->ops->erase_block(dev, &rqd); 459 457 460 458 if (plane_cnt) 461 459 nvm_dev_dma_free(dev, rqd.ppa_list, rqd.dma_ppa_list);

+21 -4

drivers/lightnvm/rrpc.c

··· 182 182 struct nvm_block *blk; 183 183 struct rrpc_block *rblk; 184 184 185 - blk = nvm_get_blk(rrpc->dev, rlun->parent, 0); 185 + blk = nvm_get_blk(rrpc->dev, rlun->parent, flags); 186 186 if (!blk) 187 187 return NULL; 188 188 ··· 200 200 static void rrpc_put_blk(struct rrpc *rrpc, struct rrpc_block *rblk) 201 201 { 202 202 nvm_put_blk(rrpc->dev, rblk->parent); 203 + } 204 + 205 + static void rrpc_put_blks(struct rrpc *rrpc) 206 + { 207 + struct rrpc_lun *rlun; 208 + int i; 209 + 210 + for (i = 0; i < rrpc->nr_luns; i++) { 211 + rlun = &rrpc->luns[i]; 212 + if (rlun->cur) 213 + rrpc_put_blk(rrpc, rlun->cur); 214 + if (rlun->gc_cur) 215 + rrpc_put_blk(rrpc, rlun->gc_cur); 216 + } 203 217 } 204 218 205 219 static struct rrpc_lun *get_next_lun(struct rrpc *rrpc) ··· 1016 1002 return 0; 1017 1003 1018 1004 /* Bring up the mapping table from device */ 1019 - ret = dev->ops->get_l2p_tbl(dev->q, 0, dev->total_pages, 1005 + ret = dev->ops->get_l2p_tbl(dev, 0, dev->total_pages, 1020 1006 rrpc_l2p_update, rrpc); 1021 1007 if (ret) { 1022 1008 pr_err("nvm: rrpc: could not read L2P table.\n"); ··· 1238 1224 1239 1225 rblk = rrpc_get_blk(rrpc, rlun, 0); 1240 1226 if (!rblk) 1241 - return -EINVAL; 1227 + goto err; 1242 1228 1243 1229 rrpc_set_lun_cur(rlun, rblk); 1244 1230 1245 1231 /* Emergency gc block */ 1246 1232 rblk = rrpc_get_blk(rrpc, rlun, 1); 1247 1233 if (!rblk) 1248 - return -EINVAL; 1234 + goto err; 1249 1235 rlun->gc_cur = rblk; 1250 1236 } 1251 1237 1252 1238 return 0; 1239 + err: 1240 + rrpc_put_blks(rrpc); 1241 + return -EINVAL; 1253 1242 } 1254 1243 1255 1244 static struct nvm_tgt_type tt_rrpc;

+14 -12

drivers/nvme/host/lightnvm.c

··· 271 271 return 0; 272 272 } 273 273 274 - static int nvme_nvm_identity(struct request_queue *q, struct nvm_id *nvm_id) 274 + static int nvme_nvm_identity(struct nvm_dev *nvmdev, struct nvm_id *nvm_id) 275 275 { 276 - struct nvme_ns *ns = q->queuedata; 276 + struct nvme_ns *ns = nvmdev->q->queuedata; 277 277 struct nvme_dev *dev = ns->dev; 278 278 struct nvme_nvm_id *nvme_nvm_id; 279 279 struct nvme_nvm_command c = {}; ··· 308 308 return ret; 309 309 } 310 310 311 - static int nvme_nvm_get_l2p_tbl(struct request_queue *q, u64 slba, u32 nlb, 311 + static int nvme_nvm_get_l2p_tbl(struct nvm_dev *nvmdev, u64 slba, u32 nlb, 312 312 nvm_l2p_update_fn *update_l2p, void *priv) 313 313 { 314 - struct nvme_ns *ns = q->queuedata; 314 + struct nvme_ns *ns = nvmdev->q->queuedata; 315 315 struct nvme_dev *dev = ns->dev; 316 316 struct nvme_nvm_command c = {}; 317 317 u32 len = queue_max_hw_sectors(dev->admin_q) << 9; ··· 415 415 return ret; 416 416 } 417 417 418 - static int nvme_nvm_set_bb_tbl(struct request_queue *q, struct nvm_rq *rqd, 418 + static int nvme_nvm_set_bb_tbl(struct nvm_dev *nvmdev, struct nvm_rq *rqd, 419 419 int type) 420 420 { 421 - struct nvme_ns *ns = q->queuedata; 421 + struct nvme_ns *ns = nvmdev->q->queuedata; 422 422 struct nvme_dev *dev = ns->dev; 423 423 struct nvme_nvm_command c = {}; 424 424 int ret = 0; ··· 455 455 struct nvm_rq *rqd = rq->end_io_data; 456 456 struct nvm_dev *dev = rqd->dev; 457 457 458 - if (dev->mt->end_io(rqd, error)) 458 + if (dev->mt && dev->mt->end_io(rqd, error)) 459 459 pr_err("nvme: err status: %x result: %lx\n", 460 460 rq->errors, (unsigned long)rq->special); 461 461 ··· 463 463 blk_mq_free_request(rq); 464 464 } 465 465 466 - static int nvme_nvm_submit_io(struct request_queue *q, struct nvm_rq *rqd) 466 + static int nvme_nvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd) 467 467 { 468 + struct request_queue *q = dev->q; 468 469 struct nvme_ns *ns = q->queuedata; 469 470 struct request *rq; 470 471 struct bio *bio = rqd->bio; ··· 503 502 return 0; 504 503 } 505 504 506 - static int nvme_nvm_erase_block(struct request_queue *q, struct nvm_rq *rqd) 505 + static int nvme_nvm_erase_block(struct nvm_dev *dev, struct nvm_rq *rqd) 507 506 { 507 + struct request_queue *q = dev->q; 508 508 struct nvme_ns *ns = q->queuedata; 509 509 struct nvme_nvm_command c = {}; 510 510 ··· 517 515 return nvme_submit_sync_cmd(q, (struct nvme_command *)&c, NULL, 0); 518 516 } 519 517 520 - static void *nvme_nvm_create_dma_pool(struct request_queue *q, char *name) 518 + static void *nvme_nvm_create_dma_pool(struct nvm_dev *nvmdev, char *name) 521 519 { 522 - struct nvme_ns *ns = q->queuedata; 520 + struct nvme_ns *ns = nvmdev->q->queuedata; 523 521 struct nvme_dev *dev = ns->dev; 524 522 525 523 return dma_pool_create(name, dev->dev, PAGE_SIZE, PAGE_SIZE, 0); ··· 532 530 dma_pool_destroy(dma_pool); 533 531 } 534 532 535 - static void *nvme_nvm_dev_dma_alloc(struct request_queue *q, void *pool, 533 + static void *nvme_nvm_dev_dma_alloc(struct nvm_dev *dev, void *pool, 536 534 gfp_t mem_flags, dma_addr_t *dma_handler) 537 535 { 538 536 return dma_pool_alloc(pool, mem_flags, dma_handler);

+7 -4

fs/block_dev.c

··· 1523 1523 WARN_ON_ONCE(bdev->bd_holders); 1524 1524 sync_blockdev(bdev); 1525 1525 kill_bdev(bdev); 1526 - /* 1527 - * ->release can cause the queue to disappear, so flush all 1528 - * dirty data before. 1529 - */ 1526 + 1530 1527 bdev_write_inode(bdev); 1528 + /* 1529 + * Detaching bdev inode from its wb in __destroy_inode() 1530 + * is too late: the queue which embeds its bdi (along with 1531 + * root wb) can be gone as soon as we put_disk() below. 1532 + */ 1533 + inode_detach_wb(bdev->bd_inode); 1531 1534 } 1532 1535 if (bdev->bd_contains == bdev) { 1533 1536 if (disk->fops->release)

+14 -7

include/linux/lightnvm.h

··· 50 50 NVM_IO_DUAL_ACCESS = 0x1, 51 51 NVM_IO_QUAD_ACCESS = 0x2, 52 52 53 + /* NAND Access Modes */ 53 54 NVM_IO_SUSPEND = 0x80, 54 55 NVM_IO_SLC_MODE = 0x100, 55 56 NVM_IO_SCRAMBLE_DISABLE = 0x200, 57 + 58 + /* Block Types */ 59 + NVM_BLK_T_FREE = 0x0, 60 + NVM_BLK_T_BAD = 0x1, 61 + NVM_BLK_T_DEV = 0x2, 62 + NVM_BLK_T_HOST = 0x4, 56 63 }; 57 64 58 65 struct nvm_id_group { ··· 183 176 184 177 typedef int (nvm_l2p_update_fn)(u64, u32, __le64 *, void *); 185 178 typedef int (nvm_bb_update_fn)(struct ppa_addr, int, u8 *, void *); 186 - typedef int (nvm_id_fn)(struct request_queue *, struct nvm_id *); 187 - typedef int (nvm_get_l2p_tbl_fn)(struct request_queue *, u64, u32, 179 + typedef int (nvm_id_fn)(struct nvm_dev *, struct nvm_id *); 180 + typedef int (nvm_get_l2p_tbl_fn)(struct nvm_dev *, u64, u32, 188 181 nvm_l2p_update_fn *, void *); 189 182 typedef int (nvm_op_bb_tbl_fn)(struct nvm_dev *, struct ppa_addr, int, 190 183 nvm_bb_update_fn *, void *); 191 - typedef int (nvm_op_set_bb_fn)(struct request_queue *, struct nvm_rq *, int); 192 - typedef int (nvm_submit_io_fn)(struct request_queue *, struct nvm_rq *); 193 - typedef int (nvm_erase_blk_fn)(struct request_queue *, struct nvm_rq *); 194 - typedef void *(nvm_create_dma_pool_fn)(struct request_queue *, char *); 184 + typedef int (nvm_op_set_bb_fn)(struct nvm_dev *, struct nvm_rq *, int); 185 + typedef int (nvm_submit_io_fn)(struct nvm_dev *, struct nvm_rq *); 186 + typedef int (nvm_erase_blk_fn)(struct nvm_dev *, struct nvm_rq *); 187 + typedef void *(nvm_create_dma_pool_fn)(struct nvm_dev *, char *); 195 188 typedef void (nvm_destroy_dma_pool_fn)(void *); 196 - typedef void *(nvm_dev_dma_alloc_fn)(struct request_queue *, void *, gfp_t, 189 + typedef void *(nvm_dev_dma_alloc_fn)(struct nvm_dev *, void *, gfp_t, 197 190 dma_addr_t *); 198 191 typedef void (nvm_dev_dma_free_fn)(void *, void*, dma_addr_t); 199 192

Configure Feed

Configure Feed