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 : 6 : 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 : 1 : struct nvme_request *req;
16 : 5 : struct nvme_payload payload;
17 : :
18 [ + - + - : 6 : if (ctrlr->trid.trtype != SPDK_NVME_TRANSPORT_PCIE) {
+ - + - ]
19 : 6 : 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 : 1 : }
33 : :
34 : : int
35 : 2040364 : 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 : 1 : struct nvme_request *req;
42 : :
43 : 2040364 : req = nvme_allocate_request_contig(qpair, buf, len, cb_fn, cb_arg);
44 : :
45 [ + + ]: 2040364 : if (req == NULL) {
46 : 6 : return -ENOMEM;
47 : : }
48 : :
49 [ + + + + : 2040358 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
+ - ]
50 : :
51 : 2040358 : return nvme_qpair_submit_request(qpair, req);
52 : 845 : }
53 : :
54 : : int
55 : 8 : 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 : 1 : struct nvme_request *req;
62 : 5 : struct nvme_payload payload;
63 : 8 : uint32_t md_len = 0;
64 : :
65 : 8 : payload = NVME_PAYLOAD_CONTIG(buf, md_buf);
66 : :
67 : : /* Calculate metadata length */
68 [ + + ]: 8 : 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 : 8 : req = nvme_allocate_request(qpair, &payload, len, md_len, cb_fn, cb_arg);
77 [ + + ]: 8 : if (req == NULL) {
78 : 6 : return -ENOMEM;
79 : : }
80 : :
81 [ - + - + : 2 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
# # ]
82 : :
83 : 2 : return nvme_qpair_submit_request(qpair, req);
84 : 1 : }
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 : 0 : 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 : 858889 : 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 : 0 : struct nvme_request *req;
131 : 0 : int rc;
132 : :
133 : 858889 : nvme_ctrlr_lock(ctrlr);
134 [ + - + - ]: 858889 : req = nvme_allocate_request_contig(ctrlr->adminq, buf, len, cb_fn, cb_arg);
135 [ + + ]: 858889 : if (req == NULL) {
136 : 0 : nvme_ctrlr_unlock(ctrlr);
137 : 0 : return -ENOMEM;
138 : : }
139 : :
140 [ + + + + : 858889 : memcpy(&req->cmd, cmd, sizeof(req->cmd));
+ - ]
141 : :
142 : 858889 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
143 : :
144 : 858889 : nvme_ctrlr_unlock(ctrlr);
145 : 858889 : return rc;
146 : 10640 : }
147 : :
148 : : int
149 : 11409 : 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 : 1 : struct nvme_request *req;
154 : 1 : struct spdk_nvme_cmd *cmd;
155 : 1 : int rc;
156 : :
157 : 11409 : nvme_ctrlr_lock(ctrlr);
158 [ + - + - ]: 11409 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
159 : 3975 : payload, payload_size,
160 : 3975 : cb_fn, cb_arg, false);
161 [ + + ]: 11409 : if (req == NULL) {
162 : 0 : nvme_ctrlr_unlock(ctrlr);
163 : 0 : return -ENOMEM;
164 : : }
165 : :
166 [ + - ]: 11409 : cmd = &req->cmd;
167 [ + - ]: 11409 : cmd->opc = SPDK_NVME_OPC_IDENTIFY;
168 [ + - + - : 11409 : cmd->cdw10_bits.identify.cns = cns;
+ - + - ]
169 [ + - + - : 11409 : cmd->cdw10_bits.identify.cntid = cntid;
+ - + - ]
170 [ + - + - : 11409 : cmd->cdw11_bits.identify.csi = csi;
+ - + - ]
171 [ + - + - ]: 11409 : cmd->nsid = nsid;
172 : :
173 : 11409 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
174 : :
175 : 11409 : nvme_ctrlr_unlock(ctrlr);
176 : 11409 : return rc;
177 : 3975 : }
178 : :
179 : : int
180 : 6 : 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 : 1 : struct nvme_request *req;
184 : 1 : struct spdk_nvme_cmd *cmd;
185 : 1 : int rc;
186 : :
187 : 6 : nvme_ctrlr_lock(ctrlr);
188 [ + - + - ]: 6 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
189 : 1 : payload, sizeof(struct spdk_nvme_ctrlr_list),
190 : 1 : cb_fn, cb_arg, true);
191 [ + + ]: 6 : if (req == NULL) {
192 : 0 : nvme_ctrlr_unlock(ctrlr);
193 : 0 : return -ENOMEM;
194 : : }
195 : :
196 [ + - ]: 6 : cmd = &req->cmd;
197 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_NS_ATTACHMENT;
198 [ + - + - ]: 6 : cmd->nsid = nsid;
199 [ + - + - : 6 : cmd->cdw10_bits.ns_attach.sel = SPDK_NVME_NS_CTRLR_ATTACH;
+ - + - ]
200 : :
201 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
202 : :
203 : 6 : nvme_ctrlr_unlock(ctrlr);
204 : 6 : return rc;
205 : 1 : }
206 : :
207 : : int
208 : 6 : 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 : 1 : struct nvme_request *req;
212 : 1 : struct spdk_nvme_cmd *cmd;
213 : 1 : int rc;
214 : :
215 : 6 : nvme_ctrlr_lock(ctrlr);
216 [ + - + - ]: 6 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
217 : 1 : payload, sizeof(struct spdk_nvme_ctrlr_list),
218 : 1 : cb_fn, cb_arg, true);
219 [ + + ]: 6 : if (req == NULL) {
220 : 0 : nvme_ctrlr_unlock(ctrlr);
221 : 0 : return -ENOMEM;
222 : : }
223 : :
224 [ + - ]: 6 : cmd = &req->cmd;
225 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_NS_ATTACHMENT;
226 [ + - + - ]: 6 : cmd->nsid = nsid;
227 [ + - + - : 6 : cmd->cdw10_bits.ns_attach.sel = SPDK_NVME_NS_CTRLR_DETACH;
+ - + - ]
228 : :
229 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
230 : :
231 : 6 : nvme_ctrlr_unlock(ctrlr);
232 : 6 : return rc;
233 : 1 : }
234 : :
235 : : int
236 : 6 : 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 : 1 : struct nvme_request *req;
240 : 1 : struct spdk_nvme_cmd *cmd;
241 : 1 : int rc;
242 : :
243 : 6 : nvme_ctrlr_lock(ctrlr);
244 [ + - + - ]: 6 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
245 : 1 : payload, sizeof(struct spdk_nvme_ns_data),
246 : 1 : cb_fn, cb_arg, true);
247 [ + + ]: 6 : if (req == NULL) {
248 : 0 : nvme_ctrlr_unlock(ctrlr);
249 : 0 : return -ENOMEM;
250 : : }
251 : :
252 [ + - ]: 6 : cmd = &req->cmd;
253 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_NS_MANAGEMENT;
254 [ + - + - : 6 : cmd->cdw10_bits.ns_manage.sel = SPDK_NVME_NS_MANAGEMENT_CREATE;
+ - + - ]
255 : :
256 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
257 : :
258 : 6 : nvme_ctrlr_unlock(ctrlr);
259 : 6 : return rc;
260 : 1 : }
261 : :
262 : : int
263 : 6 : 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 : 1 : struct nvme_request *req;
267 : 1 : struct spdk_nvme_cmd *cmd;
268 : 1 : int rc;
269 : :
270 : 6 : nvme_ctrlr_lock(ctrlr);
271 [ + - + - ]: 6 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
272 [ + + ]: 6 : if (req == NULL) {
273 : 0 : nvme_ctrlr_unlock(ctrlr);
274 : 0 : return -ENOMEM;
275 : : }
276 : :
277 [ + - ]: 6 : cmd = &req->cmd;
278 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_NS_MANAGEMENT;
279 [ + - + - : 6 : cmd->cdw10_bits.ns_manage.sel = SPDK_NVME_NS_MANAGEMENT_DELETE;
+ - + - ]
280 [ + - + - ]: 6 : cmd->nsid = nsid;
281 : :
282 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
283 : :
284 : 6 : nvme_ctrlr_unlock(ctrlr);
285 : 6 : return rc;
286 : 1 : }
287 : :
288 : : int
289 : 612 : 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 : 1 : struct nvme_request *req;
293 : 1 : struct spdk_nvme_cmd *cmd;
294 : 1 : int rc;
295 : :
296 : 612 : nvme_ctrlr_lock(ctrlr);
297 [ + - + - ]: 612 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
298 [ + + ]: 612 : if (req == NULL) {
299 : 0 : nvme_ctrlr_unlock(ctrlr);
300 : 0 : return -ENOMEM;
301 : : }
302 : :
303 [ + - ]: 612 : cmd = &req->cmd;
304 [ + - ]: 612 : cmd->opc = SPDK_NVME_OPC_DOORBELL_BUFFER_CONFIG;
305 [ + - + - : 612 : cmd->dptr.prp.prp1 = prp1;
+ - + - ]
306 [ + - + - : 612 : cmd->dptr.prp.prp2 = prp2;
+ - + - ]
307 : :
308 : 612 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
309 : :
310 : 612 : nvme_ctrlr_unlock(ctrlr);
311 : 612 : return rc;
312 : 1 : }
313 : :
314 : : int
315 : 6 : 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 : 1 : struct nvme_request *req;
319 : 1 : struct spdk_nvme_cmd *cmd;
320 : 1 : int rc;
321 : :
322 : 6 : nvme_ctrlr_lock(ctrlr);
323 [ + - + - ]: 6 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
324 [ + + ]: 6 : if (req == NULL) {
325 : 0 : nvme_ctrlr_unlock(ctrlr);
326 : 0 : return -ENOMEM;
327 : : }
328 : :
329 [ + - ]: 6 : cmd = &req->cmd;
330 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_FORMAT_NVM;
331 [ + - + - ]: 6 : cmd->nsid = nsid;
332 [ + - + - : 6 : memcpy(&cmd->cdw10, format, sizeof(uint32_t));
+ - + - ]
333 : :
334 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
335 : 6 : nvme_ctrlr_unlock(ctrlr);
336 : :
337 : 6 : return rc;
338 : 1 : }
339 : :
340 : : int
341 : 5268 : 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 : 3 : struct nvme_request *req;
346 : 3 : struct spdk_nvme_cmd *cmd;
347 : 3 : int rc;
348 : :
349 : 5268 : nvme_ctrlr_lock(ctrlr);
350 [ + - + - ]: 5268 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
351 : : true);
352 [ + + ]: 5268 : if (req == NULL) {
353 : 0 : nvme_ctrlr_unlock(ctrlr);
354 : 0 : return -ENOMEM;
355 : : }
356 : :
357 [ + - ]: 5268 : cmd = &req->cmd;
358 [ + - ]: 5268 : cmd->opc = SPDK_NVME_OPC_SET_FEATURES;
359 [ + - + - : 5268 : cmd->cdw10_bits.set_features.fid = feature;
+ - + - ]
360 [ + - + - : 5268 : cmd->cdw11 = cdw11;
+ - ]
361 [ + - + - : 5268 : cmd->cdw12 = cdw12;
+ - ]
362 : :
363 : 5268 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
364 : 5268 : nvme_ctrlr_unlock(ctrlr);
365 : :
366 : 5268 : return rc;
367 : 1991 : }
368 : :
369 : : int
370 : 1956 : 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 : 1 : struct nvme_request *req;
375 : 1 : struct spdk_nvme_cmd *cmd;
376 : 1 : int rc;
377 : :
378 : 1956 : nvme_ctrlr_lock(ctrlr);
379 [ + - + - ]: 1956 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
380 : : false);
381 [ + + ]: 1956 : if (req == NULL) {
382 : 0 : nvme_ctrlr_unlock(ctrlr);
383 : 0 : return -ENOMEM;
384 : : }
385 : :
386 [ + - ]: 1956 : cmd = &req->cmd;
387 [ + - ]: 1956 : cmd->opc = SPDK_NVME_OPC_GET_FEATURES;
388 [ + - + - : 1956 : cmd->cdw10_bits.get_features.fid = feature;
+ - + - ]
389 [ + - + - : 1956 : cmd->cdw11 = cdw11;
+ - ]
390 : :
391 : 1956 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
392 : 1956 : nvme_ctrlr_unlock(ctrlr);
393 : :
394 : 1956 : return rc;
395 : 993 : }
396 : :
397 : : int
398 : 7 : 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 : 1 : struct nvme_request *req;
404 : 1 : struct spdk_nvme_cmd *cmd;
405 : 1 : int rc;
406 : :
407 : 7 : nvme_ctrlr_lock(ctrlr);
408 [ + - + - ]: 7 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
409 : : false);
410 [ + + ]: 7 : if (req == NULL) {
411 : 0 : nvme_ctrlr_unlock(ctrlr);
412 : 0 : return -ENOMEM;
413 : : }
414 : :
415 [ + - ]: 7 : cmd = &req->cmd;
416 [ + - ]: 7 : cmd->opc = SPDK_NVME_OPC_GET_FEATURES;
417 [ + - + - : 7 : cmd->cdw10_bits.get_features.fid = feature;
+ - + - ]
418 [ + - + - : 7 : cmd->cdw11 = cdw11;
+ - ]
419 [ + - + - ]: 7 : cmd->nsid = ns_id;
420 : :
421 : 7 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
422 : 7 : nvme_ctrlr_unlock(ctrlr);
423 : :
424 : 7 : return rc;
425 : 1 : }
426 : :
427 : : int
428 : 7 : 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 : 1 : struct nvme_request *req;
434 : 1 : struct spdk_nvme_cmd *cmd;
435 : 1 : int rc;
436 : :
437 : 7 : nvme_ctrlr_lock(ctrlr);
438 [ + - + - ]: 7 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size, cb_fn, cb_arg,
439 : : true);
440 [ + + ]: 7 : if (req == NULL) {
441 : 0 : nvme_ctrlr_unlock(ctrlr);
442 : 0 : return -ENOMEM;
443 : : }
444 : :
445 [ + - ]: 7 : cmd = &req->cmd;
446 [ + - ]: 7 : cmd->opc = SPDK_NVME_OPC_SET_FEATURES;
447 [ + - + - : 7 : cmd->cdw10_bits.set_features.fid = feature;
+ - + - ]
448 [ + - + - : 7 : cmd->cdw11 = cdw11;
+ - ]
449 [ + - + - : 7 : cmd->cdw12 = cdw12;
+ - ]
450 [ + - + - ]: 7 : cmd->nsid = ns_id;
451 : :
452 : 7 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
453 : 7 : nvme_ctrlr_unlock(ctrlr);
454 : :
455 : 7 : return rc;
456 : 1 : }
457 : :
458 : : int
459 : 2564 : 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 : 0 : union spdk_nvme_feat_number_of_queues feat_num_queues;
463 : :
464 : 2564 : feat_num_queues.raw = 0;
465 : 2564 : feat_num_queues.bits.nsqr = num_queues - 1;
466 : 2564 : feat_num_queues.bits.ncqr = num_queues - 1;
467 : :
468 : 3558 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_NUMBER_OF_QUEUES, feat_num_queues.raw,
469 : : 0,
470 : 994 : NULL, 0, cb_fn, cb_arg);
471 : 0 : }
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 : 2686 : 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 : 0 : uint32_t cdw11;
487 : :
488 : 2686 : cdw11 = config.raw;
489 : 3680 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_ASYNC_EVENT_CONFIGURATION, cdw11, 0,
490 : : NULL, 0,
491 : 994 : cb_fn, cb_arg);
492 : 0 : }
493 : :
494 : : int
495 : 18 : 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 : 3 : union spdk_nvme_feat_host_identifier feat_host_identifier;
499 : :
500 : 18 : feat_host_identifier.raw = 0;
501 [ + + ]: 18 : if (host_id_size == 16) {
502 : : /* 128-bit extended host identifier */
503 : 6 : feat_host_identifier.bits.exhid = 1;
504 [ + + ]: 13 : } else if (host_id_size == 8) {
505 : : /* 64-bit host identifier */
506 : 6 : feat_host_identifier.bits.exhid = 0;
507 : 1 : } else {
508 : 6 : SPDK_ERRLOG("Invalid host ID size %u\n", host_id_size);
509 : 6 : return -EINVAL;
510 : : }
511 : :
512 : 14 : return spdk_nvme_ctrlr_cmd_set_feature(ctrlr, SPDK_NVME_FEAT_HOST_IDENTIFIER,
513 : 2 : feat_host_identifier.raw, 0,
514 : 2 : host_id, host_id_size, cb_fn, cb_arg);
515 : 3 : }
516 : :
517 : : int
518 : 1491 : 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 : 9 : struct nvme_request *req;
525 : 9 : struct spdk_nvme_cmd *cmd;
526 : 9 : uint32_t numd, numdl, numdu;
527 : 9 : uint32_t lpol, lpou;
528 : 9 : int rc;
529 : :
530 [ + + ]: 1491 : if (payload_size == 0) {
531 : 0 : return -EINVAL;
532 : : }
533 : :
534 [ - + ]: 1491 : if (offset & 3) {
535 : 0 : return -EINVAL;
536 : : }
537 : :
538 : 1491 : numd = spdk_nvme_bytes_to_numd(payload_size);
539 : 1491 : numdl = numd & 0xFFFFu;
540 [ + - ]: 1491 : numdu = (numd >> 16) & 0xFFFFu;
541 : :
542 : 1491 : lpol = (uint32_t)offset;
543 [ + - ]: 1491 : lpou = (uint32_t)(offset >> 32);
544 : :
545 : 1491 : nvme_ctrlr_lock(ctrlr);
546 : :
547 [ - + - - : 1491 : if (offset && !ctrlr->cdata.lpa.edlp) {
# # # # #
# ]
548 : 0 : nvme_ctrlr_unlock(ctrlr);
549 : 0 : return -EINVAL;
550 : : }
551 : :
552 [ + - + - ]: 1491 : req = nvme_allocate_request_user_copy(ctrlr->adminq,
553 : 11 : payload, payload_size, cb_fn, cb_arg, false);
554 [ + + ]: 1491 : if (req == NULL) {
555 : 0 : nvme_ctrlr_unlock(ctrlr);
556 : 0 : return -ENOMEM;
557 : : }
558 : :
559 [ - + ]: 1491 : cmd = &req->cmd;
560 [ - + ]: 1491 : cmd->opc = SPDK_NVME_OPC_GET_LOG_PAGE;
561 [ - + - + ]: 1491 : cmd->nsid = nsid;
562 [ - + - + : 1491 : cmd->cdw10 = cdw10;
- + ]
563 [ - + - + : 1491 : cmd->cdw10_bits.get_log_page.numdl = numdl;
- + - + ]
564 [ - + - + : 1491 : cmd->cdw10_bits.get_log_page.lid = log_page;
- + - + ]
565 : :
566 [ - + - + : 1491 : cmd->cdw11 = cdw11;
- + ]
567 [ - + - + : 1491 : cmd->cdw11_bits.get_log_page.numdu = numdu;
- + - + ]
568 [ - + - + : 1491 : cmd->cdw12 = lpol;
- + ]
569 [ - + - + ]: 1491 : cmd->cdw13 = lpou;
570 [ - + - + ]: 1491 : cmd->cdw14 = cdw14;
571 : :
572 : 1491 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
573 : 1491 : nvme_ctrlr_unlock(ctrlr);
574 : :
575 : 1491 : return rc;
576 : 11 : }
577 : :
578 : : int
579 : 856 : 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 : 867 : return spdk_nvme_ctrlr_cmd_get_log_page_ext(ctrlr, log_page, nsid, payload,
584 : 11 : payload_size, offset, 0, 0, 0, cb_fn, cb_arg);
585 : : }
586 : :
587 : : static void
588 : 300094 : nvme_ctrlr_retry_queued_abort(struct spdk_nvme_ctrlr *ctrlr)
589 : : {
590 : 0 : struct nvme_request *next, *tmp;
591 : 0 : int rc;
592 : :
593 [ - + + - : 300094 : 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 [ - + ]: 300094 : 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 [ + + # # : 300094 : STAILQ_FOREACH_SAFE(next, &ctrlr->queued_aborts, stailq, tmp) {
# # # # #
# # # # #
# # ]
604 [ + + # # : 180846 : STAILQ_REMOVE_HEAD(&ctrlr->queued_aborts, stailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
605 [ # # ]: 180846 : ctrlr->outstanding_aborts++;
606 : 180846 : rc = nvme_ctrlr_submit_admin_request(ctrlr, next);
607 [ - + ]: 180846 : 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 : 180846 : break;
617 : : }
618 : 0 : }
619 [ # # ]: 0 : }
620 : :
621 : : static int
622 : 300106 : _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 [ + + + - : 300106 : if (ctrlr->outstanding_aborts >= ctrlr->cdata.acl + 1U) {
+ - + - +
- - + ]
627 [ # # # # : 180846 : STAILQ_INSERT_TAIL(&ctrlr->queued_aborts, req, stailq);
# # # # #
# # # # #
# # # # #
# # # #
# ]
628 : 180846 : return 0;
629 : : } else {
630 [ + - ]: 119260 : ctrlr->outstanding_aborts++;
631 : 119260 : return nvme_ctrlr_submit_admin_request(ctrlr, req);
632 : : }
633 : 2 : }
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 : 0 : 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 : 18 : 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 : 3 : int rc;
655 : 3 : struct nvme_request *req;
656 : 3 : struct spdk_nvme_cmd *cmd;
657 : :
658 [ + + ]: 18 : if (qpair == NULL) {
659 [ + - + - ]: 12 : qpair = ctrlr->adminq;
660 : 2 : }
661 : :
662 : 18 : nvme_ctrlr_lock(ctrlr);
663 [ + - + - ]: 18 : req = nvme_allocate_request_null(ctrlr->adminq, nvme_ctrlr_cmd_abort_cpl, NULL);
664 [ + + ]: 18 : if (req == NULL) {
665 : 6 : nvme_ctrlr_unlock(ctrlr);
666 : 6 : return -ENOMEM;
667 : : }
668 [ + - + - ]: 12 : req->cb_arg = req;
669 [ + - + - ]: 12 : req->user_cb_fn = cb_fn;
670 [ + - + - ]: 12 : req->user_cb_arg = cb_arg;
671 : :
672 [ + - ]: 12 : cmd = &req->cmd;
673 [ + - ]: 12 : cmd->opc = SPDK_NVME_OPC_ABORT;
674 [ + - + - : 12 : cmd->cdw10_bits.abort.sqid = qpair->id;
+ - + - +
- + - ]
675 [ + - + - : 12 : cmd->cdw10_bits.abort.cid = cid;
+ - + - ]
676 : :
677 : 12 : rc = _nvme_ctrlr_submit_abort_request(ctrlr, req);
678 : :
679 : 12 : nvme_ctrlr_unlock(ctrlr);
680 : 12 : return rc;
681 : 3 : }
682 : :
683 : : static void
684 : 300094 : nvme_complete_abort_request(void *ctx, const struct spdk_nvme_cpl *cpl)
685 : : {
686 : 300094 : struct nvme_request *req = ctx;
687 [ # # # # ]: 300094 : struct nvme_request *parent = req->parent;
688 : 0 : struct spdk_nvme_ctrlr *ctrlr;
689 : :
690 [ # # # # : 300094 : ctrlr = req->qpair->ctrlr;
# # # # ]
691 : :
692 [ - + # # : 300094 : assert(ctrlr->outstanding_aborts > 0);
# # # # ]
693 [ # # ]: 300094 : ctrlr->outstanding_aborts--;
694 : 300094 : nvme_ctrlr_retry_queued_abort(ctrlr);
695 : :
696 : 300094 : nvme_request_remove_child(parent, req);
697 : :
698 [ + - + - : 300094 : if (!spdk_nvme_cpl_is_abort_success(cpl)) {
+ + # # #
# # # # #
# # # # #
# # # ]
699 [ # # # # : 252204 : parent->parent_status.cdw0 |= 1U;
# # ]
700 : 0 : }
701 : :
702 [ + - # # : 300094 : if (parent->num_children == 0) {
# # ]
703 [ # # # # : 300094 : nvme_complete_request(parent->cb_fn, parent->cb_arg, parent->qpair,
# # # # #
# # # ]
704 [ # # ]: 0 : parent, &parent->parent_status);
705 : 0 : }
706 : 300094 : }
707 : :
708 : : static int
709 : 23661667 : nvme_request_add_abort(struct nvme_request *req, void *arg)
710 : : {
711 : 23661667 : struct nvme_request *parent = arg;
712 : 3 : struct nvme_request *child;
713 : 3 : void *cmd_cb_arg;
714 : :
715 [ + - + - ]: 23661667 : cmd_cb_arg = parent->user_cb_arg;
716 : :
717 [ + + + - : 23661667 : if (req->cb_arg != cmd_cb_arg &&
+ + # # ]
718 [ + + + - : 23361554 : (req->parent == NULL || req->parent->cb_arg != cmd_cb_arg)) {
- + # # #
# # # #
# ]
719 : 23361554 : return 0;
720 : : }
721 : :
722 [ + - + - : 300113 : child = nvme_allocate_request_null(parent->qpair->ctrlr->adminq,
+ - + - +
- + - ]
723 : : nvme_complete_abort_request, NULL);
724 [ + + ]: 300113 : if (child == NULL) {
725 : 13 : return -ENOMEM;
726 : : }
727 : :
728 [ + - + - ]: 300100 : child->cb_arg = child;
729 : :
730 [ + - + - ]: 300100 : child->cmd.opc = SPDK_NVME_OPC_ABORT;
731 : : /* Copy SQID from the parent. */
732 [ + - + - : 300100 : child->cmd.cdw10_bits.abort.sqid = parent->cmd.cdw10_bits.abort.sqid;
+ - + - +
- + - + -
+ - + - +
- ]
733 [ + - + - : 300100 : child->cmd.cdw10_bits.abort.cid = req->cmd.cid;
+ - + - +
- + - + -
+ - ]
734 : :
735 [ + - + - ]: 300100 : child->parent = parent;
736 : :
737 [ + - + - : 300100 : TAILQ_INSERT_TAIL(&parent->children, child, child_tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
738 [ + - ]: 300100 : parent->num_children++;
739 : :
740 : 300100 : return 0;
741 : 3 : }
742 : :
743 : : int
744 : 841554 : spdk_nvme_ctrlr_cmd_abort_ext(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair,
745 : : void *cmd_cb_arg,
746 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
747 : : {
748 : 841554 : int rc = 0;
749 : 0 : struct nvme_request *parent, *child, *tmp;
750 : 841554 : bool child_failed = false;
751 : 841554 : int aborted = 0;
752 : :
753 [ - + ]: 841554 : if (cmd_cb_arg == NULL) {
754 : 0 : return -EINVAL;
755 : : }
756 : :
757 : 841554 : nvme_ctrlr_lock(ctrlr);
758 : :
759 [ - + ]: 841554 : if (qpair == NULL) {
760 [ # # # # ]: 0 : qpair = ctrlr->adminq;
761 : 0 : }
762 : :
763 [ # # # # ]: 841554 : parent = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
764 [ + + ]: 841554 : if (parent == NULL) {
765 : 437928 : nvme_ctrlr_unlock(ctrlr);
766 : :
767 : 437928 : return -ENOMEM;
768 : : }
769 : :
770 [ # # # # : 403626 : TAILQ_INIT(&parent->children);
# # # # #
# # # # #
# # ]
771 [ # # # # ]: 403626 : parent->num_children = 0;
772 : :
773 [ # # # # ]: 403626 : parent->cmd.opc = SPDK_NVME_OPC_ABORT;
774 [ - + # # ]: 403626 : memset(&parent->parent_status, 0, sizeof(struct spdk_nvme_cpl));
775 : :
776 : : /* Hold SQID that the requests to abort are associated with.
777 : : * This will be copied to the children.
778 : : *
779 : : * CID is not set here because the parent is not submitted directly
780 : : * and CID is not determined until request to abort is found.
781 : : */
782 [ # # # # : 403626 : parent->cmd.cdw10_bits.abort.sqid = qpair->id;
# # # # #
# # # #
# ]
783 : :
784 : : /* This is used to find request to abort. */
785 [ # # # # ]: 403626 : parent->user_cb_arg = cmd_cb_arg;
786 : :
787 : : /* Add an abort request for each outstanding request which has cmd_cb_arg
788 : : * as its callback context.
789 : : */
790 : 403626 : rc = nvme_transport_qpair_iterate_requests(qpair, nvme_request_add_abort, parent);
791 [ + + ]: 403626 : if (rc != 0) {
792 : : /* Free abort requests already added. */
793 : 7 : child_failed = true;
794 : 0 : }
795 : :
796 [ + + # # : 703720 : TAILQ_FOREACH_SAFE(child, &parent->children, child_tailq, tmp) {
# # # # #
# # # # #
# # ]
797 [ + - # # ]: 300094 : if (spdk_likely(!child_failed)) {
798 : 300094 : rc = _nvme_ctrlr_submit_abort_request(ctrlr, child);
799 [ - + ]: 300094 : if (spdk_unlikely(rc != 0)) {
800 : 0 : child_failed = true;
801 : 0 : }
802 : 0 : } else {
803 : : /* Free remaining abort requests. */
804 : 0 : nvme_request_remove_child(parent, child);
805 : 0 : nvme_free_request(child);
806 : : }
807 : 0 : }
808 : :
809 [ + + # # ]: 403626 : if (spdk_likely(!child_failed)) {
810 : : /* There is no error so far. Abort requests were submitted successfully
811 : : * or there was no outstanding request to abort.
812 : : *
813 : : * Hence abort queued requests which has cmd_cb_arg as its callback
814 : : * context next.
815 : : */
816 : 403619 : aborted = nvme_qpair_abort_queued_reqs_with_cbarg(qpair, cmd_cb_arg);
817 [ + + # # : 403619 : if (parent->num_children == 0) {
# # ]
818 : : /* There was no outstanding request to abort. */
819 [ + - ]: 103525 : if (aborted > 0) {
820 : : /* The queued requests were successfully aborted. Hence
821 : : * complete the parent request with success synchronously.
822 : : */
823 [ # # # # : 103525 : nvme_complete_request(parent->cb_fn, parent->cb_arg, parent->qpair,
# # # # #
# # # ]
824 [ # # ]: 0 : parent, &parent->parent_status);
825 : 0 : } else {
826 : : /* There was no queued request to abort. */
827 : 0 : rc = -ENOENT;
828 : : }
829 : 0 : }
830 : 0 : } else {
831 : : /* Failed to add or submit abort request. */
832 [ - + # # : 7 : if (parent->num_children != 0) {
# # ]
833 : : /* Return success since we must wait for those children
834 : : * to complete but set the parent request to failure.
835 : : */
836 [ # # # # : 0 : parent->parent_status.cdw0 |= 1U;
# # ]
837 : 0 : rc = 0;
838 : 0 : }
839 : : }
840 : :
841 [ + + ]: 403626 : if (rc != 0) {
842 : 7 : nvme_free_request(parent);
843 : 0 : }
844 : :
845 : 403626 : nvme_ctrlr_unlock(ctrlr);
846 : 403626 : return rc;
847 : 0 : }
848 : :
849 : : int
850 : 6 : nvme_ctrlr_cmd_fw_commit(struct spdk_nvme_ctrlr *ctrlr,
851 : : const struct spdk_nvme_fw_commit *fw_commit,
852 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
853 : : {
854 : 1 : struct nvme_request *req;
855 : 1 : struct spdk_nvme_cmd *cmd;
856 : 1 : int rc;
857 : :
858 : 6 : nvme_ctrlr_lock(ctrlr);
859 [ + - + - ]: 6 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
860 [ + + ]: 6 : if (req == NULL) {
861 : 0 : nvme_ctrlr_unlock(ctrlr);
862 : 0 : return -ENOMEM;
863 : : }
864 : :
865 [ + - ]: 6 : cmd = &req->cmd;
866 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_FIRMWARE_COMMIT;
867 [ + - + - : 6 : memcpy(&cmd->cdw10, fw_commit, sizeof(uint32_t));
+ - + - ]
868 : :
869 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
870 : 6 : nvme_ctrlr_unlock(ctrlr);
871 : :
872 : 6 : return rc;
873 : :
874 : 1 : }
875 : :
876 : : int
877 : 6 : nvme_ctrlr_cmd_fw_image_download(struct spdk_nvme_ctrlr *ctrlr,
878 : : uint32_t size, uint32_t offset, void *payload,
879 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
880 : : {
881 : 1 : struct nvme_request *req;
882 : 1 : struct spdk_nvme_cmd *cmd;
883 : 1 : int rc;
884 : :
885 : 6 : nvme_ctrlr_lock(ctrlr);
886 [ + - + - ]: 6 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, size, cb_fn, cb_arg, true);
887 [ + + ]: 6 : if (req == NULL) {
888 : 0 : nvme_ctrlr_unlock(ctrlr);
889 : 0 : return -ENOMEM;
890 : : }
891 : :
892 [ + - ]: 6 : cmd = &req->cmd;
893 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD;
894 [ + - + - : 6 : cmd->cdw10 = spdk_nvme_bytes_to_numd(size);
+ - ]
895 [ + - + - : 6 : cmd->cdw11 = offset >> 2;
+ - + - ]
896 : :
897 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
898 : 6 : nvme_ctrlr_unlock(ctrlr);
899 : :
900 : 6 : return rc;
901 : 1 : }
902 : :
903 : : int
904 : 170 : spdk_nvme_ctrlr_cmd_security_receive(struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
905 : : uint16_t spsp, uint8_t nssf, void *payload,
906 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
907 : : {
908 : 2 : struct nvme_request *req;
909 : 2 : struct spdk_nvme_cmd *cmd;
910 : 2 : int rc;
911 : :
912 : 170 : nvme_ctrlr_lock(ctrlr);
913 [ + - + - ]: 170 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
914 : 2 : cb_fn, cb_arg, false);
915 [ + + ]: 170 : if (req == NULL) {
916 : 6 : nvme_ctrlr_unlock(ctrlr);
917 : 6 : return -ENOMEM;
918 : : }
919 : :
920 [ + - ]: 164 : cmd = &req->cmd;
921 [ + - ]: 164 : cmd->opc = SPDK_NVME_OPC_SECURITY_RECEIVE;
922 [ + - + - : 164 : cmd->cdw10_bits.sec_send_recv.nssf = nssf;
+ - + - ]
923 [ + - + - : 164 : cmd->cdw10_bits.sec_send_recv.spsp0 = (uint8_t)spsp;
+ - + - ]
924 [ + - + - : 164 : cmd->cdw10_bits.sec_send_recv.spsp1 = (uint8_t)(spsp >> 8);
+ - + - +
- ]
925 [ + - + - : 164 : cmd->cdw10_bits.sec_send_recv.secp = secp;
+ - + - ]
926 [ + - + - : 164 : cmd->cdw11 = payload_size;
+ - ]
927 : :
928 : 164 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
929 : 164 : nvme_ctrlr_unlock(ctrlr);
930 : :
931 : 164 : return rc;
932 : 2 : }
933 : :
934 : : int
935 : 14 : spdk_nvme_ctrlr_cmd_security_send(struct spdk_nvme_ctrlr *ctrlr, uint8_t secp,
936 : : uint16_t spsp, uint8_t nssf, void *payload,
937 : : uint32_t payload_size, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
938 : : {
939 : 2 : struct nvme_request *req;
940 : 2 : struct spdk_nvme_cmd *cmd;
941 : 2 : int rc;
942 : :
943 : 14 : nvme_ctrlr_lock(ctrlr);
944 [ + - + - ]: 14 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
945 : 2 : cb_fn, cb_arg, true);
946 [ + + ]: 14 : if (req == NULL) {
947 : 6 : nvme_ctrlr_unlock(ctrlr);
948 : 6 : return -ENOMEM;
949 : : }
950 : :
951 [ + - ]: 8 : cmd = &req->cmd;
952 [ + - ]: 8 : cmd->opc = SPDK_NVME_OPC_SECURITY_SEND;
953 [ + - + - : 8 : cmd->cdw10_bits.sec_send_recv.nssf = nssf;
+ - + - ]
954 [ + - + - : 8 : cmd->cdw10_bits.sec_send_recv.spsp0 = (uint8_t)spsp;
+ - + - ]
955 [ + - + - : 8 : cmd->cdw10_bits.sec_send_recv.spsp1 = (uint8_t)(spsp >> 8);
+ - + - +
- ]
956 [ + - + - : 8 : cmd->cdw10_bits.sec_send_recv.secp = secp;
+ - + - ]
957 [ + - + - : 8 : cmd->cdw11 = payload_size;
+ - ]
958 : :
959 : 8 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
960 : 8 : nvme_ctrlr_unlock(ctrlr);
961 : :
962 : 8 : return rc;
963 : 2 : }
964 : :
965 : : int
966 : 6 : nvme_ctrlr_cmd_sanitize(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
967 : : struct spdk_nvme_sanitize *sanitize, uint32_t cdw11,
968 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg)
969 : : {
970 : 1 : struct nvme_request *req;
971 : 1 : struct spdk_nvme_cmd *cmd;
972 : 1 : int rc;
973 : :
974 : 6 : nvme_ctrlr_lock(ctrlr);
975 [ + - + - ]: 6 : req = nvme_allocate_request_null(ctrlr->adminq, cb_fn, cb_arg);
976 [ + + ]: 6 : if (req == NULL) {
977 : 0 : nvme_ctrlr_unlock(ctrlr);
978 : 0 : return -ENOMEM;
979 : : }
980 : :
981 [ + - ]: 6 : cmd = &req->cmd;
982 [ + - ]: 6 : cmd->opc = SPDK_NVME_OPC_SANITIZE;
983 [ + - + - ]: 6 : cmd->nsid = nsid;
984 [ + - + - : 6 : cmd->cdw11 = cdw11;
+ - ]
985 [ + - + - : 6 : memcpy(&cmd->cdw10, sanitize, sizeof(cmd->cdw10));
+ - + - ]
986 : :
987 : 6 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
988 : 6 : nvme_ctrlr_unlock(ctrlr);
989 : :
990 : 6 : return rc;
991 : 1 : }
992 : :
993 : : static int
994 : 12 : nvme_ctrlr_cmd_directive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
995 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
996 : : void *payload, uint32_t payload_size, uint32_t cdw12,
997 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
998 : : uint16_t opc_type, bool host_to_ctrlr)
999 : : {
1000 : 12 : struct nvme_request *req = NULL;
1001 : 12 : struct spdk_nvme_cmd *cmd = NULL;
1002 : 2 : int rc;
1003 : :
1004 : 12 : nvme_ctrlr_lock(ctrlr);
1005 [ + - + - ]: 12 : req = nvme_allocate_request_user_copy(ctrlr->adminq, payload, payload_size,
1006 [ + - ]: 2 : cb_fn, cb_arg, host_to_ctrlr);
1007 [ + + ]: 12 : if (req == NULL) {
1008 : 0 : nvme_ctrlr_unlock(ctrlr);
1009 : 0 : return -ENOMEM;
1010 : : }
1011 [ + - ]: 12 : cmd = &req->cmd;
1012 [ + - ]: 12 : cmd->opc = opc_type;
1013 [ + - + - ]: 12 : cmd->nsid = nsid;
1014 : :
1015 [ + + + - ]: 12 : if ((payload_size >> 2) > 0) {
1016 [ # # # # : 0 : cmd->cdw10 = (payload_size >> 2) - 1;
# # # # ]
1017 : 0 : }
1018 [ + - + - : 12 : cmd->cdw11_bits.directive.doper = doper;
+ - + - ]
1019 [ + - + - : 12 : cmd->cdw11_bits.directive.dtype = dtype;
+ - + - ]
1020 [ + - + - : 12 : cmd->cdw11_bits.directive.dspec = dspec;
+ - + - ]
1021 [ + - + - : 12 : cmd->cdw12 = cdw12;
+ - ]
1022 [ + - + - ]: 12 : cmd->cdw13 = cdw13;
1023 : 12 : rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
1024 : 12 : nvme_ctrlr_unlock(ctrlr);
1025 : :
1026 : 12 : return rc;
1027 : 2 : }
1028 : :
1029 : : int
1030 : 6 : spdk_nvme_ctrlr_cmd_directive_send(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
1031 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
1032 : : void *payload, uint32_t payload_size, uint32_t cdw12,
1033 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
1034 : : {
1035 : 7 : return nvme_ctrlr_cmd_directive(ctrlr, nsid, doper, dtype, dspec,
1036 : 1 : payload, payload_size, cdw12, cdw13, cb_fn, cb_arg,
1037 : : SPDK_NVME_OPC_DIRECTIVE_SEND, true);
1038 : : }
1039 : :
1040 : : int
1041 : 6 : spdk_nvme_ctrlr_cmd_directive_receive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
1042 : : uint32_t doper, uint32_t dtype, uint32_t dspec,
1043 : : void *payload, uint32_t payload_size, uint32_t cdw12,
1044 : : uint32_t cdw13, spdk_nvme_cmd_cb cb_fn, void *cb_arg)
1045 : : {
1046 : 7 : return nvme_ctrlr_cmd_directive(ctrlr, nsid, doper, dtype, dspec,
1047 : 1 : payload, payload_size, cdw12, cdw13, cb_fn, cb_arg,
1048 : : SPDK_NVME_OPC_DIRECTIVE_RECEIVE, false);
1049 : : }
|