source: src/linux/universal/linux-4.9/drivers/nvme/host/core.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 11 days ago

kernel update

File size: 51.8 KB
Line 
1/*
2 * NVM Express device driver
3 * Copyright (c) 2011-2014, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/blkdev.h>
16#include <linux/blk-mq.h>
17#include <linux/delay.h>
18#include <linux/errno.h>
19#include <linux/hdreg.h>
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/list_sort.h>
23#include <linux/slab.h>
24#include <linux/types.h>
25#include <linux/pr.h>
26#include <linux/ptrace.h>
27#include <linux/nvme_ioctl.h>
28#include <linux/t10-pi.h>
29#include <scsi/sg.h>
30#include <asm/unaligned.h>
31
32#include "nvme.h"
33#include "fabrics.h"
34
35#define NVME_MINORS             (1U << MINORBITS)
36
37unsigned char admin_timeout = 60;
38module_param(admin_timeout, byte, 0644);
39MODULE_PARM_DESC(admin_timeout, "timeout in seconds for admin commands");
40EXPORT_SYMBOL_GPL(admin_timeout);
41
42unsigned char nvme_io_timeout = 30;
43module_param_named(io_timeout, nvme_io_timeout, byte, 0644);
44MODULE_PARM_DESC(io_timeout, "timeout in seconds for I/O");
45EXPORT_SYMBOL_GPL(nvme_io_timeout);
46
47unsigned char shutdown_timeout = 5;
48module_param(shutdown_timeout, byte, 0644);
49MODULE_PARM_DESC(shutdown_timeout, "timeout in seconds for controller shutdown");
50
51unsigned int nvme_max_retries = 5;
52module_param_named(max_retries, nvme_max_retries, uint, 0644);
53MODULE_PARM_DESC(max_retries, "max number of retries a command may have");
54EXPORT_SYMBOL_GPL(nvme_max_retries);
55
56static int nvme_char_major;
57module_param(nvme_char_major, int, 0);
58
59static LIST_HEAD(nvme_ctrl_list);
60static DEFINE_SPINLOCK(dev_list_lock);
61
62static struct class *nvme_class;
63
64void nvme_cancel_request(struct request *req, void *data, bool reserved)
65{
66        int status;
67
68        if (!blk_mq_request_started(req))
69                return;
70
71        dev_dbg_ratelimited(((struct nvme_ctrl *) data)->device,
72                                "Cancelling I/O %d", req->tag);
73
74        status = NVME_SC_ABORT_REQ;
75        if (blk_queue_dying(req->q))
76                status |= NVME_SC_DNR;
77        blk_mq_complete_request(req, status);
78}
79EXPORT_SYMBOL_GPL(nvme_cancel_request);
80
81bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,
82                enum nvme_ctrl_state new_state)
83{
84        enum nvme_ctrl_state old_state;
85        bool changed = false;
86
87        spin_lock_irq(&ctrl->lock);
88
89        old_state = ctrl->state;
90        switch (new_state) {
91        case NVME_CTRL_LIVE:
92                switch (old_state) {
93                case NVME_CTRL_NEW:
94                case NVME_CTRL_RESETTING:
95                case NVME_CTRL_RECONNECTING:
96                        changed = true;
97                        /* FALLTHRU */
98                default:
99                        break;
100                }
101                break;
102        case NVME_CTRL_RESETTING:
103                switch (old_state) {
104                case NVME_CTRL_NEW:
105                case NVME_CTRL_LIVE:
106                case NVME_CTRL_RECONNECTING:
107                        changed = true;
108                        /* FALLTHRU */
109                default:
110                        break;
111                }
112                break;
113        case NVME_CTRL_RECONNECTING:
114                switch (old_state) {
115                case NVME_CTRL_LIVE:
116                        changed = true;
117                        /* FALLTHRU */
118                default:
119                        break;
120                }
121                break;
122        case NVME_CTRL_DELETING:
123                switch (old_state) {
124                case NVME_CTRL_LIVE:
125                case NVME_CTRL_RESETTING:
126                case NVME_CTRL_RECONNECTING:
127                        changed = true;
128                        /* FALLTHRU */
129                default:
130                        break;
131                }
132                break;
133        case NVME_CTRL_DEAD:
134                switch (old_state) {
135                case NVME_CTRL_DELETING:
136                        changed = true;
137                        /* FALLTHRU */
138                default:
139                        break;
140                }
141                break;
142        default:
143                break;
144        }
145
146        if (changed)
147                ctrl->state = new_state;
148
149        spin_unlock_irq(&ctrl->lock);
150
151        return changed;
152}
153EXPORT_SYMBOL_GPL(nvme_change_ctrl_state);
154
155static void nvme_free_ns(struct kref *kref)
156{
157        struct nvme_ns *ns = container_of(kref, struct nvme_ns, kref);
158
159        if (ns->ndev)
160                nvme_nvm_unregister(ns);
161
162        if (ns->disk) {
163                spin_lock(&dev_list_lock);
164                ns->disk->private_data = NULL;
165                spin_unlock(&dev_list_lock);
166        }
167
168        put_disk(ns->disk);
169        ida_simple_remove(&ns->ctrl->ns_ida, ns->instance);
170        nvme_put_ctrl(ns->ctrl);
171        kfree(ns);
172}
173
174static void nvme_put_ns(struct nvme_ns *ns)
175{
176        kref_put(&ns->kref, nvme_free_ns);
177}
178
179static struct nvme_ns *nvme_get_ns_from_disk(struct gendisk *disk)
180{
181        struct nvme_ns *ns;
182
183        spin_lock(&dev_list_lock);
184        ns = disk->private_data;
185        if (ns) {
186                if (!kref_get_unless_zero(&ns->kref))
187                        goto fail;
188                if (!try_module_get(ns->ctrl->ops->module))
189                        goto fail_put_ns;
190        }
191        spin_unlock(&dev_list_lock);
192
193        return ns;
194
195fail_put_ns:
196        kref_put(&ns->kref, nvme_free_ns);
197fail:
198        spin_unlock(&dev_list_lock);
199        return NULL;
200}
201
202void nvme_requeue_req(struct request *req)
203{
204        unsigned long flags;
205
206        blk_mq_requeue_request(req);
207        spin_lock_irqsave(req->q->queue_lock, flags);
208        if (!blk_queue_stopped(req->q))
209                blk_mq_kick_requeue_list(req->q);
210        spin_unlock_irqrestore(req->q->queue_lock, flags);
211}
212EXPORT_SYMBOL_GPL(nvme_requeue_req);
213
214struct request *nvme_alloc_request(struct request_queue *q,
215                struct nvme_command *cmd, unsigned int flags, int qid)
216{
217        struct request *req;
218
219        if (qid == NVME_QID_ANY) {
220                req = blk_mq_alloc_request(q, nvme_is_write(cmd), flags);
221        } else {
222                req = blk_mq_alloc_request_hctx(q, nvme_is_write(cmd), flags,
223                                qid ? qid - 1 : 0);
224        }
225        if (IS_ERR(req))
226                return req;
227
228        req->cmd_type = REQ_TYPE_DRV_PRIV;
229        req->cmd_flags |= REQ_FAILFAST_DRIVER;
230        req->cmd = (unsigned char *)cmd;
231        req->cmd_len = sizeof(struct nvme_command);
232
233        return req;
234}
235EXPORT_SYMBOL_GPL(nvme_alloc_request);
236
237static inline void nvme_setup_flush(struct nvme_ns *ns,
238                struct nvme_command *cmnd)
239{
240        memset(cmnd, 0, sizeof(*cmnd));
241        cmnd->common.opcode = nvme_cmd_flush;
242        cmnd->common.nsid = cpu_to_le32(ns->ns_id);
243}
244
245static inline int nvme_setup_discard(struct nvme_ns *ns, struct request *req,
246                struct nvme_command *cmnd)
247{
248        struct nvme_dsm_range *range;
249        struct page *page;
250        int offset;
251        unsigned int nr_bytes = blk_rq_bytes(req);
252
253        range = kmalloc(sizeof(*range), GFP_ATOMIC);
254        if (!range)
255                return BLK_MQ_RQ_QUEUE_BUSY;
256
257        range->cattr = cpu_to_le32(0);
258        range->nlb = cpu_to_le32(nr_bytes >> ns->lba_shift);
259        range->slba = cpu_to_le64(nvme_block_nr(ns, blk_rq_pos(req)));
260
261        memset(cmnd, 0, sizeof(*cmnd));
262        cmnd->dsm.opcode = nvme_cmd_dsm;
263        cmnd->dsm.nsid = cpu_to_le32(ns->ns_id);
264        cmnd->dsm.nr = 0;
265        cmnd->dsm.attributes = cpu_to_le32(NVME_DSMGMT_AD);
266
267        req->completion_data = range;
268        page = virt_to_page(range);
269        offset = offset_in_page(range);
270        blk_add_request_payload(req, page, offset, sizeof(*range));
271
272        /*
273         * we set __data_len back to the size of the area to be discarded
274         * on disk. This allows us to report completion on the full amount
275         * of blocks described by the request.
276         */
277        req->__data_len = nr_bytes;
278
279        return 0;
280}
281
282static inline void nvme_setup_rw(struct nvme_ns *ns, struct request *req,
283                struct nvme_command *cmnd)
284{
285        u16 control = 0;
286        u32 dsmgmt = 0;
287
288        if (req->cmd_flags & REQ_FUA)
289                control |= NVME_RW_FUA;
290        if (req->cmd_flags & (REQ_FAILFAST_DEV | REQ_RAHEAD))
291                control |= NVME_RW_LR;
292
293        if (req->cmd_flags & REQ_RAHEAD)
294                dsmgmt |= NVME_RW_DSM_FREQ_PREFETCH;
295
296        memset(cmnd, 0, sizeof(*cmnd));
297        cmnd->rw.opcode = (rq_data_dir(req) ? nvme_cmd_write : nvme_cmd_read);
298        cmnd->rw.command_id = req->tag;
299        cmnd->rw.nsid = cpu_to_le32(ns->ns_id);
300        cmnd->rw.slba = cpu_to_le64(nvme_block_nr(ns, blk_rq_pos(req)));
301        cmnd->rw.length = cpu_to_le16((blk_rq_bytes(req) >> ns->lba_shift) - 1);
302
303        if (ns->ms) {
304                switch (ns->pi_type) {
305                case NVME_NS_DPS_PI_TYPE3:
306                        control |= NVME_RW_PRINFO_PRCHK_GUARD;
307                        break;
308                case NVME_NS_DPS_PI_TYPE1:
309                case NVME_NS_DPS_PI_TYPE2:
310                        control |= NVME_RW_PRINFO_PRCHK_GUARD |
311                                        NVME_RW_PRINFO_PRCHK_REF;
312                        cmnd->rw.reftag = cpu_to_le32(
313                                        nvme_block_nr(ns, blk_rq_pos(req)));
314                        break;
315                }
316                if (!blk_integrity_rq(req))
317                        control |= NVME_RW_PRINFO_PRACT;
318        }
319
320        cmnd->rw.control = cpu_to_le16(control);
321        cmnd->rw.dsmgmt = cpu_to_le32(dsmgmt);
322}
323
324int nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
325                struct nvme_command *cmd)
326{
327        int ret = 0;
328
329        if (req->cmd_type == REQ_TYPE_DRV_PRIV)
330                memcpy(cmd, req->cmd, sizeof(*cmd));
331        else if (req_op(req) == REQ_OP_FLUSH)
332                nvme_setup_flush(ns, cmd);
333        else if (req_op(req) == REQ_OP_DISCARD)
334                ret = nvme_setup_discard(ns, req, cmd);
335        else
336                nvme_setup_rw(ns, req, cmd);
337
338        return ret;
339}
340EXPORT_SYMBOL_GPL(nvme_setup_cmd);
341
342/*
343 * Returns 0 on success.  If the result is negative, it's a Linux error code;
344 * if the result is positive, it's an NVM Express status code
345 */
346int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
347                struct nvme_completion *cqe, void *buffer, unsigned bufflen,
348                unsigned timeout, int qid, int at_head, int flags)
349{
350        struct request *req;
351        int ret;
352
353        req = nvme_alloc_request(q, cmd, flags, qid);
354        if (IS_ERR(req))
355                return PTR_ERR(req);
356
357        req->timeout = timeout ? timeout : ADMIN_TIMEOUT;
358        req->special = cqe;
359
360        if (buffer && bufflen) {
361                ret = blk_rq_map_kern(q, req, buffer, bufflen, GFP_KERNEL);
362                if (ret)
363                        goto out;
364        }
365
366        blk_execute_rq(req->q, NULL, req, at_head);
367        ret = req->errors;
368 out:
369        blk_mq_free_request(req);
370        return ret;
371}
372EXPORT_SYMBOL_GPL(__nvme_submit_sync_cmd);
373
374int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
375                void *buffer, unsigned bufflen)
376{
377        return __nvme_submit_sync_cmd(q, cmd, NULL, buffer, bufflen, 0,
378                        NVME_QID_ANY, 0, 0);
379}
380EXPORT_SYMBOL_GPL(nvme_submit_sync_cmd);
381
382int __nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd,
383                void __user *ubuffer, unsigned bufflen,
384                void __user *meta_buffer, unsigned meta_len, u32 meta_seed,
385                u32 *result, unsigned timeout)
386{
387        bool write = nvme_is_write(cmd);
388        struct nvme_completion cqe;
389        struct nvme_ns *ns = q->queuedata;
390        struct gendisk *disk = ns ? ns->disk : NULL;
391        struct request *req;
392        struct bio *bio = NULL;
393        void *meta = NULL;
394        int ret;
395
396        req = nvme_alloc_request(q, cmd, 0, NVME_QID_ANY);
397        if (IS_ERR(req))
398                return PTR_ERR(req);
399
400        req->timeout = timeout ? timeout : ADMIN_TIMEOUT;
401        req->special = &cqe;
402
403        if (ubuffer && bufflen) {
404                ret = blk_rq_map_user(q, req, NULL, ubuffer, bufflen,
405                                GFP_KERNEL);
406                if (ret)
407                        goto out;
408                bio = req->bio;
409
410                if (!disk)
411                        goto submit;
412                bio->bi_bdev = bdget_disk(disk, 0);
413                if (!bio->bi_bdev) {
414                        ret = -ENODEV;
415                        goto out_unmap;
416                }
417
418                if (meta_buffer && meta_len) {
419                        struct bio_integrity_payload *bip;
420
421                        meta = kmalloc(meta_len, GFP_KERNEL);
422                        if (!meta) {
423                                ret = -ENOMEM;
424                                goto out_unmap;
425                        }
426
427                        if (write) {
428                                if (copy_from_user(meta, meta_buffer,
429                                                meta_len)) {
430                                        ret = -EFAULT;
431                                        goto out_free_meta;
432                                }
433                        }
434
435                        bip = bio_integrity_alloc(bio, GFP_KERNEL, 1);
436                        if (IS_ERR(bip)) {
437                                ret = PTR_ERR(bip);
438                                goto out_free_meta;
439                        }
440
441                        bip->bip_iter.bi_size = meta_len;
442                        bip->bip_iter.bi_sector = meta_seed;
443
444                        ret = bio_integrity_add_page(bio, virt_to_page(meta),
445                                        meta_len, offset_in_page(meta));
446                        if (ret != meta_len) {
447                                ret = -ENOMEM;
448                                goto out_free_meta;
449                        }
450                }
451        }
452 submit:
453        blk_execute_rq(req->q, disk, req, 0);
454        ret = req->errors;
455        if (result)
456                *result = le32_to_cpu(cqe.result);
457        if (meta && !ret && !write) {
458                if (copy_to_user(meta_buffer, meta, meta_len))
459                        ret = -EFAULT;
460        }
461 out_free_meta:
462        kfree(meta);
463 out_unmap:
464        if (bio) {
465                if (disk && bio->bi_bdev)
466                        bdput(bio->bi_bdev);
467                blk_rq_unmap_user(bio);
468        }
469 out:
470        blk_mq_free_request(req);
471        return ret;
472}
473
474int nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd,
475                void __user *ubuffer, unsigned bufflen, u32 *result,
476                unsigned timeout)
477{
478        return __nvme_submit_user_cmd(q, cmd, ubuffer, bufflen, NULL, 0, 0,
479                        result, timeout);
480}
481
482static void nvme_keep_alive_end_io(struct request *rq, int error)
483{
484        struct nvme_ctrl *ctrl = rq->end_io_data;
485
486        blk_mq_free_request(rq);
487
488        if (error) {
489                dev_err(ctrl->device,
490                        "failed nvme_keep_alive_end_io error=%d\n", error);
491                return;
492        }
493
494        schedule_delayed_work(&ctrl->ka_work, ctrl->kato * HZ);
495}
496
497static int nvme_keep_alive(struct nvme_ctrl *ctrl)
498{
499        struct nvme_command c;
500        struct request *rq;
501
502        memset(&c, 0, sizeof(c));
503        c.common.opcode = nvme_admin_keep_alive;
504
505        rq = nvme_alloc_request(ctrl->admin_q, &c, BLK_MQ_REQ_RESERVED,
506                        NVME_QID_ANY);
507        if (IS_ERR(rq))
508                return PTR_ERR(rq);
509
510        rq->timeout = ctrl->kato * HZ;
511        rq->end_io_data = ctrl;
512
513        blk_execute_rq_nowait(rq->q, NULL, rq, 0, nvme_keep_alive_end_io);
514
515        return 0;
516}
517
518static void nvme_keep_alive_work(struct work_struct *work)
519{
520        struct nvme_ctrl *ctrl = container_of(to_delayed_work(work),
521                        struct nvme_ctrl, ka_work);
522
523        if (nvme_keep_alive(ctrl)) {
524                /* allocation failure, reset the controller */
525                dev_err(ctrl->device, "keep-alive failed\n");
526                ctrl->ops->reset_ctrl(ctrl);
527                return;
528        }
529}
530
531void nvme_start_keep_alive(struct nvme_ctrl *ctrl)
532{
533        if (unlikely(ctrl->kato == 0))
534                return;
535
536        INIT_DELAYED_WORK(&ctrl->ka_work, nvme_keep_alive_work);
537        schedule_delayed_work(&ctrl->ka_work, ctrl->kato * HZ);
538}
539EXPORT_SYMBOL_GPL(nvme_start_keep_alive);
540
541void nvme_stop_keep_alive(struct nvme_ctrl *ctrl)
542{
543        if (unlikely(ctrl->kato == 0))
544                return;
545
546        cancel_delayed_work_sync(&ctrl->ka_work);
547}
548EXPORT_SYMBOL_GPL(nvme_stop_keep_alive);
549
550int nvme_identify_ctrl(struct nvme_ctrl *dev, struct nvme_id_ctrl **id)
551{
552        struct nvme_command c = { };
553        int error;
554
555        /* gcc-4.4.4 (at least) has issues with initializers and anon unions */
556        c.identify.opcode = nvme_admin_identify;
557        c.identify.cns = cpu_to_le32(NVME_ID_CNS_CTRL);
558
559        *id = kmalloc(sizeof(struct nvme_id_ctrl), GFP_KERNEL);
560        if (!*id)
561                return -ENOMEM;
562
563        error = nvme_submit_sync_cmd(dev->admin_q, &c, *id,
564                        sizeof(struct nvme_id_ctrl));
565        if (error)
566                kfree(*id);
567        return error;
568}
569
570static int nvme_identify_ns_list(struct nvme_ctrl *dev, unsigned nsid, __le32 *ns_list)
571{
572        struct nvme_command c = { };
573
574        c.identify.opcode = nvme_admin_identify;
575        c.identify.cns = cpu_to_le32(NVME_ID_CNS_NS_ACTIVE_LIST);
576        c.identify.nsid = cpu_to_le32(nsid);
577        return nvme_submit_sync_cmd(dev->admin_q, &c, ns_list, 0x1000);
578}
579
580int nvme_identify_ns(struct nvme_ctrl *dev, unsigned nsid,
581                struct nvme_id_ns **id)
582{
583        struct nvme_command c = { };
584        int error;
585
586        /* gcc-4.4.4 (at least) has issues with initializers and anon unions */
587        c.identify.opcode = nvme_admin_identify,
588        c.identify.nsid = cpu_to_le32(nsid),
589
590        *id = kmalloc(sizeof(struct nvme_id_ns), GFP_KERNEL);
591        if (!*id)
592                return -ENOMEM;
593
594        error = nvme_submit_sync_cmd(dev->admin_q, &c, *id,
595                        sizeof(struct nvme_id_ns));
596        if (error)
597                kfree(*id);
598        return error;
599}
600
601int nvme_get_features(struct nvme_ctrl *dev, unsigned fid, unsigned nsid,
602                      void *buffer, size_t buflen, u32 *result)
603{
604        struct nvme_command c;
605        struct nvme_completion cqe;
606        int ret;
607
608        memset(&c, 0, sizeof(c));
609        c.features.opcode = nvme_admin_get_features;
610        c.features.nsid = cpu_to_le32(nsid);
611        c.features.fid = cpu_to_le32(fid);
612
613        ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &cqe, buffer, buflen, 0,
614                        NVME_QID_ANY, 0, 0);
615        if (ret >= 0 && result)
616                *result = le32_to_cpu(cqe.result);
617        return ret;
618}
619
620int nvme_set_features(struct nvme_ctrl *dev, unsigned fid, unsigned dword11,
621                      void *buffer, size_t buflen, u32 *result)
622{
623        struct nvme_command c;
624        struct nvme_completion cqe;
625        int ret;
626
627        memset(&c, 0, sizeof(c));
628        c.features.opcode = nvme_admin_set_features;
629        c.features.fid = cpu_to_le32(fid);
630        c.features.dword11 = cpu_to_le32(dword11);
631
632        ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &cqe,
633                        buffer, buflen, 0, NVME_QID_ANY, 0, 0);
634        if (ret >= 0 && result)
635                *result = le32_to_cpu(cqe.result);
636        return ret;
637}
638
639int nvme_get_log_page(struct nvme_ctrl *dev, struct nvme_smart_log **log)
640{
641        struct nvme_command c = { };
642        int error;
643
644        c.common.opcode = nvme_admin_get_log_page,
645        c.common.nsid = cpu_to_le32(0xFFFFFFFF),
646        c.common.cdw10[0] = cpu_to_le32(
647                        (((sizeof(struct nvme_smart_log) / 4) - 1) << 16) |
648                         NVME_LOG_SMART),
649
650        *log = kmalloc(sizeof(struct nvme_smart_log), GFP_KERNEL);
651        if (!*log)
652                return -ENOMEM;
653
654        error = nvme_submit_sync_cmd(dev->admin_q, &c, *log,
655                        sizeof(struct nvme_smart_log));
656        if (error)
657                kfree(*log);
658        return error;
659}
660
661int nvme_set_queue_count(struct nvme_ctrl *ctrl, int *count)
662{
663        u32 q_count = (*count - 1) | ((*count - 1) << 16);
664        u32 result;
665        int status, nr_io_queues;
666
667        status = nvme_set_features(ctrl, NVME_FEAT_NUM_QUEUES, q_count, NULL, 0,
668                        &result);
669        if (status < 0)
670                return status;
671
672        /*
673         * Degraded controllers might return an error when setting the queue
674         * count.  We still want to be able to bring them online and offer
675         * access to the admin queue, as that might be only way to fix them up.
676         */
677        if (status > 0) {
678                dev_err(ctrl->dev, "Could not set queue count (%d)\n", status);
679                *count = 0;
680        } else {
681                nr_io_queues = min(result & 0xffff, result >> 16) + 1;
682                *count = min(*count, nr_io_queues);
683        }
684
685        return 0;
686}
687EXPORT_SYMBOL_GPL(nvme_set_queue_count);
688
689static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
690{
691        struct nvme_user_io io;
692        struct nvme_command c;
693        unsigned length, meta_len;
694        void __user *metadata;
695
696        if (copy_from_user(&io, uio, sizeof(io)))
697                return -EFAULT;
698        if (io.flags)
699                return -EINVAL;
700
701        switch (io.opcode) {
702        case nvme_cmd_write:
703        case nvme_cmd_read:
704        case nvme_cmd_compare:
705                break;
706        default:
707                return -EINVAL;
708        }
709
710        length = (io.nblocks + 1) << ns->lba_shift;
711        meta_len = (io.nblocks + 1) * ns->ms;
712        metadata = (void __user *)(uintptr_t)io.metadata;
713
714        if (ns->ext) {
715                length += meta_len;
716                meta_len = 0;
717        } else if (meta_len) {
718                if ((io.metadata & 3) || !io.metadata)
719                        return -EINVAL;
720        }
721
722        memset(&c, 0, sizeof(c));
723        c.rw.opcode = io.opcode;
724        c.rw.flags = io.flags;
725        c.rw.nsid = cpu_to_le32(ns->ns_id);
726        c.rw.slba = cpu_to_le64(io.slba);
727        c.rw.length = cpu_to_le16(io.nblocks);
728        c.rw.control = cpu_to_le16(io.control);
729        c.rw.dsmgmt = cpu_to_le32(io.dsmgmt);
730        c.rw.reftag = cpu_to_le32(io.reftag);
731        c.rw.apptag = cpu_to_le16(io.apptag);
732        c.rw.appmask = cpu_to_le16(io.appmask);
733
734        return __nvme_submit_user_cmd(ns->queue, &c,
735                        (void __user *)(uintptr_t)io.addr, length,
736                        metadata, meta_len, io.slba, NULL, 0);
737}
738
739static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
740                        struct nvme_passthru_cmd __user *ucmd)
741{
742        struct nvme_passthru_cmd cmd;
743        struct nvme_command c;
744        unsigned timeout = 0;
745        int status;
746
747        if (!capable(CAP_SYS_ADMIN))
748                return -EACCES;
749        if (copy_from_user(&cmd, ucmd, sizeof(cmd)))
750                return -EFAULT;
751        if (cmd.flags)
752                return -EINVAL;
753
754        memset(&c, 0, sizeof(c));
755        c.common.opcode = cmd.opcode;
756        c.common.flags = cmd.flags;
757        c.common.nsid = cpu_to_le32(cmd.nsid);
758        c.common.cdw2[0] = cpu_to_le32(cmd.cdw2);
759        c.common.cdw2[1] = cpu_to_le32(cmd.cdw3);
760        c.common.cdw10[0] = cpu_to_le32(cmd.cdw10);
761        c.common.cdw10[1] = cpu_to_le32(cmd.cdw11);
762        c.common.cdw10[2] = cpu_to_le32(cmd.cdw12);
763        c.common.cdw10[3] = cpu_to_le32(cmd.cdw13);
764        c.common.cdw10[4] = cpu_to_le32(cmd.cdw14);
765        c.common.cdw10[5] = cpu_to_le32(cmd.cdw15);
766
767        if (cmd.timeout_ms)
768                timeout = msecs_to_jiffies(cmd.timeout_ms);
769
770        status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,
771                        (void __user *)(uintptr_t)cmd.addr, cmd.data_len,
772                        &cmd.result, timeout);
773        if (status >= 0) {
774                if (put_user(cmd.result, &ucmd->result))
775                        return -EFAULT;
776        }
777
778        return status;
779}
780
781static int nvme_ioctl(struct block_device *bdev, fmode_t mode,
782                unsigned int cmd, unsigned long arg)
783{
784        struct nvme_ns *ns = bdev->bd_disk->private_data;
785
786        switch (cmd) {
787        case NVME_IOCTL_ID:
788                force_successful_syscall_return();
789                return ns->ns_id;
790        case NVME_IOCTL_ADMIN_CMD:
791                return nvme_user_cmd(ns->ctrl, NULL, (void __user *)arg);
792        case NVME_IOCTL_IO_CMD:
793                return nvme_user_cmd(ns->ctrl, ns, (void __user *)arg);
794        case NVME_IOCTL_SUBMIT_IO:
795                return nvme_submit_io(ns, (void __user *)arg);
796#ifdef CONFIG_BLK_DEV_NVME_SCSI
797        case SG_GET_VERSION_NUM:
798                return nvme_sg_get_version_num((void __user *)arg);
799        case SG_IO:
800                return nvme_sg_io(ns, (void __user *)arg);
801#endif
802        default:
803                return -ENOTTY;
804        }
805}
806
807#ifdef CONFIG_COMPAT
808static int nvme_compat_ioctl(struct block_device *bdev, fmode_t mode,
809                        unsigned int cmd, unsigned long arg)
810{
811        switch (cmd) {
812        case SG_IO:
813                return -ENOIOCTLCMD;
814        }
815        return nvme_ioctl(bdev, mode, cmd, arg);
816}
817#else
818#define nvme_compat_ioctl       NULL
819#endif
820
821static int nvme_open(struct block_device *bdev, fmode_t mode)
822{
823        return nvme_get_ns_from_disk(bdev->bd_disk) ? 0 : -ENXIO;
824}
825
826static void nvme_release(struct gendisk *disk, fmode_t mode)
827{
828        struct nvme_ns *ns = disk->private_data;
829
830        module_put(ns->ctrl->ops->module);
831        nvme_put_ns(ns);
832}
833
834static int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo)
835{
836        /* some standard values */
837        geo->heads = 1 << 6;
838        geo->sectors = 1 << 5;
839        geo->cylinders = get_capacity(bdev->bd_disk) >> 11;
840        return 0;
841}
842
843#ifdef CONFIG_BLK_DEV_INTEGRITY
844static void nvme_init_integrity(struct nvme_ns *ns)
845{
846        struct blk_integrity integrity;
847
848        memset(&integrity, 0, sizeof(integrity));
849        switch (ns->pi_type) {
850        case NVME_NS_DPS_PI_TYPE3:
851                integrity.profile = &t10_pi_type3_crc;
852                integrity.tag_size = sizeof(u16) + sizeof(u32);
853                integrity.flags |= BLK_INTEGRITY_DEVICE_CAPABLE;
854                break;
855        case NVME_NS_DPS_PI_TYPE1:
856        case NVME_NS_DPS_PI_TYPE2:
857                integrity.profile = &t10_pi_type1_crc;
858                integrity.tag_size = sizeof(u16);
859                integrity.flags |= BLK_INTEGRITY_DEVICE_CAPABLE;
860                break;
861        default:
862                integrity.profile = NULL;
863                break;
864        }
865        integrity.tuple_size = ns->ms;
866        blk_integrity_register(ns->disk, &integrity);
867        blk_queue_max_integrity_segments(ns->queue, 1);
868}
869#else
870static void nvme_init_integrity(struct nvme_ns *ns)
871{
872}
873#endif /* CONFIG_BLK_DEV_INTEGRITY */
874
875static void nvme_config_discard(struct nvme_ns *ns)
876{
877        struct nvme_ctrl *ctrl = ns->ctrl;
878        u32 logical_block_size = queue_logical_block_size(ns->queue);
879
880        if (ctrl->quirks & NVME_QUIRK_DISCARD_ZEROES)
881                ns->queue->limits.discard_zeroes_data = 1;
882        else
883                ns->queue->limits.discard_zeroes_data = 0;
884
885        ns->queue->limits.discard_alignment = logical_block_size;
886        ns->queue->limits.discard_granularity = logical_block_size;
887        blk_queue_max_discard_sectors(ns->queue, UINT_MAX);
888        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, ns->queue);
889}
890
891static int nvme_revalidate_ns(struct nvme_ns *ns, struct nvme_id_ns **id)
892{
893        if (nvme_identify_ns(ns->ctrl, ns->ns_id, id)) {
894                dev_warn(ns->ctrl->dev, "%s: Identify failure\n", __func__);
895                return -ENODEV;
896        }
897
898        if ((*id)->ncap == 0) {
899                kfree(*id);
900                return -ENODEV;
901        }
902
903        if (ns->ctrl->vs >= NVME_VS(1, 1, 0))
904                memcpy(ns->eui, (*id)->eui64, sizeof(ns->eui));
905        if (ns->ctrl->vs >= NVME_VS(1, 2, 0))
906                memcpy(ns->uuid, (*id)->nguid, sizeof(ns->uuid));
907
908        return 0;
909}
910
911static void __nvme_revalidate_disk(struct gendisk *disk, struct nvme_id_ns *id)
912{
913        struct nvme_ns *ns = disk->private_data;
914        u8 lbaf, pi_type;
915        u16 old_ms;
916        unsigned short bs;
917
918        old_ms = ns->ms;
919        lbaf = id->flbas & NVME_NS_FLBAS_LBA_MASK;
920        ns->lba_shift = id->lbaf[lbaf].ds;
921        ns->ms = le16_to_cpu(id->lbaf[lbaf].ms);
922        ns->ext = ns->ms && (id->flbas & NVME_NS_FLBAS_META_EXT);
923
924        /*
925         * If identify namespace failed, use default 512 byte block size so
926         * block layer can use before failing read/write for 0 capacity.
927         */
928        if (ns->lba_shift == 0)
929                ns->lba_shift = 9;
930        bs = 1 << ns->lba_shift;
931        /* XXX: PI implementation requires metadata equal t10 pi tuple size */
932        pi_type = ns->ms == sizeof(struct t10_pi_tuple) ?
933                                        id->dps & NVME_NS_DPS_PI_MASK : 0;
934
935        blk_mq_freeze_queue(disk->queue);
936        if (blk_get_integrity(disk) && (ns->pi_type != pi_type ||
937                                ns->ms != old_ms ||
938                                bs != queue_logical_block_size(disk->queue) ||
939                                (ns->ms && ns->ext)))
940                blk_integrity_unregister(disk);
941
942        ns->pi_type = pi_type;
943        blk_queue_logical_block_size(ns->queue, bs);
944
945        if (ns->ms && !blk_get_integrity(disk) && !ns->ext)
946                nvme_init_integrity(ns);
947        if (ns->ms && !(ns->ms == 8 && ns->pi_type) && !blk_get_integrity(disk))
948                set_capacity(disk, 0);
949        else
950                set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
951
952        if (ns->ctrl->oncs & NVME_CTRL_ONCS_DSM)
953                nvme_config_discard(ns);
954        blk_mq_unfreeze_queue(disk->queue);
955}
956
957static int nvme_revalidate_disk(struct gendisk *disk)
958{
959        struct nvme_ns *ns = disk->private_data;
960        struct nvme_id_ns *id = NULL;
961        int ret;
962
963        if (test_bit(NVME_NS_DEAD, &ns->flags)) {
964                set_capacity(disk, 0);
965                return -ENODEV;
966        }
967
968        ret = nvme_revalidate_ns(ns, &id);
969        if (ret)
970                return ret;
971
972        __nvme_revalidate_disk(disk, id);
973        kfree(id);
974
975        return 0;
976}
977
978static char nvme_pr_type(enum pr_type type)
979{
980        switch (type) {
981        case PR_WRITE_EXCLUSIVE:
982                return 1;
983        case PR_EXCLUSIVE_ACCESS:
984                return 2;
985        case PR_WRITE_EXCLUSIVE_REG_ONLY:
986                return 3;
987        case PR_EXCLUSIVE_ACCESS_REG_ONLY:
988                return 4;
989        case PR_WRITE_EXCLUSIVE_ALL_REGS:
990                return 5;
991        case PR_EXCLUSIVE_ACCESS_ALL_REGS:
992                return 6;
993        default:
994                return 0;
995        }
996};
997
998static int nvme_pr_command(struct block_device *bdev, u32 cdw10,
999                                u64 key, u64 sa_key, u8 op)
1000{
1001        struct nvme_ns *ns = bdev->bd_disk->private_data;
1002        struct nvme_command c;
1003        u8 data[16] = { 0, };
1004
1005        put_unaligned_le64(key, &data[0]);
1006        put_unaligned_le64(sa_key, &data[8]);
1007
1008        memset(&c, 0, sizeof(c));
1009        c.common.opcode = op;
1010        c.common.nsid = cpu_to_le32(ns->ns_id);
1011        c.common.cdw10[0] = cpu_to_le32(cdw10);
1012
1013        return nvme_submit_sync_cmd(ns->queue, &c, data, 16);
1014}
1015
1016static int nvme_pr_register(struct block_device *bdev, u64 old,
1017                u64 new, unsigned flags)
1018{
1019        u32 cdw10;
1020
1021        if (flags & ~PR_FL_IGNORE_KEY)
1022                return -EOPNOTSUPP;
1023
1024        cdw10 = old ? 2 : 0;
1025        cdw10 |= (flags & PR_FL_IGNORE_KEY) ? 1 << 3 : 0;
1026        cdw10 |= (1 << 30) | (1 << 31); /* PTPL=1 */
1027        return nvme_pr_command(bdev, cdw10, old, new, nvme_cmd_resv_register);
1028}
1029
1030static int nvme_pr_reserve(struct block_device *bdev, u64 key,
1031                enum pr_type type, unsigned flags)
1032{
1033        u32 cdw10;
1034
1035        if (flags & ~PR_FL_IGNORE_KEY)
1036                return -EOPNOTSUPP;
1037
1038        cdw10 = nvme_pr_type(type) << 8;
1039        cdw10 |= ((flags & PR_FL_IGNORE_KEY) ? 1 << 3 : 0);
1040        return nvme_pr_command(bdev, cdw10, key, 0, nvme_cmd_resv_acquire);
1041}
1042
1043static int nvme_pr_preempt(struct block_device *bdev, u64 old, u64 new,
1044                enum pr_type type, bool abort)
1045{
1046        u32 cdw10 = nvme_pr_type(type) << 8 | abort ? 2 : 1;
1047        return nvme_pr_command(bdev, cdw10, old, new, nvme_cmd_resv_acquire);
1048}
1049
1050static int nvme_pr_clear(struct block_device *bdev, u64 key)
1051{
1052        u32 cdw10 = 1 | (key ? 1 << 3 : 0);
1053        return nvme_pr_command(bdev, cdw10, key, 0, nvme_cmd_resv_register);
1054}
1055
1056static int nvme_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
1057{
1058        u32 cdw10 = nvme_pr_type(type) << 8 | key ? 1 << 3 : 0;
1059        return nvme_pr_command(bdev, cdw10, key, 0, nvme_cmd_resv_release);
1060}
1061
1062static const struct pr_ops nvme_pr_ops = {
1063        .pr_register    = nvme_pr_register,
1064        .pr_reserve     = nvme_pr_reserve,
1065        .pr_release     = nvme_pr_release,
1066        .pr_preempt     = nvme_pr_preempt,
1067        .pr_clear       = nvme_pr_clear,
1068};
1069
1070static const struct block_device_operations nvme_fops = {
1071        .owner          = THIS_MODULE,
1072        .ioctl          = nvme_ioctl,
1073        .compat_ioctl   = nvme_compat_ioctl,
1074        .open           = nvme_open,
1075        .release        = nvme_release,
1076        .getgeo         = nvme_getgeo,
1077        .revalidate_disk= nvme_revalidate_disk,
1078        .pr_ops         = &nvme_pr_ops,
1079};
1080
1081static int nvme_wait_ready(struct nvme_ctrl *ctrl, u64 cap, bool enabled)
1082{
1083        unsigned long timeout =
1084                ((NVME_CAP_TIMEOUT(cap) + 1) * HZ / 2) + jiffies;
1085        u32 csts, bit = enabled ? NVME_CSTS_RDY : 0;
1086        int ret;
1087
1088        while ((ret = ctrl->ops->reg_read32(ctrl, NVME_REG_CSTS, &csts)) == 0) {
1089                if (csts == ~0)
1090                        return -ENODEV;
1091                if ((csts & NVME_CSTS_RDY) == bit)
1092                        break;
1093
1094                msleep(100);
1095                if (fatal_signal_pending(current))
1096                        return -EINTR;
1097                if (time_after(jiffies, timeout)) {
1098                        dev_err(ctrl->device,
1099                                "Device not ready; aborting %s\n", enabled ?
1100                                                "initialisation" : "reset");
1101                        return -ENODEV;
1102                }
1103        }
1104
1105        return ret;
1106}
1107
1108/*
1109 * If the device has been passed off to us in an enabled state, just clear
1110 * the enabled bit.  The spec says we should set the 'shutdown notification
1111 * bits', but doing so may cause the device to complete commands to the
1112 * admin queue ... and we don't know what memory that might be pointing at!
1113 */
1114int nvme_disable_ctrl(struct nvme_ctrl *ctrl, u64 cap)
1115{
1116        int ret;
1117
1118        ctrl->ctrl_config &= ~NVME_CC_SHN_MASK;
1119        ctrl->ctrl_config &= ~NVME_CC_ENABLE;
1120
1121        ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC, ctrl->ctrl_config);
1122        if (ret)
1123                return ret;
1124
1125        if (ctrl->quirks & NVME_QUIRK_DELAY_BEFORE_CHK_RDY)
1126                msleep(NVME_QUIRK_DELAY_AMOUNT);
1127
1128        return nvme_wait_ready(ctrl, cap, false);
1129}
1130EXPORT_SYMBOL_GPL(nvme_disable_ctrl);
1131
1132int nvme_enable_ctrl(struct nvme_ctrl *ctrl, u64 cap)
1133{
1134        /*
1135         * Default to a 4K page size, with the intention to update this
1136         * path in the future to accomodate architectures with differing
1137         * kernel and IO page sizes.
1138         */
1139        unsigned dev_page_min = NVME_CAP_MPSMIN(cap) + 12, page_shift = 12;
1140        int ret;
1141
1142        if (page_shift < dev_page_min) {
1143                dev_err(ctrl->device,
1144                        "Minimum device page size %u too large for host (%u)\n",
1145                        1 << dev_page_min, 1 << page_shift);
1146                return -ENODEV;
1147        }
1148
1149        ctrl->page_size = 1 << page_shift;
1150
1151        ctrl->ctrl_config = NVME_CC_CSS_NVM;
1152        ctrl->ctrl_config |= (page_shift - 12) << NVME_CC_MPS_SHIFT;
1153        ctrl->ctrl_config |= NVME_CC_ARB_RR | NVME_CC_SHN_NONE;
1154        ctrl->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES;
1155        ctrl->ctrl_config |= NVME_CC_ENABLE;
1156
1157        ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC, ctrl->ctrl_config);
1158        if (ret)
1159                return ret;
1160        return nvme_wait_ready(ctrl, cap, true);
1161}
1162EXPORT_SYMBOL_GPL(nvme_enable_ctrl);
1163
1164int nvme_shutdown_ctrl(struct nvme_ctrl *ctrl)
1165{
1166        unsigned long timeout = SHUTDOWN_TIMEOUT + jiffies;
1167        u32 csts;
1168        int ret;
1169
1170        ctrl->ctrl_config &= ~NVME_CC_SHN_MASK;
1171        ctrl->ctrl_config |= NVME_CC_SHN_NORMAL;
1172
1173        ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC, ctrl->ctrl_config);
1174        if (ret)
1175                return ret;
1176
1177        while ((ret = ctrl->ops->reg_read32(ctrl, NVME_REG_CSTS, &csts)) == 0) {
1178                if ((csts & NVME_CSTS_SHST_MASK) == NVME_CSTS_SHST_CMPLT)
1179                        break;
1180
1181                msleep(100);
1182                if (fatal_signal_pending(current))
1183                        return -EINTR;
1184                if (time_after(jiffies, timeout)) {
1185                        dev_err(ctrl->device,
1186                                "Device shutdown incomplete; abort shutdown\n");
1187                        return -ENODEV;
1188                }
1189        }
1190
1191        return ret;
1192}
1193EXPORT_SYMBOL_GPL(nvme_shutdown_ctrl);
1194
1195static void nvme_set_queue_limits(struct nvme_ctrl *ctrl,
1196                struct request_queue *q)
1197{
1198        bool vwc = false;
1199
1200        if (ctrl->max_hw_sectors) {
1201                u32 max_segments =
1202                        (ctrl->max_hw_sectors / (ctrl->page_size >> 9)) + 1;
1203
1204                blk_queue_max_hw_sectors(q, ctrl->max_hw_sectors);
1205                blk_queue_max_segments(q, min_t(u32, max_segments, USHRT_MAX));
1206        }
1207        if (ctrl->quirks & NVME_QUIRK_STRIPE_SIZE)
1208                blk_queue_chunk_sectors(q, ctrl->max_hw_sectors);
1209        blk_queue_virt_boundary(q, ctrl->page_size - 1);
1210        if (ctrl->vwc & NVME_CTRL_VWC_PRESENT)
1211                vwc = true;
1212        blk_queue_write_cache(q, vwc, vwc);
1213}
1214
1215/*
1216 * Initialize the cached copies of the Identify data and various controller
1217 * register in our nvme_ctrl structure.  This should be called as soon as
1218 * the admin queue is fully up and running.
1219 */
1220int nvme_init_identify(struct nvme_ctrl *ctrl)
1221{
1222        struct nvme_id_ctrl *id;
1223        u64 cap;
1224        int ret, page_shift;
1225        u32 max_hw_sectors;
1226
1227        ret = ctrl->ops->reg_read32(ctrl, NVME_REG_VS, &ctrl->vs);
1228        if (ret) {
1229                dev_err(ctrl->device, "Reading VS failed (%d)\n", ret);
1230                return ret;
1231        }
1232
1233        ret = ctrl->ops->reg_read64(ctrl, NVME_REG_CAP, &cap);
1234        if (ret) {
1235                dev_err(ctrl->device, "Reading CAP failed (%d)\n", ret);
1236                return ret;
1237        }
1238        page_shift = NVME_CAP_MPSMIN(cap) + 12;
1239
1240        if (ctrl->vs >= NVME_VS(1, 1, 0))
1241                ctrl->subsystem = NVME_CAP_NSSRC(cap);
1242
1243        ret = nvme_identify_ctrl(ctrl, &id);
1244        if (ret) {
1245                dev_err(ctrl->device, "Identify Controller failed (%d)\n", ret);
1246                return -EIO;
1247        }
1248
1249        ctrl->vid = le16_to_cpu(id->vid);
1250        ctrl->oncs = le16_to_cpup(&id->oncs);
1251        atomic_set(&ctrl->abort_limit, id->acl + 1);
1252        ctrl->vwc = id->vwc;
1253        ctrl->cntlid = le16_to_cpup(&id->cntlid);
1254        memcpy(ctrl->serial, id->sn, sizeof(id->sn));
1255        memcpy(ctrl->model, id->mn, sizeof(id->mn));
1256        memcpy(ctrl->firmware_rev, id->fr, sizeof(id->fr));
1257        if (id->mdts)
1258                max_hw_sectors = 1 << (id->mdts + page_shift - 9);
1259        else
1260                max_hw_sectors = UINT_MAX;
1261        ctrl->max_hw_sectors =
1262                min_not_zero(ctrl->max_hw_sectors, max_hw_sectors);
1263
1264        nvme_set_queue_limits(ctrl, ctrl->admin_q);
1265        ctrl->sgls = le32_to_cpu(id->sgls);
1266        ctrl->kas = le16_to_cpu(id->kas);
1267
1268        if (ctrl->ops->is_fabrics) {
1269                ctrl->icdoff = le16_to_cpu(id->icdoff);
1270                ctrl->ioccsz = le32_to_cpu(id->ioccsz);
1271                ctrl->iorcsz = le32_to_cpu(id->iorcsz);
1272                ctrl->maxcmd = le16_to_cpu(id->maxcmd);
1273
1274                /*
1275                 * In fabrics we need to verify the cntlid matches the
1276                 * admin connect
1277                 */
1278                if (ctrl->cntlid != le16_to_cpu(id->cntlid))
1279                        ret = -EINVAL;
1280
1281                if (!ctrl->opts->discovery_nqn && !ctrl->kas) {
1282                        dev_err(ctrl->dev,
1283                                "keep-alive support is mandatory for fabrics\n");
1284                        ret = -EINVAL;
1285                }
1286        } else {
1287                ctrl->cntlid = le16_to_cpu(id->cntlid);
1288        }
1289
1290        kfree(id);
1291        return ret;
1292}
1293EXPORT_SYMBOL_GPL(nvme_init_identify);
1294
1295static int nvme_dev_open(struct inode *inode, struct file *file)
1296{
1297        struct nvme_ctrl *ctrl;
1298        int instance = iminor(inode);
1299        int ret = -ENODEV;
1300
1301        spin_lock(&dev_list_lock);
1302        list_for_each_entry(ctrl, &nvme_ctrl_list, node) {
1303                if (ctrl->instance != instance)
1304                        continue;
1305
1306                if (!ctrl->admin_q) {
1307                        ret = -EWOULDBLOCK;
1308                        break;
1309                }
1310                if (!kref_get_unless_zero(&ctrl->kref))
1311                        break;
1312                file->private_data = ctrl;
1313                ret = 0;
1314                break;
1315        }
1316        spin_unlock(&dev_list_lock);
1317
1318        return ret;
1319}
1320
1321static int nvme_dev_release(struct inode *inode, struct file *file)
1322{
1323        nvme_put_ctrl(file->private_data);
1324        return 0;
1325}
1326
1327static int nvme_dev_user_cmd(struct nvme_ctrl *ctrl, void __user *argp)
1328{
1329        struct nvme_ns *ns;
1330        int ret;
1331
1332        mutex_lock(&ctrl->namespaces_mutex);
1333        if (list_empty(&ctrl->namespaces)) {
1334                ret = -ENOTTY;
1335                goto out_unlock;
1336        }
1337
1338        ns = list_first_entry(&ctrl->namespaces, struct nvme_ns, list);
1339        if (ns != list_last_entry(&ctrl->namespaces, struct nvme_ns, list)) {
1340                dev_warn(ctrl->device,
1341                        "NVME_IOCTL_IO_CMD not supported when multiple namespaces present!\n");
1342                ret = -EINVAL;
1343                goto out_unlock;
1344        }
1345
1346        dev_warn(ctrl->device,
1347                "using deprecated NVME_IOCTL_IO_CMD ioctl on the char device!\n");
1348        kref_get(&ns->kref);
1349        mutex_unlock(&ctrl->namespaces_mutex);
1350
1351        ret = nvme_user_cmd(ctrl, ns, argp);
1352        nvme_put_ns(ns);
1353        return ret;
1354
1355out_unlock:
1356        mutex_unlock(&ctrl->namespaces_mutex);
1357        return ret;
1358}
1359
1360static long nvme_dev_ioctl(struct file *file, unsigned int cmd,
1361                unsigned long arg)
1362{
1363        struct nvme_ctrl *ctrl = file->private_data;
1364        void __user *argp = (void __user *)arg;
1365
1366        switch (cmd) {
1367        case NVME_IOCTL_ADMIN_CMD:
1368                return nvme_user_cmd(ctrl, NULL, argp);
1369        case NVME_IOCTL_IO_CMD:
1370                return nvme_dev_user_cmd(ctrl, argp);
1371        case NVME_IOCTL_RESET:
1372                dev_warn(ctrl->device, "resetting controller\n");
1373                return ctrl->ops->reset_ctrl(ctrl);
1374        case NVME_IOCTL_SUBSYS_RESET:
1375                return nvme_reset_subsystem(ctrl);
1376        case NVME_IOCTL_RESCAN:
1377                nvme_queue_scan(ctrl);
1378                return 0;
1379        default:
1380                return -ENOTTY;
1381        }
1382}
1383
1384static const struct file_operations nvme_dev_fops = {
1385        .owner          = THIS_MODULE,
1386        .open           = nvme_dev_open,
1387        .release        = nvme_dev_release,
1388        .unlocked_ioctl = nvme_dev_ioctl,
1389        .compat_ioctl   = nvme_dev_ioctl,
1390};
1391
1392static ssize_t nvme_sysfs_reset(struct device *dev,
1393                                struct device_attribute *attr, const char *buf,
1394                                size_t count)
1395{
1396        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1397        int ret;
1398
1399        ret = ctrl->ops->reset_ctrl(ctrl);
1400        if (ret < 0)
1401                return ret;
1402        return count;
1403}
1404static DEVICE_ATTR(reset_controller, S_IWUSR, NULL, nvme_sysfs_reset);
1405
1406static ssize_t nvme_sysfs_rescan(struct device *dev,
1407                                struct device_attribute *attr, const char *buf,
1408                                size_t count)
1409{
1410        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1411
1412        nvme_queue_scan(ctrl);
1413        return count;
1414}
1415static DEVICE_ATTR(rescan_controller, S_IWUSR, NULL, nvme_sysfs_rescan);
1416
1417static ssize_t wwid_show(struct device *dev, struct device_attribute *attr,
1418                                                                char *buf)
1419{
1420        struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
1421        struct nvme_ctrl *ctrl = ns->ctrl;
1422        int serial_len = sizeof(ctrl->serial);
1423        int model_len = sizeof(ctrl->model);
1424
1425        if (memchr_inv(ns->uuid, 0, sizeof(ns->uuid)))
1426                return sprintf(buf, "eui.%16phN\n", ns->uuid);
1427
1428        if (memchr_inv(ns->eui, 0, sizeof(ns->eui)))
1429                return sprintf(buf, "eui.%8phN\n", ns->eui);
1430
1431        while (ctrl->serial[serial_len - 1] == ' ')
1432                serial_len--;
1433        while (ctrl->model[model_len - 1] == ' ')
1434                model_len--;
1435
1436        return sprintf(buf, "nvme.%04x-%*phN-%*phN-%08x\n", ctrl->vid,
1437                serial_len, ctrl->serial, model_len, ctrl->model, ns->ns_id);
1438}
1439static DEVICE_ATTR(wwid, S_IRUGO, wwid_show, NULL);
1440
1441static ssize_t uuid_show(struct device *dev, struct device_attribute *attr,
1442                                                                char *buf)
1443{
1444        struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
1445        return sprintf(buf, "%pU\n", ns->uuid);
1446}
1447static DEVICE_ATTR(uuid, S_IRUGO, uuid_show, NULL);
1448
1449static ssize_t eui_show(struct device *dev, struct device_attribute *attr,
1450                                                                char *buf)
1451{
1452        struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
1453        return sprintf(buf, "%8phd\n", ns->eui);
1454}
1455static DEVICE_ATTR(eui, S_IRUGO, eui_show, NULL);
1456
1457static ssize_t nsid_show(struct device *dev, struct device_attribute *attr,
1458                                                                char *buf)
1459{
1460        struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
1461        return sprintf(buf, "%d\n", ns->ns_id);
1462}
1463static DEVICE_ATTR(nsid, S_IRUGO, nsid_show, NULL);
1464
1465static struct attribute *nvme_ns_attrs[] = {
1466        &dev_attr_wwid.attr,
1467        &dev_attr_uuid.attr,
1468        &dev_attr_eui.attr,
1469        &dev_attr_nsid.attr,
1470        NULL,
1471};
1472
1473static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj,
1474                struct attribute *a, int n)
1475{
1476        struct device *dev = container_of(kobj, struct device, kobj);
1477        struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
1478
1479        if (a == &dev_attr_uuid.attr) {
1480                if (!memchr_inv(ns->uuid, 0, sizeof(ns->uuid)))
1481                        return 0;
1482        }
1483        if (a == &dev_attr_eui.attr) {
1484                if (!memchr_inv(ns->eui, 0, sizeof(ns->eui)))
1485                        return 0;
1486        }
1487        return a->mode;
1488}
1489
1490static const struct attribute_group nvme_ns_attr_group = {
1491        .attrs          = nvme_ns_attrs,
1492        .is_visible     = nvme_ns_attrs_are_visible,
1493};
1494
1495#define nvme_show_str_function(field)                                           \
1496static ssize_t  field##_show(struct device *dev,                                \
1497                            struct device_attribute *attr, char *buf)           \
1498{                                                                               \
1499        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);                          \
1500        return sprintf(buf, "%.*s\n", (int)sizeof(ctrl->field), ctrl->field);   \
1501}                                                                               \
1502static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);
1503
1504#define nvme_show_int_function(field)                                           \
1505static ssize_t  field##_show(struct device *dev,                                \
1506                            struct device_attribute *attr, char *buf)           \
1507{                                                                               \
1508        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);                          \
1509        return sprintf(buf, "%d\n", ctrl->field);       \
1510}                                                                               \
1511static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);
1512
1513nvme_show_str_function(model);
1514nvme_show_str_function(serial);
1515nvme_show_str_function(firmware_rev);
1516nvme_show_int_function(cntlid);
1517
1518static ssize_t nvme_sysfs_delete(struct device *dev,
1519                                struct device_attribute *attr, const char *buf,
1520                                size_t count)
1521{
1522        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1523
1524        if (device_remove_file_self(dev, attr))
1525                ctrl->ops->delete_ctrl(ctrl);
1526        return count;
1527}
1528static DEVICE_ATTR(delete_controller, S_IWUSR, NULL, nvme_sysfs_delete);
1529
1530static ssize_t nvme_sysfs_show_transport(struct device *dev,
1531                                         struct device_attribute *attr,
1532                                         char *buf)
1533{
1534        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1535
1536        return snprintf(buf, PAGE_SIZE, "%s\n", ctrl->ops->name);
1537}
1538static DEVICE_ATTR(transport, S_IRUGO, nvme_sysfs_show_transport, NULL);
1539
1540static ssize_t nvme_sysfs_show_subsysnqn(struct device *dev,
1541                                         struct device_attribute *attr,
1542                                         char *buf)
1543{
1544        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1545
1546        return snprintf(buf, PAGE_SIZE, "%s\n",
1547                        ctrl->ops->get_subsysnqn(ctrl));
1548}
1549static DEVICE_ATTR(subsysnqn, S_IRUGO, nvme_sysfs_show_subsysnqn, NULL);
1550
1551static ssize_t nvme_sysfs_show_address(struct device *dev,
1552                                         struct device_attribute *attr,
1553                                         char *buf)
1554{
1555        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1556
1557        return ctrl->ops->get_address(ctrl, buf, PAGE_SIZE);
1558}
1559static DEVICE_ATTR(address, S_IRUGO, nvme_sysfs_show_address, NULL);
1560
1561static struct attribute *nvme_dev_attrs[] = {
1562        &dev_attr_reset_controller.attr,
1563        &dev_attr_rescan_controller.attr,
1564        &dev_attr_model.attr,
1565        &dev_attr_serial.attr,
1566        &dev_attr_firmware_rev.attr,
1567        &dev_attr_cntlid.attr,
1568        &dev_attr_delete_controller.attr,
1569        &dev_attr_transport.attr,
1570        &dev_attr_subsysnqn.attr,
1571        &dev_attr_address.attr,
1572        NULL
1573};
1574
1575#define CHECK_ATTR(ctrl, a, name)               \
1576        if ((a) == &dev_attr_##name.attr &&     \
1577            !(ctrl)->ops->get_##name)           \
1578                return 0
1579
1580static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj,
1581                struct attribute *a, int n)
1582{
1583        struct device *dev = container_of(kobj, struct device, kobj);
1584        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
1585
1586        if (a == &dev_attr_delete_controller.attr) {
1587                if (!ctrl->ops->delete_ctrl)
1588                        return 0;
1589        }
1590
1591        CHECK_ATTR(ctrl, a, subsysnqn);
1592        CHECK_ATTR(ctrl, a, address);
1593
1594        return a->mode;
1595}
1596
1597static struct attribute_group nvme_dev_attrs_group = {
1598        .attrs          = nvme_dev_attrs,
1599        .is_visible     = nvme_dev_attrs_are_visible,
1600};
1601
1602static const struct attribute_group *nvme_dev_attr_groups[] = {
1603        &nvme_dev_attrs_group,
1604        NULL,
1605};
1606
1607static int ns_cmp(void *priv, struct list_head *a, struct list_head *b)
1608{
1609        struct nvme_ns *nsa = container_of(a, struct nvme_ns, list);
1610        struct nvme_ns *nsb = container_of(b, struct nvme_ns, list);
1611
1612        return nsa->ns_id - nsb->ns_id;
1613}
1614
1615static struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid)
1616{
1617        struct nvme_ns *ns, *ret = NULL;
1618
1619        mutex_lock(&ctrl->namespaces_mutex);
1620        list_for_each_entry(ns, &ctrl->namespaces, list) {
1621                if (ns->ns_id == nsid) {
1622                        kref_get(&ns->kref);
1623                        ret = ns;
1624                        break;
1625                }
1626                if (ns->ns_id > nsid)
1627                        break;
1628        }
1629        mutex_unlock(&ctrl->namespaces_mutex);
1630        return ret;
1631}
1632
1633static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid)
1634{
1635        struct nvme_ns *ns;
1636        struct gendisk *disk;
1637        struct nvme_id_ns *id;
1638        char disk_name[DISK_NAME_LEN];
1639        int node = dev_to_node(ctrl->dev);
1640
1641        ns = kzalloc_node(sizeof(*ns), GFP_KERNEL, node);
1642        if (!ns)
1643                return;
1644
1645        ns->instance = ida_simple_get(&ctrl->ns_ida, 1, 0, GFP_KERNEL);
1646        if (ns->instance < 0)
1647                goto out_free_ns;
1648
1649        ns->queue = blk_mq_init_queue(ctrl->tagset);
1650        if (IS_ERR(ns->queue))
1651                goto out_release_instance;
1652        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, ns->queue);
1653        ns->queue->queuedata = ns;
1654        ns->ctrl = ctrl;
1655
1656        kref_init(&ns->kref);
1657        ns->ns_id = nsid;
1658        ns->lba_shift = 9; /* set to a default value for 512 until disk is validated */
1659
1660        blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
1661        nvme_set_queue_limits(ctrl, ns->queue);
1662
1663        sprintf(disk_name, "nvme%dn%d", ctrl->instance, ns->instance);
1664
1665        if (nvme_revalidate_ns(ns, &id))
1666                goto out_free_queue;
1667
1668        if (nvme_nvm_ns_supported(ns, id)) {
1669                if (nvme_nvm_register(ns, disk_name, node,
1670                                                        &nvme_ns_attr_group)) {
1671                        dev_warn(ctrl->dev, "%s: LightNVM init failure\n",
1672                                                                __func__);
1673                        goto out_free_id;
1674                }
1675        } else {
1676                disk = alloc_disk_node(0, node);
1677                if (!disk)
1678                        goto out_free_id;
1679
1680                disk->fops = &nvme_fops;
1681                disk->private_data = ns;
1682                disk->queue = ns->queue;
1683                disk->flags = GENHD_FL_EXT_DEVT;
1684                memcpy(disk->disk_name, disk_name, DISK_NAME_LEN);
1685                ns->disk = disk;
1686
1687                __nvme_revalidate_disk(disk, id);
1688        }
1689
1690        mutex_lock(&ctrl->namespaces_mutex);
1691        list_add_tail(&ns->list, &ctrl->namespaces);
1692        mutex_unlock(&ctrl->namespaces_mutex);
1693
1694        kref_get(&ctrl->kref);
1695
1696        kfree(id);
1697
1698        if (ns->ndev)
1699                return;
1700
1701        device_add_disk(ctrl->device, ns->disk);
1702        if (sysfs_create_group(&disk_to_dev(ns->disk)->kobj,
1703                                        &nvme_ns_attr_group))
1704                pr_warn("%s: failed to create sysfs group for identification\n",
1705                        ns->disk->disk_name);
1706        return;
1707 out_free_id:
1708        kfree(id);
1709 out_free_queue:
1710        blk_cleanup_queue(ns->queue);
1711 out_release_instance:
1712        ida_simple_remove(&ctrl->ns_ida, ns->instance);
1713 out_free_ns:
1714        kfree(ns);
1715}
1716
1717static void nvme_ns_remove(struct nvme_ns *ns)
1718{
1719        if (test_and_set_bit(NVME_NS_REMOVING, &ns->flags))
1720                return;
1721
1722        if (ns->disk && ns->disk->flags & GENHD_FL_UP) {
1723                if (blk_get_integrity(ns->disk))
1724                        blk_integrity_unregister(ns->disk);
1725                sysfs_remove_group(&disk_to_dev(ns->disk)->kobj,
1726                                        &nvme_ns_attr_group);
1727                del_gendisk(ns->disk);
1728                blk_mq_abort_requeue_list(ns->queue);
1729                blk_cleanup_queue(ns->queue);
1730        }
1731
1732        mutex_lock(&ns->ctrl->namespaces_mutex);
1733        list_del_init(&ns->list);
1734        mutex_unlock(&ns->ctrl->namespaces_mutex);
1735
1736        nvme_put_ns(ns);
1737}
1738
1739static void nvme_validate_ns(struct nvme_ctrl *ctrl, unsigned nsid)
1740{
1741        struct nvme_ns *ns;
1742
1743        ns = nvme_find_get_ns(ctrl, nsid);
1744        if (ns) {
1745                if (ns->disk && revalidate_disk(ns->disk))
1746                        nvme_ns_remove(ns);
1747                nvme_put_ns(ns);
1748        } else
1749                nvme_alloc_ns(ctrl, nsid);
1750}
1751
1752static void nvme_remove_invalid_namespaces(struct nvme_ctrl *ctrl,
1753                                        unsigned nsid)
1754{
1755        struct nvme_ns *ns, *next;
1756
1757        list_for_each_entry_safe(ns, next, &ctrl->namespaces, list) {
1758                if (ns->ns_id > nsid)
1759                        nvme_ns_remove(ns);
1760        }
1761}
1762
1763static int nvme_scan_ns_list(struct nvme_ctrl *ctrl, unsigned nn)
1764{
1765        struct nvme_ns *ns;
1766        __le32 *ns_list;
1767        unsigned i, j, nsid, prev = 0, num_lists = DIV_ROUND_UP(nn, 1024);
1768        int ret = 0;
1769
1770        ns_list = kzalloc(0x1000, GFP_KERNEL);
1771        if (!ns_list)
1772                return -ENOMEM;
1773
1774        for (i = 0; i < num_lists; i++) {
1775                ret = nvme_identify_ns_list(ctrl, prev, ns_list);
1776                if (ret)
1777                        goto free;
1778
1779                for (j = 0; j < min(nn, 1024U); j++) {
1780                        nsid = le32_to_cpu(ns_list[j]);
1781                        if (!nsid)
1782                                goto out;
1783
1784                        nvme_validate_ns(ctrl, nsid);
1785
1786                        while (++prev < nsid) {
1787                                ns = nvme_find_get_ns(ctrl, prev);
1788                                if (ns) {
1789                                        nvme_ns_remove(ns);
1790                                        nvme_put_ns(ns);
1791                                }
1792                        }
1793                }
1794                nn -= j;
1795        }
1796 out:
1797        nvme_remove_invalid_namespaces(ctrl, prev);
1798 free:
1799        kfree(ns_list);
1800        return ret;
1801}
1802
1803static void nvme_scan_ns_sequential(struct nvme_ctrl *ctrl, unsigned nn)
1804{
1805        unsigned i;
1806
1807        for (i = 1; i <= nn; i++)
1808                nvme_validate_ns(ctrl, i);
1809
1810        nvme_remove_invalid_namespaces(ctrl, nn);
1811}
1812
1813static void nvme_scan_work(struct work_struct *work)
1814{
1815        struct nvme_ctrl *ctrl =
1816                container_of(work, struct nvme_ctrl, scan_work);
1817        struct nvme_id_ctrl *id;
1818        unsigned nn;
1819
1820        if (ctrl->state != NVME_CTRL_LIVE)
1821                return;
1822
1823        if (nvme_identify_ctrl(ctrl, &id))
1824                return;
1825
1826        nn = le32_to_cpu(id->nn);
1827        if (ctrl->vs >= NVME_VS(1, 1, 0) &&
1828            !(ctrl->quirks & NVME_QUIRK_IDENTIFY_CNS)) {
1829                if (!nvme_scan_ns_list(ctrl, nn))
1830                        goto done;
1831        }
1832        nvme_scan_ns_sequential(ctrl, nn);
1833 done:
1834        mutex_lock(&ctrl->namespaces_mutex);
1835        list_sort(NULL, &ctrl->namespaces, ns_cmp);
1836        mutex_unlock(&ctrl->namespaces_mutex);
1837        kfree(id);
1838}
1839
1840void nvme_queue_scan(struct nvme_ctrl *ctrl)
1841{
1842        /*
1843         * Do not queue new scan work when a controller is reset during
1844         * removal.
1845         */
1846        if (ctrl->state == NVME_CTRL_LIVE)
1847                schedule_work(&ctrl->scan_work);
1848}
1849EXPORT_SYMBOL_GPL(nvme_queue_scan);
1850
1851/*
1852 * This function iterates the namespace list unlocked to allow recovery from
1853 * controller failure. It is up to the caller to ensure the namespace list is
1854 * not modified by scan work while this function is executing.
1855 */
1856void nvme_remove_namespaces(struct nvme_ctrl *ctrl)
1857{
1858        struct nvme_ns *ns, *next;
1859
1860        /*
1861         * The dead states indicates the controller was not gracefully
1862         * disconnected. In that case, we won't be able to flush any data while
1863         * removing the namespaces' disks; fail all the queues now to avoid
1864         * potentially having to clean up the failed sync later.
1865         */
1866        if (ctrl->state == NVME_CTRL_DEAD)
1867                nvme_kill_queues(ctrl);
1868
1869        list_for_each_entry_safe(ns, next, &ctrl->namespaces, list)
1870                nvme_ns_remove(ns);
1871}
1872EXPORT_SYMBOL_GPL(nvme_remove_namespaces);
1873
1874static void nvme_async_event_work(struct work_struct *work)
1875{
1876        struct nvme_ctrl *ctrl =
1877                container_of(work, struct nvme_ctrl, async_event_work);
1878
1879        spin_lock_irq(&ctrl->lock);
1880        while (ctrl->event_limit > 0) {
1881                int aer_idx = --ctrl->event_limit;
1882
1883                spin_unlock_irq(&ctrl->lock);
1884                ctrl->ops->submit_async_event(ctrl, aer_idx);
1885                spin_lock_irq(&ctrl->lock);
1886        }
1887        spin_unlock_irq(&ctrl->lock);
1888}
1889
1890void nvme_complete_async_event(struct nvme_ctrl *ctrl,
1891                struct nvme_completion *cqe)
1892{
1893        u16 status = le16_to_cpu(cqe->status) >> 1;
1894        u32 result = le32_to_cpu(cqe->result);
1895
1896        if (status == NVME_SC_SUCCESS || status == NVME_SC_ABORT_REQ) {
1897                ++ctrl->event_limit;
1898                schedule_work(&ctrl->async_event_work);
1899        }
1900
1901        if (status != NVME_SC_SUCCESS)
1902                return;
1903
1904        switch (result & 0xff07) {
1905        case NVME_AER_NOTICE_NS_CHANGED:
1906                dev_info(ctrl->device, "rescanning\n");
1907                nvme_queue_scan(ctrl);
1908                break;
1909        default:
1910                dev_warn(ctrl->device, "async event result %08x\n", result);
1911        }
1912}
1913EXPORT_SYMBOL_GPL(nvme_complete_async_event);
1914
1915void nvme_queue_async_events(struct nvme_ctrl *ctrl)
1916{
1917        ctrl->event_limit = NVME_NR_AERS;
1918        schedule_work(&ctrl->async_event_work);
1919}
1920EXPORT_SYMBOL_GPL(nvme_queue_async_events);
1921
1922static DEFINE_IDA(nvme_instance_ida);
1923
1924static int nvme_set_instance(struct nvme_ctrl *ctrl)
1925{
1926        int instance, error;
1927
1928        do {
1929                if (!ida_pre_get(&nvme_instance_ida, GFP_KERNEL))
1930                        return -ENODEV;
1931
1932                spin_lock(&dev_list_lock);
1933                error = ida_get_new(&nvme_instance_ida, &instance);
1934                spin_unlock(&dev_list_lock);
1935        } while (error == -EAGAIN);
1936
1937        if (error)
1938                return -ENODEV;
1939
1940        ctrl->instance = instance;
1941        return 0;
1942}
1943
1944static void nvme_release_instance(struct nvme_ctrl *ctrl)
1945{
1946        spin_lock(&dev_list_lock);
1947        ida_remove(&nvme_instance_ida, ctrl->instance);
1948        spin_unlock(&dev_list_lock);
1949}
1950
1951void nvme_uninit_ctrl(struct nvme_ctrl *ctrl)
1952{
1953        flush_work(&ctrl->async_event_work);
1954        flush_work(&ctrl->scan_work);
1955        nvme_remove_namespaces(ctrl);
1956
1957        device_destroy(nvme_class, MKDEV(nvme_char_major, ctrl->instance));
1958
1959        spin_lock(&dev_list_lock);
1960        list_del(&ctrl->node);
1961        spin_unlock(&dev_list_lock);
1962}
1963EXPORT_SYMBOL_GPL(nvme_uninit_ctrl);
1964
1965static void nvme_free_ctrl(struct kref *kref)
1966{
1967        struct nvme_ctrl *ctrl = container_of(kref, struct nvme_ctrl, kref);
1968
1969        put_device(ctrl->device);
1970        nvme_release_instance(ctrl);
1971        ida_destroy(&ctrl->ns_ida);
1972
1973        ctrl->ops->free_ctrl(ctrl);
1974}
1975
1976void nvme_put_ctrl(struct nvme_ctrl *ctrl)
1977{
1978        kref_put(&ctrl->kref, nvme_free_ctrl);
1979}
1980EXPORT_SYMBOL_GPL(nvme_put_ctrl);
1981
1982/*
1983 * Initialize a NVMe controller structures.  This needs to be called during
1984 * earliest initialization so that we have the initialized structured around
1985 * during probing.
1986 */
1987int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev,
1988                const struct nvme_ctrl_ops *ops, unsigned long quirks)
1989{
1990        int ret;
1991
1992        ctrl->state = NVME_CTRL_NEW;
1993        spin_lock_init(&ctrl->lock);
1994        INIT_LIST_HEAD(&ctrl->namespaces);
1995        mutex_init(&ctrl->namespaces_mutex);
1996        kref_init(&ctrl->kref);
1997        ctrl->dev = dev;
1998        ctrl->ops = ops;
1999        ctrl->quirks = quirks;
2000        INIT_WORK(&ctrl->scan_work, nvme_scan_work);
2001        INIT_WORK(&ctrl->async_event_work, nvme_async_event_work);
2002
2003        ret = nvme_set_instance(ctrl);
2004        if (ret)
2005                goto out;
2006
2007        ctrl->device = device_create_with_groups(nvme_class, ctrl->dev,
2008                                MKDEV(nvme_char_major, ctrl->instance),
2009                                ctrl, nvme_dev_attr_groups,
2010                                "nvme%d", ctrl->instance);
2011        if (IS_ERR(ctrl->device)) {
2012                ret = PTR_ERR(ctrl->device);
2013                goto out_release_instance;
2014        }
2015        get_device(ctrl->device);
2016        ida_init(&ctrl->ns_ida);
2017
2018        spin_lock(&dev_list_lock);
2019        list_add_tail(&ctrl->node, &nvme_ctrl_list);
2020        spin_unlock(&dev_list_lock);
2021
2022        return 0;
2023out_release_instance:
2024        nvme_release_instance(ctrl);
2025out:
2026        return ret;
2027}
2028EXPORT_SYMBOL_GPL(nvme_init_ctrl);
2029
2030/**
2031 * nvme_kill_queues(): Ends all namespace queues
2032 * @ctrl: the dead controller that needs to end
2033 *
2034 * Call this function when the driver determines it is unable to get the
2035 * controller in a state capable of servicing IO.
2036 */
2037void nvme_kill_queues(struct nvme_ctrl *ctrl)
2038{
2039        struct nvme_ns *ns;
2040
2041        mutex_lock(&ctrl->namespaces_mutex);
2042        list_for_each_entry(ns, &ctrl->namespaces, list) {
2043                /*
2044                 * Revalidating a dead namespace sets capacity to 0. This will
2045                 * end buffered writers dirtying pages that can't be synced.
2046                 */
2047                if (!ns->disk || test_and_set_bit(NVME_NS_DEAD, &ns->flags))
2048                        continue;
2049                revalidate_disk(ns->disk);
2050                blk_set_queue_dying(ns->queue);
2051                blk_mq_abort_requeue_list(ns->queue);
2052                blk_mq_start_stopped_hw_queues(ns->queue, true);
2053        }
2054        mutex_unlock(&ctrl->namespaces_mutex);
2055}
2056EXPORT_SYMBOL_GPL(nvme_kill_queues);
2057
2058void nvme_stop_queues(struct nvme_ctrl *ctrl)
2059{
2060        struct nvme_ns *ns;
2061
2062        mutex_lock(&ctrl->namespaces_mutex);
2063        list_for_each_entry(ns, &ctrl->namespaces, list) {
2064                spin_lock_irq(ns->queue->queue_lock);
2065                queue_flag_set(QUEUE_FLAG_STOPPED, ns->queue);
2066                spin_unlock_irq(ns->queue->queue_lock);
2067
2068                blk_mq_cancel_requeue_work(ns->queue);
2069                blk_mq_stop_hw_queues(ns->queue);
2070        }
2071        mutex_unlock(&ctrl->namespaces_mutex);
2072}
2073EXPORT_SYMBOL_GPL(nvme_stop_queues);
2074
2075void nvme_start_queues(struct nvme_ctrl *ctrl)
2076{
2077        struct nvme_ns *ns;
2078
2079        mutex_lock(&ctrl->namespaces_mutex);
2080        list_for_each_entry(ns, &ctrl->namespaces, list) {
2081                queue_flag_clear_unlocked(QUEUE_FLAG_STOPPED, ns->queue);
2082                blk_mq_start_stopped_hw_queues(ns->queue, true);
2083                blk_mq_kick_requeue_list(ns->queue);
2084        }
2085        mutex_unlock(&ctrl->namespaces_mutex);
2086}
2087EXPORT_SYMBOL_GPL(nvme_start_queues);
2088
2089int __init nvme_core_init(void)
2090{
2091        int result;
2092
2093        result = __register_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme",
2094                                                        &nvme_dev_fops);
2095        if (result < 0)
2096                return result;
2097        else if (result > 0)
2098                nvme_char_major = result;
2099
2100        nvme_class = class_create(THIS_MODULE, "nvme");
2101        if (IS_ERR(nvme_class)) {
2102                result = PTR_ERR(nvme_class);
2103                goto unregister_chrdev;
2104        }
2105
2106        return 0;
2107
2108 unregister_chrdev:
2109        __unregister_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme");
2110        return result;
2111}
2112
2113void nvme_core_exit(void)
2114{
2115        class_destroy(nvme_class);
2116        __unregister_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme");
2117}
2118
2119MODULE_LICENSE("GPL");
2120MODULE_VERSION("1.0");
2121module_init(nvme_core_init);
2122module_exit(nvme_core_exit);
Note: See TracBrowser for help on using the repository browser.