![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_lu_disk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src|
Return to istgt_lu_disk.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src |
1.1 misho 1: /*
2: * Copyright (C) 2008-2011 Daisuke Aoyama <aoyama@peach.ne.jp>.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17: * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24: * SUCH DAMAGE.
25: *
26: */
27:
28: #ifdef HAVE_CONFIG_H
29: #include "config.h"
30: #endif
31:
32: #include <inttypes.h>
33: #include <stdint.h>
34:
35: #include <errno.h>
36: #include <stdio.h>
37: #include <string.h>
38: #include <pthread.h>
39: #include <time.h>
40:
41: #include <fcntl.h>
42: #include <unistd.h>
43:
44: #ifdef HAVE_UUID_H
45: #include <uuid.h>
46: #endif
47:
48: #include "istgt.h"
49: #include "istgt_ver.h"
50: #include "istgt_log.h"
51: #include "istgt_conf.h"
52: #include "istgt_sock.h"
53: #include "istgt_misc.h"
54: #include "istgt_crc32c.h"
55: #include "istgt_md5.h"
56: #include "istgt_iscsi.h"
57: #include "istgt_lu.h"
58: #include "istgt_proto.h"
59: #include "istgt_scsi.h"
60: #include "istgt_queue.h"
61:
62: #ifndef O_FSYNC
63: #define O_FSYNC O_SYNC
64: #endif
65:
66: //#define ISTGT_TRACE_DISK
67:
68: typedef enum {
69: ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE = 0x01,
70: ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS = 0x03,
71: ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY = 0x05,
72: ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY = 0x06,
73: ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS = 0x07,
74: ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS = 0x08,
75: } ISTGT_LU_PR_TYPE;
76:
77: #define PR_ALLOW(WE,EA,ALLRR,WERR,EARR) \
78: ((((WE)&1) << 4) | (((EA)&1) << 3) | (((ALLRR)&1) << 2) \
79: | (((WERR)&1) << 1) | (((EARR)&1) << 0))
80: #define PR_ALLOW_WE 0x0010
81: #define PR_ALLOW_EA 0x0008
82: #define PR_ALLOW_ALLRR 0x0004
83: #define PR_ALLOW_WERR 0x0002
84: #define PR_ALLOW_EARR 0x0001
85:
86: typedef struct istgt_lu_pr_key_t {
87: uint64_t key;
88:
89: /* transport IDs */
90: char *registered_initiator_port;
91: char *registered_target_port;
92: /* PERSISTENT RESERVE OUT received from */
93: int pg_idx; /* relative target port */
94: int pg_tag; /* target port group */
95:
96: int ninitiator_ports;
97: char **initiator_ports;
98: int all_tpg;
99: } ISTGT_LU_PR_KEY;
100:
101: typedef struct istgt_lu_disk_t {
102: ISTGT_LU_Ptr lu;
103: int num;
104: int lun;
105:
106: int fd;
107: const char *file;
108: uint64_t fsize;
109: uint64_t foffset;
110: uint64_t size;
111: uint64_t blocklen;
112: uint64_t blockcnt;
113:
114: #ifdef HAVE_UUID_H
115: uuid_t uuid;
116: #endif /* HAVE_UUID_H */
117:
118: /* cache flags */
119: int read_cache;
120: int write_cache;
121: /* parts for cache */
122: int wbufsize;
123: uint8_t *wbuf;
124: uint64_t woffset;
125: uint64_t wnbytes;
126: int req_write_cache;
127: int err_write_cache;
128:
129: /* thin provisioning */
130: int thin_provisioning;
131:
132: /* for ats */
133: pthread_mutex_t ats_mutex;
134:
135: int queue_depth;
136: pthread_mutex_t cmd_queue_mutex;
137: ISTGT_QUEUE cmd_queue;
138: pthread_mutex_t wait_lu_task_mutex;
139: ISTGT_LU_TASK_Ptr wait_lu_task;
140:
141: /* PERSISTENT RESERVE */
142: int npr_keys;
143: ISTGT_LU_PR_KEY pr_keys[MAX_LU_RESERVE];
144: uint32_t pr_generation;
145:
146: char *rsv_port;
147: uint64_t rsv_key;
148: int rsv_scope;
149: int rsv_type;
150:
151: /* SCSI sense code */
152: volatile int sense;
153: } ISTGT_LU_DISK;
154:
155: #define BUILD_SENSE(SK,ASC,ASCQ) \
156: do { \
157: *sense_len = \
158: istgt_lu_disk_build_sense_data(spec, sense_data, \
159: ISTGT_SCSI_SENSE_ ## SK, \
160: (ASC), (ASCQ)); \
161: } while (0)
162: #define BUILD_SENSE2(SK,ASC,ASCQ) \
163: do { \
164: *sense_len = \
165: istgt_lu_disk_build_sense_data2(spec, sense_data, \
166: ISTGT_SCSI_SENSE_ ## SK, \
167: (ASC), (ASCQ)); \
168: } while (0)
169:
170: static void istgt_lu_disk_free_pr_key(ISTGT_LU_PR_KEY *prkey);
171: static int istgt_lu_disk_build_sense_data(ISTGT_LU_DISK *spec, uint8_t *data, int sk, int asc, int ascq);
172: static int istgt_lu_disk_queue_abort_ITL(ISTGT_LU_DISK *spec, const char *initiator_port);
173:
174: static int
175: istgt_lu_disk_open(ISTGT_LU_DISK *spec, int flags, int mode)
176: {
177: int rc;
178:
179: rc = open(spec->file, flags, mode);
180: if (rc < 0) {
181: return -1;
182: }
183: spec->fd = rc;
184: spec->foffset = 0;
185: return 0;
186: }
187:
188: static int
189: istgt_lu_disk_close(ISTGT_LU_DISK *spec)
190: {
191: int rc;
192:
193: if (spec->fd == -1)
194: return 0;
195: rc = close(spec->fd);
196: if (rc < 0) {
197: return -1;
198: }
199: spec->fd = -1;
200: spec->foffset = 0;
201: return 0;
202: }
203:
204: #if 0
205: static off_t
206: istgt_lu_disk_lseek(ISTGT_LU_DISK *spec, off_t offset, int whence)
207: {
208: off_t rc;
209:
210: rc = lseek(spec->fd, offset, whence);
211: if (rc < 0) {
212: return -1;
213: }
214: spec->foffset = offset;
215: return rc;
216: }
217: #endif
218:
219: static int64_t
220: istgt_lu_disk_seek(ISTGT_LU_DISK *spec, uint64_t offset)
221: {
222: off_t rc;
223:
224: rc = lseek(spec->fd, (off_t) offset, SEEK_SET);
225: if (rc < 0) {
226: return -1;
227: }
228: spec->foffset = offset;
229: return 0;
230: }
231:
232: static int64_t
233: istgt_lu_disk_read(ISTGT_LU_DISK *spec, void *buf, uint64_t nbytes)
234: {
235: int64_t rc;
236:
237: if (spec->lu->istgt->swmode >= ISTGT_SWMODE_EXPERIMENTAL) {
238: if (spec->foffset + nbytes <= spec->fsize) {
239: /* inside media */
240: rc = (int64_t) read(spec->fd, buf, (size_t) nbytes);
241: } else if (spec->foffset >= spec->fsize) {
242: /* outside media */
243: memset(buf, 0, nbytes);
244: rc = nbytes;
245: if (spec->foffset + nbytes >= spec->size) {
246: rc = spec->size - spec->foffset;
247: }
248: } else if (spec->foffset + nbytes > spec->fsize) {
249: /* both */
250: uint64_t request = spec->fsize - spec->foffset;
251: memset(buf, 0, nbytes);
252: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
253: "read %"PRIu64" bytes at %"PRIu64"/%"PRIu64"\n",
254: request, spec->foffset, spec->fsize);
255: rc = (int64_t) read(spec->fd, buf, (size_t) request);
256: if (rc < 0) {
257: return -1;
258: }
259: if (rc != request) {
260: /* read size < request */
261: if (spec->foffset + rc >= spec->size) {
262: rc = spec->size - spec->foffset;
263: }
264: spec->foffset += rc;
265: return rc;
266: }
267: rc = nbytes;
268: if (spec->foffset + nbytes >= spec->size) {
269: rc = spec->size - spec->foffset;
270: }
271: } else {
272: rc = -1;
273: }
274: if (rc < 0) {
275: return -1;
276: }
277: spec->foffset += rc;
278: return rc;
279: }
280: rc = (int64_t) read(spec->fd, buf, (size_t) nbytes);
281: if (rc < 0) {
282: return -1;
283: }
284: spec->foffset += rc;
285: return rc;
286: }
287:
288: static int64_t
289: istgt_lu_disk_write(ISTGT_LU_DISK *spec, const void *buf, uint64_t nbytes)
290: {
291: int64_t rc;
292:
293: if (spec->lu->istgt->swmode >= ISTGT_SWMODE_EXPERIMENTAL) {
294: if (spec->foffset + nbytes <= spec->fsize) {
295: /* inside media */
296: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
297: } else if (spec->foffset + nbytes <= ISTGT_LU_MEDIA_SIZE_MIN) {
298: /* allways write in minimum size */
299: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
300: } else if (spec->foffset >= spec->fsize) {
301: /* outside media */
302: const uint8_t *p = (const uint8_t *) buf;
303: uint64_t n;
304: for (n = 0; n < nbytes; n++) {
305: if (p[n] != 0)
306: break;
307: }
308: if (n == nbytes) {
309: /* write all zero (skip) */
310: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
311: "write zero %"PRIu64" bytes at %"PRIu64"/%"PRIu64"\n",
312: nbytes, spec->foffset, spec->fsize);
313: rc = nbytes;
314: spec->foffset += rc;
315: return rc;
316: }
317: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
318: "write %"PRIu64" bytes at %"PRIu64"/%"PRIu64"\n",
319: nbytes, spec->foffset, spec->fsize);
320: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
321: } else if (spec->foffset + nbytes > spec->fsize) {
322: /* both */
323: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
324: } else {
325: rc = -1;
326: }
327: if (rc < 0) {
328: return -1;
329: }
330: spec->foffset += rc;
331: if (spec->foffset > spec->fsize) {
332: spec->fsize = spec->foffset;
333: }
334: return rc;
335: }
336: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
337: if (rc < 0) {
338: return -1;
339: }
340: spec->foffset += rc;
341: if (spec->foffset > spec->fsize) {
342: spec->fsize = spec->foffset;
343: }
344: return rc;
345: }
346:
347: static int64_t
348: istgt_lu_disk_sync(ISTGT_LU_DISK *spec, uint64_t offset, uint64_t nbytes)
349: {
350: int64_t rc;
351:
352: rc = (int64_t) fsync(spec->fd);
353: if (rc < 0) {
354: return -1;
355: }
356: spec->foffset = offset + nbytes;
357: return rc;
358: }
359:
360: static int
361: istgt_lu_disk_allocate(ISTGT_LU_DISK *spec)
362: {
363: uint8_t *data;
364: uint64_t fsize;
365: uint64_t size;
366: uint64_t blocklen;
367: uint64_t offset;
368: uint64_t nbytes;
369: int64_t rc;
370:
371: size = spec->size;
372: blocklen = spec->blocklen;
373: nbytes = blocklen;
374: data = xmalloc(nbytes);
375: memset(data, 0, nbytes);
376:
377: fsize = istgt_lu_get_filesize(spec->file);
378: if (fsize > size) {
379: xfree(data);
380: return 0;
381: }
382: spec->fsize = fsize;
383:
384: offset = size - nbytes;
385: rc = istgt_lu_disk_seek(spec, offset);
386: if (rc == -1) {
387: ISTGT_ERRLOG("lu_disk_seek() failed\n");
388: xfree(data);
389: return -1;
390: }
391: rc = istgt_lu_disk_read(spec, data, nbytes);
392: /* EOF is OK */
393: if (rc == -1) {
394: ISTGT_ERRLOG("lu_disk_read() failed\n");
395: xfree(data);
396: return -1;
397: }
398: if (spec->lu->istgt->swmode >= ISTGT_SWMODE_EXPERIMENTAL) {
399: /* allocate minimum size */
400: if (fsize < ISTGT_LU_MEDIA_SIZE_MIN) {
401: fsize = ISTGT_LU_MEDIA_SIZE_MIN;
402: if (size < ISTGT_LU_MEDIA_SIZE_MIN) {
403: fsize = size;
404: }
405: offset = fsize - nbytes;
406: rc = istgt_lu_disk_seek(spec, offset);
407: if (rc == -1) {
408: ISTGT_ERRLOG("lu_disk_seek() failed\n");
409: xfree(data);
410: return -1;
411: }
412: rc = istgt_lu_disk_write(spec, data, nbytes);
413: if (rc == -1 || rc != nbytes) {
414: ISTGT_ERRLOG("lu_disk_write() failed\n");
415: xfree(data);
416: return -1;
417: }
418: spec->fsize = fsize;
419: spec->foffset = fsize;
420: }
421: } else {
422: /* allocate complete size */
423: rc = istgt_lu_disk_seek(spec, offset);
424: if (rc == -1) {
425: ISTGT_ERRLOG("lu_disk_seek() failed\n");
426: xfree(data);
427: return -1;
428: }
429: rc = istgt_lu_disk_write(spec, data, nbytes);
430: if (rc == -1 || rc != nbytes) {
431: ISTGT_ERRLOG("lu_disk_write() failed\n");
432: xfree(data);
433: return -1;
434: }
435: spec->foffset = size;
436: }
437:
438: xfree(data);
439: return 0;
440: }
441:
442: static int
443: istgt_lu_disk_setcache(ISTGT_LU_DISK *spec)
444: {
445: int flags;
446: int rc;
447: int fd;
448:
449: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_disk_setcache\n");
450:
451: fd = spec->fd;
452: if (spec->read_cache) {
453: /* not implement */
454: } else {
455: /* not implement */
456: }
457: flags = fcntl(fd , F_GETFL, 0);
458: if (flags != -1) {
459: if (spec->write_cache) {
460: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "write cache enable\n");
461: rc = fcntl(fd, F_SETFL, (flags & ~O_FSYNC));
462: spec->write_cache = 1;
463: } else {
464: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "write cache disable\n");
465: rc = fcntl(fd, F_SETFL, (flags | O_FSYNC));
466: spec->write_cache = 0;
467: }
468: if (rc == -1) {
469: #if 0
470: ISTGT_ERRLOG("LU%d: LUN%d: fcntl(F_SETFL) failed(errno=%d)\n",
471: spec->num, spec->lun, errno);
472: #endif
473: }
474: } else {
475: ISTGT_ERRLOG("LU%d: LUN%d: fcntl(F_GETFL) failed(errno=%d)\n",
476: spec->num, spec->lun, errno);
477: }
478: return 0;
479: }
480:
481: int
482: istgt_lu_disk_init(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu)
483: {
484: ISTGT_LU_DISK *spec;
485: uint64_t gb_size;
486: uint64_t mb_size;
487: #ifdef HAVE_UUID_H
488: uint32_t status;
489: #endif /* HAVE_UUID_H */
490: int mb_digit;
491: int flags;
492: int newfile;
493: int rc;
494: int i, j;
495:
496: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_disk_init\n");
497:
498: printf("LU%d HDD UNIT\n", lu->num);
499: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d TargetName=%s\n",
500: lu->num, lu->name);
501: for (i = 0; i < lu->maxlun; i++) {
502: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
503: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
504: lu->num, i);
505: lu->lun[i].spec = NULL;
506: continue;
507: }
508: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_STORAGE) {
509: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
510: return -1;
511: }
512: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d storage\n",
513: lu->num, i);
514:
515: spec = xmalloc(sizeof *spec);
516: memset(spec, 0, sizeof *spec);
517: spec->lu = lu;
518: spec->num = lu->num;
519: spec->lun = i;
520: spec->fd = -1;
521: if (spec->lu->lun[i].readcache) {
522: spec->read_cache = 1;
523: } else {
524: spec->read_cache = 0;
525: }
526: if (spec->lu->lun[i].writecache) {
527: spec->write_cache = 1;
528: } else {
529: spec->write_cache = 0;
530: }
531: if (spec->lu->istgt->swmode >= ISTGT_SWMODE_EXPERIMENTAL) {
532: spec->wbufsize = ISTGT_LU_MAX_WRITE_CACHE_SIZE;
533: spec->wbuf = xmalloc(spec->wbufsize);
534: memset(spec->wbuf, 0, spec->wbufsize);
535: } else {
536: spec->wbufsize = 0;
537: spec->wbuf = NULL;
538: }
539: spec->woffset = 0;
540: spec->wnbytes = 0;
541: spec->req_write_cache = 0;
542: spec->err_write_cache = 0;
543: spec->thin_provisioning = 0;
544:
545: rc = pthread_mutex_init(&spec->ats_mutex, NULL);
546: if (rc != 0) {
547: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
548: return -1;
549: }
550:
551: spec->queue_depth = lu->queue_depth;
552: rc = pthread_mutex_init(&spec->cmd_queue_mutex, NULL);
553: if (rc != 0) {
554: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
555: return -1;
556: }
557: istgt_queue_init(&spec->cmd_queue);
558: rc = pthread_mutex_init(&spec->wait_lu_task_mutex, NULL);
559: if (rc != 0) {
560: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
561: return -1;
562: }
563: spec->wait_lu_task = NULL;
564:
565: spec->npr_keys = 0;
566: for (j = 0; j < MAX_LU_RESERVE; j++) {
567: spec->pr_keys[j].registered_initiator_port = NULL;
568: }
569: spec->pr_generation = 0;
570: spec->rsv_port = NULL;
571: spec->rsv_key = 0;
572: spec->rsv_scope = 0;
573: spec->rsv_type = 0;
574:
575: spec->sense = 0;
576: {
577: int sk, asc, ascq;
578: /* POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */
579: sk = ISTGT_SCSI_SENSE_UNIT_ATTENTION;
580: asc = 0x29;
581: ascq = 0x00;
582: spec->sense = (((sk & 0xffU) << 16)
583: | ((asc & 0xffU) << 8)
584: | ((ascq & 0xffU) << 0));
585: }
586:
587: #ifdef HAVE_UUID_H
588: uuid_create(&spec->uuid, &status);
589: if (status != uuid_s_ok) {
590: ISTGT_ERRLOG("LU%d: LUN%d: uuid_create() failed\n", lu->num, i);
591: (void) pthread_mutex_destroy(&spec->cmd_queue_mutex);
592: istgt_queue_destroy(&spec->cmd_queue);
593: xfree(spec);
594: return -1;
595: }
596: #endif /* HAVE_UUID_H */
597:
598: spec->file = lu->lun[i].u.storage.file;
599: spec->size = lu->lun[i].u.storage.size;
600: spec->blocklen = lu->blocklen;
601: if (spec->blocklen != 512
602: && spec->blocklen != 1024
603: && spec->blocklen != 2048
604: && spec->blocklen != 4096
605: && spec->blocklen != 8192
606: && spec->blocklen != 16384
607: && spec->blocklen != 32768
608: && spec->blocklen != 65536
609: && spec->blocklen != 131072
610: && spec->blocklen != 262144
611: && spec->blocklen != 524288) {
612: ISTGT_ERRLOG("LU%d: LUN%d: invalid blocklen %"PRIu64"\n",
613: lu->num, i, spec->blocklen);
614: error_return:
615: (void) pthread_mutex_destroy(&spec->cmd_queue_mutex);
616: istgt_queue_destroy(&spec->cmd_queue);
617: xfree(spec);
618: return -1;
619: }
620: spec->blockcnt = spec->size / spec->blocklen;
621: if (spec->blockcnt == 0) {
622: ISTGT_ERRLOG("LU%d: LUN%d: size zero\n", lu->num, i);
623: goto error_return;
624: }
625:
626: #if 0
627: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
628: "LU%d: LUN%d file=%s, size=%"PRIu64"\n",
629: lu->num, i, spec->file, spec->size);
630: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
631: "LU%d: LUN%d %"PRIu64" blocks, %"
632: PRIu64" bytes/block\n",
633: lu->num, i, spec->blockcnt, spec->blocklen);
634: #endif
635: printf("LU%d: LUN%d file=%s, size=%"PRIu64"\n",
636: lu->num, i, spec->file, spec->size);
637: printf("LU%d: LUN%d %"PRIu64" blocks, %"PRIu64" bytes/block\n",
638: lu->num, i, spec->blockcnt, spec->blocklen);
639:
640: flags = lu->readonly ? O_RDONLY : O_RDWR;
641: newfile = 0;
642: rc = istgt_lu_disk_open(spec, flags, 0666);
643: if (rc < 0) {
644: newfile = 1;
645: flags = lu->readonly ? O_RDONLY : (O_CREAT | O_EXCL | O_RDWR);
646: rc = istgt_lu_disk_open(spec, flags, 0666);
647: if (rc < 0) {
648: ISTGT_ERRLOG("LU%d: LUN%d: open error\n", lu->num, i);
649: goto error_return;
650: }
651: }
652: if (!lu->readonly) {
653: rc = istgt_lu_disk_allocate(spec);
654: if (rc < 0) {
655: ISTGT_ERRLOG("LU%d: LUN%d: allocate error\n", lu->num, i);
656: goto error_return;
657: }
658: }
659: rc = istgt_lu_disk_setcache(spec);
660: if (rc < 0) {
661: ISTGT_ERRLOG("LU%d: LUN%d: setcache error\n", lu->num, i);
662: goto error_return;
663: }
664:
665: gb_size = spec->size / ISTGT_LU_1GB;
666: mb_size = (spec->size % ISTGT_LU_1GB) / ISTGT_LU_1MB;
667: if (gb_size > 0) {
668: mb_digit = (int) (((mb_size * 100) / 1024) / 10);
669: #if 0
670: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
671: "LU%d LUN%d %"PRIu64".%dGB %sstorage for %s\n",
672: lu->num, i, gb_size, mb_digit,
673: lu->readonly ? "readonly " : "", lu->name);
674: #endif
675: printf("LU%d: LUN%d %"PRIu64".%dGB %sstorage for %s\n",
676: lu->num, i, gb_size, mb_digit,
677: lu->readonly ? "readonly " : "", lu->name);
678: } else {
679: #if 0
680: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
681: "LU%d: LUN%d %"PRIu64"MB %sstorage for %s\n",
682: lu->num, i, mb_size,
683: lu->readonly ? "readonly " : "", lu->name);
684: #endif
685: printf("LU%d: LUN%d %"PRIu64"MB %sstorage for %s\n",
686: lu->num, i, mb_size,
687: lu->readonly ? "readonly " : "", lu->name);
688: }
689: if (spec->lu->lun[i].serial != NULL) {
690: printf("LU%d: LUN%d serial %s\n",
691: lu->num, i, spec->lu->lun[i].serial);
692: } else {
693: printf("LU%d: LUN%d serial %s\n",
694: lu->num, i, spec->lu->inq_serial);
695: }
696: printf("LU%d: LUN%d ", lu->num, i);
697: if (spec->read_cache) {
698: printf("read cache enabled");
699: } else {
700: printf("read cache disabled");
701: }
702: printf(", ");
703: if (spec->write_cache) {
704: printf("write cache enabled");
705: } else {
706: printf("write cache disabled");
707: }
708: printf("\n");
709: if (spec->queue_depth != 0) {
710: printf("LU%d: LUN%d command queuing enabled, depth %d\n",
711: lu->num, i, spec->queue_depth);
712: } else {
713: printf("LU%d: LUN%d command queuing disabled\n",
714: lu->num, i);
715: }
716: #if 0
717: if (spec->write_cache && spec->wbufsize) {
718: mb_size = (spec->wbufsize / ISTGT_LU_1MB);
719: printf("LU%d: LUN%d write buffer %"PRIu64"MB\n",
720: lu->num, i, mb_size);
721: }
722: #endif
723:
724: lu->lun[i].spec = spec;
725: }
726:
727: return 0;
728: }
729:
730: int
731: istgt_lu_disk_shutdown(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu)
732: {
733: ISTGT_LU_DISK *spec;
734: ISTGT_LU_PR_KEY *prkey;
735: int rc;
736: int i, j;
737:
738: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_disk_shutdown\n");
739:
740: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d TargetName=%s\n",
741: lu->num, lu->name);
742: for (i = 0; i < lu->maxlun; i++) {
743: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
744: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
745: lu->num, i);
746: continue;
747: }
748: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_STORAGE) {
749: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
750: return -1;
751: }
752: spec = (ISTGT_LU_DISK *) lu->lun[i].spec;
753:
754: if (!spec->lu->readonly) {
755: rc = istgt_lu_disk_sync(spec, 0, spec->size);
756: if (rc < 0) {
757: //ISTGT_ERRLOG("LU%d: lu_disk_sync() failed\n", lu->num);
758: /* ignore error */
759: }
760: }
761: rc = istgt_lu_disk_close(spec);
762: if (rc < 0) {
763: //ISTGT_ERRLOG("LU%d: lu_disk_close() failed\n", lu->num);
764: /* ignore error */
765: }
766:
767: for (j = 0; j < spec->npr_keys; j++) {
768: prkey = &spec->pr_keys[j];
769: istgt_lu_disk_free_pr_key(prkey);
770: }
771: if (spec->rsv_key != 0) {
772: xfree(spec->rsv_port);
773: spec->rsv_port = NULL;
774: }
775:
776: rc = pthread_mutex_destroy(&spec->ats_mutex);
777: if (rc != 0) {
778: //ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
779: /* ignore error */
780: }
781:
782: istgt_queue_destroy(&spec->cmd_queue);
783: rc = pthread_mutex_destroy(&spec->cmd_queue_mutex);
784: if (rc != 0) {
785: //ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
786: /* ignore error */
787: }
788: rc = pthread_mutex_destroy(&spec->wait_lu_task_mutex);
789: if (rc != 0) {
790: //ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
791: /* ignore error */
792: }
793: xfree(spec->wbuf);
794: xfree(spec);
795: lu->lun[i].spec = NULL;
796: }
797:
798: return 0;
799: }
800:
801: void
802: istgt_scsi_dump_cdb(uint8_t *cdb)
803: {
804: int group;
805: int cdblen = 0;
806: int i;
807:
808: if (cdb == NULL)
809: return;
810:
811: group = (cdb[0] >> 5) & 0x07;
812: switch (group) {
813: case 0x00:
814: /* 6byte commands */
815: cdblen = 6;
816: break;
817: case 0x01:
818: /* 10byte commands */
819: cdblen = 10;
820: break;
821: case 0x02:
822: /* 10byte commands */
823: cdblen = 10;
824: break;
825: case 0x03:
826: /* reserved */
827: if (cdb[0] == 0x7f) {
828: /* variable length */
829: cdblen = 8 + (cdb[7] & 0xff);
830: } else {
831: /* XXX */
832: cdblen = 6;
833: }
834: break;
835: case 0x04:
836: /* 16byte commands */
837: cdblen = 16;
838: break;
839: case 0x05:
840: /* 12byte commands */
841: cdblen = 12;
842: break;
843: case 0x06:
844: case 0x07:
845: /* vendor specific */
846: cdblen = 6;
847: break;
848: }
849:
850: printf("CDB=");
851: for (i = 0; i < cdblen; i++) {
852: printf("%2.2x ", cdb[i]);
853: }
854: printf("\n");
855: }
856:
857: void
858: istgt_strcpy_pad(uint8_t *dst, size_t size, const char *src, int pad)
859: {
860: size_t len;
861:
862: len = strlen(src);
863: if (len < size) {
864: memcpy(dst, src, len);
865: memset(dst + len, pad, (size - len));
866: } else {
867: memcpy(dst, src, size);
868: }
869: }
870:
871: #ifdef HAVE_UUID_H
872: uint64_t
873: istgt_uuid2uint64(uuid_t *uuid)
874: {
875: uint64_t low, mid, hi;
876: uint64_t r;
877:
878: low = (uint64_t) uuid->time_low;
879: mid = (uint64_t) uuid->time_mid;
880: hi = (uint64_t) uuid->time_hi_and_version;
881: r = (hi & 0xffffULL) << 48;
882: r |= (mid & 0xffffULL) << 32;
883: r |= (low & 0xffffffffULL);
884: return r;
885: }
886: #endif /* HAVE_UUID_H */
887:
888: uint64_t
889: istgt_get_lui(const char *name, int lun)
890: {
891: char buf[MAX_TMPBUF];
892: uint32_t crc32c;
893: uint64_t r;
894:
895: if (lun >= 0) {
896: snprintf(buf, sizeof buf, "%s,%d",
897: name, lun);
898: } else {
899: snprintf(buf, sizeof buf, "%s",
900: name);
901: }
902: crc32c = istgt_crc32c((uint8_t *) buf, strlen(buf));
903: r = (uint64_t) crc32c;
904: return r;
905: }
906:
907: uint64_t
908: istgt_get_rkey(const char *initiator_name, uint64_t lui)
909: {
910: ISTGT_MD5CTX md5ctx;
911: uint8_t rkeymd5[ISTGT_MD5DIGEST_LEN];
912: char buf[MAX_TMPBUF];
913: uint64_t rkey;
914: int idx;
915: int i;
916:
917: snprintf(buf, sizeof buf, "%s,%16.16" PRIx64,
918: initiator_name, lui);
919:
920: istgt_md5init(&md5ctx);
921: istgt_md5update(&md5ctx, buf, strlen(buf));
922: istgt_md5final(rkeymd5, &md5ctx);
923:
924: rkey = 0U;
925: idx = ISTGT_MD5DIGEST_LEN - 8;
926: if (idx < 0) {
927: ISTGT_WARNLOG("missing MD5 length\n");
928: idx = 0;
929: }
930: for (i = idx; i < ISTGT_MD5DIGEST_LEN; i++) {
931: rkey |= (uint64_t) rkeymd5[i];
932: rkey = rkey << 8;
933: }
934: return rkey;
935: }
936:
937: /* XXX */
938: #define COMPANY_ID 0xACDE48U // 24bits
939:
940: int
941: istgt_lu_set_lid(uint8_t *buf, uint64_t vid)
942: {
943: uint64_t naa;
944: uint64_t enc;
945: int total;
946:
947: naa = 0x3; // Locally Assigned
948:
949: /* NAA + LOCALLY ADMINISTERED VALUE */
950: enc = (naa & 0xfULL) << (64-4); // 4bits
951: enc |= vid & 0xfffffffffffffffULL; //60bits
952: DSET64(&buf[0], enc);
953:
954: total = 8;
955: return total;
956: }
957:
958: int
959: istgt_lu_set_id(uint8_t *buf, uint64_t vid)
960: {
961: uint64_t naa;
962: uint64_t cid;
963: uint64_t enc;
964: int total;
965:
966: naa = 0x5; // IEEE Registered
967: cid = COMPANY_ID; //IEEE COMPANY_ID
968:
969: /* NAA + COMPANY_ID + VENDOR SPECIFIC IDENTIFIER */
970: enc = (naa & 0xfULL) << (64-4); // 4bits
971: enc |= (cid & 0xffffffULL) << (64-4-24); // 24bits
972: enc |= vid & 0xfffffffffULL; //36bits
973: DSET64(&buf[0], enc);
974:
975: total = 8;
976: return total;
977: }
978:
979: int
980: istgt_lu_set_extid(uint8_t *buf, uint64_t vid, uint64_t vide)
981: {
982: uint64_t naa;
983: uint64_t cid;
984: uint64_t enc;
985: int total;
986:
987: naa = 0x6; // IEEE Registered Extended
988: cid = COMPANY_ID; //IEEE COMPANY_ID
989:
990: /* NAA + COMPANY_ID + VENDOR SPECIFIC IDENTIFIER */
991: enc = (naa & 0xfULL) << (64-4); // 4bits
992: enc |= (cid & 0xffffffULL) << (64-4-24); // 24bits
993: enc |= vid & 0xfffffffffULL; //36bits
994: DSET64(&buf[0], enc);
995: /* VENDOR SPECIFIC IDENTIFIER EXTENSION */
996: DSET64(&buf[8], vide);
997:
998: total = 16;
999: return total;
1000: }
1001:
1002: static int
1003: istgt_lu_disk_scsi_report_luns(ISTGT_LU_Ptr lu, CONN_Ptr conn, uint8_t *cdb, int sel, uint8_t *data, int alloc_len)
1004: {
1005: uint64_t fmt_lun, lun, method;
1006: int hlen = 0, len = 0;
1007: int i;
1008:
1009: if (alloc_len < 8) {
1010: return -1;
1011: }
1012:
1013: if (sel == 0x00) {
1014: /* logical unit with addressing method */
1015: } else if (sel == 0x01) {
1016: /* well known logical unit */
1017: } else if (sel == 0x02) {
1018: /* logical unit */
1019: } else {
1020: return -1;
1021: }
1022:
1023: /* LUN LIST LENGTH */
1024: DSET32(&data[0], 0);
1025: /* Reserved */
1026: DSET32(&data[4], 0);
1027: hlen = 8;
1028:
1029: for (i = 0; i < lu->maxlun; i++) {
1030: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
1031: #if 0
1032: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
1033: lu->num, i);
1034: #endif
1035: continue;
1036: }
1037: if (alloc_len - (hlen + len) < 8) {
1038: return -1;
1039: }
1040: lun = (uint64_t) i;
1041: if (lu->maxlun <= 0x0100) {
1042: /* below 256 */
1043: method = 0x00U;
1044: fmt_lun = (method & 0x03U) << 62;
1045: fmt_lun |= (lun & 0x00ffU) << 48;
1046: } else if (lu->maxlun <= 0x4000U) {
1047: /* below 16384 */
1048: method = 0x01U;
1049: fmt_lun = (method & 0x03U) << 62;
1050: fmt_lun |= (lun & 0x3fffU) << 48;
1051: } else {
1052: /* XXX */
1053: fmt_lun = 0;
1054: }
1055: /* LUN */
1056: DSET64(&data[hlen + len], fmt_lun);
1057: len += 8;
1058: }
1059: /* LUN LIST LENGTH */
1060: DSET32(&data[0], len);
1061: return hlen + len;
1062: }
1063:
1064: static int
1065: istgt_lu_disk_scsi_inquiry(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, uint8_t *data, int alloc_len)
1066: {
1067: uint64_t LUI;
1068: uint8_t *cp, *cp2;
1069: uint32_t blocks;
1070: int hlen = 0, len = 0, plen, plen2;
1071: int pc;
1072: int pq, pd;
1073: int rmb;
1074: int evpd;
1075: int pg_tag;
1076: int i, j;
1077:
1078: if (alloc_len < 0xff) {
1079: return -1;
1080: }
1081:
1082: pq = 0x00;
1083: pd = SPC_PERIPHERAL_DEVICE_TYPE_DISK;
1084: rmb = 0;
1085:
1086: #if 0
1087: LUI = istgt_uuid2uint64(&spec->uuid);
1088: #else
1089: LUI = istgt_get_lui(spec->lu->name, spec->lun & 0xffffU);
1090: #endif
1091:
1092: pc = cdb[2];
1093: evpd = BGET8(&cdb[1], 0);
1094: if (evpd) {
1095: /* Vital product data */
1096: switch (pc) {
1097: case SPC_VPD_SUPPORTED_VPD_PAGES:
1098: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1099: BDSET8W(&data[0], pq, 7, 3);
1100: BDADD8W(&data[0], pd, 4, 5);
1101: /* PAGE CODE */
1102: data[1] = pc;
1103: /* Reserved */
1104: data[2] = 0;
1105: /* PAGE LENGTH */
1106: data[3] = 0;
1107: hlen = 4;
1108:
1109: data[4] = SPC_VPD_SUPPORTED_VPD_PAGES; /* 0x00 */
1110: data[5] = SPC_VPD_UNIT_SERIAL_NUMBER; /* 0x80 */
1111: data[6] = SPC_VPD_DEVICE_IDENTIFICATION; /* 0x83 */
1112: data[7] = SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES; /* 0x85 */
1113: data[8] = SPC_VPD_EXTENDED_INQUIRY_DATA; /* 0x86 */
1114: data[9] = SPC_VPD_MODE_PAGE_POLICY; /* 0x87 */
1115: data[10]= SPC_VPD_SCSI_PORTS; /* 0x88 */
1116: data[11]= 0xb0; /* SBC Block Limits */
1117: data[12]= 0xb1; /* SBC Block Device Characteristics */
1118: len = 13 - hlen;
1119: if (spec->thin_provisioning) {
1120: data[13]= 0xb2; /* SBC Thin Provisioning */
1121: len++;
1122: }
1123:
1124: /* PAGE LENGTH */
1125: data[3] = len;
1126: break;
1127:
1128: case SPC_VPD_UNIT_SERIAL_NUMBER:
1129: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1130: BDSET8W(&data[0], pq, 7, 3);
1131: BDADD8W(&data[0], pd, 4, 5);
1132: /* PAGE CODE */
1133: data[1] = pc;
1134: /* Reserved */
1135: data[2] = 0;
1136: /* PAGE LENGTH */
1137: data[3] = 0;
1138: hlen = 4;
1139:
1140: /* PRODUCT SERIAL NUMBER */
1141: if (spec->lu->lun[spec->lun].serial != NULL) {
1142: len = strlen(spec->lu->lun[spec->lun].serial);
1143: if (len > MAX_LU_SERIAL_STRING) {
1144: len = MAX_LU_SERIAL_STRING;
1145: }
1146: istgt_strcpy_pad(&data[4], len,
1147: spec->lu->lun[spec->lun].serial, ' ');
1148: } else {
1149: len = strlen(spec->lu->inq_serial);
1150: if (len > MAX_LU_SERIAL_STRING) {
1151: len = MAX_LU_SERIAL_STRING;
1152: }
1153: istgt_strcpy_pad(&data[4], len,
1154: spec->lu->inq_serial, ' ');
1155: }
1156:
1157: /* PAGE LENGTH */
1158: data[3] = len;
1159: break;
1160:
1161: case SPC_VPD_DEVICE_IDENTIFICATION:
1162: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1163: BDSET8W(&data[0], pq, 7, 3);
1164: BDADD8W(&data[0], pd, 4, 5);
1165: /* PAGE CODE */
1166: data[1] = pc;
1167: /* PAGE LENGTH */
1168: DSET16(&data[2], 0);
1169: hlen = 4;
1170:
1171: /* Identification descriptor 1 */
1172: /* Logical Unit */
1173: cp = &data[hlen + len];
1174:
1175: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1176: BDSET8W(&cp[0], 0, 7, 4);
1177: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
1178: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1179: BDSET8W(&cp[1], 0, 7, 1); /* PIV=0 */
1180: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
1181: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_NAA, 3, 4);
1182: /* Reserved */
1183: cp[2] = 0;
1184: /* IDENTIFIER LENGTH */
1185: cp[3] = 0;
1186:
1187: /* IDENTIFIER */
1188: #if 0
1189: /* 16bytes ID */
1190: plen = istgt_lu_set_extid(&cp[4], 0, LUI);
1191: #else
1192: plen = istgt_lu_set_lid(&cp[4], LUI);
1193: #endif
1194:
1195: cp[3] = plen;
1196: len += 4 + plen;
1197:
1198: /* Identification descriptor 2 */
1199: /* T10 VENDOR IDENTIFICATION */
1200: cp = &data[hlen + len];
1201:
1202: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1203: BDSET8W(&cp[0], 0, 7, 4);
1204: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
1205: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1206: BDSET8W(&cp[1], 0, 7, 1); /* PIV=0 */
1207: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
1208: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID, 3, 4);
1209: /* Reserved */
1210: cp[2] = 0;
1211: /* IDENTIFIER LENGTH */
1212: cp[3] = 0;
1213:
1214: /* IDENTIFIER */
1215: /* T10 VENDOR IDENTIFICATION */
1216: istgt_strcpy_pad(&cp[4], 8, spec->lu->inq_vendor, ' ');
1217: plen = 8;
1218: /* VENDOR SPECIFIC IDENTIFIER */
1219: /* PRODUCT IDENTIFICATION */
1220: istgt_strcpy_pad(&cp[12], 16, spec->lu->inq_product, ' ');
1221: /* PRODUCT SERIAL NUMBER */
1222: if (spec->lu->lun[spec->lun].serial != NULL) {
1223: istgt_strcpy_pad(&cp[28], MAX_LU_SERIAL_STRING,
1224: spec->lu->lun[spec->lun].serial, ' ');
1225: } else {
1226: istgt_strcpy_pad(&cp[28], MAX_LU_SERIAL_STRING,
1227: spec->lu->inq_serial, ' ');
1228: }
1229: plen += 16 + MAX_LU_SERIAL_STRING;
1230:
1231: cp[3] = plen;
1232: len += 4 + plen;
1233:
1234: /* Identification descriptor 3 */
1235: /* Target Device */
1236: cp = &data[hlen + len];
1237:
1238: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1239: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1240: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
1241: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1242: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
1243: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_DEVICE, 5, 2);
1244: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
1245: /* Reserved */
1246: cp[2] = 0;
1247: /* IDENTIFIER LENGTH */
1248: cp[3] = 0;
1249:
1250: /* IDENTIFIER */
1251: plen = snprintf((char *) &cp[4], MAX_TARGET_NAME,
1252: "%s",
1253: spec->lu->name);
1254: cp[3] = plen;
1255: len += 4 + plen;
1256:
1257: /* Identification descriptor 4 */
1258: /* Target Port */
1259: cp = &data[hlen + len];
1260:
1261: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1262: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1263: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
1264: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1265: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
1266: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
1267: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
1268: /* Reserved */
1269: cp[2] = 0;
1270: /* IDENTIFIER LENGTH */
1271: cp[3] = 0;
1272:
1273: /* IDENTIFIER */
1274: plen = snprintf((char *) &cp[4], MAX_TARGET_NAME,
1275: "%s"",t,0x""%4.4x",
1276: spec->lu->name,
1277: conn->portal.tag);
1278: cp[3] = plen;
1279: len += 4 + plen;
1280:
1281: /* Identification descriptor 5 */
1282: /* Relative Target Port */
1283: cp = &data[hlen + len];
1284:
1285: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1286: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1287: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
1288: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1289: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
1290: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
1291: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT,
1292: 3, 4);
1293: /* Reserved */
1294: cp[2] = 0;
1295: /* IDENTIFIER LENGTH */
1296: cp[3] = 0;
1297:
1298: /* IDENTIFIER */
1299: /* Obsolete */
1300: DSET16(&cp[4], 0);
1301: /* Relative Target Port Identifier */
1302: //DSET16(&cp[6], 1); /* port1 as port A */
1303: //DSET16(&cp[6], 2); /* port2 as port B */
1304: DSET16(&cp[6], (uint16_t) (1 + conn->portal.idx));
1305: plen = 4;
1306:
1307: cp[3] = plen;
1308: len += 4 + plen;
1309:
1310: /* Identification descriptor 6 */
1311: /* Target port group */
1312: cp = &data[hlen + len];
1313:
1314: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1315: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1316: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
1317: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1318: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
1319: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
1320: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_TARGET_PORT_GROUP,
1321: 3, 4);
1322: /* Reserved */
1323: cp[2] = 0;
1324: /* IDENTIFIER LENGTH */
1325: cp[3] = 0;
1326:
1327: /* IDENTIFIER */
1328: /* Reserved */
1329: DSET16(&cp[4], 0);
1330: /* TARGET PORT GROUP */
1331: DSET16(&cp[6], (uint16_t) (conn->portal.tag));
1332: plen = 4;
1333:
1334: cp[3] = plen;
1335: len += 4 + plen;
1336:
1337: /* Identification descriptor 7 */
1338: /* Logical unit group */
1339: cp = &data[hlen + len];
1340:
1341: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1342: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1343: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
1344: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1345: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
1346: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
1347: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_LOGICAL_UNIT_GROUP,
1348: 3, 4);
1349: /* Reserved */
1350: cp[2] = 0;
1351: /* IDENTIFIER LENGTH */
1352: cp[3] = 0;
1353:
1354: /* IDENTIFIER */
1355: /* Reserved */
1356: DSET16(&cp[4], 0);
1357: /* LOGICAL UNIT GROUP */
1358: DSET16(&cp[6], (uint16_t) (spec->lu->num));
1359: plen = 4;
1360:
1361: cp[3] = plen;
1362: len += 4 + plen;
1363:
1364: /* PAGE LENGTH */
1365: if (len > 0xffff) {
1366: len = 0xffff;
1367: }
1368: DSET16(&data[2], len);
1369: break;
1370:
1371: case SPC_VPD_EXTENDED_INQUIRY_DATA:
1372: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1373: BDSET8W(&data[0], pq, 7, 3);
1374: BDADD8W(&data[0], pd, 4, 5);
1375: /* PAGE CODE */
1376: data[1] = pc;
1377: /* Reserved */
1378: data[2] = 0;
1379: /* PAGE LENGTH */
1380: data[3] = 0;
1381: hlen = 4;
1382:
1383: /* RTO(3) GRD_CHK(2) APP_CHK(1) REF_CHK(0) */
1384: data[4] = 0;
1385: /* GROUP_SUP(4) PRIOR_SUP(3) HEADSUP(2) ORDSUP(1) SIMPSUP(0) */
1386: data[5] = 0;
1387: if (spec->queue_depth != 0) {
1388: BDADD8(&data[5], 1, 2); /* HEADSUP */
1389: //BDADD8(&data[5], 1, 1); /* ORDSUP */
1390: BDADD8(&data[5], 1, 0); /* SIMPSUP */
1391: }
1392: /* NV_SUP(1) V_SUP(0) */
1393: data[6] = 0;
1394: /* Reserved[7-63] */
1395: memset(&data[7], 0, (64 - 7));
1396: len = 64 - hlen;
1397:
1398: /* PAGE LENGTH */
1399: data[3] = len;
1400: break;
1401:
1402: case SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES:
1403: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1404: BDSET8W(&data[0], pq, 7, 3);
1405: BDADD8W(&data[0], pd, 4, 5);
1406: /* PAGE CODE */
1407: data[1] = pc;
1408: /* PAGE LENGTH */
1409: DSET16(&data[2], 0);
1410: hlen = 4;
1411:
1412: #if 0
1413: /* Network services descriptor N */
1414: cp = &data[hlen + len];
1415:
1416: /* ASSOCIATION(6-5) SERVICE TYPE(4-0) */
1417: BDSET8W(&cp[0], 0x00, 6, 2);
1418: BDADD8W(&cp[0], 0x00, 4, 5);
1419: /* Reserved */
1420: cp[1] = 0;
1421: /* NETWORK ADDRESS LENGTH */
1422: DSET16(&cp[2], 0);
1423: /* NETWORK ADDRESS */
1424: cp[4] = 0;
1425: /* ... */
1426: plen = 0;
1427: DSET16(&cp[2], plen);
1428: len += 4 + plen;
1429: #endif
1430:
1431: /* PAGE LENGTH */
1432: if (len > 0xffff) {
1433: len = 0xffff;
1434: }
1435: DSET16(&data[2], len);
1436: break;
1437:
1438: case SPC_VPD_MODE_PAGE_POLICY:
1439: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1440: BDSET8W(&data[0], pq, 7, 3);
1441: BDADD8W(&data[0], pd, 4, 5);
1442: /* PAGE CODE */
1443: data[1] = pc;
1444: /* PAGE LENGTH */
1445: DSET16(&data[2], 0);
1446: hlen = 4;
1447:
1448: /* Mode page policy descriptor 1 */
1449: cp = &data[hlen + len];
1450:
1451: /* POLICY PAGE CODE(5-0) */
1452: BDSET8W(&cp[0], 0x3f, 5, 6); /* all page code */
1453: /* POLICY SUBPAGE CODE */
1454: cp[1] = 0xff; /* all sub page */
1455: /* MLUS(7) MODE PAGE POLICY(1-0) */
1456: //BDSET8(&cp[2], 1, 7); /* multiple logical units share */
1457: BDSET8(&cp[2], 0, 7); /* own copy */
1458: BDADD8W(&cp[2], 0x00, 1, 2); /* Shared */
1459: //BDADD8W(&cp[2], 0x01, 1, 2); /* Per target port */
1460: //BDADD8W(&cp[2], 0x02, 1, 2); /* Per initiator port */
1461: //BDADD8W(&cp[2], 0x03, 1, 2); /* Per I_T nexus */
1462: /* Reserved */
1463: cp[3] = 0;
1464: len += 4;
1465:
1466: /* PAGE LENGTH */
1467: if (len > 0xffff) {
1468: len = 0xffff;
1469: }
1470: DSET16(&data[2], len);
1471: break;
1472:
1473: case SPC_VPD_SCSI_PORTS:
1474: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1475: BDSET8W(&data[0], pq, 7, 3);
1476: BDADD8W(&data[0], pd, 4, 5);
1477: /* PAGE CODE */
1478: data[1] = pc;
1479: /* PAGE LENGTH */
1480: DSET16(&data[2], 0);
1481: hlen = 4;
1482:
1483: /* Identification descriptor list */
1484: for (i = 0; i < spec->lu->maxmap; i++) {
1485: pg_tag = spec->lu->map[i].pg_tag;
1486: /* skip same pg_tag */
1487: for (j = 0; j < i; j++) {
1488: if (spec->lu->map[j].pg_tag == pg_tag) {
1489: goto skip_pg_tag;
1490: }
1491: }
1492:
1493: /* Identification descriptor N */
1494: cp = &data[hlen + len];
1495:
1496: /* Reserved */
1497: DSET16(&cp[0], 0);
1498: /* RELATIVE PORT IDENTIFIER */
1499: DSET16(&cp[2], (uint16_t) (1 + pg_tag));
1500: /* Reserved */
1501: DSET16(&cp[4], 0);
1502: /* INITIATOR PORT TRANSPORTID LENGTH */
1503: DSET16(&cp[6], 0);
1504: /* Reserved */
1505: DSET16(&cp[8], 0);
1506: /* TARGET PORT DESCRIPTORS LENGTH */
1507: DSET16(&cp[10], 0);
1508: len += 12;
1509:
1510: plen2 = 0;
1511: /* Target port descriptor 1 */
1512: cp2 = &data[hlen + len + plen2];
1513:
1514: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
1515: BDSET8W(&cp2[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
1516: BDADD8W(&cp2[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
1517: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
1518: BDSET8W(&cp2[1], 1, 7, 1); /* PIV */
1519: BDADD8W(&cp2[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
1520: BDADD8W(&cp2[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
1521: /* Reserved */
1522: cp2[2] = 0;
1523: /* IDENTIFIER LENGTH */
1524: cp2[3] = 0;
1525:
1526: /* IDENTIFIER */
1527: plen = snprintf((char *) &cp2[4], MAX_TARGET_NAME,
1528: "%s"",t,0x""%4.4x",
1529: spec->lu->name,
1530: pg_tag);
1531: cp2[3] = plen;
1532: plen2 += 4 + plen;
1533:
1534: /* TARGET PORT DESCRIPTORS LENGTH */
1535: DSET16(&cp[10], plen2);
1536: len += plen2;
1537: skip_pg_tag:
1538: ;
1539: }
1540:
1541: /* PAGE LENGTH */
1542: if (len > 0xffff) {
1543: len = 0xffff;
1544: }
1545: DSET16(&data[2], len);
1546: break;
1547:
1548: case 0xb0: /* SBC Block Limits */
1549: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1550: BDSET8W(&data[0], pq, 7, 3);
1551: BDADD8W(&data[0], pd, 4, 5);
1552: /* PAGE CODE */
1553: data[1] = pc;
1554: /* PAGE LENGTH */
1555: DSET16(&data[2], 0);
1556: hlen = 4;
1557:
1558: /* WSNZ(0) */
1559: BDSET8(&data[4], 0, 0); /* support zero length in WRITE SAME */
1560: /* MAXIMUM COMPARE AND WRITE LENGTH */
1561: blocks = ISTGT_LU_WORK_BLOCK_SIZE / (uint32_t) spec->blocklen;
1562: if (blocks > 0xff) {
1563: blocks = 0xff;
1564: }
1565: data[5] = (uint8_t) blocks;
1566: if (spec->lu->istgt->swmode == ISTGT_SWMODE_TRADITIONAL) {
1567: /* no support compare and write */
1568: data[5] = 0;
1569: }
1570:
1571: /* force align to 4KB */
1572: if (spec->blocklen < 4096) {
1573: blocks = 4096 / (uint32_t) spec->blocklen;
1574: /* OPTIMAL TRANSFER LENGTH GRANULARITY */
1575: DSET16(&data[6], blocks);
1576: /* MAXIMUM TRANSFER LENGTH */
1577: DSET32(&data[8], 0); /* no limit */
1578: /* OPTIMAL TRANSFER LENGTH */
1579: blocks = ISTGT_LU_WORK_BLOCK_SIZE / (uint32_t) spec->blocklen;
1580: DSET32(&data[12], blocks);
1581: /* MAXIMUM PREFETCH XDREAD XDWRITE TRANSFER LENGTH */
1582: DSET32(&data[16], 0);
1583: } else {
1584: blocks = 1;
1585: /* OPTIMAL TRANSFER LENGTH GRANULARITY */
1586: DSET16(&data[6], blocks);
1587: /* MAXIMUM TRANSFER LENGTH */
1588: DSET32(&data[8], 0); /* no limit */
1589: /* OPTIMAL TRANSFER LENGTH */
1590: blocks = ISTGT_LU_WORK_BLOCK_SIZE / (uint32_t) spec->blocklen;
1591: DSET32(&data[12], blocks);
1592: /* MAXIMUM PREFETCH XDREAD XDWRITE TRANSFER LENGTH */
1593: DSET32(&data[16], 0);
1594: }
1595: len = 20 - hlen;
1596:
1597: if (1 || spec->thin_provisioning) {
1598: /* MAXIMUM UNMAP LBA COUNT */
1599: DSET32(&data[20], 0); /* not implement UNMAP */
1600: /* MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT */
1601: DSET32(&data[24], 0); /* not implement UNMAP */
1602: /* OPTIMAL UNMAP GRANULARITY */
1603: DSET32(&data[28], 0); /* not specified */
1604: /* UNMAP GRANULARITY ALIGNMENT */
1605: DSET32(&data[32], (0 & 0x7fffffffU));
1606: /* UGAVALID(7) */
1607: BDADD8(&data[32], 0, 7); /* not valid ALIGNMENT */
1608: /* MAXIMUM WRITE SAME LENGTH */
1609: DSET64(&data[36], 0); /* no limit */
1610: /* Reserved */
1611: memset(&data[44], 0x00, 64-44);
1612: len = 64 - hlen;
1613: }
1614:
1615: DSET16(&data[2], len);
1616: break;
1617:
1618: case 0xb1: /* SBC Block Device Characteristics */
1619: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1620: BDSET8W(&data[0], pq, 7, 3);
1621: BDADD8W(&data[0], pd, 4, 5);
1622: /* PAGE CODE */
1623: data[1] = pc;
1624: /* PAGE LENGTH */
1625: DSET16(&data[2], 0);
1626: hlen = 4;
1627:
1628: /* MEDIUM ROTATION RATE */
1629: //DSET16(&data[4], 0x0000); /* not reported */
1630: //DSET16(&data[4], 0x0001); /* Non-rotating medium (solid state) */
1631: //DSET16(&data[4], 5400); /* rotation rate (5400rpm) */
1632: //DSET16(&data[4], 7200); /* rotation rate (7200rpm) */
1633: //DSET16(&data[4], 10000); /* rotation rate (10000rpm) */
1634: //DSET16(&data[4], 15000); /* rotation rate (15000rpm) */
1635: DSET16(&data[4], spec->lu->lun[spec->lun].rotationrate);
1636: /* Reserved */
1637: data[6] = 0;
1638: /* NOMINAL FORM FACTOR(3-0) */
1639: //BDSET8W(&data[7], 0x00, 3, 4); /* not reported */
1640: //BDSET8W(&data[7], 0x01, 3, 4); /* 5.25 inch */
1641: //BDSET8W(&data[7], 0x02, 3, 4); /* 3.5 inch */
1642: //BDSET8W(&data[7], 0x03, 3, 4); /* 2.5 inch */
1643: //BDSET8W(&data[7], 0x04, 3, 4); /* 1.8 inch */
1644: //BDSET8W(&data[7], 0x05, 3, 4); /* less 1.8 inch */
1645: BDSET8W(&data[7], spec->lu->lun[spec->lun].formfactor, 3, 4);
1646: /* Reserved */
1647: memset(&data[8], 0x00, 64-8);
1648:
1649: len = 64 - hlen;
1650: DSET16(&data[2], len);
1651: break;
1652:
1653: case 0xb2: /* SBC Thin Provisioning */
1654: if (!spec->thin_provisioning) {
1655: ISTGT_ERRLOG("unsupported INQUIRY VPD page 0x%x\n", pc);
1656: return -1;
1657: }
1658:
1659: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1660: BDSET8W(&data[0], pq, 7, 3);
1661: BDADD8W(&data[0], pd, 4, 5);
1662: /* PAGE CODE */
1663: data[1] = pc;
1664: /* PAGE LENGTH */
1665: DSET16(&data[2], 0);
1666: hlen = 4;
1667:
1668: /* THRESHOLD EXPONENT */
1669: data[4] = 0;
1670: /* DP(0) */
1671: BDSET8(&data[5], 0, 0);
1672: /* Reserved */
1673: DSET16(&data[6], 0);
1674: len = 6 - hlen;
1675: #if 0
1676: /* XXX not yet */
1677: /* PROVISIONING GROUP DESCRIPTOR ... */
1678: DSET16(&data[8], 0);
1679: len = 8 - hlen;
1680: #endif
1681:
1682: DSET16(&data[2], len);
1683: break;
1684:
1685: default:
1686: if (pc >= 0xc0 && pc <= 0xff) {
1687: ISTGT_WARNLOG("Vendor specific INQUIRY VPD page 0x%x\n", pc);
1688: } else {
1689: ISTGT_ERRLOG("unsupported INQUIRY VPD page 0x%x\n", pc);
1690: }
1691: return -1;
1692: }
1693: } else {
1694: /* Standard INQUIRY data */
1695: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
1696: BDSET8W(&data[0], pq, 7, 3);
1697: BDADD8W(&data[0], pd, 4, 5);
1698: /* RMB(7) */
1699: BDSET8W(&data[1], rmb, 7, 1);
1700: /* VERSION */
1701: /* See SPC3/SBC2/MMC4/SAM2 for more details */
1702: data[2] = SPC_VERSION_SPC3;
1703: /* NORMACA(5) HISUP(4) RESPONSE DATA FORMAT(3-0) */
1704: BDSET8W(&data[3], 2, 3, 4); /* format 2 */
1705: BDADD8(&data[1], 1, 4); /* hierarchical support */
1706: /* ADDITIONAL LENGTH */
1707: data[4] = 0;
1708: hlen = 5;
1709:
1710: /* SCCS(7) ACC(6) TPGS(5-4) 3PC(3) PROTECT(0) */
1711: data[5] = 0;
1712: //BDADD8W(&data[5], 1, 7, 1); /* storage array controller */
1713: BDADD8W(&data[5], 0x00, 5, 2); /* Not support TPGS */
1714: //BDADD8W(&data[5], 0x01, 5, 2); /* Only implicit */
1715: //BDADD8W(&data[5], 0x02, 5, 2); /* Only explicit */
1716: //BDADD8W(&data[5], 0x03, 5, 2); /* Both explicit and implicit */
1717: /* BQUE(7) ENCSERV(6) VS(5) MULTIP(4) MCHNGR(3) ADDR16(0) */
1718: data[6] = 0;
1719: BDADD8W(&data[6], 1, 4, 1); /* MULTIP */
1720: /* WBUS16(5) SYNC(4) LINKED(3) CMDQUE(1) VS(0) */
1721: data[7] = 0;
1722: if (spec->queue_depth != 0) {
1723: BDADD8(&data[7], 1, 1); /* CMDQUE */
1724: }
1725: /* T10 VENDOR IDENTIFICATION */
1726: istgt_strcpy_pad(&data[8], 8, spec->lu->inq_vendor, ' ');
1727: /* PRODUCT IDENTIFICATION */
1728: istgt_strcpy_pad(&data[16], 16, spec->lu->inq_product, ' ');
1729: /* PRODUCT REVISION LEVEL */
1730: istgt_strcpy_pad(&data[32], 4, spec->lu->inq_revision, ' ');
1731: /* Vendor specific */
1732: memset(&data[36], 0x20, 20);
1733: /* CLOCKING(3-2) QAS(1) IUS(0) */
1734: data[56] = 0;
1735: /* Reserved */
1736: data[57] = 0;
1737: /* VERSION DESCRIPTOR 1-8 */
1738: DSET16(&data[58], 0x0960); /* iSCSI (no version claimed) */
1739: DSET16(&data[60], 0x0300); /* SPC-3 (no version claimed) */
1740: DSET16(&data[62], 0x0320); /* SBC-2 (no version claimed) */
1741: DSET16(&data[64], 0x0040); /* SAM-2 (no version claimed) */
1742: DSET16(&data[66], 0x0000);
1743: DSET16(&data[68], 0x0000);
1744: DSET16(&data[70], 0x0000);
1745: DSET16(&data[72], 0x0000);
1746: /* Reserved[74-95] */
1747: memset(&data[74], 0, (96 - 74));
1748: /* Vendor specific parameters[96-n] */
1749: //data[96] = 0;
1750: len = 96 - hlen;
1751:
1752: /* ADDITIONAL LENGTH */
1753: data[4] = len;
1754: }
1755:
1756: return hlen + len;
1757: }
1758:
1759: #define MODE_SENSE_PAGE_INIT(B,L,P,SP) \
1760: do { \
1761: memset((B), 0, (L)); \
1762: if ((SP) != 0x00) { \
1763: (B)[0] = (P) | 0x40; /* PAGE + SPF=1 */ \
1764: (B)[1] = (SP); \
1765: DSET16(&(B)[2], (L) - 4); \
1766: } else { \
1767: (B)[0] = (P); \
1768: (B)[1] = (L) - 2; \
1769: } \
1770: } while (0)
1771:
1772: static int
1773: istgt_lu_disk_scsi_mode_sense_page(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, int pc, int page, int subpage, uint8_t *data, int alloc_len)
1774: {
1775: uint8_t *cp;
1776: int len = 0;
1777: int plen;
1778: int rc;
1779: int i;
1780:
1781: #if 0
1782: printf("pc=%d, page=%2.2x, subpage=%2.2x\n", pc, page, subpage);
1783: #endif
1784: #if 0
1785: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE: pc=%d, page=%2.2x, subpage=%2.2x\n", pc, page, subpage);
1786: #endif
1787:
1788: if (pc == 0x00) {
1789: /* Current values */
1790: } else if (pc == 0x01) {
1791: /* Changeable values */
1792: if (page != 0x08) {
1793: /* not supported */
1794: return 0;
1795: }
1796: } else if (pc == 0x02) {
1797: /* Default values */
1798: } else {
1799: /* Saved values */
1800: }
1801:
1802: cp = &data[len];
1803: switch (page) {
1804: case 0x00:
1805: /* Vendor specific */
1806: break;
1807: case 0x01:
1808: /* Read-Write Error Recovery */
1809: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Read-Write Error Recovery\n");
1810: if (subpage != 0x00)
1811: break;
1812: plen = 0x0a + 2;
1813: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1814: len += plen;
1815: break;
1816: case 0x02:
1817: /* Disconnect-Reconnect */
1818: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Disconnect-Reconnect\n");
1819: if (subpage != 0x00)
1820: break;
1821: plen = 0x0e + 2;
1822: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1823: len += plen;
1824: break;
1825: case 0x03:
1826: /* Obsolete (Format Device) */
1827: break;
1828: case 0x04:
1829: /* Obsolete (Rigid Disk Geometry) */
1830: break;
1831: case 0x05:
1832: /* Obsolete (Rigid Disk Geometry) */
1833: break;
1834: case 0x06:
1835: /* Reserved */
1836: break;
1837: case 0x07:
1838: /* Verify Error Recovery */
1839: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Verify Error Recovery\n");
1840: if (subpage != 0x00)
1841: break;
1842: plen = 0x0a + 2;
1843: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1844: len += plen;
1845: break;
1846: case 0x08:
1847: /* Caching */
1848: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Caching\n");
1849: if (subpage != 0x00)
1850: break;
1851:
1852: plen = 0x12 + 2;
1853: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1854: BDADD8(&cp[0], 1, 7); /* PS */
1855: BDADD8(&cp[2], 1, 2); /* WCE */
1856: //BDADD8(&cp[2], 1, 0); /* RCD */
1857: {
1858: int fd;
1859: fd = spec->fd;
1860: rc = fcntl(fd , F_GETFL, 0);
1861: if (rc != -1 && !(rc & O_FSYNC)) {
1862: BDADD8(&cp[2], 1, 2); /* WCE=1 */
1863: } else {
1864: BDADD8(&cp[2], 0, 2); /* WCE=0 */
1865: }
1866: }
1867: if (spec->read_cache == 0) {
1868: BDADD8(&cp[2], 1, 0); /* RCD=1 */
1869: } else {
1870: BDADD8(&cp[2], 0, 0); /* RCD=0 */
1871: }
1872: len += plen;
1873: break;
1874: case 0x09:
1875: /* Obsolete */
1876: break;
1877: case 0x0a:
1878: switch (subpage) {
1879: case 0x00:
1880: /* Control */
1881: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Control\n");
1882: plen = 0x0a + 2;
1883: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1884: len += plen;
1885: break;
1886: case 0x01:
1887: /* Control Extension */
1888: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Control Extension\n");
1889: plen = 0x1c + 4;
1890: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1891: len += plen;
1892: break;
1893: case 0xff:
1894: /* All subpages */
1895: len += istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, page, 0x00, &data[len], alloc_len);
1896: len += istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, page, 0x01, &data[len], alloc_len);
1897: break;
1898: default:
1899: /* 0x02-0x3e: Reserved */
1900: break;
1901: }
1902: break;
1903: case 0x0b:
1904: /* Obsolete (Medium Types Supported) */
1905: break;
1906: case 0x0c:
1907: /* Obsolete (Notch And Partitio) */
1908: break;
1909: case 0x0d:
1910: /* Obsolete */
1911: break;
1912: case 0x0e:
1913: case 0x0f:
1914: /* Reserved */
1915: break;
1916: case 0x10:
1917: /* XOR Control */
1918: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE XOR Control\n");
1919: if (subpage != 0x00)
1920: break;
1921: plen = 0x16 + 2;
1922: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1923: len += plen;
1924: break;
1925: case 0x11:
1926: case 0x12:
1927: case 0x13:
1928: /* Reserved */
1929: break;
1930: case 0x14:
1931: /* Enclosure Services Management */
1932: break;
1933: case 0x15:
1934: case 0x16:
1935: case 0x17:
1936: /* Reserved */
1937: break;
1938: case 0x18:
1939: /* Protocol-Specific LUN */
1940: #if 0
1941: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Protocol-Specific LUN\n");
1942: if (subpage != 0x00)
1943: break;
1944: plen = 0x04 + 0x00 + 2;
1945: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1946: len += plen;
1947: #endif
1948: break;
1949: case 0x19:
1950: /* Protocol-Specific Port */
1951: #if 0
1952: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Protocol-Specific Port\n");
1953: if (subpage != 0x00)
1954: break;
1955: plen = 0x04 + 0x00 + 2;
1956: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1957: len += plen;
1958: #endif
1959: break;
1960: case 0x1a:
1961: /* Power Condition */
1962: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Power Condition\n");
1963: if (subpage != 0x00)
1964: break;
1965: plen = 0x0a + 2;
1966: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1967: len += plen;
1968: break;
1969: case 0x1b:
1970: /* Reserved */
1971: break;
1972: case 0x1c:
1973: /* Informational Exceptions Control */
1974: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Informational Exceptions Control\n");
1975: if (subpage != 0x00)
1976: break;
1977:
1978: plen = 0x0a + 2;
1979: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
1980: len += plen;
1981: break;
1982: case 0x1d:
1983: case 0x1e:
1984: case 0x1f:
1985: /* Reserved */
1986: break;
1987: case 0x20:
1988: case 0x21:
1989: case 0x22:
1990: case 0x23:
1991: case 0x24:
1992: case 0x25:
1993: case 0x26:
1994: case 0x27:
1995: case 0x28:
1996: case 0x29:
1997: case 0x2a:
1998: case 0x2b:
1999: case 0x2c:
2000: case 0x2d:
2001: case 0x2e:
2002: case 0x2f:
2003: case 0x30:
2004: case 0x31:
2005: case 0x32:
2006: case 0x33:
2007: case 0x34:
2008: case 0x35:
2009: case 0x36:
2010: case 0x37:
2011: case 0x38:
2012: case 0x39:
2013: case 0x3a:
2014: case 0x3b:
2015: case 0x3c:
2016: case 0x3d:
2017: case 0x3e:
2018: /* Vendor-specific */
2019: break;
2020: case 0x3f:
2021: switch (subpage) {
2022: case 0x00:
2023: /* All mode pages */
2024: for (i = 0x00; i < 0x3e; i ++) {
2025: len += istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0x00, &cp[len], alloc_len);
2026: }
2027: break;
2028: case 0xff:
2029: /* All mode pages and subpages */
2030: for (i = 0x00; i < 0x3e; i ++) {
2031: len += istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0x00, &cp[len], alloc_len);
2032: }
2033: for (i = 0x00; i < 0x3e; i ++) {
2034: len += istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0xff, &cp[len], alloc_len);
2035: }
2036: break;
2037: default:
2038: /* 0x01-0x3e: Reserved */
2039: break;
2040: }
2041: }
2042:
2043: return len;
2044: }
2045:
2046: static int
2047: istgt_lu_disk_scsi_mode_sense6(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, int dbd, int pc, int page, int subpage, uint8_t *data, int alloc_len)
2048: {
2049: uint8_t *cp;
2050: int hlen = 0, len = 0, plen;
2051: int total;
2052: int llbaa = 0;
2053:
2054: data[0] = 0; /* Mode Data Length */
2055: data[1] = 0; /* Medium Type */
2056: data[2] = 0; /* Device-Specific Parameter */
2057: if (spec->lu->readonly) {
2058: BDADD8(&data[2], 1, 7); /* WP */
2059: }
2060: data[3] = 0; /* Block Descripter Length */
2061: hlen = 4;
2062:
2063: cp = &data[4];
2064: if (dbd) { /* Disable Block Descripters */
2065: len = 0;
2066: } else {
2067: if (llbaa) {
2068: /* Number of Blocks */
2069: DSET64(&cp[0], spec->blockcnt);
2070: /* Reserved */
2071: DSET32(&cp[8], 0);
2072: /* Block Length */
2073: DSET32(&cp[12], (uint32_t) spec->blocklen);
2074: len = 16;
2075: } else {
2076: /* Number of Blocks */
2077: if (spec->blockcnt > 0xffffffffULL) {
2078: DSET32(&cp[0], 0xffffffffUL);
2079: } else {
2080: DSET32(&cp[0], (uint32_t) spec->blockcnt);
2081: }
2082: /* Block Length */
2083: DSET32(&cp[4], (uint32_t) spec->blocklen);
2084: len = 8;
2085: }
2086: cp += len;
2087: }
2088: data[3] = len; /* Block Descripter Length */
2089:
2090: plen = istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, page, subpage, &cp[0], alloc_len);
2091: cp += plen;
2092:
2093: total = hlen + len + plen;
2094: data[0] = total - 1; /* Mode Data Length */
2095:
2096: return total;
2097: }
2098:
2099: static int
2100: istgt_lu_disk_scsi_mode_sense10(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, int dbd, int llbaa, int pc, int page, int subpage, uint8_t *data, int alloc_len)
2101: {
2102: uint8_t *cp;
2103: int hlen = 0, len = 0, plen;
2104: int total;
2105:
2106: DSET16(&data[0], 0); /* Mode Data Length */
2107: data[2] = 0; /* Medium Type */
2108: data[3] = 0; /* Device-Specific Parameter */
2109: if (spec->lu->readonly) {
2110: BDADD8(&data[3], 1, 7); /* WP */
2111: }
2112: if (llbaa) {
2113: BDSET8(&data[4], 1, 1); /* Long LBA */
2114: } else {
2115: BDSET8(&data[4], 0, 1); /* Short LBA */
2116: }
2117: data[5] = 0; /* Reserved */
2118: DSET16(&data[6], 0); /* Block Descripter Length */
2119: hlen = 8;
2120:
2121: cp = &data[8];
2122: if (dbd) { /* Disable Block Descripters */
2123: len = 0;
2124: } else {
2125: if (llbaa) {
2126: /* Number of Blocks */
2127: DSET64(&cp[0], spec->blockcnt);
2128: /* Reserved */
2129: DSET32(&cp[8], 0);
2130: /* Block Length */
2131: DSET32(&cp[12], (uint32_t) spec->blocklen);
2132: len = 16;
2133: } else {
2134: /* Number of Blocks */
2135: if (spec->blockcnt > 0xffffffffULL) {
2136: DSET32(&cp[0], 0xffffffffUL);
2137: } else {
2138: DSET32(&cp[0], (uint32_t) spec->blockcnt);
2139: }
2140: /* Block Length */
2141: DSET32(&cp[4], (uint32_t) spec->blocklen);
2142: len = 8;
2143: }
2144: cp += len;
2145: }
2146: DSET16(&data[6], len); /* Block Descripter Length */
2147:
2148: plen = istgt_lu_disk_scsi_mode_sense_page(spec, conn, cdb, pc, page, subpage, &cp[0], alloc_len);
2149: cp += plen;
2150:
2151: total = hlen + len + plen;
2152: DSET16(&data[0], total - 2); /* Mode Data Length */
2153:
2154: return total;
2155: }
2156:
2157: static int
2158: istgt_lu_disk_transfer_data(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint8_t *buf, size_t bufsize, size_t len)
2159: {
2160: int rc;
2161:
2162: if (lu_cmd->lu->queue_depth == 0) {
2163: if (len > bufsize) {
2164: ISTGT_ERRLOG("bufsize(%d) too small\n", bufsize);
2165: return -1;
2166: }
2167: rc = istgt_iscsi_transfer_out(conn, lu_cmd, buf, bufsize, len);
2168: if (rc < 0) {
2169: ISTGT_ERRLOG("iscsi_transfer_out()\n");
2170: return -1;
2171: }
2172: }
2173: return 0;
2174: }
2175:
2176: static int
2177: istgt_lu_disk_scsi_mode_select_page(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, int pf, int sp, uint8_t *data, size_t len)
2178: {
2179: int ps, spf, page, subpage;
2180: int hlen, plen;
2181: int rc;
2182:
2183: if (pf == 0) {
2184: /* vendor specific */
2185: return 0;
2186: }
2187:
2188: if (len < 1)
2189: return 0;
2190: ps = BGET8(&data[0], 7);
2191: spf = BGET8(&data[0], 6);
2192: page = data[0] & 0x3f;
2193: if (spf) {
2194: /* Sub_page mode page format */
2195: hlen = 4;
2196: if (len < hlen)
2197: return 0;
2198: subpage = data[1];
2199:
2200: plen = DGET16(&data[2]);
2201: } else {
2202: /* Page_0 mode page format */
2203: hlen = 2;
2204: if (len < hlen)
2205: return 0;
2206: subpage = 0;
2207: plen = data[1];
2208: }
2209: plen += hlen;
2210: if (len < plen)
2211: return 0;
2212:
2213: #if 0
2214: printf("ps=%d, page=%2.2x, subpage=%2.2x\n", ps, page, subpage);
2215: #endif
2216: switch (page) {
2217: case 0x08:
2218: /* Caching */
2219: {
2220: int wce, rcd;
2221:
2222: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Caching\n");
2223: if (subpage != 0x00)
2224: break;
2225: if (plen != 0x12 + hlen) {
2226: /* unknown format */
2227: break;
2228: }
2229: wce = BGET8(&data[2], 2); /* WCE */
2230: rcd = BGET8(&data[2], 0); /* RCD */
2231:
2232: {
2233: int fd;
2234: fd = spec->fd;
2235: rc = fcntl(fd , F_GETFL, 0);
2236: if (rc != -1) {
2237: if (wce) {
2238: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Writeback cache enable\n");
2239: rc = fcntl(fd, F_SETFL, (rc & ~O_FSYNC));
2240: spec->write_cache = 1;
2241: } else {
2242: rc = fcntl(fd, F_SETFL, (rc | O_FSYNC));
2243: spec->write_cache = 0;
2244: }
2245: if (rc == -1) {
2246: /* XXX */
2247: //ISTGT_ERRLOG("fcntl(F_SETFL) failed\n");
2248: }
2249: }
2250: }
2251: if (rcd) {
2252: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Read cache disable\n");
2253: spec->read_cache = 0;
2254: } else {
2255: spec->read_cache = 1;
2256: }
2257: }
2258: break;
2259: default:
2260: /* not supported */
2261: break;
2262: }
2263:
2264: len -= plen;
2265: if (len != 0) {
2266: rc = istgt_lu_disk_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[plen], len);
2267: if (rc < 0) {
2268: return rc;
2269: }
2270: }
2271: return 0;
2272: }
2273:
2274: #if 0
2275: static int
2276: istgt_lu_disk_scsi_request_sense(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, int desc, uint8_t *data, int alloc_len)
2277: {
2278: int len = 0, plen;
2279:
2280: if (alloc_len < 18) {
2281: ISTGT_ERRLOG("alloc_len(%d) too small\n", alloc_len);
2282: return -1;
2283: }
2284:
2285: /* XXX TODO: fix */
2286: if (desc == 0) {
2287: /* fixed format */
2288: /* NO ADDITIONAL SENSE INFORMATION */
2289: /* BUILD_SENSE(NO_SENSE, 0x00, 0x00); */
2290:
2291: /* VALID(7) RESPONSE CODE(6-0) */
2292: BDSET8(&data[0], 0, 7);
2293: BDADD8W(&data[0], 0x70, 6, 7);
2294: /* Obsolete */
2295: data[1] = 0;
2296: /* FILEMARK(7) EOM(6) ILI(5) SENSE KEY(3-0) */
2297: BDSET8W(&data[2], ISTGT_SCSI_SENSE_NO_SENSE, 3, 4);
2298: /* INFORMATION */
2299: memset(&data[3], 0, 4);
2300: /* ADDITIONAL SENSE LENGTH */
2301: data[7] = 0;
2302: len = 8;
2303:
2304: /* COMMAND-SPECIFIC INFORMATION */
2305: memset(&data[8], 0, 4);
2306: /* ADDITIONAL SENSE CODE */
2307: data[12] = 0x00;
2308: /* ADDITIONAL SENSE CODE QUALIFIER */
2309: data[13] = 0x00;
2310: /* FIELD REPLACEABLE UNIT CODE */
2311: data[14] = 0;
2312: /* SKSV(7) SENSE KEY SPECIFIC(6-0,7-0,7-0) */
2313: data[15] = 0;
2314: data[16] = 0;
2315: data[17] = 0;
2316: plen = 18 - len;
2317:
2318: /* ADDITIONAL SENSE LENGTH */
2319: data[7] = plen;
2320: } else {
2321: /* descriptor format */
2322: /* NO ADDITIONAL SENSE INFORMATION */
2323: /* BUILD_SENSE(NO_SENSE, 0x00, 0x00); */
2324:
2325: /* RESPONSE CODE(6-0) */
2326: BDSET8W(&data[0], 0x72, 6, 7);
2327: /* SENSE KEY(3-0) */
2328: BDSET8W(&data[1], ISTGT_SCSI_SENSE_NO_SENSE, 3, 4);
2329: /* ADDITIONAL SENSE CODE */
2330: data[2] = 0x00;
2331: /* ADDITIONAL SENSE CODE QUALIFIER */
2332: data[3] = 0x00;
2333: /* Reserved */
2334: data[4] = 0;
2335: data[5] = 0;
2336: data[6] = 0;
2337: /* ADDITIONAL SENSE LENGTH */
2338: data[7] = 0;
2339: len = 8;
2340:
2341: /* Sense data descriptor(s) */
2342: plen = 8 - len;
2343:
2344: /* ADDITIONAL SENSE LENGTH */
2345: data[7] = plen;
2346: }
2347: return len;
2348: }
2349: #endif
2350:
2351: static int
2352: istgt_lu_disk_scsi_report_target_port_groups(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, uint8_t *data, int alloc_len)
2353: {
2354: ISTGT_Ptr istgt;
2355: ISTGT_LU_Ptr lu;
2356: uint8_t *cp;
2357: uint8_t *cp_count;
2358: int hlen = 0, len = 0, plen;
2359: int total;
2360: int pg_tag;
2361: int nports;
2362: int i, j;
2363:
2364: if (alloc_len < 0xfff) {
2365: return -1;
2366: }
2367:
2368: istgt = conn->istgt;
2369: lu = spec->lu;
2370:
2371: /* RETURN DATA LENGTH */
2372: DSET32(&data[0], 0);
2373: hlen = 4;
2374:
2375: MTX_LOCK(&istgt->mutex);
2376: for (i = 0; i < lu->maxmap; i++) {
2377: pg_tag = lu->map[i].pg_tag;
2378: /* skip same pg_tag */
2379: for (j = 0; j < i; j++) {
2380: if (lu->map[j].pg_tag == pg_tag) {
2381: goto skip_pg_tag;
2382: }
2383: }
2384:
2385: /* Target port group descriptor N */
2386: cp = &data[hlen + len];
2387:
2388: /* PREF(7) ASYMMETRIC ACCESS STATE(3-0) */
2389: cp[0] = 0;
2390: BDSET8(&cp[0], 1, 7); /* PREF */
2391: switch (lu->map[j].pg_aas & 0x0f) {
2392: case AAS_ACTIVE_OPTIMIZED:
2393: BDADD8W(&cp[0], AAS_ACTIVE_OPTIMIZED, 3, 4);
2394: break;
2395: case AAS_ACTIVE_NON_OPTIMIZED:
2396: BDADD8W(&cp[0], AAS_ACTIVE_NON_OPTIMIZED, 3, 4);
2397: break;
2398: case AAS_STANDBY:
2399: BDADD8W(&cp[0], AAS_STANDBY, 3, 4);
2400: break;
2401: case AAS_UNAVAILABLE:
2402: BDADD8W(&cp[0], AAS_UNAVAILABLE, 3, 4);
2403: break;
2404: case AAS_TRANSITIONING:
2405: BDADD8W(&cp[0], AAS_TRANSITIONING, 3, 4);
2406: break;
2407: default:
2408: ISTGT_ERRLOG("unsupported AAS\n");
2409: break;
2410: }
2411: /* T_SUP(7) U_SUP(3) S_SUP(2) S_SUP AN_SUP(1) AO_SUP(0) */
2412: cp[1] = 0;
2413: //BDADD8(&cp[1], 1, 7); /* transitioning supported */
2414: //BDADD8(&cp[1], 1, 3); /* unavailable supported */
2415: //BDADD8(&cp[1], 1, 2); /* standby supported */
2416: BDADD8(&cp[1], 1, 1); /* active/non-optimized supported */
2417: BDADD8(&cp[1], 1, 0); /* active/optimized supported */
2418: /* TARGET PORT GROUP */
2419: DSET16(&cp[2], pg_tag);
2420: /* Reserved */
2421: cp[4] = 0;
2422: /* STATUS CODE */
2423: if (lu->map[j].pg_aas & AAS_STATUS_IMPLICIT) {
2424: cp[5] = 0x02; /* by implicit */
2425: } else if (lu->map[j].pg_aas & AAS_STATUS_STPG) {
2426: cp[5] = 0x01; /* by SET TARGET PORT GROUPS */
2427: } else {
2428: cp[5] = 0; /* No status */
2429: }
2430: /* Vendor specific */
2431: cp[6] = 0;
2432: /* TARGET PORT COUNT */
2433: cp[7] = 0;
2434: cp_count = &cp[7];
2435: plen = 8;
2436: len += plen;
2437:
2438: nports = 0;
2439: for (j = 0; j < istgt->nportal; j ++) {
2440: if (istgt->portal[j].tag != pg_tag)
2441: continue;
2442: /* Target port descriptor(s) */
2443: cp = &data[hlen + len];
2444: /* Obsolete */
2445: DSET16(&cp[0], 0);
2446: /* RELATIVE TARGET PORT IDENTIFIER */
2447: DSET16(&cp[2], (uint16_t) (1 + istgt->portal[j].idx));
2448: plen = 4;
2449: len += plen;
2450: nports++;
2451: }
2452:
2453: if (nports > 0xff) {
2454: ISTGT_ERRLOG("too many portals in portal group\n");
2455: MTX_UNLOCK(&istgt->mutex);
2456: return -1;
2457: }
2458:
2459: /* TARGET PORT COUNT */
2460: cp_count[0] = nports;
2461:
2462: skip_pg_tag:
2463: ;
2464: }
2465: MTX_UNLOCK(&istgt->mutex);
2466:
2467: total = hlen + len;
2468: if (total > alloc_len) {
2469: ISTGT_ERRLOG("alloc_len(%d) too small\n", alloc_len);
2470: return -1;
2471: }
2472:
2473: /* RETURN DATA LENGTH */
2474: DSET32(&data[0], total - 4);
2475:
2476: return total;
2477: }
2478:
2479: static int
2480: istgt_lu_disk_scsi_set_target_port_groups(ISTGT_LU_DISK *spec, CONN_Ptr conn, uint8_t *cdb, uint8_t *data, int len)
2481: {
2482: ISTGT_LU_Ptr lu;
2483: int pg_tag;
2484: int aas;
2485: int pg;
2486: int rc;
2487: int i;
2488:
2489: if (len < 4) {
2490: return -1;
2491: }
2492:
2493: lu = spec->lu;
2494:
2495: aas = BGET8W(&data[0], 3, 4);
2496: pg = DGET16(&data[2]);
2497:
2498: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AAS=0x%x, PG=0x%4.4x\n", aas, pg);
2499:
2500: for (i = 0; i < lu->maxmap; i++) {
2501: pg_tag = lu->map[i].pg_tag;
2502: if (pg != pg_tag)
2503: continue;
2504:
2505: switch (aas) {
2506: case AAS_ACTIVE_OPTIMIZED:
2507: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Active/optimized\n");
2508: break;
2509: case AAS_ACTIVE_NON_OPTIMIZED:
2510: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Active/non-optimized\n");
2511: break;
2512: #if 0
2513: case AAS_STANDBY:
2514: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Standby\n");
2515: break;
2516: case AAS_UNAVAILABLE:
2517: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Unavailable\n");
2518: break;
2519: #endif
2520: case AAS_TRANSITIONING:
2521: return -1;
2522: default:
2523: ISTGT_ERRLOG("unsupported AAS 0x%x\n", aas);
2524: return -1;
2525: }
2526: lu->map[i].pg_aas = aas;
2527: lu->map[i].pg_aas |= AAS_STATUS_STPG;
2528: }
2529:
2530: len -=4;
2531: if (len != 0) {
2532: rc = istgt_lu_disk_scsi_set_target_port_groups(spec, conn, cdb, data, len);
2533: if (rc < 0) {
2534: return rc;
2535: }
2536: }
2537: return 0;
2538: }
2539:
2540: static void
2541: istgt_lu_disk_free_pr_key(ISTGT_LU_PR_KEY *prkey)
2542: {
2543: int i;
2544:
2545: if (prkey == NULL)
2546: return;
2547: xfree(prkey->registered_initiator_port);
2548: prkey->registered_initiator_port = NULL;
2549: xfree(prkey->registered_target_port);
2550: prkey->registered_target_port = NULL;
2551: prkey->pg_idx = 0;
2552: prkey->pg_tag = 0;
2553: for (i = 0; i < prkey->ninitiator_ports; i++) {
2554: xfree(prkey->initiator_ports[i]);
2555: prkey->initiator_ports[i] = NULL;
2556: }
2557: xfree(prkey->initiator_ports);
2558: prkey->initiator_ports = NULL;
2559: prkey->all_tpg = 0;
2560: }
2561:
2562: static ISTGT_LU_PR_KEY *
2563: istgt_lu_disk_find_pr_key(ISTGT_LU_DISK *spec, const char *initiator_port, const char *target_port, uint64_t key)
2564: {
2565: ISTGT_LU_PR_KEY *prkey;
2566: int i;
2567:
2568: /* return pointer if I_T nexus is registered */
2569: #ifdef ISTGT_TRACE_DISK
2570: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2571: "find prkey=0x%16.16"PRIx64", port=%s\n",
2572: key, ((initiator_port != NULL) ? initiator_port : "N/A"));
2573: #endif /* ISTGT_TRACE_DISK */
2574:
2575: if (initiator_port == NULL)
2576: return NULL;
2577: for (i = 0; i < spec->npr_keys; i++) {
2578: prkey = &spec->pr_keys[i];
2579: if (prkey == NULL)
2580: continue;
2581: #ifdef ISTGT_TRACE_DISK
2582: if (key != 0) {
2583: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2584: "prkey=0x%16.16"PRIx64"\n",
2585: prkey->key);
2586: }
2587: #endif /* ISTGT_TRACE_DISK */
2588: if (key != 0 && prkey->key != key)
2589: continue;
2590: #ifdef ISTGT_TRACE_DISK
2591: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "pript=%s, ipt=%s\n",
2592: prkey->registered_initiator_port,
2593: initiator_port);
2594: #endif /* ISTGT_TRACE_DISK */
2595: if (strcmp(prkey->registered_initiator_port,
2596: initiator_port) == 0) {
2597: #ifdef ISTGT_TRACE_DISK
2598: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "prtpt=%s, tpt=%s\n",
2599: prkey->registered_target_port,
2600: target_port);
2601: #endif /* ISTGT_TRACE_DISK */
2602: if (prkey->all_tpg != 0
2603: || target_port == NULL
2604: || strcmp(prkey->registered_target_port,
2605: target_port) == 0) {
2606: return prkey;
2607: }
2608: }
2609: }
2610: return NULL;
2611: }
2612:
2613: static int
2614: istgt_lu_disk_remove_other_pr_key(ISTGT_LU_DISK *spec, CONN_Ptr conn, const char *initiator_port, const char *target_port, uint64_t key)
2615: {
2616: ISTGT_LU_PR_KEY *prkey, *prkey1, *prkey2;
2617: int i, j;
2618:
2619: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2620: "remove other prkey=0x%16.16"PRIx64", port=%s\n",
2621: key, ((initiator_port != NULL) ? initiator_port : "N/A"));
2622:
2623: for (i = 0; i < spec->npr_keys; i++) {
2624: prkey = &spec->pr_keys[i];
2625: if (prkey == NULL)
2626: continue;
2627: if (key == 0 || prkey->key == key)
2628: continue;
2629: if (initiator_port == NULL ||
2630: strcasecmp(prkey->registered_initiator_port,
2631: initiator_port) == 0)
2632: continue;
2633: if (prkey->all_tpg != 0
2634: || target_port == NULL
2635: || strcasecmp(prkey->registered_target_port,
2636: target_port) == 0)
2637: continue;
2638:
2639: istgt_lu_disk_free_pr_key(prkey);
2640: for (j = i; j < spec->npr_keys - 1; j++) {
2641: prkey1 = &spec->pr_keys[j];
2642: prkey2 = &spec->pr_keys[j+1];
2643:
2644: prkey1->registered_initiator_port
2645: = prkey2->registered_initiator_port;
2646: prkey2->registered_initiator_port = NULL;
2647: prkey1->registered_target_port
2648: = prkey2->registered_target_port;
2649: prkey2->registered_target_port = NULL;
2650: prkey1->pg_idx = prkey2->pg_idx;
2651: prkey2->pg_idx = 0;
2652: prkey1->pg_tag = prkey2->pg_tag;
2653: prkey2->pg_tag = 0;
2654: prkey1->ninitiator_ports = prkey2->ninitiator_ports;
2655: prkey2->ninitiator_ports = 0;
2656: prkey1->initiator_ports = prkey2->initiator_ports;
2657: prkey2->initiator_ports = NULL;
2658: prkey1->all_tpg = prkey2->all_tpg;
2659: prkey2->all_tpg = 0;
2660: }
2661: spec->npr_keys--;
2662: }
2663: return 0;
2664: }
2665:
2666: static int
2667: istgt_lu_disk_remove_pr_key(ISTGT_LU_DISK *spec, CONN_Ptr conn, const char *initiator_port, const char *target_port, uint64_t key)
2668: {
2669: ISTGT_LU_PR_KEY *prkey, *prkey1, *prkey2;
2670: int i, j;
2671:
2672: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2673: "remove prkey=0x%16.16"PRIx64", port=%s\n",
2674: key, ((initiator_port != NULL) ? initiator_port : "N/A"));
2675:
2676: for (i = 0; i < spec->npr_keys; i++) {
2677: prkey = &spec->pr_keys[i];
2678: if (prkey == NULL)
2679: continue;
2680: if (key != 0 && prkey->key != key)
2681: continue;
2682: if (initiator_port != NULL
2683: && strcasecmp(prkey->registered_initiator_port,
2684: initiator_port) != 0)
2685: continue;
2686: if (prkey->all_tpg == 0
2687: && target_port != NULL
2688: && strcasecmp(prkey->registered_target_port,
2689: target_port) != 0)
2690: continue;
2691:
2692: istgt_lu_disk_free_pr_key(prkey);
2693: for (j = i; j < spec->npr_keys - 1; j++) {
2694: prkey1 = &spec->pr_keys[j];
2695: prkey2 = &spec->pr_keys[j+1];
2696:
2697: prkey1->registered_initiator_port
2698: = prkey2->registered_initiator_port;
2699: prkey2->registered_initiator_port = NULL;
2700: prkey1->registered_target_port
2701: = prkey2->registered_target_port;
2702: prkey2->registered_target_port = NULL;
2703: prkey1->pg_idx = prkey2->pg_idx;
2704: prkey2->pg_idx = 0;
2705: prkey1->pg_tag = prkey2->pg_tag;
2706: prkey2->pg_tag = 0;
2707: prkey1->ninitiator_ports = prkey2->ninitiator_ports;
2708: prkey2->ninitiator_ports = 0;
2709: prkey1->initiator_ports = prkey2->initiator_ports;
2710: prkey2->initiator_ports = NULL;
2711: prkey1->all_tpg = prkey2->all_tpg;
2712: prkey2->all_tpg = 0;
2713: }
2714: spec->npr_keys--;
2715: }
2716: return 0;
2717: }
2718:
2719: static int
2720: istgt_lu_parse_transport_id(char **tid, uint8_t *data, int len)
2721: {
2722: int fc, pi;
2723: int hlen, plen;
2724:
2725: if (tid == NULL)
2726: return -1;
2727: if (data == NULL)
2728: return -1;
2729:
2730: fc = BGET8W(&data[0], 7, 2);
2731: pi = BGET8W(&data[0], 3, 4);
2732: if (fc != 0) {
2733: ISTGT_ERRLOG("FORMAT CODE != 0\n");
2734: return -1;
2735: }
2736: if (pi != SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME) {
2737: ISTGT_ERRLOG("PROTOCOL IDENTIFIER != ISCSI\n");
2738: return -1;
2739: }
2740:
2741: /* PROTOCOL IDENTIFIER = 0x05 */
2742: hlen = 4;
2743: /* ADDITIONAL LENGTH */
2744: plen = DGET16(&data[2]);
2745: if (plen > len) {
2746: ISTGT_ERRLOG("invalid length %d (expected %d)\n",
2747: plen, len);
2748: return -1;
2749: }
2750: if (plen > MAX_ISCSI_NAME) {
2751: ISTGT_ERRLOG("invalid length %d (expected %d)\n",
2752: plen, MAX_ISCSI_NAME);
2753: return -1;
2754: }
2755:
2756: /* ISCSI NAME */
2757: *tid = xmalloc(plen + 1);
2758: memcpy(*tid, data, plen);
2759: (*tid)[plen] = '\0';
2760: strlwr(*tid);
2761:
2762: return hlen + plen;
2763: }
2764:
2765: static int
2766: istgt_lu_disk_scsi_persistent_reserve_in(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int sa, uint8_t *data, int alloc_len)
2767: {
2768: ISTGT_LU_PR_KEY *prkey;
2769: uint8_t *sense_data;
2770: int *sense_len;
2771: uint8_t *cp;
2772: int hlen = 0, len = 0, plen;
2773: int total;
2774: int i;
2775:
2776: sense_data = lu_cmd->sense_data;
2777: sense_len = &lu_cmd->sense_data_len;
2778: *sense_len = 0;
2779:
2780: cp = &data[hlen + len];
2781: total = 0;
2782: switch (sa) {
2783: case 0x00: /* READ KEYS */
2784: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ KEYS\n");
2785:
2786: /* PRGENERATION */
2787: DSET32(&data[0], spec->pr_generation);
2788: /* ADDITIONAL LENGTH */
2789: DSET32(&data[4], 0);
2790: hlen = 8;
2791:
2792: for (i = 0; i < spec->npr_keys; i++) {
2793: prkey = &spec->pr_keys[i];
2794: /* reservation key N */
2795: cp = &data[hlen + len];
2796: DSET64(&cp[0], prkey->key);
2797: len += 8;
2798: }
2799: total = hlen + len;
2800: /* ADDITIONAL LENGTH */
2801: DSET32(&data[4], total - hlen);
2802: break;
2803:
2804: case 0x01: /* READ RESERVATION */
2805: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ RESERVATION\n");
2806:
2807: /* PRGENERATION */
2808: DSET32(&data[0], spec->pr_generation);
2809: /* ADDITIONAL LENGTH */
2810: DSET32(&data[4], 0);
2811: hlen = 8;
2812:
2813: if (spec->rsv_key != 0) {
2814: /* RESERVATION KEY */
2815: DSET64(&data[8], spec->rsv_key);
2816: /* Obsolete */
2817: DSET32(&data[16], 0);
2818: /* Reserved */
2819: data[20] = 0;
2820: /* SCOPE(7-4) TYPE(3-0) */
2821: BDSET8W(&data[21], spec->rsv_scope, 7, 4);
2822: BDADD8W(&data[21], spec->rsv_type, 3, 4);
2823: /* Obsolete */
2824: DSET16(&data[22], 0);
2825: len = 24 - hlen;
2826: }
2827:
2828: total = hlen + len;
2829: /* ADDITIONAL LENGTH */
2830: DSET32(&data[4], total - hlen);
2831: break;
2832:
2833: case 0x02: /* REPORT CAPABILITIES */
2834: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REPORT CAPABILITIES\n");
2835:
2836: /* LENGTH */
2837: DSET16(&data[0], 0x0008);
2838: /* CRH(4) SIP_C(3) ATP_C(2) PTPL_C(0) */
2839: data[2] = 0;
2840: //BDADD8(&data[2], 1, 4); /* Compatible Reservation Handling */
2841: BDADD8(&data[2], 1, 3); /* Specify Initiator Ports Capable */
2842: BDADD8(&data[2], 1, 2); /* All Target Ports Capable */
2843: //BDADD8(&data[2], 1, 0); /* Persist Through Power Loss Capable */
2844: /* TMV(7) PTPL_A(0) */
2845: data[3] = 0;
2846: //BDADD8(&data[2], 1, 7); /* Type Mask Valid */
2847: //BDADD8(&data[2], 1, 0); /* Persist Through Power Loss Activated */
2848: /* PERSISTENT RESERVATION TYPE MASK */
2849: DSET16(&data[4], 0);
2850: /* Reserved */
2851: DSET16(&data[6], 0);
2852: hlen = 8;
2853:
2854: total = hlen + len;
2855: break;
2856:
2857: case 0x03: /* READ FULL STATUS */
2858: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ FULL STATUS\n");
2859:
2860: /* PRGENERATION */
2861: DSET32(&data[0], spec->pr_generation);
2862: /* ADDITIONAL LENGTH */
2863: DSET32(&data[4], 0);
2864: hlen = 8;
2865:
2866: for (i = 0; i < spec->npr_keys; i++) {
2867: prkey = &spec->pr_keys[i];
2868: /* Full status descriptors N */
2869: cp = &data[hlen + len];
2870:
2871: /* RESERVATION KEY */
2872: DSET64(&cp[0], prkey->key);
2873: /* Reserved */
2874: DSET64(&cp[8], 0);
2875: /* ALL_TG_PT(1) R_HOLDER(0) */
2876: cp[12] = 0;
2877: if (prkey->all_tpg) {
2878: BDADD8(&cp[12], 1, 1);
2879: }
2880: /* SCOPE(7-4) TYPE(3-0) */
2881: cp[13] = 0;
2882: if (spec->rsv_key != 0) {
2883: if (spec->rsv_key == prkey->key) {
2884: BDADD8(&cp[12], 1, 0);
2885: BDADD8W(&cp[13], spec->rsv_scope & 0x0f, 7, 4);
2886: BDADD8W(&cp[13], spec->rsv_type & 0x0f, 3, 4);
2887: }
2888: }
2889: /* Reserved */
2890: DSET32(&cp[14], 0);
2891: /* RELATIVE TARGET PORT IDENTIFIER */
2892: DSET16(&cp[18], 1 + prkey->pg_idx);
2893: /* ADDITIONAL DESCRIPTOR LENGTH */
2894: DSET32(&cp[20], 0);
2895:
2896: /* TRANSPORTID */
2897: plen = snprintf((char *) &cp[24], MAX_INITIATOR_NAME,
2898: "%s",
2899: prkey->registered_initiator_port);
2900:
2901: /* ADDITIONAL DESCRIPTOR LENGTH */
2902: DSET32(&cp[20], plen);
2903: len += 24 + plen;
2904: }
2905:
2906: total = hlen + len;
2907: /* ADDITIONAL LENGTH */
2908: DSET32(&data[4], total - hlen);
2909: break;
2910:
2911: default:
2912: ISTGT_ERRLOG("unsupported service action 0x%x\n", sa);
2913: /* INVALID FIELD IN CDB */
2914: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
2915: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
2916: return -1;
2917: }
2918:
2919: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
2920: return total;
2921: }
2922:
2923: static int
2924: istgt_lu_disk_scsi_persistent_reserve_out(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int sa, int scope, int type, uint8_t *data, int len)
2925: {
2926: ISTGT_LU_PR_KEY *prkey;
2927: uint8_t *sense_data;
2928: int *sense_len;
2929: char *old_rsv_port = NULL;
2930: char **initiator_ports;
2931: int maxports, nports;
2932: int plen, total;
2933: uint64_t rkey;
2934: uint64_t sarkey;
2935: int spec_i_pt, all_tg_pt, aptpl;
2936: int task_abort;
2937: int idx;
2938: int rc;
2939: int i;
2940:
2941: sense_data = lu_cmd->sense_data;
2942: sense_len = &lu_cmd->sense_data_len;
2943: *sense_len = 0;
2944:
2945: rkey = DGET64(&data[0]);
2946: sarkey = DGET64(&data[8]);
2947: spec_i_pt = BGET8(&data[20], 3);
2948: all_tg_pt = BGET8(&data[20], 2);
2949: aptpl = BGET8(&data[20], 0);
2950:
2951: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2952: "sa=0x%2.2x, key=0x%16.16"PRIx64", sakey=0x%16.16"PRIx64
2953: ", ipt=%d, tgpt=%d, aptpl=%d\n",
2954: sa, rkey, sarkey, spec_i_pt, all_tg_pt, aptpl);
2955: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "port=%s\n",
2956: conn->initiator_port);
2957:
2958: switch (sa) {
2959: case 0x00: /* REGISTER */
2960: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REGISTER\n");
2961:
2962: if (aptpl != 0) {
2963: /* Activate Persist Through Power Loss */
2964: ISTGT_ERRLOG("unsupport Activate Persist Through Power Loss\n");
2965: /* INVALID FIELD IN PARAMETER LIST */
2966: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
2967: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
2968: return -1;
2969: }
2970: /* lost reservations if daemon restart */
2971:
2972: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
2973: conn->target_port, 0);
2974: if (prkey == NULL) {
2975: /* unregistered port */
2976: if (rkey != 0) {
2977: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
2978: return -1;
2979: }
2980: if (sarkey != 0) {
2981: /* XXX check spec_i_pt */
2982: }
2983: } else {
2984: /* registered port */
2985: if (spec_i_pt) {
2986: /* INVALID FIELD IN CDB */
2987: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
2988: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
2989: return -1;
2990: }
2991:
2992: prkey = istgt_lu_disk_find_pr_key(spec,
2993: conn->initiator_port, conn->target_port, rkey);
2994: if (prkey == NULL) {
2995: /* not found key */
2996: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
2997: return -1;
2998: }
2999: /* remove existing keys */
3000: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3001: conn->initiator_port, conn->target_port, rkey);
3002: if (rc < 0) {
3003: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3004: /* INTERNAL TARGET FAILURE */
3005: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3006: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3007: return -1;
3008: }
3009: }
3010:
3011: /* unregister? */
3012: if (sarkey == 0) {
3013: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3014: return 0;
3015: }
3016:
3017: goto do_register;
3018:
3019: case 0x01: /* RESERVE */
3020: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RESERVE\n");
3021:
3022: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3023: conn->target_port, 0);
3024: if (prkey == NULL) {
3025: /* unregistered port */
3026: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3027: return -1;
3028: }
3029:
3030: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3031: conn->target_port, rkey);
3032: if (prkey == NULL) {
3033: /* not found key */
3034: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3035: return -1;
3036: }
3037: if (spec->rsv_key == 0) {
3038: /* no reservation */
3039: } else {
3040: if (prkey->key != spec->rsv_key) {
3041: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3042: return -1;
3043: }
3044: if (strcasecmp(spec->rsv_port, conn->initiator_port) != 0) {
3045: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3046: return -1;
3047: }
3048: if (g_trace_flag) {
3049: ISTGT_WARNLOG("LU%d: duplicate reserve\n", spec->lu->num);
3050: }
3051: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3052: return 0;
3053: }
3054:
3055: if (scope != 0x00) { // !LU_SCOPE
3056: /* INVALID FIELD IN CDB */
3057: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3058: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3059: return -1;
3060: }
3061: if (type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE
3062: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS
3063: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY
3064: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY
3065: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS
3066: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS) {
3067: ISTGT_ERRLOG("unsupported type 0x%x\n", type);
3068: /* INVALID FIELD IN CDB */
3069: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3070: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3071: return -1;
3072: }
3073:
3074: /* establish reservation by key */
3075: xfree(spec->rsv_port);
3076: spec->rsv_port = xstrdup(conn->initiator_port);
3077: strlwr(spec->rsv_port);
3078: spec->rsv_key = rkey;
3079: spec->rsv_scope = scope;
3080: spec->rsv_type = type;
3081:
3082: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3083: "LU%d: reserved (scope=%d, type=%d) by key=0x%16.16"
3084: PRIx64"\n",
3085: spec->lu->num, scope, type, rkey);
3086: break;
3087:
3088: case 0x02: /* RELEASE */
3089: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RELEASE\n");
3090:
3091: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3092: conn->target_port, 0);
3093: if (prkey == NULL) {
3094: /* unregistered port */
3095: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3096: return -1;
3097: }
3098:
3099: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3100: conn->target_port, rkey);
3101: if (prkey == NULL) {
3102: /* not found key */
3103: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3104: return -1;
3105: }
3106: if (spec->rsv_key == 0) {
3107: /* no reservation */
3108: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3109: return 0;
3110: }
3111: if (prkey->key != spec->rsv_key) {
3112: /* INVALID RELEASE OF PERSISTENT RESERVATION */
3113: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x04);
3114: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3115: return -1;
3116: }
3117: if (strcasecmp(spec->rsv_port, conn->initiator_port) != 0) {
3118: /* INVALID RELEASE OF PERSISTENT RESERVATION */
3119: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x04);
3120: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3121: return -1;
3122: }
3123:
3124: if (scope != 0x00) { // !LU_SCOPE
3125: /* INVALID FIELD IN CDB */
3126: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3127: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3128: return -1;
3129: }
3130: if (type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE
3131: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS
3132: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY
3133: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY
3134: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS
3135: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS) {
3136: ISTGT_ERRLOG("unsupported type 0x%x\n", type);
3137: /* INVALID FIELD IN CDB */
3138: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3139: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3140: return -1;
3141: }
3142: if (spec->rsv_scope != scope || spec->rsv_type != type) {
3143: /* INVALID RELEASE OF PERSISTENT RESERVATION */
3144: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x04);
3145: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3146: return -1;
3147: }
3148:
3149: /* release reservation by key */
3150: xfree(spec->rsv_port);
3151: spec->rsv_port = NULL;
3152: spec->rsv_key = 0;
3153: spec->rsv_scope = 0;
3154: spec->rsv_type = 0;
3155:
3156: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3157: "LU%d: released (scope=%d, type=%d) by key=0x%16.16"
3158: PRIx64"\n",
3159: spec->lu->num, scope, type, rkey);
3160: break;
3161:
3162: case 0x03: /* CLEAR */
3163: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "CLEAR\n");
3164:
3165: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3166: conn->target_port, 0);
3167: if (prkey == NULL) {
3168: /* unregistered port */
3169: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3170: return -1;
3171: }
3172:
3173: /* release reservation */
3174: xfree(spec->rsv_port);
3175: spec->rsv_port = NULL;
3176: spec->rsv_key = 0;
3177: spec->rsv_scope = 0;
3178: spec->rsv_type = 0;
3179:
3180: /* remove all registrations */
3181: for (i = 0; i < spec->npr_keys; i++) {
3182: prkey = &spec->pr_keys[i];
3183: istgt_lu_disk_free_pr_key(prkey);
3184: }
3185: spec->npr_keys = 0;
3186: break;
3187:
3188: case 0x04: /* PREEMPT */
3189: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "PREEMPT\n");
3190:
3191: task_abort = 0;
3192: do_preempt:
3193: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3194: conn->target_port, 0);
3195: if (prkey == NULL) {
3196: /* unregistered port */
3197: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
3198: return -1;
3199: }
3200:
3201: if (spec->rsv_key == 0) {
3202: /* no reservation */
3203: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "no reservation\n");
3204: /* remove registration */
3205: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3206: NULL, NULL, sarkey);
3207: if (rc < 0) {
3208: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3209: /* INTERNAL TARGET FAILURE */
3210: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3211: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3212: return -1;
3213: }
3214:
3215: /* update generation */
3216: spec->pr_generation++;
3217:
3218: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3219: break;
3220: }
3221: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "rsv_key=0x%16.16"PRIx64"\n",
3222: spec->rsv_key);
3223:
3224: if (spec->rsv_type == ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS
3225: || spec->rsv_type == ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS) {
3226: if (sarkey != 0) {
3227: /* remove registration */
3228: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3229: NULL, NULL, sarkey);
3230: if (rc < 0) {
3231: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3232: /* INTERNAL TARGET FAILURE */
3233: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3234: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3235: return -1;
3236: }
3237:
3238: /* update generation */
3239: spec->pr_generation++;
3240:
3241: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3242: break;
3243: } else {
3244: /* remove other registrations */
3245: rc = istgt_lu_disk_remove_other_pr_key(spec, conn,
3246: conn->initiator_port,
3247: conn->target_port,
3248: rkey);
3249: if (rc < 0) {
3250: ISTGT_ERRLOG("lu_disk_remove_other_pr_key() failed\n");
3251: /* INTERNAL TARGET FAILURE */
3252: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3253: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3254: return -1;
3255: }
3256:
3257: if (scope != 0x00) { // !LU_SCOPE
3258: /* INVALID FIELD IN CDB */
3259: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3260: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3261: return -1;
3262: }
3263: if (type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE
3264: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS
3265: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY
3266: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY
3267: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS
3268: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS) {
3269: ISTGT_ERRLOG("unsupported type 0x%x\n", type);
3270: /* INVALID FIELD IN CDB */
3271: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3272: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3273: return -1;
3274: }
3275:
3276: /* release reservation */
3277: //xfree(spec->rsv_port);
3278: old_rsv_port = spec->rsv_port;
3279: spec->rsv_port = NULL;
3280: spec->rsv_key = 0;
3281: spec->rsv_scope = 0;
3282: spec->rsv_type = 0;
3283: /* establish new reservation */
3284: spec->rsv_port = xstrdup(conn->initiator_port);
3285: strlwr(spec->rsv_port);
3286: spec->rsv_key = rkey;
3287: spec->rsv_scope = scope;
3288: spec->rsv_type = type;
3289:
3290: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3291: "LU%d: reserved (scope=%d, type=%d)"
3292: "by key=0x%16.16"PRIx64"\n",
3293: spec->lu->num, scope, type, rkey);
3294:
3295: /* update generation */
3296: spec->pr_generation++;
3297:
3298: /* XXX TODO fix */
3299: if (task_abort) {
3300: /* abort all tasks for preempted I_T nexus */
3301: if (old_rsv_port != NULL) {
3302: rc = istgt_lu_disk_queue_abort_ITL(spec, old_rsv_port);
3303: xfree(old_rsv_port);
3304: old_rsv_port = NULL;
3305: if (rc < 0) {
3306: /* INTERNAL TARGET FAILURE */
3307: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3308: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3309: return -1;
3310: }
3311: }
3312: }
3313: if (old_rsv_port != NULL) {
3314: xfree(old_rsv_port);
3315: old_rsv_port = NULL;
3316: }
3317:
3318: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3319: break;
3320: }
3321: }
3322:
3323: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3324: conn->target_port, rkey);
3325:
3326: if (prkey == NULL) {
3327: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3328: "prkey == NULL\n");
3329: } else {
3330: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3331: "prkey key=%16.16"PRIx64"\n",
3332: prkey->key);
3333: }
3334:
3335: if (prkey == NULL
3336: || sarkey != spec->rsv_key) {
3337: if (sarkey != 0) {
3338: /* remove registration */
3339: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3340: NULL, NULL, sarkey);
3341: if (rc < 0) {
3342: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3343: /* INTERNAL TARGET FAILURE */
3344: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3345: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3346: return -1;
3347: }
3348: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3349: break;
3350: } else {
3351: /* INVALID FIELD IN PARAMETER LIST */
3352: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
3353: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3354: return -1;
3355: }
3356: }
3357:
3358: /* remove registration */
3359: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3360: NULL, NULL, sarkey);
3361: if (rc < 0) {
3362: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3363: /* INTERNAL TARGET FAILURE */
3364: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3365: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3366: return -1;
3367: }
3368:
3369: if (scope != 0x00) { // !LU_SCOPE
3370: /* INVALID FIELD IN CDB */
3371: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3372: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3373: return -1;
3374: }
3375: if (type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE
3376: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS
3377: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY
3378: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY
3379: && type != ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS
3380: && type != ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS) {
3381: ISTGT_ERRLOG("unsupported type 0x%x\n", type);
3382: /* INVALID FIELD IN CDB */
3383: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3384: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3385: return -1;
3386: }
3387:
3388: /* release reservation */
3389: //xfree(spec->rsv_port);
3390: old_rsv_port = spec->rsv_port;
3391: spec->rsv_port = NULL;
3392: spec->rsv_key = 0;
3393: spec->rsv_scope = 0;
3394: spec->rsv_type = 0;
3395: /* establish new reservation */
3396: spec->rsv_port = xstrdup(conn->initiator_port);
3397: strlwr(spec->rsv_port);
3398: spec->rsv_key = rkey;
3399: spec->rsv_scope = scope;
3400: spec->rsv_type = type;
3401:
3402: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3403: "LU%d: reserved (scope=%d, type=%d) by key=0x%16.16"
3404: PRIx64"\n",
3405: spec->lu->num, scope, type, rkey);
3406:
3407: /* update generation */
3408: spec->pr_generation++;
3409:
3410: /* XXX TODO fix */
3411: if (task_abort) {
3412: /* abort all tasks for preempted I_T nexus */
3413: if (old_rsv_port != NULL) {
3414: rc = istgt_lu_disk_queue_abort_ITL(spec, old_rsv_port);
3415: xfree(old_rsv_port);
3416: old_rsv_port = NULL;
3417: if (rc < 0) {
3418: /* INTERNAL TARGET FAILURE */
3419: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3420: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3421: return -1;
3422: }
3423: }
3424: }
3425: if (old_rsv_port != NULL) {
3426: xfree(old_rsv_port);
3427: old_rsv_port = NULL;
3428: }
3429:
3430: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3431: break;
3432:
3433: case 0x05: /* PREEMPT AND ABORT */
3434: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "PREEMPT AND ABORT\n");
3435:
3436: task_abort = 1;
3437: goto do_preempt;
3438:
3439: case 0x06: /* REGISTER AND IGNORE EXISTING KEY */
3440: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REGISTER AND IGNORE EXISTING KEY\n");
3441:
3442: if (aptpl != 0) {
3443: /* Activate Persist Through Power Loss */
3444: ISTGT_ERRLOG("unsupport Activate Persist Through Power Loss\n");
3445: /* INVALID FIELD IN PARAMETER LIST */
3446: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
3447: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3448: return -1;
3449: }
3450: /* lost reservations if daemon restart */
3451:
3452: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3453: conn->target_port, 0);
3454: if (prkey == NULL) {
3455: /* unregistered port */
3456: if (sarkey != 0) {
3457: if (spec_i_pt) {
3458: /* INVALID FIELD IN CDB */
3459: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3460: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3461: return -1;
3462: }
3463: }
3464: } else {
3465: /* registered port */
3466: if (spec_i_pt) {
3467: /* INVALID FIELD IN CDB */
3468: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3469: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3470: return -1;
3471: }
3472: }
3473:
3474: /* remove existing keys */
3475: rc = istgt_lu_disk_remove_pr_key(spec, conn,
3476: conn->initiator_port,
3477: conn->target_port, 0);
3478: if (rc < 0) {
3479: ISTGT_ERRLOG("lu_disk_remove_pr_key() failed\n");
3480: /* INTERNAL TARGET FAILURE */
3481: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3482: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3483: return -1;
3484: }
3485:
3486: /* unregister? */
3487: if (sarkey == 0) {
3488: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3489: return 0;
3490: }
3491:
3492: do_register:
3493: /* specified port? */
3494: nports = 0;
3495: initiator_ports = NULL;
3496: if (spec_i_pt) {
3497: if (len < 28) {
3498: /* INVALID FIELD IN PARAMETER LIST */
3499: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
3500: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3501: return -1;
3502: }
3503:
3504: /* TRANSPORTID PARAMETER DATA LENGTH */
3505: plen = DGET32(&data[24]);
3506: if (28 + plen > len) {
3507: ISTGT_ERRLOG("invalid length %d (expect %d)\n",
3508: len, 28 + plen);
3509: /* INVALID FIELD IN PARAMETER LIST */
3510: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
3511: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3512: return -1;
3513: }
3514:
3515: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3516: "TransportID parameter data length %d\n",
3517: plen);
3518: if (plen != 0) {
3519: maxports = MAX_LU_RESERVE_IPT;
3520: initiator_ports = xmalloc(sizeof (char *) * maxports);
3521: memset(initiator_ports, 0, sizeof (char *) * maxports);
3522: nports = 0;
3523: total = 0;
3524: while (total < plen) {
3525: if (nports >= MAX_LU_RESERVE_IPT) {
3526: ISTGT_ERRLOG("maximum transport IDs\n");
3527: /* INSUFFICIENT REGISTRATION RESOURCES */
3528: BUILD_SENSE(ILLEGAL_REQUEST, 0x55, 0x04);
3529: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3530: return -1;
3531: }
3532: rc = istgt_lu_parse_transport_id
3533: (&initiator_ports[nports],
3534: &data[24] + total, plen - total);
3535: if (rc < 0) {
3536: /* INVALID FIELD IN PARAMETER LIST */
3537: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
3538: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3539: return -1;
3540: }
3541: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "got TransportID %s\n",
3542: initiator_ports[nports]);
3543: total += rc;
3544: nports++;
3545: }
3546: }
3547: /* check all port unregistered? */
3548: for (i = 0; i < nports; i++) {
3549: prkey = istgt_lu_disk_find_pr_key(spec,
3550: initiator_ports[i], NULL, 0);
3551: if (prkey != NULL) {
3552: /* registered port */
3553: /* INVALID FIELD IN CDB */
3554: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3555: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3556: return -1;
3557: }
3558: }
3559: /* OK, all port unregistered */
3560: idx = spec->npr_keys;
3561: if (idx + nports >= MAX_LU_RESERVE) {
3562: /* INSUFFICIENT REGISTRATION RESOURCES */
3563: BUILD_SENSE(ILLEGAL_REQUEST, 0x55, 0x04);
3564: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3565: return -1;
3566: }
3567: /* register each I_T nexus */
3568: for (i = 0; i < nports; i++) {
3569: prkey = &spec->pr_keys[idx + i];
3570:
3571: /* register new key */
3572: prkey->key = sarkey;
3573:
3574: /* command received port */
3575: prkey->registered_initiator_port
3576: = xstrdup(conn->initiator_port);
3577: strlwr(prkey->registered_initiator_port);
3578: prkey->registered_target_port
3579: = xstrdup(conn->target_port);
3580: strlwr(prkey->registered_target_port);
3581: prkey->pg_idx = conn->portal.idx;
3582: prkey->pg_tag = conn->portal.tag;
3583:
3584: /* specified ports */
3585: prkey->ninitiator_ports = 0;
3586: prkey->initiator_ports = NULL;
3587: prkey->all_tpg = (all_tg_pt) ? 1 : 0;
3588: }
3589: spec->npr_keys = idx + nports;
3590: }
3591:
3592: idx = spec->npr_keys;
3593: if (idx >= MAX_LU_RESERVE) {
3594: /* INSUFFICIENT REGISTRATION RESOURCES */
3595: BUILD_SENSE(ILLEGAL_REQUEST, 0x55, 0x04);
3596: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3597: return -1;
3598: }
3599: prkey = &spec->pr_keys[idx];
3600:
3601: /* register new key */
3602: prkey->key = sarkey;
3603:
3604: /* command received port */
3605: prkey->registered_initiator_port = xstrdup(conn->initiator_port);
3606: strlwr(prkey->registered_initiator_port);
3607: prkey->registered_target_port = xstrdup(conn->target_port);
3608: strlwr(prkey->registered_target_port);
3609: prkey->pg_idx = conn->portal.idx;
3610: prkey->pg_tag = conn->portal.tag;
3611:
3612: /* specified ports */
3613: prkey->ninitiator_ports = nports;
3614: prkey->initiator_ports = initiator_ports;
3615: prkey->all_tpg = (all_tg_pt) ? 1 : 0;
3616:
3617: /* count up keys */
3618: idx++;
3619: spec->npr_keys = idx;
3620:
3621: /* update generation */
3622: spec->pr_generation++;
3623: break;
3624:
3625: case 0x07: /* REGISTER AND MOVE */
3626: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REGISTER AND MOVE\n");
3627: /* INVALID FIELD IN CDB */
3628: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3629: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3630: return -1;
3631:
3632: default:
3633: ISTGT_ERRLOG("unsupported service action 0x%x\n", sa);
3634: /* INVALID FIELD IN CDB */
3635: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
3636: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3637: return -1;
3638: }
3639:
3640: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3641: return 0;
3642: }
3643:
3644: static int
3645: istgt_lu_disk_check_pr(ISTGT_LU_DISK *spec, CONN_Ptr conn, int pr_allow)
3646: {
3647: ISTGT_LU_PR_KEY *prkey;
3648:
3649: #ifdef ISTGT_TRACE_DISK
3650: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3651: "RSV_KEY=0x%16.16"PRIx64", RSV_TYPE=0x%x, PR_ALLOW=0x%x\n",
3652: spec->rsv_key, spec->rsv_type, pr_allow);
3653: #endif /* ISTGT_TRACE_DISK */
3654:
3655: prkey = istgt_lu_disk_find_pr_key(spec, conn->initiator_port,
3656: conn->target_port, 0);
3657: if (prkey != NULL) {
3658: #ifdef ISTGT_TRACE_DISK
3659: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3660: "PRKEY(0x%16.16"PRIx64") found for %s\n",
3661: prkey->key, conn->initiator_port);
3662: #endif /* ISTGT_TRACE_DISK */
3663:
3664: if (spec->rsv_key == prkey->key) {
3665: /* reservation holder */
3666: return 0;
3667: }
3668:
3669: switch (spec->rsv_type) {
3670: case ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS:
3671: if (pr_allow & PR_ALLOW_ALLRR)
3672: return 0;
3673: return -1;
3674: case ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS:
3675: if (pr_allow & PR_ALLOW_ALLRR)
3676: return 0;
3677: return -1;
3678: case ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY:
3679: if (pr_allow & PR_ALLOW_ALLRR)
3680: return 0;
3681: return -1;
3682: case ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY:
3683: if (pr_allow & PR_ALLOW_ALLRR)
3684: return 0;
3685: return -1;
3686: }
3687: } else {
3688: #ifdef ISTGT_TRACE_DISK
3689: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
3690: "PRKEY not found for %s\n",
3691: conn->initiator_port);
3692: #endif /* ISTGT_TRACE_DISK */
3693:
3694: switch (spec->rsv_type) {
3695: case ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS:
3696: if (pr_allow & PR_ALLOW_WERR)
3697: return 0;
3698: return -1;
3699: case ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY:
3700: if (pr_allow & PR_ALLOW_WERR)
3701: return 0;
3702: return -1;
3703: case ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS:
3704: if (pr_allow & PR_ALLOW_EARR)
3705: return 0;
3706: return -1;
3707: case ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY:
3708: if (pr_allow & PR_ALLOW_EARR)
3709: return 0;
3710: return -1;
3711: }
3712: }
3713:
3714: #ifdef ISTGT_TRACE_DISK
3715: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "non registrans type\n");
3716: #endif /* ISTGT_TRACE_DISK */
3717: /* any I_T nexus */
3718: switch (spec->rsv_type) {
3719: case ISTGT_LU_PR_TYPE_WRITE_EXCLUSIVE:
3720: if (pr_allow & PR_ALLOW_WE)
3721: return 0;
3722: return -1;
3723: case ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS:
3724: if (pr_allow & PR_ALLOW_EA)
3725: return 0;
3726: return -1;
3727: }
3728:
3729: /* NG */
3730: return -1;
3731: }
3732:
3733: static int
3734: istgt_lu_disk_scsi_release(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
3735: {
3736: ISTGT_LU_CMD lu_cmd2;
3737: uint8_t *sense_data;
3738: int *sense_len;
3739: uint64_t LUI;
3740: uint64_t rkey;
3741: uint8_t cdb[10];
3742: uint8_t PRO_data[24];
3743: int parameter_len;
3744: int rc;
3745:
3746: sense_data = lu_cmd->sense_data;
3747: sense_len = &lu_cmd->sense_data_len;
3748: *sense_len = 0;
3749:
3750: memset(&lu_cmd2, 0, sizeof lu_cmd2);
3751: lu_cmd2.sense_data = lu_cmd->sense_data;
3752: lu_cmd2.sense_data_len = lu_cmd->sense_data_len;
3753: memset(&cdb, 0, sizeof cdb);
3754: parameter_len = sizeof PRO_data;
3755:
3756: LUI = istgt_get_lui(spec->lu->name, spec->lun & 0xffffU);
3757: rkey = istgt_get_rkey(conn->initiator_name, LUI);
3758:
3759: /* issue release action of PERSISTENT RESERVE OUT */
3760: cdb[0] = SPC_PERSISTENT_RESERVE_OUT;
3761: BDSET8W(&cdb[1], 0x02, 4, 5); /* RELEASE */
3762: BDSET8W(&cdb[2], 0x00, 7, 4); /* LU_SCOPE */
3763: BDADD8W(&cdb[2], 0x03, 3, 4); /* ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS */
3764: cdb[3] = 0;
3765: cdb[4] = 0;
3766: DSET32(&cdb[5], parameter_len);
3767: cdb[9] = 0;
3768: lu_cmd2.cdb = &cdb[0];
3769:
3770: memset(&PRO_data, 0, sizeof PRO_data);
3771: DSET64(&PRO_data[0], rkey); // RESERVATION KEY
3772: DSET64(&PRO_data[8], 0);
3773:
3774: rc = istgt_lu_disk_scsi_persistent_reserve_out(spec, conn, &lu_cmd2,
3775: 0x02, 0x00, 0x03,
3776: PRO_data, parameter_len);
3777: if (rc < 0) {
3778: lu_cmd->status = lu_cmd2.status;
3779: if (lu_cmd->status == ISTGT_SCSI_STATUS_RESERVATION_CONFLICT) {
3780: return -1;
3781: }
3782: /* INTERNAL TARGET FAILURE */
3783: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3784: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3785: return -1;
3786: }
3787:
3788: /* issue unregister action of PERSISTENT RESERVE OUT */
3789: cdb[0] = SPC_PERSISTENT_RESERVE_OUT;
3790: BDSET8W(&cdb[1], 0x06, 4, 5); /* REGISTER AND IGNORE EXISTING KEY */
3791: cdb[2] = 0;
3792: cdb[3] = 0;
3793: cdb[4] = 0;
3794: DSET32(&cdb[5], parameter_len);
3795: cdb[9] = 0;
3796: lu_cmd2.cdb = &cdb[0];
3797:
3798: memset(&PRO_data, 0, sizeof PRO_data);
3799: DSET64(&PRO_data[0], rkey); // RESERVATION KEY
3800: DSET64(&PRO_data[8], 0); // unregister
3801:
3802: rc = istgt_lu_disk_scsi_persistent_reserve_out(spec, conn, &lu_cmd2,
3803: 0x06, 0, 0,
3804: PRO_data, parameter_len);
3805: if (rc < 0) {
3806: lu_cmd->status = lu_cmd2.status;
3807: if (lu_cmd->status == ISTGT_SCSI_STATUS_RESERVATION_CONFLICT) {
3808: return -1;
3809: }
3810: /* INTERNAL TARGET FAILURE */
3811: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3812: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3813: return -1;
3814: }
3815:
3816: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3817: return 0;
3818: }
3819:
3820: static int
3821: istgt_lu_disk_scsi_reserve(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
3822: {
3823: ISTGT_LU_CMD lu_cmd2;
3824: uint8_t *sense_data;
3825: int *sense_len;
3826: uint64_t LUI;
3827: uint64_t rkey;
3828: uint8_t cdb[10];
3829: uint8_t PRO_data[24];
3830: int parameter_len;
3831: int rc;
3832:
3833: sense_data = lu_cmd->sense_data;
3834: sense_len = &lu_cmd->sense_data_len;
3835: *sense_len = 0;
3836:
3837: memset(&lu_cmd2, 0, sizeof lu_cmd2);
3838: lu_cmd2.sense_data = lu_cmd->sense_data;
3839: lu_cmd2.sense_data_len = lu_cmd->sense_data_len;
3840: memset(&cdb, 0, sizeof cdb);
3841: parameter_len = sizeof PRO_data;
3842:
3843: LUI = istgt_get_lui(spec->lu->name, spec->lun & 0xffffU);
3844: rkey = istgt_get_rkey(conn->initiator_name, LUI);
3845:
3846: /* issue register action of PERSISTENT RESERVE OUT */
3847: cdb[0] = SPC_PERSISTENT_RESERVE_OUT;
3848: BDSET8W(&cdb[1], 0x06, 4, 5); /* REGISTER AND IGNORE EXISTING KEY */
3849: cdb[2] = 0;
3850: cdb[3] = 0;
3851: cdb[4] = 0;
3852: DSET32(&cdb[5], parameter_len);
3853: cdb[9] = 0;
3854: lu_cmd2.cdb = &cdb[0];
3855:
3856: memset(&PRO_data, 0, sizeof PRO_data);
3857: DSET64(&PRO_data[0], 0);
3858: DSET64(&PRO_data[8], rkey); // SERVICE ACTION RESERVATION KEY
3859:
3860: rc = istgt_lu_disk_scsi_persistent_reserve_out(spec, conn, &lu_cmd2,
3861: 0x06, 0, 0,
3862: PRO_data, parameter_len);
3863: if (rc < 0) {
3864: lu_cmd->status = lu_cmd2.status;
3865: if (lu_cmd->status == ISTGT_SCSI_STATUS_RESERVATION_CONFLICT) {
3866: return -1;
3867: }
3868: /* INTERNAL TARGET FAILURE */
3869: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3870: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3871: return -1;
3872: }
3873:
3874: /* issue reserve action of PERSISTENT RESERVE OUT */
3875: cdb[0] = SPC_PERSISTENT_RESERVE_OUT;
3876: BDSET8W(&cdb[1], 0x01, 4, 5); /* RESERVE */
3877: BDSET8W(&cdb[2], 0x00, 7, 4); /* LU_SCOPE */
3878: BDADD8W(&cdb[2], 0x03, 3, 4); /* ISTGT_LU_PR_TYPE_EXCLUSIVE_ACCESS */
3879: cdb[3] = 0;
3880: cdb[4] = 0;
3881: DSET32(&cdb[5], parameter_len);
3882: cdb[9] = 0;
3883: lu_cmd2.cdb = &cdb[0];
3884:
3885: memset(&PRO_data, 0, sizeof PRO_data);
3886: DSET64(&PRO_data[0], rkey); // RESERVATION KEY
3887: DSET64(&PRO_data[8], 0);
3888:
3889: rc = istgt_lu_disk_scsi_persistent_reserve_out(spec, conn, &lu_cmd2,
3890: 0x01, 0x00, 0x03,
3891: PRO_data, parameter_len);
3892: if (rc < 0) {
3893: lu_cmd->status = lu_cmd2.status;
3894: if (lu_cmd->status == ISTGT_SCSI_STATUS_RESERVATION_CONFLICT) {
3895: return -1;
3896: }
3897: /* INTERNAL TARGET FAILURE */
3898: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
3899: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
3900: return -1;
3901: }
3902:
3903: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
3904: return 0;
3905: }
3906:
3907: static int
3908: istgt_lu_disk_lbread(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lba, uint32_t len)
3909: {
3910: uint8_t *data;
3911: uint64_t maxlba;
3912: uint64_t llen;
3913: uint64_t blen;
3914: uint64_t offset;
3915: uint64_t nbytes;
3916: int64_t rc;
3917:
3918: if (len == 0) {
3919: lu_cmd->data = NULL;
3920: lu_cmd->data_len = 0;
3921: return 0;
3922: }
3923:
3924: maxlba = spec->blockcnt;
3925: llen = (uint64_t) len;
3926: blen = spec->blocklen;
3927: offset = lba * blen;
3928: nbytes = llen * blen;
3929:
3930: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
3931: "Read: max=%"PRIu64", lba=%"PRIu64", len=%u\n",
3932: maxlba, lba, len);
3933:
3934: if (lba >= maxlba || llen > maxlba || lba > (maxlba - llen)) {
3935: ISTGT_ERRLOG("end of media\n");
3936: return -1;
3937: }
3938:
3939: if (nbytes > lu_cmd->iobufsize) {
3940: ISTGT_ERRLOG("nbytes(%u) > iobufsize(%u)\n",
3941: nbytes, lu_cmd->iobufsize);
3942: return -1;
3943: }
3944: data = lu_cmd->iobuf;
3945:
3946: rc = istgt_lu_disk_seek(spec, offset);
3947: if (rc < 0) {
3948: ISTGT_ERRLOG("lu_disk_seek() failed\n");
3949: return -1;
3950: }
3951:
3952: rc = istgt_lu_disk_read(spec, data, nbytes);
3953: if (rc < 0) {
3954: ISTGT_ERRLOG("lu_disk_read() failed\n");
3955: return -1;
3956: }
3957: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Read %"PRId64"/%"PRIu64" bytes\n",
3958: rc, nbytes);
3959:
3960: lu_cmd->data = data;
3961: lu_cmd->data_len = rc;
3962:
3963: return 0;
3964: }
3965:
3966: static int
3967: istgt_lu_disk_lbwrite(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lba, uint32_t len)
3968: {
3969: uint8_t *data;
3970: uint64_t maxlba;
3971: uint64_t llen;
3972: uint64_t blen;
3973: uint64_t offset;
3974: uint64_t nbytes;
3975: int64_t rc;
3976:
3977: if (len == 0) {
3978: lu_cmd->data_len = 0;
3979: return 0;
3980: }
3981:
3982: maxlba = spec->blockcnt;
3983: llen = (uint64_t) len;
3984: blen = spec->blocklen;
3985: offset = lba * blen;
3986: nbytes = llen * blen;
3987:
3988: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
3989: "Write: max=%"PRIu64", lba=%"PRIu64", len=%u\n",
3990: maxlba, lba, len);
3991:
3992: if (lba >= maxlba || llen > maxlba || lba > (maxlba - llen)) {
3993: ISTGT_ERRLOG("end of media\n");
3994: return -1;
3995: }
3996:
3997: if (nbytes > lu_cmd->iobufsize) {
3998: ISTGT_ERRLOG("nbytes(%u) > iobufsize(%u)\n",
3999: nbytes, lu_cmd->iobufsize);
4000: return -1;
4001: }
4002: data = lu_cmd->iobuf;
4003:
4004: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
4005: lu_cmd->iobufsize, nbytes);
4006: if (rc < 0) {
4007: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
4008: return -1;
4009: }
4010:
4011: if (spec->lu->readonly) {
4012: ISTGT_ERRLOG("LU%d: readonly unit\n", spec->lu->num);
4013: return -1;
4014: }
4015:
4016: spec->req_write_cache = 0;
4017: rc = istgt_lu_disk_seek(spec, offset);
4018: if (rc < 0) {
4019: ISTGT_ERRLOG("lu_disk_seek() failed\n");
4020: return -1;
4021: }
4022:
4023: rc = istgt_lu_disk_write(spec, data, nbytes);
4024: if (rc < 0 || rc != nbytes) {
4025: ISTGT_ERRLOG("lu_disk_write() failed\n");
4026: return -1;
4027: }
4028: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Wrote %"PRId64"/%"PRIu64" bytes\n",
4029: rc, nbytes);
4030:
4031: lu_cmd->data_len = rc;
4032:
4033: return 0;
4034: }
4035:
4036: static int
4037: istgt_lu_disk_lbwrite_same(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lba, uint32_t len)
4038: {
4039: uint8_t *data;
4040: uint64_t maxlba;
4041: uint64_t llen;
4042: uint64_t blen;
4043: uint64_t offset;
4044: uint64_t nbytes;
4045: uint64_t nblocks;
4046: uint64_t wblocks;
4047: int64_t rc;
4048:
4049: maxlba = spec->blockcnt;
4050: llen = (uint64_t) len;
4051: if (llen == 0) {
4052: if (lba >= maxlba) {
4053: ISTGT_ERRLOG("end of media\n");
4054: return -1;
4055: }
4056: llen = maxlba - lba;
4057: }
4058: blen = spec->blocklen;
4059: offset = lba * blen;
4060: nbytes = 1 * blen;
4061:
4062: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
4063: "Write Same: max=%"PRIu64", lba=%"PRIu64", len=%u\n",
4064: maxlba, lba, len);
4065:
4066: if (lba >= maxlba || llen > maxlba || lba > (maxlba - llen)) {
4067: ISTGT_ERRLOG("end of media\n");
4068: return -1;
4069: }
4070:
4071: if (nbytes > lu_cmd->iobufsize) {
4072: ISTGT_ERRLOG("nbytes(%u) > iobufsize(%u)\n",
4073: nbytes, lu_cmd->iobufsize);
4074: return -1;
4075: }
4076: data = lu_cmd->iobuf;
4077:
4078: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
4079: lu_cmd->iobufsize, nbytes);
4080: if (rc < 0) {
4081: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
4082: return -1;
4083: }
4084:
4085: if (spec->lu->readonly) {
4086: ISTGT_ERRLOG("LU%d: readonly unit\n", spec->lu->num);
4087: return -1;
4088: }
4089:
4090: if (conn->workbuf == NULL) {
4091: conn->worksize = ISTGT_LU_WORK_BLOCK_SIZE;
4092: conn->workbuf = xmalloc(conn->worksize);
4093: }
4094: wblocks = (int64_t)conn->worksize / nbytes;
4095: if (wblocks == 0) {
4096: ISTGT_ERRLOG("work buffer is too small\n");
4097: return -1;
4098: }
4099:
4100: spec->req_write_cache = 0;
4101: rc = istgt_lu_disk_seek(spec, offset);
4102: if (rc < 0) {
4103: ISTGT_ERRLOG("lu_disk_seek() failed\n");
4104: return -1;
4105: }
4106:
4107: #if 0
4108: nblocks = 0;
4109: while (nblocks < llen) {
4110: rc = istgt_lu_disk_write(spec, data, nbytes);
4111: if (rc < 0 || rc != nbytes) {
4112: ISTGT_ERRLOG("lu_disk_write() failed\n");
4113: return -1;
4114: }
4115: nblocks++;
4116: }
4117: #else
4118: nblocks = 0;
4119: while (nblocks < wblocks) {
4120: memcpy(conn->workbuf + (nblocks * nbytes), data, nbytes);
4121: nblocks++;
4122: }
4123:
4124: nblocks = 0;
4125: while (nblocks < llen) {
4126: uint64_t reqblocks = DMIN64(wblocks, (llen - nblocks));
4127: rc = istgt_lu_disk_write(spec, conn->workbuf, (reqblocks * nbytes));
4128: if (rc < 0 || rc != (reqblocks * nbytes)) {
4129: ISTGT_ERRLOG("lu_disk_write() failed\n");
4130: return -1;
4131: }
4132: nblocks += reqblocks;
4133: }
4134: #endif
4135: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Wrote %"PRId64"/%"PRIu64" bytes\n",
4136: (nblocks * nbytes), (llen * nbytes));
4137:
4138: lu_cmd->data_len = nbytes;
4139:
4140: return 0;
4141: }
4142:
4143: static int
4144: istgt_lu_disk_lbwrite_ats(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lba, uint32_t len)
4145: {
4146: uint8_t *tmp;
4147: uint8_t *data;
4148: uint64_t maxlba;
4149: uint64_t llen;
4150: uint64_t blen;
4151: uint64_t offset;
4152: uint64_t nbytes;
4153: int64_t rc;
4154: uint8_t *sense_data;
4155: int *sense_len;
4156:
4157: if (len == 0) {
4158: lu_cmd->data_len = 0;
4159: return 0;
4160: }
4161:
4162: sense_data = lu_cmd->sense_data;
4163: sense_len = &lu_cmd->sense_data_len;
4164: *sense_len = 0;
4165:
4166: maxlba = spec->blockcnt;
4167: llen = (uint64_t) len;
4168: blen = spec->blocklen;
4169: offset = lba * blen;
4170: nbytes = llen * blen;
4171:
4172: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
4173: "Write ATS: max=%"PRIu64", lba=%"PRIu64", len=%u\n",
4174: maxlba, lba, len);
4175:
4176: if (lba >= maxlba || llen > maxlba || lba > (maxlba - llen)) {
4177: ISTGT_ERRLOG("end of media\n");
4178: return -1;
4179: }
4180:
4181: if (nbytes > lu_cmd->iobufsize) {
4182: ISTGT_ERRLOG("nbytes(%u) > iobufsize(%u)\n",
4183: nbytes, lu_cmd->iobufsize);
4184: return -1;
4185: }
4186: data = lu_cmd->iobuf;
4187:
4188: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
4189: lu_cmd->iobufsize, nbytes * 2);
4190: if (rc < 0) {
4191: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
4192: return -1;
4193: }
4194:
4195: if (spec->lu->readonly) {
4196: ISTGT_ERRLOG("LU%d: readonly unit\n", spec->lu->num);
4197: return -1;
4198: }
4199:
4200: tmp = xmalloc(nbytes);
4201: spec->req_write_cache = 0;
4202: /* start atomic test and set */
4203: MTX_LOCK(&spec->ats_mutex);
4204:
4205: rc = istgt_lu_disk_seek(spec, offset);
4206: if (rc < 0) {
4207: MTX_UNLOCK(&spec->ats_mutex);
4208: ISTGT_ERRLOG("lu_disk_seek() failed\n");
4209: xfree(tmp);
4210: return -1;
4211: }
4212:
4213: rc = istgt_lu_disk_read(spec, tmp, nbytes);
4214: if (rc < 0 || rc != nbytes) {
4215: MTX_UNLOCK(&spec->ats_mutex);
4216: ISTGT_ERRLOG("lu_disk_read() failed\n");
4217: xfree(tmp);
4218: return -1;
4219: }
4220:
4221: #if 0
4222: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "ATS VERIFY", data, nbytes);
4223: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "ATS WRITE", data + nbytes, nbytes);
4224: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "ATS DATA", tmp, nbytes);
4225: #endif
4226: if (memcmp(tmp, data, nbytes) != 0) {
4227: MTX_UNLOCK(&spec->ats_mutex);
4228: //ISTGT_ERRLOG("compare failed\n");
4229: xfree(tmp);
4230: /* MISCOMPARE DURING VERIFY OPERATION */
4231: BUILD_SENSE(MISCOMPARE, 0x1d, 0x00);
4232: return -1;
4233: }
4234:
4235: rc = istgt_lu_disk_seek(spec, offset);
4236: if (rc < 0) {
4237: MTX_UNLOCK(&spec->ats_mutex);
4238: ISTGT_ERRLOG("lu_disk_seek() failed\n");
4239: xfree(tmp);
4240: return -1;
4241: }
4242: rc = istgt_lu_disk_write(spec, data + nbytes, nbytes);
4243: if (rc < 0 || rc != nbytes) {
4244: MTX_UNLOCK(&spec->ats_mutex);
4245: ISTGT_ERRLOG("lu_disk_write() failed\n");
4246: xfree(tmp);
4247: return -1;
4248: }
4249: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Wrote %"PRId64"/%"PRIu64" bytes\n",
4250: rc, nbytes);
4251:
4252: MTX_UNLOCK(&spec->ats_mutex);
4253: /* end atomic test and set */
4254: xfree(tmp);
4255:
4256: lu_cmd->data_len = nbytes * 2;
4257:
4258: return 0;
4259: }
4260:
4261: static int
4262: istgt_lu_disk_lbsync(ISTGT_LU_DISK *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lba, uint32_t len)
4263: {
4264: uint64_t maxlba;
4265: uint64_t llen;
4266: uint64_t blen;
4267: uint64_t offset;
4268: uint64_t nbytes;
4269: int64_t rc;
4270:
4271: if (len == 0) {
4272: return 0;
4273: }
4274:
4275: maxlba = spec->blockcnt;
4276: llen = (uint64_t) len;
4277: blen = spec->blocklen;
4278: offset = lba * blen;
4279: nbytes = llen * blen;
4280:
4281: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
4282: "Sync: max=%"PRIu64", lba=%"PRIu64", len=%u\n",
4283: maxlba, lba, len);
4284:
4285: if (lba >= maxlba || llen > maxlba || lba > (maxlba - llen)) {
4286: ISTGT_ERRLOG("end of media\n");
4287: return -1;
4288: }
4289:
4290: rc = istgt_lu_disk_sync(spec, offset, nbytes);
4291: if (rc < 0) {
4292: ISTGT_ERRLOG("lu_disk_sync() failed\n");
4293: return -1;
4294: }
4295:
4296: return 0;
4297: }
4298:
4299: int
4300: istgt_lu_scsi_build_sense_data(uint8_t *data, int sk, int asc, int ascq)
4301: {
4302: uint8_t *cp;
4303: int resp_code;
4304: int hlen = 0, len = 0, plen;
4305: int total;
4306:
4307: resp_code = 0x70; /* Current + Fixed format */
4308:
4309: /* SenseLength */
4310: DSET16(&data[0], 0);
4311: hlen = 2;
4312:
4313: /* Sense Data */
4314: cp = &data[hlen + len];
4315:
4316: /* VALID(7) RESPONSE CODE(6-0) */
4317: BDSET8(&cp[0], 1, 7);
4318: BDADD8W(&cp[0], resp_code, 6, 7);
4319: /* Obsolete */
4320: cp[1] = 0;
4321: /* FILEMARK(7) EOM(6) ILI(5) SENSE KEY(3-0) */
4322: BDSET8W(&cp[2], sk, 3, 4);
4323: /* INFORMATION */
4324: memset(&cp[3], 0, 4);
4325: /* ADDITIONAL SENSE LENGTH */
4326: cp[7] = 0;
4327: len = 8;
4328:
4329: /* COMMAND-SPECIFIC INFORMATION */
4330: memset(&cp[8], 0, 4);
4331: /* ADDITIONAL SENSE CODE */
4332: cp[12] = asc;
4333: /* ADDITIONAL SENSE CODE QUALIFIER */
4334: cp[13] = ascq;
4335: /* FIELD REPLACEABLE UNIT CODE */
4336: cp[14] = 0;
4337: /* SKSV(7) SENSE KEY SPECIFIC(6-0,7-0,7-0) */
4338: cp[15] = 0;
4339: cp[16] = 0;
4340: cp[17] = 0;
4341: /* Additional sense bytes */
4342: //data[18] = 0;
4343: plen = 18 - len;
4344:
4345: /* ADDITIONAL SENSE LENGTH */
4346: cp[7] = plen;
4347:
4348: total = hlen + len + plen;
4349:
4350: /* SenseLength */
4351: DSET16(&data[0], total - 2);
4352:
4353: return total;
4354: }
4355:
4356: static int
4357: istgt_lu_disk_build_sense_data(ISTGT_LU_DISK *spec, uint8_t *data, int sk, int asc, int ascq)
4358: {
4359: int rc;
4360:
4361: rc = istgt_lu_scsi_build_sense_data(data, sk, asc, ascq);
4362: if (rc < 0) {
4363: return -1;
4364: }
4365: return rc;
4366: }
4367:
4368: int
4369: istgt_lu_scsi_build_sense_data2(uint8_t *data, int sk, int asc, int ascq)
4370: {
4371: uint8_t *cp;
4372: int resp_code;
4373: int hlen = 0, len = 0, plen;
4374: int total;
4375:
4376: resp_code = 0x71; /* Deferred + Fixed format */
4377:
4378: /* SenseLength */
4379: DSET16(&data[0], 0);
4380: hlen = 2;
4381:
4382: /* Sense Data */
4383: cp = &data[hlen + len];
4384:
4385: /* VALID(7) RESPONSE CODE(6-0) */
4386: BDSET8(&cp[0], 1, 7);
4387: BDADD8W(&cp[0], resp_code, 6, 7);
4388: /* Obsolete */
4389: cp[1] = 0;
4390: /* FILEMARK(7) EOM(6) ILI(5) SENSE KEY(3-0) */
4391: BDSET8W(&cp[2], sk, 3, 4);
4392: /* INFORMATION */
4393: memset(&cp[3], 0, 4);
4394: /* ADDITIONAL SENSE LENGTH */
4395: cp[7] = 0;
4396: len = 8;
4397:
4398: /* COMMAND-SPECIFIC INFORMATION */
4399: memset(&cp[8], 0, 4);
4400: /* ADDITIONAL SENSE CODE */
4401: cp[12] = asc;
4402: /* ADDITIONAL SENSE CODE QUALIFIER */
4403: cp[13] = ascq;
4404: /* FIELD REPLACEABLE UNIT CODE */
4405: cp[14] = 0;
4406: /* SKSV(7) SENSE KEY SPECIFIC(6-0,7-0,7-0) */
4407: cp[15] = 0;
4408: cp[16] = 0;
4409: cp[17] = 0;
4410: /* Additional sense bytes */
4411: //data[18] = 0;
4412: plen = 18 - len;
4413:
4414: /* ADDITIONAL SENSE LENGTH */
4415: cp[7] = plen;
4416:
4417: total = hlen + len + plen;
4418:
4419: /* SenseLength */
4420: DSET16(&data[0], total - 2);
4421:
4422: return total;
4423: }
4424:
4425: static int
4426: istgt_lu_disk_build_sense_data2(ISTGT_LU_DISK *spec, uint8_t *data, int sk, int asc, int ascq)
4427: {
4428: int rc;
4429:
4430: rc = istgt_lu_scsi_build_sense_data2(data, sk, asc, ascq);
4431: if (rc < 0) {
4432: return -1;
4433: }
4434: return rc;
4435: }
4436:
4437: int
4438: istgt_lu_disk_reset(ISTGT_LU_Ptr lu, int lun)
4439: {
4440: ISTGT_LU_DISK *spec;
4441: int flags;
4442: int rc;
4443:
4444: if (lu == NULL) {
4445: return -1;
4446: }
4447: if (lun >= lu->maxlun) {
4448: return -1;
4449: }
4450: if (lu->lun[lun].type == ISTGT_LU_LUN_TYPE_NONE) {
4451: return -1;
4452: }
4453: if (lu->lun[lun].type != ISTGT_LU_LUN_TYPE_STORAGE) {
4454: return -1;
4455: }
4456: spec = (ISTGT_LU_DISK *) lu->lun[lun].spec;
4457:
4458: #if 0
4459: if (spec->lock) {
4460: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "unlock by reset\n");
4461: spec->lock = 0;
4462: }
4463: #endif
4464:
4465: if (lu->queue_depth != 0) {
4466: rc = istgt_lu_disk_queue_clear_all(lu, lun);
4467: if (rc < 0) {
4468: ISTGT_ERRLOG("lu_disk_queue_clear_all() failed\n");
4469: return -1;
4470: }
4471: }
4472:
4473: /* re-open file */
4474: if (!spec->lu->readonly) {
4475: rc = istgt_lu_disk_sync(spec, 0, spec->size);
4476: if (rc < 0) {
4477: ISTGT_ERRLOG("LU%d: LUN%d: lu_disk_sync() failed\n",
4478: lu->num, lun);
4479: /* ignore error */
4480: }
4481: }
4482: rc = istgt_lu_disk_close(spec);
4483: if (rc < 0) {
4484: ISTGT_ERRLOG("LU%d: LUN%d: lu_disk_close() failed\n",
4485: lu->num, lun);
4486: /* ignore error */
4487: }
4488: flags = lu->readonly ? O_RDONLY : O_RDWR;
4489: rc = istgt_lu_disk_open(spec, flags, 0666);
4490: if (rc < 0) {
4491: ISTGT_ERRLOG("LU%d: LUN%d: lu_disk_open() failed\n",
4492: lu->num, lun);
4493: return -1;
4494: }
4495:
4496: return 0;
4497: }
4498:
4499: static int
4500: istgt_lu_disk_queue_clear_internal(ISTGT_LU_DISK *spec, const char *initiator_port, int all_cmds, uint32_t CmdSN)
4501: {
4502: ISTGT_LU_TASK_Ptr lu_task;
4503: ISTGT_QUEUE saved_queue;
4504: time_t now;
4505: int rc;
4506:
4507: if (spec == NULL)
4508: return -1;
4509:
4510: if (all_cmds != 0) {
4511: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "queue clear by port=%s\n",
4512: initiator_port);
4513: } else {
4514: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "queue clear by port=%s, CmdSN=%u\n",
4515: initiator_port, CmdSN);
4516: }
4517:
4518: istgt_queue_init(&saved_queue);
4519:
4520: now = time(NULL);
4521: MTX_LOCK(&spec->cmd_queue_mutex);
4522: while (1) {
4523: lu_task = istgt_queue_dequeue(&spec->cmd_queue);
4524: if (lu_task == NULL)
4525: break;
4526: if (((all_cmds != 0) || (lu_task->lu_cmd.CmdSN == CmdSN))
4527: && (strcasecmp(lu_task->initiator_port,
4528: initiator_port) == 0)) {
4529: ISTGT_LOG("CmdSN(%u), OP=0x%x, ElapsedTime=%u cleared\n",
4530: lu_task->lu_cmd.CmdSN,
4531: lu_task->lu_cmd.cdb[0],
4532: (now - lu_task->create_time));
4533: rc = istgt_lu_destroy_task(lu_task);
4534: if (rc < 0) {
4535: MTX_UNLOCK(&spec->cmd_queue_mutex);
4536: ISTGT_ERRLOG("lu_destory_task() failed\n");
4537: goto error_return;
4538: }
4539: continue;
4540: }
4541: rc = istgt_queue_enqueue(&saved_queue, lu_task);
4542: if (rc < 0) {
4543: MTX_UNLOCK(&spec->cmd_queue_mutex);
4544: ISTGT_ERRLOG("queue_enqueue() failed\n");
4545: goto error_return;
4546: }
4547: }
4548: while (1) {
4549: lu_task = istgt_queue_dequeue(&saved_queue);
4550: if (lu_task == NULL)
4551: break;
4552: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4553: if (rc < 0) {
4554: MTX_UNLOCK(&spec->cmd_queue_mutex);
4555: ISTGT_ERRLOG("queue_enqueue() failed\n");
4556: goto error_return;
4557: }
4558: }
4559: MTX_UNLOCK(&spec->cmd_queue_mutex);
4560:
4561: /* check wait task */
4562: MTX_LOCK(&spec->wait_lu_task_mutex);
4563: lu_task = spec->wait_lu_task;
4564: if (lu_task != NULL) {
4565: if (((all_cmds != 0) || (lu_task->lu_cmd.CmdSN == CmdSN))
4566: && (strcasecmp(lu_task->initiator_port,
4567: initiator_port) == 0)) {
4568: /* conn had gone? */
4569: rc = pthread_mutex_trylock(&lu_task->trans_mutex);
4570: if (rc == 0) {
4571: ISTGT_LOG("CmdSN(%u), OP=0x%x, ElapsedTime=%u aborted\n",
4572: lu_task->lu_cmd.CmdSN,
4573: lu_task->lu_cmd.cdb[0],
4574: (now - lu_task->create_time));
4575: /* force error */
4576: lu_task->error = 1;
4577: lu_task->abort = 1;
4578: rc = pthread_cond_broadcast(&lu_task->trans_cond);
4579: if (rc != 0) {
4580: /* ignore error */
4581: }
4582: MTX_UNLOCK(&lu_task->trans_mutex);
4583: }
4584: }
4585: }
4586: MTX_UNLOCK(&spec->wait_lu_task_mutex);
4587:
4588: rc = istgt_queue_count(&saved_queue);
4589: if (rc != 0) {
4590: ISTGT_ERRLOG("temporary queue is not empty\n");
4591: goto error_return;
4592: }
4593:
4594: istgt_queue_destroy(&saved_queue);
4595: return 0;
4596:
4597: error_return:
4598: istgt_queue_destroy(&saved_queue);
4599: return -1;
4600: }
4601:
4602: static int
4603: istgt_lu_disk_queue_abort_ITL(ISTGT_LU_DISK *spec, const char *initiator_port)
4604: {
4605: int rc;
4606:
4607: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "queue abort by port=%s\n",
4608: initiator_port);
4609:
4610: rc = istgt_lu_disk_queue_clear_internal(spec, initiator_port,
4611: 1, 0U); /* ALL, CmdSN=0 */
4612: return rc;
4613: }
4614:
4615: int
4616: istgt_lu_disk_queue_clear_IT(CONN_Ptr conn, ISTGT_LU_Ptr lu)
4617: {
4618: ISTGT_LU_DISK *spec;
4619: int rc;
4620: int i;
4621:
4622: if (lu == NULL)
4623: return -1;
4624:
4625: for (i = 0; i < lu->maxlun; i++) {
4626: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
4627: #if 0
4628: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
4629: lu->num, i);
4630: #endif
4631: continue;
4632: }
4633: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_STORAGE) {
4634: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
4635: return -1;
4636: }
4637: spec = (ISTGT_LU_DISK *) lu->lun[i].spec;
4638: if (spec == NULL) {
4639: continue;
4640: }
4641:
4642: rc = istgt_lu_disk_queue_clear_ITL(conn, lu, i);
4643: if (rc < 0) {
4644: return -1;
4645: }
4646: }
4647:
4648: return 0;
4649: }
4650:
4651: int
4652: istgt_lu_disk_queue_clear_ITL(CONN_Ptr conn, ISTGT_LU_Ptr lu, int lun)
4653: {
4654: ISTGT_LU_DISK *spec;
4655: int rc;
4656:
4657: if (lu == NULL)
4658: return -1;
4659: if (lun >= lu->maxlun)
4660: return -1;
4661:
4662: spec = (ISTGT_LU_DISK *) lu->lun[lun].spec;
4663: if (spec == NULL)
4664: return -1;
4665:
4666: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "queue clear by name=%s, port=%s\n",
4667: conn->initiator_name, conn->initiator_port);
4668:
4669: rc = istgt_lu_disk_queue_clear_internal(spec, conn->initiator_port,
4670: 1, 0U); /* ALL, CmdSN=0 */
4671: return rc;
4672: }
4673:
4674: int
4675: istgt_lu_disk_queue_clear_ITLQ(CONN_Ptr conn, ISTGT_LU_Ptr lu, int lun, uint32_t CmdSN)
4676: {
4677: ISTGT_LU_DISK *spec;
4678: int rc;
4679:
4680: if (lu == NULL)
4681: return -1;
4682: if (lun >= lu->maxlun)
4683: return -1;
4684:
4685: spec = (ISTGT_LU_DISK *) lu->lun[lun].spec;
4686: if (spec == NULL)
4687: return -1;
4688:
4689: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "queue clear by name=%s, port=%s\n",
4690: conn->initiator_name, conn->initiator_port);
4691:
4692: rc = istgt_lu_disk_queue_clear_internal(spec, conn->initiator_port,
4693: 0, CmdSN);
4694: return rc;
4695: }
4696:
4697: int
4698: istgt_lu_disk_queue_clear_all(ISTGT_LU_Ptr lu, int lun)
4699: {
4700: ISTGT_LU_TASK_Ptr lu_task;
4701: ISTGT_LU_DISK *spec;
4702: time_t now;
4703: int rc;
4704:
4705: if (lu == NULL)
4706: return -1;
4707: if (lun >= lu->maxlun)
4708: return -1;
4709:
4710: if (lu->lun[lun].type == ISTGT_LU_LUN_TYPE_NONE) {
4711: return -1;
4712: }
4713: if (lu->lun[lun].type != ISTGT_LU_LUN_TYPE_STORAGE) {
4714: return -1;
4715: }
4716: spec = (ISTGT_LU_DISK *) lu->lun[lun].spec;
4717: if (spec == NULL)
4718: return -1;
4719:
4720: now = time(NULL);
4721: MTX_LOCK(&spec->cmd_queue_mutex);
4722: while (1) {
4723: lu_task = istgt_queue_dequeue(&spec->cmd_queue);
4724: if (lu_task == NULL)
4725: break;
4726: ISTGT_LOG("CmdSN(%u), OP=0x%x, ElapsedTime=%u cleared\n",
4727: lu_task->lu_cmd.CmdSN,
4728: lu_task->lu_cmd.cdb[0],
4729: (now - lu_task->create_time));
4730: rc = istgt_lu_destroy_task(lu_task);
4731: if (rc < 0) {
4732: MTX_UNLOCK(&spec->cmd_queue_mutex);
4733: ISTGT_ERRLOG("lu_destory_task() failed\n");
4734: return -1;
4735: }
4736: }
4737: MTX_UNLOCK(&spec->cmd_queue_mutex);
4738:
4739: /* check wait task */
4740: MTX_LOCK(&spec->wait_lu_task_mutex);
4741: lu_task = spec->wait_lu_task;
4742: if (lu_task != NULL) {
4743: /* conn had gone? */
4744: rc = pthread_mutex_trylock(&lu_task->trans_mutex);
4745: if (rc == 0) {
4746: ISTGT_LOG("CmdSN(%u), OP=0x%x, ElapsedTime=%u aborted\n",
4747: lu_task->lu_cmd.CmdSN,
4748: lu_task->lu_cmd.cdb[0],
4749: (now - lu_task->create_time));
4750: /* force error */
4751: lu_task->error = 1;
4752: lu_task->abort = 1;
4753: rc = pthread_cond_broadcast(&lu_task->trans_cond);
4754: if (rc != 0) {
4755: /* ignore error */
4756: }
4757: MTX_UNLOCK(&lu_task->trans_mutex);
4758: }
4759: }
4760: MTX_UNLOCK(&spec->wait_lu_task_mutex);
4761:
4762: MTX_LOCK(&spec->cmd_queue_mutex);
4763: rc = istgt_queue_count(&spec->cmd_queue);
4764: MTX_UNLOCK(&spec->cmd_queue_mutex);
4765: if (rc != 0) {
4766: ISTGT_ERRLOG("cmd queue is not empty\n");
4767: return -1;
4768: }
4769:
4770: return 0;
4771: }
4772:
4773: int
4774: istgt_lu_disk_queue(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
4775: {
4776: ISTGT_LU_TASK_Ptr lu_task;
4777: ISTGT_LU_Ptr lu;
4778: ISTGT_LU_DISK *spec;
4779: uint8_t *data;
4780: uint8_t *cdb;
4781: uint32_t allocation_len;
4782: int data_len;
4783: int data_alloc_len;
4784: uint8_t *sense_data;
4785: int *sense_len;
4786: int lun_i;
4787: int maxq;
4788: int qcnt;
4789: int rc;
4790:
4791: if (lu_cmd == NULL)
4792: return -1;
4793: lu = lu_cmd->lu;
4794: if (lu == NULL) {
4795: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
4796: return -1;
4797: }
4798: spec = NULL;
4799: cdb = lu_cmd->cdb;
4800: data = lu_cmd->data;
4801: data_alloc_len = lu_cmd->alloc_len;
4802: sense_data = lu_cmd->sense_data;
4803: sense_len = &lu_cmd->sense_data_len;
4804: *sense_len = 0;
4805:
4806: lun_i = istgt_lu_islun2lun(lu_cmd->lun);
4807: if (lun_i >= lu->maxlun) {
4808: #ifdef ISTGT_TRACE_DISK
4809: ISTGT_ERRLOG("LU%d: LUN%4.4"PRIx64" invalid\n",
4810: lu->num, lun_i);
4811: #endif /* ISTGT_TRACE_DISK */
4812: if (cdb[0] == SPC_INQUIRY) {
4813: allocation_len = DGET16(&cdb[3]);
4814: if (allocation_len > data_alloc_len) {
4815: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
4816: data_alloc_len);
4817: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
4818: return -1;
4819: }
4820: memset(data, 0, allocation_len);
4821: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
4822: BDSET8W(&data[0], 0x03, 7, 3);
4823: BDADD8W(&data[0], 0x1f, 4, 5);
4824: data_len = 96;
4825: memset(&data[1], 0, data_len - 1);
4826: /* ADDITIONAL LENGTH */
4827: data[4] = data_len - 5;
4828: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
4829: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
4830: return ISTGT_LU_TASK_RESULT_IMMEDIATE;
4831: } else {
4832: /* LOGICAL UNIT NOT SUPPORTED */
4833: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
4834: lu_cmd->data_len = 0;
4835: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
4836: return ISTGT_LU_TASK_RESULT_IMMEDIATE;
4837: }
4838: }
4839: spec = (ISTGT_LU_DISK *) lu->lun[lun_i].spec;
4840: if (spec == NULL) {
4841: /* LOGICAL UNIT NOT SUPPORTED */
4842: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
4843: lu_cmd->data_len = 0;
4844: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
4845: return ISTGT_LU_TASK_RESULT_IMMEDIATE;
4846: }
4847: /* ready to enqueue, spec is valid for LUN access */
4848:
4849: /* allocate task and copy LU_CMD(PDU) */
4850: lu_task = xmalloc(sizeof *lu_task);
4851: memset(lu_task, 0, sizeof *lu_task);
4852: rc = istgt_lu_create_task(conn, lu_cmd, lu_task, lun_i);
4853: if (rc < 0) {
4854: ISTGT_ERRLOG("lu_create_task() failed\n");
4855: xfree(lu_task);
4856: return -1;
4857: }
4858:
4859: MTX_LOCK(&lu->queue_mutex);
4860: /* enqueue SCSI command */
4861: MTX_LOCK(&spec->cmd_queue_mutex);
4862: rc = istgt_queue_count(&spec->cmd_queue);
4863: maxq = spec->queue_depth * lu->istgt->MaxSessions;
4864: if (rc > maxq) {
4865: MTX_UNLOCK(&spec->cmd_queue_mutex);
4866: MTX_UNLOCK(&lu->queue_mutex);
4867: lu_cmd->data_len = 0;
4868: lu_cmd->status = ISTGT_SCSI_STATUS_TASK_SET_FULL;
4869: rc = istgt_lu_destroy_task(lu_task);
4870: if (rc < 0) {
4871: ISTGT_ERRLOG("lu_destroy_task() failed\n");
4872: return -1;
4873: }
4874: return ISTGT_LU_TASK_RESULT_QUEUE_FULL;
4875: }
4876: qcnt = rc;
4877: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
4878: "Queue(%d), CmdSN=%u, OP=0x%x, LUN=0x%16.16"PRIx64"\n",
4879: qcnt, lu_cmd->CmdSN, lu_cmd->cdb[0], lu_cmd->lun);
4880:
4881: /* enqueue task to LUN */
4882: switch (lu_cmd->Attr_bit) {
4883: case 0x03: /* Head of Queue */
4884: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert Head of Queue\n");
4885: rc = istgt_queue_enqueue_first(&spec->cmd_queue, lu_task);
4886: break;
4887: case 0x00: /* Untagged */
4888: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert Untagged\n");
4889: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4890: break;
4891: case 0x01: /* Simple */
4892: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert Simple\n");
4893: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4894: break;
4895: case 0x02: /* Ordered */
4896: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert Ordered\n");
4897: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4898: break;
4899: case 0x04: /* ACA */
4900: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert ACA\n");
4901: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4902: break;
4903: default: /* Reserved */
4904: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "insert Reserved Attribute\n");
4905: rc = istgt_queue_enqueue(&spec->cmd_queue, lu_task);
4906: break;
4907: }
4908: MTX_UNLOCK(&spec->cmd_queue_mutex);
4909: if (rc < 0) {
4910: MTX_UNLOCK(&lu->queue_mutex);
4911: ISTGT_ERRLOG("queue_enqueue() failed\n");
4912: error_return:
4913: rc = istgt_lu_destroy_task(lu_task);
4914: if (rc < 0) {
4915: ISTGT_ERRLOG("lu_destroy_task() failed\n");
4916: return -1;
4917: }
4918: return -1;
4919: }
4920:
4921: /* notify LUN thread */
4922: rc = pthread_cond_broadcast(&lu->queue_cond);
4923: MTX_UNLOCK(&lu->queue_mutex);
4924: if (rc != 0) {
4925: ISTGT_ERRLOG("LU%d: cond_broadcast() failed\n", lu->num);
4926: goto error_return;
4927: }
4928:
4929: return ISTGT_LU_TASK_RESULT_QUEUE_OK;
4930: }
4931:
4932: int
4933: istgt_lu_disk_queue_count(ISTGT_LU_Ptr lu, int *lun)
4934: {
4935: ISTGT_LU_DISK *spec;
4936: int qcnt;
4937: int luns;
4938: int i;
4939:
4940: if (lun == NULL)
4941: return -1;
4942:
4943: i = *lun;
4944: if (i >= lu->maxlun) {
4945: *lun = 0;
4946: i = 0;
4947: }
4948:
4949: qcnt = 0;
4950: for (luns = lu->maxlun; luns >= 0 ; luns--) {
4951: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
4952: goto next_lun;
4953: }
4954: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_STORAGE) {
4955: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
4956: goto next_lun;
4957: }
4958: spec = (ISTGT_LU_DISK *) lu->lun[i].spec;
4959: if (spec == NULL) {
4960: goto next_lun;
4961: }
4962:
4963: MTX_LOCK(&spec->cmd_queue_mutex);
4964: qcnt = istgt_queue_count(&spec->cmd_queue);
4965: MTX_UNLOCK(&spec->cmd_queue_mutex);
4966: if (qcnt > 0) {
4967: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
4968: "LU%d: LUN%d queue(%d)\n",
4969: lu->num, i, qcnt);
4970: *lun = spec->lun;
4971: break;
4972: }
4973:
4974: next_lun:
4975: i++;
4976: if (i >= lu->maxlun) {
4977: i = 0;
4978: }
4979: }
4980: return qcnt;
4981: }
4982:
4983: int
4984: istgt_lu_disk_queue_start(ISTGT_LU_Ptr lu, int lun)
4985: {
4986: ISTGT_Ptr istgt;
4987: ISTGT_LU_DISK *spec;
4988: ISTGT_LU_TASK_Ptr lu_task;
4989: CONN_Ptr conn;
4990: ISTGT_LU_CMD_Ptr lu_cmd;
4991: struct timespec abstime;
4992: time_t now;
4993: uint8_t *iobuf;
4994: char tmp[1];
4995: int abort_task = 0;
4996: int rc;
4997:
4998: if (lun < 0 || lun >= lu->maxlun) {
4999: return -1;
5000: }
5001:
5002: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LU%d: LUN%d queue start\n",
5003: lu->num, lun);
5004: spec = (ISTGT_LU_DISK *) lu->lun[lun].spec;
5005: if (spec == NULL)
5006: return -1;
5007:
5008: MTX_LOCK(&spec->cmd_queue_mutex);
5009: lu_task = istgt_queue_dequeue(&spec->cmd_queue);
5010: MTX_UNLOCK(&spec->cmd_queue_mutex);
5011: if (lu_task == NULL) {
5012: /* cleared or empty queue */
5013: return 0;
5014: }
5015: lu_task->thread = pthread_self();
5016: conn = lu_task->conn;
5017: istgt = conn->istgt;
5018: lu_cmd = &lu_task->lu_cmd;
5019:
5020: /* XXX need pre-allocate? */
5021: #if 0
5022: /* allocated in istgt_lu_create_task() */
5023: lu_task->data = xmalloc(lu_cmd->alloc_len);
5024: lu_task->sense_data = xmalloc(lu_cmd->sense_alloc_len);
5025: lu_task->iobuf = NULL;
5026: #endif
5027: lu_cmd->data = lu_task->data;
5028: lu_cmd->data_len = 0;
5029: lu_cmd->sense_data = lu_task->sense_data;
5030: lu_cmd->sense_data_len = 0;
5031:
5032: tmp[0] = 'Q';
5033: if (lu_cmd->W_bit) {
5034: if (lu_cmd->pdu->data_segment_len >= lu_cmd->transfer_len) {
5035: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
5036: "LU%d: LUN%d Task Write Immediate Start\n",
5037: lu->num, lun);
5038: #if 0
5039: iobuf = xmalloc(lu_cmd->pdu->data_segment_len);
5040: memcpy(iobuf, lu_cmd->pdu->data,
5041: lu_cmd->pdu->data_segment_len);
5042: lu_task->iobuf = iobuf;
5043: #else
5044: iobuf = lu_cmd->pdu->data;
5045: lu_task->dup_iobuf = 1;
5046: #endif
5047: lu_cmd->iobuf = iobuf;
5048:
5049: MTX_LOCK(&lu_cmd->lu->mutex);
5050: rc = istgt_lu_disk_execute(conn, lu_cmd);
5051: MTX_UNLOCK(&lu_cmd->lu->mutex);
5052: if (rc < 0) {
5053: ISTGT_ERRLOG("lu_disk_execute() failed\n");
5054: error_return:
5055: rc = istgt_lu_destroy_task(lu_task);
5056: if (rc < 0) {
5057: ISTGT_ERRLOG("lu_destroy_task() failed\n");
5058: return -1;
5059: }
5060: return -1;
5061: }
5062: lu_task->execute = 1;
5063:
5064: /* response */
5065: if (conn->use_sender == 0) {
5066: MTX_LOCK(&conn->task_queue_mutex);
5067: rc = istgt_queue_enqueue(&conn->task_queue, lu_task);
5068: MTX_UNLOCK(&conn->task_queue_mutex);
5069: if (rc < 0) {
5070: ISTGT_ERRLOG("queue_enqueue() failed\n");
5071: goto error_return;
5072: }
5073: rc = write(conn->task_pipe[1], tmp, 1);
5074: if(rc < 0 || rc != 1) {
5075: ISTGT_ERRLOG("write() failed\n");
5076: goto error_return;
5077: }
5078: } else {
5079: MTX_LOCK(&conn->result_queue_mutex);
5080: rc = istgt_queue_enqueue(&conn->result_queue, lu_task);
5081: if (rc < 0) {
5082: MTX_UNLOCK(&conn->result_queue_mutex);
5083: ISTGT_ERRLOG("queue_enqueue() failed\n");
5084: goto error_return;
5085: }
5086: rc = pthread_cond_broadcast(&conn->result_queue_cond);
5087: MTX_UNLOCK(&conn->result_queue_mutex);
5088: if (rc != 0) {
5089: ISTGT_ERRLOG("cond_broadcast() failed\n");
5090: goto error_return;
5091: }
5092: }
5093:
5094: #if 0
5095: /* write cache */
5096: if (spec->req_write_cache) {
5097: MTX_LOCK(&lu->mutex);
5098: rc = istgt_lu_disk_write_cache(spec, conn);
5099: MTX_UNLOCK(&lu->mutex);
5100: if (rc < 0) {
5101: ISTGT_ERRLOG("disk_write_cache() failed\n");
5102: return -1;
5103: }
5104: }
5105: #endif
5106: } else {
5107: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
5108: "LU%d: LUN%d Task Write Start\n",
5109: lu->num, lun);
5110:
5111: #if 0
5112: MTX_LOCK(&spec->wait_lu_task_mutex);
5113: spec->wait_lu_task = NULL;
5114: MTX_UNLOCK(&spec->wait_lu_task_mutex);
5115: #endif
5116: rc = pthread_mutex_init(&lu_task->trans_mutex, NULL);
5117: if (rc != 0) {
5118: ISTGT_ERRLOG("mutex_init() failed\n");
5119: goto error_return;
5120: }
5121: rc = pthread_cond_init(&lu_task->trans_cond, NULL);
5122: if (rc != 0) {
5123: ISTGT_ERRLOG("cond_init() failed\n");
5124: goto error_return;
5125: }
5126: rc = pthread_cond_init(&lu_task->exec_cond, NULL);
5127: if (rc != 0) {
5128: ISTGT_ERRLOG("cond_init() failed\n");
5129: goto error_return;
5130: }
5131: lu_task->use_cond = 1;
5132: #if 0
5133: lu_cmd->iobufsize = lu_cmd->transfer_len + 65536;
5134: iobuf = xmalloc(lu_cmd->iobufsize);
5135: lu_task->iobuf = iobuf;
5136: #else
5137: lu_cmd->iobufsize = lu_task->lu_cmd.iobufsize;
5138: iobuf = lu_task->iobuf;
5139: #endif
5140: lu_cmd->iobuf = iobuf;
5141: lu_task->req_transfer_out = 1;
5142: memset(&abstime, 0, sizeof abstime);
5143: abstime.tv_sec = 0;
5144: abstime.tv_nsec = 0;
5145:
5146: MTX_LOCK(&lu_task->trans_mutex);
5147: MTX_LOCK(&conn->task_queue_mutex);
5148: rc = istgt_queue_enqueue(&conn->task_queue, lu_task);
5149: MTX_UNLOCK(&conn->task_queue_mutex);
5150: if (rc < 0) {
5151: MTX_UNLOCK(&lu_task->trans_mutex);
5152: ISTGT_ERRLOG("queue_enqueue() failed\n");
5153: goto error_return;
5154: }
5155: rc = write(conn->task_pipe[1], tmp, 1);
5156: if(rc < 0 || rc != 1) {
5157: MTX_UNLOCK(&lu_task->trans_mutex);
5158: ISTGT_ERRLOG("write() failed\n");
5159: goto error_return;
5160: }
5161:
5162: now = time(NULL);
5163: abstime.tv_sec = now + (lu_task->condwait / 1000);
5164: abstime.tv_nsec = (lu_task->condwait % 1000) * 1000000;
5165: #if 0
5166: ISTGT_LOG("wait CmdSN=%u\n", lu_task->lu_cmd.CmdSN);
5167: #endif
5168: MTX_LOCK(&spec->wait_lu_task_mutex);
5169: spec->wait_lu_task = lu_task;
5170: MTX_UNLOCK(&spec->wait_lu_task_mutex);
5171: while (lu_task->req_transfer_out == 1) {
5172: rc = pthread_cond_timedwait(&lu_task->trans_cond,
5173: &lu_task->trans_mutex,
5174: &abstime);
5175: if (rc == ETIMEDOUT) {
5176: if (lu_task->req_transfer_out == 1) {
5177: lu_task->error = 1;
5178: MTX_LOCK(&spec->wait_lu_task_mutex);
5179: spec->wait_lu_task = NULL;
5180: MTX_UNLOCK(&spec->wait_lu_task_mutex);
5181: MTX_UNLOCK(&lu_task->trans_mutex);
5182: ISTGT_ERRLOG("timeout trans_cond CmdSN=%u\n",
5183: lu_task->lu_cmd.CmdSN);
5184: /* timeout */
5185: return -1;
5186: }
5187: /* OK cond */
5188: rc = 0;
5189: break;
5190: }
5191: if (lu_task->error != 0) {
5192: rc = -1;
5193: break;
5194: }
5195: if (rc != 0) {
5196: break;
5197: }
5198: }
5199: MTX_LOCK(&spec->wait_lu_task_mutex);
5200: spec->wait_lu_task = NULL;
5201: MTX_UNLOCK(&spec->wait_lu_task_mutex);
5202: MTX_UNLOCK(&lu_task->trans_mutex);
5203: if (rc != 0) {
5204: if (rc < 0) {
5205: lu_task->error = 1;
5206: if (lu_task->abort) {
5207: ISTGT_WARNLOG("transfer abort CmdSN=%u\n",
5208: lu_task->lu_cmd.CmdSN);
5209: return -2;
5210: } else {
5211: ISTGT_ERRLOG("transfer error CmdSN=%u\n",
5212: lu_task->lu_cmd.CmdSN);
5213: return -1;
5214: }
5215: }
5216: if (rc == ETIMEDOUT) {
5217: lu_task->error = 1;
5218: ISTGT_ERRLOG("timeout trans_cond CmdSN=%u\n",
5219: lu_task->lu_cmd.CmdSN);
5220: return -1;
5221: }
5222: lu_task->error = 1;
5223: ISTGT_ERRLOG("cond_timedwait rc=%d\n", rc);
5224: return -1;
5225: }
5226:
5227: if (lu_task->req_execute == 0) {
5228: ISTGT_ERRLOG("wrong request\n");
5229: goto error_return;
5230: }
5231: MTX_LOCK(&lu_cmd->lu->mutex);
5232: rc = istgt_lu_disk_execute(conn, lu_cmd);
5233: MTX_UNLOCK(&lu_cmd->lu->mutex);
5234: if (rc < 0) {
5235: lu_task->error = 1;
5236: ISTGT_ERRLOG("lu_disk_execute() failed\n");
5237: goto error_return;
5238: }
5239: lu_task->execute = 1;
5240:
5241: /* response */
5242: if (conn->use_sender == 0) {
5243: MTX_LOCK(&conn->task_queue_mutex);
5244: rc = istgt_queue_enqueue(&conn->task_queue, lu_task);
5245: MTX_UNLOCK(&conn->task_queue_mutex);
5246: if (rc < 0) {
5247: ISTGT_ERRLOG("queue_enqueue() failed\n");
5248: goto error_return;
5249: }
5250: rc = write(conn->task_pipe[1], tmp, 1);
5251: if(rc < 0 || rc != 1) {
5252: ISTGT_ERRLOG("write() failed\n");
5253: goto error_return;
5254: }
5255: } else {
5256: MTX_LOCK(&conn->result_queue_mutex);
5257: rc = istgt_queue_enqueue(&conn->result_queue, lu_task);
5258: if (rc < 0) {
5259: MTX_UNLOCK(&conn->result_queue_mutex);
5260: ISTGT_ERRLOG("queue_enqueue() failed\n");
5261: goto error_return;
5262: }
5263: rc = pthread_cond_broadcast(&conn->result_queue_cond);
5264: MTX_UNLOCK(&conn->result_queue_mutex);
5265: if (rc != 0) {
5266: ISTGT_ERRLOG("cond_broadcast() failed\n");
5267: goto error_return;
5268: }
5269: }
5270:
5271: #if 0
5272: /* write cache */
5273: if (spec->req_write_cache) {
5274: MTX_LOCK(&lu->mutex);
5275: rc = istgt_lu_disk_write_cache(spec, conn);
5276: MTX_UNLOCK(&lu->mutex);
5277: if (rc < 0) {
5278: ISTGT_ERRLOG("disk_write_cache() failed\n");
5279: return -1;
5280: }
5281: }
5282: #endif
5283: }
5284: } else {
5285: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
5286: "LU%d: LUN%d Task Read Start\n",
5287: lu->num, lun);
5288: #if 0
5289: lu_cmd->iobufsize = lu_cmd->transfer_len + 65536;
5290: iobuf = xmalloc(lu_cmd->iobufsize);
5291: lu_task->iobuf = iobuf;
5292: #else
5293: lu_cmd->iobufsize = lu_task->lu_cmd.iobufsize;
5294: iobuf = lu_task->iobuf;
5295: #endif
5296: lu_cmd->iobuf = iobuf;
5297: MTX_LOCK(&lu_cmd->lu->mutex);
5298: rc = istgt_lu_disk_execute(conn, lu_cmd);
5299: MTX_UNLOCK(&lu_cmd->lu->mutex);
5300: if (rc < 0) {
5301: ISTGT_ERRLOG("lu_disk_execute() failed\n");
5302: goto error_return;
5303: }
5304: lu_task->execute = 1;
5305:
5306: /* response */
5307: if (conn->use_sender == 0) {
5308: MTX_LOCK(&conn->task_queue_mutex);
5309: rc = istgt_queue_enqueue(&conn->task_queue, lu_task);
5310: MTX_UNLOCK(&conn->task_queue_mutex);
5311: if (rc < 0) {
5312: ISTGT_ERRLOG("queue_enqueue() failed\n");
5313: goto error_return;
5314: }
5315: rc = write(conn->task_pipe[1], tmp, 1);
5316: if(rc < 0 || rc != 1) {
5317: ISTGT_ERRLOG("write() failed\n");
5318: goto error_return;
5319: }
5320: } else {
5321: MTX_LOCK(&conn->result_queue_mutex);
5322: rc = istgt_queue_enqueue(&conn->result_queue, lu_task);
5323: if (rc < 0) {
5324: MTX_UNLOCK(&conn->result_queue_mutex);
5325: ISTGT_ERRLOG("queue_enqueue() failed\n");
5326: goto error_return;
5327: }
5328: rc = pthread_cond_broadcast(&conn->result_queue_cond);
5329: MTX_UNLOCK(&conn->result_queue_mutex);
5330: if (rc != 0) {
5331: ISTGT_ERRLOG("cond_broadcast() failed\n");
5332: goto error_return;
5333: }
5334: }
5335: }
5336:
5337: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LU%d: LUN%d queue end\n",
5338: lu->num, lun);
5339:
5340: if (abort_task) {
5341: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Abort Task\n");
5342: return -1;
5343: }
5344: return 0;
5345: }
5346:
5347: int
5348: istgt_lu_disk_execute(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
5349: {
5350: ISTGT_LU_Ptr lu;
5351: ISTGT_LU_DISK *spec;
5352: uint8_t *data;
5353: uint8_t *cdb;
5354: uint32_t allocation_len;
5355: int data_len;
5356: int data_alloc_len;
5357: uint64_t lba;
5358: uint32_t len;
5359: uint32_t transfer_len;
5360: uint32_t parameter_len;
5361: uint8_t *sense_data;
5362: int *sense_len;
5363: int lun_i;
5364: int rc;
5365:
5366: if (lu_cmd == NULL)
5367: return -1;
5368: lu = lu_cmd->lu;
5369: if (lu == NULL) {
5370: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5371: return -1;
5372: }
5373: spec = NULL;
5374: cdb = lu_cmd->cdb;
5375: data = lu_cmd->data;
5376: data_alloc_len = lu_cmd->alloc_len;
5377: sense_data = lu_cmd->sense_data;
5378: sense_len = &lu_cmd->sense_data_len;
5379: *sense_len = 0;
5380:
5381: lun_i = istgt_lu_islun2lun(lu_cmd->lun);
5382: if (lun_i >= lu->maxlun) {
5383: #ifdef ISTGT_TRACE_DISK
5384: ISTGT_ERRLOG("LU%d: LUN%4.4"PRIx64" invalid\n",
5385: lu->num, lun_i);
5386: #endif /* ISTGT_TRACE_DISK */
5387: if (cdb[0] == SPC_INQUIRY) {
5388: allocation_len = DGET16(&cdb[3]);
5389: if (allocation_len > data_alloc_len) {
5390: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5391: data_alloc_len);
5392: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5393: return -1;
5394: }
5395: memset(data, 0, allocation_len);
5396: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
5397: BDSET8W(&data[0], 0x03, 7, 3);
5398: BDADD8W(&data[0], 0x1f, 4, 5);
5399: data_len = 96;
5400: memset(&data[1], 0, data_len - 1);
5401: /* ADDITIONAL LENGTH */
5402: data[4] = data_len - 5;
5403: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5404: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5405: return 0;
5406: } else {
5407: /* LOGICAL UNIT NOT SUPPORTED */
5408: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
5409: lu_cmd->data_len = 0;
5410: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5411: return 0;
5412: }
5413: }
5414: spec = (ISTGT_LU_DISK *) lu->lun[lun_i].spec;
5415: if (spec == NULL) {
5416: /* LOGICAL UNIT NOT SUPPORTED */
5417: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
5418: lu_cmd->data_len = 0;
5419: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5420: return 0;
5421: }
5422:
5423: if (spec->sense != 0) {
5424: int sk, asc, ascq;
5425: if (cdb[0] != SPC_INQUIRY
5426: && cdb[0] != SPC_REPORT_LUNS) {
5427: sk = (spec->sense >> 16) & 0xffU;
5428: asc = (spec->sense >> 8) & 0xffU;
5429: ascq = (spec->sense >> 0) & 0xffU;
5430: spec->sense = 0;
5431: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
5432: "Generate sk=0x%x, asc=0x%x, ascq=0x%x\n",
5433: sk, asc, ascq);
5434: *sense_len
5435: = istgt_lu_disk_build_sense_data(spec, sense_data,
5436: sk, asc, ascq);
5437: lu_cmd->data_len = 0;
5438: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5439: return 0;
5440: }
5441: }
5442:
5443: if (spec->err_write_cache) {
5444: /* WRITE ERROR - AUTO REALLOCATION FAILED */
5445: BUILD_SENSE2(MEDIUM_ERROR, 0x0c, 0x02);
5446: #if 0
5447: /* WRITE ERROR - RECOMMEND REASSIGNMENT */
5448: BUILD_SENSE2(MEDIUM_ERROR, 0x0c, 0x03);
5449: #endif
5450: spec->err_write_cache = 0;
5451: lba = spec->woffset / spec->blocklen;
5452: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
5453: "Deferred error (write cache) at %"PRIu64"\n", lba);
5454: if (lba > 0xffffffffULL) {
5455: ISTGT_WARNLOG("lba > 0xffffffff\n");
5456: }
5457: /* COMMAND-SPECIFIC INFORMATION */
5458: DSET32(&sense_data[8], (uint32_t)(lba & 0xffffffffULL));
5459: lu_cmd->data_len = 0;
5460: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5461: return 0;
5462: }
5463:
5464: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
5465: "SCSI OP=0x%x, LUN=0x%16.16"PRIx64"\n",
5466: cdb[0], lu_cmd->lun);
5467: #ifdef ISTGT_TRACE_DISK
5468: if (cdb[0] != SPC_TEST_UNIT_READY) {
5469: istgt_scsi_dump_cdb(cdb);
5470: }
5471: #endif /* ISTGT_TRACE_DISK */
5472: switch (cdb[0]) {
5473: case SPC_INQUIRY:
5474: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "INQUIRY\n");
5475: if (lu_cmd->R_bit == 0) {
5476: ISTGT_ERRLOG("R_bit == 0\n");
5477: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5478: return -1;
5479: }
5480: allocation_len = DGET16(&cdb[3]);
5481: if (allocation_len > data_alloc_len) {
5482: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5483: data_alloc_len);
5484: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5485: return -1;
5486: }
5487: memset(data, 0, allocation_len);
5488: data_len = istgt_lu_disk_scsi_inquiry(spec, conn, cdb,
5489: data, data_alloc_len);
5490: if (data_len < 0) {
5491: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5492: break;
5493: }
5494: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "INQUIRY", data, data_len);
5495: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5496: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5497: break;
5498:
5499: case SPC_REPORT_LUNS:
5500: {
5501: int sel;
5502:
5503: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REPORT LUNS\n");
5504: if (lu_cmd->R_bit == 0) {
5505: ISTGT_ERRLOG("R_bit == 0\n");
5506: return -1;
5507: }
5508:
5509: sel = cdb[2];
5510: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "sel=%x\n", sel);
5511:
5512: allocation_len = DGET32(&cdb[6]);
5513: if (allocation_len > data_alloc_len) {
5514: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5515: data_alloc_len);
5516: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5517: return -1;
5518: }
5519: if (allocation_len < 16) {
5520: /* INVALID FIELD IN CDB */
5521: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
5522: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5523: break;
5524: }
5525: memset(data, 0, allocation_len);
5526: data_len = istgt_lu_disk_scsi_report_luns(lu, conn, cdb, sel,
5527: data, data_alloc_len);
5528: if (data_len < 0) {
5529: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5530: break;
5531: }
5532: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "REPORT LUNS", data, data_len);
5533: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5534: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5535: }
5536: break;
5537:
5538: case SPC_TEST_UNIT_READY:
5539: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "TEST_UNIT_READY\n");
5540: lu_cmd->data_len = 0;
5541: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5542: break;
5543:
5544: case SBC_START_STOP_UNIT:
5545: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "START_STOP_UNIT\n");
5546: {
5547: int pc, loej, start;
5548:
5549: pc = BGET8W(&cdb[4], 7, 4);
5550: loej = BGET8(&cdb[4], 1);
5551: start = BGET8(&cdb[4], 0);
5552:
5553: if (start != 0 || pc != 0) {
5554: if (spec->rsv_key) {
5555: rc = istgt_lu_disk_check_pr(spec, conn,
5556: PR_ALLOW(0,0,1,0,0));
5557: if (rc != 0) {
5558: lu_cmd->status
5559: = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5560: break;
5561: }
5562: }
5563: }
5564:
5565: lu_cmd->data_len = 0;
5566: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5567: }
5568: break;
5569:
5570: case SBC_READ_CAPACITY_10:
5571: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ_CAPACITY_10\n");
5572: if (lu_cmd->R_bit == 0) {
5573: ISTGT_ERRLOG("R_bit == 0\n");
5574: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5575: return -1;
5576: }
5577: if (spec->blockcnt - 1 > 0xffffffffULL) {
5578: DSET32(&data[0], 0xffffffffUL);
5579: } else {
5580: DSET32(&data[0], (uint32_t) (spec->blockcnt - 1));
5581: }
5582: DSET32(&data[4], (uint32_t) spec->blocklen);
5583: data_len = 8;
5584: lu_cmd->data_len = data_len;
5585: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5586: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
5587: "SBC_READ_CAPACITY_10", data, data_len);
5588: break;
5589:
5590: case SPC_SERVICE_ACTION_IN_16:
5591: switch (BGET8W(&cdb[1], 4, 5)) { /* SERVICE ACTION */
5592: case SBC_SAI_READ_CAPACITY_16:
5593: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ_CAPACITY_16\n");
5594: if (lu_cmd->R_bit == 0) {
5595: ISTGT_ERRLOG("R_bit == 0\n");
5596: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5597: return -1;
5598: }
5599: allocation_len = DGET32(&cdb[10]);
5600: if (allocation_len > data_alloc_len) {
5601: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5602: data_alloc_len);
5603: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5604: return -1;
5605: }
5606: memset(data, 0, allocation_len);
5607: DSET64(&data[0], spec->blockcnt - 1);
5608: DSET32(&data[8], (uint32_t) spec->blocklen);
5609: data[12] = 0; /* RTO_EN(1) PROT_EN(0) */
5610: memset(&data[13], 0, 32 - (8 + 4 + 1)); /* Reserved */
5611: data_len = 32;
5612: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5613: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5614: break;
5615: case SBC_SAI_READ_LONG_16:
5616: default:
5617: /* INVALID COMMAND OPERATION CODE */
5618: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
5619: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5620: break;
5621: }
5622: break;
5623:
5624: case SPC_MODE_SELECT_6:
5625: #if 0
5626: istgt_scsi_dump_cdb(cdb);
5627: #endif
5628: {
5629: int pf, sp, pllen;
5630: int mdlen, mt, dsp, bdlen;
5631:
5632: if (spec->rsv_key) {
5633: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
5634: if (rc != 0) {
5635: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5636: break;
5637: }
5638: }
5639:
5640: pf = BGET8(&cdb[1], 4);
5641: sp = BGET8(&cdb[1], 0);
5642: pllen = cdb[4]; /* Parameter List Length */
5643:
5644: if (pllen == 0) {
5645: lu_cmd->data_len = 0;
5646: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5647: break;
5648: }
5649: /* Data-Out */
5650: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
5651: lu_cmd->iobufsize, pllen);
5652: if (rc < 0) {
5653: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
5654: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5655: break;
5656: }
5657: if (pllen < 4) {
5658: /* INVALID FIELD IN CDB */
5659: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
5660: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5661: break;
5662: }
5663: #if 0
5664: istgt_dump("MODE SELECT(6)", lu_cmd->iobuf, pllen);
5665: #endif
5666: data = lu_cmd->iobuf;
5667: mdlen = data[0]; /* Mode Data Length */
5668: mt = data[1]; /* Medium Type */
5669: dsp = data[2]; /* Device-Specific Parameter */
5670: bdlen = data[3]; /* Block Descriptor Length */
5671:
5672: /* Short LBA mode parameter block descriptor */
5673: /* data[4]-data[7] Number of Blocks */
5674: /* data[8]-data[11] Block Length */
5675:
5676: /* page data */
5677: data_len = istgt_lu_disk_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[4 + bdlen], pllen - (4 + bdlen));
5678: if (data_len != 0) {
5679: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5680: break;
5681: }
5682: lu_cmd->data_len = pllen;
5683: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5684: break;
5685: }
5686:
5687: case SPC_MODE_SELECT_10:
5688: #if 0
5689: istgt_scsi_dump_cdb(cdb);
5690: #endif
5691: {
5692: int pf, sp, pllen;
5693: int mdlen, mt, dsp, bdlen;
5694: int llba;
5695:
5696: if (spec->rsv_key) {
5697: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
5698: if (rc != 0) {
5699: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5700: break;
5701: }
5702: }
5703:
5704: pf = BGET8(&cdb[1], 4);
5705: sp = BGET8(&cdb[1], 0);
5706: pllen = DGET16(&cdb[7]); /* Parameter List Length */
5707:
5708: if (pllen == 0) {
5709: lu_cmd->data_len = 0;
5710: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5711: break;
5712: }
5713: /* Data-Out */
5714: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
5715: lu_cmd->iobufsize, pllen);
5716: if (rc < 0) {
5717: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
5718: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5719: break;
5720: }
5721: if (pllen < 4) {
5722: /* INVALID FIELD IN CDB */
5723: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
5724: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5725: break;
5726: }
5727: #if 0
5728: istgt_dump("MODE SELECT(10)", lu_cmd->iobuf, pllen);
5729: #endif
5730: data = lu_cmd->iobuf;
5731: mdlen = DGET16(&data[0]); /* Mode Data Length */
5732: mt = data[2]; /* Medium Type */
5733: dsp = data[3]; /* Device-Specific Parameter */
5734: llba = BGET8(&data[4], 0); /* Long LBA */
5735: bdlen = DGET16(&data[6]); /* Block Descriptor Length */
5736:
5737: if (llba) {
5738: /* Long LBA mode parameter block descriptor */
5739: /* data[8]-data[15] Number of Blocks */
5740: /* data[16]-data[19] Reserved */
5741: /* data[20]-data[23] Block Length */
5742: } else {
5743: /* Short LBA mode parameter block descriptor */
5744: /* data[8]-data[11] Number of Blocks */
5745: /* data[12]-data[15] Block Length */
5746: }
5747:
5748: /* page data */
5749: data_len = istgt_lu_disk_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[8 + bdlen], pllen - (8 + bdlen));
5750: if (data_len != 0) {
5751: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5752: break;
5753: }
5754: lu_cmd->data_len = pllen;
5755: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5756: break;
5757: }
5758:
5759: case SPC_MODE_SENSE_6:
5760: #if 0
5761: istgt_scsi_dump_cdb(cdb);
5762: #endif
5763: {
5764: int dbd, pc, page, subpage;
5765:
5766: if (spec->rsv_key) {
5767: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
5768: if (rc != 0) {
5769: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5770: break;
5771: }
5772: }
5773:
5774: if (lu_cmd->R_bit == 0) {
5775: ISTGT_ERRLOG("R_bit == 0\n");
5776: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5777: return -1;
5778: }
5779:
5780: dbd = BGET8(&cdb[1], 3);
5781: pc = BGET8W(&cdb[2], 7, 2);
5782: page = BGET8W(&cdb[2], 5, 6);
5783: subpage = cdb[3];
5784:
5785: allocation_len = cdb[4];
5786: if (allocation_len > data_alloc_len) {
5787: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5788: data_alloc_len);
5789: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5790: return -1;
5791: }
5792: memset(data, 0, allocation_len);
5793:
5794: data_len = istgt_lu_disk_scsi_mode_sense6(spec, conn, cdb, dbd, pc, page, subpage, data, data_alloc_len);
5795: if (data_len < 0) {
5796: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5797: break;
5798: }
5799: #if 0
5800: istgt_dump("MODE SENSE(6)", data, data_len);
5801: #endif
5802: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5803: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5804: break;
5805: }
5806:
5807: case SPC_MODE_SENSE_10:
5808: #if 0
5809: istgt_scsi_dump_cdb(cdb);
5810: #endif
5811: {
5812: int dbd, pc, page, subpage;
5813: int llbaa;
5814:
5815: if (spec->rsv_key) {
5816: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
5817: if (rc != 0) {
5818: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5819: break;
5820: }
5821: }
5822:
5823: if (lu_cmd->R_bit == 0) {
5824: ISTGT_ERRLOG("R_bit == 0\n");
5825: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5826: return -1;
5827: }
5828:
5829: llbaa = BGET8(&cdb[1], 4);
5830: dbd = BGET8(&cdb[1], 3);
5831: pc = BGET8W(&cdb[2], 7, 2);
5832: page = BGET8W(&cdb[2], 5, 6);
5833: subpage = cdb[3];
5834:
5835: allocation_len = DGET16(&cdb[7]);
5836: if (allocation_len > data_alloc_len) {
5837: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5838: data_alloc_len);
5839: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5840: return -1;
5841: }
5842: memset(data, 0, allocation_len);
5843:
5844: data_len = istgt_lu_disk_scsi_mode_sense10(spec, conn, cdb, llbaa, dbd, pc, page, subpage, data, data_alloc_len);
5845: if (data_len < 0) {
5846: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5847: break;
5848: }
5849: #if 0
5850: istgt_dump("MODE SENSE(10)", data, data_len);
5851: #endif
5852: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5853: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5854: break;
5855: }
5856:
5857: #if 0
5858: case SPC_LOG_SELECT:
5859: case SPC_LOG_SENSE:
5860: /* INVALID COMMAND OPERATION CODE */
5861: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
5862: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5863: break;
5864: #endif
5865:
5866: case SPC_REQUEST_SENSE:
5867: {
5868: int desc;
5869: int sk, asc, ascq;
5870:
5871: if (lu_cmd->R_bit == 0) {
5872: ISTGT_ERRLOG("R_bit == 0\n");
5873: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5874: return -1;
5875: }
5876:
5877: desc = BGET8(&cdb[1], 0);
5878: if (desc != 0) {
5879: /* INVALID FIELD IN CDB */
5880: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
5881: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5882: break;
5883: }
5884:
5885: allocation_len = cdb[4];
5886: if (allocation_len > data_alloc_len) {
5887: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
5888: data_alloc_len);
5889: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5890: return -1;
5891: }
5892: memset(data, 0, allocation_len);
5893:
5894: if (!spec->sense) {
5895: /* NO ADDITIONAL SENSE INFORMATION */
5896: sk = ISTGT_SCSI_SENSE_NO_SENSE;
5897: asc = 0x00;
5898: ascq = 0x00;
5899: } else {
5900: sk = (spec->sense >> 16) & 0xffU;
5901: asc = (spec->sense >> 8) & 0xffU;
5902: ascq = spec->sense & 0xffU;
5903: }
5904: data_len = istgt_lu_disk_build_sense_data(spec, sense_data,
5905: sk, asc, ascq);
5906: if (data_len < 0 || data_len < 2) {
5907: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5908: break;
5909: }
5910: /* omit SenseLength */
5911: data_len -= 2;
5912: memcpy(data, sense_data + 2, data_len);
5913: #if 0
5914: istgt_dump("REQUEST SENSE", data, data_len);
5915: #endif
5916: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
5917: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5918: break;
5919: }
5920:
5921: case SBC_READ_6:
5922: {
5923: if (spec->rsv_key) {
5924: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
5925: if (rc != 0) {
5926: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5927: break;
5928: }
5929: }
5930:
5931: if (lu_cmd->R_bit == 0) {
5932: ISTGT_ERRLOG("R_bit == 0\n");
5933: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5934: return -1;
5935: }
5936:
5937: lba = (uint64_t) (DGET24(&cdb[1]) & 0x001fffffU);
5938: transfer_len = (uint32_t) DGET8(&cdb[4]);
5939: if (transfer_len == 0) {
5940: transfer_len = 256;
5941: }
5942: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
5943: "READ_6(lba %"PRIu64", len %u blocks)\n",
5944: lba, transfer_len);
5945: rc = istgt_lu_disk_lbread(spec, conn, lu_cmd, lba, transfer_len);
5946: if (rc < 0) {
5947: ISTGT_ERRLOG("lu_disk_lbread() failed\n");
5948: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5949: break;
5950: }
5951: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5952: break;
5953: }
5954:
5955: case SBC_READ_10:
5956: {
5957: int dpo, fua, fua_nv;
5958:
5959: if (spec->rsv_key) {
5960: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
5961: if (rc != 0) {
5962: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5963: break;
5964: }
5965: }
5966:
5967: if (lu_cmd->R_bit == 0) {
5968: ISTGT_ERRLOG("R_bit == 0\n");
5969: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5970: return -1;
5971: }
5972:
5973: dpo = BGET8(&cdb[1], 4);
5974: fua = BGET8(&cdb[1], 3);
5975: fua_nv = BGET8(&cdb[1], 1);
5976: lba = (uint64_t) DGET32(&cdb[2]);
5977: transfer_len = (uint32_t) DGET16(&cdb[7]);
5978: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
5979: "READ_10(lba %"PRIu64", len %u blocks)\n",
5980: lba, transfer_len);
5981: rc = istgt_lu_disk_lbread(spec, conn, lu_cmd, lba, transfer_len);
5982: if (rc < 0) {
5983: ISTGT_ERRLOG("lu_disk_lbread() failed\n");
5984: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
5985: break;
5986: }
5987: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
5988: break;
5989: }
5990:
5991: case SBC_READ_12:
5992: {
5993: int dpo, fua, fua_nv;
5994:
5995: if (spec->rsv_key) {
5996: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
5997: if (rc != 0) {
5998: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
5999: break;
6000: }
6001: }
6002:
6003: if (lu_cmd->R_bit == 0) {
6004: ISTGT_ERRLOG("R_bit == 0\n");
6005: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6006: return -1;
6007: }
6008:
6009: dpo = BGET8(&cdb[1], 4);
6010: fua = BGET8(&cdb[1], 3);
6011: fua_nv = BGET8(&cdb[1], 1);
6012: lba = (uint64_t) DGET32(&cdb[2]);
6013: transfer_len = (uint32_t) DGET32(&cdb[6]);
6014: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6015: "READ_12(lba %"PRIu64", len %u blocks)\n",
6016: lba, transfer_len);
6017: rc = istgt_lu_disk_lbread(spec, conn, lu_cmd, lba, transfer_len);
6018: if (rc < 0) {
6019: ISTGT_ERRLOG("lu_disk_lbread() failed\n");
6020: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6021: break;
6022: }
6023: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6024: break;
6025: }
6026:
6027: case SBC_READ_16:
6028: {
6029: int dpo, fua, fua_nv;
6030:
6031: if (spec->rsv_key) {
6032: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
6033: if (rc != 0) {
6034: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6035: break;
6036: }
6037: }
6038:
6039: if (lu_cmd->R_bit == 0) {
6040: ISTGT_ERRLOG("R_bit == 0\n");
6041: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6042: return -1;
6043: }
6044:
6045: dpo = BGET8(&cdb[1], 4);
6046: fua = BGET8(&cdb[1], 3);
6047: fua_nv = BGET8(&cdb[1], 1);
6048: lba = (uint64_t) DGET64(&cdb[2]);
6049: transfer_len = (uint32_t) DGET32(&cdb[10]);
6050: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6051: "READ_16(lba %"PRIu64", len %u blocks)\n",
6052: lba, transfer_len);
6053: rc = istgt_lu_disk_lbread(spec, conn, lu_cmd, lba, transfer_len);
6054: if (rc < 0) {
6055: ISTGT_ERRLOG("lu_disk_lbread() failed\n");
6056: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6057: break;
6058: }
6059: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6060: break;
6061: }
6062:
6063: case SBC_WRITE_6:
6064: {
6065: if (spec->rsv_key) {
6066: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6067: if (rc != 0) {
6068: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6069: break;
6070: }
6071: }
6072:
6073: if (lu_cmd->W_bit == 0) {
6074: ISTGT_ERRLOG("W_bit == 0\n");
6075: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6076: return -1;
6077: }
6078:
6079: lba = (uint64_t) (DGET24(&cdb[1]) & 0x001fffffU);
6080: transfer_len = (uint32_t) DGET8(&cdb[4]);
6081: if (transfer_len == 0) {
6082: transfer_len = 256;
6083: }
6084: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6085: "WRITE_6(lba %"PRIu64", len %u blocks)\n",
6086: lba, transfer_len);
6087: rc = istgt_lu_disk_lbwrite(spec, conn, lu_cmd, lba, transfer_len);
6088: if (rc < 0) {
6089: ISTGT_ERRLOG("lu_disk_lbwrite() failed\n");
6090: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6091: break;
6092: }
6093: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6094: break;
6095: }
6096:
6097: case SBC_WRITE_10:
6098: case SBC_WRITE_AND_VERIFY_10:
6099: {
6100: int dpo, fua, fua_nv;
6101:
6102: if (spec->rsv_key) {
6103: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6104: if (rc != 0) {
6105: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6106: break;
6107: }
6108: }
6109:
6110: if (lu_cmd->W_bit == 0) {
6111: ISTGT_ERRLOG("W_bit == 0\n");
6112: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6113: return -1;
6114: }
6115:
6116: dpo = BGET8(&cdb[1], 4);
6117: fua = BGET8(&cdb[1], 3);
6118: fua_nv = BGET8(&cdb[1], 1);
6119: lba = (uint64_t) DGET32(&cdb[2]);
6120: transfer_len = (uint32_t) DGET16(&cdb[7]);
6121: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6122: "WRITE_10(lba %"PRIu64", len %u blocks)\n",
6123: lba, transfer_len);
6124: rc = istgt_lu_disk_lbwrite(spec, conn, lu_cmd, lba, transfer_len);
6125: if (rc < 0) {
6126: ISTGT_ERRLOG("lu_disk_lbwrite() failed\n");
6127: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6128: break;
6129: }
6130: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6131: break;
6132: }
6133:
6134: case SBC_WRITE_12:
6135: case SBC_WRITE_AND_VERIFY_12:
6136: {
6137: int dpo, fua, fua_nv;
6138:
6139: if (spec->rsv_key) {
6140: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6141: if (rc != 0) {
6142: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6143: break;
6144: }
6145: }
6146:
6147: if (lu_cmd->W_bit == 0) {
6148: ISTGT_ERRLOG("W_bit == 0\n");
6149: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6150: return -1;
6151: }
6152:
6153: dpo = BGET8(&cdb[1], 4);
6154: fua = BGET8(&cdb[1], 3);
6155: fua_nv = BGET8(&cdb[1], 1);
6156: lba = (uint64_t) DGET32(&cdb[2]);
6157: transfer_len = (uint32_t) DGET32(&cdb[6]);
6158: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6159: "WRITE_12(lba %"PRIu64", len %u blocks)\n",
6160: lba, transfer_len);
6161: rc = istgt_lu_disk_lbwrite(spec, conn, lu_cmd, lba, transfer_len);
6162: if (rc < 0) {
6163: ISTGT_ERRLOG("lu_disk_lbwrite() failed\n");
6164: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6165: break;
6166: }
6167: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6168: break;
6169: }
6170:
6171: case SBC_WRITE_16:
6172: case SBC_WRITE_AND_VERIFY_16:
6173: {
6174: int dpo, fua, fua_nv;
6175:
6176: if (spec->rsv_key) {
6177: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6178: if (rc != 0) {
6179: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6180: break;
6181: }
6182: }
6183:
6184: if (lu_cmd->W_bit == 0) {
6185: ISTGT_ERRLOG("W_bit == 0\n");
6186: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6187: return -1;
6188: }
6189:
6190: dpo = BGET8(&cdb[1], 4);
6191: fua = BGET8(&cdb[1], 3);
6192: fua_nv = BGET8(&cdb[1], 1);
6193: lba = (uint64_t) DGET64(&cdb[2]);
6194: transfer_len = (uint32_t) DGET32(&cdb[10]);
6195: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6196: "WRITE_16(lba %"PRIu64", len %u blocks)\n",
6197: lba, transfer_len);
6198: rc = istgt_lu_disk_lbwrite(spec, conn, lu_cmd, lba, transfer_len);
6199: if (rc < 0) {
6200: ISTGT_ERRLOG("lu_disk_lbwrite() failed\n");
6201: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6202: break;
6203: }
6204: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6205: break;
6206: }
6207:
6208: case SBC_VERIFY_10:
6209: {
6210: int dpo, bytchk;
6211:
6212: if (spec->rsv_key) {
6213: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
6214: if (rc != 0) {
6215: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6216: break;
6217: }
6218: }
6219:
6220: dpo = BGET8(&cdb[1], 4);
6221: bytchk = BGET8(&cdb[1], 1);
6222: lba = (uint64_t) DGET32(&cdb[2]);
6223: len = (uint32_t) DGET16(&cdb[7]);
6224: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6225: "VERIFY_10(lba %"PRIu64", len %u blocks)\n",
6226: lba, len);
6227: lu_cmd->data_len = 0;
6228: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6229: break;
6230: }
6231:
6232: case SBC_VERIFY_12:
6233: {
6234: int dpo, bytchk;
6235:
6236: if (spec->rsv_key) {
6237: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
6238: if (rc != 0) {
6239: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6240: break;
6241: }
6242: }
6243:
6244: dpo = BGET8(&cdb[1], 4);
6245: bytchk = BGET8(&cdb[1], 1);
6246: lba = (uint64_t) DGET32(&cdb[2]);
6247: len = (uint32_t) DGET32(&cdb[6]);
6248: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6249: "VERIFY_12(lba %"PRIu64", len %u blocks)\n",
6250: lba, len);
6251: lu_cmd->data_len = 0;
6252: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6253: break;
6254: }
6255:
6256: case SBC_VERIFY_16:
6257: {
6258: int dpo, bytchk;
6259:
6260: if (spec->rsv_key) {
6261: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(1,0,1,1,0));
6262: if (rc != 0) {
6263: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6264: break;
6265: }
6266: }
6267:
6268: dpo = BGET8(&cdb[1], 4);
6269: bytchk = BGET8(&cdb[1], 1);
6270: lba = (uint64_t) DGET64(&cdb[2]);
6271: len = (uint32_t) DGET32(&cdb[10]);
6272: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6273: "VERIFY_16(lba %"PRIu64", len %u blocks)\n",
6274: lba, len);
6275: lu_cmd->data_len = 0;
6276: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6277: break;
6278: }
6279:
6280: case SBC_WRITE_SAME_10:
6281: {
6282: int wprotect, pbdata, lbdata, group_no;
6283:
6284: if (spec->rsv_key) {
6285: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6286: if (rc != 0) {
6287: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6288: break;
6289: }
6290: }
6291:
6292: if (lu_cmd->W_bit == 0) {
6293: ISTGT_ERRLOG("W_bit == 0\n");
6294: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6295: return -1;
6296: }
6297:
6298: wprotect = BGET8W(&cdb[1], 7, 3);
6299: pbdata = BGET8(&cdb[1], 2);
6300: lbdata = BGET8(&cdb[1], 1);
6301: lba = (uint64_t) DGET32(&cdb[2]);
6302: transfer_len = (uint32_t) DGET16(&cdb[7]);
6303: group_no = BGET8W(&cdb[6], 4, 5);
6304:
6305: /* only PBDATA=0 and LBDATA=0 support */
6306: if (pbdata || lbdata) {
6307: /* INVALID FIELD IN CDB */
6308: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6309: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6310: break;
6311: }
6312:
6313: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6314: "WRITE_SAME_10(lba %"PRIu64", len %u blocks)\n",
6315: lba, transfer_len);
6316: rc = istgt_lu_disk_lbwrite_same(spec, conn, lu_cmd, lba, transfer_len);
6317: if (rc < 0) {
6318: ISTGT_ERRLOG("lu_disk_lbwrite_same() failed\n");
6319: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6320: break;
6321: }
6322: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6323: break;
6324: }
6325:
6326: case SBC_WRITE_SAME_16:
6327: {
6328: int wprotect, anchor, unmap, pbdata, lbdata, group_no;
6329:
6330: #if 0
6331: istgt_scsi_dump_cdb(cdb);
6332: #endif
6333: if (spec->rsv_key) {
6334: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6335: if (rc != 0) {
6336: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6337: break;
6338: }
6339: }
6340:
6341: if (lu_cmd->W_bit == 0) {
6342: ISTGT_ERRLOG("W_bit == 0\n");
6343: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6344: return -1;
6345: }
6346:
6347: wprotect = BGET8W(&cdb[1], 7, 3);
6348: anchor = BGET8(&cdb[1], 4);
6349: unmap = BGET8(&cdb[1], 3);
6350: pbdata = BGET8(&cdb[1], 2);
6351: lbdata = BGET8(&cdb[1], 1);
6352: lba = (uint64_t) DGET64(&cdb[2]);
6353: transfer_len = (uint32_t) DGET32(&cdb[10]);
6354: group_no = BGET8W(&cdb[14], 4, 5);
6355:
6356: /* only PBDATA=0 and LBDATA=0 support */
6357: if (pbdata || lbdata) {
6358: /* INVALID FIELD IN CDB */
6359: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6360: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6361: break;
6362: }
6363: if (anchor) {
6364: /* INVALID FIELD IN CDB */
6365: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6366: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6367: break;
6368: }
6369:
6370: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6371: "WRITE_SAME_16(lba %"PRIu64", len %u blocks)\n",
6372: lba, transfer_len);
6373: rc = istgt_lu_disk_lbwrite_same(spec, conn, lu_cmd, lba, transfer_len);
6374: if (rc < 0) {
6375: ISTGT_ERRLOG("lu_disk_lbwrite_same() failed\n");
6376: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6377: break;
6378: }
6379: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6380: break;
6381: }
6382:
6383: case SBC_COMPARE_AND_WRITE:
6384: {
6385: int64_t maxlen;
6386: int wprotect, dpo, fua, fua_nv, group_no;
6387:
6388: #if 0
6389: istgt_scsi_dump_cdb(cdb);
6390: #endif
6391: if (spec->lu->istgt->swmode == ISTGT_SWMODE_TRADITIONAL) {
6392: /* INVALID COMMAND OPERATION CODE */
6393: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
6394: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6395: break;
6396: }
6397: if (spec->rsv_key) {
6398: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6399: if (rc != 0) {
6400: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6401: break;
6402: }
6403: }
6404:
6405: if (lu_cmd->W_bit == 0) {
6406: ISTGT_ERRLOG("W_bit == 0\n");
6407: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6408: return -1;
6409: }
6410:
6411: wprotect = BGET8W(&cdb[1], 7, 3);
6412: dpo = BGET8(&cdb[1], 4);
6413: fua = BGET8(&cdb[1], 3);
6414: fua_nv = BGET8(&cdb[1], 1);
6415: lba = (uint64_t) DGET64(&cdb[2]);
6416: transfer_len = (uint32_t) DGET8(&cdb[13]);
6417: group_no = BGET8W(&cdb[14], 4, 5);
6418:
6419: maxlen = ISTGT_LU_WORK_BLOCK_SIZE / spec->blocklen;
6420: if (maxlen > 0xff) {
6421: maxlen = 0xff;
6422: }
6423: if (transfer_len > maxlen) {
6424: /* INVALID FIELD IN CDB */
6425: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6426: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6427: break;
6428: }
6429:
6430: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6431: "COMPARE_AND_WRITE(lba %"PRIu64", len %u blocks)\n",
6432: lba, transfer_len);
6433: rc = istgt_lu_disk_lbwrite_ats(spec, conn, lu_cmd, lba, transfer_len);
6434: if (rc < 0) {
6435: //ISTGT_ERRLOG("lu_disk_lbwrite_ats() failed\n");
6436: /* sense data build by function */
6437: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6438: break;
6439: }
6440: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6441: break;
6442: }
6443:
6444: case SBC_SYNCHRONIZE_CACHE_10:
6445: {
6446: int sync_nv, immed;
6447:
6448: if (spec->rsv_key) {
6449: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6450: if (rc != 0) {
6451: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6452: break;
6453: }
6454: }
6455:
6456: sync_nv = BGET8(&cdb[1], 2);
6457: immed = BGET8(&cdb[1], 1);
6458: lba = (uint64_t) DGET32(&cdb[2]);
6459: len = (uint32_t) DGET16(&cdb[7]);
6460: if (len == 0) {
6461: len = spec->blockcnt;
6462: }
6463: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6464: "SYNCHRONIZE_CACHE_10(lba %"PRIu64
6465: ", len %u blocks)\n",
6466: lba, len);
6467: rc = istgt_lu_disk_lbsync(spec, conn, lu_cmd, lba, len);
6468: if (rc < 0) {
6469: ISTGT_ERRLOG("lu_disk_lbsync() failed\n");
6470: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6471: break;
6472: }
6473: lu_cmd->data_len = 0;
6474: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6475: break;
6476: }
6477:
6478: case SBC_SYNCHRONIZE_CACHE_16:
6479: {
6480: int sync_nv, immed;
6481:
6482: if (spec->rsv_key) {
6483: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6484: if (rc != 0) {
6485: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6486: break;
6487: }
6488: }
6489:
6490: sync_nv = BGET8(&cdb[1], 2);
6491: immed = BGET8(&cdb[1], 1);
6492: lba = (uint64_t) DGET64(&cdb[2]);
6493: len = (uint32_t) DGET32(&cdb[10]);
6494: if (len == 0) {
6495: len = spec->blockcnt;
6496: }
6497: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6498: "SYNCHRONIZE_CACHE_10(lba %"PRIu64
6499: ", len %u blocks)\n",
6500: lba, len);
6501: rc = istgt_lu_disk_lbsync(spec, conn, lu_cmd, lba, len);
6502: if (rc < 0) {
6503: ISTGT_ERRLOG("lu_disk_lbsync() failed\n");
6504: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6505: break;
6506: }
6507: lu_cmd->data_len = 0;
6508: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6509: break;
6510: }
6511:
6512: case SCC_MAINTENANCE_IN:
6513: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MAINTENANCE_IN\n");
6514: switch (BGET8W(&cdb[1], 4, 5)) { /* SERVICE ACTION */
6515: case SPC_MI_REPORT_TARGET_PORT_GROUPS:
6516: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REPORT_TARGET_PORT_GROUPS\n");
6517: if (lu_cmd->R_bit == 0) {
6518: ISTGT_ERRLOG("R_bit == 0\n");
6519: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6520: return -1;
6521: }
6522: allocation_len = DGET32(&cdb[6]);
6523: if (allocation_len > data_alloc_len) {
6524: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
6525: data_alloc_len);
6526: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6527: return -1;
6528: }
6529: memset(data, 0, allocation_len);
6530: data_len = istgt_lu_disk_scsi_report_target_port_groups(spec, conn, cdb, data, data_alloc_len);
6531: if (data_len < 0) {
6532: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6533: break;
6534: }
6535: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
6536: "REPORT_TARGET_PORT_GROUPS", data, data_len);
6537: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
6538: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6539: break;
6540: default:
6541: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "SA=0x%2.2x\n",
6542: BGET8W(&cdb[1], 4, 5));
6543: /* INVALID COMMAND OPERATION CODE */
6544: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
6545: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6546: break;
6547: }
6548: break;
6549:
6550: case SCC_MAINTENANCE_OUT:
6551: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MAINTENANCE_OUT\n");
6552: switch (BGET8W(&cdb[1], 4, 5)) { /* SERVICE ACTION */
6553: case SPC_MO_SET_TARGET_PORT_GROUPS:
6554: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "SET_TARGET_PORT_GROUPS\n");
6555: if (spec->rsv_key) {
6556: rc = istgt_lu_disk_check_pr(spec, conn, PR_ALLOW(0,0,1,0,0));
6557: if (rc != 0) {
6558: lu_cmd->status = ISTGT_SCSI_STATUS_RESERVATION_CONFLICT;
6559: break;
6560: }
6561: }
6562: if (lu_cmd->W_bit == 0) {
6563: ISTGT_ERRLOG("W_bit == 0\n");
6564: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6565: return -1;
6566: }
6567: parameter_len = DGET32(&cdb[6]);
6568: if (parameter_len == 0) {
6569: lu_cmd->data_len = 0;
6570: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6571: break;
6572: }
6573: /* Data-Out */
6574: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
6575: lu_cmd->iobufsize, parameter_len);
6576: if (rc < 0) {
6577: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
6578: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6579: break;
6580: }
6581: if (parameter_len < 4) {
6582: /* INVALID FIELD IN CDB */
6583: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6584: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6585: break;
6586: }
6587: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
6588: "SET_TARGET_PORT_GROUPS",
6589: lu_cmd->iobuf, parameter_len);
6590: data = lu_cmd->iobuf;
6591: /* data[0]-data[3] Reserved */
6592: /* Set target port group descriptor(s) */
6593: data_len = istgt_lu_disk_scsi_set_target_port_groups(spec, conn, cdb, &data[4], parameter_len - 4);
6594: if (data_len < 0) {
6595: /* INVALID FIELD IN PARAMETER LIST */
6596: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
6597: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6598: break;
6599: }
6600: lu_cmd->data_len = parameter_len;
6601: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6602: break;
6603: default:
6604: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "SA=0x%2.2x\n",
6605: BGET8W(&cdb[1], 4, 5));
6606: /* INVALID COMMAND OPERATION CODE */
6607: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
6608: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6609: break;
6610: }
6611: break;
6612:
6613: case SPC_PERSISTENT_RESERVE_IN:
6614: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "PERSISTENT_RESERVE_IN\n");
6615: {
6616: int sa;
6617:
6618: if (lu_cmd->R_bit == 0) {
6619: ISTGT_ERRLOG("R_bit == 0\n");
6620: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6621: return -1;
6622: }
6623:
6624: sa = BGET8W(&cdb[1], 4, 5);
6625: allocation_len = DGET16(&cdb[7]);
6626: if (allocation_len > data_alloc_len) {
6627: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
6628: data_alloc_len);
6629: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6630: return -1;
6631: }
6632: memset(data, 0, allocation_len);
6633:
6634: data_len = istgt_lu_disk_scsi_persistent_reserve_in(spec, conn, lu_cmd, sa, data, allocation_len);
6635: if (data_len < 0) {
6636: /* status build by function */
6637: break;
6638: }
6639: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
6640: "PERSISTENT_RESERVE_IN", data, data_len);
6641: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
6642: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6643: }
6644: break;
6645:
6646: case SPC_PERSISTENT_RESERVE_OUT:
6647: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "PERSISTENT_RESERVE_OUT\n");
6648: {
6649: int sa, scope, type;
6650:
6651: if (lu_cmd->W_bit == 0) {
6652: ISTGT_ERRLOG("W_bit == 0\n");
6653: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6654: return -1;
6655: }
6656:
6657: sa = BGET8W(&cdb[1], 4, 5);
6658: scope = BGET8W(&cdb[2], 7, 4);
6659: type = BGET8W(&cdb[2], 3, 4);
6660: parameter_len = DGET32(&cdb[5]);
6661:
6662: /* Data-Out */
6663: rc = istgt_lu_disk_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
6664: lu_cmd->iobufsize, parameter_len);
6665: if (rc < 0) {
6666: ISTGT_ERRLOG("lu_disk_transfer_data() failed\n");
6667: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6668: break;
6669: }
6670: if (parameter_len < 24) {
6671: /* INVALID FIELD IN CDB */
6672: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
6673: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6674: break;
6675: }
6676:
6677: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
6678: "PERSISTENT_RESERVE_OUT",
6679: lu_cmd->iobuf, parameter_len);
6680: data = lu_cmd->iobuf;
6681:
6682: data_len = istgt_lu_disk_scsi_persistent_reserve_out(spec, conn, lu_cmd, sa, scope, type, &data[0], parameter_len);
6683: if (data_len < 0) {
6684: /* status build by function */
6685: break;
6686: }
6687: lu_cmd->data_len = parameter_len;
6688: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6689: }
6690: break;
6691:
6692: /* XXX TODO: fix */
6693: case SPC_EXTENDED_COPY:
6694: /* INVALID COMMAND OPERATION CODE */
6695: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
6696: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6697: break;
6698: case SPC2_RELEASE_6:
6699: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RELEASE_6\n");
6700: rc = istgt_lu_disk_scsi_release(spec, conn, lu_cmd);
6701: if (rc < 0) {
6702: /* build by function */
6703: break;
6704: }
6705: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6706: break;
6707: case SPC2_RELEASE_10:
6708: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RELEASE_10\n");
6709: rc = istgt_lu_disk_scsi_release(spec, conn, lu_cmd);
6710: if (rc < 0) {
6711: /* build by function */
6712: break;
6713: }
6714: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6715: break;
6716: case SPC2_RESERVE_6:
6717: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RESERVE_6\n");
6718: rc = istgt_lu_disk_scsi_reserve(spec, conn, lu_cmd);
6719: if (rc < 0) {
6720: /* build by function */
6721: break;
6722: }
6723: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6724: break;
6725: case SPC2_RESERVE_10:
6726: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RESERVE_10\n");
6727: rc = istgt_lu_disk_scsi_reserve(spec, conn, lu_cmd);
6728: if (rc < 0) {
6729: /* build by function */
6730: break;
6731: }
6732: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
6733: break;
6734:
6735: default:
6736: ISTGT_ERRLOG("unsupported SCSI OP=0x%x\n", cdb[0]);
6737: /* INVALID COMMAND OPERATION CODE */
6738: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
6739: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
6740: break;
6741: }
6742:
6743: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
6744: "SCSI OP=0x%x, LUN=0x%16.16"PRIx64" status=0x%x,"
6745: " complete\n",
6746: cdb[0], lu_cmd->lun, lu_cmd->status);
6747: return 0;
6748: }