Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2015 Intel Corporation. All rights reserved.
3 : : * Copyright (c) 2021 Mellanox Technologies LTD. All rights reserved.
4 : : */
5 : :
6 : : #include "nvme_internal.h"
7 : : #include "spdk/nvme.h"
8 : :
9 : : int
10 : 3 : spdk_nvme_ctrlr_io_cmd_raw_no_payload_build(struct spdk_nvme_ctrlr *ctrlr,
11 : : struct spdk_nvme_qpair *qpair,
12 : : struct spdk_nvme_cmd *cmd,
13 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
14 : : {
15 : : struct nvme_request *req;
16 : 3 : struct nvme_payload payload;
17 : :
18 [ + - # # : 3 : if (ctrlr->trid.trtype != SPDK_NVME_TRANSPORT_PCIE) {
# # # # ]
19 : 3 : return -EINVAL;
20 : : }
21 : :
22 [ # # ]: 0 : memset(&payload, 0, sizeof(payload));
23 : 0 : req = nvme_allocate_request(qpair, &payload, 0, 0, cb_fn, cb_arg);
24 : :
25 [ # # ]: 0 : if (req == NULL) {
26 : 0 : return -ENOMEM;
27 : : }
28 : :
29 [ # # # # : 0 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
# # ]
30 : :
31 : 0 : return nvme_qpair_submit_request(qpair, req);
32 : 0 : }
33 : :
34 : : int
35 : 2276700 : spdk_nvme_ctrlr_cmd_io_raw(struct spdk_nvme_ctrlr *ctrlr,
36 : : struct spdk_nvme_qpair *qpair,
37 : : struct spdk_nvme_cmd *cmd,
38 : : void *buf, uint32_t len,
39 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
40 : : {
41 : : struct nvme_request *req;
42 : :
43 : 2276700 : req = nvme_allocate_request_contig(qpair, buf, len, cb_fn, cb_arg);
44 : :
45 [ + + ]: 2276700 : if (req == NULL) {
46 : 3 : return -ENOMEM;
47 : : }
48 : :
49 [ + + + + : 2276697 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
+ - ]
50 : :
51 : 2276697 : return nvme_qpair_submit_request(qpair, req);
52 : 619 : }
53 : :
54 : : int
55 : 5 : spdk_nvme_ctrlr_cmd_io_raw_with_md(struct spdk_nvme_ctrlr *ctrlr,
56 : : struct spdk_nvme_qpair *qpair,
57 : : struct spdk_nvme_cmd *cmd,
58 : : void *buf, uint32_t len, void *md_buf,
59 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
60 : : {
61 : : struct nvme_request *req;
62 : 3 : struct nvme_payload payload;
63 : 5 : uint32_t md_len = 0;
64 : :
65 : 5 : payload = NVME_PAYLOAD_CONTIG(buf, md_buf);
66 : :
67 : : /* Calculate metadata length */
68 [ - + ]: 5 : if (md_buf) {
69 [ # # # # ]: 0 : struct spdk_nvme_ns *ns = spdk_nvme_ctrlr_get_ns(ctrlr, cmd->nsid);
70 : :
71 [ # # # # ]: 0 : assert(ns != NULL);
72 [ # # # # : 0 : assert(ns->sector_size != 0);
# # # # ]
73 [ # # # # : 0 : md_len = len / ns->sector_size * ns->md_size;
# # # # #
# ]
74 : 0 : }
75 : :
76 : 5 : req = nvme_allocate_request(qpair, &payload, len, md_len, cb_fn, cb_arg);
77 [ + + ]: 5 : if (req == NULL) {
78 : 3 : return -ENOMEM;
79 : : }
80 : :
81 [ - + - + : 2 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
# # ]
82 : :
83 : 2 : return nvme_qpair_submit_request(qpair, req);
84 : 0 : }
85 : :
86 : : int
87 : 0 : spdk_nvme_ctrlr_cmd_iov_raw_with_md(struct spdk_nvme_ctrlr *ctrlr,
88 : : struct spdk_nvme_qpair *qpair,
89 : : struct spdk_nvme_cmd *cmd,
90 : : uint32_t len, void *md_buf,
91 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg,
92 : : spdk_nvme_req_reset_sgl_cb reset_sgl_fn,
93 : : spdk_nvme_req_next_sge_cb next_sge_fn)
94 : : {
95 : : struct nvme_request *req;
96 : 0 : struct nvme_payload payload;
97 : 0 : uint32_t md_len = 0;
98 : :
99 [ # # # # ]: 0 : if (reset_sgl_fn == NULL || next_sge_fn == NULL) {
100 : 0 : return -EINVAL;
101 : : }
102 : :
103 : 0 : payload = NVME_PAYLOAD_SGL(reset_sgl_fn, next_sge_fn, cb_arg, md_buf);
104 : :
105 : : /* Calculate metadata length */
106 [ # # ]: 0 : if (md_buf) {
107 [ # # # # ]: 0 : struct spdk_nvme_ns *ns = spdk_nvme_ctrlr_get_ns(ctrlr, cmd->nsid);
108 : :
109 [ # # # # ]: 0 : assert(ns != NULL);
110 [ # # # # : 0 : assert(ns->sector_size != 0);
# # # # ]
111 [ # # # # : 0 : md_len = len / ns->sector_size * ns->md_size;
# # # # #
# ]
112 : 0 : }
113 : :
114 : 0 : req = nvme_allocate_request(qpair, &payload, len, md_len, cb_fn, cb_arg);
115 [ # # ]: 0 : if (req == NULL) {
116 : 0 : return -ENOMEM;
117 : : }
118 : :
119 [ # # # # : 0 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
# # ]
120 : :
121 : 0 : return nvme_qpair_submit_request(qpair, req);
122 : 0 : }
123 : :
124 : : int
125 : 909066 : spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr,
126 : : struct spdk_nvme_cmd *cmd,
127 : : void *buf, uint32_t len,
128 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
129 : : {
130 : : struct nvme_request *req;
131 : : int rc;
132 : :
133 : 909066 : nvme_ctrlr_lock(ctrlr);
134 [ + - + - ]: 909066 : req = nvme_allocate_request_contig(ctrlr->adminq, buf, len, cb_fn, cb_arg);
135 [ + + ]: 909066 : if (req == NULL) {
136 : 0 : nvme_ctrlr_unlock(ctrlr);
137 : 0 : return -ENOMEM;
138 : : }
139 : :
140 [ + + + + : 909066 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
+ - ]
141 : :
142 : 909066 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
143 : :
144 : 909066 : nvme_ctrlr_unlock(ctrlr);
145 : 909066 : return rc;
146 : 8463 : }
147 : :
148 : : int
149 : 15009 : nvme_ctrlr_cmd_identify(struct spdk_nvme_ctrlr *ctrlr, uint8_t cns, uint16_t cntid, uint32_t nsid,
150 : : uint8_t csi, void *payload, size_t payload_size,
151 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
152 : : {
153 : : struct nvme_request *req;
154 : : struct spdk_nvme_cmd *cmd;
155 : : int rc;
156 : :
157 : 15009 : nvme_ctrlr_lock(ctrlr);
158 [ + - + - ]: 15009 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
159 : 3238 : payload, payload_size,
160 : 3238 : cb_fn, cb_arg, false);
161 [ + + ]: 15009 : if (req == NULL) {
162 : 0 : nvme_ctrlr_unlock(ctrlr);
163 : 0 : return -ENOMEM;
164 : : }
165 : :
166 [ + - ]: 15009 : cmd = &req->cmd;
167 [ + - ]: 15009 : cmd->opc = SPDK_NVME_OPC_IDENTIFY;
168 [ + - + - : 15009 : cmd->cdw10_bits.identify.cns = cns;
+ - + - ]
169 [ + - + - : 15009 : cmd->cdw10_bits.identify.cntid = cntid;
+ - + - ]
170 [ + - + - : 15009 : cmd->cdw11_bits.identify.csi = csi;
+ - + - ]
171 [ + - + - ]: 15009 : cmd->nsid = nsid;
172 : :
173 : 15009 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
174 : :
175 : 15009 : nvme_ctrlr_unlock(ctrlr);
176 : 15009 : return rc;
177 : 3238 : }
178 : :
179 : : int
180 : 3 : nvme_ctrlr_cmd_attach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
181 : : struct spdk_nvme_ctrlr_list *payload, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
182 : : {
183 : : struct nvme_request *req;
184 : : struct spdk_nvme_cmd *cmd;
185 : : int rc;
186 : :
187 : 3 : nvme_ctrlr_lock(ctrlr);
188 [ # # # # ]: 3 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
189 : 0 : payload, sizeof(struct spdk_nvme_ctrlr_list),
190 : 0 : cb_fn, cb_arg, true);
191 [ - + ]: 3 : if (req == NULL) {
192 : 0 : nvme_ctrlr_unlock(ctrlr);
193 : 0 : return -ENOMEM;
194 : : }
195 : :
196 [ # # ]: 3 : cmd = &req->cmd;
197 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_NS_ATTACHMENT;
198 [ # # # # ]: 3 : cmd->nsid = nsid;
199 [ # # # # : 3 : cmd->cdw10_bits.ns_attach.sel = SPDK_NVME_NS_CTRLR_ATTACH;
# # # # ]
200 : :
201 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
202 : :
203 : 3 : nvme_ctrlr_unlock(ctrlr);
204 : 3 : return rc;
205 : 0 : }
206 : :
207 : : int
208 : 3 : nvme_ctrlr_cmd_detach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
209 : : struct spdk_nvme_ctrlr_list *payload, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
210 : : {
211 : : struct nvme_request *req;
212 : : struct spdk_nvme_cmd *cmd;
213 : : int rc;
214 : :
215 : 3 : nvme_ctrlr_lock(ctrlr);
216 [ # # # # ]: 3 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
217 : 0 : payload, sizeof(struct spdk_nvme_ctrlr_list),
218 : 0 : cb_fn, cb_arg, true);
219 [ - + ]: 3 : if (req == NULL) {
220 : 0 : nvme_ctrlr_unlock(ctrlr);
221 : 0 : return -ENOMEM;
222 : : }
223 : :
224 [ # # ]: 3 : cmd = &req->cmd;
225 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_NS_ATTACHMENT;
226 [ # # # # ]: 3 : cmd->nsid = nsid;
227 [ # # # # : 3 : cmd->cdw10_bits.ns_attach.sel = SPDK_NVME_NS_CTRLR_DETACH;
# # # # ]
228 : :
229 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
230 : :
231 : 3 : nvme_ctrlr_unlock(ctrlr);
232 : 3 : return rc;
233 : 0 : }
234 : :
235 : : int
236 : 3 : nvme_ctrlr_cmd_create_ns(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_ns_data *payload,
237 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
238 : : {
239 : : struct nvme_request *req;
240 : : struct spdk_nvme_cmd *cmd;
241 : : int rc;
242 : :
243 : 3 : nvme_ctrlr_lock(ctrlr);
244 [ # # # # ]: 3 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
245 : 0 : payload, sizeof(struct spdk_nvme_ns_data),
246 : 0 : cb_fn, cb_arg, true);
247 [ - + ]: 3 : if (req == NULL) {
248 : 0 : nvme_ctrlr_unlock(ctrlr);
249 : 0 : return -ENOMEM;
250 : : }
251 : :
252 [ # # ]: 3 : cmd = &req->cmd;
253 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_NS_MANAGEMENT;
254 [ # # # # : 3 : cmd->cdw10_bits.ns_manage.sel = SPDK_NVME_NS_MANAGEMENT_CREATE;
# # # # ]
255 : :
256 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
257 : :
258 : 3 : nvme_ctrlr_unlock(ctrlr);
259 : 3 : return rc;
260 : 0 : }
261 : :
262 : : int
263 : 3 : nvme_ctrlr_cmd_delete_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, spdk_nvme_cmd_cb cb_fn,
264 : : void *cb_arg)
265 : : {
266 : : struct nvme_request *req;
267 : : struct spdk_nvme_cmd *cmd;
268 : : int rc;
269 : :
270 : 3 : nvme_ctrlr_lock(ctrlr);
271 [ # # # # ]: 3 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
272 [ - + ]: 3 : if (req == NULL) {
273 : 0 : nvme_ctrlr_unlock(ctrlr);
274 : 0 : return -ENOMEM;
275 : : }
276 : :
277 [ # # ]: 3 : cmd = &req->cmd;
278 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_NS_MANAGEMENT;
279 [ # # # # : 3 : cmd->cdw10_bits.ns_manage.sel = SPDK_NVME_NS_MANAGEMENT_DELETE;
# # # # ]
280 [ # # # # ]: 3 : cmd->nsid = nsid;
281 : :
282 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
283 : :
284 : 3 : nvme_ctrlr_unlock(ctrlr);
285 : 3 : return rc;
286 : 0 : }
287 : :
288 : : int
289 : 665 : nvme_ctrlr_cmd_doorbell_buffer_config(struct spdk_nvme_ctrlr *ctrlr, uint64_t prp1, uint64_t prp2,
290 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
291 : : {
292 : : struct nvme_request *req;
293 : : struct spdk_nvme_cmd *cmd;
294 : : int rc;
295 : :
296 : 665 : nvme_ctrlr_lock(ctrlr);
297 [ # # # # ]: 665 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
298 [ - + ]: 665 : if (req == NULL) {
299 : 0 : nvme_ctrlr_unlock(ctrlr);
300 : 0 : return -ENOMEM;
301 : : }
302 : :
303 [ # # ]: 665 : cmd = &req->cmd;
304 [ # # ]: 665 : cmd->opc = SPDK_NVME_OPC_DOORBELL_BUFFER_CONFIG;
305 [ # # # # : 665 : cmd->dptr.prp.prp1 = prp1;
# # # # ]
306 [ # # # # : 665 : cmd->dptr.prp.prp2 = prp2;
# # # # ]
307 : :
308 : 665 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
309 : :
310 : 665 : nvme_ctrlr_unlock(ctrlr);
311 : 665 : return rc;
312 : 0 : }
313 : :
314 : : int
315 : 3 : nvme_ctrlr_cmd_format(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, struct spdk_nvme_format *format,
316 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
317 : : {
318 : : struct nvme_request *req;
319 : : struct spdk_nvme_cmd *cmd;
320 : : int rc;
321 : :
322 : 3 : nvme_ctrlr_lock(ctrlr);
323 [ # # # # ]: 3 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
324 [ - + ]: 3 : if (req == NULL) {
325 : 0 : nvme_ctrlr_unlock(ctrlr);
326 : 0 : return -ENOMEM;
327 : : }
328 : :
329 [ # # ]: 3 : cmd = &req->cmd;
330 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_FORMAT_NVM;
331 [ # # # # ]: 3 : cmd->nsid = nsid;
332 [ # # # # : 3 : memcpy(&cmd->cdw10, format, sizeof(uint32_t));
# # # # ]
333 : :
334 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
335 : 3 : nvme_ctrlr_unlock(ctrlr);
336 : :
337 : 3 : return rc;
338 : 0 : }
339 : :
340 : : int
341 : 7327 : spdk_nvme_ctrlr_cmd_set_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
342 : : uint32_t cdw11, uint32_t cdw12, void *payload, uint32_t payload_size,
343 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
344 : : {
345 : : struct nvme_request *req;
346 : : struct spdk_nvme_cmd *cmd;
347 : : int rc;
348 : :
349 : 7327 : nvme_ctrlr_lock(ctrlr);
350 [ + - + - ]: 7327 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
351 : : true);
352 [ + + ]: 7327 : if (req == NULL) {
353 : 0 : nvme_ctrlr_unlock(ctrlr);
354 : 0 : return -ENOMEM;
355 : : }
356 : :
357 [ + - ]: 7327 : cmd = &req->cmd;
358 [ + - ]: 7327 : cmd->opc = SPDK_NVME_OPC_SET_FEATURES;
359 [ + - + - : 7327 : cmd->cdw10_bits.set_features.fid = feature;
+ - + - ]
360 [ + - + - : 7327 : cmd->cdw11 = cdw11;
+ - ]
361 [ + - + - : 7327 : cmd->cdw12 = cdw12;
+ - ]
362 : :
363 : 7327 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
364 : 7327 : nvme_ctrlr_unlock(ctrlr);
365 : :
366 : 7327 : return rc;
367 : 1620 : }
368 : :
369 : : int
370 : 2604 : spdk_nvme_ctrlr_cmd_get_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
371 : : uint32_t cdw11, void *payload, uint32_t payload_size,
372 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
373 : : {
374 : : struct nvme_request *req;
375 : : struct spdk_nvme_cmd *cmd;
376 : : int rc;
377 : :
378 : 2604 : nvme_ctrlr_lock(ctrlr);
379 [ + - + - ]: 2604 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
380 : : false);
381 [ + + ]: 2604 : if (req == NULL) {
382 : 0 : nvme_ctrlr_unlock(ctrlr);
383 : 0 : return -ENOMEM;
384 : : }
385 : :
386 [ + - ]: 2604 : cmd = &req->cmd;
387 [ + - ]: 2604 : cmd->opc = SPDK_NVME_OPC_GET_FEATURES;
388 [ + - + - : 2604 : cmd->cdw10_bits.get_features.fid = feature;
+ - + - ]
389 [ + - + - : 2604 : cmd->cdw11 = cdw11;
+ - ]
390 : :
391 : 2604 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
392 : 2604 : nvme_ctrlr_unlock(ctrlr);
393 : :
394 : 2604 : return rc;
395 : 808 : }
396 : :
397 : : int
398 : 4 : spdk_nvme_ctrlr_cmd_get_feature_ns(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
399 : : uint32_t cdw11, void *payload,
400 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn,
401 : : void *cb_arg, uint32_t ns_id)
402 : : {
403 : : struct nvme_request *req;
404 : : struct spdk_nvme_cmd *cmd;
405 : : int rc;
406 : :
407 : 4 : nvme_ctrlr_lock(ctrlr);
408 [ # # # # ]: 4 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
409 : : false);
410 [ - + ]: 4 : if (req == NULL) {
411 : 0 : nvme_ctrlr_unlock(ctrlr);
412 : 0 : return -ENOMEM;
413 : : }
414 : :
415 [ # # ]: 4 : cmd = &req->cmd;
416 [ # # ]: 4 : cmd->opc = SPDK_NVME_OPC_GET_FEATURES;
417 [ # # # # : 4 : cmd->cdw10_bits.get_features.fid = feature;
# # # # ]
418 [ # # # # : 4 : cmd->cdw11 = cdw11;
# # ]
419 [ # # # # ]: 4 : cmd->nsid = ns_id;
420 : :
421 : 4 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
422 : 4 : nvme_ctrlr_unlock(ctrlr);
423 : :
424 : 4 : return rc;
425 : 0 : }
426 : :
427 : : int
428 : 4 : spdk_nvme_ctrlr_cmd_set_feature_ns(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
429 : : uint32_t cdw11, uint32_t cdw12, void *payload,
430 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn,
431 : : void *cb_arg, uint32_t ns_id)
432 : : {
433 : : struct nvme_request *req;
434 : : struct spdk_nvme_cmd *cmd;
435 : : int rc;
436 : :
437 : 4 : nvme_ctrlr_lock(ctrlr);
438 [ # # # # ]: 4 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
439 : : true);
440 [ - + ]: 4 : if (req == NULL) {
441 : 0 : nvme_ctrlr_unlock(ctrlr);
442 : 0 : return -ENOMEM;
443 : : }
444 : :
445 [ # # ]: 4 : cmd = &req->cmd;
446 [ # # ]: 4 : cmd->opc = SPDK_NVME_OPC_SET_FEATURES;
447 [ # # # # : 4 : cmd->cdw10_bits.set_features.fid = feature;
# # # # ]
448 [ # # # # : 4 : cmd->cdw11 = cdw11;
# # ]
449 [ # # # # : 4 : cmd->cdw12 = cdw12;
# # ]
450 [ # # # # ]: 4 : cmd->nsid = ns_id;
451 : :
452 : 4 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
453 : 4 : nvme_ctrlr_unlock(ctrlr);
454 : :
455 : 4 : return rc;
456 : 0 : }
457 : :
458 : : int
459 : 3252 : nvme_ctrlr_cmd_set_num_queues(struct spdk_nvme_ctrlr *ctrlr,
460 : : uint32_t num_queues, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
461 : : {
462 : : union spdk_nvme_feat_number_of_queues feat_num_queues;
463 : :
464 : 3252 : feat_num_queues.raw = 0;
465 : 3252 : feat_num_queues.bits.nsqr = num_queues - 1;
466 : 3252 : feat_num_queues.bits.ncqr = num_queues - 1;
467 : :
468 : 4062 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_NUMBER_OF_QUEUES, feat_num_queues.raw,
469 : : 0,
470 : 810 : NULL, 0, cb_fn, cb_arg);
471 : : }
472 : :
473 : : int
474 : 0 : nvme_ctrlr_cmd_get_num_queues(struct spdk_nvme_ctrlr *ctrlr,
475 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
476 : : {
477 : 0 : return spdk_nvme_ctrlr_cmd_get_feature(ctrlr, SPDK_NVME_FEAT_NUMBER_OF_QUEUES, 0, NULL, 0,
478 : 0 : cb_fn, cb_arg);
479 : : }
480 : :
481 : : int
482 : 3404 : nvme_ctrlr_cmd_set_async_event_config(struct spdk_nvme_ctrlr *ctrlr,
483 : : union spdk_nvme_feat_async_event_configuration config, spdk_nvme_cmd_cb cb_fn,
484 : : void *cb_arg)
485 : : {
486 : : uint32_t cdw11;
487 : :
488 : 3404 : cdw11 = config.raw;
489 : 4214 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_ASYNC_EVENT_CONFIGURATION, cdw11, 0,
490 : : NULL, 0,
491 : 810 : cb_fn, cb_arg);
492 : : }
493 : :
494 : : int
495 : 9 : nvme_ctrlr_cmd_set_host_id(struct spdk_nvme_ctrlr *ctrlr, void *host_id, uint32_t host_id_size,
496 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
497 : : {
498 : : union spdk_nvme_feat_host_identifier feat_host_identifier;
499 : :
500 : 9 : feat_host_identifier.raw = 0;
501 [ + + ]: 9 : if (host_id_size == 16) {
502 : : /* 128-bit extended host identifier */
503 : 3 : feat_host_identifier.bits.exhid = 1;
504 [ + + ]: 6 : } else if (host_id_size == 8) {
505 : : /* 64-bit host identifier */
506 : 3 : feat_host_identifier.bits.exhid = 0;
507 : 0 : } else {
508 : 3 : SPDK_ERRLOG("Invalid host ID size %u\n", host_id_size);
509 : 3 : return -EINVAL;
510 : : }
511 : :
512 : 6 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_HOST_IDENTIFIER,
513 : 0 : feat_host_identifier.raw, 0,
514 : 0 : host_id, host_id_size, cb_fn, cb_arg);
515 : 0 : }
516 : :
517 : : int
518 : 2405 : spdk_nvme_ctrlr_cmd_get_log_page_ext(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page,
519 : : uint32_t nsid, void *payload, uint32_t payload_size,
520 : : uint64_t offset, uint32_t cdw10,
521 : : uint32_t cdw11, uint32_t cdw14,
522 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
523 : : {
524 : : struct nvme_request *req;
525 : : struct spdk_nvme_cmd *cmd;
526 : : uint32_t numd, numdl, numdu;
527 : : uint32_t lpol, lpou;
528 : : int rc;
529 : :
530 [ + + ]: 2405 : if (payload_size == 0) {
531 : 0 : return -EINVAL;
532 : : }
533 : :
534 [ - + ]: 2405 : if (offset & 3) {
535 : 0 : return -EINVAL;
536 : : }
537 : :
538 : 2405 : numd = spdk_nvme_bytes_to_numd(payload_size);
539 : 2405 : numdl = numd & 0xFFFFu;
540 [ + - ]: 2405 : numdu = (numd >> 16) & 0xFFFFu;
541 : :
542 : 2405 : lpol = (uint32_t)offset;
543 [ + - ]: 2405 : lpou = (uint32_t)(offset >> 32);
544 : :
545 : 2405 : nvme_ctrlr_lock(ctrlr);
546 : :
547 [ + + - + : 2405 : if (offset && !ctrlr->cdata.lpa.edlp) {
# # # # #
# ]
548 : 0 : nvme_ctrlr_unlock(ctrlr);
549 : 0 : return -EINVAL;
550 : : }
551 : :
552 [ + - + - ]: 2405 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
553 : 2 : payload, payload_size, cb_fn, cb_arg, false);
554 [ + + ]: 2405 : if (req == NULL) {
555 : 0 : nvme_ctrlr_unlock(ctrlr);
556 : 0 : return -ENOMEM;
557 : : }
558 : :
559 [ - + ]: 2405 : cmd = &req->cmd;
560 [ - + ]: 2405 : cmd->opc = SPDK_NVME_OPC_GET_LOG_PAGE;
561 [ - + - + ]: 2405 : cmd->nsid = nsid;
562 [ - + - + : 2405 : cmd->cdw10 = cdw10;
- + ]
563 [ - + - + : 2405 : cmd->cdw10_bits.get_log_page.numdl = numdl;
- + - + ]
564 [ - + - + : 2405 : cmd->cdw10_bits.get_log_page.lid = log_page;
- + - + ]
565 : :
566 [ - + - + : 2405 : cmd->cdw11 = cdw11;
- + ]
567 [ - + - + : 2405 : cmd->cdw11_bits.get_log_page.numdu = numdu;
- + - + ]
568 [ - + - + : 2405 : cmd->cdw12 = lpol;
- + ]
569 [ - + - + : 2405 : cmd->cdw13 = lpou;
- + ]
570 [ - + - + ]: 2405 : cmd->cdw14 = cdw14;
571 : :
572 : 2405 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
573 : 2405 : nvme_ctrlr_unlock(ctrlr);
574 : :
575 : 2405 : return rc;
576 : 2 : }
577 : :
578 : : int
579 : 1383 : spdk_nvme_ctrlr_cmd_get_log_page(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page,
580 : : uint32_t nsid, void *payload, uint32_t payload_size,
581 : : uint64_t offset, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
582 : : {
583 : 1385 : return spdk_nvme_ctrlr_cmd_get_log_page_ext(ctrlr, log_page, nsid, payload,
584 : 2 : payload_size, offset, 0, 0, 0, cb_fn, cb_arg);
585 : : }
586 : :
587 : : static void
588 : 364709 : nvme_ctrlr_retry_queued_abort(struct spdk_nvme_ctrlr *ctrlr)
589 : : {
590 : : struct nvme_request *next, *tmp;
591 : : int rc;
592 : :
593 [ - + + - : 364709 : if (ctrlr->is_resetting || ctrlr->is_destructed || ctrlr->is_failed) {
- + + - -
+ - + # #
# # # # #
# # # #
# ]
594 : : /* Don't resubmit aborts if ctrlr is failing */
595 : 0 : return;
596 : : }
597 : :
598 [ - + ]: 364709 : if (spdk_nvme_ctrlr_get_admin_qp_failure_reason(ctrlr) != SPDK_NVME_QPAIR_FAILURE_NONE) {
599 : : /* Don't resubmit aborts if admin qpair is failed */
600 : 0 : return;
601 : : }
602 : :
603 [ + + # # : 364709 : STAILQ_FOREACH_SAFE(next, &ctrlr->queued_aborts, stailq, tmp) {
# # # # #
# # # # #
# # ]
604 [ + + # # : 227691 : STAILQ_REMOVE_HEAD(&ctrlr->queued_aborts, stailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
605 [ # # ]: 227691 : ctrlr->outstanding_aborts++;
606 : 227691 : rc = nvme_ctrlr_submit_admin_request(ctrlr, next);
607 [ - + ]: 227691 : if (rc < 0) {
608 : 0 : SPDK_ERRLOG("Failed to submit queued abort.\n");
609 [ # # # # ]: 0 : memset(&next->cpl, 0, sizeof(next->cpl));
610 [ # # # # : 0 : next->cpl.status.sct = SPDK_NVME_SCT_GENERIC;
# # # # ]
611 [ # # # # : 0 : next->cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
# # # # ]
612 [ # # # # : 0 : next->cpl.status.dnr = 1;
# # # # ]
613 [ # # # # : 0 : nvme_complete_request(next->cb_fn, next->cb_arg, next->qpair, next, &next->cpl);
# # # # #
# # # #
# ]
614 : 0 : } else {
615 : : /* If the first abort succeeds, stop iterating. */
616 : 227691 : break;
617 : : }
618 : 0 : }
619 : 0 : }
620 : :
621 : : static int
622 : 364715 : _nvme_ctrlr_submit_abort_request(struct spdk_nvme_ctrlr *ctrlr,
623 : : struct nvme_request *req)
624 : : {
625 : : /* ACL is a 0's based value. */
626 [ + + # # : 364715 : if (ctrlr->outstanding_aborts >= ctrlr->cdata.acl + 1U) {
# # # # #
# # # ]
627 [ # # # # : 227691 : STAILQ_INSERT_TAIL(&ctrlr->queued_aborts, req, stailq);
# # # # #
# # # # #
# # # # #
# # # #
# ]
628 : 227691 : return 0;
629 : : } else {
630 [ # # ]: 137024 : ctrlr->outstanding_aborts++;
631 : 137024 : return nvme_ctrlr_submit_admin_request(ctrlr, req);
632 : : }
633 : 0 : }
634 : :
635 : : static void
636 : 0 : nvme_ctrlr_cmd_abort_cpl(void *ctx, const struct spdk_nvme_cpl *cpl)
637 : : {
638 : 0 : struct nvme_request *req = ctx;
639 : : struct spdk_nvme_ctrlr *ctrlr;
640 : :
641 [ # # # # : 0 : ctrlr = req->qpair->ctrlr;
# # # # ]
642 : :
643 [ # # # # : 0 : assert(ctrlr->outstanding_aborts > 0);
# # # # ]
644 [ # # ]: 0 : ctrlr->outstanding_aborts--;
645 : 0 : nvme_ctrlr_retry_queued_abort(ctrlr);
646 : :
647 [ # # # # : 0 : req->user_cb_fn(req->user_cb_arg, cpl);
# # # # #
# # # ]
648 : 0 : }
649 : :
650 : : int
651 : 9 : spdk_nvme_ctrlr_cmd_abort(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair,
652 : : uint16_t cid, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
653 : : {
654 : : int rc;
655 : : struct nvme_request *req;
656 : : struct spdk_nvme_cmd *cmd;
657 : :
658 [ + + ]: 9 : if (qpair == NULL) {
659 [ # # # # ]: 6 : qpair = ctrlr->adminq;
660 : 0 : }
661 : :
662 : 9 : nvme_ctrlr_lock(ctrlr);
663 [ # # # # ]: 9 : req = nvme_allocate_request_null(ctrlr->adminq, nvme_ctrlr_cmd_abort_cpl, NULL);
664 [ + + ]: 9 : if (req == NULL) {
665 : 3 : nvme_ctrlr_unlock(ctrlr);
666 : 3 : return -ENOMEM;
667 : : }
668 [ # # # # ]: 6 : req->cb_arg = req;
669 [ # # # # ]: 6 : req->user_cb_fn = cb_fn;
670 [ # # # # ]: 6 : req->user_cb_arg = cb_arg;
671 : :
672 [ # # ]: 6 : cmd = &req->cmd;
673 [ # # ]: 6 : cmd->opc = SPDK_NVME_OPC_ABORT;
674 [ # # # # : 6 : cmd->cdw10_bits.abort.sqid = qpair->id;
# # # # #
# # # ]
675 [ # # # # : 6 : cmd->cdw10_bits.abort.cid = cid;
# # # # ]
676 : :
677 : 6 : rc = _nvme_ctrlr_submit_abort_request(ctrlr, req);
678 : :
679 : 6 : nvme_ctrlr_unlock(ctrlr);
680 : 6 : return rc;
681 : 0 : }
682 : :
683 : : static void
684 : 364709 : nvme_complete_abort_request(void *ctx, const struct spdk_nvme_cpl *cpl)
685 : : {
686 : 364709 : struct nvme_request *req = ctx;
687 [ # # # # ]: 364709 : struct nvme_request *parent = req->parent;
688 : : struct spdk_nvme_ctrlr *ctrlr;
689 : :
690 [ # # # # : 364709 : ctrlr = req->qpair->ctrlr;
# # # # ]
691 : :
692 [ - + # # : 364709 : assert(ctrlr->outstanding_aborts > 0);
# # # # ]
693 [ # # ]: 364709 : ctrlr->outstanding_aborts--;
694 : 364709 : nvme_ctrlr_retry_queued_abort(ctrlr);
695 : :
696 : 364709 : nvme_request_remove_child(parent, req);
697 : :
698 [ + - + - : 364709 : if (!spdk_nvme_cpl_is_abort_success(cpl)) {
+ + # # #
# # # # #
# # # # #
# # # ]
699 [ # # # # : 286576 : parent->parent_status.cdw0 |= 1U;
# # ]
700 : 0 : }
701 : :
702 [ + - # # : 364709 : if (parent->num_children == 0) {
# # ]
703 [ # # # # : 364709 : nvme_complete_request(parent->cb_fn, parent->cb_arg, parent->qpair,
# # # # #
# # # ]
704 [ # # ]: 0 : parent, &parent->parent_status);
705 : 0 : }
706 : 364709 : }
707 : :
708 : : static int
709 : 30921032 : nvme_request_add_abort(struct nvme_request *req, void *arg)
710 : : {
711 : 30921032 : struct nvme_request *parent = arg;
712 : : struct nvme_request *child;
713 : : void *cmd_cb_arg;
714 : :
715 [ # # # # ]: 30921032 : cmd_cb_arg = parent->user_cb_arg;
716 : :
717 [ + + ]: 30921032 : if (!nvme_request_abort_match(req, cmd_cb_arg)) {
718 : 30556296 : return 0;
719 : : }
720 : :
721 [ # # # # : 364736 : child = nvme_allocate_request_null(parent->qpair->ctrlr->adminq,
# # # # #
# # # ]
722 : : nvme_complete_abort_request, NULL);
723 [ + + ]: 364736 : if (child == NULL) {
724 : 24 : return -ENOMEM;
725 : : }
726 : :
727 [ # # # # ]: 364712 : child->cb_arg = child;
728 : :
729 [ # # # # ]: 364712 : child->cmd.opc = SPDK_NVME_OPC_ABORT;
730 : : /* Copy SQID from the parent. */
731 [ # # # # : 364712 : child->cmd.cdw10_bits.abort.sqid = parent->cmd.cdw10_bits.abort.sqid;
# # # # #
# # # # #
# # # # #
# ]
732 [ # # # # : 364712 : child->cmd.cdw10_bits.abort.cid = req->cmd.cid;
# # # # #
# # # # #
# # ]
733 : :
734 [ # # # # ]: 364712 : child->parent = parent;
735 : :
736 [ # # # # : 364712 : TAILQ_INSERT_TAIL(&parent->children, child, child_tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
737 [ # # ]: 364712 : parent->num_children++;
738 : :
739 : 364712 : return 0;
740 : 0 : }
741 : :
742 : : int
743 : 986072 : spdk_nvme_ctrlr_cmd_abort_ext(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair,
744 : : void *cmd_cb_arg,
745 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
746 : : {
747 : 986072 : int rc = 0;
748 : : struct nvme_request *parent, *child, *tmp;
749 : 986072 : bool child_failed = false;
750 : 986072 : int aborted = 0;
751 : :
752 [ - + ]: 986072 : if (cmd_cb_arg == NULL) {
753 : 0 : return -EINVAL;
754 : : }
755 : :
756 : 986072 : nvme_ctrlr_lock(ctrlr);
757 : :
758 [ - + ]: 986072 : if (qpair == NULL) {
759 [ # # # # ]: 0 : qpair = ctrlr->adminq;
760 : 0 : }
761 : :
762 [ # # # # ]: 986072 : parent = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
763 [ + + ]: 986072 : if (parent == NULL) {
764 : 486634 : nvme_ctrlr_unlock(ctrlr);
765 : :
766 : 486634 : return -ENOMEM;
767 : : }
768 : :
769 [ # # # # : 499438 : TAILQ_INIT(&parent->children);
# # # # #
# # # # #
# # ]
770 [ # # # # ]: 499438 : parent->num_children = 0;
771 : :
772 [ # # # # ]: 499438 : parent->cmd.opc = SPDK_NVME_OPC_ABORT;
773 [ - + # # ]: 499438 : memset(&parent->parent_status, 0, sizeof(struct spdk_nvme_cpl));
774 : :
775 : : /* Hold SQID that the requests to abort are associated with.
776 : : * This will be copied to the children.
777 : : *
778 : : * CID is not set here because the parent is not submitted directly
779 : : * and CID is not determined until request to abort is found.
780 : : */
781 [ # # # # : 499438 : parent->cmd.cdw10_bits.abort.sqid = qpair->id;
# # # # #
# # # #
# ]
782 : :
783 : : /* This is used to find request to abort. */
784 [ # # # # ]: 499438 : parent->user_cb_arg = cmd_cb_arg;
785 : :
786 : : /* Add an abort request for each outstanding request which has cmd_cb_arg
787 : : * as its callback context.
788 : : */
789 : 499438 : rc = nvme_transport_qpair_iterate_requests(qpair, nvme_request_add_abort, parent);
790 [ + + ]: 499438 : if (rc != 0) {
791 : : /* Free abort requests already added. */
792 : 21 : child_failed = true;
793 : 0 : }
794 : :
795 [ + + # # : 864147 : TAILQ_FOREACH_SAFE(child, &parent->children, child_tailq, tmp) {
# # # # #
# # # # #
# # ]
796 [ + - # # ]: 364709 : if (spdk_likely(!child_failed)) {
797 : 364709 : rc = _nvme_ctrlr_submit_abort_request(ctrlr, child);
798 [ - + ]: 364709 : if (spdk_unlikely(rc != 0)) {
799 : 0 : child_failed = true;
800 : 0 : }
801 : 0 : } else {
802 : : /* Free remaining abort requests. */
803 : 0 : nvme_request_remove_child(parent, child);
804 : 0 : nvme_free_request(child);
805 : : }
806 : 0 : }
807 : :
808 [ + + # # ]: 499438 : if (spdk_likely(!child_failed)) {
809 : : /* There is no error so far. Abort requests were submitted successfully
810 : : * or there was no outstanding request to abort.
811 : : *
812 : : * Hence abort queued requests which has cmd_cb_arg as its callback
813 : : * context next.
814 : : */
815 : 499417 : aborted = nvme_qpair_abort_queued_reqs_with_cbarg(qpair, cmd_cb_arg);
816 [ + + # # : 499417 : if (parent->num_children == 0) {
# # ]
817 : : /* There was no outstanding request to abort. */
818 [ + - ]: 134708 : if (aborted > 0) {
819 : : /* The queued requests were successfully aborted. Hence
820 : : * complete the parent request with success synchronously.
821 : : */
822 [ # # # # : 134708 : nvme_complete_request(parent->cb_fn, parent->cb_arg, parent->qpair,
# # # # #
# # # ]
823 [ # # ]: 0 : parent, &parent->parent_status);
824 : 0 : } else {
825 : : /* There was no queued request to abort. */
826 : 0 : rc = -ENOENT;
827 : : }
828 : 0 : }
829 : 0 : } else {
830 : : /* Failed to add or submit abort request. */
831 [ - + # # : 21 : if (parent->num_children != 0) {
# # ]
832 : : /* Return success since we must wait for those children
833 : : * to complete but set the parent request to failure.
834 : : */
835 [ # # # # : 0 : parent->parent_status.cdw0 |= 1U;
# # ]
836 : 0 : rc = 0;
837 : 0 : }
838 : : }
839 : :
840 [ + + ]: 499438 : if (rc != 0) {
841 : 21 : nvme_free_request(parent);
842 : 0 : }
843 : :
844 : 499438 : nvme_ctrlr_unlock(ctrlr);
845 : 499438 : return rc;
846 : 0 : }
847 : :
848 : : int
849 : 3 : nvme_ctrlr_cmd_fw_commit(struct spdk_nvme_ctrlr *ctrlr,
850 : : const struct spdk_nvme_fw_commit *fw_commit,
851 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
852 : : {
853 : : struct nvme_request *req;
854 : : struct spdk_nvme_cmd *cmd;
855 : : int rc;
856 : :
857 : 3 : nvme_ctrlr_lock(ctrlr);
858 [ # # # # ]: 3 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
859 [ - + ]: 3 : if (req == NULL) {
860 : 0 : nvme_ctrlr_unlock(ctrlr);
861 : 0 : return -ENOMEM;
862 : : }
863 : :
864 [ # # ]: 3 : cmd = &req->cmd;
865 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_FIRMWARE_COMMIT;
866 [ # # # # : 3 : memcpy(&cmd->cdw10, fw_commit, sizeof(uint32_t));
# # # # ]
867 : :
868 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
869 : 3 : nvme_ctrlr_unlock(ctrlr);
870 : :
871 : 3 : return rc;
872 : :
873 : 0 : }
874 : :
875 : : int
876 : 3 : nvme_ctrlr_cmd_fw_image_download(struct spdk_nvme_ctrlr *ctrlr,
877 : : uint32_t size, uint32_t offset, void *payload,
878 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
879 : : {
880 : : struct nvme_request *req;
881 : : struct spdk_nvme_cmd *cmd;
882 : : int rc;
883 : :
884 : 3 : nvme_ctrlr_lock(ctrlr);
885 [ # # # # ]: 3 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, size, cb_fn, cb_arg, true);
886 [ - + ]: 3 : if (req == NULL) {
887 : 0 : nvme_ctrlr_unlock(ctrlr);
888 : 0 : return -ENOMEM;
889 : : }
890 : :
891 [ # # ]: 3 : cmd = &req->cmd;
892 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD;
893 [ # # # # : 3 : cmd->cdw10 = spdk_nvme_bytes_to_numd(size);
# # ]
894 [ # # # # : 3 : cmd->cdw11 = offset >> 2;
# # # # ]
895 : :
896 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
897 : 3 : nvme_ctrlr_unlock(ctrlr);
898 : :
899 : 3 : return rc;
900 : 0 : }
901 : :
902 : : int
903 : 209 : spdk_nvme_ctrlr_cmd_security_receive(struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
904 : : uint16_t spsp, uint8_t nssf, void *payload,
905 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
906 : : {
907 : : struct nvme_request *req;
908 : : struct spdk_nvme_cmd *cmd;
909 : : int rc;
910 : :
911 : 209 : nvme_ctrlr_lock(ctrlr);
912 [ # # # # ]: 209 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
913 : 0 : cb_fn, cb_arg, false);
914 [ + + ]: 209 : if (req == NULL) {
915 : 3 : nvme_ctrlr_unlock(ctrlr);
916 : 3 : return -ENOMEM;
917 : : }
918 : :
919 [ # # ]: 206 : cmd = &req->cmd;
920 [ # # ]: 206 : cmd->opc = SPDK_NVME_OPC_SECURITY_RECEIVE;
921 [ # # # # : 206 : cmd->cdw10_bits.sec_send_recv.nssf = nssf;
# # # # ]
922 [ # # # # : 206 : cmd->cdw10_bits.sec_send_recv.spsp0 = (uint8_t)spsp;
# # # # ]
923 [ # # # # : 206 : cmd->cdw10_bits.sec_send_recv.spsp1 = (uint8_t)(spsp >> 8);
# # # # #
# ]
924 [ # # # # : 206 : cmd->cdw10_bits.sec_send_recv.secp = secp;
# # # # ]
925 [ # # # # : 206 : cmd->cdw11 = payload_size;
# # ]
926 : :
927 : 206 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
928 : 206 : nvme_ctrlr_unlock(ctrlr);
929 : :
930 : 206 : return rc;
931 : 0 : }
932 : :
933 : : int
934 : 8 : spdk_nvme_ctrlr_cmd_security_send(struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
935 : : uint16_t spsp, uint8_t nssf, void *payload,
936 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
937 : : {
938 : : struct nvme_request *req;
939 : : struct spdk_nvme_cmd *cmd;
940 : : int rc;
941 : :
942 : 8 : nvme_ctrlr_lock(ctrlr);
943 [ # # # # ]: 8 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
944 : 0 : cb_fn, cb_arg, true);
945 [ + + ]: 8 : if (req == NULL) {
946 : 3 : nvme_ctrlr_unlock(ctrlr);
947 : 3 : return -ENOMEM;
948 : : }
949 : :
950 [ # # ]: 5 : cmd = &req->cmd;
951 [ # # ]: 5 : cmd->opc = SPDK_NVME_OPC_SECURITY_SEND;
952 [ # # # # : 5 : cmd->cdw10_bits.sec_send_recv.nssf = nssf;
# # # # ]
953 [ # # # # : 5 : cmd->cdw10_bits.sec_send_recv.spsp0 = (uint8_t)spsp;
# # # # ]
954 [ # # # # : 5 : cmd->cdw10_bits.sec_send_recv.spsp1 = (uint8_t)(spsp >> 8);
# # # # #
# ]
955 [ # # # # : 5 : cmd->cdw10_bits.sec_send_recv.secp = secp;
# # # # ]
956 [ # # # # : 5 : cmd->cdw11 = payload_size;
# # ]
957 : :
958 : 5 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
959 : 5 : nvme_ctrlr_unlock(ctrlr);
960 : :
961 : 5 : return rc;
962 : 0 : }
963 : :
964 : : int
965 : 3 : nvme_ctrlr_cmd_sanitize(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
966 : : struct spdk_nvme_sanitize *sanitize, uint32_t cdw11,
967 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
968 : : {
969 : : struct nvme_request *req;
970 : : struct spdk_nvme_cmd *cmd;
971 : : int rc;
972 : :
973 : 3 : nvme_ctrlr_lock(ctrlr);
974 [ # # # # ]: 3 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
975 [ - + ]: 3 : if (req == NULL) {
976 : 0 : nvme_ctrlr_unlock(ctrlr);
977 : 0 : return -ENOMEM;
978 : : }
979 : :
980 [ # # ]: 3 : cmd = &req->cmd;
981 [ # # ]: 3 : cmd->opc = SPDK_NVME_OPC_SANITIZE;
982 [ # # # # ]: 3 : cmd->nsid = nsid;
983 [ # # # # : 3 : cmd->cdw11 = cdw11;
# # ]
984 [ # # # # : 3 : memcpy(&cmd->cdw10, sanitize, sizeof(cmd->cdw10));
# # # # ]
985 : :
986 : 3 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
987 : 3 : nvme_ctrlr_unlock(ctrlr);
988 : :
989 : 3 : return rc;
990 : 0 : }
991 : :
992 : : static int
993 : 6 : nvme_ctrlr_cmd_directive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
994 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
995 : : void *payload, uint32_t payload_size, uint32_t cdw12,
996 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
997 : : uint16_t opc_type, bool host_to_ctrlr)
998 : : {
999 : 6 : struct nvme_request *req = NULL;
1000 : 6 : struct spdk_nvme_cmd *cmd = NULL;
1001 : : int rc;
1002 : :
1003 : 6 : nvme_ctrlr_lock(ctrlr);
1004 [ # # # # ]: 6 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
1005 [ # # ]: 0 : cb_fn, cb_arg, host_to_ctrlr);
1006 [ - + ]: 6 : if (req == NULL) {
1007 : 0 : nvme_ctrlr_unlock(ctrlr);
1008 : 0 : return -ENOMEM;
1009 : : }
1010 [ # # ]: 6 : cmd = &req->cmd;
1011 [ # # ]: 6 : cmd->opc = opc_type;
1012 [ # # # # ]: 6 : cmd->nsid = nsid;
1013 : :
1014 [ - + # # ]: 6 : if ((payload_size >> 2) > 0) {
1015 [ # # # # : 0 : cmd->cdw10 = (payload_size >> 2) - 1;
# # # # ]
1016 : 0 : }
1017 [ # # # # : 6 : cmd->cdw11_bits.directive.doper = doper;
# # # # ]
1018 [ # # # # : 6 : cmd->cdw11_bits.directive.dtype = dtype;
# # # # ]
1019 [ # # # # : 6 : cmd->cdw11_bits.directive.dspec = dspec;
# # # # ]
1020 [ # # # # : 6 : cmd->cdw12 = cdw12;
# # ]
1021 [ # # # # : 6 : cmd->cdw13 = cdw13;
# # ]
1022 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
1023 : 6 : nvme_ctrlr_unlock(ctrlr);
1024 : :
1025 : 6 : return rc;
1026 : 0 : }
1027 : :
1028 : : int
1029 : 3 : spdk_nvme_ctrlr_cmd_directive_send(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
1030 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
1031 : : void *payload, uint32_t payload_size, uint32_t cdw12,
1032 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
1033 : : {
1034 : 3 : return nvme_ctrlr_cmd_directive(ctrlr, nsid, doper, dtype, dspec,
1035 : 0 : payload, payload_size, cdw12, cdw13, cb_fn, cb_arg,
1036 : : SPDK_NVME_OPC_DIRECTIVE_SEND, true);
1037 : : }
1038 : :
1039 : : int
1040 : 3 : spdk_nvme_ctrlr_cmd_directive_receive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
1041 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
1042 : : void *payload, uint32_t payload_size, uint32_t cdw12,
1043 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
1044 : : {
1045 : 3 : return nvme_ctrlr_cmd_directive(ctrlr, nsid, doper, dtype, dspec,
1046 : 0 : payload, payload_size, cdw12, cdw13, cb_fn, cb_arg,
1047 : : SPDK_NVME_OPC_DIRECTIVE_RECEIVE, false);
1048 : : }
|