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 <uapi/linux/lightnvm.h>
32 static LIST_HEAD(nvm_targets
);
33 static LIST_HEAD(nvm_mgrs
);
34 static LIST_HEAD(nvm_devices
);
35 static DECLARE_RWSEM(nvm_lock
);
37 static struct nvm_tgt_type
*nvm_find_target_type(const char *name
)
39 struct nvm_tgt_type
*tt
;
41 list_for_each_entry(tt
, &nvm_targets
, list
)
42 if (!strcmp(name
, tt
->name
))
48 int nvm_register_target(struct nvm_tgt_type
*tt
)
52 down_write(&nvm_lock
);
53 if (nvm_find_target_type(tt
->name
))
56 list_add(&tt
->list
, &nvm_targets
);
61 EXPORT_SYMBOL(nvm_register_target
);
63 void nvm_unregister_target(struct nvm_tgt_type
*tt
)
68 down_write(&nvm_lock
);
72 EXPORT_SYMBOL(nvm_unregister_target
);
74 void *nvm_dev_dma_alloc(struct nvm_dev
*dev
, gfp_t mem_flags
,
75 dma_addr_t
*dma_handler
)
77 return dev
->ops
->dev_dma_alloc(dev
->q
, dev
->ppalist_pool
, mem_flags
,
80 EXPORT_SYMBOL(nvm_dev_dma_alloc
);
82 void nvm_dev_dma_free(struct nvm_dev
*dev
, void *ppa_list
,
83 dma_addr_t dma_handler
)
85 dev
->ops
->dev_dma_free(dev
->ppalist_pool
, ppa_list
, dma_handler
);
87 EXPORT_SYMBOL(nvm_dev_dma_free
);
89 static struct nvmm_type
*nvm_find_mgr_type(const char *name
)
93 list_for_each_entry(mt
, &nvm_mgrs
, list
)
94 if (!strcmp(name
, mt
->name
))
100 int nvm_register_mgr(struct nvmm_type
*mt
)
104 down_write(&nvm_lock
);
105 if (nvm_find_mgr_type(mt
->name
))
108 list_add(&mt
->list
, &nvm_mgrs
);
113 EXPORT_SYMBOL(nvm_register_mgr
);
115 void nvm_unregister_mgr(struct nvmm_type
*mt
)
120 down_write(&nvm_lock
);
124 EXPORT_SYMBOL(nvm_unregister_mgr
);
126 static struct nvm_dev
*nvm_find_nvm_dev(const char *name
)
130 list_for_each_entry(dev
, &nvm_devices
, devices
)
131 if (!strcmp(name
, dev
->name
))
137 struct nvm_block
*nvm_get_blk(struct nvm_dev
*dev
, struct nvm_lun
*lun
,
140 return dev
->mt
->get_blk(dev
, lun
, flags
);
142 EXPORT_SYMBOL(nvm_get_blk
);
144 /* Assumes that all valid pages have already been moved on release to bm */
145 void nvm_put_blk(struct nvm_dev
*dev
, struct nvm_block
*blk
)
147 return dev
->mt
->put_blk(dev
, blk
);
149 EXPORT_SYMBOL(nvm_put_blk
);
151 int nvm_submit_io(struct nvm_dev
*dev
, struct nvm_rq
*rqd
)
153 return dev
->mt
->submit_io(dev
, rqd
);
155 EXPORT_SYMBOL(nvm_submit_io
);
157 int nvm_erase_blk(struct nvm_dev
*dev
, struct nvm_block
*blk
)
159 return dev
->mt
->erase_blk(dev
, blk
, 0);
161 EXPORT_SYMBOL(nvm_erase_blk
);
163 static void nvm_core_free(struct nvm_dev
*dev
)
168 static int nvm_core_init(struct nvm_dev
*dev
)
170 struct nvm_id
*id
= &dev
->identity
;
171 struct nvm_id_group
*grp
= &id
->groups
[0];
174 dev
->nr_chnls
= grp
->num_ch
;
175 dev
->luns_per_chnl
= grp
->num_lun
;
176 dev
->pgs_per_blk
= grp
->num_pg
;
177 dev
->blks_per_lun
= grp
->num_blk
;
178 dev
->nr_planes
= grp
->num_pln
;
179 dev
->sec_size
= grp
->csecs
;
180 dev
->oob_size
= grp
->sos
;
181 dev
->sec_per_pg
= grp
->fpg_sz
/ grp
->csecs
;
182 dev
->addr_mode
= id
->ppat
;
183 dev
->addr_format
= id
->ppaf
;
185 dev
->plane_mode
= NVM_PLANE_SINGLE
;
186 dev
->max_rq_size
= dev
->ops
->max_phys_sect
* dev
->sec_size
;
188 if (grp
->mtype
!= 0) {
189 pr_err("nvm: memory type not supported\n");
193 if (grp
->fmtype
!= 0 && grp
->fmtype
!= 1) {
194 pr_err("nvm: flash type not supported\n");
198 if (grp
->mpos
& 0x020202)
199 dev
->plane_mode
= NVM_PLANE_DOUBLE
;
200 if (grp
->mpos
& 0x040404)
201 dev
->plane_mode
= NVM_PLANE_QUAD
;
203 /* calculated values */
204 dev
->sec_per_pl
= dev
->sec_per_pg
* dev
->nr_planes
;
205 dev
->sec_per_blk
= dev
->sec_per_pl
* dev
->pgs_per_blk
;
206 dev
->sec_per_lun
= dev
->sec_per_blk
* dev
->blks_per_lun
;
207 dev
->nr_luns
= dev
->luns_per_chnl
* dev
->nr_chnls
;
209 dev
->total_blocks
= dev
->nr_planes
*
213 dev
->total_pages
= dev
->total_blocks
* dev
->pgs_per_blk
;
214 INIT_LIST_HEAD(&dev
->online_targets
);
219 static void nvm_free(struct nvm_dev
*dev
)
225 dev
->mt
->unregister_mgr(dev
);
230 static int nvm_init(struct nvm_dev
*dev
)
232 struct nvmm_type
*mt
;
235 if (!dev
->q
|| !dev
->ops
)
238 if (dev
->ops
->identity(dev
->q
, &dev
->identity
)) {
239 pr_err("nvm: device could not be identified\n");
244 pr_debug("nvm: ver:%x nvm_vendor:%x groups:%u\n",
245 dev
->identity
.ver_id
, dev
->identity
.vmnt
,
246 dev
->identity
.cgrps
);
248 if (dev
->identity
.ver_id
!= 1) {
249 pr_err("nvm: device not supported by kernel.");
253 if (dev
->identity
.cgrps
!= 1) {
254 pr_err("nvm: only one group configuration supported.");
258 ret
= nvm_core_init(dev
);
260 pr_err("nvm: could not initialize core structures.\n");
264 /* register with device with a supported manager */
265 list_for_each_entry(mt
, &nvm_mgrs
, list
) {
266 ret
= mt
->register_mgr(dev
);
268 goto err
; /* initialization failed */
271 break; /* successfully initialized */
276 pr_info("nvm: no compatible manager found.\n");
280 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n",
281 dev
->name
, dev
->sec_per_pg
, dev
->nr_planes
,
282 dev
->pgs_per_blk
, dev
->blks_per_lun
, dev
->nr_luns
,
287 pr_err("nvm: failed to initialize nvm\n");
291 static void nvm_exit(struct nvm_dev
*dev
)
293 if (dev
->ppalist_pool
)
294 dev
->ops
->destroy_dma_pool(dev
->ppalist_pool
);
297 pr_info("nvm: successfully unloaded\n");
300 int nvm_register(struct request_queue
*q
, char *disk_name
,
301 struct nvm_dev_ops
*ops
)
309 dev
= kzalloc(sizeof(struct nvm_dev
), GFP_KERNEL
);
315 strncpy(dev
->name
, disk_name
, DISK_NAME_LEN
);
321 if (dev
->ops
->max_phys_sect
> 1) {
322 dev
->ppalist_pool
= dev
->ops
->create_dma_pool(dev
->q
,
324 if (!dev
->ppalist_pool
) {
325 pr_err("nvm: could not create ppa pool\n");
328 } else if (dev
->ops
->max_phys_sect
> 256) {
329 pr_info("nvm: max sectors supported is 256.\n");
333 down_write(&nvm_lock
);
334 list_add(&dev
->devices
, &nvm_devices
);
342 EXPORT_SYMBOL(nvm_register
);
344 void nvm_unregister(char *disk_name
)
346 struct nvm_dev
*dev
= nvm_find_nvm_dev(disk_name
);
349 pr_err("nvm: could not find device %s to unregister\n",
356 down_write(&nvm_lock
);
357 list_del(&dev
->devices
);
360 EXPORT_SYMBOL(nvm_unregister
);
362 static const struct block_device_operations nvm_fops
= {
363 .owner
= THIS_MODULE
,
366 static int nvm_create_target(struct nvm_dev
*dev
,
367 struct nvm_ioctl_create
*create
)
369 struct nvm_ioctl_create_simple
*s
= &create
->conf
.s
;
370 struct request_queue
*tqueue
;
371 struct nvmm_type
*mt
;
372 struct gendisk
*tdisk
;
373 struct nvm_tgt_type
*tt
;
374 struct nvm_target
*t
;
379 /* register with device with a supported NVM manager */
380 list_for_each_entry(mt
, &nvm_mgrs
, list
) {
381 ret
= mt
->register_mgr(dev
);
383 return ret
; /* initialization failed */
386 break; /* successfully initialized */
391 pr_info("nvm: no compatible nvm manager found.\n");
396 tt
= nvm_find_target_type(create
->tgttype
);
398 pr_err("nvm: target type %s not found\n", create
->tgttype
);
402 down_write(&nvm_lock
);
403 list_for_each_entry(t
, &dev
->online_targets
, list
) {
404 if (!strcmp(create
->tgtname
, t
->disk
->disk_name
)) {
405 pr_err("nvm: target name already exists.\n");
412 t
= kmalloc(sizeof(struct nvm_target
), GFP_KERNEL
);
416 tqueue
= blk_alloc_queue_node(GFP_KERNEL
, dev
->q
->node
);
419 blk_queue_make_request(tqueue
, tt
->make_rq
);
421 tdisk
= alloc_disk(0);
425 sprintf(tdisk
->disk_name
, "%s", create
->tgtname
);
426 tdisk
->flags
= GENHD_FL_EXT_DEVT
;
428 tdisk
->first_minor
= 0;
429 tdisk
->fops
= &nvm_fops
;
430 tdisk
->queue
= tqueue
;
432 targetdata
= tt
->init(dev
, tdisk
, s
->lun_begin
, s
->lun_end
);
433 if (IS_ERR(targetdata
))
436 tdisk
->private_data
= targetdata
;
437 tqueue
->queuedata
= targetdata
;
439 blk_queue_max_hw_sectors(tqueue
, 8 * dev
->ops
->max_phys_sect
);
441 set_capacity(tdisk
, tt
->capacity(targetdata
));
447 down_write(&nvm_lock
);
448 list_add_tail(&t
->list
, &dev
->online_targets
);
455 blk_cleanup_queue(tqueue
);
461 static void nvm_remove_target(struct nvm_target
*t
)
463 struct nvm_tgt_type
*tt
= t
->type
;
464 struct gendisk
*tdisk
= t
->disk
;
465 struct request_queue
*q
= tdisk
->queue
;
467 lockdep_assert_held(&nvm_lock
);
471 tt
->exit(tdisk
->private_data
);
473 blk_cleanup_queue(q
);
481 static int __nvm_configure_create(struct nvm_ioctl_create
*create
)
484 struct nvm_ioctl_create_simple
*s
;
486 dev
= nvm_find_nvm_dev(create
->dev
);
488 pr_err("nvm: device not found\n");
492 if (create
->conf
.type
!= NVM_CONFIG_TYPE_SIMPLE
) {
493 pr_err("nvm: config type not valid\n");
498 if (s
->lun_begin
> s
->lun_end
|| s
->lun_end
> dev
->nr_luns
) {
499 pr_err("nvm: lun out of bound (%u:%u > %u)\n",
500 s
->lun_begin
, s
->lun_end
, dev
->nr_luns
);
504 return nvm_create_target(dev
, create
);
507 static int __nvm_configure_remove(struct nvm_ioctl_remove
*remove
)
509 struct nvm_target
*t
= NULL
;
513 down_write(&nvm_lock
);
514 list_for_each_entry(dev
, &nvm_devices
, devices
)
515 list_for_each_entry(t
, &dev
->online_targets
, list
) {
516 if (!strcmp(remove
->tgtname
, t
->disk
->disk_name
)) {
517 nvm_remove_target(t
);
525 pr_err("nvm: target \"%s\" doesn't exist.\n", remove
->tgtname
);
532 #ifdef CONFIG_NVM_DEBUG
533 static int nvm_configure_show(const char *val
)
536 char opcode
, devname
[DISK_NAME_LEN
];
539 ret
= sscanf(val
, "%c %32s", &opcode
, devname
);
541 pr_err("nvm: invalid command. Use \"opcode devicename\".\n");
545 dev
= nvm_find_nvm_dev(devname
);
547 pr_err("nvm: device not found\n");
554 dev
->mt
->free_blocks_print(dev
);
559 static int nvm_configure_remove(const char *val
)
561 struct nvm_ioctl_remove remove
;
565 ret
= sscanf(val
, "%c %256s", &opcode
, remove
.tgtname
);
567 pr_err("nvm: invalid command. Use \"d targetname\".\n");
573 return __nvm_configure_remove(&remove
);
576 static int nvm_configure_create(const char *val
)
578 struct nvm_ioctl_create create
;
580 int lun_begin
, lun_end
, ret
;
582 ret
= sscanf(val
, "%c %256s %256s %48s %u:%u", &opcode
, create
.dev
,
583 create
.tgtname
, create
.tgttype
,
584 &lun_begin
, &lun_end
);
586 pr_err("nvm: invalid command. Use \"opcode device name tgttype lun_begin:lun_end\".\n");
591 create
.conf
.type
= NVM_CONFIG_TYPE_SIMPLE
;
592 create
.conf
.s
.lun_begin
= lun_begin
;
593 create
.conf
.s
.lun_end
= lun_end
;
595 return __nvm_configure_create(&create
);
599 /* Exposes administrative interface through /sys/module/lnvm/configure_by_str */
600 static int nvm_configure_by_str_event(const char *val
,
601 const struct kernel_param
*kp
)
606 ret
= sscanf(val
, "%c", &opcode
);
608 pr_err("nvm: string must have the format of \"cmd ...\"\n");
614 return nvm_configure_create(val
);
616 return nvm_configure_remove(val
);
618 return nvm_configure_show(val
);
620 pr_err("nvm: invalid command\n");
627 static int nvm_configure_get(char *buf
, const struct kernel_param
*kp
)
630 char *buf_start
= buf
;
633 buf
+= sprintf(buf
, "available devices:\n");
634 down_write(&nvm_lock
);
635 list_for_each_entry(dev
, &nvm_devices
, devices
) {
636 if (sz
> 4095 - DISK_NAME_LEN
)
638 buf
+= sprintf(buf
, " %32s\n", dev
->name
);
642 return buf
- buf_start
- 1;
645 static const struct kernel_param_ops nvm_configure_by_str_event_param_ops
= {
646 .set
= nvm_configure_by_str_event
,
647 .get
= nvm_configure_get
,
650 #undef MODULE_PARAM_PREFIX
651 #define MODULE_PARAM_PREFIX "lnvm."
653 module_param_cb(configure_debug
, &nvm_configure_by_str_event_param_ops
, NULL
,
656 #endif /* CONFIG_NVM_DEBUG */
658 static long nvm_ioctl_info(struct file
*file
, void __user
*arg
)
660 struct nvm_ioctl_info
*info
;
661 struct nvm_tgt_type
*tt
;
664 if (!capable(CAP_SYS_ADMIN
))
667 info
= memdup_user(arg
, sizeof(struct nvm_ioctl_info
));
671 info
->version
[0] = NVM_VERSION_MAJOR
;
672 info
->version
[1] = NVM_VERSION_MINOR
;
673 info
->version
[2] = NVM_VERSION_PATCH
;
675 down_write(&nvm_lock
);
676 list_for_each_entry(tt
, &nvm_targets
, list
) {
677 struct nvm_ioctl_info_tgt
*tgt
= &info
->tgts
[tgt_iter
];
679 tgt
->version
[0] = tt
->version
[0];
680 tgt
->version
[1] = tt
->version
[1];
681 tgt
->version
[2] = tt
->version
[2];
682 strncpy(tgt
->tgtname
, tt
->name
, NVM_TTYPE_NAME_MAX
);
687 info
->tgtsize
= tgt_iter
;
690 if (copy_to_user(arg
, info
, sizeof(struct nvm_ioctl_info
)))
697 static long nvm_ioctl_get_devices(struct file
*file
, void __user
*arg
)
699 struct nvm_ioctl_get_devices
*devices
;
703 if (!capable(CAP_SYS_ADMIN
))
706 devices
= kzalloc(sizeof(struct nvm_ioctl_get_devices
), GFP_KERNEL
);
710 down_write(&nvm_lock
);
711 list_for_each_entry(dev
, &nvm_devices
, devices
) {
712 struct nvm_ioctl_device_info
*info
= &devices
->info
[i
];
714 sprintf(info
->devname
, "%s", dev
->name
);
716 info
->bmversion
[0] = dev
->mt
->version
[0];
717 info
->bmversion
[1] = dev
->mt
->version
[1];
718 info
->bmversion
[2] = dev
->mt
->version
[2];
719 sprintf(info
->bmname
, "%s", dev
->mt
->name
);
721 sprintf(info
->bmname
, "none");
726 pr_err("nvm: max 31 devices can be reported.\n");
732 devices
->nr_devices
= i
;
734 if (copy_to_user(arg
, devices
, sizeof(struct nvm_ioctl_get_devices
)))
741 static long nvm_ioctl_dev_create(struct file
*file
, void __user
*arg
)
743 struct nvm_ioctl_create create
;
745 if (!capable(CAP_SYS_ADMIN
))
748 if (copy_from_user(&create
, arg
, sizeof(struct nvm_ioctl_create
)))
751 create
.dev
[DISK_NAME_LEN
- 1] = '\0';
752 create
.tgttype
[NVM_TTYPE_NAME_MAX
- 1] = '\0';
753 create
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
755 if (create
.flags
!= 0) {
756 pr_err("nvm: no flags supported\n");
760 return __nvm_configure_create(&create
);
763 static long nvm_ioctl_dev_remove(struct file
*file
, void __user
*arg
)
765 struct nvm_ioctl_remove remove
;
767 if (!capable(CAP_SYS_ADMIN
))
770 if (copy_from_user(&remove
, arg
, sizeof(struct nvm_ioctl_remove
)))
773 remove
.tgtname
[DISK_NAME_LEN
- 1] = '\0';
775 if (remove
.flags
!= 0) {
776 pr_err("nvm: no flags supported\n");
780 return __nvm_configure_remove(&remove
);
783 static long nvm_ctl_ioctl(struct file
*file
, uint cmd
, unsigned long arg
)
785 void __user
*argp
= (void __user
*)arg
;
789 return nvm_ioctl_info(file
, argp
);
790 case NVM_GET_DEVICES
:
791 return nvm_ioctl_get_devices(file
, argp
);
793 return nvm_ioctl_dev_create(file
, argp
);
795 return nvm_ioctl_dev_remove(file
, argp
);
800 static const struct file_operations _ctl_fops
= {
801 .open
= nonseekable_open
,
802 .unlocked_ioctl
= nvm_ctl_ioctl
,
803 .owner
= THIS_MODULE
,
804 .llseek
= noop_llseek
,
807 static struct miscdevice _nvm_misc
= {
808 .minor
= MISC_DYNAMIC_MINOR
,
810 .nodename
= "lightnvm/control",
814 MODULE_ALIAS_MISCDEV(MISC_DYNAMIC_MINOR
);
816 static int __init
nvm_mod_init(void)
820 ret
= misc_register(&_nvm_misc
);
822 pr_err("nvm: misc_register failed for control device");
827 static void __exit
nvm_mod_exit(void)
829 misc_deregister(&_nvm_misc
);
832 MODULE_AUTHOR("Matias Bjorling <m@bjorling.me>");
833 MODULE_LICENSE("GPL v2");
834 MODULE_VERSION("0.1");
835 module_init(nvm_mod_init
);
836 module_exit(nvm_mod_exit
);