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_targets
);
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_targets
, list
)
43 if (!strcmp(name
, tt
->name
))
49 int nvm_register_target(struct nvm_tgt_type
*tt
)
53 down_write(&nvm_lock
);
54 if (nvm_find_target_type(tt
->name
))
57 list_add(&tt
->list
, &nvm_targets
);
62 EXPORT_SYMBOL(nvm_register_target
);
64 void nvm_unregister_target(struct nvm_tgt_type
*tt
)
69 down_write(&nvm_lock
);
73 EXPORT_SYMBOL(nvm_unregister_target
);
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
= (1 << 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 ppa_addr
*ppa
, int nr_ppas
,
326 int opcode
, int flags
, void *buf
, int len
)
328 DECLARE_COMPLETION_ONSTACK(wait
);
332 unsigned long hang_check
;
334 bio
= bio_map_kern(dev
->q
, buf
, len
, GFP_KERNEL
);
335 if (IS_ERR_OR_NULL(bio
))
338 memset(&rqd
, 0, sizeof(struct nvm_rq
));
339 ret
= nvm_set_rqd_ppalist(dev
, &rqd
, ppa
, nr_ppas
);
349 rqd
.end_io
= nvm_end_io_sync
;
351 nvm_generic_to_addr_mode(dev
, &rqd
);
353 ret
= dev
->ops
->submit_io(dev
, &rqd
);
355 /* Prevent hang_check timer from firing at us during very long I/O */
356 hang_check
= sysctl_hung_task_timeout_secs
;
358 while (!wait_for_completion_io_timeout(&wait
, hang_check
* (HZ
/2)));
360 wait_for_completion_io(&wait
);
362 nvm_free_rqd_ppalist(dev
, &rqd
);
366 EXPORT_SYMBOL(nvm_submit_ppa
);
368 static int nvm_init_slc_tbl(struct nvm_dev
*dev
, struct nvm_id_group
*grp
)
372 dev
->lps_per_blk
= dev
->pgs_per_blk
;
373 dev
->lptbl
= kcalloc(dev
->lps_per_blk
, sizeof(int), GFP_KERNEL
);
377 /* Just a linear array */
378 for (i
= 0; i
< dev
->lps_per_blk
; i
++)
384 static int nvm_init_mlc_tbl(struct nvm_dev
*dev
, struct nvm_id_group
*grp
)
387 struct nvm_id_lp_mlc
*mlc
= &grp
->lptbl
.mlc
;
392 dev
->lps_per_blk
= mlc
->num_pairs
;
393 dev
->lptbl
= kcalloc(dev
->lps_per_blk
, sizeof(int), GFP_KERNEL
);
397 /* The lower page table encoding consists of a list of bytes, where each
398 * has a lower and an upper half. The first half byte maintains the
399 * increment value and every value after is an offset added to the
400 * previous incrementation value */
401 dev
->lptbl
[0] = mlc
->pairs
[0] & 0xF;
402 for (i
= 1; i
< dev
->lps_per_blk
; i
++) {
403 p
= mlc
->pairs
[i
>> 1];
404 if (i
& 0x1) /* upper */
405 dev
->lptbl
[i
] = dev
->lptbl
[i
- 1] + ((p
& 0xF0) >> 4);
407 dev
->lptbl
[i
] = dev
->lptbl
[i
- 1] + (p
& 0xF);
413 static int nvm_core_init(struct nvm_dev
*dev
)
415 struct nvm_id
*id
= &dev
->identity
;
416 struct nvm_id_group
*grp
= &id
->groups
[0];
419 dev
->nr_chnls
= grp
->num_ch
;
420 dev
->luns_per_chnl
= grp
->num_lun
;
421 dev
->pgs_per_blk
= grp
->num_pg
;
422 dev
->blks_per_lun
= grp
->num_blk
;
423 dev
->nr_planes
= grp
->num_pln
;
424 dev
->sec_size
= grp
->csecs
;
425 dev
->oob_size
= grp
->sos
;
426 dev
->sec_per_pg
= grp
->fpg_sz
/ grp
->csecs
;
427 dev
->mccap
= grp
->mccap
;
428 memcpy(&dev
->ppaf
, &id
->ppaf
, sizeof(struct nvm_addr_format
));
430 dev
->plane_mode
= NVM_PLANE_SINGLE
;
431 dev
->max_rq_size
= dev
->ops
->max_phys_sect
* dev
->sec_size
;
433 if (grp
->mtype
!= 0) {
434 pr_err("nvm: memory type not supported\n");
438 switch (grp
->fmtype
) {
439 case NVM_ID_FMTYPE_SLC
:
440 if (nvm_init_slc_tbl(dev
, grp
))
443 case NVM_ID_FMTYPE_MLC
:
444 if (nvm_init_mlc_tbl(dev
, grp
))
448 pr_err("nvm: flash type not supported\n");
452 if (!dev
->lps_per_blk
)
453 pr_info("nvm: lower page programming table missing\n");
455 if (grp
->mpos
& 0x020202)
456 dev
->plane_mode
= NVM_PLANE_DOUBLE
;
457 if (grp
->mpos
& 0x040404)
458 dev
->plane_mode
= NVM_PLANE_QUAD
;
460 /* calculated values */
461 dev
->sec_per_pl
= dev
->sec_per_pg
* dev
->nr_planes
;
462 dev
->sec_per_blk
= dev
->sec_per_pl
* dev
->pgs_per_blk
;
463 dev
->sec_per_lun
= dev
->sec_per_blk
* dev
->blks_per_lun
;
464 dev
->nr_luns
= dev
->luns_per_chnl
* dev
->nr_chnls
;
466 dev
->total_blocks
= dev
->nr_planes
*
470 dev
->total_pages
= dev
->total_blocks
* dev
->pgs_per_blk
;
471 INIT_LIST_HEAD(&dev
->online_targets
);
472 mutex_init(&dev
->mlock
);
477 static void nvm_free(struct nvm_dev
*dev
)
483 dev
->mt
->unregister_mgr(dev
);
488 static int nvm_init(struct nvm_dev
*dev
)
492 if (!dev
->q
|| !dev
->ops
)
495 if (dev
->ops
->identity(dev
, &dev
->identity
)) {
496 pr_err("nvm: device could not be identified\n");
500 pr_debug("nvm: ver:%x nvm_vendor:%x groups:%u\n",
501 dev
->identity
.ver_id
, dev
->identity
.vmnt
,
502 dev
->identity
.cgrps
);
504 if (dev
->identity
.ver_id
!= 1) {
505 pr_err("nvm: device not supported by kernel.");
509 if (dev
->identity
.cgrps
!= 1) {
510 pr_err("nvm: only one group configuration supported.");
514 ret
= nvm_core_init(dev
);
516 pr_err("nvm: could not initialize core structures.\n");
520 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n",
521 dev
->name
, dev
->sec_per_pg
, dev
->nr_planes
,
522 dev
->pgs_per_blk
, dev
->blks_per_lun
, dev
->nr_luns
,
526 pr_err("nvm: failed to initialize nvm\n");
530 static void nvm_exit(struct nvm_dev
*dev
)
532 if (dev
->ppalist_pool
)
533 dev
->ops
->destroy_dma_pool(dev
->ppalist_pool
);
536 pr_info("nvm: successfully unloaded\n");
539 int nvm_register(struct request_queue
*q
, char *disk_name
,
540 struct nvm_dev_ops
*ops
)
548 dev
= kzalloc(sizeof(struct nvm_dev
), GFP_KERNEL
);
554 strncpy(dev
->name
, disk_name
, DISK_NAME_LEN
);
560 if (dev
->ops
->max_phys_sect
> 256) {
561 pr_info("nvm: max sectors supported is 256.\n");
566 if (dev
->ops
->max_phys_sect
> 1) {
567 dev
->ppalist_pool
= dev
->ops
->create_dma_pool(dev
, "ppalist");
568 if (!dev
->ppalist_pool
) {
569 pr_err("nvm: could not create ppa pool\n");
575 ret
= nvm_get_sysblock(dev
, &dev
->sb
);
577 pr_err("nvm: device not initialized.\n");
579 pr_err("nvm: err (%d) on device initialization\n", ret
);
581 /* register device with a supported media manager */
582 down_write(&nvm_lock
);
584 dev
->mt
= nvm_init_mgr(dev
);
585 list_add(&dev
->devices
, &nvm_devices
);
593 EXPORT_SYMBOL(nvm_register
);
595 void nvm_unregister(char *disk_name
)
599 down_write(&nvm_lock
);
600 dev
= nvm_find_nvm_dev(disk_name
);
602 pr_err("nvm: could not find device %s to unregister\n",
608 list_del(&dev
->devices
);
614 EXPORT_SYMBOL(nvm_unregister
);
616 static const struct block_device_operations nvm_fops
= {
617 .owner
= THIS_MODULE
,
620 static int nvm_create_target(struct nvm_dev
*dev
,
621 struct nvm_ioctl_create
*create
)
623 struct nvm_ioctl_create_simple
*s
= &create
->conf
.s
;
624 struct request_queue
*tqueue
;
625 struct gendisk
*tdisk
;
626 struct nvm_tgt_type
*tt
;
627 struct nvm_target
*t
;
631 pr_info("nvm: device has no media manager registered.\n");
635 down_write(&nvm_lock
);
636 tt
= nvm_find_target_type(create
->tgttype
);
638 pr_err("nvm: target type %s not found\n", create
->tgttype
);
643 list_for_each_entry(t
, &dev
->online_targets
, list
) {
644 if (!strcmp(create
->tgtname
, t
->disk
->disk_name
)) {
645 pr_err("nvm: target name already exists.\n");
652 t
= kmalloc(sizeof(struct nvm_target
), GFP_KERNEL
);
656 tqueue
= blk_alloc_queue_node(GFP_KERNEL
, dev
->q
->node
);
659 blk_queue_make_request(tqueue
, tt
->make_rq
);
661 tdisk
= alloc_disk(0);
665 sprintf(tdisk
->disk_name
, "%s", create
->tgtname
);
666 tdisk
->flags
= GENHD_FL_EXT_DEVT
;
668 tdisk
->first_minor
= 0;
669 tdisk
->fops
= &nvm_fops
;
670 tdisk
->queue
= tqueue
;
672 targetdata
= tt
->init(dev
, tdisk
, s
->lun_begin
, s
->lun_end
);
673 if (IS_ERR(targetdata
))
676 tdisk
->private_data
= targetdata
;
677 tqueue
->queuedata
= targetdata
;
679 blk_queue_max_hw_sectors(tqueue
, 8 * dev
->ops
->max_phys_sect
);
681 set_capacity(tdisk
, tt
->capacity(targetdata
));
687 down_write(&nvm_lock
);
688 list_add_tail(&t
->list
, &dev
->online_targets
);
695 blk_cleanup_queue(tqueue
);
701 static void nvm_remove_target(struct nvm_target
*t
)
703 struct nvm_tgt_type
*tt
= t
->type
;
704 struct gendisk
*tdisk
= t
->disk
;
705 struct request_queue
*q
= tdisk
->queue
;
707 lockdep_assert_held(&nvm_lock
);
710 blk_cleanup_queue(q
);
713 tt
->exit(tdisk
->private_data
);
721 static int __nvm_configure_create(struct nvm_ioctl_create
*create
)
724 struct nvm_ioctl_create_simple
*s
;
726 down_write(&nvm_lock
);
727 dev
= nvm_find_nvm_dev(create
->dev
);
730 pr_err("nvm: device not found\n");
734 if (create
->conf
.type
!= NVM_CONFIG_TYPE_SIMPLE
) {
735 pr_err("nvm: config type not valid\n");
740 if (s
->lun_begin
> s
->lun_end
|| s
->lun_end
> dev
->nr_luns
) {
741 pr_err("nvm: lun out of bound (%u:%u > %u)\n",
742 s
->lun_begin
, s
->lun_end
, dev
->nr_luns
);
746 return nvm_create_target(dev
, create
);
749 static int __nvm_configure_remove(struct nvm_ioctl_remove
*remove
)
751 struct nvm_target
*t
= NULL
;
755 down_write(&nvm_lock
);
756 list_for_each_entry(dev
, &nvm_devices
, devices
)
757 list_for_each_entry(t
, &dev
->online_targets
, list
) {
758 if (!strcmp(remove
->tgtname
, t
->disk
->disk_name
)) {
759 nvm_remove_target(t
);
767 pr_err("nvm: target \"%s\" doesn't exist.\n", remove
->tgtname
);
774 #ifdef CONFIG_NVM_DEBUG
775 static int nvm_configure_show(const char *val
)
778 char opcode
, devname
[DISK_NAME_LEN
];
781 ret
= sscanf(val
, "%c %32s", &opcode
, devname
);
783 pr_err("nvm: invalid command. Use \"opcode devicename\".\n");
787 down_write(&nvm_lock
);
788 dev
= nvm_find_nvm_dev(devname
);
791 pr_err("nvm: device not found\n");
798 dev
->mt
->lun_info_print(dev
);
803 static int nvm_configure_remove(const char *val
)
805 struct nvm_ioctl_remove remove
;
809 ret
= sscanf(val
, "%c %256s", &opcode
, remove
.tgtname
);
811 pr_err("nvm: invalid command. Use \"d targetname\".\n");
817 return __nvm_configure_remove(&remove
);
820 static int nvm_configure_create(const char *val
)
822 struct nvm_ioctl_create create
;
824 int lun_begin
, lun_end
, ret
;
826 ret
= sscanf(val
, "%c %256s %256s %48s %u:%u", &opcode
, create
.dev
,
827 create
.tgtname
, create
.tgttype
,
828 &lun_begin
, &lun_end
);
830 pr_err("nvm: invalid command. Use \"opcode device name tgttype lun_begin:lun_end\".\n");
835 create
.conf
.type
= NVM_CONFIG_TYPE_SIMPLE
;
836 create
.conf
.s
.lun_begin
= lun_begin
;
837 create
.conf
.s
.lun_end
= lun_end
;
839 return __nvm_configure_create(&create
);
843 /* Exposes administrative interface through /sys/module/lnvm/configure_by_str */
844 static int nvm_configure_by_str_event(const char *val
,
845 const struct kernel_param
*kp
)
850 ret
= sscanf(val
, "%c", &opcode
);
852 pr_err("nvm: string must have the format of \"cmd ...\"\n");
858 return nvm_configure_create(val
);
860 return nvm_configure_remove(val
);
862 return nvm_configure_show(val
);
864 pr_err("nvm: invalid command\n");
871 static int nvm_configure_get(char *buf
, const struct kernel_param
*kp
)
874 char *buf_start
= buf
;
877 buf
+= sprintf(buf
, "available devices:\n");
878 down_write(&nvm_lock
);
879 list_for_each_entry(dev
, &nvm_devices
, devices
) {
880 if (sz
> 4095 - DISK_NAME_LEN
)
882 buf
+= sprintf(buf
, " %32s\n", dev
->name
);
886 return buf
- buf_start
- 1;
889 static const struct kernel_param_ops nvm_configure_by_str_event_param_ops
= {
890 .set
= nvm_configure_by_str_event
,
891 .get
= nvm_configure_get
,
894 #undef MODULE_PARAM_PREFIX
895 #define MODULE_PARAM_PREFIX "lnvm."
897 module_param_cb(configure_debug
, &nvm_configure_by_str_event_param_ops
, NULL
,
900 #endif /* CONFIG_NVM_DEBUG */
902 static long nvm_ioctl_info(struct file
*file
, void __user
*arg
)
904 struct nvm_ioctl_info
*info
;
905 struct nvm_tgt_type
*tt
;
908 if (!capable(CAP_SYS_ADMIN
))
911 info
= memdup_user(arg
, sizeof(struct nvm_ioctl_info
));
915 info
->version
[0] = NVM_VERSION_MAJOR
;
916 info
->version
[1] = NVM_VERSION_MINOR
;
917 info
->version
[2] = NVM_VERSION_PATCH
;
919 down_write(&nvm_lock
);
920 list_for_each_entry(tt
, &nvm_targets
, list
) {
921 struct nvm_ioctl_info_tgt
*tgt
= &info
->tgts
[tgt_iter
];
923 tgt
->version
[0] = tt
->version
[0];
924 tgt
->version
[1] = tt
->version
[1];
925 tgt
->version
[2] = tt
->version
[2];
926 strncpy(tgt
->tgtname
, tt
->name
, NVM_TTYPE_NAME_MAX
);
931 info
->tgtsize
= tgt_iter
;
934 if (copy_to_user(arg
, info
, sizeof(struct nvm_ioctl_info
))) {
943 static long nvm_ioctl_get_devices(struct file
*file
, void __user
*arg
)
945 struct nvm_ioctl_get_devices
*devices
;
949 if (!capable(CAP_SYS_ADMIN
))
952 devices
= kzalloc(sizeof(struct nvm_ioctl_get_devices
), GFP_KERNEL
);
956 down_write(&nvm_lock
);
957 list_for_each_entry(dev
, &nvm_devices
, devices
) {
958 struct nvm_ioctl_device_info
*info
= &devices
->info
[i
];
960 sprintf(info
->devname
, "%s", dev
->name
);
962 info
->bmversion
[0] = dev
->mt
->version
[0];
963 info
->bmversion
[1] = dev
->mt
->version
[1];
964 info
->bmversion
[2] = dev
->mt
->version
[2];
965 sprintf(info
->bmname
, "%s", dev
->mt
->name
);
967 sprintf(info
->bmname
, "none");
972 pr_err("nvm: max 31 devices can be reported.\n");
978 devices
->nr_devices
= i
;
980 if (copy_to_user(arg
, devices
,
981 sizeof(struct nvm_ioctl_get_devices
))) {
990 static long nvm_ioctl_dev_create(struct file
*file
, void __user
*arg
)
992 struct nvm_ioctl_create create
;
994 if (!capable(CAP_SYS_ADMIN
))
997 if (copy_from_user(&create
, arg
, sizeof(struct nvm_ioctl_create
)))
1000 create
.dev
[DISK_NAME_LEN
- 1] = '\0';
1001 create
.tgttype
[NVM_TTYPE_NAME_MAX
- 1] = '\0';
1002 create
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
1004 if (create
.flags
!= 0) {
1005 pr_err("nvm: no flags supported\n");
1009 return __nvm_configure_create(&create
);
1012 static long nvm_ioctl_dev_remove(struct file
*file
, void __user
*arg
)
1014 struct nvm_ioctl_remove remove
;
1016 if (!capable(CAP_SYS_ADMIN
))
1019 if (copy_from_user(&remove
, arg
, sizeof(struct nvm_ioctl_remove
)))
1022 remove
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
1024 if (remove
.flags
!= 0) {
1025 pr_err("nvm: no flags supported\n");
1029 return __nvm_configure_remove(&remove
);
1032 static void nvm_setup_nvm_sb_info(struct nvm_sb_info
*info
)
1035 info
->erase_cnt
= 0;
1039 static long __nvm_ioctl_dev_init(struct nvm_ioctl_dev_init
*init
)
1041 struct nvm_dev
*dev
;
1042 struct nvm_sb_info info
;
1045 down_write(&nvm_lock
);
1046 dev
= nvm_find_nvm_dev(init
->dev
);
1047 up_write(&nvm_lock
);
1049 pr_err("nvm: device not found\n");
1053 nvm_setup_nvm_sb_info(&info
);
1055 strncpy(info
.mmtype
, init
->mmtype
, NVM_MMTYPE_LEN
);
1056 info
.fs_ppa
.ppa
= -1;
1058 ret
= nvm_init_sysblock(dev
, &info
);
1062 memcpy(&dev
->sb
, &info
, sizeof(struct nvm_sb_info
));
1064 down_write(&nvm_lock
);
1065 dev
->mt
= nvm_init_mgr(dev
);
1066 up_write(&nvm_lock
);
1071 static long nvm_ioctl_dev_init(struct file
*file
, void __user
*arg
)
1073 struct nvm_ioctl_dev_init init
;
1075 if (!capable(CAP_SYS_ADMIN
))
1078 if (copy_from_user(&init
, arg
, sizeof(struct nvm_ioctl_dev_init
)))
1081 if (init
.flags
!= 0) {
1082 pr_err("nvm: no flags supported\n");
1086 init
.dev
[DISK_NAME_LEN
- 1] = '\0';
1088 return __nvm_ioctl_dev_init(&init
);
1091 static long nvm_ioctl_dev_factory(struct file
*file
, void __user
*arg
)
1093 struct nvm_ioctl_dev_factory fact
;
1094 struct nvm_dev
*dev
;
1096 if (!capable(CAP_SYS_ADMIN
))
1099 if (copy_from_user(&fact
, arg
, sizeof(struct nvm_ioctl_dev_factory
)))
1102 fact
.dev
[DISK_NAME_LEN
- 1] = '\0';
1104 if (fact
.flags
& ~(NVM_FACTORY_NR_BITS
- 1))
1107 down_write(&nvm_lock
);
1108 dev
= nvm_find_nvm_dev(fact
.dev
);
1109 up_write(&nvm_lock
);
1111 pr_err("nvm: device not found\n");
1116 dev
->mt
->unregister_mgr(dev
);
1120 return nvm_dev_factory(dev
, fact
.flags
);
1123 static long nvm_ctl_ioctl(struct file
*file
, uint cmd
, unsigned long arg
)
1125 void __user
*argp
= (void __user
*)arg
;
1129 return nvm_ioctl_info(file
, argp
);
1130 case NVM_GET_DEVICES
:
1131 return nvm_ioctl_get_devices(file
, argp
);
1132 case NVM_DEV_CREATE
:
1133 return nvm_ioctl_dev_create(file
, argp
);
1134 case NVM_DEV_REMOVE
:
1135 return nvm_ioctl_dev_remove(file
, argp
);
1137 return nvm_ioctl_dev_init(file
, argp
);
1138 case NVM_DEV_FACTORY
:
1139 return nvm_ioctl_dev_factory(file
, argp
);
1144 static const struct file_operations _ctl_fops
= {
1145 .open
= nonseekable_open
,
1146 .unlocked_ioctl
= nvm_ctl_ioctl
,
1147 .owner
= THIS_MODULE
,
1148 .llseek
= noop_llseek
,
1151 static struct miscdevice _nvm_misc
= {
1152 .minor
= MISC_DYNAMIC_MINOR
,
1154 .nodename
= "lightnvm/control",
1158 MODULE_ALIAS_MISCDEV(MISC_DYNAMIC_MINOR
);
1160 static int __init
nvm_mod_init(void)
1164 ret
= misc_register(&_nvm_misc
);
1166 pr_err("nvm: misc_register failed for control device");
1171 static void __exit
nvm_mod_exit(void)
1173 misc_deregister(&_nvm_misc
);
1176 MODULE_AUTHOR("Matias Bjorling <m@bjorling.me>");
1177 MODULE_LICENSE("GPL v2");
1178 MODULE_VERSION("0.1");
1179 module_init(nvm_mod_init
);
1180 module_exit(nvm_mod_exit
);