1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2011-2014, Intel Corporation.
4 * Copyright (c) 2017-2021 Christoph Hellwig.
5 */
6#include <linux/blk-integrity.h>
7#include <linux/ptrace.h> /* for force_successful_syscall_return */
8#include <linux/nvme_ioctl.h>
9#include <linux/io_uring/cmd.h>
10#include "nvme.h"
11
12enum {
13 NVME_IOCTL_VEC = (1 << 0),
14 NVME_IOCTL_PARTITION = (1 << 1),
15};
16
17static bool nvme_cmd_allowed(struct nvme_ns *ns, struct nvme_command *c,
18 unsigned int flags, bool open_for_write)
19{
20 u32 effects;
21
22 /*
23 * Do not allow unprivileged passthrough on partitions, as that allows an
24 * escape from the containment of the partition.
25 */
26 if (flags & NVME_IOCTL_PARTITION)
27 goto admin;
28
29 /*
30 * Do not allow unprivileged processes to send vendor specific or fabrics
31 * commands as we can't be sure about their effects.
32 */
33 if (c->common.opcode >= nvme_cmd_vendor_start ||
34 c->common.opcode == nvme_fabrics_command)
35 goto admin;
36
37 /*
38 * Do not allow unprivileged passthrough of admin commands except
39 * for a subset of identify commands that contain information required
40 * to form proper I/O commands in userspace and do not expose any
41 * potentially sensitive information.
42 */
43 if (!ns) {
44 if (c->common.opcode == nvme_admin_identify) {
45 switch (c->identify.cns) {
46 case NVME_ID_CNS_NS:
47 case NVME_ID_CNS_CS_NS:
48 case NVME_ID_CNS_NS_CS_INDEP:
49 case NVME_ID_CNS_CS_CTRL:
50 case NVME_ID_CNS_CTRL:
51 return true;
52 }
53 }
54 goto admin;
55 }
56
57 /*
58 * Check if the controller provides a Commands Supported and Effects log
59 * and marks this command as supported. If not reject unprivileged
60 * passthrough.
61 */
62 effects = nvme_command_effects(ctrl: ns->ctrl, ns, opcode: c->common.opcode);
63 if (!(effects & NVME_CMD_EFFECTS_CSUPP))
64 goto admin;
65
66 /*
67 * Don't allow passthrough for command that have intrusive (or unknown)
68 * effects.
69 */
70 if (effects & ~(NVME_CMD_EFFECTS_CSUPP | NVME_CMD_EFFECTS_LBCC |
71 NVME_CMD_EFFECTS_UUID_SEL |
72 NVME_CMD_EFFECTS_SCOPE_MASK))
73 goto admin;
74
75 /*
76 * Only allow I/O commands that transfer data to the controller or that
77 * change the logical block contents if the file descriptor is open for
78 * writing.
79 */
80 if ((nvme_is_write(cmd: c) || (effects & NVME_CMD_EFFECTS_LBCC)) &&
81 !open_for_write)
82 goto admin;
83
84 return true;
85admin:
86 return capable(CAP_SYS_ADMIN);
87}
88
89/*
90 * Convert integer values from ioctl structures to user pointers, silently
91 * ignoring the upper bits in the compat case to match behaviour of 32-bit
92 * kernels.
93 */
94static void __user *nvme_to_user_ptr(uintptr_t ptrval)
95{
96 if (in_compat_syscall())
97 ptrval = (compat_uptr_t)ptrval;
98 return (void __user *)ptrval;
99}
100
101static struct request *nvme_alloc_user_request(struct request_queue *q,
102 struct nvme_command *cmd, blk_opf_t rq_flags,
103 blk_mq_req_flags_t blk_flags)
104{
105 struct request *req;
106
107 req = blk_mq_alloc_request(q, opf: nvme_req_op(cmd) | rq_flags, flags: blk_flags);
108 if (IS_ERR(ptr: req))
109 return req;
110 nvme_init_request(req, cmd);
111 nvme_req(req)->flags |= NVME_REQ_USERCMD;
112 return req;
113}
114
115static int nvme_map_user_request(struct request *req, u64 ubuffer,
116 unsigned bufflen, void __user *meta_buffer, unsigned meta_len,
117 struct iov_iter *iter, unsigned int flags)
118{
119 struct request_queue *q = req->q;
120 struct nvme_ns *ns = q->queuedata;
121 struct block_device *bdev = ns ? ns->disk->part0 : NULL;
122 bool supports_metadata = bdev && blk_get_integrity(disk: bdev->bd_disk);
123 struct nvme_ctrl *ctrl = nvme_req(req)->ctrl;
124 bool has_metadata = meta_buffer && meta_len;
125 struct bio *bio = NULL;
126 int ret;
127
128 if (!nvme_ctrl_sgl_supported(ctrl))
129 dev_warn_once(ctrl->device, "using unchecked data buffer\n");
130 if (has_metadata) {
131 if (!supports_metadata)
132 return -EINVAL;
133
134 if (!nvme_ctrl_meta_sgl_supported(ctrl))
135 dev_warn_once(ctrl->device,
136 "using unchecked metadata buffer\n");
137 }
138
139 if (iter)
140 ret = blk_rq_map_user_iov(q, req, NULL, iter, GFP_KERNEL);
141 else
142 ret = blk_rq_map_user_io(req, NULL, nvme_to_user_ptr(ptrval: ubuffer),
143 bufflen, GFP_KERNEL, flags & NVME_IOCTL_VEC, 0,
144 0, rq_data_dir(req));
145 if (ret)
146 return ret;
147
148 if (has_metadata) {
149 ret = blk_rq_integrity_map_user(rq: req, ubuf: meta_buffer, bytes: meta_len);
150 if (ret)
151 goto out_unmap;
152 }
153
154 return ret;
155
156out_unmap:
157 if (bio)
158 blk_rq_unmap_user(bio);
159 return ret;
160}
161
162static int nvme_submit_user_cmd(struct request_queue *q,
163 struct nvme_command *cmd, u64 ubuffer, unsigned bufflen,
164 void __user *meta_buffer, unsigned meta_len,
165 u64 *result, unsigned timeout, unsigned int flags)
166{
167 struct nvme_ns *ns = q->queuedata;
168 struct nvme_ctrl *ctrl;
169 struct request *req;
170 struct bio *bio;
171 u32 effects;
172 int ret;
173
174 req = nvme_alloc_user_request(q, cmd, rq_flags: 0, blk_flags: 0);
175 if (IS_ERR(ptr: req))
176 return PTR_ERR(ptr: req);
177
178 req->timeout = timeout;
179 if (ubuffer && bufflen) {
180 ret = nvme_map_user_request(req, ubuffer, bufflen, meta_buffer,
181 meta_len, NULL, flags);
182 if (ret)
183 goto out_free_req;
184 }
185
186 bio = req->bio;
187 ctrl = nvme_req(req)->ctrl;
188
189 effects = nvme_passthru_start(ctrl, ns, opcode: cmd->common.opcode);
190 ret = nvme_execute_rq(rq: req, at_head: false);
191 if (result)
192 *result = le64_to_cpu(nvme_req(req)->result.u64);
193 if (bio)
194 blk_rq_unmap_user(bio);
195 blk_mq_free_request(rq: req);
196
197 if (effects)
198 nvme_passthru_end(ctrl, ns, effects, cmd, status: ret);
199 return ret;
200
201out_free_req:
202 blk_mq_free_request(rq: req);
203 return ret;
204}
205
206static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
207{
208 struct nvme_user_io io;
209 struct nvme_command c;
210 unsigned length, meta_len;
211 void __user *metadata;
212
213 if (copy_from_user(to: &io, from: uio, n: sizeof(io)))
214 return -EFAULT;
215 if (io.flags)
216 return -EINVAL;
217
218 switch (io.opcode) {
219 case nvme_cmd_write:
220 case nvme_cmd_read:
221 case nvme_cmd_compare:
222 break;
223 default:
224 return -EINVAL;
225 }
226
227 length = (io.nblocks + 1) << ns->head->lba_shift;
228
229 if ((io.control & NVME_RW_PRINFO_PRACT) &&
230 (ns->head->ms == ns->head->pi_size)) {
231 /*
232 * Protection information is stripped/inserted by the
233 * controller.
234 */
235 if (nvme_to_user_ptr(ptrval: io.metadata))
236 return -EINVAL;
237 meta_len = 0;
238 metadata = NULL;
239 } else {
240 meta_len = (io.nblocks + 1) * ns->head->ms;
241 metadata = nvme_to_user_ptr(ptrval: io.metadata);
242 }
243
244 if (ns->head->features & NVME_NS_EXT_LBAS) {
245 length += meta_len;
246 meta_len = 0;
247 } else if (meta_len) {
248 if ((io.metadata & 3) || !io.metadata)
249 return -EINVAL;
250 }
251
252 memset(&c, 0, sizeof(c));
253 c.rw.opcode = io.opcode;
254 c.rw.flags = io.flags;
255 c.rw.nsid = cpu_to_le32(ns->head->ns_id);
256 c.rw.slba = cpu_to_le64(io.slba);
257 c.rw.length = cpu_to_le16(io.nblocks);
258 c.rw.control = cpu_to_le16(io.control);
259 c.rw.dsmgmt = cpu_to_le32(io.dsmgmt);
260 c.rw.reftag = cpu_to_le32(io.reftag);
261 c.rw.lbat = cpu_to_le16(io.apptag);
262 c.rw.lbatm = cpu_to_le16(io.appmask);
263
264 return nvme_submit_user_cmd(q: ns->queue, cmd: &c, ubuffer: io.addr, bufflen: length, meta_buffer: metadata,
265 meta_len, NULL, timeout: 0, flags: 0);
266}
267
268static bool nvme_validate_passthru_nsid(struct nvme_ctrl *ctrl,
269 struct nvme_ns *ns, __u32 nsid)
270{
271 if (ns && nsid != ns->head->ns_id) {
272 dev_err(ctrl->device,
273 "%s: nsid (%u) in cmd does not match nsid (%u) of namespace\n",
274 current->comm, nsid, ns->head->ns_id);
275 return false;
276 }
277
278 return true;
279}
280
281static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
282 struct nvme_passthru_cmd __user *ucmd, unsigned int flags,
283 bool open_for_write)
284{
285 struct nvme_passthru_cmd cmd;
286 struct nvme_command c;
287 unsigned timeout = 0;
288 u64 result;
289 int status;
290
291 if (copy_from_user(to: &cmd, from: ucmd, n: sizeof(cmd)))
292 return -EFAULT;
293 if (cmd.flags)
294 return -EINVAL;
295 if (!nvme_validate_passthru_nsid(ctrl, ns, nsid: cmd.nsid))
296 return -EINVAL;
297
298 memset(&c, 0, sizeof(c));
299 c.common.opcode = cmd.opcode;
300 c.common.flags = cmd.flags;
301 c.common.nsid = cpu_to_le32(cmd.nsid);
302 c.common.cdw2[0] = cpu_to_le32(cmd.cdw2);
303 c.common.cdw2[1] = cpu_to_le32(cmd.cdw3);
304 c.common.cdw10 = cpu_to_le32(cmd.cdw10);
305 c.common.cdw11 = cpu_to_le32(cmd.cdw11);
306 c.common.cdw12 = cpu_to_le32(cmd.cdw12);
307 c.common.cdw13 = cpu_to_le32(cmd.cdw13);
308 c.common.cdw14 = cpu_to_le32(cmd.cdw14);
309 c.common.cdw15 = cpu_to_le32(cmd.cdw15);
310
311 if (!nvme_cmd_allowed(ns, c: &c, flags: 0, open_for_write))
312 return -EACCES;
313
314 if (cmd.timeout_ms)
315 timeout = msecs_to_jiffies(m: cmd.timeout_ms);
316
317 status = nvme_submit_user_cmd(q: ns ? ns->queue : ctrl->admin_q, cmd: &c,
318 ubuffer: cmd.addr, bufflen: cmd.data_len, meta_buffer: nvme_to_user_ptr(ptrval: cmd.metadata),
319 meta_len: cmd.metadata_len, result: &result, timeout, flags: 0);
320
321 if (status >= 0) {
322 if (put_user(result, &ucmd->result))
323 return -EFAULT;
324 }
325
326 return status;
327}
328
329static int nvme_user_cmd64(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
330 struct nvme_passthru_cmd64 __user *ucmd, unsigned int flags,
331 bool open_for_write)
332{
333 struct nvme_passthru_cmd64 cmd;
334 struct nvme_command c;
335 unsigned timeout = 0;
336 int status;
337
338 if (copy_from_user(to: &cmd, from: ucmd, n: sizeof(cmd)))
339 return -EFAULT;
340 if (cmd.flags)
341 return -EINVAL;
342 if (!nvme_validate_passthru_nsid(ctrl, ns, nsid: cmd.nsid))
343 return -EINVAL;
344
345 memset(&c, 0, sizeof(c));
346 c.common.opcode = cmd.opcode;
347 c.common.flags = cmd.flags;
348 c.common.nsid = cpu_to_le32(cmd.nsid);
349 c.common.cdw2[0] = cpu_to_le32(cmd.cdw2);
350 c.common.cdw2[1] = cpu_to_le32(cmd.cdw3);
351 c.common.cdw10 = cpu_to_le32(cmd.cdw10);
352 c.common.cdw11 = cpu_to_le32(cmd.cdw11);
353 c.common.cdw12 = cpu_to_le32(cmd.cdw12);
354 c.common.cdw13 = cpu_to_le32(cmd.cdw13);
355 c.common.cdw14 = cpu_to_le32(cmd.cdw14);
356 c.common.cdw15 = cpu_to_le32(cmd.cdw15);
357
358 if (!nvme_cmd_allowed(ns, c: &c, flags, open_for_write))
359 return -EACCES;
360
361 if (cmd.timeout_ms)
362 timeout = msecs_to_jiffies(m: cmd.timeout_ms);
363
364 status = nvme_submit_user_cmd(q: ns ? ns->queue : ctrl->admin_q, cmd: &c,
365 ubuffer: cmd.addr, bufflen: cmd.data_len, meta_buffer: nvme_to_user_ptr(ptrval: cmd.metadata),
366 meta_len: cmd.metadata_len, result: &cmd.result, timeout, flags);
367
368 if (status >= 0) {
369 if (put_user(cmd.result, &ucmd->result))
370 return -EFAULT;
371 }
372
373 return status;
374}
375
376struct nvme_uring_data {
377 __u64 metadata;
378 __u64 addr;
379 __u32 data_len;
380 __u32 metadata_len;
381 __u32 timeout_ms;
382};
383
384/*
385 * This overlays struct io_uring_cmd pdu.
386 * Expect build errors if this grows larger than that.
387 */
388struct nvme_uring_cmd_pdu {
389 struct request *req;
390 struct bio *bio;
391 u64 result;
392 int status;
393};
394
395static inline struct nvme_uring_cmd_pdu *nvme_uring_cmd_pdu(
396 struct io_uring_cmd *ioucmd)
397{
398 return io_uring_cmd_to_pdu(ioucmd, struct nvme_uring_cmd_pdu);
399}
400
401static void nvme_uring_task_cb(struct io_tw_req tw_req, io_tw_token_t tw)
402{
403 struct io_uring_cmd *ioucmd = io_uring_cmd_from_tw(tw_req);
404 struct nvme_uring_cmd_pdu *pdu = nvme_uring_cmd_pdu(ioucmd);
405
406 if (pdu->bio)
407 blk_rq_unmap_user(pdu->bio);
408 io_uring_cmd_done32(ioucmd, ret: pdu->status, res2: pdu->result,
409 IO_URING_CMD_TASK_WORK_ISSUE_FLAGS);
410}
411
412static enum rq_end_io_ret nvme_uring_cmd_end_io(struct request *req,
413 blk_status_t err)
414{
415 struct io_uring_cmd *ioucmd = req->end_io_data;
416 struct nvme_uring_cmd_pdu *pdu = nvme_uring_cmd_pdu(ioucmd);
417
418 if (nvme_req(req)->flags & NVME_REQ_CANCELLED) {
419 pdu->status = -EINTR;
420 } else {
421 pdu->status = nvme_req(req)->status;
422 if (!pdu->status)
423 pdu->status = blk_status_to_errno(status: err);
424 }
425 pdu->result = le64_to_cpu(nvme_req(req)->result.u64);
426
427 /*
428 * IOPOLL could potentially complete this request directly, but
429 * if multiple rings are polling on the same queue, then it's possible
430 * for one ring to find completions for another ring. Punting the
431 * completion via task_work will always direct it to the right
432 * location, rather than potentially complete requests for ringA
433 * under iopoll invocations from ringB.
434 */
435 io_uring_cmd_do_in_task_lazy(ioucmd, task_work_cb: nvme_uring_task_cb);
436 return RQ_END_IO_FREE;
437}
438
439static int nvme_uring_cmd_io(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
440 struct io_uring_cmd *ioucmd, unsigned int issue_flags, bool vec)
441{
442 struct nvme_uring_cmd_pdu *pdu = nvme_uring_cmd_pdu(ioucmd);
443 const struct nvme_uring_cmd *cmd = io_uring_sqe_cmd(sqe: ioucmd->sqe);
444 struct request_queue *q = ns ? ns->queue : ctrl->admin_q;
445 struct nvme_uring_data d;
446 struct nvme_command c;
447 struct iov_iter iter;
448 struct iov_iter *map_iter = NULL;
449 struct request *req;
450 blk_opf_t rq_flags = 0;
451 blk_mq_req_flags_t blk_flags = 0;
452 int ret;
453
454 c.common.opcode = READ_ONCE(cmd->opcode);
455 c.common.flags = READ_ONCE(cmd->flags);
456 if (c.common.flags)
457 return -EINVAL;
458
459 c.common.command_id = 0;
460 c.common.nsid = cpu_to_le32(cmd->nsid);
461 if (!nvme_validate_passthru_nsid(ctrl, ns, le32_to_cpu(c.common.nsid)))
462 return -EINVAL;
463
464 c.common.cdw2[0] = cpu_to_le32(READ_ONCE(cmd->cdw2));
465 c.common.cdw2[1] = cpu_to_le32(READ_ONCE(cmd->cdw3));
466 c.common.metadata = 0;
467 c.common.dptr.prp1 = c.common.dptr.prp2 = 0;
468 c.common.cdw10 = cpu_to_le32(READ_ONCE(cmd->cdw10));
469 c.common.cdw11 = cpu_to_le32(READ_ONCE(cmd->cdw11));
470 c.common.cdw12 = cpu_to_le32(READ_ONCE(cmd->cdw12));
471 c.common.cdw13 = cpu_to_le32(READ_ONCE(cmd->cdw13));
472 c.common.cdw14 = cpu_to_le32(READ_ONCE(cmd->cdw14));
473 c.common.cdw15 = cpu_to_le32(READ_ONCE(cmd->cdw15));
474
475 if (!nvme_cmd_allowed(ns, c: &c, flags: 0, open_for_write: ioucmd->file->f_mode & FMODE_WRITE))
476 return -EACCES;
477
478 d.metadata = READ_ONCE(cmd->metadata);
479 d.addr = READ_ONCE(cmd->addr);
480 d.data_len = READ_ONCE(cmd->data_len);
481 d.metadata_len = READ_ONCE(cmd->metadata_len);
482 d.timeout_ms = READ_ONCE(cmd->timeout_ms);
483
484 if (d.data_len && (ioucmd->flags & IORING_URING_CMD_FIXED)) {
485 int ddir = nvme_is_write(cmd: &c) ? WRITE : READ;
486
487 if (vec)
488 ret = io_uring_cmd_import_fixed_vec(ioucmd,
489 u64_to_user_ptr(d.addr), uvec_segs: d.data_len,
490 ddir, iter: &iter, issue_flags);
491 else
492 ret = io_uring_cmd_import_fixed(ubuf: d.addr, len: d.data_len,
493 rw: ddir, iter: &iter, ioucmd, issue_flags);
494 if (ret < 0)
495 return ret;
496
497 map_iter = &iter;
498 }
499
500 if (issue_flags & IO_URING_F_NONBLOCK) {
501 rq_flags |= REQ_NOWAIT;
502 blk_flags = BLK_MQ_REQ_NOWAIT;
503 }
504 if (issue_flags & IO_URING_F_IOPOLL)
505 rq_flags |= REQ_POLLED;
506
507 req = nvme_alloc_user_request(q, cmd: &c, rq_flags, blk_flags);
508 if (IS_ERR(ptr: req))
509 return PTR_ERR(ptr: req);
510 req->timeout = d.timeout_ms ? msecs_to_jiffies(m: d.timeout_ms) : 0;
511
512 if (d.data_len) {
513 ret = nvme_map_user_request(req, ubuffer: d.addr, bufflen: d.data_len,
514 meta_buffer: nvme_to_user_ptr(ptrval: d.metadata), meta_len: d.metadata_len,
515 iter: map_iter, flags: vec ? NVME_IOCTL_VEC : 0);
516 if (ret)
517 goto out_free_req;
518 }
519
520 /* to free bio on completion, as req->bio will be null at that time */
521 pdu->bio = req->bio;
522 pdu->req = req;
523 req->end_io_data = ioucmd;
524 req->end_io = nvme_uring_cmd_end_io;
525 blk_execute_rq_nowait(rq: req, at_head: false);
526 return -EIOCBQUEUED;
527
528out_free_req:
529 blk_mq_free_request(rq: req);
530 return ret;
531}
532
533static bool is_ctrl_ioctl(unsigned int cmd)
534{
535 if (cmd == NVME_IOCTL_ADMIN_CMD || cmd == NVME_IOCTL_ADMIN64_CMD)
536 return true;
537 if (is_sed_ioctl(cmd))
538 return true;
539 return false;
540}
541
542static int nvme_ctrl_ioctl(struct nvme_ctrl *ctrl, unsigned int cmd,
543 void __user *argp, bool open_for_write)
544{
545 switch (cmd) {
546 case NVME_IOCTL_ADMIN_CMD:
547 return nvme_user_cmd(ctrl, NULL, ucmd: argp, flags: 0, open_for_write);
548 case NVME_IOCTL_ADMIN64_CMD:
549 return nvme_user_cmd64(ctrl, NULL, ucmd: argp, flags: 0, open_for_write);
550 default:
551 return sed_ioctl(dev: ctrl->opal_dev, cmd, ioctl_ptr: argp);
552 }
553}
554
555#ifdef COMPAT_FOR_U64_ALIGNMENT
556struct nvme_user_io32 {
557 __u8 opcode;
558 __u8 flags;
559 __u16 control;
560 __u16 nblocks;
561 __u16 rsvd;
562 __u64 metadata;
563 __u64 addr;
564 __u64 slba;
565 __u32 dsmgmt;
566 __u32 reftag;
567 __u16 apptag;
568 __u16 appmask;
569} __attribute__((__packed__));
570#define NVME_IOCTL_SUBMIT_IO32 _IOW('N', 0x42, struct nvme_user_io32)
571#endif /* COMPAT_FOR_U64_ALIGNMENT */
572
573static int nvme_ns_ioctl(struct nvme_ns *ns, unsigned int cmd,
574 void __user *argp, unsigned int flags, bool open_for_write)
575{
576 switch (cmd) {
577 case NVME_IOCTL_ID:
578 force_successful_syscall_return();
579 return ns->head->ns_id;
580 case NVME_IOCTL_IO_CMD:
581 return nvme_user_cmd(ctrl: ns->ctrl, ns, ucmd: argp, flags, open_for_write);
582 /*
583 * struct nvme_user_io can have different padding on some 32-bit ABIs.
584 * Just accept the compat version as all fields that are used are the
585 * same size and at the same offset.
586 */
587#ifdef COMPAT_FOR_U64_ALIGNMENT
588 case NVME_IOCTL_SUBMIT_IO32:
589#endif
590 case NVME_IOCTL_SUBMIT_IO:
591 return nvme_submit_io(ns, uio: argp);
592 case NVME_IOCTL_IO64_CMD_VEC:
593 flags |= NVME_IOCTL_VEC;
594 fallthrough;
595 case NVME_IOCTL_IO64_CMD:
596 return nvme_user_cmd64(ctrl: ns->ctrl, ns, ucmd: argp, flags,
597 open_for_write);
598 default:
599 return -ENOTTY;
600 }
601}
602
603int nvme_ioctl(struct block_device *bdev, blk_mode_t mode,
604 unsigned int cmd, unsigned long arg)
605{
606 struct nvme_ns *ns = bdev->bd_disk->private_data;
607 bool open_for_write = mode & BLK_OPEN_WRITE;
608 void __user *argp = (void __user *)arg;
609 unsigned int flags = 0;
610
611 if (bdev_is_partition(bdev))
612 flags |= NVME_IOCTL_PARTITION;
613
614 if (is_ctrl_ioctl(cmd))
615 return nvme_ctrl_ioctl(ctrl: ns->ctrl, cmd, argp, open_for_write);
616 return nvme_ns_ioctl(ns, cmd, argp, flags, open_for_write);
617}
618
619long nvme_ns_chr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
620{
621 struct nvme_ns *ns =
622 container_of(file_inode(file)->i_cdev, struct nvme_ns, cdev);
623 bool open_for_write = file->f_mode & FMODE_WRITE;
624 void __user *argp = (void __user *)arg;
625
626 if (is_ctrl_ioctl(cmd))
627 return nvme_ctrl_ioctl(ctrl: ns->ctrl, cmd, argp, open_for_write);
628 return nvme_ns_ioctl(ns, cmd, argp, flags: 0, open_for_write);
629}
630
631static int nvme_uring_cmd_checks(unsigned int issue_flags)
632{
633
634 /* NVMe passthrough requires big SQE/CQE support */
635 if ((issue_flags & (IO_URING_F_SQE128|IO_URING_F_CQE32)) !=
636 (IO_URING_F_SQE128|IO_URING_F_CQE32))
637 return -EOPNOTSUPP;
638 return 0;
639}
640
641static int nvme_ns_uring_cmd(struct nvme_ns *ns, struct io_uring_cmd *ioucmd,
642 unsigned int issue_flags)
643{
644 struct nvme_ctrl *ctrl = ns->ctrl;
645 int ret;
646
647 ret = nvme_uring_cmd_checks(issue_flags);
648 if (ret)
649 return ret;
650
651 switch (ioucmd->cmd_op) {
652 case NVME_URING_CMD_IO:
653 ret = nvme_uring_cmd_io(ctrl, ns, ioucmd, issue_flags, vec: false);
654 break;
655 case NVME_URING_CMD_IO_VEC:
656 ret = nvme_uring_cmd_io(ctrl, ns, ioucmd, issue_flags, vec: true);
657 break;
658 default:
659 ret = -ENOTTY;
660 }
661
662 return ret;
663}
664
665int nvme_ns_chr_uring_cmd(struct io_uring_cmd *ioucmd, unsigned int issue_flags)
666{
667 struct nvme_ns *ns = container_of(file_inode(ioucmd->file)->i_cdev,
668 struct nvme_ns, cdev);
669
670 return nvme_ns_uring_cmd(ns, ioucmd, issue_flags);
671}
672
673int nvme_ns_chr_uring_cmd_iopoll(struct io_uring_cmd *ioucmd,
674 struct io_comp_batch *iob,
675 unsigned int poll_flags)
676{
677 struct nvme_uring_cmd_pdu *pdu = nvme_uring_cmd_pdu(ioucmd);
678 struct request *req = pdu->req;
679
680 if (req && blk_rq_is_poll(rq: req))
681 return blk_rq_poll(rq: req, iob, poll_flags);
682 return 0;
683}
684#ifdef CONFIG_NVME_MULTIPATH
685static int nvme_ns_head_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd,
686 void __user *argp, struct nvme_ns_head *head, int srcu_idx,
687 bool open_for_write)
688 __releases(&head->srcu)
689{
690 struct nvme_ctrl *ctrl = ns->ctrl;
691 int ret;
692
693 nvme_get_ctrl(ctrl: ns->ctrl);
694 srcu_read_unlock(ssp: &head->srcu, idx: srcu_idx);
695 ret = nvme_ctrl_ioctl(ctrl: ns->ctrl, cmd, argp, open_for_write);
696
697 nvme_put_ctrl(ctrl);
698 return ret;
699}
700
701int nvme_ns_head_ioctl(struct block_device *bdev, blk_mode_t mode,
702 unsigned int cmd, unsigned long arg)
703{
704 struct nvme_ns_head *head = bdev->bd_disk->private_data;
705 bool open_for_write = mode & BLK_OPEN_WRITE;
706 void __user *argp = (void __user *)arg;
707 struct nvme_ns *ns;
708 int srcu_idx, ret = -EWOULDBLOCK;
709 unsigned int flags = 0;
710
711 if (bdev_is_partition(bdev))
712 flags |= NVME_IOCTL_PARTITION;
713
714 srcu_idx = srcu_read_lock(ssp: &head->srcu);
715 ns = nvme_find_path(head);
716 if (!ns)
717 goto out_unlock;
718
719 /*
720 * Handle ioctls that apply to the controller instead of the namespace
721 * separately and drop the ns SRCU reference early. This avoids a
722 * deadlock when deleting namespaces using the passthrough interface.
723 */
724 if (is_ctrl_ioctl(cmd))
725 return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx,
726 open_for_write);
727
728 ret = nvme_ns_ioctl(ns, cmd, argp, flags, open_for_write);
729out_unlock:
730 srcu_read_unlock(ssp: &head->srcu, idx: srcu_idx);
731 return ret;
732}
733
734long nvme_ns_head_chr_ioctl(struct file *file, unsigned int cmd,
735 unsigned long arg)
736{
737 bool open_for_write = file->f_mode & FMODE_WRITE;
738 struct cdev *cdev = file_inode(f: file)->i_cdev;
739 struct nvme_ns_head *head =
740 container_of(cdev, struct nvme_ns_head, cdev);
741 void __user *argp = (void __user *)arg;
742 struct nvme_ns *ns;
743 int srcu_idx, ret = -EWOULDBLOCK;
744
745 srcu_idx = srcu_read_lock(ssp: &head->srcu);
746 ns = nvme_find_path(head);
747 if (!ns)
748 goto out_unlock;
749
750 if (is_ctrl_ioctl(cmd))
751 return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx,
752 open_for_write);
753
754 ret = nvme_ns_ioctl(ns, cmd, argp, flags: 0, open_for_write);
755out_unlock:
756 srcu_read_unlock(ssp: &head->srcu, idx: srcu_idx);
757 return ret;
758}
759
760int nvme_ns_head_chr_uring_cmd(struct io_uring_cmd *ioucmd,
761 unsigned int issue_flags)
762{
763 struct cdev *cdev = file_inode(f: ioucmd->file)->i_cdev;
764 struct nvme_ns_head *head = container_of(cdev, struct nvme_ns_head, cdev);
765 int srcu_idx = srcu_read_lock(ssp: &head->srcu);
766 struct nvme_ns *ns = nvme_find_path(head);
767 int ret = -EINVAL;
768
769 if (ns)
770 ret = nvme_ns_uring_cmd(ns, ioucmd, issue_flags);
771 srcu_read_unlock(ssp: &head->srcu, idx: srcu_idx);
772 return ret;
773}
774#endif /* CONFIG_NVME_MULTIPATH */
775
776int nvme_dev_uring_cmd(struct io_uring_cmd *ioucmd, unsigned int issue_flags)
777{
778 struct nvme_ctrl *ctrl = ioucmd->file->private_data;
779 int ret;
780
781 /* IOPOLL not supported yet */
782 if (issue_flags & IO_URING_F_IOPOLL)
783 return -EOPNOTSUPP;
784
785 ret = nvme_uring_cmd_checks(issue_flags);
786 if (ret)
787 return ret;
788
789 switch (ioucmd->cmd_op) {
790 case NVME_URING_CMD_ADMIN:
791 ret = nvme_uring_cmd_io(ctrl, NULL, ioucmd, issue_flags, vec: false);
792 break;
793 case NVME_URING_CMD_ADMIN_VEC:
794 ret = nvme_uring_cmd_io(ctrl, NULL, ioucmd, issue_flags, vec: true);
795 break;
796 default:
797 ret = -ENOTTY;
798 }
799
800 return ret;
801}
802
803static int nvme_dev_user_cmd(struct nvme_ctrl *ctrl, void __user *argp,
804 bool open_for_write)
805{
806 struct nvme_ns *ns;
807 int ret, srcu_idx;
808
809 srcu_idx = srcu_read_lock(ssp: &ctrl->srcu);
810 if (list_empty(head: &ctrl->namespaces)) {
811 ret = -ENOTTY;
812 goto out_unlock;
813 }
814
815 ns = list_first_or_null_rcu(&ctrl->namespaces, struct nvme_ns, list);
816 if (ns != list_last_entry(&ctrl->namespaces, struct nvme_ns, list)) {
817 dev_warn(ctrl->device,
818 "NVME_IOCTL_IO_CMD not supported when multiple namespaces present!\n");
819 ret = -EINVAL;
820 goto out_unlock;
821 }
822
823 dev_warn(ctrl->device,
824 "using deprecated NVME_IOCTL_IO_CMD ioctl on the char device!\n");
825 if (!nvme_get_ns(ns)) {
826 ret = -ENXIO;
827 goto out_unlock;
828 }
829 srcu_read_unlock(ssp: &ctrl->srcu, idx: srcu_idx);
830
831 ret = nvme_user_cmd(ctrl, ns, ucmd: argp, flags: 0, open_for_write);
832 nvme_put_ns(ns);
833 return ret;
834
835out_unlock:
836 srcu_read_unlock(ssp: &ctrl->srcu, idx: srcu_idx);
837 return ret;
838}
839
840long nvme_dev_ioctl(struct file *file, unsigned int cmd,
841 unsigned long arg)
842{
843 bool open_for_write = file->f_mode & FMODE_WRITE;
844 struct nvme_ctrl *ctrl = file->private_data;
845 void __user *argp = (void __user *)arg;
846
847 switch (cmd) {
848 case NVME_IOCTL_ADMIN_CMD:
849 return nvme_user_cmd(ctrl, NULL, ucmd: argp, flags: 0, open_for_write);
850 case NVME_IOCTL_ADMIN64_CMD:
851 return nvme_user_cmd64(ctrl, NULL, ucmd: argp, flags: 0, open_for_write);
852 case NVME_IOCTL_IO_CMD:
853 return nvme_dev_user_cmd(ctrl, argp, open_for_write);
854 case NVME_IOCTL_RESET:
855 if (!capable(CAP_SYS_ADMIN))
856 return -EACCES;
857 dev_warn(ctrl->device, "resetting controller\n");
858 return nvme_reset_ctrl_sync(ctrl);
859 case NVME_IOCTL_SUBSYS_RESET:
860 if (!capable(CAP_SYS_ADMIN))
861 return -EACCES;
862 return nvme_reset_subsystem(ctrl);
863 case NVME_IOCTL_RESCAN:
864 if (!capable(CAP_SYS_ADMIN))
865 return -EACCES;
866 nvme_queue_scan(ctrl);
867 return 0;
868 default:
869 return -ENOTTY;
870 }
871}
872

source code of linux/drivers/nvme/host/ioctl.c