1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
3 * Copyright (C) 2016 Intel Corporation.
4 * All rights reserved.
5 */
6
7 #include "scsi_internal.h"
8
9 #include "spdk/env.h"
10 #include "spdk/bdev.h"
11 #include "spdk/endian.h"
12 #include "spdk/likely.h"
13 #include "spdk/string.h"
14 #include "spdk/util.h"
15
16 #define SPDK_WORK_BLOCK_SIZE (4ULL * 1024ULL * 1024ULL)
17 #define SPDK_WORK_ATS_BLOCK_SIZE (1ULL * 1024ULL * 1024ULL)
18 #define MAX_SERIAL_STRING 32
19
20 #define DEFAULT_DISK_VENDOR "INTEL"
21 #define DEFAULT_DISK_REVISION "0001"
22 #define DEFAULT_DISK_ROTATION_RATE 1 /* Non-rotating medium */
23 #define DEFAULT_DISK_FORM_FACTOR 0x02 /* 3.5 inch */
24 #define DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT 256
25
26 #define INQUIRY_OFFSET(field) offsetof(struct spdk_scsi_cdb_inquiry_data, field) + \
27 SPDK_SIZEOF_MEMBER(struct spdk_scsi_cdb_inquiry_data, field)
28
29 static void bdev_scsi_process_block_resubmit(void *arg);
30
31 static void
bdev_scsi_set_naa_ieee_extended(const char * name,uint8_t * buf)32 bdev_scsi_set_naa_ieee_extended(const char *name, uint8_t *buf)
33 {
34 int i;
35 uint64_t local_value = 0, id_a, seed = 131;
36
37 for (i = 0; name[i] != '\0'; i++) {
38 local_value = (local_value * seed) + name[i];
39 }
40
41 /*
42 * see spc3r23 7.6.3.6.2,
43 * NAA IEEE Extended identifier format
44 */
45 id_a = local_value & 0x0000000fff000000ull;
46 id_a = id_a << 24;
47
48 local_value &= 0x0000000000ffffffull;
49 /* NAA 02, and 00 03 47 for IEEE Intel */
50 local_value |= 0x2000000347000000ull;
51 local_value |= id_a;
52
53 to_be64((void *)buf, local_value);
54 }
55
56 static int
bdev_scsi_report_luns(struct spdk_scsi_lun * lun,int sel,uint8_t * data,int alloc_len)57 bdev_scsi_report_luns(struct spdk_scsi_lun *lun,
58 int sel, uint8_t *data, int alloc_len)
59 {
60 struct spdk_scsi_dev *dev;
61 struct spdk_scsi_lun *tmp_lun;
62 uint64_t fmt_lun;
63 int hlen, len = 0;
64
65 if (alloc_len < 8) {
66 return -1;
67 }
68
69 if (sel == 0x00) {
70 /* logical unit with addressing method */
71 } else if (sel == 0x01) {
72 /* well known logical unit */
73 } else if (sel == 0x02) {
74 /* logical unit */
75 } else {
76 return -1;
77 }
78
79 /* LUN LIST LENGTH */
80 memset(data, 0, 4);
81
82 /* Reserved */
83 memset(&data[4], 0, 4);
84 hlen = 8;
85
86 dev = lun->dev;
87
88 for (tmp_lun = spdk_scsi_dev_get_first_lun(dev); tmp_lun != NULL;
89 tmp_lun = spdk_scsi_dev_get_next_lun(tmp_lun)) {
90 if (alloc_len - (hlen + len) < 8) {
91 return -1;
92 }
93
94 fmt_lun = spdk_scsi_lun_id_int_to_fmt(tmp_lun->id);
95
96 /* LUN */
97 to_be64(&data[hlen + len], fmt_lun);
98 len += 8;
99 }
100
101 /* LUN LIST LENGTH */
102 to_be32(data, len);
103
104 return hlen + len;
105 }
106
107 static int
bdev_scsi_pad_scsi_name(char * dst,const char * name)108 bdev_scsi_pad_scsi_name(char *dst, const char *name)
109 {
110 size_t len;
111
112 len = strlen(name);
113 memcpy(dst, name, len);
114 do {
115 dst[len++] = '\0';
116 } while (len & 3);
117
118 return len;
119 }
120
121 static int
bdev_scsi_inquiry(struct spdk_bdev * bdev,struct spdk_scsi_task * task,uint8_t * cdb,uint8_t * data,uint16_t alloc_len)122 bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
123 uint8_t *cdb, uint8_t *data, uint16_t alloc_len)
124 {
125 struct spdk_scsi_lun *lun;
126 struct spdk_scsi_dev *dev;
127 struct spdk_scsi_port *port;
128 uint32_t blocks, optimal_blocks;
129 int hlen = 0, plen, plen2;
130 uint16_t len = 0;
131 int pc;
132 int pd;
133 int evpd;
134 int i;
135 struct spdk_scsi_cdb_inquiry *inq = (struct spdk_scsi_cdb_inquiry *)cdb;
136
137 /* standard inquiry command at lease with 36 Bytes */
138 if (alloc_len < 0x24) {
139 goto inq_error;
140 }
141
142 lun = task->lun;
143 dev = lun->dev;
144 port = task->target_port;
145
146 pd = SPDK_SPC_PERIPHERAL_DEVICE_TYPE_DISK;
147 pc = inq->page_code;
148 evpd = inq->evpd & 0x1;
149
150 if (!evpd && pc) {
151 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
152 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
153 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
154 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
155 return -1;
156 }
157
158 if (evpd) {
159 struct spdk_scsi_vpd_page *vpage = (struct spdk_scsi_vpd_page *)data;
160
161 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
162 vpage->peripheral_device_type = pd;
163 vpage->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED;
164 /* PAGE CODE */
165 vpage->page_code = pc;
166
167 /* Vital product data */
168 switch (pc) {
169 case SPDK_SPC_VPD_SUPPORTED_VPD_PAGES:
170 hlen = 4;
171
172 vpage->params[0] = SPDK_SPC_VPD_SUPPORTED_VPD_PAGES;
173 vpage->params[1] = SPDK_SPC_VPD_UNIT_SERIAL_NUMBER;
174 vpage->params[2] = SPDK_SPC_VPD_DEVICE_IDENTIFICATION;
175 vpage->params[3] = SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES;
176 vpage->params[4] = SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA;
177 vpage->params[5] = SPDK_SPC_VPD_MODE_PAGE_POLICY;
178 vpage->params[6] = SPDK_SPC_VPD_SCSI_PORTS;
179 vpage->params[7] = SPDK_SPC_VPD_BLOCK_LIMITS;
180 vpage->params[8] = SPDK_SPC_VPD_BLOCK_DEV_CHARS;
181 len = 9;
182 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) {
183 vpage->params[9] = SPDK_SPC_VPD_BLOCK_THIN_PROVISION;
184 len++;
185 }
186
187 /* PAGE LENGTH */
188 to_be16(vpage->alloc_len, len);
189 break;
190
191 case SPDK_SPC_VPD_UNIT_SERIAL_NUMBER: {
192 const char *name = spdk_bdev_get_name(bdev);
193
194 hlen = 4;
195
196 /* PRODUCT SERIAL NUMBER */
197 len = strlen(name) + 1;
198 if (len > MAX_SERIAL_STRING) {
199 len = MAX_SERIAL_STRING;
200 }
201
202 memcpy(vpage->params, name, len - 1);
203 vpage->params[len - 1] = 0;
204
205 /* PAGE LENGTH */
206 to_be16(vpage->alloc_len, len);
207 break;
208 }
209
210 case SPDK_SPC_VPD_DEVICE_IDENTIFICATION: {
211 const char *name = spdk_bdev_get_name(bdev);
212 const char *product_name = spdk_bdev_get_product_name(bdev);
213 uint8_t protocol_id = dev->protocol_id;
214 uint8_t *buf = vpage->params;
215 struct spdk_scsi_desig_desc *desig;
216
217 hlen = 4;
218
219 /* Check total length by calculated how much space all entries take */
220 len = sizeof(struct spdk_scsi_desig_desc) + 8;
221 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING;
222 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_DEV_MAX_NAME + 1;
223 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_PORT_MAX_NAME_LENGTH;
224 len += sizeof(struct spdk_scsi_desig_desc) + 4;
225 len += sizeof(struct spdk_scsi_desig_desc) + 4;
226 len += sizeof(struct spdk_scsi_desig_desc) + 4;
227 if (sizeof(struct spdk_scsi_vpd_page) + len > alloc_len) {
228 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
229 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
230 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
231 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
232 return -1;
233 }
234
235 /* Now fill out the designator array */
236
237 /* NAA designator */
238 desig = (struct spdk_scsi_desig_desc *)buf;
239 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY;
240 desig->protocol_id = protocol_id;
241 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_NAA;
242 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT;
243 desig->reserved0 = 0;
244 desig->piv = 1;
245 desig->reserved1 = 0;
246 desig->len = 8;
247 bdev_scsi_set_naa_ieee_extended(name, desig->desig);
248 len = sizeof(struct spdk_scsi_desig_desc) + 8;
249
250 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
251
252 /* T10 Vendor ID designator */
253 desig = (struct spdk_scsi_desig_desc *)buf;
254 desig->code_set = SPDK_SPC_VPD_CODE_SET_ASCII;
255 desig->protocol_id = protocol_id;
256 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID;
257 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT;
258 desig->reserved0 = 0;
259 desig->piv = 1;
260 desig->reserved1 = 0;
261 desig->len = 8 + 16 + MAX_SERIAL_STRING;
262 spdk_strcpy_pad(desig->desig, DEFAULT_DISK_VENDOR, 8, ' ');
263 spdk_strcpy_pad(&desig->desig[8], product_name, 16, ' ');
264 spdk_strcpy_pad(&desig->desig[24], name, MAX_SERIAL_STRING, ' ');
265 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING;
266
267 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
268
269 /* SCSI Device Name designator */
270 desig = (struct spdk_scsi_desig_desc *)buf;
271 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8;
272 desig->protocol_id = protocol_id;
273 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME;
274 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_DEVICE;
275 desig->reserved0 = 0;
276 desig->piv = 1;
277 desig->reserved1 = 0;
278 desig->len = bdev_scsi_pad_scsi_name(desig->desig, dev->name);
279 len += sizeof(struct spdk_scsi_desig_desc) + desig->len;
280
281 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
282
283 /* SCSI Port Name designator */
284 desig = (struct spdk_scsi_desig_desc *)buf;
285 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8;
286 desig->protocol_id = protocol_id;
287 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME;
288 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT;
289 desig->reserved0 = 0;
290 desig->piv = 1;
291 desig->reserved1 = 0;
292 desig->len = snprintf(desig->desig, SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s", port->name);
293 len += sizeof(struct spdk_scsi_desig_desc) + desig->len;
294
295 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
296
297 /* Relative Target Port designator */
298 desig = (struct spdk_scsi_desig_desc *)buf;
299 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY;
300 desig->protocol_id = protocol_id;
301 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT;
302 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT;
303 desig->reserved0 = 0;
304 desig->piv = 1;
305 desig->reserved1 = 0;
306 desig->len = 4;
307 memset(desig->desig, 0, 2); /* Reserved */
308 to_be16(&desig->desig[2], port->index);
309 len += sizeof(struct spdk_scsi_desig_desc) + desig->len;
310
311 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
312
313 /* Target port group designator */
314 desig = (struct spdk_scsi_desig_desc *)buf;
315 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY;
316 desig->protocol_id = protocol_id;
317 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_TARGET_PORT_GROUP;
318 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT;
319 desig->reserved0 = 0;
320 desig->piv = 1;
321 desig->reserved1 = 0;
322 desig->len = 4;
323 memset(desig->desig, 0, 4);
324 len += sizeof(struct spdk_scsi_desig_desc) + desig->len;
325
326 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len;
327
328 /* Logical unit group designator */
329 desig = (struct spdk_scsi_desig_desc *)buf;
330 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY;
331 desig->protocol_id = protocol_id;
332 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_LOGICAL_UNIT_GROUP;
333 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT;
334 desig->reserved0 = 0;
335 desig->piv = 1;
336 desig->reserved1 = 0;
337 desig->len = 4;
338 memset(desig->desig, 0, 2); /* Reserved */
339 to_be16(&desig->desig[2], dev->id);
340 len += sizeof(struct spdk_scsi_desig_desc) + desig->len;
341
342 to_be16(vpage->alloc_len, len);
343
344 break;
345 }
346
347 case SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA: {
348 struct spdk_scsi_vpd_ext_inquiry *vext = (struct spdk_scsi_vpd_ext_inquiry *)vpage;
349
350 hlen = 4;
351 memset((uint8_t *)vext + hlen, 0, sizeof(*vext) - hlen);
352
353 /* RTO(3) GRD_CHK(2) APP_CHK(1) REF_CHK(0) */
354
355 /* GROUP_SUP(4) PRIOR_SUP(3) HEADSUP(2) ORDSUP(1) SIMPSUP(0) */
356 vext->sup = SPDK_SCSI_VEXT_HEADSUP | SPDK_SCSI_VEXT_SIMPSUP;
357
358 /* NV_SUP(1) V_SUP(0) */
359
360 /* Reserved[7-63] */
361
362 len = 64 - hlen;
363
364 /* PAGE LENGTH */
365 to_be16(vpage->alloc_len, len);
366 break;
367 }
368
369 case SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES:
370 /* PAGE LENGTH */
371 hlen = 4;
372
373 to_be16(vpage->alloc_len, len);
374 break;
375
376 case SPDK_SPC_VPD_MODE_PAGE_POLICY: {
377 struct spdk_scsi_mpage_policy_desc *pdesc =
378 (struct spdk_scsi_mpage_policy_desc *)vpage->params;
379
380 hlen = 4;
381
382 /* Mode page policy descriptor 1 */
383
384 /* POLICY PAGE CODE(5-0) */
385 /* all page code */
386 pdesc->page_code = 0x3f;
387
388 /* POLICY SUBPAGE CODE */
389 /* all sub page */
390 pdesc->sub_page_code = 0xff;
391
392 /* MLUS(7) MODE PAGE POLICY(1-0) */
393 /* MLUS own copy */
394 /* Shared MODE PAGE policy */
395 pdesc->policy = 0;
396 /* Reserved */
397 pdesc->reserved = 0;
398
399 len += 4;
400
401 to_be16(vpage->alloc_len, len);
402 break;
403 }
404
405 case SPDK_SPC_VPD_SCSI_PORTS: {
406 /* PAGE LENGTH */
407 hlen = 4;
408
409 /* Identification descriptor list */
410 for (i = 0; i < SPDK_SCSI_DEV_MAX_PORTS; i++) {
411 struct spdk_scsi_port_desc *sdesc;
412 struct spdk_scsi_tgt_port_desc *pdesc;
413
414 if (!dev->port[i].is_used) {
415 continue;
416 }
417
418 /* Identification descriptor N */
419 sdesc = (struct spdk_scsi_port_desc *)&vpage->params[len];
420
421 /* Reserved */
422 sdesc->reserved = 0;
423
424 /* RELATIVE PORT IDENTIFIER */
425 to_be16(&sdesc->rel_port_id, dev->port[i].index);
426
427 /* Reserved */
428 sdesc->reserved2 = 0;
429
430 /* INITIATOR PORT TRANSPORTID LENGTH */
431 sdesc->init_port_len = 0;
432
433 /* Reserved */
434 sdesc->init_port_id = 0;
435
436 /* TARGET PORT DESCRIPTORS LENGTH */
437 sdesc->tgt_desc_len = 0;
438
439 len += 12;
440
441 plen2 = 0;
442 /* Target port descriptor 1 */
443 pdesc = (struct spdk_scsi_tgt_port_desc *)sdesc->tgt_desc;
444
445 /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
446 pdesc->code_set =
447 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI << 4 |
448 SPDK_SPC_VPD_CODE_SET_UTF8;
449
450 /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
451 pdesc->desig_type = SPDK_SPC_VPD_DESIG_PIV |
452 SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT << 4 |
453 SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME;
454
455 /* Reserved */
456 pdesc->reserved = 0;
457
458 /* IDENTIFIER */
459 plen = snprintf((char *)pdesc->designator,
460 SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s",
461 dev->port[i].name);
462 pdesc->len = plen;
463
464 plen2 += 4 + plen;
465
466 /* TARGET PORT DESCRIPTORS LENGTH */
467 to_be16(&sdesc->tgt_desc_len, plen2);
468
469 len += plen2;
470 }
471
472 to_be16(vpage->alloc_len, len);
473 break;
474 }
475
476 case SPDK_SPC_VPD_BLOCK_LIMITS: {
477 uint32_t block_size = spdk_bdev_get_data_block_size(bdev);
478
479 /* PAGE LENGTH */
480 memset(&data[4], 0, 60);
481
482 hlen = 4;
483
484 /* WSNZ(0) */
485 /* support zero length in WRITE SAME */
486
487 /* MAXIMUM COMPARE AND WRITE LENGTH */
488 blocks = SPDK_WORK_ATS_BLOCK_SIZE / block_size;
489
490 if (blocks > 0xff) {
491 blocks = 0xff;
492 }
493
494 data[5] = (uint8_t)blocks;
495
496 /* force align to 4KB */
497 if (block_size < 4096) {
498 optimal_blocks = 4096 / block_size;
499 } else {
500 optimal_blocks = 1;
501 }
502
503 /* OPTIMAL TRANSFER LENGTH GRANULARITY */
504 to_be16(&data[6], optimal_blocks);
505
506 blocks = SPDK_WORK_BLOCK_SIZE / block_size;
507
508 /* MAXIMUM TRANSFER LENGTH */
509 to_be32(&data[8], blocks);
510 /* OPTIMAL TRANSFER LENGTH */
511 to_be32(&data[12], blocks);
512
513 /* MAXIMUM PREFETCH XDREAD XDWRITE TRANSFER LENGTH */
514
515 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) {
516 /*
517 * MAXIMUM UNMAP LBA COUNT: indicates the
518 * maximum number of LBAs that may be
519 * unmapped by an UNMAP command.
520 */
521 /* For now, choose 4MB as the maximum. */
522 to_be32(&data[20], 4194304);
523
524 /*
525 * MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT:
526 * indicates the maximum number of UNMAP
527 * block descriptors that shall be contained
528 * in the parameter data transferred to the
529 * device server for an UNMAP command.
530 * The bdev layer automatically splits unmap
531 * requests, so pick an arbitrary high number here.
532 */
533 to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT);
534
535 /*
536 * The UGAVALID bit is left as 0 which means neither the
537 * OPTIMAL UNMAP GRANULARITY nor the UNMAP GRANULARITY
538 * ALIGNMENT fields are valid.
539 */
540 }
541
542 /*
543 * MAXIMUM WRITE SAME LENGTH: indicates the
544 * maximum number of contiguous logical blocks
545 * that the device server allows to be unmapped
546 * or written in a single WRITE SAME command.
547 */
548 to_be64(&data[36], blocks);
549
550 /* Reserved */
551 /* not specified */
552 len = 64 - hlen;
553
554 to_be16(vpage->alloc_len, len);
555 break;
556 }
557
558 case SPDK_SPC_VPD_BLOCK_DEV_CHARS: {
559 /* PAGE LENGTH */
560 hlen = 4;
561 len = 64 - hlen;
562
563 to_be16(&data[4], DEFAULT_DISK_ROTATION_RATE);
564
565 /* Reserved */
566 data[6] = 0;
567 /* NOMINAL FORM FACTOR(3-0) */
568 data[7] = DEFAULT_DISK_FORM_FACTOR << 4;
569 /* Reserved */
570 memset(&data[8], 0, 64 - 8);
571
572 to_be16(vpage->alloc_len, len);
573 break;
574 }
575
576 case SPDK_SPC_VPD_BLOCK_THIN_PROVISION: {
577 if (!spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) {
578 goto inq_error;
579 }
580
581 hlen = 4;
582 len = 7;
583
584 /*
585 * PAGE LENGTH : if the DP bit is set to one, then the
586 * page length shall be set 0004h.
587 */
588 to_be16(&data[2], 0x0004);
589
590 /*
591 * THRESHOLD EXPONENT : it indicates the threshold set
592 * size in LBAs as a power of 2( i.e., the threshold
593 * set size = 2 ^ (threshold exponent).
594 */
595 data[4] = 0;
596
597 /*
598 * Set the LBPU bit to indicate the support for UNMAP
599 * command.
600 */
601 data[5] |= SPDK_SCSI_UNMAP_LBPU;
602
603 /*
604 * Set the provisioning type to thin provision.
605 */
606 data[6] = SPDK_SCSI_UNMAP_THIN_PROVISIONING;
607
608 to_be16(vpage->alloc_len, len);
609 break;
610 }
611
612 default:
613 if (pc >= 0xc0 && pc <= 0xff) {
614 SPDK_DEBUGLOG(scsi, "Vendor specific INQUIRY VPD page 0x%x\n", pc);
615 } else {
616 SPDK_NOTICELOG("unsupported INQUIRY VPD page 0x%x\n", pc);
617 }
618 goto inq_error;
619 }
620 } else {
621 struct spdk_scsi_cdb_inquiry_data *inqdata =
622 (struct spdk_scsi_cdb_inquiry_data *)data;
623
624 /* Standard INQUIRY data */
625 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
626 inqdata->peripheral_device_type = pd;
627 inqdata->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED;
628
629 /* RMB(7) */
630 inqdata->rmb = 0;
631
632 /* VERSION */
633 /* See SPC3/SBC2/MMC4/SAM2 for more details */
634 inqdata->version = SPDK_SPC_VERSION_SPC3;
635
636 /* NORMACA(5) HISUP(4) RESPONSE DATA FORMAT(3-0) */
637 /* format 2 */ /* hierarchical support */
638 inqdata->response = 2 | 1 << 4;
639
640 hlen = 5;
641
642 /* SCCS(7) ACC(6) TPGS(5-4) 3PC(3) PROTECT(0) */
643 /* Not support TPGS */
644 inqdata->flags = 0;
645
646 /* MULTIP */
647 inqdata->flags2 = 0x10;
648
649 /* WBUS16(5) SYNC(4) LINKED(3) CMDQUE(1) VS(0) */
650 /* CMDQUE */
651 inqdata->flags3 = 0x2;
652
653 /* T10 VENDOR IDENTIFICATION */
654 spdk_strcpy_pad(inqdata->t10_vendor_id, DEFAULT_DISK_VENDOR, 8, ' ');
655
656 /* PRODUCT IDENTIFICATION */
657 spdk_strcpy_pad(inqdata->product_id, spdk_bdev_get_product_name(bdev), 16, ' ');
658
659 /* PRODUCT REVISION LEVEL */
660 spdk_strcpy_pad(inqdata->product_rev, DEFAULT_DISK_REVISION, 4, ' ');
661
662 /*
663 * Standard inquiry data ends here. Only populate remaining fields if alloc_len
664 * indicates enough space to hold it.
665 */
666 len = INQUIRY_OFFSET(product_rev) - 5;
667
668 if (alloc_len >= INQUIRY_OFFSET(vendor)) {
669 /* Vendor specific */
670 memset(inqdata->vendor, 0x20, 20);
671 len += sizeof(inqdata->vendor);
672 }
673
674 if (alloc_len >= INQUIRY_OFFSET(ius)) {
675 /* CLOCKING(3-2) QAS(1) IUS(0) */
676 inqdata->ius = 0;
677 len += sizeof(inqdata->ius);
678 }
679
680 if (alloc_len >= INQUIRY_OFFSET(reserved)) {
681 /* Reserved */
682 inqdata->reserved = 0;
683 len += sizeof(inqdata->reserved);
684 }
685
686 /* VERSION DESCRIPTOR 1-8 */
687 if (alloc_len >= INQUIRY_OFFSET(reserved) + 2) {
688 to_be16(&inqdata->desc[0], 0x0960);
689 len += 2;
690 }
691
692 if (alloc_len >= INQUIRY_OFFSET(reserved) + 4) {
693 to_be16(&inqdata->desc[2], 0x0300); /* SPC-3 (no version claimed) */
694 len += 2;
695 }
696
697 if (alloc_len >= INQUIRY_OFFSET(reserved) + 6) {
698 to_be16(&inqdata->desc[4], 0x320); /* SBC-2 (no version claimed) */
699 len += 2;
700 }
701
702 if (alloc_len >= INQUIRY_OFFSET(reserved) + 8) {
703 to_be16(&inqdata->desc[6], 0x0040); /* SAM-2 (no version claimed) */
704 len += 2;
705 }
706
707 /*
708 * We only fill out 4 descriptors, but if the allocation length goes past
709 * that, zero the remaining bytes. This fixes some SCSI compliance tests
710 * which expect a full 96 bytes to be returned, including the unpopulated
711 * version descriptors 5-8 (4 * 2 = 8 bytes) plus the 22 bytes of reserved
712 * space (bytes 74-95) - for a total of 30 bytes.
713 */
714 if (alloc_len > INQUIRY_OFFSET(reserved) + 8) {
715 i = alloc_len - (INQUIRY_OFFSET(reserved) + 8);
716 if (i > 30) {
717 i = 30;
718 }
719 memset(&inqdata->desc[8], 0, i);
720 len += i;
721 }
722
723 /* ADDITIONAL LENGTH */
724 inqdata->add_len = len;
725 }
726
727 return hlen + len;
728
729 inq_error:
730 task->data_transferred = 0;
731 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
732 SPDK_SCSI_SENSE_NO_SENSE,
733 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
734 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
735 return -1;
736 }
737
738 static void
mode_sense_page_init(uint8_t * buf,int len,int page,int subpage)739 mode_sense_page_init(uint8_t *buf, int len, int page, int subpage)
740 {
741 if (!buf) {
742 return;
743 }
744
745 memset(buf, 0, len);
746 if (subpage != 0) {
747 buf[0] = page | 0x40; /* PAGE + SPF=1 */
748 buf[1] = subpage;
749 to_be16(&buf[2], len - 4);
750 } else {
751 buf[0] = page;
752 buf[1] = len - 2;
753 }
754 }
755
756 static int
bdev_scsi_mode_sense_page(struct spdk_bdev * bdev,uint8_t * cdb,int pc,int page,int subpage,uint8_t * data,struct spdk_scsi_task * task)757 bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
758 uint8_t *cdb, int pc, int page, int subpage,
759 uint8_t *data, struct spdk_scsi_task *task)
760 {
761 uint8_t *cp = data;
762 int len = 0;
763 int plen;
764 int i;
765
766 if (pc == 0x00) {
767 /* Current values */
768 } else if (pc == 0x01) {
769 /* Changeable values */
770 /* As we currently do not support changeable values,
771 all parameters are reported as zero. */
772 } else if (pc == 0x02) {
773 /* Default values */
774 } else {
775 /* Saved values not supported */
776 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
777 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
778 SPDK_SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED,
779 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
780 return -1;
781 }
782
783 switch (page) {
784 case 0x00:
785 /* Vendor specific */
786 break;
787 case 0x01:
788 /* Read-Write Error Recovery */
789 SPDK_DEBUGLOG(scsi,
790 "MODE_SENSE Read-Write Error Recovery\n");
791 if (subpage != 0x00) {
792 break;
793 }
794 plen = 0x0a + 2;
795 mode_sense_page_init(cp, plen, page, subpage);
796 len += plen;
797 break;
798 case 0x02:
799 /* Disconnect-Reconnect */
800 SPDK_DEBUGLOG(scsi,
801 "MODE_SENSE Disconnect-Reconnect\n");
802 if (subpage != 0x00) {
803 break;
804 }
805 plen = 0x0e + 2;
806 mode_sense_page_init(cp, plen, page, subpage);
807 len += plen;
808 break;
809 case 0x03:
810 /* Obsolete (Format Device) */
811 break;
812 case 0x04:
813 /* Obsolete (Rigid Disk Geometry) */
814 break;
815 case 0x05:
816 /* Obsolete (Rigid Disk Geometry) */
817 break;
818 case 0x06:
819 /* Reserved */
820 break;
821 case 0x07:
822 /* Verify Error Recovery */
823 SPDK_DEBUGLOG(scsi,
824 "MODE_SENSE Verify Error Recovery\n");
825
826 if (subpage != 0x00) {
827 break;
828 }
829
830 plen = 0x0a + 2;
831 mode_sense_page_init(cp, plen, page, subpage);
832 len += plen;
833 break;
834 case 0x08: {
835 /* Caching */
836 SPDK_DEBUGLOG(scsi, "MODE_SENSE Caching\n");
837 if (subpage != 0x00) {
838 break;
839 }
840
841 plen = 0x12 + 2;
842 mode_sense_page_init(cp, plen, page, subpage);
843
844 if (cp && spdk_bdev_has_write_cache(bdev) && pc != 0x01) {
845 cp[2] |= 0x4; /* WCE */
846 }
847
848 /* Read Cache Disable (RCD) = 1 */
849 if (cp && pc != 0x01) {
850 cp[2] |= 0x1;
851 }
852
853 len += plen;
854 break;
855 }
856 case 0x09:
857 /* Obsolete */
858 break;
859 case 0x0a:
860 switch (subpage) {
861 case 0x00:
862 /* Control */
863 SPDK_DEBUGLOG(scsi,
864 "MODE_SENSE Control\n");
865 plen = 0x0a + 2;
866 mode_sense_page_init(cp, plen, page, subpage);
867 len += plen;
868 break;
869 case 0x01:
870 /* Control Extension */
871 SPDK_DEBUGLOG(scsi,
872 "MODE_SENSE Control Extension\n");
873 plen = 0x1c + 4;
874 mode_sense_page_init(cp, plen, page, subpage);
875 len += plen;
876 break;
877 case 0xff:
878 /* All subpages */
879 len += bdev_scsi_mode_sense_page(bdev,
880 cdb, pc, page,
881 0x00,
882 cp ? &cp[len] : NULL, task);
883 len += bdev_scsi_mode_sense_page(bdev,
884 cdb, pc, page,
885 0x01,
886 cp ? &cp[len] : NULL, task);
887 break;
888 default:
889 /* 0x02-0x3e: Reserved */
890 break;
891 }
892 break;
893 case 0x0b:
894 /* Obsolete (Medium Types Supported) */
895 break;
896 case 0x0c:
897 /* Obsolete (Notch And Partition) */
898 break;
899 case 0x0d:
900 /* Obsolete */
901 break;
902 case 0x0e:
903 case 0x0f:
904 /* Reserved */
905 break;
906 case 0x10:
907 /* XOR Control */
908 SPDK_DEBUGLOG(scsi, "MODE_SENSE XOR Control\n");
909 if (subpage != 0x00) {
910 break;
911 }
912 plen = 0x16 + 2;
913 mode_sense_page_init(cp, plen, page, subpage);
914 len += plen;
915 break;
916 case 0x11:
917 case 0x12:
918 case 0x13:
919 /* Reserved */
920 break;
921 case 0x14:
922 /* Enclosure Services Management */
923 break;
924 case 0x15:
925 case 0x16:
926 case 0x17:
927 /* Reserved */
928 break;
929 case 0x18:
930 /* Protocol-Specific LUN */
931 break;
932 case 0x19:
933 /* Protocol-Specific Port */
934 break;
935 case 0x1a:
936 /* Power Condition */
937 SPDK_DEBUGLOG(scsi,
938 "MODE_SENSE Power Condition\n");
939 if (subpage != 0x00) {
940 break;
941 }
942 plen = 0x0a + 2;
943 mode_sense_page_init(cp, plen, page, subpage);
944 len += plen;
945 break;
946 case 0x1b:
947 /* Reserved */
948 break;
949 case 0x1c:
950 /* Informational Exceptions Control */
951 SPDK_DEBUGLOG(scsi,
952 "MODE_SENSE Informational Exceptions Control\n");
953 if (subpage != 0x00) {
954 break;
955 }
956
957 plen = 0x0a + 2;
958 mode_sense_page_init(cp, plen, page, subpage);
959 len += plen;
960 break;
961 case 0x1d:
962 case 0x1e:
963 case 0x1f:
964 /* Reserved */
965 break;
966 case 0x20:
967 case 0x21:
968 case 0x22:
969 case 0x23:
970 case 0x24:
971 case 0x25:
972 case 0x26:
973 case 0x27:
974 case 0x28:
975 case 0x29:
976 case 0x2a:
977 case 0x2b:
978 case 0x2c:
979 case 0x2d:
980 case 0x2e:
981 case 0x2f:
982 case 0x30:
983 case 0x31:
984 case 0x32:
985 case 0x33:
986 case 0x34:
987 case 0x35:
988 case 0x36:
989 case 0x37:
990 case 0x38:
991 case 0x39:
992 case 0x3a:
993 case 0x3b:
994 case 0x3c:
995 case 0x3d:
996 case 0x3e:
997 /* Vendor-specific */
998 break;
999 case 0x3f:
1000 switch (subpage) {
1001 case 0x00:
1002 /* All mode pages */
1003 for (i = 0x00; i < 0x3e; i ++) {
1004 len += bdev_scsi_mode_sense_page(
1005 bdev, cdb, pc, i, 0x00,
1006 cp ? &cp[len] : NULL, task);
1007 }
1008 break;
1009 case 0xff:
1010 /* All mode pages and subpages */
1011 for (i = 0x00; i < 0x3e; i ++) {
1012 len += bdev_scsi_mode_sense_page(
1013 bdev, cdb, pc, i, 0x00,
1014 cp ? &cp[len] : NULL, task);
1015 }
1016 for (i = 0x00; i < 0x3e; i ++) {
1017 len += bdev_scsi_mode_sense_page(
1018 bdev, cdb, pc, i, 0xff,
1019 cp ? &cp[len] : NULL, task);
1020 }
1021 break;
1022 default:
1023 /* 0x01-0x3e: Reserved */
1024 break;
1025 }
1026 }
1027
1028 return len;
1029 }
1030
1031 static int
bdev_scsi_mode_sense(struct spdk_bdev * bdev,int md,uint8_t * cdb,int dbd,int llbaa,int pc,int page,int subpage,uint8_t * data,struct spdk_scsi_task * task)1032 bdev_scsi_mode_sense(struct spdk_bdev *bdev, int md,
1033 uint8_t *cdb, int dbd, int llbaa, int pc,
1034 int page, int subpage, uint8_t *data, struct spdk_scsi_task *task)
1035 {
1036 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev);
1037 uint32_t block_size = spdk_bdev_get_data_block_size(bdev);
1038 uint8_t *hdr, *bdesc, *pages;
1039 int hlen;
1040 int blen;
1041 int plen, total;
1042
1043 assert(md == 6 || md == 10);
1044
1045 if (md == 6) {
1046 hlen = 4;
1047 blen = 8; /* For MODE SENSE 6 only short LBA */
1048 } else {
1049 hlen = 8;
1050 blen = llbaa ? 16 : 8;
1051 }
1052
1053 if (dbd) {
1054 blen = 0;
1055 }
1056
1057 pages = data ? &data[hlen + blen] : NULL;
1058 plen = bdev_scsi_mode_sense_page(bdev, cdb, pc, page,
1059 subpage,
1060 pages, task);
1061 if (plen < 0) {
1062 return -1;
1063 }
1064
1065 total = hlen + blen + plen;
1066 if (data == NULL) {
1067 return total;
1068 }
1069
1070 hdr = &data[0];
1071 if (hlen == 4) {
1072 hdr[0] = total - 1; /* Mode Data Length */
1073 hdr[1] = 0; /* Medium Type */
1074 hdr[2] = 0; /* Device-Specific Parameter */
1075 hdr[3] = blen; /* Block Descriptor Length */
1076 } else {
1077 to_be16(&hdr[0], total - 2); /* Mode Data Length */
1078 hdr[2] = 0; /* Medium Type */
1079 hdr[3] = 0; /* Device-Specific Parameter */
1080 hdr[4] = llbaa ? 0x1 : 0; /* Long/short LBA */
1081 hdr[5] = 0; /* Reserved */
1082 to_be16(&hdr[6], blen); /* Block Descriptor Length */
1083 }
1084
1085 bdesc = &data[hlen];
1086 if (blen == 16) {
1087 /* Number of Blocks */
1088 to_be64(&bdesc[0], num_blocks);
1089 /* Reserved */
1090 memset(&bdesc[8], 0, 4);
1091 /* Block Length */
1092 to_be32(&bdesc[12], block_size);
1093 } else if (blen == 8) {
1094 /* Number of Blocks */
1095 if (num_blocks > 0xffffffffULL) {
1096 memset(&bdesc[0], 0xff, 4);
1097 } else {
1098 to_be32(&bdesc[0], num_blocks);
1099 }
1100
1101 /* Block Length */
1102 to_be32(&bdesc[4], block_size);
1103 }
1104
1105 return total;
1106 }
1107
1108 static void
bdev_scsi_task_complete_cmd(struct spdk_bdev_io * bdev_io,bool success,void * cb_arg)1109 bdev_scsi_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success,
1110 void *cb_arg)
1111 {
1112 struct spdk_scsi_task *task = cb_arg;
1113 int sc, sk, asc, ascq;
1114
1115 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq);
1116
1117 spdk_bdev_free_io(bdev_io);
1118
1119 spdk_scsi_task_set_status(task, sc, sk, asc, ascq);
1120 scsi_lun_complete_task(task->lun, task);
1121 }
1122
1123 static void
bdev_scsi_read_task_complete_cmd(struct spdk_bdev_io * bdev_io,bool success,void * cb_arg)1124 bdev_scsi_read_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success,
1125 void *cb_arg)
1126 {
1127 struct spdk_scsi_task *task = cb_arg;
1128 int sc, sk, asc, ascq;
1129
1130 task->bdev_io = bdev_io;
1131
1132 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq);
1133
1134 spdk_scsi_task_set_status(task, sc, sk, asc, ascq);
1135 scsi_lun_complete_task(task->lun, task);
1136 }
1137
1138 static void
bdev_scsi_task_complete_reset(struct spdk_bdev_io * bdev_io,bool success,void * cb_arg)1139 bdev_scsi_task_complete_reset(struct spdk_bdev_io *bdev_io, bool success,
1140 void *cb_arg)
1141 {
1142 struct spdk_scsi_task *task = cb_arg;
1143
1144 spdk_bdev_free_io(bdev_io);
1145
1146 if (success) {
1147 task->response = SPDK_SCSI_TASK_MGMT_RESP_SUCCESS;
1148 }
1149
1150 scsi_lun_complete_reset_task(task->lun, task);
1151 }
1152
1153 static void
bdev_scsi_queue_io(struct spdk_scsi_task * task,spdk_bdev_io_wait_cb cb_fn,void * cb_arg)1154 bdev_scsi_queue_io(struct spdk_scsi_task *task, spdk_bdev_io_wait_cb cb_fn, void *cb_arg)
1155 {
1156 struct spdk_scsi_lun *lun = task->lun;
1157 struct spdk_bdev *bdev = lun->bdev;
1158 struct spdk_io_channel *ch = lun->io_channel;
1159 int rc;
1160
1161 task->bdev_io_wait.bdev = bdev;
1162 task->bdev_io_wait.cb_fn = cb_fn;
1163 task->bdev_io_wait.cb_arg = cb_arg;
1164
1165 rc = spdk_bdev_queue_io_wait(bdev, ch, &task->bdev_io_wait);
1166 if (rc != 0) {
1167 assert(false);
1168 }
1169 }
1170
1171 static int
bdev_scsi_sync(struct spdk_bdev * bdev,struct spdk_bdev_desc * bdev_desc,struct spdk_io_channel * bdev_ch,struct spdk_scsi_task * task,uint64_t lba,uint32_t num_blocks)1172 bdev_scsi_sync(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc,
1173 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task,
1174 uint64_t lba, uint32_t num_blocks)
1175 {
1176 uint64_t bdev_num_blocks;
1177 int rc;
1178
1179 if (num_blocks == 0) {
1180 return SPDK_SCSI_TASK_COMPLETE;
1181 }
1182
1183 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev);
1184
1185 if (lba >= bdev_num_blocks || num_blocks > bdev_num_blocks ||
1186 lba > (bdev_num_blocks - num_blocks)) {
1187 SPDK_ERRLOG("end of media\n");
1188 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1189 SPDK_SCSI_SENSE_NO_SENSE,
1190 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1191 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1192 return SPDK_SCSI_TASK_COMPLETE;
1193 }
1194
1195 rc = spdk_bdev_flush_blocks(bdev_desc, bdev_ch, lba, num_blocks,
1196 bdev_scsi_task_complete_cmd, task);
1197
1198 if (rc) {
1199 if (rc == -ENOMEM) {
1200 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task);
1201 return SPDK_SCSI_TASK_PENDING;
1202 }
1203 SPDK_ERRLOG("spdk_bdev_flush_blocks() failed\n");
1204 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1205 SPDK_SCSI_SENSE_NO_SENSE,
1206 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1207 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1208 return SPDK_SCSI_TASK_COMPLETE;
1209 }
1210 task->data_transferred = 0;
1211 return SPDK_SCSI_TASK_PENDING;
1212 }
1213
1214 static uint64_t
_bytes_to_blocks(uint32_t block_size,uint64_t offset_bytes,uint64_t * offset_blocks,uint64_t num_bytes,uint64_t * num_blocks)1215 _bytes_to_blocks(uint32_t block_size, uint64_t offset_bytes, uint64_t *offset_blocks,
1216 uint64_t num_bytes, uint64_t *num_blocks)
1217 {
1218 uint8_t shift_cnt;
1219
1220 /* Avoid expensive div operations if possible. These spdk_u32 functions are very cheap. */
1221 if (spdk_likely(spdk_u32_is_pow2(block_size))) {
1222 shift_cnt = spdk_u32log2(block_size);
1223 *offset_blocks = offset_bytes >> shift_cnt;
1224 *num_blocks = num_bytes >> shift_cnt;
1225 return (offset_bytes - (*offset_blocks << shift_cnt)) |
1226 (num_bytes - (*num_blocks << shift_cnt));
1227 } else {
1228 *offset_blocks = offset_bytes / block_size;
1229 *num_blocks = num_bytes / block_size;
1230 return (offset_bytes % block_size) | (num_bytes % block_size);
1231 }
1232 }
1233
1234 static int
bdev_scsi_readwrite(struct spdk_bdev * bdev,struct spdk_bdev_desc * bdev_desc,struct spdk_io_channel * bdev_ch,struct spdk_scsi_task * task,uint64_t lba,uint32_t xfer_len,bool is_read,bool is_compare)1235 bdev_scsi_readwrite(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc,
1236 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task,
1237 uint64_t lba, uint32_t xfer_len, bool is_read, bool is_compare)
1238 {
1239 uint64_t bdev_num_blocks, offset_blocks, num_blocks;
1240 uint32_t max_xfer_len, block_size;
1241 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE;
1242 int rc;
1243
1244 task->data_transferred = 0;
1245
1246 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_NONE &&
1247 task->dxfer_dir != (is_read ? SPDK_SCSI_DIR_FROM_DEV : SPDK_SCSI_DIR_TO_DEV))) {
1248 SPDK_ERRLOG("Incorrect data direction\n");
1249 goto check_condition;
1250 }
1251
1252 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev);
1253 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) {
1254 SPDK_DEBUGLOG(scsi, "end of media\n");
1255 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST;
1256 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1257 goto check_condition;
1258 }
1259
1260 if (spdk_unlikely(xfer_len == 0)) {
1261 task->status = SPDK_SCSI_STATUS_GOOD;
1262 return SPDK_SCSI_TASK_COMPLETE;
1263 }
1264
1265 block_size = spdk_bdev_get_data_block_size(bdev);
1266
1267 /* Transfer Length is limited to the Block Limits VPD page Maximum Transfer Length */
1268 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size;
1269 if (spdk_unlikely(xfer_len > max_xfer_len)) {
1270 SPDK_ERRLOG("xfer_len %" PRIu32 " > maximum transfer length %" PRIu32 "\n",
1271 xfer_len, max_xfer_len);
1272 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST;
1273 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB;
1274 goto check_condition;
1275 }
1276
1277 if (!is_read) {
1278 /* Additional check for Transfer Length */
1279 if (xfer_len * block_size > task->transfer_len) {
1280 SPDK_ERRLOG("xfer_len %" PRIu32 " * block_size %" PRIu32 " > transfer_len %u\n",
1281 xfer_len, block_size, task->transfer_len);
1282 goto check_condition;
1283 }
1284 }
1285
1286 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks, task->length, &num_blocks) != 0) {
1287 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n",
1288 task->offset, task->length);
1289 goto check_condition;
1290 }
1291
1292 offset_blocks += lba;
1293
1294 SPDK_DEBUGLOG(scsi,
1295 "%s: lba=%"PRIu64", len=%"PRIu64"\n",
1296 is_read ? "Read" : "Write", offset_blocks, num_blocks);
1297
1298 if (is_read) {
1299 rc = spdk_bdev_readv_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt,
1300 offset_blocks, num_blocks,
1301 bdev_scsi_read_task_complete_cmd, task);
1302 } else if (is_compare) {
1303 struct iovec *iov;
1304 size_t len;
1305
1306 if (task->iovcnt != 1 || task->iovs[0].iov_len != (block_size * 2)) {
1307 if (task->iovcnt != 1) {
1308 SPDK_ERRLOG("task's iovcnt %" PRIu32 " is not 1.\n", task->iovcnt);
1309 } else {
1310 SPDK_ERRLOG("task's iov len %" PRIu64 " is not 2 * BLOCK_SIZE.\n",
1311 task->iovs[0].iov_len);
1312 }
1313 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST;
1314 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB;
1315 goto check_condition;
1316 }
1317
1318 iov = &task->iovs[0];
1319 len = iov->iov_len >> 1;
1320 task->caw_iov.iov_len = len;
1321 task->caw_iov.iov_base = (uint8_t *)(iov->iov_base) + len;
1322 iov->iov_len = len;
1323
1324 rc = spdk_bdev_comparev_and_writev_blocks(bdev_desc, bdev_ch, iov, 1,
1325 &task->caw_iov, 1, offset_blocks, 1, bdev_scsi_task_complete_cmd, task);
1326 } else {
1327 rc = spdk_bdev_writev_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt,
1328 offset_blocks, num_blocks,
1329 bdev_scsi_task_complete_cmd, task);
1330 }
1331
1332 if (rc) {
1333 if (rc == -ENOMEM) {
1334 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task);
1335 return SPDK_SCSI_TASK_PENDING;
1336 }
1337 SPDK_ERRLOG("spdk_bdev_%s_blocks() failed: %d\n",
1338 is_read ? "readv" : (is_compare ? "comparev_and_writev" : "writev"), rc);
1339 goto check_condition;
1340 }
1341
1342 task->data_transferred = task->length;
1343 return SPDK_SCSI_TASK_PENDING;
1344
1345 check_condition:
1346 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, sk, asc,
1347 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1348 return SPDK_SCSI_TASK_COMPLETE;
1349 }
1350
1351 struct spdk_bdev_scsi_split_ctx {
1352 struct spdk_scsi_task *task;
1353 union {
1354 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT];
1355 uint64_t start_offset_blocks; /* used by writesame */
1356 };
1357 uint16_t remaining_count;
1358 uint16_t current_count;
1359 uint16_t outstanding_count;
1360 int (*fn)(struct spdk_bdev_scsi_split_ctx *ctx);
1361 };
1362
1363 static int bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx);
1364
1365 static void
bdev_scsi_split_resubmit(void * arg)1366 bdev_scsi_split_resubmit(void *arg)
1367 {
1368 struct spdk_bdev_scsi_split_ctx *ctx = arg;
1369
1370 bdev_scsi_split(ctx);
1371 }
1372
1373 static int
bdev_scsi_split(struct spdk_bdev_scsi_split_ctx * ctx)1374 bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx)
1375 {
1376 struct spdk_scsi_task *task = ctx->task;
1377 uint8_t opcode = task->cdb[0];
1378 int rc;
1379
1380 while (ctx->remaining_count != 0) {
1381 rc = ctx->fn(ctx);
1382 if (rc == 0) {
1383 ctx->current_count++;
1384 ctx->remaining_count--;
1385 ctx->outstanding_count++;
1386 continue;
1387 } else if (rc == -ENOMEM) {
1388 break;
1389 }
1390
1391 SPDK_ERRLOG("SCSI %s failed\n", spdk_scsi_sbc_opcode_string(opcode, 0));
1392 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1393 SPDK_SCSI_SENSE_NO_SENSE,
1394 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1395 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1396 /* If any child I/O failed, stop further splitting process. */
1397 ctx->current_count += ctx->remaining_count;
1398 ctx->remaining_count = 0;
1399 break;
1400 }
1401
1402 if (ctx->outstanding_count != 0) {
1403 /* We can't complete here - we may have to wait for previously
1404 * submitted child I/Os to complete */
1405 return SPDK_SCSI_TASK_PENDING;
1406 }
1407
1408 if (rc == -ENOMEM) {
1409 /* none outstanding child IO submitted, no callback would be involked.
1410 this is the last chance to resubmit on -ENOMEM */
1411 bdev_scsi_queue_io(task, bdev_scsi_split_resubmit, ctx);
1412 return SPDK_SCSI_TASK_PENDING;
1413 }
1414
1415 free(ctx);
1416 return SPDK_SCSI_TASK_COMPLETE;
1417 }
1418
1419 static void
bdev_scsi_task_complete_split_cmd(struct spdk_bdev_io * bdev_io,bool success,void * cb_arg)1420 bdev_scsi_task_complete_split_cmd(struct spdk_bdev_io *bdev_io, bool success,
1421 void *cb_arg)
1422 {
1423 struct spdk_bdev_scsi_split_ctx *ctx = cb_arg;
1424 struct spdk_scsi_task *task = ctx->task;
1425
1426 spdk_bdev_free_io(bdev_io);
1427
1428 if (!success) {
1429 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1430 SPDK_SCSI_SENSE_NO_SENSE,
1431 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1432 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1433 /* If any child I/O failed, stop further splitting process. */
1434 ctx->current_count += ctx->remaining_count;
1435 ctx->remaining_count = 0;
1436 }
1437
1438 ctx->outstanding_count--;
1439 if (ctx->outstanding_count != 0) {
1440 /* Any child I/O is still outstanding. */
1441 return;
1442 }
1443
1444 if (ctx->remaining_count == 0) {
1445 /* SCSI task finishes when all descriptors are consumed. */
1446 scsi_lun_complete_task(task->lun, task);
1447 free(ctx);
1448 return;
1449 }
1450
1451 /* Continue with splitting process. */
1452 bdev_scsi_split(ctx);
1453 }
1454
1455 static int
__copy_desc(struct spdk_bdev_scsi_split_ctx * ctx,uint8_t * data,size_t data_len)1456 __copy_desc(struct spdk_bdev_scsi_split_ctx *ctx, uint8_t *data, size_t data_len)
1457 {
1458 uint16_t desc_data_len;
1459 uint16_t desc_count;
1460
1461 if (!data) {
1462 return -EINVAL;
1463 }
1464
1465 if (data_len < 8) {
1466 /* We can't even get the reported length, so fail. */
1467 return -EINVAL;
1468 }
1469
1470 desc_data_len = from_be16(&data[2]);
1471 desc_count = desc_data_len / 16;
1472
1473 if (desc_data_len > (data_len - 8)) {
1474 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%zu) - 8\n",
1475 desc_data_len, data_len);
1476 return -EINVAL;
1477 }
1478
1479 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) {
1480 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n",
1481 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT);
1482 return -EINVAL;
1483 }
1484
1485 memcpy(ctx->desc, &data[8], desc_data_len);
1486 return desc_count;
1487 }
1488
1489 static int
_bdev_scsi_unmap(struct spdk_bdev_scsi_split_ctx * ctx)1490 _bdev_scsi_unmap(struct spdk_bdev_scsi_split_ctx *ctx)
1491 {
1492 struct spdk_scsi_task *task = ctx->task;
1493 struct spdk_scsi_lun *lun = task->lun;
1494 struct spdk_scsi_unmap_bdesc *desc;
1495 uint64_t offset_blocks;
1496 uint64_t num_blocks;
1497
1498 desc = &ctx->desc[ctx->current_count];
1499
1500 offset_blocks = from_be64(&desc->lba);
1501 num_blocks = from_be32(&desc->block_count);
1502
1503 return spdk_bdev_unmap_blocks(lun->bdev_desc,
1504 lun->io_channel,
1505 offset_blocks,
1506 num_blocks,
1507 bdev_scsi_task_complete_split_cmd,
1508 ctx);
1509 }
1510
1511 static int
bdev_scsi_unmap(struct spdk_bdev * bdev,struct spdk_scsi_task * task)1512 bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_scsi_task *task)
1513 {
1514 struct spdk_bdev_scsi_split_ctx *ctx;
1515 uint8_t *data;
1516 int desc_count = -1;
1517 int data_len;
1518
1519 assert(task->status == SPDK_SCSI_STATUS_GOOD);
1520
1521 ctx = calloc(1, sizeof(*ctx));
1522 if (!ctx) {
1523 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1524 SPDK_SCSI_SENSE_NO_SENSE,
1525 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1526 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1527 return SPDK_SCSI_TASK_COMPLETE;
1528 }
1529
1530 ctx->task = task;
1531 ctx->current_count = 0;
1532 ctx->outstanding_count = 0;
1533 ctx->fn = _bdev_scsi_unmap;
1534
1535 if (task->iovcnt == 1) {
1536 data = (uint8_t *)task->iovs[0].iov_base;
1537 data_len = task->iovs[0].iov_len;
1538 desc_count = __copy_desc(ctx, data, data_len);
1539 } else {
1540 data = spdk_scsi_task_gather_data(task, &data_len);
1541 if (data) {
1542 desc_count = __copy_desc(ctx, data, data_len);
1543 free(data);
1544 }
1545 }
1546
1547 if (desc_count > 0) {
1548 ctx->remaining_count = desc_count;
1549 return bdev_scsi_split(ctx);
1550 }
1551
1552 if (desc_count < 0) {
1553 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1554 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
1555 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
1556 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1557 }
1558
1559 free(ctx);
1560 return SPDK_SCSI_TASK_COMPLETE;
1561 }
1562
1563 static int
_bdev_scsi_write_same(struct spdk_bdev_scsi_split_ctx * ctx)1564 _bdev_scsi_write_same(struct spdk_bdev_scsi_split_ctx *ctx)
1565 {
1566 struct spdk_scsi_task *task = ctx->task;
1567 struct spdk_scsi_lun *lun = task->lun;
1568 uint64_t offset_blocks;
1569
1570 offset_blocks = ctx->start_offset_blocks + ctx->current_count;
1571 return spdk_bdev_writev_blocks(lun->bdev_desc, lun->io_channel, task->iovs, task->iovcnt,
1572 offset_blocks, 1, bdev_scsi_task_complete_split_cmd, ctx);
1573 }
1574
1575 static int
bdev_scsi_write_same(struct spdk_bdev * bdev,struct spdk_bdev_desc * bdev_desc,struct spdk_io_channel * bdev_ch,struct spdk_scsi_task * task,uint64_t lba,uint32_t xfer_len,uint8_t flags)1576 bdev_scsi_write_same(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc,
1577 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task,
1578 uint64_t lba, uint32_t xfer_len, uint8_t flags)
1579 {
1580 struct spdk_bdev_scsi_split_ctx *ctx;
1581 uint64_t bdev_num_blocks, offset_blocks, num_blocks;
1582 uint32_t max_xfer_len, block_size;
1583 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE;
1584
1585 task->data_transferred = 0;
1586
1587 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_TO_DEV)) {
1588 SPDK_ERRLOG("Incorrect data direction\n");
1589 goto check_condition;
1590 }
1591
1592 block_size = spdk_bdev_get_data_block_size(bdev);
1593 if (spdk_unlikely(task->transfer_len != block_size)) {
1594 SPDK_ERRLOG("Incorrect data length(%d), a single logical block(%d) is required\n",
1595 task->transfer_len, block_size);
1596 goto check_condition;
1597 }
1598
1599 if (spdk_unlikely(xfer_len == 0)) {
1600 task->status = SPDK_SCSI_STATUS_GOOD;
1601 return SPDK_SCSI_TASK_COMPLETE;
1602 }
1603
1604 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev);
1605 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) {
1606 SPDK_DEBUGLOG(scsi, "end of media\n");
1607 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST;
1608 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1609 goto check_condition;
1610 }
1611
1612 /* see MAXIMUM WRITE SAME LENGTH of SPDK_SPC_VPD_BLOCK_LIMITS */
1613 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size;
1614 if (spdk_unlikely(xfer_len > max_xfer_len)) {
1615 SPDK_ERRLOG("xfer_len %"PRIu32 " > maximum transfer length %" PRIu32 "\n",
1616 xfer_len, max_xfer_len);
1617 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST;
1618 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB;
1619 goto check_condition;
1620 }
1621
1622 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks,
1623 (uint64_t)task->length * xfer_len,
1624 &num_blocks) != 0) {
1625 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n",
1626 task->offset, task->length);
1627 goto check_condition;
1628 }
1629
1630 offset_blocks += lba;
1631 SPDK_DEBUGLOG(scsi, "Writesame: lba=%"PRIu64", len=%"PRIu64"\n",
1632 offset_blocks, num_blocks);
1633
1634 ctx = calloc(1, sizeof(*ctx));
1635 if (!ctx) {
1636 SPDK_ERRLOG("No enough memory on SCSI WRITE SAME\n");
1637 goto check_condition;
1638 }
1639
1640 ctx->task = task;
1641 ctx->start_offset_blocks = offset_blocks;
1642 ctx->current_count = 0;
1643 ctx->outstanding_count = 0;
1644 ctx->remaining_count = xfer_len;
1645 ctx->fn = _bdev_scsi_write_same;
1646
1647 task->data_transferred = task->length;
1648
1649 return bdev_scsi_split(ctx);
1650
1651 check_condition:
1652 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1653 sk, asc, SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1654 return SPDK_SCSI_TASK_COMPLETE;
1655 }
1656
1657 static int
bdev_scsi_process_block(struct spdk_scsi_task * task)1658 bdev_scsi_process_block(struct spdk_scsi_task *task)
1659 {
1660 struct spdk_scsi_lun *lun = task->lun;
1661 struct spdk_bdev *bdev = lun->bdev;
1662 uint64_t lba;
1663 uint32_t xfer_len;
1664 uint32_t len = 0;
1665 uint8_t *cdb = task->cdb;
1666
1667 /* XXX: We need to support FUA bit for writes! */
1668 switch (cdb[0]) {
1669 case SPDK_SBC_READ_6:
1670 case SPDK_SBC_WRITE_6:
1671 lba = (uint64_t)cdb[1] << 16;
1672 lba |= (uint64_t)cdb[2] << 8;
1673 lba |= (uint64_t)cdb[3];
1674 xfer_len = cdb[4];
1675 if (xfer_len == 0) {
1676 xfer_len = 256;
1677 }
1678 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel,
1679 task, lba, xfer_len,
1680 cdb[0] == SPDK_SBC_READ_6, false);
1681
1682 case SPDK_SBC_READ_10:
1683 case SPDK_SBC_WRITE_10:
1684 lba = from_be32(&cdb[2]);
1685 xfer_len = from_be16(&cdb[7]);
1686 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel,
1687 task, lba, xfer_len,
1688 cdb[0] == SPDK_SBC_READ_10, false);
1689
1690 case SPDK_SBC_READ_12:
1691 case SPDK_SBC_WRITE_12:
1692 lba = from_be32(&cdb[2]);
1693 xfer_len = from_be32(&cdb[6]);
1694 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel,
1695 task, lba, xfer_len,
1696 cdb[0] == SPDK_SBC_READ_12, false);
1697 case SPDK_SBC_READ_16:
1698 case SPDK_SBC_WRITE_16:
1699 lba = from_be64(&cdb[2]);
1700 xfer_len = from_be32(&cdb[10]);
1701 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel,
1702 task, lba, xfer_len,
1703 cdb[0] == SPDK_SBC_READ_16, false);
1704
1705 case SPDK_SBC_COMPARE_AND_WRITE: {
1706 uint32_t num_blocks = cdb[13];
1707 uint8_t wrprotect = (cdb[1] >> 5) & 0x07;
1708 bool dpo = cdb[1] & 0x10;
1709 bool fua = cdb[1] & 0x08;
1710
1711 lba = from_be64(&cdb[2]);
1712
1713 if (dpo || fua || wrprotect) {
1714 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1715 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
1716 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
1717 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1718 SPDK_ERRLOG("Invalid Task\n");
1719 return SPDK_SCSI_TASK_COMPLETE;
1720 }
1721
1722 if (num_blocks != 1) {
1723 SPDK_ERRLOG("Invalid CAW block count, request block count is %u, limit is : 1\n",
1724 num_blocks);
1725 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1726 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
1727 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
1728 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1729 return SPDK_SCSI_TASK_COMPLETE;
1730 }
1731
1732 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel,
1733 task, lba, num_blocks, false, true);
1734 }
1735
1736 case SPDK_SBC_READ_CAPACITY_10: {
1737 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev);
1738 uint8_t buffer[8];
1739
1740 if (num_blocks - 1 > 0xffffffffULL) {
1741 memset(buffer, 0xff, 4);
1742 } else {
1743 to_be32(buffer, num_blocks - 1);
1744 }
1745 to_be32(&buffer[4], spdk_bdev_get_data_block_size(bdev));
1746
1747 len = spdk_min(task->length, sizeof(buffer));
1748 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) {
1749 break;
1750 }
1751
1752 task->data_transferred = len;
1753 task->status = SPDK_SCSI_STATUS_GOOD;
1754 break;
1755 }
1756
1757 case SPDK_SPC_SERVICE_ACTION_IN_16:
1758 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */
1759 case SPDK_SBC_SAI_READ_CAPACITY_16: {
1760 uint8_t buffer[32] = {0};
1761 uint32_t lbppb, lbppbe;
1762
1763 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1);
1764 to_be32(&buffer[8], spdk_bdev_get_data_block_size(bdev));
1765 lbppb = spdk_bdev_get_physical_block_size(bdev) / spdk_bdev_get_data_block_size(bdev);
1766 lbppbe = spdk_u32log2(lbppb);
1767 if (lbppbe > 0xf) {
1768 SPDK_ERRLOG("lbppbe(0x%x) > 0xf\n", lbppbe);
1769 } else {
1770 buffer[13] = lbppbe;
1771 }
1772 /*
1773 * Set the TPE bit to 1 to indicate thin provisioning.
1774 * The position of TPE bit is the 7th bit in 14th byte
1775 * in READ CAPACITY (16) parameter data.
1776 */
1777 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) {
1778 buffer[14] |= 1 << 7;
1779 }
1780
1781 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer));
1782 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) {
1783 break;
1784 }
1785
1786 task->data_transferred = len;
1787 task->status = SPDK_SCSI_STATUS_GOOD;
1788 break;
1789 }
1790
1791 default:
1792 return SPDK_SCSI_TASK_UNKNOWN;
1793 }
1794 break;
1795
1796 case SPDK_SBC_SYNCHRONIZE_CACHE_10:
1797 case SPDK_SBC_SYNCHRONIZE_CACHE_16:
1798 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) {
1799 lba = from_be32(&cdb[2]);
1800 len = from_be16(&cdb[7]);
1801 } else {
1802 lba = from_be64(&cdb[2]);
1803 len = from_be32(&cdb[10]);
1804 }
1805
1806 if (len == 0) {
1807 len = spdk_bdev_get_num_blocks(bdev) - lba;
1808 }
1809
1810 return bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len);
1811 break;
1812
1813 case SPDK_SBC_UNMAP:
1814 return bdev_scsi_unmap(bdev, task);
1815
1816 case SPDK_SBC_WRITE_SAME_10:
1817 lba = from_be32(&cdb[2]);
1818 xfer_len = from_be16(&cdb[7]);
1819 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel,
1820 task, lba, xfer_len, cdb[1]);
1821
1822 case SPDK_SBC_WRITE_SAME_16:
1823 lba = from_be64(&cdb[2]);
1824 xfer_len = from_be32(&cdb[10]);
1825 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel,
1826 task, lba, xfer_len, cdb[1]);
1827
1828
1829 default:
1830 return SPDK_SCSI_TASK_UNKNOWN;
1831 }
1832
1833 return SPDK_SCSI_TASK_COMPLETE;
1834 }
1835
1836 static void
bdev_scsi_process_block_resubmit(void * arg)1837 bdev_scsi_process_block_resubmit(void *arg)
1838 {
1839 struct spdk_scsi_task *task = arg;
1840
1841 bdev_scsi_process_block(task);
1842 }
1843
1844 static int
bdev_scsi_check_len(struct spdk_scsi_task * task,int len,int min_len)1845 bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len)
1846 {
1847 if (len >= min_len) {
1848 return 0;
1849 }
1850
1851 /* INVALID FIELD IN CDB */
1852 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1853 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
1854 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
1855 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1856 return -1;
1857 }
1858
1859 static int
bdev_scsi_process_primary(struct spdk_scsi_task * task)1860 bdev_scsi_process_primary(struct spdk_scsi_task *task)
1861 {
1862 struct spdk_scsi_lun *lun = task->lun;
1863 struct spdk_bdev *bdev = lun->bdev;
1864 int alloc_len = -1;
1865 int data_len = -1;
1866 uint8_t *cdb = task->cdb;
1867 uint8_t *data = NULL;
1868 int rc = 0;
1869 int pllen, md = 0;
1870 int llba;
1871 int dbd, pc, page, subpage;
1872 int cmd_parsed = 0;
1873
1874 switch (cdb[0]) {
1875 case SPDK_SPC_INQUIRY:
1876 alloc_len = from_be16(&cdb[3]);
1877 data_len = spdk_max(4096, alloc_len);
1878 data = calloc(1, data_len);
1879 assert(data != NULL);
1880 rc = bdev_scsi_inquiry(bdev, task, cdb, data, data_len);
1881 data_len = spdk_min(rc, data_len);
1882 if (rc < 0) {
1883 break;
1884 }
1885
1886 SPDK_LOGDUMP(scsi, "INQUIRY", data, data_len);
1887 break;
1888
1889 case SPDK_SPC_REPORT_LUNS: {
1890 int sel;
1891
1892 sel = cdb[2];
1893 SPDK_DEBUGLOG(scsi, "sel=%x\n", sel);
1894
1895 alloc_len = from_be32(&cdb[6]);
1896 rc = bdev_scsi_check_len(task, alloc_len, 16);
1897 if (rc < 0) {
1898 break;
1899 }
1900
1901 data_len = spdk_max(4096, alloc_len);
1902 data = calloc(1, data_len);
1903 assert(data != NULL);
1904 rc = bdev_scsi_report_luns(task->lun, sel, data, data_len);
1905 data_len = rc;
1906 if (rc < 0) {
1907 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1908 SPDK_SCSI_SENSE_NO_SENSE,
1909 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE,
1910 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1911 break;
1912 }
1913
1914 SPDK_LOGDUMP(scsi, "REPORT LUNS", data, data_len);
1915 break;
1916 }
1917
1918 case SPDK_SPC_MODE_SELECT_6:
1919 case SPDK_SPC_MODE_SELECT_10:
1920 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) {
1921 /* MODE_SELECT(6) must have at least a 4 byte header. */
1922 md = 4;
1923 pllen = cdb[4];
1924 } else {
1925 /* MODE_SELECT(10) must have at least an 8 byte header. */
1926 md = 8;
1927 pllen = from_be16(&cdb[7]);
1928 }
1929
1930 if (pllen == 0) {
1931 break;
1932 }
1933
1934 rc = bdev_scsi_check_len(task, pllen, md);
1935 if (rc < 0) {
1936 break;
1937 }
1938
1939 data = spdk_scsi_task_gather_data(task, &rc);
1940 if (rc < 0) {
1941 break;
1942 }
1943 data_len = rc;
1944
1945 rc = bdev_scsi_check_len(task, data_len, spdk_max(pllen, md));
1946 if (rc < 0) {
1947 break;
1948 }
1949
1950 rc = pllen;
1951 data_len = 0;
1952 break;
1953
1954 case SPDK_SPC_MODE_SENSE_6:
1955 alloc_len = cdb[4];
1956 md = 6;
1957 /* FALLTHROUGH */
1958 case SPDK_SPC_MODE_SENSE_10:
1959 llba = 0;
1960
1961 if (md == 0) {
1962 alloc_len = from_be16(&cdb[7]);
1963 llba = !!(cdb[1] & 0x10);
1964 md = 10;
1965 }
1966
1967 dbd = !!(cdb[1] & 0x8);
1968 pc = (cdb[2] & 0xc0) >> 6;
1969 page = cdb[2] & 0x3f;
1970 subpage = cdb[3];
1971
1972 /* First call with no buffer to discover needed buffer size */
1973 rc = bdev_scsi_mode_sense(bdev, md,
1974 cdb, dbd, llba, pc,
1975 page, subpage,
1976 NULL, task);
1977 if (rc < 0) {
1978 break;
1979 }
1980
1981 data_len = rc;
1982 data = calloc(1, data_len);
1983 assert(data != NULL);
1984
1985 /* First call with no buffer to discover needed buffer size */
1986 rc = bdev_scsi_mode_sense(bdev, md,
1987 cdb, dbd, llba, pc,
1988 page, subpage,
1989 data, task);
1990 if (rc < 0) {
1991 /* INVALID FIELD IN CDB */
1992 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
1993 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
1994 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
1995 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
1996 break;
1997 }
1998 break;
1999
2000 case SPDK_SPC_REQUEST_SENSE: {
2001 int desc;
2002 int sk, asc, ascq;
2003
2004 desc = cdb[1] & 0x1;
2005 if (desc != 0) {
2006 /* INVALID FIELD IN CDB */
2007 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
2008 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
2009 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
2010 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
2011 break;
2012 }
2013
2014 alloc_len = cdb[4];
2015
2016 /* NO ADDITIONAL SENSE INFORMATION */
2017 sk = SPDK_SCSI_SENSE_NO_SENSE;
2018 asc = 0x00;
2019 ascq = 0x00;
2020
2021 spdk_scsi_task_build_sense_data(task, sk, asc, ascq);
2022
2023 data_len = task->sense_data_len;
2024 data = calloc(1, data_len);
2025 assert(data != NULL);
2026 memcpy(data, task->sense_data, data_len);
2027 break;
2028 }
2029
2030 case SPDK_SPC_LOG_SELECT:
2031 SPDK_DEBUGLOG(scsi, "LOG_SELECT\n");
2032 cmd_parsed = 1;
2033 /* FALLTHROUGH */
2034 case SPDK_SPC_LOG_SENSE:
2035 if (!cmd_parsed) {
2036 SPDK_DEBUGLOG(scsi, "LOG_SENSE\n");
2037 }
2038
2039 /* INVALID COMMAND OPERATION CODE */
2040 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
2041 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
2042 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE,
2043 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
2044 rc = -1;
2045 break;
2046
2047 case SPDK_SPC_TEST_UNIT_READY:
2048 SPDK_DEBUGLOG(scsi, "TEST_UNIT_READY\n");
2049 cmd_parsed = 1;
2050 /* FALLTHROUGH */
2051 case SPDK_SBC_START_STOP_UNIT:
2052 if (!cmd_parsed) {
2053 SPDK_DEBUGLOG(scsi, "START_STOP_UNIT\n");
2054 }
2055
2056 rc = 0;
2057 break;
2058
2059 case SPDK_SPC_PERSISTENT_RESERVE_OUT:
2060 pllen = from_be32(&cdb[5]);
2061 rc = bdev_scsi_check_len(task, pllen, 24);
2062 if (rc < 0) {
2063 break;
2064 }
2065
2066 data = spdk_scsi_task_gather_data(task, &rc);
2067 if (rc < 0) {
2068 break;
2069 }
2070 data_len = rc;
2071 if (data_len < 24) {
2072 rc = -1;
2073 break;
2074 }
2075
2076 rc = scsi_pr_out(task, cdb, data, data_len);
2077 if (rc < 0) {
2078 break;
2079 }
2080 rc = pllen;
2081 data_len = 0;
2082 break;
2083
2084 case SPDK_SPC_PERSISTENT_RESERVE_IN:
2085 alloc_len = from_be16(&cdb[7]);
2086 data_len = alloc_len;
2087 data = calloc(1, data_len);
2088 assert(data != NULL);
2089 rc = scsi_pr_in(task, cdb, data, data_len);
2090 break;
2091
2092 case SPDK_SPC2_RESERVE_6:
2093 case SPDK_SPC2_RESERVE_10:
2094 rc = scsi2_reserve(task, cdb);
2095 if (rc == 0) {
2096 if (cdb[0] == SPDK_SPC2_RESERVE_10) {
2097 rc = from_be16(&cdb[7]);
2098 }
2099 data_len = 0;
2100 }
2101 break;
2102
2103 case SPDK_SPC2_RELEASE_6:
2104 case SPDK_SPC2_RELEASE_10:
2105 rc = scsi2_release(task);
2106 break;
2107
2108 default:
2109 return SPDK_SCSI_TASK_UNKNOWN;
2110 }
2111
2112 if (rc >= 0 && data_len > 0) {
2113 assert(alloc_len >= 0);
2114 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len));
2115 rc = spdk_min(data_len, alloc_len);
2116 }
2117
2118 if (rc >= 0) {
2119 task->data_transferred = rc;
2120 task->status = SPDK_SCSI_STATUS_GOOD;
2121 }
2122
2123 if (data) {
2124 free(data);
2125 }
2126
2127 return SPDK_SCSI_TASK_COMPLETE;
2128 }
2129
2130 int
bdev_scsi_execute(struct spdk_scsi_task * task)2131 bdev_scsi_execute(struct spdk_scsi_task *task)
2132 {
2133 int rc;
2134
2135 if ((rc = bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) {
2136 if ((rc = bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) {
2137 SPDK_DEBUGLOG(scsi, "unsupported SCSI OP=0x%x\n", task->cdb[0]);
2138 /* INVALID COMMAND OPERATION CODE */
2139 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
2140 SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
2141 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE,
2142 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
2143 return SPDK_SCSI_TASK_COMPLETE;
2144 }
2145 }
2146
2147 return rc;
2148 }
2149
2150 static void
bdev_scsi_reset_resubmit(void * arg)2151 bdev_scsi_reset_resubmit(void *arg)
2152 {
2153 struct spdk_scsi_task *task = arg;
2154
2155 bdev_scsi_reset(task);
2156 }
2157
2158 void
bdev_scsi_reset(struct spdk_scsi_task * task)2159 bdev_scsi_reset(struct spdk_scsi_task *task)
2160 {
2161 struct spdk_scsi_lun *lun = task->lun;
2162 int rc;
2163
2164 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, bdev_scsi_task_complete_reset,
2165 task);
2166 if (rc == -ENOMEM) {
2167 bdev_scsi_queue_io(task, bdev_scsi_reset_resubmit, task);
2168 }
2169 }
2170
2171 bool
bdev_scsi_get_dif_ctx(struct spdk_bdev * bdev,struct spdk_scsi_task * task,struct spdk_dif_ctx * dif_ctx)2172 bdev_scsi_get_dif_ctx(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
2173 struct spdk_dif_ctx *dif_ctx)
2174 {
2175 uint32_t ref_tag = 0, dif_check_flags = 0, data_offset;
2176 uint8_t *cdb;
2177 int rc;
2178 struct spdk_dif_ctx_init_ext_opts dif_opts;
2179
2180 if (spdk_likely(spdk_bdev_get_md_size(bdev) == 0)) {
2181 return false;
2182 }
2183
2184 cdb = task->cdb;
2185 data_offset = task->offset;
2186
2187 /* We use lower 32 bits of LBA as Reference. Tag */
2188 switch (cdb[0]) {
2189 case SPDK_SBC_READ_6:
2190 case SPDK_SBC_WRITE_6:
2191 ref_tag = (uint32_t)cdb[1] << 16;
2192 ref_tag |= (uint32_t)cdb[2] << 8;
2193 ref_tag |= (uint32_t)cdb[3];
2194 break;
2195 case SPDK_SBC_READ_10:
2196 case SPDK_SBC_WRITE_10:
2197 case SPDK_SBC_READ_12:
2198 case SPDK_SBC_WRITE_12:
2199 ref_tag = from_be32(&cdb[2]);
2200 break;
2201 case SPDK_SBC_READ_16:
2202 case SPDK_SBC_WRITE_16:
2203 ref_tag = (uint32_t)from_be64(&cdb[2]);
2204 break;
2205 default:
2206 return false;
2207 }
2208
2209 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)) {
2210 dif_check_flags |= SPDK_DIF_FLAGS_REFTAG_CHECK;
2211 }
2212
2213 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)) {
2214 dif_check_flags |= SPDK_DIF_FLAGS_GUARD_CHECK;
2215 }
2216
2217 dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2218 dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2219 rc = spdk_dif_ctx_init(dif_ctx,
2220 spdk_bdev_get_block_size(bdev),
2221 spdk_bdev_get_md_size(bdev),
2222 spdk_bdev_is_md_interleaved(bdev),
2223 spdk_bdev_is_dif_head_of_md(bdev),
2224 spdk_bdev_get_dif_type(bdev),
2225 dif_check_flags,
2226 ref_tag, 0, 0, data_offset, 0, &dif_opts);
2227
2228 return (rc == 0) ? true : false;
2229 }
2230