projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lightnvm: refactor rqd ppa list into set/free
[deliverable/linux.git] / drivers / lightnvm / core.c
CommitLineData
cd9e9808
MB		 1/*
2 * Copyright (C) 2015 IT University of Copenhagen. All rights reserved.
3 * Initial release: Matias Bjorling <m@bjorling.me>
4 *
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.
8 *
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.
13 *
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,
17 * USA.
18 *
19 */
20
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>
31
32static LIST_HEAD(nvm_targets);
33static LIST_HEAD(nvm_mgrs);
34static LIST_HEAD(nvm_devices);
35static DECLARE_RWSEM(nvm_lock);
36
37static struct nvm_tgt_type *nvm_find_target_type(const char *name)
38{
39 struct nvm_tgt_type *tt;
40
41 list_for_each_entry(tt, &nvm_targets, list)
42 if (!strcmp(name, tt->name))
43 return tt;
44
45 return NULL;
46}
47
48int nvm_register_target(struct nvm_tgt_type *tt)
49{
50 int ret = 0;
51
52 down_write(&nvm_lock);
53 if (nvm_find_target_type(tt->name))
54 ret = -EEXIST;
55 else
56 list_add(&tt->list, &nvm_targets);
57 up_write(&nvm_lock);
58
59 return ret;
60}
61EXPORT_SYMBOL(nvm_register_target);
62
63void nvm_unregister_target(struct nvm_tgt_type *tt)
64{
65 if (!tt)
66 return;
67
68 down_write(&nvm_lock);
69 list_del(&tt->list);
70 up_write(&nvm_lock);
71}
72EXPORT_SYMBOL(nvm_unregister_target);
73
74void *nvm_dev_dma_alloc(struct nvm_dev *dev, gfp_t mem_flags,
75 dma_addr_t *dma_handler)
76{
16f26c3a 77 return dev->ops->dev_dma_alloc(dev, dev->ppalist_pool, mem_flags,
cd9e9808
MB		 78 dma_handler);
79}
80EXPORT_SYMBOL(nvm_dev_dma_alloc);
81
82void nvm_dev_dma_free(struct nvm_dev *dev, void *ppa_list,
83 dma_addr_t dma_handler)
84{
85 dev->ops->dev_dma_free(dev->ppalist_pool, ppa_list, dma_handler);
86}
87EXPORT_SYMBOL(nvm_dev_dma_free);
88
89static struct nvmm_type *nvm_find_mgr_type(const char *name)
90{
91 struct nvmm_type *mt;
92
93 list_for_each_entry(mt, &nvm_mgrs, list)
94 if (!strcmp(name, mt->name))
95 return mt;
96
97 return NULL;
98}
99
762796bc
MB		 100struct 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
cd9e9808
MB		 120int nvm_register_mgr(struct nvmm_type *mt)
121{
762796bc 122 struct nvm_dev *dev;
cd9e9808
MB		 123 int ret = 0;
124
125 down_write(&nvm_lock);
762796bc 126 if (nvm_find_mgr_type(mt->name)) {
cd9e9808 127 ret = -EEXIST;
762796bc
MB		 128 goto finish;
129 } else {
cd9e9808 130 list_add(&mt->list, &nvm_mgrs);
762796bc
MB		 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 }
140finish:
cd9e9808
MB		 141 up_write(&nvm_lock);
142
143 return ret;
144}
145EXPORT_SYMBOL(nvm_register_mgr);
146
147void nvm_unregister_mgr(struct nvmm_type *mt)
148{
149 if (!mt)
150 return;
151
152 down_write(&nvm_lock);
153 list_del(&mt->list);
154 up_write(&nvm_lock);
155}
156EXPORT_SYMBOL(nvm_unregister_mgr);
157
158static struct nvm_dev *nvm_find_nvm_dev(const char *name)
159{
160 struct nvm_dev *dev;
161
162 list_for_each_entry(dev, &nvm_devices, devices)
163 if (!strcmp(name, dev->name))
164 return dev;
165
166 return NULL;
167}
168
169struct nvm_block *nvm_get_blk(struct nvm_dev *dev, struct nvm_lun *lun,
170 unsigned long flags)
171{
172 return dev->mt->get_blk(dev, lun, flags);
173}
174EXPORT_SYMBOL(nvm_get_blk);
175
176/* Assumes that all valid pages have already been moved on release to bm */
177void nvm_put_blk(struct nvm_dev *dev, struct nvm_block *blk)
178{
179 return dev->mt->put_blk(dev, blk);
180}
181EXPORT_SYMBOL(nvm_put_blk);
182
183int nvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd)
184{
185 return dev->mt->submit_io(dev, rqd);
186}
187EXPORT_SYMBOL(nvm_submit_io);
188
189int nvm_erase_blk(struct nvm_dev *dev, struct nvm_block *blk)
190{
191 return dev->mt->erase_blk(dev, blk, 0);
192}
193EXPORT_SYMBOL(nvm_erase_blk);
194
069368e9
MB		 195void nvm_addr_to_generic_mode(struct nvm_dev *dev, struct nvm_rq *rqd)
196{
197 int i;
198
199 if (rqd->nr_pages > 1) {
200 for (i = 0; i < rqd->nr_pages; i++)
201 rqd->ppa_list[i] = dev_to_generic_addr(dev,
202 rqd->ppa_list[i]);
203 } else {
204 rqd->ppa_addr = dev_to_generic_addr(dev, rqd->ppa_addr);
205 }
206}
207EXPORT_SYMBOL(nvm_addr_to_generic_mode);
208
209void nvm_generic_to_addr_mode(struct nvm_dev *dev, struct nvm_rq *rqd)
210{
211 int i;
212
213 if (rqd->nr_pages > 1) {
214 for (i = 0; i < rqd->nr_pages; i++)
215 rqd->ppa_list[i] = generic_to_dev_addr(dev,
216 rqd->ppa_list[i]);
217 } else {
218 rqd->ppa_addr = generic_to_dev_addr(dev, rqd->ppa_addr);
219 }
220}
221EXPORT_SYMBOL(nvm_generic_to_addr_mode);
222
abd805ec
MB		 223int nvm_set_rqd_ppalist(struct nvm_dev *dev, struct nvm_rq *rqd,
224 struct ppa_addr *ppas, int nr_ppas)
069368e9 225{
abd805ec
MB		 226 int i, plane_cnt, pl_idx;
227
228 if (dev->plane_mode == NVM_PLANE_SINGLE && nr_ppas == 1) {
229 rqd->nr_pages = 1;
230 rqd->ppa_addr = ppas[0];
069368e9 231
069368e9 232 return 0;
abd805ec 233 }
069368e9 234
abd805ec
MB		 235 plane_cnt = (1 << dev->plane_mode);
236 rqd->nr_pages = plane_cnt * nr_ppas;
069368e9 237
abd805ec
MB		 238 if (dev->ops->max_phys_sect < rqd->nr_pages)
239 return -EINVAL;
240
241 rqd->ppa_list = nvm_dev_dma_alloc(dev, GFP_KERNEL, &rqd->dma_ppa_list);
242 if (!rqd->ppa_list) {
243 pr_err("nvm: failed to allocate dma memory\n");
244 return -ENOMEM;
245 }
246
247 for (i = 0; i < nr_ppas; i++) {
069368e9 248 for (pl_idx = 0; pl_idx < plane_cnt; pl_idx++) {
abd805ec
MB		 249 ppas[i].g.pl = pl_idx;
250 rqd->ppa_list[(i * plane_cnt) + pl_idx] = ppas[i];
069368e9
MB		 251 }
252 }
253
abd805ec
MB		 254 return 0;
255}
256EXPORT_SYMBOL(nvm_set_rqd_ppalist);
257
258void nvm_free_rqd_ppalist(struct nvm_dev *dev, struct nvm_rq *rqd)
259{
260 if (!rqd->ppa_list)
261 return;
262
263 nvm_dev_dma_free(dev, rqd->ppa_list, rqd->dma_ppa_list);
264}
265EXPORT_SYMBOL(nvm_free_rqd_ppalist);
266
267int nvm_erase_ppa(struct nvm_dev *dev, struct ppa_addr ppa)
268{
269 struct nvm_rq rqd;
270 int ret;
271
272 if (!dev->ops->erase_block)
273 return 0;
274
275 memset(&rqd, 0, sizeof(struct nvm_rq));
276
277 ret = nvm_set_rqd_ppalist(dev, &rqd, &ppa, 1);
278 if (ret)
279 return ret;
280
069368e9
MB		 281 nvm_generic_to_addr_mode(dev, &rqd);
282
283 ret = dev->ops->erase_block(dev, &rqd);
284
abd805ec 285 nvm_free_rqd_ppalist(dev, &rqd);
069368e9
MB		 286
287 return ret;
288}
289EXPORT_SYMBOL(nvm_erase_ppa);
290
cd9e9808
MB		 291static int nvm_core_init(struct nvm_dev *dev)
292{
293 struct nvm_id *id = &dev->identity;
294 struct nvm_id_group *grp = &id->groups[0];
295
296 /* device values */
297 dev->nr_chnls = grp->num_ch;
298 dev->luns_per_chnl = grp->num_lun;
299 dev->pgs_per_blk = grp->num_pg;
300 dev->blks_per_lun = grp->num_blk;
301 dev->nr_planes = grp->num_pln;
302 dev->sec_size = grp->csecs;
303 dev->oob_size = grp->sos;
304 dev->sec_per_pg = grp->fpg_sz / grp->csecs;
7386af27 305 memcpy(&dev->ppaf, &id->ppaf, sizeof(struct nvm_addr_format));
cd9e9808
MB		 306
307 dev->plane_mode = NVM_PLANE_SINGLE;
308 dev->max_rq_size = dev->ops->max_phys_sect * dev->sec_size;
309
4264c980
MB		 310 if (grp->mtype != 0) {
311 pr_err("nvm: memory type not supported\n");
312 return -EINVAL;
313 }
314
315 if (grp->fmtype != 0 && grp->fmtype != 1) {
316 pr_err("nvm: flash type not supported\n");
317 return -EINVAL;
318 }
319
cd9e9808
MB		 320 if (grp->mpos & 0x020202)
321 dev->plane_mode = NVM_PLANE_DOUBLE;
322 if (grp->mpos & 0x040404)
323 dev->plane_mode = NVM_PLANE_QUAD;
324
325 /* calculated values */
326 dev->sec_per_pl = dev->sec_per_pg * dev->nr_planes;
327 dev->sec_per_blk = dev->sec_per_pl * dev->pgs_per_blk;
328 dev->sec_per_lun = dev->sec_per_blk * dev->blks_per_lun;
329 dev->nr_luns = dev->luns_per_chnl * dev->nr_chnls;
330
331 dev->total_blocks = dev->nr_planes *
332 dev->blks_per_lun *
333 dev->luns_per_chnl *
334 dev->nr_chnls;
335 dev->total_pages = dev->total_blocks * dev->pgs_per_blk;
336 INIT_LIST_HEAD(&dev->online_targets);
337
338 return 0;
339}
340
341static void nvm_free(struct nvm_dev *dev)
342{
343 if (!dev)
344 return;
345
346 if (dev->mt)
347 dev->mt->unregister_mgr(dev);
cd9e9808
MB		 348}
349
350static int nvm_init(struct nvm_dev *dev)
351{
480fc0db 352 int ret = -EINVAL;
cd9e9808
MB		 353
354 if (!dev->q || !dev->ops)
480fc0db 355 return ret;
cd9e9808 356
16f26c3a 357 if (dev->ops->identity(dev, &dev->identity)) {
cd9e9808 358 pr_err("nvm: device could not be identified\n");
cd9e9808
MB		 359 goto err;
360 }
361
362 pr_debug("nvm: ver:%x nvm_vendor:%x groups:%u\n",
363 dev->identity.ver_id, dev->identity.vmnt,
364 dev->identity.cgrps);
365
366 if (dev->identity.ver_id != 1) {
367 pr_err("nvm: device not supported by kernel.");
368 goto err;
369 }
370
371 if (dev->identity.cgrps != 1) {
372 pr_err("nvm: only one group configuration supported.");
373 goto err;
374 }
375
376 ret = nvm_core_init(dev);
377 if (ret) {
378 pr_err("nvm: could not initialize core structures.\n");
379 goto err;
380 }
381
cd9e9808
MB		 382 pr_info("nvm: registered %s [%u/%u/%u/%u/%u/%u]\n",
383 dev->name, dev->sec_per_pg, dev->nr_planes,
384 dev->pgs_per_blk, dev->blks_per_lun, dev->nr_luns,
385 dev->nr_chnls);
386 return 0;
387err:
cd9e9808
MB		 388 pr_err("nvm: failed to initialize nvm\n");
389 return ret;
390}
391
392static void nvm_exit(struct nvm_dev *dev)
393{
394 if (dev->ppalist_pool)
395 dev->ops->destroy_dma_pool(dev->ppalist_pool);
396 nvm_free(dev);
397
398 pr_info("nvm: successfully unloaded\n");
399}
400
401int nvm_register(struct request_queue *q, char *disk_name,
402 struct nvm_dev_ops *ops)
403{
404 struct nvm_dev *dev;
405 int ret;
406
407 if (!ops->identity)
408 return -EINVAL;
409
410 dev = kzalloc(sizeof(struct nvm_dev), GFP_KERNEL);
411 if (!dev)
412 return -ENOMEM;
413
414 dev->q = q;
415 dev->ops = ops;
416 strncpy(dev->name, disk_name, DISK_NAME_LEN);
417
418 ret = nvm_init(dev);
419 if (ret)
420 goto err_init;
421
d160147b
WT		 422 if (dev->ops->max_phys_sect > 256) {
423 pr_info("nvm: max sectors supported is 256.\n");
424 ret = -EINVAL;
425 goto err_init;
426 }
427
cd9e9808 428 if (dev->ops->max_phys_sect > 1) {
16f26c3a 429 dev->ppalist_pool = dev->ops->create_dma_pool(dev, "ppalist");
cd9e9808
MB		 430 if (!dev->ppalist_pool) {
431 pr_err("nvm: could not create ppa pool\n");
93e70c1f
MB		 432 ret = -ENOMEM;
433 goto err_init;
cd9e9808 434 }
cd9e9808
MB		 435 }
436
762796bc 437 /* register device with a supported media manager */
edad2e66 438 down_write(&nvm_lock);
762796bc 439 dev->mt = nvm_init_mgr(dev);
edad2e66
MB		 440 list_add(&dev->devices, &nvm_devices);
441 up_write(&nvm_lock);
442
cd9e9808
MB		 443 return 0;
444err_init:
445 kfree(dev);
446 return ret;
447}
448EXPORT_SYMBOL(nvm_register);
449
450void nvm_unregister(char *disk_name)
451{
d0a712ce 452 struct nvm_dev *dev;
cd9e9808 453
d0a712ce
WT		 454 down_write(&nvm_lock);
455 dev = nvm_find_nvm_dev(disk_name);
cd9e9808
MB		 456 if (!dev) {
457 pr_err("nvm: could not find device %s to unregister\n",
458 disk_name);
d0a712ce 459 up_write(&nvm_lock);
cd9e9808
MB		 460 return;
461 }
462
cd9e9808
MB		 463 list_del(&dev->devices);
464 up_write(&nvm_lock);
c1480ad5
MB		 465
466 nvm_exit(dev);
467 kfree(dev);
cd9e9808
MB		 468}
469EXPORT_SYMBOL(nvm_unregister);
470
471static const struct block_device_operations nvm_fops = {
472 .owner = THIS_MODULE,
473};
474
475static int nvm_create_target(struct nvm_dev *dev,
476 struct nvm_ioctl_create *create)
477{
478 struct nvm_ioctl_create_simple *s = &create->conf.s;
479 struct request_queue *tqueue;
cd9e9808
MB		 480 struct gendisk *tdisk;
481 struct nvm_tgt_type *tt;
482 struct nvm_target *t;
483 void *targetdata;
cd9e9808
MB		 484
485 if (!dev->mt) {
762796bc
MB		 486 pr_info("nvm: device has no media manager registered.\n");
487 return -ENODEV;
cd9e9808
MB		 488 }
489
762796bc 490 down_write(&nvm_lock);
cd9e9808
MB		 491 tt = nvm_find_target_type(create->tgttype);
492 if (!tt) {
493 pr_err("nvm: target type %s not found\n", create->tgttype);
d0a712ce 494 up_write(&nvm_lock);
cd9e9808
MB		 495 return -EINVAL;
496 }
497
cd9e9808
MB		 498 list_for_each_entry(t, &dev->online_targets, list) {
499 if (!strcmp(create->tgtname, t->disk->disk_name)) {
500 pr_err("nvm: target name already exists.\n");
501 up_write(&nvm_lock);
502 return -EINVAL;
503 }
504 }
505 up_write(&nvm_lock);
506
507 t = kmalloc(sizeof(struct nvm_target), GFP_KERNEL);
508 if (!t)
509 return -ENOMEM;
510
511 tqueue = blk_alloc_queue_node(GFP_KERNEL, dev->q->node);
512 if (!tqueue)
513 goto err_t;
514 blk_queue_make_request(tqueue, tt->make_rq);
515
516 tdisk = alloc_disk(0);
517 if (!tdisk)
518 goto err_queue;
519
520 sprintf(tdisk->disk_name, "%s", create->tgtname);
521 tdisk->flags = GENHD_FL_EXT_DEVT;
522 tdisk->major = 0;
523 tdisk->first_minor = 0;
524 tdisk->fops = &nvm_fops;
525 tdisk->queue = tqueue;
526
527 targetdata = tt->init(dev, tdisk, s->lun_begin, s->lun_end);
528 if (IS_ERR(targetdata))
529 goto err_init;
530
531 tdisk->private_data = targetdata;
532 tqueue->queuedata = targetdata;
533
534 blk_queue_max_hw_sectors(tqueue, 8 * dev->ops->max_phys_sect);
535
536 set_capacity(tdisk, tt->capacity(targetdata));
537 add_disk(tdisk);
538
539 t->type = tt;
540 t->disk = tdisk;
541
542 down_write(&nvm_lock);
543 list_add_tail(&t->list, &dev->online_targets);
544 up_write(&nvm_lock);
545
546 return 0;
547err_init:
548 put_disk(tdisk);
549err_queue:
550 blk_cleanup_queue(tqueue);
551err_t:
552 kfree(t);
553 return -ENOMEM;
554}
555
556static void nvm_remove_target(struct nvm_target *t)
557{
558 struct nvm_tgt_type *tt = t->type;
559 struct gendisk *tdisk = t->disk;
560 struct request_queue *q = tdisk->queue;
561
562 lockdep_assert_held(&nvm_lock);
563
564 del_gendisk(tdisk);
d09f9581
JG		 565 blk_cleanup_queue(q);
566
cd9e9808
MB		 567 if (tt->exit)
568 tt->exit(tdisk->private_data);
569
cd9e9808
MB		 570 put_disk(tdisk);
571
572 list_del(&t->list);
573 kfree(t);
574}
575
576static int __nvm_configure_create(struct nvm_ioctl_create *create)
577{
578 struct nvm_dev *dev;
579 struct nvm_ioctl_create_simple *s;
580
d0a712ce 581 down_write(&nvm_lock);
cd9e9808 582 dev = nvm_find_nvm_dev(create->dev);
d0a712ce 583 up_write(&nvm_lock);
cd9e9808
MB		 584 if (!dev) {
585 pr_err("nvm: device not found\n");
586 return -EINVAL;
587 }
588
589 if (create->conf.type != NVM_CONFIG_TYPE_SIMPLE) {
590 pr_err("nvm: config type not valid\n");
591 return -EINVAL;
592 }
593 s = &create->conf.s;
594
595 if (s->lun_begin > s->lun_end || s->lun_end > dev->nr_luns) {
596 pr_err("nvm: lun out of bound (%u:%u > %u)\n",
597 s->lun_begin, s->lun_end, dev->nr_luns);
598 return -EINVAL;
599 }
600
601 return nvm_create_target(dev, create);
602}
603
604static int __nvm_configure_remove(struct nvm_ioctl_remove *remove)
605{
606 struct nvm_target *t = NULL;
607 struct nvm_dev *dev;
608 int ret = -1;
609
610 down_write(&nvm_lock);
611 list_for_each_entry(dev, &nvm_devices, devices)
612 list_for_each_entry(t, &dev->online_targets, list) {
613 if (!strcmp(remove->tgtname, t->disk->disk_name)) {
614 nvm_remove_target(t);
615 ret = 0;
616 break;
617 }
618 }
619 up_write(&nvm_lock);
620
621 if (ret) {
622 pr_err("nvm: target \"%s\" doesn't exist.\n", remove->tgtname);
623 return -EINVAL;
624 }
625
626 return 0;
627}
628
629#ifdef CONFIG_NVM_DEBUG
630static int nvm_configure_show(const char *val)
631{
632 struct nvm_dev *dev;
633 char opcode, devname[DISK_NAME_LEN];
634 int ret;
635
636 ret = sscanf(val, "%c %32s", &opcode, devname);
637 if (ret != 2) {
638 pr_err("nvm: invalid command. Use \"opcode devicename\".\n");
639 return -EINVAL;
640 }
641
d0a712ce 642 down_write(&nvm_lock);
cd9e9808 643 dev = nvm_find_nvm_dev(devname);
d0a712ce 644 up_write(&nvm_lock);
cd9e9808
MB		 645 if (!dev) {
646 pr_err("nvm: device not found\n");
647 return -EINVAL;
648 }
649
650 if (!dev->mt)
651 return 0;
652
2fde0e48 653 dev->mt->lun_info_print(dev);
cd9e9808
MB		 654
655 return 0;
656}
657
658static int nvm_configure_remove(const char *val)
659{
660 struct nvm_ioctl_remove remove;
661 char opcode;
662 int ret;
663
664 ret = sscanf(val, "%c %256s", &opcode, remove.tgtname);
665 if (ret != 2) {
666 pr_err("nvm: invalid command. Use \"d targetname\".\n");
667 return -EINVAL;
668 }
669
670 remove.flags = 0;
671
672 return __nvm_configure_remove(&remove);
673}
674
675static int nvm_configure_create(const char *val)
676{
677 struct nvm_ioctl_create create;
678 char opcode;
679 int lun_begin, lun_end, ret;
680
681 ret = sscanf(val, "%c %256s %256s %48s %u:%u", &opcode, create.dev,
682 create.tgtname, create.tgttype,
683 &lun_begin, &lun_end);
684 if (ret != 6) {
685 pr_err("nvm: invalid command. Use \"opcode device name tgttype lun_begin:lun_end\".\n");
686 return -EINVAL;
687 }
688
689 create.flags = 0;
690 create.conf.type = NVM_CONFIG_TYPE_SIMPLE;
691 create.conf.s.lun_begin = lun_begin;
692 create.conf.s.lun_end = lun_end;
693
694 return __nvm_configure_create(&create);
695}
696
697
698/* Exposes administrative interface through /sys/module/lnvm/configure_by_str */
699static int nvm_configure_by_str_event(const char *val,
700 const struct kernel_param *kp)
701{
702 char opcode;
703 int ret;
704
705 ret = sscanf(val, "%c", &opcode);
706 if (ret != 1) {
707 pr_err("nvm: string must have the format of \"cmd ...\"\n");
708 return -EINVAL;
709 }
710
711 switch (opcode) {
712 case 'a':
713 return nvm_configure_create(val);
714 case 'd':
715 return nvm_configure_remove(val);
716 case 's':
717 return nvm_configure_show(val);
718 default:
719 pr_err("nvm: invalid command\n");
720 return -EINVAL;
721 }
722
723 return 0;
724}
725
726static int nvm_configure_get(char *buf, const struct kernel_param *kp)
727{
728 int sz = 0;
729 char *buf_start = buf;
730 struct nvm_dev *dev;
731
732 buf += sprintf(buf, "available devices:\n");
733 down_write(&nvm_lock);
734 list_for_each_entry(dev, &nvm_devices, devices) {
735 if (sz > 4095 - DISK_NAME_LEN)
736 break;
737 buf += sprintf(buf, " %32s\n", dev->name);
738 }
739 up_write(&nvm_lock);
740
741 return buf - buf_start - 1;
742}
743
744static const struct kernel_param_ops nvm_configure_by_str_event_param_ops = {
745 .set = nvm_configure_by_str_event,
746 .get = nvm_configure_get,
747};
748
749#undef MODULE_PARAM_PREFIX
750#define MODULE_PARAM_PREFIX "lnvm."
751
752module_param_cb(configure_debug, &nvm_configure_by_str_event_param_ops, NULL,
753 0644);
754
755#endif /* CONFIG_NVM_DEBUG */
756
757static long nvm_ioctl_info(struct file *file, void __user *arg)
758{
759 struct nvm_ioctl_info *info;
760 struct nvm_tgt_type *tt;
761 int tgt_iter = 0;
762
763 if (!capable(CAP_SYS_ADMIN))
764 return -EPERM;
765
766 info = memdup_user(arg, sizeof(struct nvm_ioctl_info));
767 if (IS_ERR(info))
768 return -EFAULT;
769
770 info->version[0] = NVM_VERSION_MAJOR;
771 info->version[1] = NVM_VERSION_MINOR;
772 info->version[2] = NVM_VERSION_PATCH;
773
774 down_write(&nvm_lock);
775 list_for_each_entry(tt, &nvm_targets, list) {
776 struct nvm_ioctl_info_tgt *tgt = &info->tgts[tgt_iter];
777
778 tgt->version[0] = tt->version[0];
779 tgt->version[1] = tt->version[1];
780 tgt->version[2] = tt->version[2];
781 strncpy(tgt->tgtname, tt->name, NVM_TTYPE_NAME_MAX);
782
783 tgt_iter++;
784 }
785
786 info->tgtsize = tgt_iter;
787 up_write(&nvm_lock);
788
76e25081
SM		 789 if (copy_to_user(arg, info, sizeof(struct nvm_ioctl_info))) {
790 kfree(info);
cd9e9808 791 return -EFAULT;
76e25081 792 }
cd9e9808
MB		 793
794 kfree(info);
795 return 0;
796}
797
798static long nvm_ioctl_get_devices(struct file *file, void __user *arg)
799{
800 struct nvm_ioctl_get_devices *devices;
801 struct nvm_dev *dev;
802 int i = 0;
803
804 if (!capable(CAP_SYS_ADMIN))
805 return -EPERM;
806
807 devices = kzalloc(sizeof(struct nvm_ioctl_get_devices), GFP_KERNEL);
808 if (!devices)
809 return -ENOMEM;
810
811 down_write(&nvm_lock);
812 list_for_each_entry(dev, &nvm_devices, devices) {
813 struct nvm_ioctl_device_info *info = &devices->info[i];
814
815 sprintf(info->devname, "%s", dev->name);
816 if (dev->mt) {
817 info->bmversion[0] = dev->mt->version[0];
818 info->bmversion[1] = dev->mt->version[1];
819 info->bmversion[2] = dev->mt->version[2];
820 sprintf(info->bmname, "%s", dev->mt->name);
821 } else {
822 sprintf(info->bmname, "none");
823 }
824
825 i++;
826 if (i > 31) {
827 pr_err("nvm: max 31 devices can be reported.\n");
828 break;
829 }
830 }
831 up_write(&nvm_lock);
832
833 devices->nr_devices = i;
834
76e25081
SM		 835 if (copy_to_user(arg, devices,
836 sizeof(struct nvm_ioctl_get_devices))) {
837 kfree(devices);
cd9e9808 838 return -EFAULT;
76e25081 839 }
cd9e9808
MB		 840
841 kfree(devices);
842 return 0;
843}
844
845static long nvm_ioctl_dev_create(struct file *file, void __user *arg)
846{
847 struct nvm_ioctl_create create;
848
849 if (!capable(CAP_SYS_ADMIN))
850 return -EPERM;
851
852 if (copy_from_user(&create, arg, sizeof(struct nvm_ioctl_create)))
853 return -EFAULT;
854
855 create.dev[DISK_NAME_LEN - 1] = '\0';
856 create.tgttype[NVM_TTYPE_NAME_MAX - 1] = '\0';
857 create.tgtname[DISK_NAME_LEN - 1] = '\0';
858
859 if (create.flags != 0) {
860 pr_err("nvm: no flags supported\n");
861 return -EINVAL;
862 }
863
864 return __nvm_configure_create(&create);
865}
866
867static long nvm_ioctl_dev_remove(struct file *file, void __user *arg)
868{
869 struct nvm_ioctl_remove remove;
870
871 if (!capable(CAP_SYS_ADMIN))
872 return -EPERM;
873
874 if (copy_from_user(&remove, arg, sizeof(struct nvm_ioctl_remove)))
875 return -EFAULT;
876
877 remove.tgtname[DISK_NAME_LEN - 1] = '\0';
878
879 if (remove.flags != 0) {
880 pr_err("nvm: no flags supported\n");
881 return -EINVAL;
882 }
883
884 return __nvm_configure_remove(&remove);
885}
886
887static long nvm_ctl_ioctl(struct file *file, uint cmd, unsigned long arg)
888{
889 void __user *argp = (void __user *)arg;
890
891 switch (cmd) {
892 case NVM_INFO:
893 return nvm_ioctl_info(file, argp);
894 case NVM_GET_DEVICES:
895 return nvm_ioctl_get_devices(file, argp);
896 case NVM_DEV_CREATE:
897 return nvm_ioctl_dev_create(file, argp);
898 case NVM_DEV_REMOVE:
899 return nvm_ioctl_dev_remove(file, argp);
900 }
901 return 0;
902}
903
904static const struct file_operations _ctl_fops = {
905 .open = nonseekable_open,
906 .unlocked_ioctl = nvm_ctl_ioctl,
907 .owner = THIS_MODULE,
908 .llseek = noop_llseek,
909};
910
911static struct miscdevice _nvm_misc = {
912 .minor = MISC_DYNAMIC_MINOR,
913 .name = "lightnvm",
914 .nodename = "lightnvm/control",
915 .fops = &_ctl_fops,
916};
917
918MODULE_ALIAS_MISCDEV(MISC_DYNAMIC_MINOR);
919
920static int __init nvm_mod_init(void)
921{
922 int ret;
923
924 ret = misc_register(&_nvm_misc);
925 if (ret)
926 pr_err("nvm: misc_register failed for control device");
927
928 return ret;
929}
930
931static void __exit nvm_mod_exit(void)
932{
933 misc_deregister(&_nvm_misc);
934}
935
936MODULE_AUTHOR("Matias Bjorling <m@bjorling.me>");
937MODULE_LICENSE("GPL v2");
938MODULE_VERSION("0.1");
939module_init(nvm_mod_init);
940module_exit(nvm_mod_exit);
Linux kernel - Deliverables
This page took 0.069912 seconds and 5 git commands to generate.