2 * Copyright (C) 2015 IT University of Copenhagen. All rights reserved.
3 * Initial release: Matias Bjorling <m@bjorling.me>
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version
7 * 2 as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
21 #include <linux/blkdev.h>
22 #include <linux/blk-mq.h>
23 #include <linux/list.h>
24 #include <linux/types.h>
25 #include <linux/sem.h>
26 #include <linux/bitmap.h>
27 #include <linux/module.h>
28 #include <linux/miscdevice.h>
29 #include <linux/lightnvm.h>
30 #include <linux/sched/sysctl.h>
31 #include <uapi/linux/lightnvm.h>
33 static LIST_HEAD(nvm_tgt_types
);
34 static LIST_HEAD(nvm_mgrs
);
35 static LIST_HEAD(nvm_devices
);
36 static DECLARE_RWSEM(nvm_lock
);
38 static struct nvm_tgt_type
*nvm_find_target_type(const char *name
)
40 struct nvm_tgt_type
*tt
;
42 list_for_each_entry(tt
, &nvm_tgt_types
, list
)
43 if (!strcmp(name
, tt
->name
))
49 int nvm_register_tgt_type(struct nvm_tgt_type
*tt
)
53 down_write(&nvm_lock
);
54 if (nvm_find_target_type(tt
->name
))
57 list_add(&tt
->list
, &nvm_tgt_types
);
62 EXPORT_SYMBOL(nvm_register_tgt_type
);
64 void nvm_unregister_tgt_type(struct nvm_tgt_type
*tt
)
69 down_write(&nvm_lock
);
73 EXPORT_SYMBOL(nvm_unregister_tgt_type
);
75 void *nvm_dev_dma_alloc(struct nvm_dev
*dev
, gfp_t mem_flags
,
76 dma_addr_t
*dma_handler
)
78 return dev
->ops
->dev_dma_alloc(dev
, dev
->ppalist_pool
, mem_flags
,
81 EXPORT_SYMBOL(nvm_dev_dma_alloc
);
83 void nvm_dev_dma_free(struct nvm_dev
*dev
, void *ppa_list
,
84 dma_addr_t dma_handler
)
86 dev
->ops
->dev_dma_free(dev
->ppalist_pool
, ppa_list
, dma_handler
);
88 EXPORT_SYMBOL(nvm_dev_dma_free
);
90 static struct nvmm_type
*nvm_find_mgr_type(const char *name
)
94 list_for_each_entry(mt
, &nvm_mgrs
, list
)
95 if (!strcmp(name
, mt
->name
))
101 struct nvmm_type
*nvm_init_mgr(struct nvm_dev
*dev
)
103 struct nvmm_type
*mt
;
106 lockdep_assert_held(&nvm_lock
);
108 list_for_each_entry(mt
, &nvm_mgrs
, list
) {
109 if (strncmp(dev
->sb
.mmtype
, mt
->name
, NVM_MMTYPE_LEN
))
112 ret
= mt
->register_mgr(dev
);
114 pr_err("nvm: media mgr failed to init (%d) on dev %s\n",
116 return NULL
; /* initialization failed */
124 int nvm_register_mgr(struct nvmm_type
*mt
)
129 down_write(&nvm_lock
);
130 if (nvm_find_mgr_type(mt
->name
)) {
134 list_add(&mt
->list
, &nvm_mgrs
);
137 /* try to register media mgr if any device have none configured */
138 list_for_each_entry(dev
, &nvm_devices
, devices
) {
142 dev
->mt
= nvm_init_mgr(dev
);
149 EXPORT_SYMBOL(nvm_register_mgr
);
151 void nvm_unregister_mgr(struct nvmm_type
*mt
)
156 down_write(&nvm_lock
);
160 EXPORT_SYMBOL(nvm_unregister_mgr
);
162 static struct nvm_dev
*nvm_find_nvm_dev(const char *name
)
166 list_for_each_entry(dev
, &nvm_devices
, devices
)
167 if (!strcmp(name
, dev
->name
))
173 struct nvm_block
*nvm_get_blk_unlocked(struct nvm_dev
*dev
, struct nvm_lun
*lun
,
176 return dev
->mt
->get_blk_unlocked(dev
, lun
, flags
);
178 EXPORT_SYMBOL(nvm_get_blk_unlocked
);
180 /* Assumes that all valid pages have already been moved on release to bm */
181 void nvm_put_blk_unlocked(struct nvm_dev
*dev
, struct nvm_block
*blk
)
183 return dev
->mt
->put_blk_unlocked(dev
, blk
);
185 EXPORT_SYMBOL(nvm_put_blk_unlocked
);
187 struct nvm_block
*nvm_get_blk(struct nvm_dev
*dev
, struct nvm_lun
*lun
,
190 return dev
->mt
->get_blk(dev
, lun
, flags
);
192 EXPORT_SYMBOL(nvm_get_blk
);
194 /* Assumes that all valid pages have already been moved on release to bm */
195 void nvm_put_blk(struct nvm_dev
*dev
, struct nvm_block
*blk
)
197 return dev
->mt
->put_blk(dev
, blk
);
199 EXPORT_SYMBOL(nvm_put_blk
);
201 int nvm_submit_io(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
203 return dev
->mt
->submit_io(dev
, rqd
);
205 EXPORT_SYMBOL(nvm_submit_io
);
207 int nvm_erase_blk(struct nvm_dev
*dev
, struct nvm_block
*blk
)
209 return dev
->mt
->erase_blk(dev
, blk
, 0);
211 EXPORT_SYMBOL(nvm_erase_blk
);
213 void nvm_addr_to_generic_mode(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
217 if (rqd
->nr_pages
> 1) {
218 for (i
= 0; i
< rqd
->nr_pages
; i
++)
219 rqd
->ppa_list
[i
] = dev_to_generic_addr(dev
,
222 rqd
->ppa_addr
= dev_to_generic_addr(dev
, rqd
->ppa_addr
);
225 EXPORT_SYMBOL(nvm_addr_to_generic_mode
);
227 void nvm_generic_to_addr_mode(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
231 if (rqd
->nr_pages
> 1) {
232 for (i
= 0; i
< rqd
->nr_pages
; i
++)
233 rqd
->ppa_list
[i
] = generic_to_dev_addr(dev
,
236 rqd
->ppa_addr
= generic_to_dev_addr(dev
, rqd
->ppa_addr
);
239 EXPORT_SYMBOL(nvm_generic_to_addr_mode
);
241 int nvm_set_rqd_ppalist(struct nvm_dev
*dev
, struct nvm_rq
*rqd
,
242 struct ppa_addr
*ppas
, int nr_ppas
)
244 int i
, plane_cnt
, pl_idx
;
246 if (dev
->plane_mode
== NVM_PLANE_SINGLE
&& nr_ppas
== 1) {
248 rqd
->ppa_addr
= ppas
[0];
253 plane_cnt
= dev
->plane_mode
;
254 rqd
->nr_pages
= plane_cnt
* nr_ppas
;
256 if (dev
->ops
->max_phys_sect
< rqd
->nr_pages
)
259 rqd
->ppa_list
= nvm_dev_dma_alloc(dev
, GFP_KERNEL
, &rqd
->dma_ppa_list
);
260 if (!rqd
->ppa_list
) {
261 pr_err("nvm: failed to allocate dma memory\n");
265 for (pl_idx
= 0; pl_idx
< plane_cnt
; pl_idx
++) {
266 for (i
= 0; i
< nr_ppas
; i
++) {
267 ppas
[i
].g
.pl
= pl_idx
;
268 rqd
->ppa_list
[(pl_idx
* nr_ppas
) + i
] = ppas
[i
];
274 EXPORT_SYMBOL(nvm_set_rqd_ppalist
);
276 void nvm_free_rqd_ppalist(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
281 nvm_dev_dma_free(dev
, rqd
->ppa_list
, rqd
->dma_ppa_list
);
283 EXPORT_SYMBOL(nvm_free_rqd_ppalist
);
285 int nvm_erase_ppa(struct nvm_dev
*dev
, struct ppa_addr
*ppas
, int nr_ppas
)
290 if (!dev
->ops
->erase_block
)
293 memset(&rqd
, 0, sizeof(struct nvm_rq
));
295 ret
= nvm_set_rqd_ppalist(dev
, &rqd
, ppas
, nr_ppas
);
299 nvm_generic_to_addr_mode(dev
, &rqd
);
301 ret
= dev
->ops
->erase_block(dev
, &rqd
);
303 nvm_free_rqd_ppalist(dev
, &rqd
);
307 EXPORT_SYMBOL(nvm_erase_ppa
);
309 void nvm_end_io(struct nvm_rq
*rqd
, int error
)
314 EXPORT_SYMBOL(nvm_end_io
);
316 static void nvm_end_io_sync(struct nvm_rq
*rqd
)
318 struct completion
*waiting
= rqd
->wait
;
325 int __nvm_submit_ppa(struct nvm_dev
*dev
, struct nvm_rq
*rqd
, int opcode
,
326 int flags
, void *buf
, int len
)
328 DECLARE_COMPLETION_ONSTACK(wait
);
331 unsigned long hang_check
;
333 bio
= bio_map_kern(dev
->q
, buf
, len
, GFP_KERNEL
);
334 if (IS_ERR_OR_NULL(bio
))
337 nvm_generic_to_addr_mode(dev
, rqd
);
340 rqd
->opcode
= opcode
;
344 rqd
->end_io
= nvm_end_io_sync
;
346 ret
= dev
->ops
->submit_io(dev
, rqd
);
352 /* Prevent hang_check timer from firing at us during very long I/O */
353 hang_check
= sysctl_hung_task_timeout_secs
;
355 while (!wait_for_completion_io_timeout(&wait
, hang_check
* (HZ
/2)));
357 wait_for_completion_io(&wait
);
363 * nvm_submit_ppa_list - submit user-defined ppa list to device. The user must
364 * take to free ppa list if necessary.
366 * @ppa_list: user created ppa_list
367 * @nr_ppas: length of ppa_list
368 * @opcode: device opcode
369 * @flags: device flags
371 * @len: data buffer length
373 int nvm_submit_ppa_list(struct nvm_dev
*dev
, struct ppa_addr
*ppa_list
,
374 int nr_ppas
, int opcode
, int flags
, void *buf
, int len
)
378 if (dev
->ops
->max_phys_sect
< nr_ppas
)
381 memset(&rqd
, 0, sizeof(struct nvm_rq
));
383 rqd
.nr_pages
= nr_ppas
;
385 rqd
.ppa_list
= ppa_list
;
387 rqd
.ppa_addr
= ppa_list
[0];
389 return __nvm_submit_ppa(dev
, &rqd
, opcode
, flags
, buf
, len
);
391 EXPORT_SYMBOL(nvm_submit_ppa_list
);
394 * nvm_submit_ppa - submit PPAs to device. PPAs will automatically be unfolded
395 * as single, dual, quad plane PPAs depending on device type.
397 * @ppa: user created ppa_list
398 * @nr_ppas: length of ppa_list
399 * @opcode: device opcode
400 * @flags: device flags
402 * @len: data buffer length
404 int nvm_submit_ppa(struct nvm_dev
*dev
, struct ppa_addr
*ppa
, int nr_ppas
,
405 int opcode
, int flags
, void *buf
, int len
)
410 memset(&rqd
, 0, sizeof(struct nvm_rq
));
411 ret
= nvm_set_rqd_ppalist(dev
, &rqd
, ppa
, nr_ppas
);
415 ret
= __nvm_submit_ppa(dev
, &rqd
, opcode
, flags
, buf
, len
);
417 nvm_free_rqd_ppalist(dev
, &rqd
);
421 EXPORT_SYMBOL(nvm_submit_ppa
);
424 * folds a bad block list from its plane representation to its virtual
425 * block representation. The fold is done in place and reduced size is
428 * If any of the planes status are bad or grown bad block, the virtual block
429 * is marked bad. If not bad, the first plane state acts as the block state.
431 int nvm_bb_tbl_fold(struct nvm_dev
*dev
, u8
*blks
, int nr_blks
)
433 int blk
, offset
, pl
, blktype
;
435 if (nr_blks
!= dev
->blks_per_lun
* dev
->plane_mode
)
438 for (blk
= 0; blk
< dev
->blks_per_lun
; blk
++) {
439 offset
= blk
* dev
->plane_mode
;
440 blktype
= blks
[offset
];
442 /* Bad blocks on any planes take precedence over other types */
443 for (pl
= 0; pl
< dev
->plane_mode
; pl
++) {
444 if (blks
[offset
+ pl
] &
445 (NVM_BLK_T_BAD
|NVM_BLK_T_GRWN_BAD
)) {
446 blktype
= blks
[offset
+ pl
];
454 return dev
->blks_per_lun
;
456 EXPORT_SYMBOL(nvm_bb_tbl_fold
);
458 static int nvm_init_slc_tbl(struct nvm_dev
*dev
, struct nvm_id_group
*grp
)
462 dev
->lps_per_blk
= dev
->pgs_per_blk
;
463 dev
->lptbl
= kcalloc(dev
->lps_per_blk
, sizeof(int), GFP_KERNEL
);
467 /* Just a linear array */
468 for (i
= 0; i
< dev
->lps_per_blk
; i
++)
474 static int nvm_init_mlc_tbl(struct nvm_dev
*dev
, struct nvm_id_group
*grp
)
477 struct nvm_id_lp_mlc
*mlc
= &grp
->lptbl
.mlc
;
482 dev
->lps_per_blk
= mlc
->num_pairs
;
483 dev
->lptbl
= kcalloc(dev
->lps_per_blk
, sizeof(int), GFP_KERNEL
);
487 /* The lower page table encoding consists of a list of bytes, where each
488 * has a lower and an upper half. The first half byte maintains the
489 * increment value and every value after is an offset added to the
490 * previous incrementation value */
491 dev
->lptbl
[0] = mlc
->pairs
[0] & 0xF;
492 for (i
= 1; i
< dev
->lps_per_blk
; i
++) {
493 p
= mlc
->pairs
[i
>> 1];
494 if (i
& 0x1) /* upper */
495 dev
->lptbl
[i
] = dev
->lptbl
[i
- 1] + ((p
& 0xF0) >> 4);
497 dev
->lptbl
[i
] = dev
->lptbl
[i
- 1] + (p
& 0xF);
503 static int nvm_core_init(struct nvm_dev
*dev
)
505 struct nvm_id
*id
= &dev
->identity
;
506 struct nvm_id_group
*grp
= &id
->groups
[0];
510 dev
->nr_chnls
= grp
->num_ch
;
511 dev
->luns_per_chnl
= grp
->num_lun
;
512 dev
->pgs_per_blk
= grp
->num_pg
;
513 dev
->blks_per_lun
= grp
->num_blk
;
514 dev
->nr_planes
= grp
->num_pln
;
515 dev
->fpg_size
= grp
->fpg_sz
;
516 dev
->pfpg_size
= grp
->fpg_sz
* grp
->num_pln
;
517 dev
->sec_size
= grp
->csecs
;
518 dev
->oob_size
= grp
->sos
;
519 dev
->sec_per_pg
= grp
->fpg_sz
/ grp
->csecs
;
520 dev
->mccap
= grp
->mccap
;
521 memcpy(&dev
->ppaf
, &id
->ppaf
, sizeof(struct nvm_addr_format
));
523 dev
->plane_mode
= NVM_PLANE_SINGLE
;
524 dev
->max_rq_size
= dev
->ops
->max_phys_sect
* dev
->sec_size
;
526 if (grp
->mpos
& 0x020202)
527 dev
->plane_mode
= NVM_PLANE_DOUBLE
;
528 if (grp
->mpos
& 0x040404)
529 dev
->plane_mode
= NVM_PLANE_QUAD
;
531 if (grp
->mtype
!= 0) {
532 pr_err("nvm: memory type not supported\n");
536 /* calculated values */
537 dev
->sec_per_pl
= dev
->sec_per_pg
* dev
->nr_planes
;
538 dev
->sec_per_blk
= dev
->sec_per_pl
* dev
->pgs_per_blk
;
539 dev
->sec_per_lun
= dev
->sec_per_blk
* dev
->blks_per_lun
;
540 dev
->nr_luns
= dev
->luns_per_chnl
* dev
->nr_chnls
;
542 dev
->total_secs
= dev
->nr_luns
* dev
->sec_per_lun
;
543 dev
->lun_map
= kcalloc(BITS_TO_LONGS(dev
->nr_luns
),
544 sizeof(unsigned long), GFP_KERNEL
);
548 switch (grp
->fmtype
) {
549 case NVM_ID_FMTYPE_SLC
:
550 if (nvm_init_slc_tbl(dev
, grp
)) {
555 case NVM_ID_FMTYPE_MLC
:
556 if (nvm_init_mlc_tbl(dev
, grp
)) {
562 pr_err("nvm: flash type not supported\n");
567 INIT_LIST_HEAD(&dev
->online_targets
);
568 mutex_init(&dev
->mlock
);
569 spin_lock_init(&dev
->lock
);
577 static void nvm_free(struct nvm_dev
*dev
)
583 dev
->mt
->unregister_mgr(dev
);
589 static int nvm_init(struct nvm_dev
*dev
)
593 if (!dev
->q
|| !dev
->ops
)
596 if (dev
->ops
->identity(dev
, &dev
->identity
)) {
597 pr_err("nvm: device could not be identified\n");
601 pr_debug("nvm: ver:%x nvm_vendor:%x groups:%u\n",
602 dev
->identity
.ver_id
, dev
->identity
.vmnt
,
603 dev
->identity
.cgrps
);
605 if (dev
->identity
.ver_id
!= 1) {
606 pr_err("nvm: device not supported by kernel.");
610 if (dev
->identity
.cgrps
!= 1) {
611 pr_err("nvm: only one group configuration supported.");
615 ret
= nvm_core_init(dev
);
617 pr_err("nvm: could not initialize core structures.\n");
621 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n",
622 dev
->name
, dev
->sec_per_pg
, dev
->nr_planes
,
623 dev
->pgs_per_blk
, dev
->blks_per_lun
, dev
->nr_luns
,
627 pr_err("nvm: failed to initialize nvm\n");
631 static void nvm_exit(struct nvm_dev
*dev
)
633 if (dev
->ppalist_pool
)
634 dev
->ops
->destroy_dma_pool(dev
->ppalist_pool
);
637 pr_info("nvm: successfully unloaded\n");
640 int nvm_register(struct request_queue
*q
, char *disk_name
,
641 struct nvm_dev_ops
*ops
)
649 dev
= kzalloc(sizeof(struct nvm_dev
), GFP_KERNEL
);
655 strncpy(dev
->name
, disk_name
, DISK_NAME_LEN
);
661 if (dev
->ops
->max_phys_sect
> 256) {
662 pr_info("nvm: max sectors supported is 256.\n");
667 if (dev
->ops
->max_phys_sect
> 1) {
668 dev
->ppalist_pool
= dev
->ops
->create_dma_pool(dev
, "ppalist");
669 if (!dev
->ppalist_pool
) {
670 pr_err("nvm: could not create ppa pool\n");
676 if (dev
->identity
.cap
& NVM_ID_DCAP_BBLKMGMT
) {
677 ret
= nvm_get_sysblock(dev
, &dev
->sb
);
679 pr_err("nvm: device not initialized.\n");
681 pr_err("nvm: err (%d) on device initialization\n", ret
);
684 /* register device with a supported media manager */
685 down_write(&nvm_lock
);
687 dev
->mt
= nvm_init_mgr(dev
);
688 list_add(&dev
->devices
, &nvm_devices
);
697 EXPORT_SYMBOL(nvm_register
);
699 void nvm_unregister(char *disk_name
)
703 down_write(&nvm_lock
);
704 dev
= nvm_find_nvm_dev(disk_name
);
706 pr_err("nvm: could not find device %s to unregister\n",
712 list_del(&dev
->devices
);
718 EXPORT_SYMBOL(nvm_unregister
);
720 static const struct block_device_operations nvm_fops
= {
721 .owner
= THIS_MODULE
,
724 static int nvm_create_target(struct nvm_dev
*dev
,
725 struct nvm_ioctl_create
*create
)
727 struct nvm_ioctl_create_simple
*s
= &create
->conf
.s
;
728 struct request_queue
*tqueue
;
729 struct gendisk
*tdisk
;
730 struct nvm_tgt_type
*tt
;
731 struct nvm_target
*t
;
735 pr_info("nvm: device has no media manager registered.\n");
739 down_write(&nvm_lock
);
740 tt
= nvm_find_target_type(create
->tgttype
);
742 pr_err("nvm: target type %s not found\n", create
->tgttype
);
747 list_for_each_entry(t
, &dev
->online_targets
, list
) {
748 if (!strcmp(create
->tgtname
, t
->disk
->disk_name
)) {
749 pr_err("nvm: target name already exists.\n");
756 t
= kmalloc(sizeof(struct nvm_target
), GFP_KERNEL
);
760 tqueue
= blk_alloc_queue_node(GFP_KERNEL
, dev
->q
->node
);
763 blk_queue_make_request(tqueue
, tt
->make_rq
);
765 tdisk
= alloc_disk(0);
769 sprintf(tdisk
->disk_name
, "%s", create
->tgtname
);
770 tdisk
->flags
= GENHD_FL_EXT_DEVT
;
772 tdisk
->first_minor
= 0;
773 tdisk
->fops
= &nvm_fops
;
774 tdisk
->queue
= tqueue
;
776 targetdata
= tt
->init(dev
, tdisk
, s
->lun_begin
, s
->lun_end
);
777 if (IS_ERR(targetdata
))
780 tdisk
->private_data
= targetdata
;
781 tqueue
->queuedata
= targetdata
;
783 blk_queue_max_hw_sectors(tqueue
, 8 * dev
->ops
->max_phys_sect
);
785 set_capacity(tdisk
, tt
->capacity(targetdata
));
791 down_write(&nvm_lock
);
792 list_add_tail(&t
->list
, &dev
->online_targets
);
799 blk_cleanup_queue(tqueue
);
805 static void nvm_remove_target(struct nvm_target
*t
)
807 struct nvm_tgt_type
*tt
= t
->type
;
808 struct gendisk
*tdisk
= t
->disk
;
809 struct request_queue
*q
= tdisk
->queue
;
811 lockdep_assert_held(&nvm_lock
);
814 blk_cleanup_queue(q
);
817 tt
->exit(tdisk
->private_data
);
825 static int __nvm_configure_create(struct nvm_ioctl_create
*create
)
828 struct nvm_ioctl_create_simple
*s
;
830 down_write(&nvm_lock
);
831 dev
= nvm_find_nvm_dev(create
->dev
);
834 pr_err("nvm: device not found\n");
838 if (create
->conf
.type
!= NVM_CONFIG_TYPE_SIMPLE
) {
839 pr_err("nvm: config type not valid\n");
844 if (s
->lun_begin
> s
->lun_end
|| s
->lun_end
> dev
->nr_luns
) {
845 pr_err("nvm: lun out of bound (%u:%u > %u)\n",
846 s
->lun_begin
, s
->lun_end
, dev
->nr_luns
);
850 return nvm_create_target(dev
, create
);
853 static int __nvm_configure_remove(struct nvm_ioctl_remove
*remove
)
855 struct nvm_target
*t
= NULL
;
859 down_write(&nvm_lock
);
860 list_for_each_entry(dev
, &nvm_devices
, devices
)
861 list_for_each_entry(t
, &dev
->online_targets
, list
) {
862 if (!strcmp(remove
->tgtname
, t
->disk
->disk_name
)) {
863 nvm_remove_target(t
);
871 pr_err("nvm: target \"%s\" doesn't exist.\n", remove
->tgtname
);
878 #ifdef CONFIG_NVM_DEBUG
879 static int nvm_configure_show(const char *val
)
882 char opcode
, devname
[DISK_NAME_LEN
];
885 ret
= sscanf(val
, "%c %32s", &opcode
, devname
);
887 pr_err("nvm: invalid command. Use \"opcode devicename\".\n");
891 down_write(&nvm_lock
);
892 dev
= nvm_find_nvm_dev(devname
);
895 pr_err("nvm: device not found\n");
902 dev
->mt
->lun_info_print(dev
);
907 static int nvm_configure_remove(const char *val
)
909 struct nvm_ioctl_remove remove
;
913 ret
= sscanf(val
, "%c %256s", &opcode
, remove
.tgtname
);
915 pr_err("nvm: invalid command. Use \"d targetname\".\n");
921 return __nvm_configure_remove(&remove
);
924 static int nvm_configure_create(const char *val
)
926 struct nvm_ioctl_create create
;
928 int lun_begin
, lun_end
, ret
;
930 ret
= sscanf(val
, "%c %256s %256s %48s %u:%u", &opcode
, create
.dev
,
931 create
.tgtname
, create
.tgttype
,
932 &lun_begin
, &lun_end
);
934 pr_err("nvm: invalid command. Use \"opcode device name tgttype lun_begin:lun_end\".\n");
939 create
.conf
.type
= NVM_CONFIG_TYPE_SIMPLE
;
940 create
.conf
.s
.lun_begin
= lun_begin
;
941 create
.conf
.s
.lun_end
= lun_end
;
943 return __nvm_configure_create(&create
);
947 /* Exposes administrative interface through /sys/module/lnvm/configure_by_str */
948 static int nvm_configure_by_str_event(const char *val
,
949 const struct kernel_param
*kp
)
954 ret
= sscanf(val
, "%c", &opcode
);
956 pr_err("nvm: string must have the format of \"cmd ...\"\n");
962 return nvm_configure_create(val
);
964 return nvm_configure_remove(val
);
966 return nvm_configure_show(val
);
968 pr_err("nvm: invalid command\n");
975 static int nvm_configure_get(char *buf
, const struct kernel_param
*kp
)
980 sz
= sprintf(buf
, "available devices:\n");
981 down_write(&nvm_lock
);
982 list_for_each_entry(dev
, &nvm_devices
, devices
) {
983 if (sz
> 4095 - DISK_NAME_LEN
- 2)
985 sz
+= sprintf(buf
+ sz
, " %32s\n", dev
->name
);
992 static const struct kernel_param_ops nvm_configure_by_str_event_param_ops
= {
993 .set
= nvm_configure_by_str_event
,
994 .get
= nvm_configure_get
,
997 #undef MODULE_PARAM_PREFIX
998 #define MODULE_PARAM_PREFIX "lnvm."
1000 module_param_cb(configure_debug
, &nvm_configure_by_str_event_param_ops
, NULL
,
1003 #endif /* CONFIG_NVM_DEBUG */
1005 static long nvm_ioctl_info(struct file
*file
, void __user
*arg
)
1007 struct nvm_ioctl_info
*info
;
1008 struct nvm_tgt_type
*tt
;
1011 if (!capable(CAP_SYS_ADMIN
))
1014 info
= memdup_user(arg
, sizeof(struct nvm_ioctl_info
));
1018 info
->version
[0] = NVM_VERSION_MAJOR
;
1019 info
->version
[1] = NVM_VERSION_MINOR
;
1020 info
->version
[2] = NVM_VERSION_PATCH
;
1022 down_write(&nvm_lock
);
1023 list_for_each_entry(tt
, &nvm_tgt_types
, list
) {
1024 struct nvm_ioctl_info_tgt
*tgt
= &info
->tgts
[tgt_iter
];
1026 tgt
->version
[0] = tt
->version
[0];
1027 tgt
->version
[1] = tt
->version
[1];
1028 tgt
->version
[2] = tt
->version
[2];
1029 strncpy(tgt
->tgtname
, tt
->name
, NVM_TTYPE_NAME_MAX
);
1034 info
->tgtsize
= tgt_iter
;
1035 up_write(&nvm_lock
);
1037 if (copy_to_user(arg
, info
, sizeof(struct nvm_ioctl_info
))) {
1046 static long nvm_ioctl_get_devices(struct file
*file
, void __user
*arg
)
1048 struct nvm_ioctl_get_devices
*devices
;
1049 struct nvm_dev
*dev
;
1052 if (!capable(CAP_SYS_ADMIN
))
1055 devices
= kzalloc(sizeof(struct nvm_ioctl_get_devices
), GFP_KERNEL
);
1059 down_write(&nvm_lock
);
1060 list_for_each_entry(dev
, &nvm_devices
, devices
) {
1061 struct nvm_ioctl_device_info
*info
= &devices
->info
[i
];
1063 sprintf(info
->devname
, "%s", dev
->name
);
1065 info
->bmversion
[0] = dev
->mt
->version
[0];
1066 info
->bmversion
[1] = dev
->mt
->version
[1];
1067 info
->bmversion
[2] = dev
->mt
->version
[2];
1068 sprintf(info
->bmname
, "%s", dev
->mt
->name
);
1070 sprintf(info
->bmname
, "none");
1075 pr_err("nvm: max 31 devices can be reported.\n");
1079 up_write(&nvm_lock
);
1081 devices
->nr_devices
= i
;
1083 if (copy_to_user(arg
, devices
,
1084 sizeof(struct nvm_ioctl_get_devices
))) {
1093 static long nvm_ioctl_dev_create(struct file
*file
, void __user
*arg
)
1095 struct nvm_ioctl_create create
;
1097 if (!capable(CAP_SYS_ADMIN
))
1100 if (copy_from_user(&create
, arg
, sizeof(struct nvm_ioctl_create
)))
1103 create
.dev
[DISK_NAME_LEN
- 1] = '\0';
1104 create
.tgttype
[NVM_TTYPE_NAME_MAX
- 1] = '\0';
1105 create
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
1107 if (create
.flags
!= 0) {
1108 pr_err("nvm: no flags supported\n");
1112 return __nvm_configure_create(&create
);
1115 static long nvm_ioctl_dev_remove(struct file
*file
, void __user
*arg
)
1117 struct nvm_ioctl_remove remove
;
1119 if (!capable(CAP_SYS_ADMIN
))
1122 if (copy_from_user(&remove
, arg
, sizeof(struct nvm_ioctl_remove
)))
1125 remove
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
1127 if (remove
.flags
!= 0) {
1128 pr_err("nvm: no flags supported\n");
1132 return __nvm_configure_remove(&remove
);
1135 static void nvm_setup_nvm_sb_info(struct nvm_sb_info
*info
)
1138 info
->erase_cnt
= 0;
1142 static long __nvm_ioctl_dev_init(struct nvm_ioctl_dev_init
*init
)
1144 struct nvm_dev
*dev
;
1145 struct nvm_sb_info info
;
1148 down_write(&nvm_lock
);
1149 dev
= nvm_find_nvm_dev(init
->dev
);
1150 up_write(&nvm_lock
);
1152 pr_err("nvm: device not found\n");
1156 nvm_setup_nvm_sb_info(&info
);
1158 strncpy(info
.mmtype
, init
->mmtype
, NVM_MMTYPE_LEN
);
1159 info
.fs_ppa
.ppa
= -1;
1161 if (dev
->identity
.cap
& NVM_ID_DCAP_BBLKMGMT
) {
1162 ret
= nvm_init_sysblock(dev
, &info
);
1167 memcpy(&dev
->sb
, &info
, sizeof(struct nvm_sb_info
));
1169 down_write(&nvm_lock
);
1170 dev
->mt
= nvm_init_mgr(dev
);
1171 up_write(&nvm_lock
);
1176 static long nvm_ioctl_dev_init(struct file
*file
, void __user
*arg
)
1178 struct nvm_ioctl_dev_init init
;
1180 if (!capable(CAP_SYS_ADMIN
))
1183 if (copy_from_user(&init
, arg
, sizeof(struct nvm_ioctl_dev_init
)))
1186 if (init
.flags
!= 0) {
1187 pr_err("nvm: no flags supported\n");
1191 init
.dev
[DISK_NAME_LEN
- 1] = '\0';
1193 return __nvm_ioctl_dev_init(&init
);
1196 static long nvm_ioctl_dev_factory(struct file
*file
, void __user
*arg
)
1198 struct nvm_ioctl_dev_factory fact
;
1199 struct nvm_dev
*dev
;
1201 if (!capable(CAP_SYS_ADMIN
))
1204 if (copy_from_user(&fact
, arg
, sizeof(struct nvm_ioctl_dev_factory
)))
1207 fact
.dev
[DISK_NAME_LEN
- 1] = '\0';
1209 if (fact
.flags
& ~(NVM_FACTORY_NR_BITS
- 1))
1212 down_write(&nvm_lock
);
1213 dev
= nvm_find_nvm_dev(fact
.dev
);
1214 up_write(&nvm_lock
);
1216 pr_err("nvm: device not found\n");
1221 dev
->mt
->unregister_mgr(dev
);
1225 if (dev
->identity
.cap
& NVM_ID_DCAP_BBLKMGMT
)
1226 return nvm_dev_factory(dev
, fact
.flags
);
1231 static long nvm_ctl_ioctl(struct file
*file
, uint cmd
, unsigned long arg
)
1233 void __user
*argp
= (void __user
*)arg
;
1237 return nvm_ioctl_info(file
, argp
);
1238 case NVM_GET_DEVICES
:
1239 return nvm_ioctl_get_devices(file
, argp
);
1240 case NVM_DEV_CREATE
:
1241 return nvm_ioctl_dev_create(file
, argp
);
1242 case NVM_DEV_REMOVE
:
1243 return nvm_ioctl_dev_remove(file
, argp
);
1245 return nvm_ioctl_dev_init(file
, argp
);
1246 case NVM_DEV_FACTORY
:
1247 return nvm_ioctl_dev_factory(file
, argp
);
1252 static const struct file_operations _ctl_fops
= {
1253 .open
= nonseekable_open
,
1254 .unlocked_ioctl
= nvm_ctl_ioctl
,
1255 .owner
= THIS_MODULE
,
1256 .llseek
= noop_llseek
,
1259 static struct miscdevice _nvm_misc
= {
1260 .minor
= MISC_DYNAMIC_MINOR
,
1262 .nodename
= "lightnvm/control",
1266 MODULE_ALIAS_MISCDEV(MISC_DYNAMIC_MINOR
);
1268 static int __init
nvm_mod_init(void)
1272 ret
= misc_register(&_nvm_misc
);
1274 pr_err("nvm: misc_register failed for control device");
1279 static void __exit
nvm_mod_exit(void)
1281 misc_deregister(&_nvm_misc
);
1284 MODULE_AUTHOR("Matias Bjorling <m@bjorling.me>");
1285 MODULE_LICENSE("GPL v2");
1286 MODULE_VERSION("0.1");
1287 module_init(nvm_mod_init
);
1288 module_exit(nvm_mod_exit
);