Annotation of embedaddon/istgt/src/istgt_lu_tape.c, revision 1.1
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 <sys/types.h>
! 39: #include <sys/stat.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 <sys/types.h>
! 49: #include <sys/stat.h>
! 50:
! 51: #include "istgt.h"
! 52: #include "istgt_ver.h"
! 53: #include "istgt_log.h"
! 54: #include "istgt_conf.h"
! 55: #include "istgt_sock.h"
! 56: #include "istgt_misc.h"
! 57: #include "istgt_iscsi.h"
! 58: #include "istgt_lu.h"
! 59: #include "istgt_proto.h"
! 60: #include "istgt_scsi.h"
! 61:
! 62: #define TAPE_DEBUG
! 63: //#define ISTGT_TRACE_TAPE
! 64:
! 65: #define DENSITY_DFLT (TAPE_DENSITY_DEFAULT)
! 66: //#define MEDIATYPE_DFLT (TAPE_MEDIATYPE_DLT_III)
! 67: //#define DENSITY_DFLT (TAPE_DENSITY_DLT_III)
! 68: #define MEDIATYPE_DFLT (TAPE_MEDIATYPE_DLT_IV)
! 69: //#define DENSITY_DFLT (TAPE_DENSITY_DLT_IV)
! 70: //#define MEDIATYPE_DFLT (TAPE_MEDIATYPE_SDLT_I)
! 71: //#define DENSITY_DFLT (TAPE_DENSITY_SDLT_I)
! 72: //#define MEDIATYPE_DFLT (TAPE_MEDIATYPE_LTO4)
! 73: //#define DENSITY_DFLT (TAPE_DENSITY_LTO4)
! 74:
! 75: /* Block Alignment for emulation tape */
! 76: #define TAPE_BLOCKLEN 512
! 77: #define TAPE_ALIGNMENT 8
! 78: #define COMPRESSION_DFLT 1
! 79:
! 80: #define ISCSI_DLT 0
! 81: #define ISCSI_LTO 1
! 82:
! 83: #define TAPE_VENDOR "QUANTUM"
! 84: #define TAPE_PRODUCT "DLT8000"
! 85: #define TAPE_REVISION "CX01" /* servo + r/w */
! 86: #define TAPE_MODULE_REV "C001"
! 87: #if 0
! 88: #define TAPE_PRODUCT "DLT4000"
! 89: #define TAPE_REVISION "CD01"
! 90: #define TAPE_MODULE_REV "C001"
! 91: #endif
! 92:
! 93: #if 0
! 94: /* Quantum DLT8000 */
! 95: #define TAPE_MAXIMUM_BLOCK_LENGTH 0x0ffffe
! 96: #define TAPE_MINIMUM_BLOCK_LENGTH 0x000000
! 97: #define TAPE_WRITE_DELAY 200 /* x 100ms */
! 98: /* for multiple of 4bytes */
! 99: #define TAPE_MAXIMUM_BLOCK_LENGTH 0xfffffc
! 100: #define TAPE_MINIMUM_BLOCK_LENGTH 0x000004
! 101: #endif
! 102: /* for multiple of 8bytes */
! 103: #define TAPE_MAXIMUM_BLOCK_LENGTH 0xfffff8
! 104: #define TAPE_MINIMUM_BLOCK_LENGTH 0x000008
! 105: //#define TAPE_WRITE_DELAY 0x000f /* x 100ms */
! 106: #define TAPE_WRITE_DELAY 200 /* x 100ms */
! 107: #define TAPE_COMP_ALGORITHM 0x10 /* IBM IDRC */
! 108:
! 109: #define TAPE_MEDIATYPE_NONE 0x00
! 110: #define TAPE_MEDIATYPE_DLT_CL 0x81
! 111: #define TAPE_MEDIATYPE_DLT_III 0x83
! 112: #define TAPE_MEDIATYPE_DLT_IIIXT 0x84
! 113: #define TAPE_MEDIATYPE_DLT_IV 0x85
! 114: #define TAPE_MEDIATYPE_SDLT_I 0x86
! 115: #define TAPE_MEDIATYPE_SDLT_II 0x87
! 116: #define TAPE_MEDIATYPE_DLT_S4 0x91
! 117: #define TAPE_MEDIATYPE_LTO1 0x18
! 118: #define TAPE_MEDIATYPE_LTO2 0x28
! 119: #define TAPE_MEDIATYPE_LTO3 0x38
! 120: #define TAPE_MEDIATYPE_LTO4 0x48
! 121:
! 122: #define TAPE_DENSITY_DEFAULT 0x00
! 123: #define TAPE_DENSITY_DLT_III 0x19
! 124: #define TAPE_DENSITY_DLT_IV20 0x1a
! 125: #define TAPE_DENSITY_DLT_IV35 0x1b
! 126: #define TAPE_DENSITY_DLT_IV 0x41
! 127: #define TAPE_DENSITY_SDLT_I 0x49
! 128: #define TAPE_DENSITY_SDLT_II 0x4a
! 129: #define TAPE_DENSITY_DLT_S4 0x4b
! 130: #define TAPE_DENSITY_LTO1 0x40
! 131: #define TAPE_DENSITY_LTO2 0x42
! 132: #define TAPE_DENSITY_LTO3 0x44
! 133: #define TAPE_DENSITY_LTO4 0x46
! 134:
! 135: #define CTLBLOCKLEN (128*1024)
! 136: #define CTLMAGIC "ISVTCTRL"
! 137: #define CTLMAGICLEN 8
! 138: #define CTLVERSION 0ULL
! 139: #define CTLENDIAN 0x1122334455667788ULL
! 140: #define MARK_END 0xffffffffffffffffULL
! 141: #define MARK_EOD 0xfffffffffffffffeULL
! 142: #define LBPOS_INVALID 0xffffffffffffffffULL
! 143: #define LBPOS_MAX 0xfffffffffffffffeULL
! 144:
! 145: typedef struct tape_markpos_t {
! 146: uint64_t lbpos; /* logical position */
! 147: uint64_t offset; /* physical position */
! 148: uint64_t prev; /* previous position if not zero */
! 149: uint64_t junk1;
! 150: } tape_markpos_t;
! 151:
! 152: /* Control Block = 128K */
! 153: #define MAX_FILEMARKS (1024)
! 154: typedef struct tape_ctlblock_t {
! 155: /* 16k block 0-2 */
! 156: uint8_t magic[8]; /* 'ISVTCTRL' (network order) */
! 157: uint64_t endian; /* endian ID = 0x1122334455667788ULL */
! 158: uint64_t version; /* version = 0 */
! 159: uint64_t ctlblocklen; /* ctlblocklen = 128K */
! 160:
! 161: uint64_t blocklen; /* blocklen = 512 */
! 162: uint64_t marklen; /* marklen = 128 */
! 163: uint64_t alignment; /* alignment = 8 */
! 164: uint64_t allocate; /* allocate = 0 */
! 165:
! 166: uint64_t type; /* media type = default */
! 167: uint64_t id; /* media ID = empty */
! 168: uint64_t size; /* media size = empty */
! 169: uint64_t junk1;
! 170:
! 171: uint64_t reserve0[512-12]; /* room for 4K(8x512) */
! 172: tape_markpos_t marks[MAX_FILEMARKS]; /* marks[0] = BOT, ..., EOT 32K */
! 173: uint8_t reserve2[(16*1024) - (8*512)];
! 174:
! 175: /* 16k block 3-7 */
! 176: uint8_t reserve3[(16*1024)];
! 177: uint8_t reserve4[(16*1024)];
! 178: uint8_t reserve5[(16*1024)];
! 179: uint8_t reserve6[(16*1024)];
! 180: uint8_t reserve7[(16*1024)];
! 181: } tape_ctlblock_t;
! 182:
! 183: /* physical marker in virtual tape */
! 184: #define MARK_LENGTH 128
! 185: #define MARK_MAXLENGTH (TAPE_BLOCKLEN)
! 186: #define MARK_MAGICLEN 8
! 187: #define MARK_VERSION 0ULL
! 188: #define MARK_ENDIAN 0x1122334455667788ULL
! 189: #define MARK_BOTMAGIC "ISVTBOTB"
! 190: #define MARK_EOTMAGIC "ISVTEOTB"
! 191: #define MARK_EOFMAGIC "ISVTEOFB"
! 192: #define MARK_EODMAGIC "ISVTEODB"
! 193: #define MARK_DATAMAGIC "ISVTDATA"
! 194: #define MARK_COMPALGO_NONE 0
! 195:
! 196: /* Mark Block = 128B */
! 197: typedef struct tape_markblock_t {
! 198: uint8_t magic[8]; /* 'ISVT'+ 'BOTB' / 'DATA' / 'EOFB' */
! 199: uint64_t endian; /* endian ID = 0x1122334455667788ULL */
! 200: uint64_t version; /* version = 0 */
! 201: uint64_t marklen; /* marklen = 128 */
! 202:
! 203: uint64_t lblen; /* logical block length */
! 204: uint64_t lbpos; /* logical block position */
! 205: uint64_t offset; /* self physical offset */
! 206: uint64_t prev; /* previous offset if non zero */
! 207:
! 208: uint64_t compalgo; /* compression algorithm (0=none) */
! 209: uint64_t vtcompalgo; /* VT compression algorithm (0=none) */
! 210: uint64_t vtdecomplen; /* VT decompression length */
! 211: uint64_t junk1;
! 212:
! 213: /* reserved */
! 214: uint64_t reserve[16-12]; /* 128B(8x16) */
! 215: } tape_markblock_t;
! 216:
! 217:
! 218: typedef struct istgt_lu_tape_t {
! 219: ISTGT_LU_Ptr lu;
! 220: int num;
! 221: int lun;
! 222:
! 223: int fd;
! 224: const char *file;
! 225: uint64_t size;
! 226: uint64_t blocklen;
! 227: uint64_t blockcnt;
! 228:
! 229: #ifdef HAVE_UUID_H
! 230: uuid_t uuid;
! 231: #endif /* HAVE_UUID_H */
! 232:
! 233: /* flags */
! 234: int mflags;
! 235:
! 236: tape_ctlblock_t *ctlblock; /* control block */
! 237: tape_markblock_t *markblock; /* mark block */
! 238:
! 239: uint64_t lblen; /* logical block length for fixed */
! 240: uint64_t lbpos; /* logical block position */
! 241:
! 242: uint64_t offset; /* physical offset in virtual tape */
! 243: uint64_t prev; /* previous offset if not zero */
! 244: int index; /* current maker index */
! 245:
! 246: int compalgo; /* compression algorithme */
! 247: int vtcompalgo; /* compression algorithme in vtape */
! 248:
! 249: /* pending flags */
! 250: int need_savectl;
! 251: int need_writeeod;
! 252:
! 253: /* media state */
! 254: volatile int mload;
! 255: volatile int mchanged;
! 256: volatile int mwait;
! 257:
! 258: /* mode flags */
! 259: volatile int lock;
! 260: int compression;
! 261: int bot;
! 262: int eof;
! 263: int eod;
! 264: int eom;
! 265:
! 266: /* SCSI sense code */
! 267: volatile int sense;
! 268:
! 269: /* command information */
! 270: uint32_t info;
! 271: } ISTGT_LU_TAPE;
! 272:
! 273: #define BUILD_SENSE(SK,ASC,ASCQ) \
! 274: do { \
! 275: *sense_len = \
! 276: istgt_lu_tape_build_sense_data(spec, sense_data, \
! 277: ISTGT_SCSI_SENSE_ ## SK, \
! 278: (ASC), (ASCQ)); \
! 279: } while (0)
! 280:
! 281: static int istgt_lu_tape_save_ctlblock(ISTGT_LU_TAPE *spec);
! 282: static int istgt_lu_tape_allocate(ISTGT_LU_TAPE *spec);
! 283: static int istgt_lu_tape_build_sense_data(ISTGT_LU_TAPE *spec, uint8_t *data, int sk, int asc, int ascq);
! 284:
! 285: static int
! 286: istgt_lu_tape_open(ISTGT_LU_TAPE *spec, int flags, int mode)
! 287: {
! 288: int rc;
! 289:
! 290: rc = open(spec->file, flags, mode);
! 291: if (rc < 0) {
! 292: return -1;
! 293: }
! 294: spec->fd = rc;
! 295: return 0;
! 296: }
! 297:
! 298: static int
! 299: istgt_lu_tape_close(ISTGT_LU_TAPE *spec)
! 300: {
! 301: int rc;
! 302:
! 303: if (spec->fd == -1)
! 304: return 0;
! 305: rc = close(spec->fd);
! 306: if (rc < 0) {
! 307: return -1;
! 308: }
! 309: spec->fd = -1;
! 310: return 0;
! 311: }
! 312:
! 313: static int64_t
! 314: istgt_lu_tape_seek(ISTGT_LU_TAPE *spec, uint64_t offset)
! 315: {
! 316: off_t rc;
! 317:
! 318: rc = lseek(spec->fd, (off_t) offset, SEEK_SET);
! 319: if (rc < 0) {
! 320: return -1;
! 321: }
! 322: return 0;
! 323: }
! 324:
! 325: static int64_t
! 326: istgt_lu_tape_read(ISTGT_LU_TAPE *spec, void *buf, uint64_t nbytes)
! 327: {
! 328: int64_t rc;
! 329:
! 330: rc = (int64_t) read(spec->fd, buf, (size_t) nbytes);
! 331: if (rc < 0) {
! 332: return -1;
! 333: }
! 334: return rc;
! 335: }
! 336:
! 337: static int64_t
! 338: istgt_lu_tape_write(ISTGT_LU_TAPE *spec, const void *buf, uint64_t nbytes)
! 339: {
! 340: int64_t rc;
! 341:
! 342: rc = (int64_t) write(spec->fd, buf, (size_t) nbytes);
! 343: if (rc < 0) {
! 344: return -1;
! 345: }
! 346: return rc;
! 347: }
! 348:
! 349: static int64_t
! 350: istgt_lu_tape_sync(ISTGT_LU_TAPE *spec, uint64_t offset, uint64_t nbytes)
! 351: {
! 352: int64_t rc;
! 353:
! 354: rc = (int64_t) fsync(spec->fd);
! 355: if (rc < 0) {
! 356: return -1;
! 357: }
! 358: return rc;
! 359: }
! 360:
! 361: #if 0
! 362: static uint64_t
! 363: swap_uint64(uint64_t val)
! 364: {
! 365: uint64_t r;
! 366: int i;
! 367:
! 368: r = 0;
! 369: for (i = 0; i < sizeof(uint64_t); i++) {
! 370: r |= val & 0xffULL;
! 371: r <<= 8;
! 372: val >>= 8;
! 373: }
! 374: return r;
! 375: }
! 376: #endif
! 377:
! 378: #define SWAP_UINT64(D) \
! 379: ((( (D) >> (56 - 0 )) & 0x00000000000000ffULL) \
! 380: | (((D) << (56 - 0 )) & 0xff00000000000000ULL) \
! 381: | (((D) >> (48 - 8 )) & 0x000000000000ff00ULL) \
! 382: | (((D) << (48 - 8 )) & 0x00ff000000000000ULL) \
! 383: | (((D) >> (40 - 16)) & 0x0000000000ff0000ULL) \
! 384: | (((D) << (40 - 16)) & 0x0000ff0000000000ULL) \
! 385: | (((D) >> (32 - 24)) & 0x00000000ff000000ULL) \
! 386: | (((D) << (32 - 24)) & 0x000000ff00000000ULL))
! 387:
! 388:
! 389: static int
! 390: istgt_lu_tape_read_native_mark(ISTGT_LU_TAPE *spec, tape_markblock_t *mbp)
! 391: {
! 392: uint64_t marklen;
! 393: uint64_t *lp;
! 394: int64_t rc;
! 395: int i;
! 396:
! 397: marklen = spec->ctlblock->marklen;
! 398:
! 399: rc = istgt_lu_tape_read(spec, mbp, marklen);
! 400: if (rc < 0 || rc != marklen) {
! 401: ISTGT_ERRLOG("lu_tape_read() failed: rc %d\n", rc);
! 402: return -1;
! 403: }
! 404: if (mbp->endian != MARK_ENDIAN) {
! 405: /* convert byte order but except magic */
! 406: lp = (uint64_t *) mbp;
! 407: for (i = 1; i < marklen / sizeof(uint64_t); i++) {
! 408: lp[i] = SWAP_UINT64(lp[i]);
! 409: }
! 410: }
! 411: return 0;
! 412: }
! 413:
! 414: static int
! 415: istgt_lu_tape_write_native_mark(ISTGT_LU_TAPE *spec, tape_markblock_t *mbp)
! 416: {
! 417: uint64_t marklen;
! 418: int64_t rc;
! 419:
! 420: marklen = spec->ctlblock->marklen;
! 421:
! 422: rc = istgt_lu_tape_write(spec, mbp, marklen);
! 423: if (rc != marklen) {
! 424: ISTGT_ERRLOG("lu_tape_write() failed at offset %" PRIu64 ", size %" PRIu64 "\n", spec->offset, spec->size);
! 425: return -1;
! 426: }
! 427: return 0;
! 428: }
! 429:
! 430: static int
! 431: istgt_lu_tape_write_padding(ISTGT_LU_TAPE *spec, uint8_t *data)
! 432: {
! 433: uint64_t tape_leader;
! 434: uint64_t offset;
! 435: uint64_t alignment, padlen;
! 436: int64_t rc;
! 437:
! 438: tape_leader = spec->ctlblock->ctlblocklen;
! 439: offset = spec->offset;
! 440: alignment = spec->ctlblock->alignment;
! 441:
! 442: if (offset % alignment) {
! 443: padlen = alignment;
! 444: padlen -= offset % alignment;
! 445: memset(data, 0, alignment);
! 446: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 447: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 448: return -1;
! 449: }
! 450: rc = istgt_lu_tape_write(spec, data, padlen);
! 451: if (rc < 0 || rc != padlen) {
! 452: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 453: return -1;
! 454: }
! 455: offset += padlen;
! 456: spec->offset = offset;
! 457: }
! 458: return 0;
! 459: }
! 460:
! 461: static int
! 462: istgt_lu_tape_write_eof(ISTGT_LU_TAPE *spec, int count, uint8_t *data)
! 463: {
! 464: tape_markblock_t *mbp;
! 465: uint64_t tape_leader;
! 466: uint64_t lbpos, offset, prev, version, marklen;
! 467: int index_i;
! 468: int i;
! 469:
! 470: if (count <= 0) {
! 471: // flush buffer
! 472: return 0;
! 473: }
! 474:
! 475: if (istgt_lu_tape_write_padding(spec, data) < 0) {
! 476: ISTGT_ERRLOG("lu_tape_write_padding() failed\n");
! 477: return -1;
! 478: }
! 479:
! 480: tape_leader = spec->ctlblock->ctlblocklen;
! 481: lbpos = spec->lbpos;
! 482: offset = spec->offset;
! 483: prev = spec->prev;
! 484: index_i = spec->index;
! 485: version = spec->ctlblock->version;
! 486: marklen = spec->ctlblock->marklen;
! 487:
! 488: /* prepare mark */
! 489: mbp = (tape_markblock_t *) data;
! 490: memset(mbp, 0, marklen);
! 491: memcpy(mbp->magic, MARK_EOFMAGIC, MARK_MAGICLEN);
! 492: mbp->endian = MARK_ENDIAN;
! 493: mbp->version = MARK_VERSION;
! 494: mbp->marklen = marklen;
! 495: mbp->lblen = 0ULL;
! 496: mbp->compalgo = 0ULL;
! 497: mbp->vtcompalgo = 0ULL;
! 498: mbp->vtdecomplen = 0ULL;
! 499:
! 500: /* seek to current physical position */
! 501: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 502: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 503: return -1;
! 504: }
! 505:
! 506: /* write EOF N blocks */
! 507: for (i = 0; i < count; i++) {
! 508: mbp->lbpos = lbpos;
! 509: mbp->offset = offset;
! 510: mbp->prev = prev;
! 511: index_i++;
! 512: spec->ctlblock->marks[index_i].lbpos = lbpos;
! 513: spec->ctlblock->marks[index_i].offset = offset;
! 514: spec->ctlblock->marks[index_i].prev = prev;
! 515: spec->ctlblock->marks[index_i + 1].lbpos = MARK_END;
! 516: spec->ctlblock->marks[index_i + 1].offset = MARK_END;
! 517: spec->ctlblock->marks[index_i + 1].prev = offset + marklen;
! 518: spec->index = index_i;
! 519: spec->offset = offset;
! 520: if (istgt_lu_tape_write_native_mark(spec, mbp) < 0) {
! 521: ISTGT_ERRLOG("istgt_lu_tape_write_native_mark() failed\n");
! 522: spec->prev = 0ULL;
! 523: return -1;
! 524: }
! 525: lbpos++;
! 526: prev = offset;
! 527: offset += marklen;
! 528: /* update information */
! 529: spec->lbpos = lbpos;
! 530: spec->prev = prev;
! 531: spec->offset = offset;
! 532: spec->eof = 1;
! 533: }
! 534: return 0;
! 535: }
! 536:
! 537: static int
! 538: istgt_lu_tape_write_bot(ISTGT_LU_TAPE *spec, uint8_t *data)
! 539: {
! 540: tape_markblock_t *mbp;
! 541: uint64_t tape_leader;
! 542: uint64_t lbpos, offset, prev, version, marklen;
! 543: int index_i;
! 544:
! 545: tape_leader = spec->ctlblock->ctlblocklen;
! 546: lbpos = 0ULL;
! 547: offset = 0ULL;
! 548: prev = 0ULL;
! 549: index_i = 0ULL;
! 550: version = spec->ctlblock->version;
! 551: marklen = spec->ctlblock->marklen;
! 552:
! 553: /* prepare mark */
! 554: mbp = (tape_markblock_t *) data;
! 555: memset(mbp, 0, marklen);
! 556: memcpy(mbp->magic, MARK_BOTMAGIC, MARK_MAGICLEN);
! 557: mbp->endian = MARK_ENDIAN;
! 558: mbp->version = MARK_VERSION;
! 559: mbp->marklen = marklen;
! 560: mbp->lblen = 0ULL;
! 561: mbp->compalgo = 0ULL;
! 562: mbp->vtcompalgo = 0ULL;
! 563: mbp->vtdecomplen = 0ULL;
! 564:
! 565: /* seek to current physical position */
! 566: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 567: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 568: return -1;
! 569: }
! 570:
! 571: /* write BOT block */
! 572: mbp->lbpos = lbpos;
! 573: mbp->offset = offset;
! 574: mbp->prev = prev;
! 575: index_i++;
! 576: spec->ctlblock->marks[index_i].lbpos = lbpos;
! 577: spec->ctlblock->marks[index_i].offset = offset;
! 578: spec->ctlblock->marks[index_i].prev = prev;
! 579: spec->ctlblock->marks[index_i + 1].lbpos = MARK_END;
! 580: spec->ctlblock->marks[index_i + 1].offset = MARK_END;
! 581: spec->ctlblock->marks[index_i + 1].prev = offset + marklen;
! 582: spec->index = index_i;
! 583: spec->offset = offset;
! 584: if (istgt_lu_tape_write_native_mark(spec, mbp) < 0) {
! 585: ISTGT_ERRLOG("lu_tape_write_native_mark() failed\n");
! 586: spec->prev = 0ULL;
! 587: return -1;
! 588: }
! 589: lbpos++;
! 590: prev = offset;
! 591: offset += marklen;
! 592: /* update information */
! 593: spec->lbpos = lbpos;
! 594: spec->prev = prev;
! 595: spec->offset = offset;
! 596: return 0;
! 597: }
! 598:
! 599: static int
! 600: istgt_lu_tape_write_eod(ISTGT_LU_TAPE *spec, uint8_t *data)
! 601: {
! 602: tape_markblock_t *mbp;
! 603: uint64_t tape_leader;
! 604: uint64_t lbpos, offset, prev, version, marklen;
! 605: int index_i;
! 606:
! 607: tape_leader = spec->ctlblock->ctlblocklen;
! 608: lbpos = spec->lbpos;
! 609: offset = spec->offset;
! 610: prev = spec->prev;
! 611: index_i = spec->index;
! 612: version = spec->ctlblock->version;
! 613: marklen = spec->ctlblock->marklen;
! 614:
! 615: /* prepare mark */
! 616: mbp = (tape_markblock_t *) data;
! 617: memset(mbp, 0, marklen);
! 618: memcpy(mbp->magic, MARK_EODMAGIC, MARK_MAGICLEN);
! 619: mbp->endian = MARK_ENDIAN;
! 620: mbp->version = MARK_VERSION;
! 621: mbp->marklen = marklen;
! 622: mbp->lblen = 0ULL;
! 623: mbp->compalgo = 0ULL;
! 624: mbp->vtcompalgo = 0ULL;
! 625: mbp->vtdecomplen = 0ULL;
! 626:
! 627: /* seek to current physical position */
! 628: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 629: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 630: return -1;
! 631: }
! 632:
! 633: /* write EOD block */
! 634: mbp->lbpos = lbpos;
! 635: mbp->offset = offset;
! 636: mbp->prev = prev;
! 637: if (istgt_lu_tape_write_native_mark(spec, mbp) < 0) {
! 638: ISTGT_ERRLOG("lu_tape_write_native_mark() failed\n");
! 639: return -1;
! 640: }
! 641: /* no update information */
! 642: return 0;
! 643: }
! 644:
! 645: static int
! 646: istgt_lu_tape_write_media_check(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t request_len)
! 647: {
! 648: uint64_t tape_leader;
! 649: uint64_t extendsize;
! 650: uint64_t mediasize;
! 651: uint64_t offset;
! 652: int data_len;
! 653:
! 654: tape_leader = spec->ctlblock->ctlblocklen;
! 655: mediasize = spec->size;
! 656: offset = spec->offset;
! 657:
! 658: /* writable media? */
! 659: if (spec->lu->readonly
! 660: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 661: /* WRITE PROTECTED */
! 662: data_len
! 663: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 664: ISTGT_SCSI_SENSE_DATA_PROTECT,
! 665: 0x27, 0x00);
! 666: lu_cmd->sense_data_len = data_len;
! 667: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 668: return -1;
! 669: }
! 670:
! 671: /* always keep control block */
! 672: if (mediasize < tape_leader) {
! 673: /* INTERNAL TARGET FAILURE */
! 674: data_len
! 675: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 676: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 677: 0x44, 0x00);
! 678: lu_cmd->sense_data_len = data_len;
! 679: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 680: return -1;
! 681: }
! 682: mediasize -= tape_leader;
! 683:
! 684: /* request can store? */
! 685: if (request_len > mediasize || offset > mediasize - request_len) {
! 686: /* determine extend size */
! 687: extendsize = request_len / ISTGT_LU_MEDIA_EXTEND_UNIT;
! 688: extendsize *= ISTGT_LU_MEDIA_EXTEND_UNIT;
! 689: if (request_len % ISTGT_LU_MEDIA_EXTEND_UNIT) {
! 690: extendsize += ISTGT_LU_MEDIA_EXTEND_UNIT;
! 691: }
! 692: /* can handle? */
! 693: if (mediasize < MARK_END - 1 - tape_leader - extendsize) {
! 694: if (spec->mflags & ISTGT_LU_FLAG_MEDIA_DYNAMIC) {
! 695: /* OK dynamic allocation */
! 696: mediasize += extendsize;
! 697: } else if (spec->mflags & ISTGT_LU_FLAG_MEDIA_EXTEND) {
! 698: /* OK extend media size */
! 699: mediasize += extendsize;
! 700: } else {
! 701: /* no space virtual EOM */
! 702: goto eom_error;
! 703: }
! 704: } else {
! 705: eom_error:
! 706: /* physical EOM */
! 707: spec->eom = 1;
! 708: /* END-OF-PARTITION/MEDIUM DETECTED */
! 709: /* VOLUME OVERFLOW */
! 710: data_len
! 711: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 712: ISTGT_SCSI_SENSE_VOLUME_OVERFLOW,
! 713: 0x00, 0x02);
! 714: lu_cmd->sense_data_len = data_len;
! 715: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 716: return -1;
! 717: }
! 718: }
! 719:
! 720: /* update information */
! 721: spec->size = tape_leader + mediasize;
! 722:
! 723: /* complete check, ready to write */
! 724: return 0;
! 725: }
! 726:
! 727: static int
! 728: istgt_lu_tape_read_media_check(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t request_len)
! 729: {
! 730: uint64_t tape_leader;
! 731: uint64_t mediasize;
! 732: uint64_t offset;
! 733: int data_len;
! 734:
! 735: tape_leader = spec->ctlblock->ctlblocklen;
! 736: mediasize = spec->size;
! 737: offset = spec->offset;
! 738:
! 739: /* always keep control block */
! 740: if (mediasize < tape_leader) {
! 741: /* INTERNAL TARGET FAILURE */
! 742: data_len
! 743: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 744: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 745: 0x44, 0x00);
! 746: lu_cmd->sense_data_len = data_len;
! 747: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 748: return -1;
! 749: }
! 750: mediasize -= tape_leader;
! 751:
! 752: /* request can seek? */
! 753: if (request_len > mediasize || offset > mediasize - request_len) {
! 754: /* physical EOM */
! 755: spec->eom = 1;
! 756: /* END-OF-PARTITION/MEDIUM DETECTED */
! 757: data_len
! 758: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 759: ISTGT_SCSI_SENSE_MEDIUM_ERROR,
! 760: 0x00, 0x02);
! 761: lu_cmd->sense_data_len = data_len;
! 762: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 763: return -1;
! 764: }
! 765:
! 766: /* complete check, ready to read */
! 767: return 0;
! 768: }
! 769:
! 770: static int
! 771: istgt_lu_tape_prepare_offset(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 772: {
! 773: uint64_t lbpos, offset, prev, marklen;
! 774: int index_i;
! 775:
! 776: lbpos = spec->lbpos;
! 777: offset = spec->offset;
! 778: prev = spec->prev;
! 779: index_i = spec->index;
! 780: marklen = spec->ctlblock->marklen;
! 781:
! 782: /* position to logical block zero */
! 783: if (spec->bot) {
! 784: spec->bot = 0;
! 785: spec->eof = spec->eod = spec->eom = 0;
! 786: offset = 0;
! 787: prev = offset;
! 788: offset += marklen;
! 789: lbpos++;
! 790: }
! 791:
! 792: if (spec->eom || offset == MARK_END) {
! 793: spec->eom = 1;
! 794: spec->bot = spec->eof = spec->eod = 0;
! 795: }
! 796:
! 797: /* update information */
! 798: spec->index = index_i;
! 799: spec->lbpos = lbpos;
! 800: spec->prev = prev;
! 801: spec->offset = offset;
! 802: return 0;
! 803: }
! 804:
! 805: static int
! 806: istgt_lu_tape_write_pending_data(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 807: {
! 808: uint64_t marklen;
! 809: int data_len;
! 810:
! 811: if (spec->need_savectl) {
! 812: if (istgt_lu_tape_save_ctlblock(spec) < 0) {
! 813: ISTGT_ERRLOG("lu_tape_save_ctlblock() failed\n");
! 814: io_failure:
! 815: /* INTERNAL TARGET FAILURE */
! 816: data_len
! 817: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 818: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 819: 0x44, 0x00);
! 820: lu_cmd->sense_data_len = data_len;
! 821: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 822: return 0;
! 823: }
! 824: spec->need_savectl = 0;
! 825: }
! 826: if (spec->need_writeeod) {
! 827: marklen = spec->ctlblock->marklen;
! 828: if (istgt_lu_tape_write_media_check(spec, conn, lu_cmd, marklen) < 0) {
! 829: goto io_failure;
! 830: }
! 831: if (istgt_lu_tape_write_eod(spec, lu_cmd->data) < 0) {
! 832: ISTGT_ERRLOG("lu_tape_write_eod() failed\n");
! 833: goto io_failure;
! 834: }
! 835: spec->need_writeeod = 0;
! 836: }
! 837: return 0;
! 838: }
! 839:
! 840: static int
! 841: istgt_lu_tape_rewind(ISTGT_LU_TAPE *spec)
! 842: {
! 843: uint64_t lbpos, offset, prev;
! 844: int index_i;
! 845:
! 846: /* position to BOT */
! 847: spec->bot = 1;
! 848: spec->eof = spec->eod = spec->eom = 0;
! 849: index_i = 0;
! 850: lbpos = spec->ctlblock->marks[index_i].lbpos;
! 851: offset = spec->ctlblock->marks[index_i].offset;
! 852: prev = spec->ctlblock->marks[index_i].prev;
! 853:
! 854: /* update information */
! 855: spec->index = index_i;
! 856: spec->lbpos = lbpos;
! 857: spec->prev = prev;
! 858: spec->offset = offset;
! 859: return 0;
! 860: }
! 861:
! 862: static int
! 863: istgt_lu_tape_load_ctlblock(ISTGT_LU_TAPE *spec)
! 864: {
! 865: int64_t rc;
! 866:
! 867: if (istgt_lu_tape_seek(spec, 0) == -1) {
! 868: return -1;
! 869: }
! 870: rc = istgt_lu_tape_read(spec, spec->ctlblock, CTLBLOCKLEN);
! 871: if (rc < 0 || rc != CTLBLOCKLEN) {
! 872: return -1;
! 873: }
! 874: return rc;
! 875: }
! 876:
! 877: static int
! 878: istgt_lu_tape_save_ctlblock(ISTGT_LU_TAPE *spec)
! 879: {
! 880: int64_t rc;
! 881:
! 882: if (istgt_lu_tape_seek(spec, 0) == -1) {
! 883: return -1;
! 884: }
! 885: rc = istgt_lu_tape_write(spec, spec->ctlblock,
! 886: spec->ctlblock->ctlblocklen);
! 887: if (rc < 0 || rc != spec->ctlblock->ctlblocklen) {
! 888: return -1;
! 889: }
! 890: return rc;
! 891: }
! 892:
! 893: static int
! 894: istgt_lu_tape_init_ctlblock(ISTGT_LU_TAPE *spec, int newfile)
! 895: {
! 896: tape_ctlblock_t *cbp;
! 897: uint64_t *lp;
! 898: int rc;
! 899: int i;
! 900:
! 901: cbp = spec->ctlblock;
! 902:
! 903: rc = istgt_lu_tape_load_ctlblock(spec);
! 904: if (rc < 0) {
! 905: return -1;
! 906: }
! 907: if (memcmp(cbp->magic, CTLMAGIC, CTLMAGICLEN) != 0) {
! 908: if (spec->lu->readonly
! 909: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)
! 910: || !newfile) {
! 911: ISTGT_ERRLOG("Can not initialize \"%s\"\n", spec->file);
! 912: return -1;
! 913: }
! 914: /* initialize control block */
! 915: memset(cbp, 0, CTLBLOCKLEN);
! 916: memcpy(cbp->magic, CTLMAGIC, CTLMAGICLEN);
! 917: cbp->marks[0].offset = 0ULL;
! 918: cbp->marks[0].lbpos = 0ULL;
! 919: cbp->marks[0].prev = 0ULL;
! 920: cbp->marks[1].offset = MARK_END;
! 921: cbp->marks[1].lbpos = MARK_END;
! 922: cbp->marks[1].prev = 0ULL;
! 923: cbp->endian = CTLENDIAN;
! 924: cbp->version = CTLVERSION;
! 925: cbp->ctlblocklen = (uint64_t) CTLBLOCKLEN;
! 926: cbp->blocklen = (uint64_t) TAPE_BLOCKLEN;
! 927: cbp->marklen = (uint64_t) MARK_LENGTH;
! 928: cbp->alignment = (uint64_t) TAPE_ALIGNMENT;
! 929: cbp->allocate = 0ULL;
! 930: cbp->type = 0ULL;
! 931: cbp->id = 0ULL;
! 932: cbp->size = 0ULL;
! 933: rc = istgt_lu_tape_save_ctlblock(spec);
! 934: if (rc < 0) {
! 935: ISTGT_ERRLOG("lu_tape_save_ctlblock() failed\n");
! 936: return -1;
! 937: }
! 938: rc = istgt_lu_tape_write_bot(spec, (uint8_t *) spec->markblock);
! 939: if (rc < 0) {
! 940: ISTGT_ERRLOG("lu_tape_write_bot() failed\n");
! 941: return -1;
! 942: }
! 943: rc = istgt_lu_tape_write_eod(spec, (uint8_t *) spec->markblock);
! 944: if (rc < 0) {
! 945: ISTGT_ERRLOG("lu_tape_write_eod() failed\n");
! 946: return -1;
! 947: }
! 948: } else {
! 949: if (cbp->endian != CTLENDIAN) {
! 950: /* convert byte order but except magic */
! 951: lp = (uint64_t *) cbp;
! 952: for (i = 1; i < CTLBLOCKLEN / sizeof(uint64_t); i++) {
! 953: lp[i] = SWAP_UINT64(lp[i]);
! 954: }
! 955: }
! 956: if (cbp->ctlblocklen == 0ULL
! 957: || cbp->blocklen == 0ULL
! 958: || cbp->marklen == 0ULL
! 959: || cbp->alignment == 0ULL) {
! 960: ISTGT_ERRLOG("bad length\n");
! 961: return -1;
! 962: }
! 963: if (cbp->version > CTLVERSION) {
! 964: ISTGT_ERRLOG("unsupported tape version 0x%"PRIx64"\n",
! 965: cbp->version);
! 966: return -1;
! 967: }
! 968: if (cbp->marklen > MARK_MAXLENGTH) {
! 969: ISTGT_ERRLOG("marklen is too long\n");
! 970: return -1;
! 971: }
! 972: }
! 973: return 0;
! 974: }
! 975:
! 976: int
! 977: istgt_lu_tape_media_present(ISTGT_LU_TAPE *spec)
! 978: {
! 979: if (spec->mload) {
! 980: return 1;
! 981: }
! 982: return 0;
! 983: }
! 984:
! 985: int
! 986: istgt_lu_tape_media_lock(ISTGT_LU_TAPE *spec)
! 987: {
! 988: if (spec->lock) {
! 989: return 1;
! 990: }
! 991: return 0;
! 992: }
! 993:
! 994: int
! 995: istgt_lu_tape_load_media(ISTGT_LU_TAPE *spec)
! 996: {
! 997: ISTGT_LU_Ptr lu;
! 998: int flags;
! 999: int newfile;
! 1000: int rc;
! 1001:
! 1002: if (istgt_lu_tape_media_present(spec)) {
! 1003: /* media present */
! 1004: return -1;
! 1005: }
! 1006: if (spec->mchanged) {
! 1007: /* changed soon */
! 1008: return -1;
! 1009: }
! 1010:
! 1011: lu = spec->lu;
! 1012: if (lu->lun[spec->lun].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 1013: ISTGT_ERRLOG("LU%d: not removable\n", lu->num);
! 1014: return -1;
! 1015: }
! 1016: if (strcasecmp(lu->lun[spec->lun].u.removable.file,
! 1017: "/dev/null") == 0) {
! 1018: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: empty\n", lu->num);
! 1019: spec->file = NULL;
! 1020: spec->size = 0;
! 1021: spec->mflags = 0;
! 1022: spec->blocklen = TAPE_BLOCKLEN;
! 1023: spec->blockcnt = spec->size / spec->blocklen;
! 1024: spec->compalgo = TAPE_COMP_ALGORITHM;
! 1025: spec->vtcompalgo = MARK_COMPALGO_NONE;
! 1026: spec->compression = COMPRESSION_DFLT;
! 1027: spec->lblen = 0ULL; /* default to variable length */
! 1028: spec->index = 0; /* position to BOT */
! 1029: spec->lbpos = 0ULL;
! 1030: spec->offset = 0ULL;
! 1031: spec->prev = 0ULL;
! 1032: spec->bot = 0;
! 1033: spec->eof = spec->eod = spec->eom = 0;
! 1034: spec->prev = spec->offset;
! 1035: spec->need_savectl = 0;
! 1036: spec->need_writeeod = 0;
! 1037: return 0;
! 1038: }
! 1039: spec->file = lu->lun[spec->lun].u.removable.file;
! 1040: spec->size = lu->lun[spec->lun].u.removable.size;
! 1041: spec->mflags = lu->lun[spec->lun].u.removable.flags;
! 1042: spec->blocklen = TAPE_BLOCKLEN;
! 1043: spec->blockcnt = spec->size / spec->blocklen;
! 1044: spec->compalgo = TAPE_COMP_ALGORITHM;
! 1045: spec->vtcompalgo = MARK_COMPALGO_NONE;
! 1046: spec->compression = COMPRESSION_DFLT;
! 1047: spec->lblen = 0ULL; /* default to variable length */
! 1048: spec->index = 0; /* position to BOT */
! 1049: spec->lbpos = 0ULL;
! 1050: spec->offset = 0ULL;
! 1051: spec->prev = 0ULL;
! 1052: spec->bot = 1;
! 1053: spec->eof = spec->eod = spec->eom = 0;
! 1054: spec->prev = spec->offset;
! 1055: spec->need_savectl = 0;
! 1056: spec->need_writeeod = 0;
! 1057:
! 1058: spec->mload = 0;
! 1059: spec->mchanged = 1;
! 1060: spec->mwait = 3;
! 1061:
! 1062: if (access(spec->file, W_OK) != 0) {
! 1063: if (errno != ENOENT) {
! 1064: spec->mflags |= ISTGT_LU_FLAG_MEDIA_READONLY;
! 1065: }
! 1066: } else {
! 1067: struct stat st;
! 1068: rc = stat(spec->file, &st);
! 1069: if (rc != 0 || !S_ISREG(st.st_mode)) {
! 1070: spec->mflags |= ISTGT_LU_FLAG_MEDIA_READONLY;
! 1071: } else {
! 1072: if ((st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0) {
! 1073: spec->mflags |= ISTGT_LU_FLAG_MEDIA_READONLY;
! 1074: }
! 1075: }
! 1076: }
! 1077: if (spec->lu->readonly
! 1078: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1079: flags = O_RDONLY;
! 1080: } else {
! 1081: flags = O_RDWR;
! 1082: }
! 1083: newfile = 0;
! 1084: rc = istgt_lu_tape_open(spec, flags, 0666);
! 1085: if (rc < 0) {
! 1086: /* new file? */
! 1087: newfile = 1;
! 1088: if (spec->lu->readonly
! 1089: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1090: flags = O_RDONLY;
! 1091: } else {
! 1092: flags = (O_CREAT | O_EXCL | O_RDWR);
! 1093: }
! 1094: rc = istgt_lu_tape_open(spec, flags, 0666);
! 1095: if (rc < 0) {
! 1096: ISTGT_ERRLOG("LU%d: LUN%d: open error\n", lu->num, spec->lun);
! 1097: return -1;
! 1098: }
! 1099: if (lu->lun[spec->lun].u.removable.size < ISTGT_LU_MEDIA_SIZE_MIN) {
! 1100: lu->lun[spec->lun].u.removable.size = ISTGT_LU_MEDIA_SIZE_MIN;
! 1101: }
! 1102: }
! 1103:
! 1104: if (spec->lu->readonly
! 1105: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1106: /* readonly */
! 1107: } else {
! 1108: if (newfile == 0) {
! 1109: /* existing file check */
! 1110: if (istgt_lu_tape_init_ctlblock(spec, newfile) < 0) {
! 1111: ISTGT_ERRLOG("lu_tape_init_ctlblock() failed\n");
! 1112: return -1;
! 1113: }
! 1114: }
! 1115: rc = istgt_lu_tape_allocate(spec);
! 1116: if (rc < 0) {
! 1117: ISTGT_ERRLOG("LU%d: LUN%d: allocate error\n", lu->num, spec->lun);
! 1118: return -1;
! 1119: }
! 1120: }
! 1121: /* initialize filemarks */
! 1122: if (istgt_lu_tape_init_ctlblock(spec, newfile) < 0) {
! 1123: ISTGT_ERRLOG("lu_tape_init_ctlblock() failed\n");
! 1124: return -1;
! 1125: }
! 1126: istgt_lu_tape_rewind(spec);
! 1127: return 0;
! 1128: }
! 1129:
! 1130: int
! 1131: istgt_lu_tape_unload_media(ISTGT_LU_TAPE *spec)
! 1132: {
! 1133: int rc;
! 1134:
! 1135: if (!istgt_lu_tape_media_present(spec)
! 1136: && !spec->mchanged) {
! 1137: /* media absent */
! 1138: return 0;
! 1139: }
! 1140: if (istgt_lu_tape_media_lock(spec)) {
! 1141: return -1;
! 1142: }
! 1143:
! 1144: if (spec->need_savectl) {
! 1145: if (istgt_lu_tape_save_ctlblock(spec) < 0) {
! 1146: ISTGT_ERRLOG("lu_tape_save_ctlblock() failed\n");
! 1147: return -1;
! 1148: }
! 1149: spec->need_savectl = 0;
! 1150: }
! 1151: if (spec->need_writeeod) {
! 1152: if (istgt_lu_tape_write_eod(spec, (uint8_t *) spec->markblock) < 0) {
! 1153: ISTGT_ERRLOG("write_eod() failed\n");
! 1154: return -1;
! 1155: }
! 1156: spec->need_writeeod = 0;
! 1157: }
! 1158:
! 1159: if (!spec->lu->readonly
! 1160: && !(spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1161: rc = istgt_lu_tape_sync(spec, 0, spec->size);
! 1162: if (rc < 0) {
! 1163: ISTGT_ERRLOG("lu_tape_sync() failed\n");
! 1164: return -1;
! 1165: }
! 1166: }
! 1167: rc = (int64_t) istgt_lu_tape_close(spec);
! 1168: if (rc < 0) {
! 1169: ISTGT_ERRLOG("lu_tape_close() failed\n");
! 1170: return -1;
! 1171: }
! 1172:
! 1173: spec->file = NULL;
! 1174: spec->size = 0;
! 1175: spec->mflags = 0;
! 1176: spec->blocklen = TAPE_BLOCKLEN;
! 1177: spec->blockcnt = spec->size / spec->blocklen;
! 1178: spec->compalgo = TAPE_COMP_ALGORITHM;
! 1179: spec->vtcompalgo = MARK_COMPALGO_NONE;
! 1180: spec->compression = COMPRESSION_DFLT;
! 1181: spec->lblen = 0ULL; /* default to variable length */
! 1182: spec->index = 0; /* position to BOT */
! 1183: spec->lbpos = 0ULL;
! 1184: spec->offset = 0ULL;
! 1185: spec->prev = 0ULL;
! 1186: spec->bot = 0;
! 1187: spec->eof = spec->eod = spec->eom = 0;
! 1188: spec->prev = spec->offset;
! 1189: spec->need_savectl = 0;
! 1190: spec->need_writeeod = 0;
! 1191:
! 1192: spec->mload = 0;
! 1193: spec->mchanged = 0;
! 1194: spec->mwait = 3;
! 1195:
! 1196: return 0;
! 1197: }
! 1198:
! 1199: int
! 1200: istgt_lu_tape_change_media(ISTGT_LU_TAPE *spec, char *type, char *flags, char *file, char *size)
! 1201: {
! 1202: ISTGT_LU_Ptr lu;
! 1203: char *mfile;
! 1204: uint64_t msize;
! 1205: int mflags;
! 1206: int rc;
! 1207:
! 1208: if (istgt_lu_tape_media_lock(spec)) {
! 1209: return -1;
! 1210: }
! 1211:
! 1212: lu = spec->lu;
! 1213: if (lu->lun[spec->lun].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 1214: ISTGT_ERRLOG("LU%d: not removable\n", lu->num);
! 1215: return -1;
! 1216: }
! 1217:
! 1218: if (strcmp(type, "-") == 0) {
! 1219: /* use VT image */
! 1220: ;
! 1221: } else {
! 1222: ISTGT_ERRLOG("unsupported media type\n");
! 1223: return -1;
! 1224: }
! 1225:
! 1226: mfile = xstrdup(file);
! 1227: mflags = istgt_lu_parse_media_flags(flags);
! 1228: msize = istgt_lu_parse_media_size(file, size, &mflags);
! 1229:
! 1230: rc = istgt_lu_tape_unload_media(spec);
! 1231: if (rc < 0) {
! 1232: return -1;
! 1233: }
! 1234:
! 1235: /* replace */
! 1236: xfree(lu->lun[spec->lun].u.removable.file);
! 1237: lu->lun[spec->lun].u.removable.file = mfile;
! 1238: lu->lun[spec->lun].u.removable.size = msize;
! 1239: lu->lun[spec->lun].u.removable.flags = mflags;
! 1240:
! 1241: /* reload */
! 1242: rc = istgt_lu_tape_load_media(spec);
! 1243: if (rc < 0) {
! 1244: (void) istgt_lu_tape_unload_media(spec);
! 1245: }
! 1246: if (spec->file == NULL) {
! 1247: (void) istgt_lu_tape_unload_media(spec);
! 1248: }
! 1249: spec->mwait = 5;
! 1250: return rc;
! 1251: }
! 1252:
! 1253: static int
! 1254: istgt_lu_tape_allocate(ISTGT_LU_TAPE *spec)
! 1255: {
! 1256: uint8_t *data;
! 1257: uint64_t fsize;
! 1258: uint64_t size;
! 1259: uint64_t blocklen;
! 1260: uint64_t offset;
! 1261: uint64_t nbytes;
! 1262: int64_t rc;
! 1263:
! 1264: size = spec->size;
! 1265: blocklen = spec->blocklen;
! 1266: nbytes = blocklen;
! 1267: data = xmalloc(nbytes);
! 1268: memset(data, 0, nbytes);
! 1269:
! 1270: fsize = istgt_lu_get_filesize(spec->file);
! 1271: if (fsize > size) {
! 1272: xfree(data);
! 1273: return 0;
! 1274: }
! 1275:
! 1276: offset = size - nbytes;
! 1277: rc = istgt_lu_tape_seek(spec, offset);
! 1278: if (rc == -1) {
! 1279: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 1280: xfree(data);
! 1281: return -1;
! 1282: }
! 1283: rc = istgt_lu_tape_read(spec, data, nbytes);
! 1284: /* EOF is OK */
! 1285: if (rc == -1) {
! 1286: ISTGT_ERRLOG("lu_tape_read() failed\n");
! 1287: xfree(data);
! 1288: return -1;
! 1289: }
! 1290: rc = istgt_lu_tape_seek(spec, offset);
! 1291: if (rc == -1) {
! 1292: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 1293: xfree(data);
! 1294: return -1;
! 1295: }
! 1296: rc = istgt_lu_tape_write(spec, data, nbytes);
! 1297: if (rc == -1 || rc != nbytes) {
! 1298: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 1299: xfree(data);
! 1300: return -1;
! 1301: }
! 1302:
! 1303: xfree(data);
! 1304: return 0;
! 1305: }
! 1306:
! 1307: int
! 1308: istgt_lu_tape_init(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu)
! 1309: {
! 1310: ISTGT_LU_TAPE *spec;
! 1311: uint64_t gb_size;
! 1312: uint64_t mb_size;
! 1313: #ifdef HAVE_UUID_H
! 1314: uint32_t status;
! 1315: #endif /* HAVE_UUID_H */
! 1316: int mb_digit;
! 1317: int ro;
! 1318: int rc;
! 1319: int i;
! 1320:
! 1321: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_tape_init\n");
! 1322:
! 1323: if (sizeof(tape_ctlblock_t) != CTLBLOCKLEN) {
! 1324: ISTGT_ERRLOG("Invalid ctlblock len %" PRIu64 ".\n",
! 1325: sizeof(tape_ctlblock_t));
! 1326: return -1;
! 1327: }
! 1328:
! 1329: printf("LU%d TAPE UNIT\n", lu->num);
! 1330: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d TargetName=%s\n",
! 1331: lu->num, lu->name);
! 1332: for (i = 0; i < lu->maxlun; i++) {
! 1333: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
! 1334: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
! 1335: lu->num, i);
! 1336: lu->lun[i].spec = NULL;
! 1337: continue;
! 1338: }
! 1339: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 1340: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
! 1341: return -1;
! 1342: }
! 1343: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d removable\n",
! 1344: lu->num, i);
! 1345:
! 1346: spec = xmalloc(sizeof *spec);
! 1347: memset(spec, 0, sizeof *spec);
! 1348: spec->lu = lu;
! 1349: spec->num = lu->num;
! 1350: spec->lun = i;
! 1351: spec->fd = -1;
! 1352:
! 1353: #ifdef HAVE_UUID_H
! 1354: uuid_create(&spec->uuid, &status);
! 1355: if (status != uuid_s_ok) {
! 1356: ISTGT_ERRLOG("LU%d: LUN%d: uuid_create() failed\n", lu->num, i);
! 1357: xfree(spec);
! 1358: return -1;
! 1359: }
! 1360: #endif /* HAVE_UUID_H */
! 1361:
! 1362: spec->ctlblock = xmalloc(CTLBLOCKLEN);
! 1363: spec->markblock = xmalloc(MARK_MAXLENGTH);
! 1364:
! 1365: spec->mload = 0;
! 1366: spec->mchanged = 0;
! 1367: spec->mwait = 0;
! 1368: rc = istgt_lu_tape_load_media(spec);
! 1369: if (rc < 0) {
! 1370: ISTGT_ERRLOG("lu_tape_load_media() failed\n");
! 1371: xfree(spec->markblock);
! 1372: xfree(spec->ctlblock);
! 1373: xfree(spec);
! 1374: return -1;
! 1375: }
! 1376:
! 1377: if (spec->file != NULL) {
! 1378: /* initial state */
! 1379: spec->mload = 1;
! 1380: spec->mchanged = 0;
! 1381: spec->mwait = 0;
! 1382:
! 1383: if (spec->lu->readonly
! 1384: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1385: ro = 1;
! 1386: } else {
! 1387: ro = 0;
! 1388: }
! 1389:
! 1390: printf("LU%d: LUN%d file=%s, size=%"PRIu64", flag=%s\n",
! 1391: lu->num, i, spec->file, spec->size, ro ? "ro" : "rw");
! 1392: printf("LU%d: LUN%d %"PRIu64" blocks, %"PRIu64" bytes/block\n",
! 1393: lu->num, i, spec->blockcnt, spec->blocklen);
! 1394:
! 1395: gb_size = spec->size / ISTGT_LU_1GB;
! 1396: mb_size = (spec->size % ISTGT_LU_1GB) / ISTGT_LU_1MB;
! 1397: if (gb_size > 0) {
! 1398: mb_digit = (int) (((mb_size * 100) / 1024) / 10);
! 1399: printf("LU%d: LUN%d %"PRIu64".%dGB %sstorage for %s\n",
! 1400: lu->num, i, gb_size, mb_digit,
! 1401: lu->readonly ? "readonly " : "", lu->name);
! 1402: } else {
! 1403: printf("LU%d: LUN%d %"PRIu64"MB %sstorage for %s\n",
! 1404: lu->num, i, mb_size,
! 1405: lu->readonly ? "readonly " : "", lu->name);
! 1406: }
! 1407: } else {
! 1408: /* initial state */
! 1409: spec->mload = 0;
! 1410: spec->mchanged = 0;
! 1411: spec->mwait = 0;
! 1412:
! 1413: printf("LU%d: LUN%d empty slot\n",
! 1414: lu->num, i);
! 1415: }
! 1416:
! 1417: lu->lun[i].spec = spec;
! 1418: }
! 1419:
! 1420: return 0;
! 1421: }
! 1422:
! 1423: int
! 1424: istgt_lu_tape_shutdown(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu)
! 1425: {
! 1426: ISTGT_LU_CMD lu_cmd;
! 1427: ISTGT_LU_TAPE *spec;
! 1428: uint8_t *data;
! 1429: int alloc_len;
! 1430: int rc;
! 1431: int i;
! 1432:
! 1433: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_tape_shutdown\n");
! 1434:
! 1435: alloc_len = 65536;
! 1436: data = xmalloc(alloc_len);
! 1437: memset(&lu_cmd, 0, sizeof lu_cmd);
! 1438: lu_cmd.iobuf = data;
! 1439: lu_cmd.iobufsize = alloc_len;
! 1440: lu_cmd.data = data;
! 1441: lu_cmd.data_len = 0;
! 1442: lu_cmd.alloc_len = alloc_len;
! 1443: lu_cmd.sense_data = data;
! 1444: lu_cmd.sense_alloc_len = alloc_len;
! 1445:
! 1446: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d TargetName=%s\n",
! 1447: lu->num, lu->name);
! 1448: for (i = 0; i < lu->maxlun; i++) {
! 1449: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
! 1450: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
! 1451: lu->num, i);
! 1452: continue;
! 1453: }
! 1454: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 1455: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
! 1456: xfree(data);
! 1457: return -1;
! 1458: }
! 1459: spec = (ISTGT_LU_TAPE *) lu->lun[i].spec;
! 1460:
! 1461: /* flush pending data */
! 1462: rc = istgt_lu_tape_write_pending_data(spec, NULL, &lu_cmd);
! 1463: if (rc < 0) {
! 1464: ISTGT_ERRLOG("lu_tape_write_pending_data() failed\n");
! 1465: /* ignore error for other cleanup */
! 1466: }
! 1467:
! 1468: if (!spec->lu->readonly
! 1469: && !(spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 1470: rc = istgt_lu_tape_sync(spec, 0, spec->size);
! 1471: if (rc < 0) {
! 1472: //ISTGT_ERRLOG("LU%d: lu_tape_sync() failed\n", lu->num);
! 1473: /* ignore error */
! 1474: }
! 1475: }
! 1476: rc = istgt_lu_tape_close(spec);
! 1477: if (rc < 0) {
! 1478: //ISTGT_ERRLOG("LU%d: lu_tape_close() failed\n", lu->num);
! 1479: /* ignore error */
! 1480: }
! 1481: xfree(spec->ctlblock);
! 1482: xfree(spec->markblock);
! 1483: xfree(spec);
! 1484: lu->lun[i].spec = NULL;
! 1485: }
! 1486:
! 1487: xfree(data);
! 1488: return 0;
! 1489: }
! 1490:
! 1491: static int
! 1492: istgt_lu_tape_scsi_report_luns(ISTGT_LU_Ptr lu, CONN_Ptr conn, uint8_t *cdb, int sel, uint8_t *data, int alloc_len)
! 1493: {
! 1494: uint64_t fmt_lun, lun, method;
! 1495: int hlen = 0, len = 0;
! 1496: int i;
! 1497:
! 1498: if (alloc_len < 8) {
! 1499: return -1;
! 1500: }
! 1501:
! 1502: if (sel == 0x00) {
! 1503: /* logical unit with addressing method */
! 1504: } else if (sel == 0x01) {
! 1505: /* well known logical unit */
! 1506: } else if (sel == 0x02) {
! 1507: /* logical unit */
! 1508: } else {
! 1509: return -1;
! 1510: }
! 1511:
! 1512: /* LUN LIST LENGTH */
! 1513: DSET32(&data[0], 0);
! 1514: /* Reserved */
! 1515: DSET32(&data[4], 0);
! 1516: hlen = 8;
! 1517:
! 1518: for (i = 0; i < lu->maxlun; i++) {
! 1519: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
! 1520: #if 0
! 1521: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: LUN%d none\n",
! 1522: lu->num, i);
! 1523: #endif
! 1524: continue;
! 1525: }
! 1526: if (alloc_len - (hlen + len) < 8) {
! 1527: return -1;
! 1528: }
! 1529: lun = (uint64_t) i;
! 1530: if (lu->maxlun <= 0x0100) {
! 1531: /* below 256 */
! 1532: method = 0x00U;
! 1533: fmt_lun = (method & 0x03U) << 62;
! 1534: fmt_lun |= (lun & 0x00ffU) << 48;
! 1535: } else if (lu->maxlun <= 0x4000U) {
! 1536: /* below 16384 */
! 1537: method = 0x01U;
! 1538: fmt_lun = (method & 0x03U) << 62;
! 1539: fmt_lun |= (lun & 0x3fffU) << 48;
! 1540: } else {
! 1541: /* XXX */
! 1542: fmt_lun = 0;
! 1543: }
! 1544: /* LUN */
! 1545: DSET64(&data[hlen + len], fmt_lun);
! 1546: len += 8;
! 1547: }
! 1548: /* LUN LIST LENGTH */
! 1549: DSET32(&data[0], len);
! 1550: return hlen + len;
! 1551: }
! 1552:
! 1553: static int
! 1554: istgt_lu_tape_scsi_inquiry(ISTGT_LU_TAPE *spec, CONN_Ptr conn, uint8_t *cdb, uint8_t *data, int alloc_len)
! 1555: {
! 1556: char buf[MAX_TMPBUF];
! 1557: uint64_t LUI, TPI;
! 1558: uint8_t *cp, *cp2;
! 1559: int hlen = 0, len = 0, plen, plen2;
! 1560: int pc;
! 1561: int pq, pd;
! 1562: int rmb;
! 1563: int evpd;
! 1564: int pg_tag;
! 1565: int i, j;
! 1566:
! 1567: if (alloc_len < 0xff) {
! 1568: return -1;
! 1569: }
! 1570:
! 1571: pq = 0x00;
! 1572: pd = SPC_PERIPHERAL_DEVICE_TYPE_TAPE;
! 1573: rmb = 1;
! 1574:
! 1575: LUI = istgt_get_lui(spec->lu->name, spec->lun & 0xffffU);
! 1576: TPI = istgt_get_lui(spec->lu->name, conn->portal.tag << 16);
! 1577:
! 1578: pc = cdb[2];
! 1579: evpd = BGET8(&cdb[1], 0);
! 1580: if (evpd) {
! 1581: /* Vital product data */
! 1582: switch (pc) {
! 1583: case SPC_VPD_SUPPORTED_VPD_PAGES:
! 1584: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 1585: BDSET8W(&data[0], pq, 7, 3);
! 1586: BDADD8W(&data[0], pd, 4, 5);
! 1587: /* PAGE CODE */
! 1588: data[1] = pc;
! 1589: /* Reserved */
! 1590: data[2] = 0;
! 1591: /* PAGE LENGTH */
! 1592: data[3] = 0;
! 1593: hlen = 4;
! 1594:
! 1595: #if 0
! 1596: data[4] = SPC_VPD_SUPPORTED_VPD_PAGES; /* 0x00 */
! 1597: data[5] = SPC_VPD_UNIT_SERIAL_NUMBER; /* 0x80 */
! 1598: data[6] = SPC_VPD_DEVICE_IDENTIFICATION; /* 0x83 */
! 1599: data[7] = SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES; /* 0x85 */
! 1600: data[8] = SPC_VPD_EXTENDED_INQUIRY_DATA; /* 0x86 */
! 1601: data[9] = SPC_VPD_MODE_PAGE_POLICY; /* 0x87 */
! 1602: data[10]= SPC_VPD_SCSI_PORTS; /* 0x88 */
! 1603: len = 11 - hlen;
! 1604:
! 1605: /* for DLT8000 */
! 1606: data[4] = SPC_VPD_SUPPORTED_VPD_PAGES; /* 0x00 */
! 1607: data[5] = SPC_VPD_UNIT_SERIAL_NUMBER; /* 0x80 */
! 1608: data[6] = 0xc0; /* Firmware Build Information */
! 1609: data[7] = 0xc1; /* Subsystem Components Revision */
! 1610: len = 8 - hlen;
! 1611: #else
! 1612: /* for DLT-S4 */
! 1613: data[4] = SPC_VPD_SUPPORTED_VPD_PAGES; /* 0x00 */
! 1614: data[5] = SPC_VPD_UNIT_SERIAL_NUMBER; /* 0x80 */
! 1615: data[6] = SPC_VPD_DEVICE_IDENTIFICATION; /* 0x83 */
! 1616: data[7] = 0xb0; /* Sequential-Access Device Capabilities */
! 1617: data[8] = 0xb1; /* Manufacturer-assigned Serial Number */
! 1618: data[9] = 0xc0; /* Firmware Build Information */
! 1619: data[10] = 0xc1; /* Subsystem Components Revision */
! 1620: len = 11 - hlen;
! 1621: #endif
! 1622:
! 1623: /* PAGE LENGTH */
! 1624: data[3] = len;
! 1625: break;
! 1626:
! 1627: case SPC_VPD_UNIT_SERIAL_NUMBER:
! 1628: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 1629: BDSET8W(&data[0], pq, 7, 3);
! 1630: BDADD8W(&data[0], pd, 4, 5);
! 1631: /* PAGE CODE */
! 1632: data[1] = pc;
! 1633: /* Reserved */
! 1634: data[2] = 0;
! 1635: /* PAGE LENGTH */
! 1636: data[3] = 0;
! 1637: hlen = 4;
! 1638:
! 1639: /* PRODUCT SERIAL NUMBER */
! 1640: len = strlen(spec->lu->inq_serial);
! 1641: if (len > MAX_LU_SERIAL_STRING) {
! 1642: len = MAX_LU_SERIAL_STRING;
! 1643: }
! 1644: istgt_strcpy_pad(&data[4], len, spec->lu->inq_serial, ' ');
! 1645:
! 1646: /* PAGE LENGTH */
! 1647: data[3] = len;
! 1648: break;
! 1649:
! 1650: case SPC_VPD_DEVICE_IDENTIFICATION:
! 1651: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 1652: BDSET8W(&data[0], pq, 7, 3);
! 1653: BDADD8W(&data[0], pd, 4, 5);
! 1654: /* PAGE CODE */
! 1655: data[1] = pc;
! 1656: /* PAGE LENGTH */
! 1657: DSET16(&data[2], 0);
! 1658: hlen = 4;
! 1659:
! 1660: /* Identification descriptor 1 */
! 1661: /* Vendor-Unique Logical Unit Identifier */
! 1662: cp = &data[hlen + len];
! 1663:
! 1664: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1665: BDSET8W(&cp[0], 0, 7, 4);
! 1666: BDADD8W(&cp[0], SPC_VPD_CODE_SET_ASCII, 3, 4);
! 1667: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1668: BDSET8W(&cp[1], 0, 7, 1); /* PIV */
! 1669: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
! 1670: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID, 3, 4);
! 1671: /* Reserved */
! 1672: cp[2] = 0;
! 1673: /* IDENTIFIER LENGTH */
! 1674: cp[3] = 0;
! 1675:
! 1676: /* IDENTIFIER */
! 1677: /* T10 VENDOR IDENTIFICATION */
! 1678: istgt_strcpy_pad(&cp[4], 8, spec->lu->inq_vendor, ' ');
! 1679: /* PRODUCT IDENTIFICATION */
! 1680: istgt_strcpy_pad(&cp[16], 16, spec->lu->inq_product, ' ');
! 1681: /* PRODUCT SERIAL NUMBER */
! 1682: istgt_strcpy_pad(&cp[32], 10, spec->lu->inq_serial, ' ');
! 1683: plen = 8 + 16 + 10;
! 1684:
! 1685: cp[3] = plen;
! 1686: len += 4 + plen;
! 1687:
! 1688: /* Identification descriptor 2 */
! 1689: /* Logical Unit NAA Identifier */
! 1690: cp = &data[hlen + len];
! 1691:
! 1692: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1693: BDSET8W(&cp[0], 0, 7, 4);
! 1694: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_FC, 7, 4);
! 1695: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_SAS, 7, 4);
! 1696: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1697: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1698: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1699: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
! 1700: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_NAA, 3, 4);
! 1701: /* Reserved */
! 1702: cp[2] = 0;
! 1703: /* IDENTIFIER LENGTH */
! 1704: cp[3] = 0;
! 1705:
! 1706: /* IDENTIFIER */
! 1707: /* NAA Identifier (WWNN) */
! 1708: plen = istgt_lu_set_lid(&cp[4], LUI);
! 1709:
! 1710: cp[3] = plen;
! 1711: len += 4 + plen;
! 1712:
! 1713: /* Identification descriptor 3 */
! 1714: /* Port NAA Identifier */
! 1715: cp = &data[hlen + len];
! 1716:
! 1717: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1718: BDSET8W(&cp[0], 0, 7, 4);
! 1719: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_FC, 7, 4);
! 1720: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_SAS, 7, 4);
! 1721: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1722: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1723: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1724: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1725: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_NAA, 3, 4);
! 1726: /* Reserved */
! 1727: cp[2] = 0;
! 1728: /* IDENTIFIER LENGTH */
! 1729: cp[3] = 0;
! 1730:
! 1731: /* IDENTIFIER */
! 1732: /* NAA Identifier (WWPN) */
! 1733: plen = istgt_lu_set_lid(&cp[4], TPI);
! 1734:
! 1735: cp[3] = plen;
! 1736: len += 4 + plen;
! 1737:
! 1738: /* Identification descriptor 4 */
! 1739: /* Relative Target Port Identifier */
! 1740: cp = &data[hlen + len];
! 1741:
! 1742: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1743: BDSET8W(&cp[0], 0, 7, 4);
! 1744: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_FC, 7, 4);
! 1745: //BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_SAS, 7, 4);
! 1746: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1747: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1748: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1749: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1750: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT,
! 1751: 3, 4);
! 1752: /* Reserved */
! 1753: cp[2] = 0;
! 1754: /* IDENTIFIER LENGTH */
! 1755: cp[3] = 0;
! 1756:
! 1757: /* IDENTIFIER */
! 1758: /* Obsolete */
! 1759: DSET16(&cp[4], 0);
! 1760: /* Relative Target Port Identifier */
! 1761: DSET16(&cp[6], 1); /* port1 as port A */
! 1762: //DSET16(&cp[6], 2); /* port2 as port B */
! 1763: plen = 4;
! 1764:
! 1765: cp[3] = plen;
! 1766: len += 4 + plen;
! 1767:
! 1768: #undef LU_ISCSI_IDENTIFIER
! 1769: #ifdef LU_ISCSI_IDENTIFIER
! 1770: /* Identification descriptor 1 */
! 1771: /* Logical Unit */
! 1772: cp = &data[hlen + len];
! 1773:
! 1774: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1775: BDSET8W(&cp[0], 0, 7, 4);
! 1776: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1777: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1778: BDSET8W(&cp[1], 0, 7, 1); /* PIV=0 */
! 1779: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
! 1780: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_NAA, 3, 4);
! 1781: /* Reserved */
! 1782: cp[2] = 0;
! 1783: /* IDENTIFIER LENGTH */
! 1784: cp[3] = 0;
! 1785:
! 1786: /* IDENTIFIER */
! 1787: #if 0
! 1788: /* 16bytes ID */
! 1789: plen = istgt_lu_set_extid(&cp[4], 0, LUI);
! 1790: #else
! 1791: plen = istgt_lu_set_lid(&cp[4], LUI);
! 1792: #endif
! 1793:
! 1794: cp[3] = plen;
! 1795: len += 4 + plen;
! 1796:
! 1797: /* Identification descriptor 2 */
! 1798: /* T10 VENDOR IDENTIFICATION */
! 1799: cp = &data[hlen + len];
! 1800:
! 1801: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1802: BDSET8W(&cp[0], 0, 7, 4);
! 1803: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
! 1804: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1805: BDSET8W(&cp[1], 0, 7, 1); /* PIV=0 */
! 1806: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_LOGICAL_UNIT, 5, 2);
! 1807: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID, 3, 4);
! 1808: /* Reserved */
! 1809: cp[2] = 0;
! 1810: /* IDENTIFIER LENGTH */
! 1811: cp[3] = 0;
! 1812:
! 1813: /* IDENTIFIER */
! 1814: /* T10 VENDOR IDENTIFICATION */
! 1815: istgt_strcpy_pad(&cp[4], 8, spec->lu->inq_vendor, ' ');
! 1816: plen = 8;
! 1817: /* VENDOR SPECIFIC IDENTIFIER */
! 1818: /* PRODUCT IDENTIFICATION */
! 1819: istgt_strcpy_pad(&cp[12], 16, spec->lu->inq_product, ' ');
! 1820: /* PRODUCT SERIAL NUMBER */
! 1821: istgt_strcpy_pad(&cp[28], MAX_LU_SERIAL_STRING,
! 1822: spec->lu->inq_serial, ' ');
! 1823: plen += 16 + MAX_LU_SERIAL_STRING;
! 1824:
! 1825: cp[3] = plen;
! 1826: len += 4 + plen;
! 1827:
! 1828: /* Identification descriptor 3 */
! 1829: /* Target Device */
! 1830: cp = &data[hlen + len];
! 1831:
! 1832: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1833: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 1834: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
! 1835: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1836: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1837: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_DEVICE, 5, 2);
! 1838: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
! 1839: /* Reserved */
! 1840: cp[2] = 0;
! 1841: /* IDENTIFIER LENGTH */
! 1842: cp[3] = 0;
! 1843:
! 1844: /* IDENTIFIER */
! 1845: plen = snprintf((char *) &cp[4], MAX_TARGET_NAME,
! 1846: "%s",
! 1847: spec->lu->name);
! 1848: cp[3] = plen;
! 1849: len += 4 + plen;
! 1850:
! 1851: /* Identification descriptor 4 */
! 1852: /* Target Port */
! 1853: cp = &data[hlen + len];
! 1854:
! 1855: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1856: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 1857: BDADD8W(&cp[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
! 1858: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1859: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1860: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1861: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
! 1862: /* Reserved */
! 1863: cp[2] = 0;
! 1864: /* IDENTIFIER LENGTH */
! 1865: cp[3] = 0;
! 1866:
! 1867: /* IDENTIFIER */
! 1868: plen = snprintf((char *) &cp[4], MAX_TARGET_NAME,
! 1869: "%s"",t,0x""%4.4x",
! 1870: spec->lu->name,
! 1871: conn->portal.tag);
! 1872: cp[3] = plen;
! 1873: len += 4 + plen;
! 1874:
! 1875: /* Identification descriptor 5 */
! 1876: /* Relative Target Port */
! 1877: cp = &data[hlen + len];
! 1878:
! 1879: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1880: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 1881: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1882: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1883: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1884: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1885: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT,
! 1886: 3, 4);
! 1887: /* Reserved */
! 1888: cp[2] = 0;
! 1889: /* IDENTIFIER LENGTH */
! 1890: cp[3] = 0;
! 1891:
! 1892: /* IDENTIFIER */
! 1893: /* Obsolete */
! 1894: DSET16(&cp[4], 0);
! 1895: /* Relative Target Port Identifier */
! 1896: //DSET16(&cp[6], 1); /* port1 as port A */
! 1897: //DSET16(&cp[6], 2); /* port2 as port B */
! 1898: DSET16(&cp[6], (uint16_t) (1 + conn->portal.idx));
! 1899: plen = 4;
! 1900:
! 1901: cp[3] = plen;
! 1902: len += 4 + plen;
! 1903:
! 1904: /* Identification descriptor 6 */
! 1905: /* Target port group */
! 1906: cp = &data[hlen + len];
! 1907:
! 1908: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1909: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 1910: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1911: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1912: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1913: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1914: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_TARGET_PORT_GROUP,
! 1915: 3, 4);
! 1916: /* Reserved */
! 1917: cp[2] = 0;
! 1918: /* IDENTIFIER LENGTH */
! 1919: cp[3] = 0;
! 1920:
! 1921: /* IDENTIFIER */
! 1922: /* Reserved */
! 1923: DSET16(&cp[4], 0);
! 1924: /* TARGET PORT GROUP */
! 1925: DSET16(&cp[6], (uint16_t) (conn->portal.tag));
! 1926: plen = 4;
! 1927:
! 1928: cp[3] = plen;
! 1929: len += 4 + plen;
! 1930:
! 1931: /* Identification descriptor 7 */
! 1932: /* Logical unit group */
! 1933: cp = &data[hlen + len];
! 1934:
! 1935: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 1936: BDSET8W(&cp[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 1937: BDADD8W(&cp[0], SPC_VPD_CODE_SET_BINARY, 3, 4);
! 1938: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 1939: BDSET8W(&cp[1], 1, 7, 1); /* PIV */
! 1940: BDADD8W(&cp[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 1941: BDADD8W(&cp[1], SPC_VPD_IDENTIFIER_TYPE_LOGICAL_UNIT_GROUP,
! 1942: 3, 4);
! 1943: /* Reserved */
! 1944: cp[2] = 0;
! 1945: /* IDENTIFIER LENGTH */
! 1946: cp[3] = 0;
! 1947:
! 1948: /* IDENTIFIER */
! 1949: /* Reserved */
! 1950: DSET16(&cp[4], 0);
! 1951: /* LOGICAL UNIT GROUP */
! 1952: DSET16(&cp[6], (uint16_t) (spec->lu->num));
! 1953: plen = 4;
! 1954:
! 1955: cp[3] = plen;
! 1956: len += 4 + plen;
! 1957: #endif /* LU_ISCSI_IDENTIFIER */
! 1958:
! 1959: /* PAGE LENGTH */
! 1960: if (len > 0xffff) {
! 1961: len = 0xffff;
! 1962: }
! 1963: DSET16(&data[2], len);
! 1964: break;
! 1965:
! 1966: case SPC_VPD_EXTENDED_INQUIRY_DATA:
! 1967: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 1968: BDSET8W(&data[0], pq, 7, 3);
! 1969: BDADD8W(&data[0], pd, 4, 5);
! 1970: /* PAGE CODE */
! 1971: data[1] = pc;
! 1972: /* Reserved */
! 1973: data[2] = 0;
! 1974: /* PAGE LENGTH */
! 1975: data[3] = 0;
! 1976: hlen = 4;
! 1977:
! 1978: /* RTO(3) GRD_CHK(2) APP_CHK(1) REF_CHK(0) */
! 1979: data[4] = 0;
! 1980: /* GROUP_SUP(4) PRIOR_SUP(3) HEADSUP(2) ORDSUP(1) SIMPSUP(0) */
! 1981: data[5] = 0;
! 1982: /* NV_SUP(1) V_SUP(0) */
! 1983: data[6] = 0;
! 1984: /* Reserved[7-63] */
! 1985: memset(&data[7], 0, (64 - 7));
! 1986: len = 64 - hlen;
! 1987:
! 1988: /* PAGE LENGTH */
! 1989: data[3] = len;
! 1990: break;
! 1991:
! 1992: case SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES:
! 1993: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 1994: BDSET8W(&data[0], pq, 7, 3);
! 1995: BDADD8W(&data[0], pd, 4, 5);
! 1996: /* PAGE CODE */
! 1997: data[1] = pc;
! 1998: /* PAGE LENGTH */
! 1999: DSET16(&data[2], 0);
! 2000: hlen = 4;
! 2001:
! 2002: #if 0
! 2003: /* Network services descriptor N */
! 2004: cp = &data[hlen + len];
! 2005:
! 2006: /* ASSOCIATION(6-5) SERVICE TYPE(4-0) */
! 2007: BDSET8W(&cp[0], 0x00, 6, 2);
! 2008: BDADD8W(&cp[0], 0x00, 4, 5);
! 2009: /* Reserved */
! 2010: cp[1] = 0;
! 2011: /* NETWORK ADDRESS LENGTH */
! 2012: DSET16(&cp[2], 0);
! 2013: /* NETWORK ADDRESS */
! 2014: cp[4] = 0;
! 2015: /* ... */
! 2016: plen = 0;
! 2017: DSET16(&cp[2], plen);
! 2018: len += 4 + plen;
! 2019: #endif
! 2020:
! 2021: /* PAGE LENGTH */
! 2022: if (len > 0xffff) {
! 2023: len = 0xffff;
! 2024: }
! 2025: DSET16(&data[2], len);
! 2026: break;
! 2027:
! 2028: case SPC_VPD_MODE_PAGE_POLICY:
! 2029: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2030: BDSET8W(&data[0], pq, 7, 3);
! 2031: BDADD8W(&data[0], pd, 4, 5);
! 2032: /* PAGE CODE */
! 2033: data[1] = pc;
! 2034: /* PAGE LENGTH */
! 2035: DSET16(&data[2], 0);
! 2036: hlen = 4;
! 2037:
! 2038: /* Mode page policy descriptor 1 */
! 2039: cp = &data[hlen + len];
! 2040:
! 2041: /* POLICY PAGE CODE(5-0) */
! 2042: BDSET8W(&cp[0], 0x3f, 5, 6); /* all page code */
! 2043: /* POLICY SUBPAGE CODE */
! 2044: cp[1] = 0xff; /* all sub page */
! 2045: /* MLUS(7) MODE PAGE POLICY(1-0) */
! 2046: //BDSET8(&cp[2], 1, 7); /* multiple logical units share */
! 2047: BDSET8(&cp[2], 0, 7); /* own copy */
! 2048: BDADD8W(&cp[2], 0x00, 1, 2); /* Shared */
! 2049: //BDADD8W(&cp[2], 0x01, 1, 2); /* Per target port */
! 2050: //BDADD8W(&cp[2], 0x02, 1, 2); /* Per initiator port */
! 2051: //BDADD8W(&cp[2], 0x03, 1, 2); /* Per I_T nexus */
! 2052: /* Reserved */
! 2053: cp[3] = 0;
! 2054: len += 4;
! 2055:
! 2056: /* PAGE LENGTH */
! 2057: if (len > 0xffff) {
! 2058: len = 0xffff;
! 2059: }
! 2060: DSET16(&data[2], len);
! 2061: break;
! 2062:
! 2063: case SPC_VPD_SCSI_PORTS:
! 2064: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2065: BDSET8W(&data[0], pq, 7, 3);
! 2066: BDADD8W(&data[0], pd, 4, 5);
! 2067: /* PAGE CODE */
! 2068: data[1] = pc;
! 2069: /* PAGE LENGTH */
! 2070: DSET16(&data[2], 0);
! 2071: hlen = 4;
! 2072:
! 2073: /* Identification descriptor list */
! 2074: for (i = 0; i < spec->lu->maxmap; i++) {
! 2075: pg_tag = spec->lu->map[i].pg_tag;
! 2076: /* skip same pg_tag */
! 2077: for (j = 0; j < i; j++) {
! 2078: if (spec->lu->map[j].pg_tag == pg_tag) {
! 2079: goto skip_pg_tag;
! 2080: }
! 2081: }
! 2082:
! 2083: /* Identification descriptor N */
! 2084: cp = &data[hlen + len];
! 2085:
! 2086: /* Reserved */
! 2087: DSET16(&cp[0], 0);
! 2088: /* RELATIVE PORT IDENTIFIER */
! 2089: DSET16(&cp[2], (uint16_t) (1 + pg_tag));
! 2090: /* Reserved */
! 2091: DSET16(&cp[4], 0);
! 2092: /* INITIATOR PORT TRANSPORTID LENGTH */
! 2093: DSET16(&cp[6], 0);
! 2094: /* Reserved */
! 2095: DSET16(&cp[8], 0);
! 2096: /* TARGET PORT DESCRIPTORS LENGTH */
! 2097: DSET16(&cp[10], 0);
! 2098: len += 12;
! 2099:
! 2100: plen2 = 0;
! 2101: /* Target port descriptor 1 */
! 2102: cp2 = &data[hlen + len + plen2];
! 2103:
! 2104: /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */
! 2105: BDSET8W(&cp2[0], SPC_PROTOCOL_IDENTIFIER_ISCSI, 7, 4);
! 2106: BDADD8W(&cp2[0], SPC_VPD_CODE_SET_UTF8, 3, 4);
! 2107: /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */
! 2108: BDSET8W(&cp2[1], 1, 7, 1); /* PIV */
! 2109: BDADD8W(&cp2[1], SPC_VPD_ASSOCIATION_TARGET_PORT, 5, 2);
! 2110: BDADD8W(&cp2[1], SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME, 3, 4);
! 2111: /* Reserved */
! 2112: cp2[2] = 0;
! 2113: /* IDENTIFIER LENGTH */
! 2114: cp2[3] = 0;
! 2115:
! 2116: /* IDENTIFIER */
! 2117: plen = snprintf((char *) &cp2[4], MAX_TARGET_NAME,
! 2118: "%s"",t,0x""%4.4x",
! 2119: spec->lu->name,
! 2120: pg_tag);
! 2121: cp2[3] = plen;
! 2122: plen2 += 4 + plen;
! 2123:
! 2124: /* TARGET PORT DESCRIPTORS LENGTH */
! 2125: DSET16(&cp[10], plen2);
! 2126: len += plen2;
! 2127: skip_pg_tag:
! 2128: ;
! 2129: }
! 2130:
! 2131: /* PAGE LENGTH */
! 2132: if (len > 0xffff) {
! 2133: len = 0xffff;
! 2134: }
! 2135: DSET16(&data[2], len);
! 2136: break;
! 2137:
! 2138: /* for DLT-S4 */
! 2139: case 0xb0: /* Sequential-Access Device Capabilities */
! 2140: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2141: BDSET8W(&data[0], pq, 7, 3);
! 2142: BDADD8W(&data[0], pd, 4, 5);
! 2143: /* PAGE CODE */
! 2144: data[1] = pc;
! 2145: /* Reserved */
! 2146: data[2] = 0;
! 2147: /* PAGE LENGTH */
! 2148: data[3] = 0;
! 2149: hlen = 4;
! 2150:
! 2151: len = 0x4;
! 2152: memset(&data[4], 0, len);
! 2153: //BSET8(&data[4], 0); /* WORM */
! 2154:
! 2155: /* PAGE LENGTH */
! 2156: data[3] = len;
! 2157: break;
! 2158:
! 2159: case 0xb1: /* Manufacturer-assigned Serial Number */
! 2160: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2161: BDSET8W(&data[0], pq, 7, 3);
! 2162: BDADD8W(&data[0], pd, 4, 5);
! 2163: /* PAGE CODE */
! 2164: data[1] = pc;
! 2165: /* Reserved */
! 2166: data[2] = 0;
! 2167: /* PAGE LENGTH */
! 2168: data[3] = 0;
! 2169: hlen = 4;
! 2170:
! 2171: len = 0x10;
! 2172: memset(&data[4], 0, len);
! 2173:
! 2174: /* Manufacturer Serial Number */
! 2175: snprintf(buf, sizeof buf, "%16.16d", 0);
! 2176: istgt_strcpy_pad(&data[4], 16, buf, ' ');
! 2177:
! 2178: /* PAGE LENGTH */
! 2179: data[3] = len;
! 2180: break;
! 2181:
! 2182: /* for DLT8000 */
! 2183: case 0xc0: /* Firmware Build Information */
! 2184: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2185: BDSET8W(&data[0], pq, 7, 3);
! 2186: BDADD8W(&data[0], pd, 4, 5);
! 2187: /* PAGE CODE */
! 2188: data[1] = pc;
! 2189: /* Reserved */
! 2190: data[2] = 0;
! 2191: /* PAGE LENGTH */
! 2192: data[3] = 0;
! 2193: hlen = 4;
! 2194:
! 2195: len = 0x20;
! 2196: memset(&data[4], 0, len);
! 2197:
! 2198: /* PAGE LENGTH */
! 2199: data[3] = len;
! 2200: break;
! 2201:
! 2202: case 0xc1: /* Subsystem Components Revision */
! 2203: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2204: BDSET8W(&data[0], pq, 7, 3);
! 2205: BDADD8W(&data[0], pd, 4, 5);
! 2206: /* PAGE CODE */
! 2207: data[1] = pc;
! 2208: /* Reserved */
! 2209: data[2] = 0;
! 2210: /* PAGE LENGTH */
! 2211: data[3] = 0;
! 2212: hlen = 4;
! 2213:
! 2214: len = 0x14;
! 2215: memset(&data[4], 0, len);
! 2216:
! 2217: /* Media Loader Present Flag */
! 2218: data[18] = 0;
! 2219: /* Library Present Flag */
! 2220: data[19] = 0;
! 2221:
! 2222: /* PAGE LENGTH */
! 2223: data[3] = len;
! 2224: break;
! 2225:
! 2226: default:
! 2227: if (pc >= 0xc0 && pc <= 0xff) {
! 2228: ISTGT_WARNLOG("Vendor specific INQUIRY VPD page 0x%x\n", pc);
! 2229: } else {
! 2230: ISTGT_ERRLOG("unsupported INQUIRY VPD page 0x%x\n", pc);
! 2231: }
! 2232: return -1;
! 2233: }
! 2234: } else {
! 2235: /* Standard INQUIRY data */
! 2236: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 2237: BDSET8W(&data[0], pq, 7, 3);
! 2238: BDADD8W(&data[0], pd, 4, 5);
! 2239: /* RMB(7) */
! 2240: BDSET8W(&data[1], rmb, 7, 1);
! 2241: /* VERSION */
! 2242: /* See SPC3/SBC2/MMC4/SAM2 for more details */
! 2243: data[2] = SPC_VERSION_SPC3;
! 2244: /* NORMACA(5) HISUP(4) RESPONSE DATA FORMAT(3-0) */
! 2245: BDSET8W(&data[3], 2, 3, 4); /* format 2 */
! 2246: /* ADDITIONAL LENGTH */
! 2247: data[4] = 0;
! 2248: hlen = 5;
! 2249:
! 2250: /* SCCS(7) ACC(6) TPGS(5-4) 3PC(3) PROTECT(0) */
! 2251: data[5] = 0;
! 2252: /* BQUE(7) ENCSERV(6) VS(5) MULTIP(4) MCHNGR(3) ADDR16(0) */
! 2253: data[6] = 0;
! 2254: /* WBUS16(5) SYNC(4) LINKED(3) CMDQUE(1) VS(0) */
! 2255: data[7] = 0;
! 2256: /* T10 VENDOR IDENTIFICATION */
! 2257: istgt_strcpy_pad(&data[8], 8, spec->lu->inq_vendor, ' ');
! 2258: /* PRODUCT IDENTIFICATION */
! 2259: istgt_strcpy_pad(&data[16], 16, spec->lu->inq_product, ' ');
! 2260: /* PRODUCT REVISION LEVEL */
! 2261: istgt_strcpy_pad(&data[32], 4, spec->lu->inq_revision, ' ');
! 2262: /* Vendor specific */
! 2263: memset(&data[36], 0x20, 20);
! 2264: #if 1
! 2265: /* for Quantum DLT */
! 2266: /* Product Family(7-4) Released Firmware(3-0) */
! 2267: //BDSET8W(&data[36], 5, 7, 4); /* 20/40GB */
! 2268: BDSET8W(&data[36], 11, 7, 4); /* 40/80GB */
! 2269: BDSET8W(&data[36], 1, 3, 4); /* Vxxx firmware */
! 2270: /* Firmware Major Version # */
! 2271: data[37] = 0x01;
! 2272: /* Firmware Minor Version # */
! 2273: data[38] = 0x00;
! 2274: /* EEPROM Format Major Version # */
! 2275: data[39] = 0x01;
! 2276: /* EEPROM Format Minor Version # */
! 2277: data[40] = 0x00;
! 2278: /* Firmware Personality */
! 2279: data[41] = 0x04; /* OEM family */
! 2280: /* Firmware Sub-Personality */
! 2281: data[42] = 0x01; /* primary firmware personality variant */
! 2282: /* Vendor Unique Subtype */
! 2283: data[43] = 0x00;
! 2284: /* Controller Hardware Version # */
! 2285: data[44] = 0x01;
! 2286: /* Drive EEPROM Version # */
! 2287: data[45] = 0x01;
! 2288: /* Drive Hardware Version # */
! 2289: data[46] = 0x01;
! 2290: /* Media Loader Firmware Version # */
! 2291: data[47] = 0x00;
! 2292: /* Media Loader Hardware Version # */
! 2293: data[48] = 0x00;
! 2294: /* Media Loader Mechanical Version # */
! 2295: data[49]= 0x00;
! 2296: /* Media Loader Present Flag */
! 2297: data[50] = 0;
! 2298: /* Library Present Flag */
! 2299: data[51] = 0;
! 2300: /* Module Revision */
! 2301: istgt_strcpy_pad(&data[54], 4, TAPE_MODULE_REV, ' ');
! 2302: #endif
! 2303: /* CLOCKING(3-2) QAS(1) IUS(0) */
! 2304: data[56] = 0;
! 2305: /* Reserved */
! 2306: data[57] = 0;
! 2307: /* VERSION DESCRIPTOR 1-8 */
! 2308: DSET16(&data[58], 0x0960); /* iSCSI (no version claimed) */
! 2309: DSET16(&data[60], 0x0300); /* SPC-3 (no version claimed) */
! 2310: DSET16(&data[62], 0x0360); /* SSC-2 (no version claimed) */
! 2311: DSET16(&data[64], 0x0040); /* SAM-2 (no version claimed) */
! 2312: DSET16(&data[66], 0x0000);
! 2313: DSET16(&data[68], 0x0000);
! 2314: DSET16(&data[70], 0x0000);
! 2315: DSET16(&data[72], 0x0000);
! 2316: /* Reserved[74-95] */
! 2317: memset(&data[74], 0, (96 - 74));
! 2318: /* Vendor specific parameters[96-n] */
! 2319: //data[96] = 0;
! 2320: len = 96 - hlen;
! 2321:
! 2322: /* ADDITIONAL LENGTH */
! 2323: data[4] = len;
! 2324: }
! 2325:
! 2326: return hlen + len;
! 2327: }
! 2328:
! 2329: #define MODE_SENSE_PAGE_INIT(B,L,P,SP) \
! 2330: do { \
! 2331: memset((B), 0, (L)); \
! 2332: if ((SP) != 0x00) { \
! 2333: (B)[0] = (P) | 0x40; /* PAGE + SPF=1 */ \
! 2334: (B)[1] = (SP); \
! 2335: DSET16(&(B)[2], (L) - 4); \
! 2336: } else { \
! 2337: (B)[0] = (P); \
! 2338: (B)[1] = (L) - 2; \
! 2339: } \
! 2340: } while (0)
! 2341:
! 2342: static int
! 2343: istgt_lu_tape_scsi_mode_sense_page(ISTGT_LU_TAPE *spec, CONN_Ptr conn, uint8_t *cdb, int pc, int page, int subpage, uint8_t *data, int alloc_len)
! 2344: {
! 2345: uint8_t *cp;
! 2346: int len = 0;
! 2347: int plen;
! 2348: int i;
! 2349:
! 2350: #if 0
! 2351: printf("SENSE pc=%d, page=%2.2x, subpage=%2.2x\n", pc, page, subpage);
! 2352: #endif
! 2353: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE: pc=%d, page=%2.2x, subpage=%2.2x\n", pc, page, subpage);
! 2354:
! 2355: if (pc == 0x00) {
! 2356: /* Current values */
! 2357: } else if (pc == 0x01) {
! 2358: /* Changeable values */
! 2359: if (page != 0x08) {
! 2360: /* not supported */
! 2361: return 0;
! 2362: }
! 2363: } else if (pc == 0x02) {
! 2364: /* Default values */
! 2365: } else {
! 2366: /* Saved values */
! 2367: }
! 2368:
! 2369: cp = &data[len];
! 2370: switch (page) {
! 2371: case 0x00:
! 2372: /* Vendor specific */
! 2373: break;
! 2374: case 0x01:
! 2375: /* Read-Write Error Recovery */
! 2376: break;
! 2377: case 0x02:
! 2378: /* Disconnect-Reconnect mode page */
! 2379: break;
! 2380: case 0x03:
! 2381: case 0x04:
! 2382: case 0x05:
! 2383: case 0x06:
! 2384: case 0x07:
! 2385: case 0x08:
! 2386: /* Reserved */
! 2387: break;
! 2388: case 0x09:
! 2389: /* Obsolete */
! 2390: break;
! 2391: case 0x0a:
! 2392: /* Control mode page */
! 2393: break;
! 2394: case 0x0b:
! 2395: case 0x0c:
! 2396: case 0x0d:
! 2397: case 0x0e:
! 2398: /* Reserved */
! 2399: break;
! 2400: case 0x0f:
! 2401: /* Data Compression */
! 2402: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Data Compression\n");
! 2403: if (subpage != 0x00)
! 2404: break;
! 2405:
! 2406: plen = 0x0e + 2;
! 2407: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
! 2408: if (spec->compression) {
! 2409: BDADD8(&cp[2], 1, 7); /* DCE=1 compression enable */
! 2410: } else {
! 2411: BDADD8(&cp[2], 0, 7); /* DCE=0 compression disable */
! 2412: }
! 2413: //BDADD8(&cp[2], 0, 6); /* DCC=0 not support compression */
! 2414: BDADD8(&cp[2], 1, 6); /* DCC=1 support compression */
! 2415: BDADD8(&cp[3], 1, 7); /* DDE=1 decompression enable */
! 2416: BDADD8W(&cp[3], 0, 6, 2); /* RED=0 not support */
! 2417: /* COMPRESSION ALGORITHM */
! 2418: //DSET32(&cp[4], 0);
! 2419: //DSET32(&cp[4], 0x03); /* IBM ALDC with 512 byte buffer */
! 2420: //DSET32(&cp[4], 0x04); /* IBM ALDC with 1024 byte buffer */
! 2421: //DSET32(&cp[4], 0x05); /* IBM ALDC with 2048 byte buffer */
! 2422: //DSET32(&cp[4], 0x10); /* IBM IDRC */
! 2423: DSET32(&cp[4], TAPE_COMP_ALGORITHM);
! 2424: /* DECOMPRESSION ALGORITHM */
! 2425: //DSET32(&cp[8], 0);
! 2426: DSET32(&cp[8], TAPE_COMP_ALGORITHM);
! 2427: len += plen;
! 2428: break;
! 2429: case 0x10:
! 2430: /* Device Configuration */
! 2431: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Device Configuration\n");
! 2432: if (subpage != 0x00)
! 2433: break;
! 2434:
! 2435: plen = 0x0e + 2;
! 2436: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
! 2437: /* WRITE DELAY TIME */
! 2438: DSET16(&cp[6], TAPE_WRITE_DELAY);
! 2439: /* RSMK(5) */
! 2440: BDADD8(&data[8], 0, 5); /* report setmarks not support */
! 2441: /* LOIS(6) */
! 2442: BDADD8(&data[8], 1, 6);
! 2443: /* EEG(4) SEW(3) */
! 2444: BDADD8(&data[10], 1, 4);
! 2445: BDADD8(&data[10], 1, 3);
! 2446: /* SELECT DATA COMPRESSION ALGORITHM */
! 2447: if (spec->compression) {
! 2448: data[14] = 1; /* data compression is enabled */
! 2449: }
! 2450: len += plen;
! 2451: break;
! 2452: case 0x11:
! 2453: /* Medium Partition */
! 2454: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Medium Partition\n");
! 2455: if (subpage != 0x00)
! 2456: break;
! 2457:
! 2458: plen = 0x08 + 2;
! 2459: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
! 2460: len += plen;
! 2461: break;
! 2462: case 0x12:
! 2463: /* Obsolete */
! 2464: break;
! 2465: case 0x13:
! 2466: /* Obsolete */
! 2467: break;
! 2468: case 0x14:
! 2469: /* Obsolete */
! 2470: break;
! 2471: case 0x15:
! 2472: case 0x16:
! 2473: case 0x17:
! 2474: /* Reserved */
! 2475: break;
! 2476: case 0x18:
! 2477: /* Protocol Specific LUN */
! 2478: break;
! 2479: case 0x19:
! 2480: /* Protocol Specific Port */
! 2481: break;
! 2482: case 0x1a:
! 2483: /* Power Condition */
! 2484: break;
! 2485: case 0x1b:
! 2486: /* Reserved */
! 2487: break;
! 2488: case 0x1c:
! 2489: /* Informational Exceptions Control */
! 2490: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SENSE Informational Exceptions Control\n");
! 2491: if (subpage != 0x00)
! 2492: break;
! 2493:
! 2494: plen = 0x0a + 2;
! 2495: MODE_SENSE_PAGE_INIT(cp, plen, page, subpage);
! 2496: len += plen;
! 2497: break;
! 2498: case 0x1d:
! 2499: case 0x1e:
! 2500: case 0x1f:
! 2501: /* Reserved */
! 2502: break;
! 2503: case 0x20:
! 2504: case 0x21:
! 2505: case 0x22:
! 2506: case 0x23:
! 2507: case 0x24:
! 2508: case 0x25:
! 2509: case 0x26:
! 2510: case 0x27:
! 2511: case 0x28:
! 2512: case 0x29:
! 2513: case 0x2a:
! 2514: case 0x2b:
! 2515: case 0x2c:
! 2516: case 0x2d:
! 2517: case 0x2e:
! 2518: case 0x2f:
! 2519: case 0x30:
! 2520: case 0x31:
! 2521: case 0x32:
! 2522: case 0x33:
! 2523: case 0x34:
! 2524: case 0x35:
! 2525: case 0x36:
! 2526: case 0x37:
! 2527: case 0x38:
! 2528: case 0x39:
! 2529: case 0x3a:
! 2530: case 0x3b:
! 2531: case 0x3c:
! 2532: case 0x3d:
! 2533: case 0x3e:
! 2534: /* Vendor-specific */
! 2535: break;
! 2536: case 0x3f:
! 2537: switch (subpage) {
! 2538: case 0x00:
! 2539: /* All mode pages */
! 2540: for (i = 0x00; i < 0x3e; i ++) {
! 2541: len += istgt_lu_tape_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0x00, &cp[len], alloc_len);
! 2542: }
! 2543: break;
! 2544: case 0xff:
! 2545: /* All mode pages and subpages */
! 2546: for (i = 0x00; i < 0x3e; i ++) {
! 2547: len += istgt_lu_tape_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0x00, &cp[len], alloc_len);
! 2548: }
! 2549: for (i = 0x00; i < 0x3e; i ++) {
! 2550: len += istgt_lu_tape_scsi_mode_sense_page(spec, conn, cdb, pc, i, 0xff, &cp[len], alloc_len);
! 2551: }
! 2552: break;
! 2553: default:
! 2554: /* 0x01-0x3e: Reserved */
! 2555: break;
! 2556: }
! 2557: }
! 2558:
! 2559: return len;
! 2560: }
! 2561:
! 2562: static int
! 2563: istgt_lu_tape_scsi_mode_sense6(ISTGT_LU_TAPE *spec, CONN_Ptr conn, uint8_t *cdb, int dbd, int pc, int page, int subpage, uint8_t *data, int alloc_len)
! 2564: {
! 2565: uint8_t *cp;
! 2566: int hlen = 0, len = 0, plen;
! 2567: int total;
! 2568: int llbaa = 0;
! 2569:
! 2570: data[0] = 0; /* Mode Data Length */
! 2571: if (spec->mload) {
! 2572: //data[1] = 0; /* Medium Type (no media) */
! 2573: //data[1] = TAPE_MEDIATYPE_LTO; /* Medium Type (LTO) */
! 2574: data[1] = MEDIATYPE_DFLT; /* Medium Type */
! 2575: data[2] = 0; /* Device-Specific Parameter */
! 2576: if (spec->lu->readonly
! 2577: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 2578: BDADD8(&data[2], 1, 7); /* WP */
! 2579: }
! 2580: } else {
! 2581: data[1] = 0; /* Medium Type (no media) */
! 2582: data[2] = 0; /* Device-Specific Parameter */
! 2583: }
! 2584: BDADD8W(&data[2], 1, 6, 3); /* Buffed Mode=1 */
! 2585: data[3] = 0; /* Block Descripter Length */
! 2586: hlen = 4;
! 2587:
! 2588: cp = &data[4];
! 2589: if (dbd) { /* Disable Block Descripters */
! 2590: len = 0;
! 2591: } else {
! 2592: if (llbaa) {
! 2593: if (spec->mload) {
! 2594: /* Number of Blocks */
! 2595: DSET64(&cp[0], 0ULL); /* all of the remaining */
! 2596: /* Reserved */
! 2597: DSET32(&cp[8], 0);
! 2598: /* Block Length */
! 2599: DSET32(&cp[12], (uint32_t) spec->lblen);
! 2600: } else {
! 2601: /* Number of Blocks */
! 2602: DSET64(&cp[0], 0ULL); /* all of the remaining */
! 2603: /* Reserved */
! 2604: DSET32(&cp[8], 0);
! 2605: /* Block Length */
! 2606: DSET32(&cp[12], 0);
! 2607: }
! 2608: len = 16;
! 2609: } else {
! 2610: if (spec->mload) {
! 2611: /* Number of Blocks */
! 2612: DSET32(&cp[0], 0); /* all of the remaining */
! 2613: /* Block Length */
! 2614: DSET32(&cp[4], (uint32_t) spec->lblen);
! 2615: cp[0] = DENSITY_DFLT; /* Density Code */
! 2616: cp[4] = 0; /* Reserved */
! 2617: } else {
! 2618: /* Number of Blocks */
! 2619: DSET32(&cp[0], 0); /* all of the remaining */
! 2620: /* Block Length */
! 2621: DSET32(&cp[4], 0);
! 2622: cp[0] = 0; /* Density Code */
! 2623: cp[4] = 0; /* Reserved */
! 2624: }
! 2625: len = 8;
! 2626: }
! 2627: cp += len;
! 2628: }
! 2629: data[3] = len; /* Block Descripter Length */
! 2630:
! 2631: plen = istgt_lu_tape_scsi_mode_sense_page(spec, conn, cdb, pc, page, subpage, &cp[0], alloc_len);
! 2632: cp += plen;
! 2633:
! 2634: total = hlen + len + plen;
! 2635: data[0] = total - 1; /* Mode Data Length */
! 2636:
! 2637: return total;
! 2638: }
! 2639:
! 2640: static int
! 2641: istgt_lu_tape_scsi_mode_sense10(ISTGT_LU_TAPE *spec, CONN_Ptr conn, uint8_t *cdb, int dbd, int llbaa, int pc, int page, int subpage, uint8_t *data, int alloc_len)
! 2642: {
! 2643: uint8_t *cp;
! 2644: int hlen = 0, len = 0, plen;
! 2645: int total;
! 2646:
! 2647: DSET16(&data[0], 0); /* Mode Data Length */
! 2648: if (spec->mload) {
! 2649: //data[2] = 0; /* Medium Type (no media) */
! 2650: //data[2] = TAPE_MEDIATYPE_LTO; /* Medium Type (DLT) */
! 2651: data[2] = MEDIATYPE_DFLT; /* Medium Type */
! 2652: data[3] = 0; /* Device-Specific Parameter */
! 2653: if (spec->lu->readonly
! 2654: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 2655: BDADD8(&data[3], 1, 7); /* WP */
! 2656: }
! 2657: } else {
! 2658: data[2] = 0; /* Medium Type (no media) */
! 2659: data[3] = 0; /* Device-Specific Parameter */
! 2660: }
! 2661: BDADD8W(&data[3], 1, 6, 3); /* Buffed Mode=1 */
! 2662: if (llbaa) {
! 2663: BDSET8(&data[4], 1, 1); /* Long LBA */
! 2664: } else {
! 2665: BDSET8(&data[4], 0, 1); /* Short LBA */
! 2666: }
! 2667: data[5] = 0; /* Reserved */
! 2668: DSET16(&data[6], 0); /* Block Descripter Length */
! 2669: hlen = 8;
! 2670:
! 2671: cp = &data[8];
! 2672: if (dbd) { /* Disable Block Descripters */
! 2673: len = 0;
! 2674: } else {
! 2675: if (llbaa) {
! 2676: if (spec->mload) {
! 2677: /* Number of Blocks */
! 2678: DSET64(&cp[0], 0ULL); /* all of the remaining */
! 2679: /* Reserved */
! 2680: DSET32(&cp[8], 0);
! 2681: /* Block Length */
! 2682: DSET32(&cp[12], (uint32_t) spec->lblen);
! 2683: } else {
! 2684: /* Number of Blocks */
! 2685: DSET64(&cp[0], 0ULL); /* all of the remaining */
! 2686: /* Reserved */
! 2687: DSET32(&cp[8], 0);
! 2688: /* Block Length */
! 2689: DSET32(&cp[12], 0);
! 2690: }
! 2691: len = 16;
! 2692: } else {
! 2693: if (spec->mload) {
! 2694: /* Number of Blocks */
! 2695: DSET32(&cp[0], 0); /* all of the remaining */
! 2696: /* Block Length */
! 2697: DSET32(&cp[4], (uint32_t) spec->lblen);
! 2698: cp[0] = DENSITY_DFLT; /* Density Code */
! 2699: cp[4] = 0; /* Reserved */
! 2700: } else {
! 2701: /* Number of Blocks */
! 2702: DSET32(&cp[0], 0); /* all of the remaining */
! 2703: /* Block Length */
! 2704: DSET32(&cp[4], 0);
! 2705: cp[0] = 0; /* Density Code */
! 2706: cp[4] = 0; /* Reserved */
! 2707: }
! 2708: len = 8;
! 2709: }
! 2710: cp += len;
! 2711: }
! 2712: DSET16(&data[6], len); /* Block Descripter Length */
! 2713:
! 2714: plen = istgt_lu_tape_scsi_mode_sense_page(spec, conn, cdb, pc, page, subpage, &cp[0], alloc_len);
! 2715: cp += plen;
! 2716:
! 2717: total = hlen + len + plen;
! 2718: DSET16(&data[0], total - 2); /* Mode Data Length */
! 2719:
! 2720: return total;
! 2721: }
! 2722:
! 2723: static int
! 2724: istgt_lu_tape_transfer_data(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint8_t *buf, size_t bufsize, size_t len)
! 2725: {
! 2726: int rc;
! 2727:
! 2728: if (len > bufsize) {
! 2729: ISTGT_ERRLOG("bufsize(%d) too small\n", bufsize);
! 2730: return -1;
! 2731: }
! 2732: rc = istgt_iscsi_transfer_out(conn, lu_cmd, buf, bufsize, len);
! 2733: if (rc < 0) {
! 2734: ISTGT_ERRLOG("iscsi_transfer_out()\n");
! 2735: return -1;
! 2736: }
! 2737: return 0;
! 2738: }
! 2739:
! 2740: static int
! 2741: istgt_lu_tape_scsi_mode_select_page(ISTGT_LU_TAPE *spec, CONN_Ptr conn, uint8_t *cdb, int pf, int sp, uint8_t *data, size_t len)
! 2742: {
! 2743: int ps, spf, page, subpage;
! 2744: int hlen, plen;
! 2745: int rc;
! 2746:
! 2747: if (pf == 0) {
! 2748: /* vendor specific */
! 2749: return 0;
! 2750: }
! 2751:
! 2752: if (len < 1)
! 2753: return 0;
! 2754: ps = BGET8(&data[0], 7);
! 2755: spf = BGET8(&data[0], 6);
! 2756: page = data[0] & 0x3f;
! 2757: if (spf) {
! 2758: /* Sub_page mode page format */
! 2759: hlen = 4;
! 2760: if (len < hlen)
! 2761: return 0;
! 2762: subpage = data[1];
! 2763:
! 2764: plen = DGET16(&data[2]);
! 2765: } else {
! 2766: /* Page_0 mode page format */
! 2767: hlen = 2;
! 2768: if (len < hlen)
! 2769: return 0;
! 2770: subpage = 0;
! 2771: plen = data[1];
! 2772: }
! 2773: plen += hlen;
! 2774: if (len < plen)
! 2775: return 0;
! 2776:
! 2777: #if 0
! 2778: printf("SELECT ps=%d, page=%2.2x, subpage=%2.2x\n", ps, page, subpage);
! 2779: #endif
! 2780: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT: ps=%d, page=%2.2x, subpage=%2.2x\n", ps, page, subpage);
! 2781: switch (page) {
! 2782: case 0x0f:
! 2783: /* Data Compression */
! 2784: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Data Compression\n");
! 2785: {
! 2786: int dce, dde, red;
! 2787: uint32_t compalgo, decompalgo;
! 2788:
! 2789: if (subpage != 0x00)
! 2790: break;
! 2791: if (plen != 0x0e + hlen) {
! 2792: /* unknown format */
! 2793: break;
! 2794: }
! 2795:
! 2796: dce = BGET8(&data[2], 7); /* DCE */
! 2797: dde = BGET8(&data[3], 7); /* DDE */
! 2798: red = BGET8W(&data[3], 6, 2); /* RED */
! 2799:
! 2800: compalgo = DGET32(&data[4]);
! 2801: decompalgo = DGET32(&data[8]);
! 2802:
! 2803: switch (compalgo) {
! 2804: case 0x00: /* default by hard */
! 2805: compalgo = TAPE_COMP_ALGORITHM;
! 2806: case 0x03: /* ALDC 512 */
! 2807: case 0x04: /* ALDC 1024 */
! 2808: case 0x05: /* ALDC 2048 */
! 2809: case 0x10: /* IDRC */
! 2810: spec->compalgo = compalgo;
! 2811: spec->vtcompalgo = MARK_COMPALGO_NONE;
! 2812: break;
! 2813: default:
! 2814: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "unsupported Compression Algorithm\n");
! 2815: /* force to default */
! 2816: spec->compalgo = TAPE_COMP_ALGORITHM;
! 2817: spec->vtcompalgo = MARK_COMPALGO_NONE;
! 2818: break;
! 2819: }
! 2820:
! 2821: if (dce) {
! 2822: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Data compression enable\n");
! 2823: spec->compression = 1;
! 2824: } else {
! 2825: spec->compression = 0;
! 2826: }
! 2827: if (dde) {
! 2828: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Data decompression enable\n");
! 2829: }
! 2830: break;
! 2831: }
! 2832: case 0x10:
! 2833: /* Device Configuration */
! 2834: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "MODE_SELECT Device Configuration\n");
! 2835: {
! 2836: if (subpage != 0x00)
! 2837: break;
! 2838: if (plen != 0x0e + hlen) {
! 2839: /* unknown format */
! 2840: break;
! 2841: }
! 2842: break;
! 2843: }
! 2844: default:
! 2845: /* not supported */
! 2846: break;
! 2847: }
! 2848:
! 2849: len -= plen;
! 2850: if (len != 0) {
! 2851: rc = istgt_lu_tape_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[plen], len);
! 2852: if (rc < 0) {
! 2853: return rc;
! 2854: }
! 2855: }
! 2856: return 0;
! 2857: }
! 2858:
! 2859: static int
! 2860: istgt_convert_signed_24bits(uint32_t usval)
! 2861: {
! 2862: int value;
! 2863:
! 2864: /* 24bits two's complement notation */
! 2865: if (usval > 0x007fffff) {
! 2866: usval -= 1;
! 2867: usval = ~usval;
! 2868: usval &= 0x00ffffff;
! 2869: value = (int) usval;
! 2870: value = -value;
! 2871: } else {
! 2872: value = (int) usval;
! 2873: }
! 2874: return value;
! 2875: }
! 2876:
! 2877: #define THREAD_YIELD do { istgt_yield(); usleep(1000); } while (0)
! 2878:
! 2879: static int
! 2880: istgt_lu_tape_shrink_media(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t request_len, uint8_t *data)
! 2881: {
! 2882: struct stat st;
! 2883: uint64_t mediasize;
! 2884: uint64_t marklen;
! 2885: uint32_t mediaflags;
! 2886: int fd;
! 2887:
! 2888: fd = spec->fd;
! 2889: mediasize = spec->size;
! 2890: mediaflags = spec->mflags;
! 2891: marklen = spec->ctlblock->marklen;
! 2892:
! 2893: if (fstat(fd, &st) == -1) {
! 2894: ISTGT_ERRLOG("fstat() failed\n");
! 2895: return -1;
! 2896: }
! 2897:
! 2898: if (S_ISREG(st.st_mode)) {
! 2899: /* media is file */
! 2900: if (mediaflags & ISTGT_LU_FLAG_MEDIA_DYNAMIC) {
! 2901: if (request_len < ISTGT_LU_MEDIA_SIZE_MIN) {
! 2902: request_len = ISTGT_LU_MEDIA_SIZE_MIN;
! 2903: }
! 2904: mediasize = request_len;
! 2905: #ifdef TAPE_DEBUG
! 2906: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Shrink: %" PRIu64 " -> %" PRIu64 "\n", st.st_size, request_len);
! 2907: #endif /* TAPE_DEBUG */
! 2908: /* truncate */
! 2909: if (ftruncate(fd, request_len) == -1) {
! 2910: ISTGT_ERRLOG("ftruncate() failed\n");
! 2911: return -1;
! 2912: }
! 2913: fsync(fd);
! 2914: spec->size = mediasize;
! 2915: }
! 2916: } else {
! 2917: /* media is not file */
! 2918: }
! 2919: return 0;
! 2920: }
! 2921:
! 2922: static int
! 2923: istgt_lu_tape_scsi_erase(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint8_t *data)
! 2924: {
! 2925: struct stat st;
! 2926: uint64_t mediasize;
! 2927: uint64_t ctlblocklen;
! 2928: uint64_t marklen;
! 2929: uint64_t request_len;
! 2930: uint32_t mediaflags;
! 2931: int data_len;
! 2932: int newfile;
! 2933: int fd;
! 2934:
! 2935: fd = spec->fd;
! 2936: mediasize = spec->size;
! 2937: mediaflags = spec->mflags;
! 2938:
! 2939: ctlblocklen = spec->ctlblock->ctlblocklen;
! 2940: marklen = spec->ctlblock->marklen;
! 2941: if (ctlblocklen < CTLBLOCKLEN) {
! 2942: ctlblocklen = CTLBLOCKLEN;
! 2943: }
! 2944: if (marklen < MARK_LENGTH) {
! 2945: marklen = MARK_LENGTH;
! 2946: }
! 2947:
! 2948: if (spec->lu->readonly
! 2949: || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 2950: /* WRITE PROTECTED */
! 2951: data_len
! 2952: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 2953: ISTGT_SCSI_SENSE_DATA_PROTECT,
! 2954: 0x27, 0x00);
! 2955: lu_cmd->sense_data_len = data_len;
! 2956: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 2957: return -1;
! 2958: }
! 2959: if (!spec->bot) {
! 2960: /* PARAMETER VALUE INVALID */
! 2961: data_len
! 2962: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 2963: ISTGT_SCSI_SENSE_ILLEGAL_REQUEST,
! 2964: 0x26, 0x02);
! 2965: lu_cmd->sense_data_len = data_len;
! 2966: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 2967: return -1;
! 2968: }
! 2969: if (spec->lu->lun[spec->lun].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 2970: /* INTERNAL TARGET FAILURE */
! 2971: data_len
! 2972: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 2973: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 2974: 0x44, 0x00);
! 2975: lu_cmd->sense_data_len = data_len;
! 2976: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 2977: return -1;
! 2978: }
! 2979:
! 2980: /* low I/O */
! 2981: if (fstat(fd, &st) == -1) {
! 2982: ISTGT_ERRLOG("fstat() failed\n");
! 2983: io_failure:
! 2984: /* LOGICAL UNIT FAILURE */
! 2985: data_len
! 2986: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 2987: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 2988: 0x3e, 0x01);
! 2989: lu_cmd->sense_data_len = data_len;
! 2990: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 2991: return -1;
! 2992: }
! 2993:
! 2994: /* clear ctlblock + BOT + EOD */
! 2995: request_len = ctlblocklen + marklen * 2;
! 2996: spec->ctlblock->marks[1].offset = MARK_END;
! 2997: spec->ctlblock->marks[1].lbpos = MARK_END;
! 2998: spec->ctlblock->marks[1].prev = 0ULL;
! 2999: memset(data, 0, request_len);
! 3000: if (istgt_lu_tape_seek(spec, 0) == -1) {
! 3001: ISTGT_ERRLOG("lu_tape_lseek() failed\n");
! 3002: goto io_failure;
! 3003: }
! 3004: if (istgt_lu_tape_write(spec, data, request_len) != request_len) {
! 3005: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 3006: goto io_failure;
! 3007: }
! 3008: fsync(fd);
! 3009: /* initialize filemarks */
! 3010: newfile = 1;
! 3011: if (istgt_lu_tape_init_ctlblock(spec, newfile) < 0) {
! 3012: ISTGT_ERRLOG("lu_tape_init_ctlblock() failed\n");
! 3013: goto io_failure;
! 3014: }
! 3015: fsync(fd);
! 3016:
! 3017: if (S_ISREG(st.st_mode)) {
! 3018: /* media is file */
! 3019: /* truncate and extend */
! 3020: if (ftruncate(fd, request_len) == -1) {
! 3021: ISTGT_ERRLOG("ftruncate() failed\n");
! 3022: goto io_failure;
! 3023: }
! 3024: fsync(fd);
! 3025: if (mediaflags & ISTGT_LU_FLAG_MEDIA_DYNAMIC) {
! 3026: if (request_len < ISTGT_LU_MEDIA_SIZE_MIN) {
! 3027: request_len = ISTGT_LU_MEDIA_SIZE_MIN;
! 3028: }
! 3029: mediasize = request_len;
! 3030: }
! 3031: memset(data, 0, marklen);
! 3032: if (istgt_lu_tape_seek(spec, (mediasize - marklen)) == -1) {
! 3033: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 3034: goto io_failure;
! 3035: }
! 3036: if (istgt_lu_tape_write(spec, data, marklen) != marklen) {
! 3037: ISTGT_ERRLOG("istgt_lu_tape_write() failed\n");
! 3038: goto io_failure;
! 3039: }
! 3040: fsync(fd);
! 3041: spec->size = mediasize;
! 3042: } else {
! 3043: /* media is not file */
! 3044: uint64_t offset, wlen, rest;
! 3045: /* clear with 256K */
! 3046: offset = request_len;
! 3047: wlen = 256*1024;
! 3048: memset(data, 0, wlen);
! 3049: for ( ; offset < mediasize - wlen; offset += wlen) {
! 3050: THREAD_YIELD;
! 3051: if (istgt_lu_tape_write(spec, data, wlen) != wlen) {
! 3052: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 3053: goto io_failure;
! 3054: }
! 3055: }
! 3056: /* clear rest size */
! 3057: rest = mediasize % wlen;
! 3058: if (rest != 0) {
! 3059: THREAD_YIELD;
! 3060: if (istgt_lu_tape_write(spec, data, rest) != rest) {
! 3061: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 3062: goto io_failure;
! 3063: }
! 3064: }
! 3065: THREAD_YIELD;
! 3066: fsync(fd);
! 3067: }
! 3068:
! 3069: /* rewind */
! 3070: istgt_lu_tape_rewind(spec);
! 3071:
! 3072: /* complete erase */
! 3073: lu_cmd->data_len = 0;
! 3074: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3075: return 0;
! 3076: }
! 3077:
! 3078: static int
! 3079: istgt_lu_tape_valid_mark_magic(tape_markblock_t *mbp)
! 3080: {
! 3081: if (mbp == NULL)
! 3082: return 0;
! 3083: if (memcmp(mbp->magic, MARK_BOTMAGIC, MARK_MAGICLEN) == 0)
! 3084: return 1;
! 3085: if (memcmp(mbp->magic, MARK_EOTMAGIC, MARK_MAGICLEN) == 0)
! 3086: return 1;
! 3087: if (memcmp(mbp->magic, MARK_EOFMAGIC, MARK_MAGICLEN) == 0)
! 3088: return 1;
! 3089: if (memcmp(mbp->magic, MARK_EODMAGIC, MARK_MAGICLEN) == 0)
! 3090: return 1;
! 3091: if (memcmp(mbp->magic, MARK_DATAMAGIC, MARK_MAGICLEN) == 0)
! 3092: return 1;
! 3093: return 0;
! 3094: }
! 3095:
! 3096: static int
! 3097: istgt_lu_tape_search_lbpos(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lbpos, uint8_t *data)
! 3098: {
! 3099: tape_markblock_t *mbp;
! 3100: uint64_t tape_leader;
! 3101: uint64_t marklen, alignment, padlen;
! 3102: uint64_t lbpos1, offset1, lbpos2, offset2;
! 3103: uint64_t offset, prev;
! 3104: int found_lbpos = 0;
! 3105: int data_len;
! 3106: int index_i;
! 3107: int rc;
! 3108: int i;
! 3109:
! 3110: tape_leader = spec->ctlblock->ctlblocklen;
! 3111: marklen = spec->ctlblock->marklen;
! 3112: alignment = spec->ctlblock->alignment;
! 3113:
! 3114: #ifdef TAPE_DEBUG
! 3115: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "search lbpos=%" PRIu64 "\n", lbpos);
! 3116: #endif /* TAPE_DEBUG */
! 3117: /* firset step, jump near position by EOF */
! 3118: index_i = -1;
! 3119: for (i = 0; i < MAX_FILEMARKS - 1; i++) {
! 3120: offset1 = spec->ctlblock->marks[i].offset;
! 3121: offset2 = spec->ctlblock->marks[i + 1].offset;
! 3122: lbpos1 = spec->ctlblock->marks[i].lbpos;
! 3123: lbpos2 = spec->ctlblock->marks[i + 1].lbpos;
! 3124: if (offset1 == MARK_END) {
! 3125: /* no more marks */
! 3126: break;
! 3127: }
! 3128: if (offset2 == MARK_END) {
! 3129: /* adjust to real media size */
! 3130: offset2 = spec->size;
! 3131: }
! 3132: /* lbpos within EOFs? */
! 3133: if (lbpos >= lbpos1 && lbpos < lbpos2) {
! 3134: index_i = i;
! 3135: break;
! 3136: }
! 3137: }
! 3138: if (index_i < 0) {
! 3139: /* END-OF-PARTITION/MEDIUM DETECTED */
! 3140: data_len
! 3141: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3142: ISTGT_SCSI_SENSE_MEDIUM_ERROR,
! 3143: 0x00, 0x02);
! 3144: lu_cmd->sense_data_len = data_len;
! 3145: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3146: return -1;
! 3147: }
! 3148:
! 3149: /* next step, search in file */
! 3150: mbp = (tape_markblock_t *) data;
! 3151: prev = spec->ctlblock->marks[index_i].prev;
! 3152: found_lbpos = 0;
! 3153: for (offset = offset1; offset < offset2; ) {
! 3154: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 3155: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 3156: break;
! 3157: }
! 3158: rc = istgt_lu_tape_read_native_mark(spec, mbp);
! 3159: if (rc < 0) {
! 3160: ISTGT_ERRLOG("lu_tape_read_native_mark() failed: rc %d\n", rc);
! 3161: break;
! 3162: }
! 3163: /* check in logical block */
! 3164: if (!istgt_lu_tape_valid_mark_magic(mbp)) {
! 3165: ISTGT_ERRLOG("bad magic offset %" PRIu64 "\n", offset);
! 3166: break;
! 3167: }
! 3168: #ifdef TAPE_DEBUG
! 3169: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "read mlbpos=%" PRIu64 ", mlblen=%" PRIu64 ", moffset=%" PRIu64 ", offset=%" PRIu64 ", index=%d\n",
! 3170: mbp->lbpos, mbp->lblen, mbp->offset, offset, index_i);
! 3171: #endif /* TAPE_DEBUG */
! 3172: if (lbpos == mbp->lbpos) {
! 3173: found_lbpos = 1;
! 3174: offset = mbp->offset;
! 3175: break;
! 3176: }
! 3177:
! 3178: /* next offset to read */
! 3179: prev = offset;
! 3180: offset += marklen + mbp->lblen;
! 3181: if (offset % alignment) {
! 3182: padlen = alignment;
! 3183: padlen -= offset % alignment;
! 3184: offset += padlen;
! 3185: }
! 3186: }
! 3187: if (!found_lbpos) {
! 3188: /* within EOFs, but not found */
! 3189: /* INTERNAL TARGET FAILURE */
! 3190: data_len
! 3191: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3192: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 3193: 0x44, 0x00);
! 3194: lu_cmd->sense_data_len = data_len;
! 3195: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3196: return -1;
! 3197: }
! 3198:
! 3199: #ifdef TAPE_DEBUG
! 3200: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set lbpos=%" PRIu64 ", offset=%" PRIu64 ", index=%d\n", lbpos, offset, index_i);
! 3201: #endif /* TAPE_DEBUG */
! 3202: /* update information */
! 3203: spec->index = index_i;
! 3204: spec->lbpos = lbpos;
! 3205: spec->prev = prev;
! 3206: spec->offset = offset;
! 3207:
! 3208: spec->bot = spec->eof = spec->eod = spec->eom = 0;
! 3209: if (index_i == 0 && offset == 0) {
! 3210: spec->bot = 1;
! 3211: } else if (offset == spec->ctlblock->marks[index_i].offset) {
! 3212: if (offset == MARK_END) {
! 3213: spec->eom = 1;
! 3214: } else {
! 3215: spec->eof = 1;
! 3216: }
! 3217: }
! 3218:
! 3219: /* complete search, new position to lbpos */
! 3220: lu_cmd->data_len = 0;
! 3221: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3222: return 0;
! 3223: }
! 3224:
! 3225: static int
! 3226: istgt_lu_tape_search_lbpos_fast_reverse(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lbpos, int count, uint8_t *data)
! 3227: {
! 3228: uint64_t xlbpos, offset, prev;
! 3229: int index_i;
! 3230:
! 3231: xlbpos = spec->lbpos;
! 3232: offset = spec->offset;
! 3233: prev = spec->prev;
! 3234: index_i = spec->index;
! 3235:
! 3236: /* now only support -1 */
! 3237: if (count != -1)
! 3238: return -1;
! 3239:
! 3240: /* END mark is special */
! 3241: if (offset == MARK_END
! 3242: || spec->ctlblock->marks[index_i].offset == MARK_END
! 3243: || spec->ctlblock->marks[index_i + 1].offset == MARK_END)
! 3244: return -1;
! 3245:
! 3246: /* this lbpos have previous offset? */
! 3247: if (lbpos != xlbpos)
! 3248: return -1;
! 3249: if (offset == spec->ctlblock->marks[index_i + 1].offset
! 3250: && spec->ctlblock->marks[index_i + 1].prev != 0ULL) {
! 3251: /* get from EOF mark */
! 3252: offset = spec->ctlblock->marks[index_i + 1].prev;
! 3253: lbpos = spec->ctlblock->marks[index_i + 1].lbpos;
! 3254: lbpos--;
! 3255: prev = 0ULL;
! 3256:
! 3257: #ifdef TAPE_DEBUG
! 3258: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set lbpos=%" PRIu64 ", offset=%" PRIu64 ", index=%d\n", lbpos, offset, index_i);
! 3259: #endif /* TAPE_DEBUG */
! 3260: /* update information */
! 3261: spec->index = index_i;
! 3262: spec->lbpos = lbpos;
! 3263: spec->prev = prev;
! 3264: spec->offset = offset;
! 3265:
! 3266: spec->bot = spec->eof = spec->eod = spec->eom = 0;
! 3267: if (index_i == 0 && offset == 0) {
! 3268: spec->bot = 1;
! 3269: } else if (offset == spec->ctlblock->marks[index_i].offset) {
! 3270: if (offset == MARK_END) {
! 3271: spec->eom = 1;
! 3272: } else {
! 3273: spec->eof = 1;
! 3274: }
! 3275: }
! 3276:
! 3277: /* complete search, new position to lbpos */
! 3278: lu_cmd->data_len = 0;
! 3279: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3280: return 0;
! 3281: }
! 3282:
! 3283: /* no method for fast reverse */
! 3284: return -1;
! 3285: }
! 3286:
! 3287: static int
! 3288: istgt_lu_tape_scsi_space(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int code, int count, uint8_t *data)
! 3289: {
! 3290: uint64_t lbpos, offset, prev;
! 3291: int found_bot = 0, found_eom = 0;
! 3292: int data_len;
! 3293: int index_i;
! 3294: int i;
! 3295:
! 3296: if (code != 0x03 && count == 0) {
! 3297: /* no-op except EOD */
! 3298: lu_cmd->data_len = 0;
! 3299: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3300: return 0;
! 3301: }
! 3302:
! 3303: lbpos = spec->lbpos;
! 3304: offset = spec->offset;
! 3305: prev = spec->prev;
! 3306: index_i = spec->index;
! 3307:
! 3308: if (code == 0x00) {
! 3309: /* Logical blocks */
! 3310: if (count < 0) {
! 3311: /* reverse */
! 3312: /* first check search cache etc. */
! 3313: data_len
! 3314: = istgt_lu_tape_search_lbpos_fast_reverse(spec, conn, lu_cmd,
! 3315: lbpos, count, data);
! 3316: if (data_len > 0) {
! 3317: /* scsi condition met */
! 3318: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3319: return data_len;
! 3320: } else if (data_len == 0) {
! 3321: /* found position */
! 3322: lu_cmd->data_len = 0;
! 3323: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3324: return 0;
! 3325: }
! 3326: count = -count;
! 3327: if (lbpos < (uint64_t) count) {
! 3328: lbpos = 0ULL;
! 3329: } else {
! 3330: lbpos -= (uint64_t) count;
! 3331: }
! 3332: } else if (count > 0) {
! 3333: /* forward */
! 3334: if ((uint64_t) count > LBPOS_MAX - lbpos) {
! 3335: lbpos = LBPOS_MAX;
! 3336: } else {
! 3337: lbpos += (uint64_t) count;
! 3338: }
! 3339: }
! 3340:
! 3341: /* search in file (logical blocks) */
! 3342: data_len = istgt_lu_tape_search_lbpos(spec, conn, lu_cmd, lbpos, data);
! 3343: if (data_len != 0) {
! 3344: /* sense data build by function */
! 3345: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3346: return data_len;
! 3347: }
! 3348: } else if (code == 0x01) {
! 3349: /* Filemarks */
! 3350: if (count < 0) {
! 3351: /* reverse */
! 3352: for (i = 0; i > count; i--) {
! 3353: if (index_i + i == 0) {
! 3354: found_bot = 1;
! 3355: break;
! 3356: }
! 3357: }
! 3358: index_i += i;
! 3359: offset = spec->ctlblock->marks[index_i].offset;
! 3360: if (offset == MARK_END) {
! 3361: /* INTERNAL TARGET FAILURE */
! 3362: data_len
! 3363: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3364: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 3365: 0x44, 0x00);
! 3366: lu_cmd->sense_data_len = data_len;
! 3367: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3368: return data_len;
! 3369: }
! 3370: /* position to EOF */
! 3371: lbpos = spec->ctlblock->marks[index_i + 1].lbpos;
! 3372: offset = spec->ctlblock->marks[index_i + 1].offset;
! 3373: prev = spec->ctlblock->marks[index_i + 1].prev;
! 3374: } else if (count > 0) {
! 3375: /* forward */
! 3376: for (i = 0; i < count; i++) {
! 3377: if (spec->ctlblock->marks[index_i + i].offset == MARK_END) {
! 3378: found_eom = 1;
! 3379: break;
! 3380: }
! 3381: }
! 3382: index_i += i;
! 3383: offset = spec->ctlblock->marks[index_i].offset;
! 3384: if (found_eom || offset == MARK_END) {
! 3385: /* END-OF-DATA DETECTED */
! 3386: data_len
! 3387: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3388: ISTGT_SCSI_SENSE_BLANK_CHECK,
! 3389: 0x00, 0x05);
! 3390: DSET32(&data[2+3], (uint32_t) count - i);
! 3391: lu_cmd->sense_data_len = data_len;
! 3392: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3393: return data_len;
! 3394: }
! 3395: lbpos = spec->ctlblock->marks[index_i].lbpos;
! 3396: /* position to next block of EOF */
! 3397: prev = offset;
! 3398: offset += spec->ctlblock->marklen;
! 3399: lbpos++;
! 3400: }
! 3401:
! 3402: #ifdef TAPE_DEBUG
! 3403: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set lbpos=%" PRIu64 ", offset=%" PRIu64 ", index=%d\n", lbpos, offset, index_i);
! 3404: #endif /* TAPE_DEBUG */
! 3405: /* update information */
! 3406: spec->index = index_i;
! 3407: spec->lbpos = lbpos;
! 3408: spec->prev = prev;
! 3409: spec->offset = offset;
! 3410:
! 3411: spec->bot = spec->eof = spec->eod = spec->eom = 0;
! 3412: if (index_i == 0 && offset == 0) {
! 3413: spec->bot = 1;
! 3414: } else if (offset == spec->ctlblock->marks[index_i].offset) {
! 3415: if (offset == MARK_END) {
! 3416: spec->eom = 1;
! 3417: } else {
! 3418: spec->eof = 1;
! 3419: }
! 3420: }
! 3421: } else if (code == 0x03) {
! 3422: /* End-of-data */
! 3423: index_i = -1;
! 3424: for (i = 0; i < MAX_FILEMARKS ; i++) {
! 3425: if (spec->ctlblock->marks[i].offset == MARK_END) {
! 3426: index_i = i;
! 3427: break;
! 3428: }
! 3429: }
! 3430: if (index_i <= 0) {
! 3431: /* INTERNAL TARGET FAILURE */
! 3432: data_len
! 3433: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3434: ISTGT_SCSI_SENSE_HARDWARE_ERROR,
! 3435: 0x44, 0x00);
! 3436: lu_cmd->sense_data_len = data_len;
! 3437: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3438: return data_len;
! 3439: }
! 3440:
! 3441: /* skip EOT (position to last EOF) */
! 3442: index_i--;
! 3443: lbpos = spec->ctlblock->marks[index_i].lbpos;
! 3444: offset = spec->ctlblock->marks[index_i].offset;
! 3445: /* position to next block of EOF */
! 3446: prev = offset;
! 3447: offset += spec->ctlblock->marklen;
! 3448: lbpos++;
! 3449:
! 3450: #ifdef TAPE_DEBUG
! 3451: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set lbpos=%" PRIu64 ", offset=%" PRIu64 ", index=%d\n", lbpos, offset, index_i);
! 3452: #endif /* TAPE_DEBUG */
! 3453: /* update information */
! 3454: spec->index = index_i;
! 3455: spec->lbpos = lbpos;
! 3456: spec->prev = prev;
! 3457: spec->offset = offset;
! 3458:
! 3459: spec->bot = spec->eof = spec->eod = spec->eom = 0;
! 3460: if (index_i == 0 && offset == 0) {
! 3461: spec->bot = 1;
! 3462: } else if (offset == spec->ctlblock->marks[index_i].offset) {
! 3463: if (offset == MARK_END) {
! 3464: spec->eom = 1;
! 3465: } else {
! 3466: spec->eof = 1;
! 3467: }
! 3468: }
! 3469: } else {
! 3470: /* INVALID FIELD IN CDB */
! 3471: data_len
! 3472: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3473: ISTGT_SCSI_SENSE_ILLEGAL_REQUEST,
! 3474: 0x24, 0x00);
! 3475: lu_cmd->sense_data_len = data_len;
! 3476: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3477: return data_len;
! 3478: }
! 3479:
! 3480: /* complete space command, new position to lbpos */
! 3481: lu_cmd->data_len = 0;
! 3482: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3483: return 0;
! 3484: }
! 3485:
! 3486: static int
! 3487: istgt_lu_tape_scsi_locate(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint32_t loi, uint8_t *data)
! 3488: {
! 3489: uint64_t lbpos;
! 3490: int data_len;
! 3491:
! 3492: if (loi == 0) {
! 3493: /* position to zero (BOT) */
! 3494: istgt_lu_tape_rewind(spec);
! 3495: lu_cmd->data_len = 0;
! 3496: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3497: return 0;
! 3498: }
! 3499:
! 3500: lbpos = (uint64_t) loi;
! 3501:
! 3502: /* search logical block */
! 3503: data_len = istgt_lu_tape_search_lbpos(spec, conn, lu_cmd, lbpos, data);
! 3504: if (data_len != 0) {
! 3505: /* sense data build by function */
! 3506: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3507: return data_len;
! 3508: }
! 3509:
! 3510: /* complete locate command, new position to lbpos */
! 3511: lu_cmd->data_len = 0;
! 3512: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3513: return 0;
! 3514: }
! 3515:
! 3516: static int
! 3517: istgt_lu_tape_scsi_read_position(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int sa, uint8_t *data)
! 3518: {
! 3519: uint64_t lbpos;
! 3520: int data_len;
! 3521:
! 3522: lbpos = spec->lbpos;
! 3523:
! 3524: switch (sa) {
! 3525: case 0x00:
! 3526: /* 0x00 SHORT FORM -- BLOCK ID */
! 3527: case 0x01:
! 3528: /* 0x01 SHORT FORM -- VENDOR-SPECIFIC */
! 3529: data_len = 20;
! 3530: memset(&data[0], 0, data_len);
! 3531:
! 3532: /* BOP(7) EOP(6) LOCU(5) BYCU(4) LOLU(2) PERR(1) */
! 3533: /* only one partision is supported, BOT/EOT equal BOP/EOP */
! 3534: if (lbpos == 0ULL) {
! 3535: BSET8(&data[0], 7); /* BOP=1 */
! 3536: }
! 3537: if (spec->eom) {
! 3538: BSET8(&data[0], 6); /* EOP=1 */
! 3539: }
! 3540: /* logical object count unknown */
! 3541: BSET8(&data[0], 5); /* LOCU=1 */
! 3542: /* byte count unknown */
! 3543: BSET8(&data[0], 4); /* BYCU=1 */
! 3544: /* logical object location unknown */
! 3545: //BSET8(&data[0], 2); /* LOLU=1 */
! 3546: if (lbpos > 0xffffffffULL) {
! 3547: BSET8(&data[0], 0); /* PERR=1 */
! 3548: }
! 3549:
! 3550: /* PARTITION NUMBER */
! 3551: data[1] = 0;
! 3552: /* FIRST LOGICAL OBJECT LOCATION */
! 3553: DSET32(&data[4], (uint32_t)lbpos);
! 3554: /* LAST LOGICAL OBJECT LOCATION */
! 3555: DSET32(&data[8], 0);
! 3556: /* NUMBER OF LOGICAL OBJECTS IN OBJECT BUFFER */
! 3557: DSET24(&data[13], 0);
! 3558: /* NUMBER OF BYTES IN OBJECT BUFFER */
! 3559: DSET32(&data[16], 0);
! 3560: break;
! 3561:
! 3562: case 0x06:
! 3563: /* LONG FORM */
! 3564: data_len = 32;
! 3565: memset(&data[0], 0, data_len);
! 3566:
! 3567: /* BOP(7) EOP(6) MPU(3) LONU(2) */
! 3568: /* only one partision is supported, BOT/EOT equal BOP/EOP */
! 3569: if (lbpos == 0ULL) {
! 3570: BSET8(&data[0], 7); /* BOP=1 */
! 3571: }
! 3572: if (spec->eom) {
! 3573: BSET8(&data[0], 6); /* EOP=1 */
! 3574: }
! 3575:
! 3576: /* mark position unknown */
! 3577: BSET8(&data[0], 3); /* MPU=1 */
! 3578: /* logical object number unknown */
! 3579: //BSET8(&data[0], 2); /* LONU=1 */
! 3580:
! 3581: /* PARTITION NUMBER */
! 3582: DSET32(&data[4], 0);
! 3583: /* LOGICAL OBJECT NUMBER */
! 3584: DSET64(&data[8], lbpos);
! 3585: /* LOGICAL FILE IDENTIFIER */
! 3586: DSET64(&data[16], 0ULL);
! 3587: /* LOGICAL SET IDENTIFIER */
! 3588: DSET64(&data[24], 0ULL);
! 3589: break;
! 3590:
! 3591: default:
! 3592: /* INVALID FIELD IN CDB */
! 3593: data_len
! 3594: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3595: ISTGT_SCSI_SENSE_ILLEGAL_REQUEST,
! 3596: 0x24, 0x00);
! 3597: lu_cmd->sense_data_len = data_len;
! 3598: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3599: return -1;
! 3600: }
! 3601:
! 3602: lu_cmd->data_len = data_len;
! 3603: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3604: return 0;
! 3605: }
! 3606:
! 3607: static int
! 3608: istgt_lu_tape_build_sense_data(ISTGT_LU_TAPE *spec, uint8_t *data, int sk, int asc, int ascq)
! 3609: {
! 3610: uint8_t *cp;
! 3611: int hlen = 0, len = 0, plen;
! 3612: int total;
! 3613: int data_len;
! 3614:
! 3615: data_len = istgt_lu_scsi_build_sense_data(data, sk, asc, ascq);
! 3616: hlen = 2;
! 3617: if (data_len < (hlen + 18)) {
! 3618: return data_len;
! 3619: }
! 3620:
! 3621: cp = &data[hlen + len];
! 3622: len = 8;
! 3623:
! 3624: /* FILEMARK(7) EOM(6) ILI(5) SENSE KEY(3-0) */
! 3625: if (spec != NULL && spec->eof) {
! 3626: BSET8(&cp[2], 7); /* FILEMARK=1 */
! 3627: }
! 3628: if (spec != NULL && spec->eom) {
! 3629: BSET8(&cp[2], 6); /* EOM=1 */
! 3630: }
! 3631:
! 3632: /* Additional sense bytes */
! 3633:
! 3634: /* for DLT8000 */
! 3635: /* Internal Status Code */
! 3636: cp[18] = 0;
! 3637: //cp[18] = 0x86; /* Directory Bad */
! 3638: /* Tape Motion Hours */
! 3639: DSET16(&cp[19], 0);
! 3640: /* Power On Hours */
! 3641: DSET32(&cp[21], 0);
! 3642: /* Tape Remaining */
! 3643: DSET32(&cp[25], 0);
! 3644: //DSET32(&cp[25], (uint32_t) (spec->size / spec->ctlblock->blocklen));
! 3645: /* Reserved */
! 3646: cp[29] = 0;
! 3647: plen = 30 - len;
! 3648:
! 3649: /* ADDITIONAL SENSE LENGTH */
! 3650: cp[7] = plen;
! 3651:
! 3652: total = hlen + len + plen;
! 3653:
! 3654: /* SenseLength */
! 3655: DSET16(&data[0], total - 2);
! 3656:
! 3657: return total;
! 3658: }
! 3659:
! 3660: static int
! 3661: istgt_lu_tape_build_sense_media(ISTGT_LU_TAPE *spec, uint8_t *data)
! 3662: {
! 3663: uint8_t *sense_data;
! 3664: int *sense_len;
! 3665: int data_len;
! 3666:
! 3667: sense_data = data;
! 3668: sense_len = &data_len;
! 3669: *sense_len = 0;
! 3670:
! 3671: if (!spec->mload && !spec->mchanged) {
! 3672: /* MEDIUM NOT PRESENT */
! 3673: BUILD_SENSE(NOT_READY, 0x3a, 0x00);
! 3674: return data_len;
! 3675: }
! 3676: if (spec->mchanged) {
! 3677: /* MEDIUM NOT PRESENT */
! 3678: BUILD_SENSE(NOT_READY, 0x3a, 0x00);
! 3679: return data_len;
! 3680: #if 0
! 3681: /* LOGICAL UNIT NOT READY, CAUSE NOT REPORTABLE */
! 3682: BUILD_SENSE(NOT_READY, 0x04, 0x00);
! 3683: return data_len;
! 3684: /* LOGICAL UNIT IS IN PROCESS OF BECOMING READY */
! 3685: BUILD_SENSE(NOT_READY, 0x04, 0x01);
! 3686: return data_len;
! 3687: #endif
! 3688: }
! 3689: return 0;
! 3690: }
! 3691:
! 3692: static int
! 3693: istgt_lu_tape_variable_lbread(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lblen)
! 3694: {
! 3695: tape_markblock_t *mbp;
! 3696: uint8_t *data;
! 3697: uint64_t mediasize;
! 3698: uint64_t tape_leader;
! 3699: uint64_t marklen, alignment, padlen;
! 3700: uint64_t lbpos, offset, prev;
! 3701: uint64_t blen;
! 3702: uint64_t total;
! 3703: uint64_t request_len;
! 3704: uint32_t u;
! 3705: int64_t rc;
! 3706:
! 3707: mediasize = spec->size;
! 3708: tape_leader = spec->ctlblock->ctlblocklen;
! 3709: marklen = spec->ctlblock->marklen;
! 3710: alignment = spec->ctlblock->alignment;
! 3711: lbpos = spec->lbpos;
! 3712: offset = spec->offset;
! 3713: mbp = (tape_markblock_t *) lu_cmd->iobuf;
! 3714: data = (uint8_t *) lu_cmd->iobuf + marklen;
! 3715: total = 0ULL;
! 3716: u = 0;
! 3717: /* header + data + EOD */
! 3718: request_len = marklen + lblen + marklen;
! 3719: spec->info = (uint32_t) lblen;
! 3720:
! 3721: #ifdef TAPE_DEBUG
! 3722: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read: %"PRIu64" (%"PRIu64")\n",
! 3723: lblen, offset);
! 3724: #endif /* TAPE_DEBUG */
! 3725:
! 3726: if (request_len > lu_cmd->iobufsize) {
! 3727: ISTGT_ERRLOG("request_len(%"PRIu64") > iobufsize(%u)\n",
! 3728: request_len, lu_cmd->iobufsize);
! 3729: return -1;
! 3730: }
! 3731:
! 3732: /* read media check */
! 3733: if (istgt_lu_tape_read_media_check(spec, conn, lu_cmd, request_len) < 0) {
! 3734: /* INFORMATION */
! 3735: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) spec->info);
! 3736: /* not I/O error */
! 3737: return 0;
! 3738: }
! 3739:
! 3740: /* position to virtual tape mark */
! 3741: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 3742: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 3743: return -1;
! 3744: }
! 3745: /* virtual tape mark */
! 3746: rc = istgt_lu_tape_read_native_mark(spec, mbp);
! 3747: if (rc < 0) {
! 3748: ISTGT_ERRLOG("lu_tape_read_native_mark() failed\n");
! 3749: return -1;
! 3750: }
! 3751: if (!istgt_lu_tape_valid_mark_magic(mbp)) {
! 3752: ISTGT_ERRLOG("bad magic offset %"PRIu64"\n", offset);
! 3753: return -1;
! 3754: }
! 3755: if (lbpos != mbp->lbpos) {
! 3756: ISTGT_ERRLOG("bad position offset %"PRIu64" lbpos %"PRIu64
! 3757: " mlbpos %"PRIu64"\n", offset, lbpos, mbp->lbpos);
! 3758: return -1;
! 3759: }
! 3760: if (memcmp(mbp->magic, MARK_EOFMAGIC, MARK_MAGICLEN) == 0) {
! 3761: #ifdef TAPE_DEBUG
! 3762: ISTGT_TRACELOG(ISTGT_TRACE_LU, "EOF found\n");
! 3763: #endif /* TAPE_DEBUG */
! 3764: /* EOF detected */
! 3765: spec->eof = 1;
! 3766: goto early_return;
! 3767: }
! 3768: if (memcmp(mbp->magic, MARK_EODMAGIC, MARK_MAGICLEN) == 0) {
! 3769: #ifdef TAPE_DEBUG
! 3770: ISTGT_TRACELOG(ISTGT_TRACE_LU, "EOD found\n");
! 3771: #endif /* TAPE_DEBUG */
! 3772: /* EOD detected */
! 3773: spec->eod = 1;
! 3774: goto early_return;
! 3775: }
! 3776: /* user data */
! 3777: rc = istgt_lu_tape_read(spec, data + total, mbp->lblen);
! 3778: if (rc < 0 || rc != mbp->lblen) {
! 3779: ISTGT_ERRLOG("lu_tape_read() failed: rc %d\n", rc);
! 3780: return -1;
! 3781: }
! 3782: #ifdef TAPE_DEBUG
! 3783: ISTGT_TRACELOG(ISTGT_TRACE_LU, "read mlbpos=%"PRIu64", lblen=%"PRIu64
! 3784: ", offset=%"PRIu64"\n", mbp->lbpos, mbp->lblen, offset);
! 3785: #endif /* TAPE_DEBUG */
! 3786: /* 1 block OK */
! 3787: spec->info -= (uint32_t) lblen;
! 3788: /* next offset to read */
! 3789: prev = offset;
! 3790: offset += marklen + mbp->lblen;
! 3791: if (offset % alignment) {
! 3792: padlen = alignment;
! 3793: padlen -= offset % alignment;
! 3794: offset += padlen;
! 3795: }
! 3796: lbpos++;
! 3797: /* update information */
! 3798: spec->lbpos = lbpos;
! 3799: spec->prev = prev;
! 3800: spec->offset = offset;
! 3801:
! 3802: if (lblen > mbp->lblen) {
! 3803: blen = mbp->lblen;
! 3804: } else {
! 3805: blen = lblen;
! 3806: }
! 3807: #ifdef TAPE_DEBUG
! 3808: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read %"PRIu64" bytes\n", blen);
! 3809: #endif /* TAPE_DEBUG */
! 3810: total += blen;
! 3811: u++;
! 3812:
! 3813: early_return:
! 3814: #ifdef TAPE_DEBUG
! 3815: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read %"PRIu64" bytes total\n", total);
! 3816: #endif /* TAPE_DEBUG */
! 3817: lu_cmd->data = data;
! 3818: lu_cmd->data_len = total;
! 3819: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3820: return 0;
! 3821: }
! 3822:
! 3823: static int
! 3824: istgt_lu_tape_fixed_lbread(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lblen, uint32_t count)
! 3825: {
! 3826: tape_markblock_t *mbp;
! 3827: uint8_t *data;
! 3828: uint64_t mediasize;
! 3829: uint64_t tape_leader;
! 3830: uint64_t marklen, alignment, padlen;
! 3831: uint64_t lbpos, offset, prev;
! 3832: uint64_t blen;
! 3833: uint64_t total;
! 3834: uint64_t request_len;
! 3835: uint64_t rest;
! 3836: uint32_t u;
! 3837: int data_len;
! 3838: int64_t rc;
! 3839:
! 3840: mediasize = spec->size;
! 3841: tape_leader = spec->ctlblock->ctlblocklen;
! 3842: marklen = spec->ctlblock->marklen;
! 3843: alignment = spec->ctlblock->alignment;
! 3844: lbpos = spec->lbpos;
! 3845: offset = spec->offset;
! 3846: mbp = (tape_markblock_t *) lu_cmd->iobuf;
! 3847: data = (uint8_t *) lu_cmd->iobuf + marklen;
! 3848: total = 0ULL;
! 3849: /* (header + data) x N + EOD */
! 3850: request_len = ((marklen + lblen) * (uint64_t) count) + marklen;
! 3851: spec->info = count;
! 3852:
! 3853: #ifdef TAPE_DEBUG
! 3854: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read: %"PRIu64" x %u (%"PRIu64")\n",
! 3855: lblen, count, offset);
! 3856: #endif /* TAPE_DEBUG */
! 3857:
! 3858: if (request_len > lu_cmd->iobufsize) {
! 3859: ISTGT_ERRLOG("request_len(%"PRIu64") > iobufsize(%u)\n",
! 3860: request_len, lu_cmd->iobufsize);
! 3861: return -1;
! 3862: }
! 3863:
! 3864: /* read media check */
! 3865: if (istgt_lu_tape_read_media_check(spec, conn, lu_cmd, request_len) < 0) {
! 3866: /* INFORMATION */
! 3867: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) spec->info);
! 3868: /* not I/O error */
! 3869: return 0;
! 3870: }
! 3871:
! 3872: /* position to virtual tape mark */
! 3873: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 3874: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 3875: return -1;
! 3876: }
! 3877:
! 3878: rest = 0ULL;
! 3879: /* read N blocks */
! 3880: for (u = 0; u < count; u++) {
! 3881: if (rest == 0) {
! 3882: /* virtual tape mark */
! 3883: rc = istgt_lu_tape_read_native_mark(spec, mbp);
! 3884: if (rc < 0) {
! 3885: ISTGT_ERRLOG("lu_tape_read_native_mark() failed\n");
! 3886: return -1;
! 3887: }
! 3888: if (!istgt_lu_tape_valid_mark_magic(mbp)) {
! 3889: ISTGT_ERRLOG("bad magic offset %"PRIu64"\n", offset);
! 3890: return -1;
! 3891: }
! 3892: if (lbpos != mbp->lbpos) {
! 3893: ISTGT_ERRLOG("bad position offset %"PRIu64" lbpos %"PRIu64
! 3894: " mlbpos %"PRIu64"\n", offset, lbpos, mbp->lbpos);
! 3895: return -1;
! 3896: }
! 3897: if (memcmp(mbp->magic, MARK_EOFMAGIC, MARK_MAGICLEN) == 0) {
! 3898: #ifdef TAPE_DEBUG
! 3899: ISTGT_TRACELOG(ISTGT_TRACE_LU, "EOF found\n");
! 3900: #endif /* TAPE_DEBUG */
! 3901: /* EOF detected */
! 3902: spec->eof = 1;
! 3903: goto early_return;
! 3904: }
! 3905: if (memcmp(mbp->magic, MARK_EODMAGIC, MARK_MAGICLEN) == 0) {
! 3906: #ifdef TAPE_DEBUG
! 3907: ISTGT_TRACELOG(ISTGT_TRACE_LU, "EOD found\n");
! 3908: #endif /* TAPE_DEBUG */
! 3909: /* EOD detected */
! 3910: spec->eod = 1;
! 3911: goto early_return;
! 3912: }
! 3913: /* user data */
! 3914: rc = istgt_lu_tape_read(spec, data + total, mbp->lblen);
! 3915: if (rc < 0 || rc != mbp->lblen) {
! 3916: ISTGT_ERRLOG("lu_tape_read() failed: rc %d\n", rc);
! 3917: return -1;
! 3918: }
! 3919: #ifdef TAPE_DEBUG
! 3920: ISTGT_TRACELOG(ISTGT_TRACE_LU, "read mlbpos=%"PRIu64", lblen=%"
! 3921: PRIu64", offset=%"PRIu64"\n",
! 3922: mbp->lbpos, mbp->lblen, offset);
! 3923: #endif /* TAPE_DEBUG */
! 3924: rest = mbp->lblen;
! 3925: }
! 3926: /* check logical block size */
! 3927: if ((rest > lblen * (count - u))
! 3928: || rest < lblen) {
! 3929: /* incorrect length */
! 3930: data_len
! 3931: = istgt_lu_tape_build_sense_data(spec, lu_cmd->sense_data,
! 3932: ISTGT_SCSI_SENSE_NO_SENSE,
! 3933: 0x00, 0x00);
! 3934: BSET8(&lu_cmd->sense_data[2+2], 5); /* ILI=1 */
! 3935: //spec->info = count - u;
! 3936: /* INFORMATION */
! 3937: DSET32(&lu_cmd->sense_data[2+3], spec->info);
! 3938: lu_cmd->sense_data_len = data_len;
! 3939: lu_cmd->data = data;
! 3940: lu_cmd->data_len = total;
! 3941: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 3942: return -1;
! 3943: } else {
! 3944: /* 1 block OK */
! 3945: spec->info--;
! 3946: rest -= lblen;
! 3947: blen = lblen;
! 3948: }
! 3949:
! 3950: /* buffer empty? */
! 3951: if (rest == 0) {
! 3952: /* next offset to read */
! 3953: prev = offset;
! 3954: offset += marklen + mbp->lblen;
! 3955: if (offset % alignment) {
! 3956: padlen = alignment;
! 3957: padlen -= offset % alignment;
! 3958: offset += padlen;
! 3959: }
! 3960: lbpos++;
! 3961: /* update information */
! 3962: spec->lbpos = lbpos;
! 3963: spec->prev = prev;
! 3964: spec->offset = offset;
! 3965: }
! 3966:
! 3967: #ifdef TAPE_DEBUG
! 3968: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read %"PRIu64" bytes\n", blen);
! 3969: #endif /* TAPE_DEBUG */
! 3970: total += blen;
! 3971: }
! 3972:
! 3973: early_return:
! 3974: #ifdef TAPE_DEBUG
! 3975: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Read %"PRIu64" bytes total\n", total);
! 3976: #endif /* TAPE_DEBUG */
! 3977: lu_cmd->data = data;
! 3978: lu_cmd->data_len = total;
! 3979: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 3980: return 0;
! 3981: }
! 3982:
! 3983: static int
! 3984: istgt_lu_tape_variable_lbwrite(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lblen)
! 3985: {
! 3986: tape_markblock_t *mbp;
! 3987: uint8_t *data;
! 3988: uint64_t mediasize;
! 3989: uint64_t tape_leader;
! 3990: uint64_t marklen, alignment, padlen;
! 3991: uint64_t lbpos, offset, prev;
! 3992: uint64_t total;
! 3993: uint64_t request_len;
! 3994: int64_t rc;
! 3995:
! 3996: mediasize = spec->size;
! 3997: tape_leader = spec->ctlblock->ctlblocklen;
! 3998: marklen = spec->ctlblock->marklen;
! 3999: alignment = spec->ctlblock->alignment;
! 4000: lbpos = spec->lbpos;
! 4001: offset = spec->offset;
! 4002: prev = spec->prev;
! 4003: mbp = (tape_markblock_t *) lu_cmd->iobuf;
! 4004: data = (uint8_t *) lu_cmd->iobuf + marklen;
! 4005: total = 0ULL;
! 4006: /* header + data + EOD */
! 4007: request_len = marklen + lblen + marklen;
! 4008: spec->info = (uint32_t) lblen;
! 4009:
! 4010: #ifdef TAPE_DEBUG
! 4011: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Write: %"PRIu64" (%"PRIu64")\n",
! 4012: lblen, offset);
! 4013: #endif /* TAPE_DEBUG */
! 4014:
! 4015: if (request_len > lu_cmd->iobufsize) {
! 4016: ISTGT_ERRLOG("request_len(%"PRIu64") > iobufsize(%u)\n",
! 4017: request_len, lu_cmd->iobufsize);
! 4018: return -1;
! 4019: }
! 4020:
! 4021: /* prepare mark */
! 4022: memset(mbp, 0, marklen);
! 4023: memcpy(mbp->magic, MARK_DATAMAGIC, MARK_MAGICLEN);
! 4024: mbp->endian = MARK_ENDIAN;
! 4025: mbp->version = MARK_VERSION;
! 4026: mbp->marklen = marklen;
! 4027: mbp->lblen = lblen;
! 4028: if (spec->compression) {
! 4029: /* not supported yet */
! 4030: mbp->compalgo = spec->compalgo;
! 4031: mbp->vtcompalgo = MARK_COMPALGO_NONE;
! 4032: mbp->vtdecomplen = 0ULL;
! 4033: } else {
! 4034: mbp->compalgo = 0ULL;
! 4035: mbp->vtcompalgo = MARK_COMPALGO_NONE;
! 4036: mbp->vtdecomplen = 0ULL;
! 4037: }
! 4038:
! 4039: mbp->lbpos = lbpos;
! 4040: mbp->offset = offset;
! 4041: mbp->prev = prev;
! 4042:
! 4043: /* DATAOUT */
! 4044: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, data,
! 4045: lu_cmd->iobufsize - marklen, lblen);
! 4046: if (rc < 0) {
! 4047: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 4048: return -1;
! 4049: }
! 4050:
! 4051: /* write media check */
! 4052: if (istgt_lu_tape_write_media_check(spec, conn, lu_cmd, request_len) < 0) {
! 4053: /* INFORMATION */
! 4054: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) spec->info);
! 4055: /* not I/O error */
! 4056: return 0;
! 4057: }
! 4058:
! 4059: /* position to virtual tape mark */
! 4060: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 4061: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 4062: return -1;
! 4063: }
! 4064: #ifdef TAPE_DEBUG
! 4065: ISTGT_TRACELOG(ISTGT_TRACE_LU, "write mlbpos=%"PRIu64", lblen=%"PRIu64
! 4066: ", offset=%"PRIu64"\n", mbp->lbpos, mbp->lblen, offset);
! 4067: #endif /* TAPE_DEBUG */
! 4068: /* virtual tape mark */
! 4069: rc = istgt_lu_tape_write_native_mark(spec, mbp);
! 4070: if (rc < 0) {
! 4071: ISTGT_ERRLOG("lu_tape_write_native_mark() failed\n");
! 4072: return -1;
! 4073: }
! 4074: /* user data */
! 4075: rc = istgt_lu_tape_write(spec, data + total, lblen);
! 4076: if (rc != lblen) {
! 4077: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 4078: return -1;
! 4079: }
! 4080: /* 1 block OK */
! 4081: spec->info -= (uint32_t) lblen;
! 4082: /* next offset to read */
! 4083: prev = offset;
! 4084: offset += marklen + mbp->lblen;
! 4085: if (offset % alignment) {
! 4086: padlen = alignment;
! 4087: padlen -= offset % alignment;
! 4088: offset += padlen;
! 4089: }
! 4090: lbpos++;
! 4091: /* update information */
! 4092: spec->lbpos = lbpos;
! 4093: spec->prev = prev;
! 4094: spec->offset = offset;
! 4095:
! 4096: mbp->lbpos = lbpos;
! 4097: mbp->offset = offset;
! 4098: mbp->prev = prev;
! 4099:
! 4100: total += lblen;
! 4101:
! 4102: #ifdef TAPE_DEBUG
! 4103: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Wrote %"PRIu64" bytes\n", total);
! 4104: #endif /* TAPE_DEBUG */
! 4105: lu_cmd->data_len = total;
! 4106: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4107: return 0;
! 4108: }
! 4109:
! 4110: static int
! 4111: istgt_lu_tape_fixed_lbwrite(ISTGT_LU_TAPE *spec, CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint64_t lblen, uint32_t count)
! 4112: {
! 4113: tape_markblock_t *mbp;
! 4114: uint8_t *data;
! 4115: uint64_t mediasize;
! 4116: uint64_t tape_leader;
! 4117: uint64_t marklen, alignment, padlen;
! 4118: uint64_t lbpos, offset, prev;
! 4119: uint64_t total;
! 4120: uint64_t request_len;
! 4121: uint32_t u;
! 4122: int64_t rc;
! 4123:
! 4124: mediasize = spec->size;
! 4125: tape_leader = spec->ctlblock->ctlblocklen;
! 4126: marklen = spec->ctlblock->marklen;
! 4127: alignment = spec->ctlblock->alignment;
! 4128: lbpos = spec->lbpos;
! 4129: offset = spec->offset;
! 4130: prev = spec->prev;
! 4131: mbp = (tape_markblock_t *) lu_cmd->iobuf;
! 4132: data = (uint8_t *) lu_cmd->iobuf + marklen;
! 4133: total = 0ULL;
! 4134: /* (header + data) x N + EOD */
! 4135: request_len = ((marklen + lblen) * (uint64_t) count) + marklen;
! 4136: spec->info = count;
! 4137:
! 4138: #ifdef TAPE_DEBUG
! 4139: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Write: %"PRIu64" (%"PRIu64")\n",
! 4140: lblen, offset);
! 4141: #endif /* TAPE_DEBUG */
! 4142:
! 4143: if (request_len > lu_cmd->iobufsize) {
! 4144: ISTGT_ERRLOG("request_len(%"PRIu64") > iobufsize(%u)\n",
! 4145: request_len, lu_cmd->iobufsize);
! 4146: return -1;
! 4147: }
! 4148:
! 4149: /* prepare mark */
! 4150: memset(mbp, 0, marklen);
! 4151: memcpy(mbp->magic, MARK_DATAMAGIC, MARK_MAGICLEN);
! 4152: mbp->endian = MARK_ENDIAN;
! 4153: mbp->version = MARK_VERSION;
! 4154: mbp->marklen = marklen;
! 4155: mbp->lblen = lblen;
! 4156: if (spec->compression) {
! 4157: /* not supported yet */
! 4158: mbp->compalgo = spec->compalgo;
! 4159: mbp->vtcompalgo = MARK_COMPALGO_NONE;
! 4160: mbp->vtdecomplen = 0ULL;
! 4161: } else {
! 4162: mbp->compalgo = 0ULL;
! 4163: mbp->vtcompalgo = MARK_COMPALGO_NONE;
! 4164: mbp->vtdecomplen = 0ULL;
! 4165: }
! 4166:
! 4167: mbp->lbpos = lbpos;
! 4168: mbp->offset = offset;
! 4169: mbp->prev = prev;
! 4170:
! 4171: /* DATAOUT */
! 4172: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, data,
! 4173: lu_cmd->iobufsize - marklen, lblen * count);
! 4174: if (rc < 0) {
! 4175: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 4176: return -1;
! 4177: }
! 4178:
! 4179: /* write media check */
! 4180: if (istgt_lu_tape_write_media_check(spec, conn, lu_cmd, request_len) < 0) {
! 4181: /* INFORMATION */
! 4182: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) spec->info);
! 4183: /* not I/O error */
! 4184: return 0;
! 4185: }
! 4186:
! 4187: /* position to virtual tape mark */
! 4188: if (istgt_lu_tape_seek(spec, (tape_leader + offset)) == -1) {
! 4189: ISTGT_ERRLOG("lu_tape_seek() failed\n");
! 4190: return -1;
! 4191: }
! 4192: /* write N blocks */
! 4193: for (u = 0; u < count; u++) {
! 4194: #ifdef TAPE_DEBUG
! 4195: ISTGT_TRACELOG(ISTGT_TRACE_LU, "write mlbpos=%"PRIu64", lblen=%"PRIu64
! 4196: ", offset=%"PRIu64"\n", mbp->lbpos, mbp->lblen, offset);
! 4197: #endif /* TAPE_DEBUG */
! 4198: /* virtual tape mark */
! 4199: rc = istgt_lu_tape_write_native_mark(spec, mbp);
! 4200: if (rc < 0) {
! 4201: ISTGT_ERRLOG("lu_tape_write_native_mark() failed\n");
! 4202: return -1;
! 4203: }
! 4204: /* user data */
! 4205: rc = istgt_lu_tape_write(spec, data + total, lblen);
! 4206: if (rc != lblen) {
! 4207: ISTGT_ERRLOG("lu_tape_write() failed\n");
! 4208: return -1;
! 4209: }
! 4210: /* 1 block OK */
! 4211: spec->info--;
! 4212: /* next offset to read */
! 4213: prev = offset;
! 4214: offset += marklen + mbp->lblen;
! 4215: if (offset % alignment) {
! 4216: padlen = alignment;
! 4217: padlen -= offset % alignment;
! 4218: offset += padlen;
! 4219: }
! 4220: lbpos++;
! 4221: /* update information */
! 4222: spec->lbpos = lbpos;
! 4223: spec->prev = prev;
! 4224: spec->offset = offset;
! 4225:
! 4226: mbp->lbpos = lbpos;
! 4227: mbp->offset = offset;
! 4228: mbp->prev = prev;
! 4229:
! 4230: total += lblen;
! 4231: }
! 4232:
! 4233: #ifdef TAPE_DEBUG
! 4234: ISTGT_TRACELOG(ISTGT_TRACE_LU, "Wrote %"PRIu64" bytes\n", total);
! 4235: #endif /* TAPE_DEBUG */
! 4236: lu_cmd->data_len = total;
! 4237: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4238: return 0;
! 4239: }
! 4240:
! 4241: int
! 4242: istgt_lu_tape_reset(ISTGT_LU_Ptr lu, int lun)
! 4243: {
! 4244: ISTGT_LU_TAPE *spec;
! 4245: int flags;
! 4246: int rc;
! 4247:
! 4248: if (lu == NULL) {
! 4249: return -1;
! 4250: }
! 4251: if (lun >= lu->maxlun) {
! 4252: return -1;
! 4253: }
! 4254: if (lu->lun[lun].type == ISTGT_LU_LUN_TYPE_NONE) {
! 4255: return -1;
! 4256: }
! 4257: if (lu->lun[lun].type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
! 4258: return -1;
! 4259: }
! 4260: spec = (ISTGT_LU_TAPE *) lu->lun[lun].spec;
! 4261:
! 4262: if (spec->lock) {
! 4263: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "unlock by reset\n");
! 4264: spec->lock = 0;
! 4265: }
! 4266:
! 4267: /* re-open file */
! 4268: if (!spec->lu->readonly
! 4269: && !(spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY)) {
! 4270: rc = istgt_lu_tape_sync(spec, 0, spec->size);
! 4271: if (rc < 0) {
! 4272: ISTGT_ERRLOG("LU%d: LUN%d: lu_tape_sync() failed\n",
! 4273: lu->num, lun);
! 4274: /* ignore error */
! 4275: }
! 4276: }
! 4277: rc = istgt_lu_tape_close(spec);
! 4278: if (rc < 0) {
! 4279: ISTGT_ERRLOG("LU%d: LUN%d: lu_tape_close() failed\n",
! 4280: lu->num, lun);
! 4281: /* ignore error */
! 4282: }
! 4283: flags = (lu->readonly || (spec->mflags & ISTGT_LU_FLAG_MEDIA_READONLY))
! 4284: ? O_RDONLY : O_RDWR;
! 4285: rc = istgt_lu_tape_open(spec, flags, 0666);
! 4286: if (rc < 0) {
! 4287: ISTGT_ERRLOG("LU%d: LUN%d: lu_tape_open() failed\n",
! 4288: lu->num, lun);
! 4289: return -1;
! 4290: }
! 4291:
! 4292: return 0;
! 4293: }
! 4294:
! 4295: int
! 4296: istgt_lu_tape_execute(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 4297: {
! 4298: ISTGT_LU_Ptr lu;
! 4299: ISTGT_LU_TAPE *spec;
! 4300: uint8_t *data;
! 4301: uint8_t *cdb;
! 4302: uint64_t fmt_lun;
! 4303: uint64_t lun;
! 4304: uint64_t method;
! 4305: uint32_t allocation_len;
! 4306: int data_len;
! 4307: int data_alloc_len;
! 4308: uint32_t transfer_len;
! 4309: uint8_t *sense_data;
! 4310: int *sense_len;
! 4311: int rc;
! 4312:
! 4313: if (lu_cmd == NULL)
! 4314: return -1;
! 4315: lu = lu_cmd->lu;
! 4316: if (lu == NULL) {
! 4317: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4318: return -1;
! 4319: }
! 4320: spec = NULL;
! 4321: cdb = lu_cmd->cdb;
! 4322: data = lu_cmd->data;
! 4323: data_alloc_len = lu_cmd->alloc_len;
! 4324: sense_data = lu_cmd->sense_data;
! 4325: sense_len = &lu_cmd->sense_data_len;
! 4326: *sense_len = 0;
! 4327:
! 4328: fmt_lun = lu_cmd->lun;
! 4329: method = (fmt_lun >> 62) & 0x03U;
! 4330: fmt_lun = fmt_lun >> 48;
! 4331: if (method == 0x00U) {
! 4332: lun = fmt_lun & 0x00ffU;
! 4333: } else if (method == 0x01U) {
! 4334: lun = fmt_lun & 0x3fffU;
! 4335: } else {
! 4336: lun = 0xffffU;
! 4337: }
! 4338: if (lun >= lu->maxlun) {
! 4339: #ifdef ISTGT_TRACE_TAPE
! 4340: ISTGT_ERRLOG("LU%d: LUN%4.4"PRIx64" invalid\n",
! 4341: lu->num, lun);
! 4342: #endif /* ISTGT_TRACE_TAPE */
! 4343: if (cdb[0] == SPC_INQUIRY) {
! 4344: allocation_len = DGET16(&cdb[3]);
! 4345: if (allocation_len > data_alloc_len) {
! 4346: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4347: data_alloc_len);
! 4348: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4349: return -1;
! 4350: }
! 4351: memset(data, 0, allocation_len);
! 4352: /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */
! 4353: BDSET8W(&data[0], 0x03, 7, 3);
! 4354: BDADD8W(&data[0], 0x1f, 4, 5);
! 4355: data_len = 96;
! 4356: memset(&data[1], 0, data_len - 1);
! 4357: /* ADDITIONAL LENGTH */
! 4358: data[4] = data_len - 5;
! 4359: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4360: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4361: return 0;
! 4362: } else {
! 4363: /* LOGICAL UNIT NOT SUPPORTED */
! 4364: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
! 4365: lu_cmd->data_len = 0;
! 4366: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4367: return 0;
! 4368: }
! 4369: }
! 4370: spec = (ISTGT_LU_TAPE *) lu->lun[lun].spec;
! 4371: if (spec == NULL) {
! 4372: /* LOGICAL UNIT NOT SUPPORTED */
! 4373: BUILD_SENSE(ILLEGAL_REQUEST, 0x25, 0x00);
! 4374: lu_cmd->data_len = 0;
! 4375: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4376: return 0;
! 4377: }
! 4378:
! 4379: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "SCSI OP=0x%x, LUN=0x%16.16"PRIx64"\n",
! 4380: cdb[0], lu_cmd->lun);
! 4381: #ifdef ISTGT_TRACE_TAPE
! 4382: if (cdb[0] != SPC_TEST_UNIT_READY) {
! 4383: istgt_scsi_dump_cdb(cdb);
! 4384: }
! 4385: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "mload=%d, mchanged=%d, mwait=%d\n", spec->mload, spec->mchanged, spec->mwait);
! 4386: #endif /* ISTGT_TRACE_TAPE */
! 4387:
! 4388: if (cdb[0] == SSC_WRITE_6 || cdb[0] == SSC_WRITE_FILEMARKS_6) {
! 4389: /* write operation (no sync) */
! 4390: } else {
! 4391: /* non write operation */
! 4392: if (spec->need_savectl || spec->need_writeeod) {
! 4393: /* flush pending data */
! 4394: if (istgt_lu_tape_write_pending_data(spec, conn, lu_cmd) < 0) {
! 4395: ISTGT_ERRLOG("lu_tape_write_pending_data() failed\n");
! 4396: lu_cmd->data_len = 0;
! 4397: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4398: return 0;
! 4399: }
! 4400: }
! 4401: }
! 4402:
! 4403: switch (cdb[0]) {
! 4404: case SPC_INQUIRY:
! 4405: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "INQUIRY\n");
! 4406: if (lu_cmd->R_bit == 0) {
! 4407: ISTGT_ERRLOG("R_bit == 0\n");
! 4408: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4409: return -1;
! 4410: }
! 4411: allocation_len = DGET16(&cdb[3]);
! 4412: if (allocation_len > data_alloc_len) {
! 4413: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4414: data_alloc_len);
! 4415: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4416: return -1;
! 4417: }
! 4418: memset(data, 0, allocation_len);
! 4419: data_len = istgt_lu_tape_scsi_inquiry(spec, conn, cdb,
! 4420: data, data_alloc_len);
! 4421: if (data_len < 0) {
! 4422: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4423: break;
! 4424: }
! 4425: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "INQUIRY", data, data_len);
! 4426: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4427: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4428: break;
! 4429:
! 4430: case SPC_REPORT_LUNS:
! 4431: {
! 4432: int sel;
! 4433:
! 4434: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REPORT LUNS\n");
! 4435: if (lu_cmd->R_bit == 0) {
! 4436: ISTGT_ERRLOG("R_bit == 0\n");
! 4437: return -1;
! 4438: }
! 4439:
! 4440: sel = cdb[2];
! 4441: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "sel=%x\n", sel);
! 4442:
! 4443: allocation_len = DGET32(&cdb[6]);
! 4444: if (allocation_len > data_alloc_len) {
! 4445: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4446: data_alloc_len);
! 4447: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4448: return -1;
! 4449: }
! 4450: if (allocation_len < 16) {
! 4451: /* INVALID FIELD IN CDB */
! 4452: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 4453: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4454: break;
! 4455: }
! 4456: memset(data, 0, allocation_len);
! 4457: data_len = istgt_lu_tape_scsi_report_luns(lu, conn, cdb, sel,
! 4458: data, data_alloc_len);
! 4459: if (data_len < 0) {
! 4460: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4461: break;
! 4462: }
! 4463: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "REPORT LUNS", data, data_len);
! 4464: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4465: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4466: }
! 4467: break;
! 4468:
! 4469: case SPC_TEST_UNIT_READY:
! 4470: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "TEST_UNIT_READY\n");
! 4471: {
! 4472: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4473:
! 4474: /* media state change? */
! 4475: if (spec->mchanged) {
! 4476: /* wait OS polling */
! 4477: if (spec->mwait > 0) {
! 4478: spec->mwait--;
! 4479: } else {
! 4480: /* load new media */
! 4481: spec->mchanged = 0;
! 4482: spec->mload = 1;
! 4483: }
! 4484: }
! 4485:
! 4486: if (data_len != 0) {
! 4487: *sense_len = data_len;
! 4488: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4489: break;
! 4490: }
! 4491:
! 4492: /* OK media present */
! 4493: lu_cmd->data_len = 0;
! 4494: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4495: break;
! 4496: }
! 4497:
! 4498: case SSC_LOAD_UNLOAD:
! 4499: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LOAD_UNLOAD\n");
! 4500: {
! 4501: int hold, eot, reten, load;
! 4502:
! 4503: hold = BGET8(&cdb[4], 3);
! 4504: eot = BGET8(&cdb[4], 2);
! 4505: reten = BGET8(&cdb[4], 1);
! 4506: load = BGET8(&cdb[4], 0);
! 4507:
! 4508: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4509: if (data_len != 0) {
! 4510: *sense_len = data_len;
! 4511: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4512: break;
! 4513: }
! 4514:
! 4515: if (load) {
! 4516: if (!spec->mload) {
! 4517: if (istgt_lu_tape_load_media(spec) < 0) {
! 4518: ISTGT_ERRLOG("lu_tape_load_media() failed\n");
! 4519: /* INTERNAL TARGET FAILURE */
! 4520: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
! 4521: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4522: break;
! 4523: }
! 4524: /* OK load */
! 4525: }
! 4526: if (hold) {
! 4527: /* loding tape to unit */
! 4528: } else {
! 4529: /* loding tape to unit and potision to zero */
! 4530: istgt_lu_tape_rewind(spec);
! 4531: }
! 4532: } else {
! 4533: if (hold) {
! 4534: /* if media in unit, position by eot,reten */
! 4535: } else {
! 4536: /* unload tape from unit */
! 4537: if (!spec->lock) {
! 4538: if (!spec->mload) {
! 4539: lu_cmd->data_len = 0;
! 4540: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4541: break;
! 4542: }
! 4543: if (istgt_lu_tape_unload_media(spec) < 0) {
! 4544: ISTGT_ERRLOG("lu_tape_unload_media() failed\n");
! 4545: /* INTERNAL TARGET FAILURE */
! 4546: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
! 4547: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4548: break;
! 4549: }
! 4550: /* OK unload */
! 4551: } else {
! 4552: /* MEDIUM REMOVAL PREVENTED */
! 4553: BUILD_SENSE(ILLEGAL_REQUEST, 0x53, 0x02);
! 4554: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4555: break;
! 4556: }
! 4557: }
! 4558: }
! 4559:
! 4560: lu_cmd->data_len = 0;
! 4561: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4562: break;
! 4563: }
! 4564:
! 4565: case SPC_PREVENT_ALLOW_MEDIUM_REMOVAL:
! 4566: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "PREVENT_ALLOW_MEDIUM_REMOVAL\n");
! 4567: {
! 4568: int persistent, prevent;
! 4569:
! 4570: persistent = BGET8(&cdb[4], 1);
! 4571: prevent = BGET8(&cdb[4], 0);
! 4572:
! 4573: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4574: if (data_len != 0) {
! 4575: *sense_len = data_len;
! 4576: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4577: break;
! 4578: }
! 4579:
! 4580: if (persistent) {
! 4581: if (prevent) {
! 4582: /* Persistent Prevent */
! 4583: } else {
! 4584: /* Persistent Allow */
! 4585: }
! 4586: } else {
! 4587: if (prevent) {
! 4588: /* Locked */
! 4589: spec->lock = 1;
! 4590: } else {
! 4591: /* Unlocked */
! 4592: spec->lock = 0;
! 4593: }
! 4594: }
! 4595:
! 4596: lu_cmd->data_len = 0;
! 4597: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4598: break;
! 4599: }
! 4600:
! 4601: case SSC_READ_BLOCK_LIMITS:
! 4602: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ_BLOCK_LIMITS\n");
! 4603: {
! 4604: if (lu_cmd->R_bit == 0) {
! 4605: ISTGT_ERRLOG("R_bit == 0\n");
! 4606: return -1;
! 4607: }
! 4608:
! 4609: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4610: if (data_len != 0) {
! 4611: *sense_len = data_len;
! 4612: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4613: break;
! 4614: }
! 4615:
! 4616: data_len = 6;
! 4617: /* GRANULARITY */
! 4618: data[0] = 0;
! 4619: /* MAXIMUM BLOCK LENGTH LIMIT */
! 4620: DSET24(&data[1], TAPE_MAXIMUM_BLOCK_LENGTH);
! 4621: /* MINIMUM BLOCK LENGTH LIMIT */
! 4622: DSET16(&data[4], TAPE_MINIMUM_BLOCK_LENGTH);
! 4623:
! 4624: lu_cmd->data_len = data_len;
! 4625: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4626: break;
! 4627: }
! 4628:
! 4629: case SPC_MODE_SELECT_6:
! 4630: {
! 4631: int pf, sp, pllen;
! 4632: int mdlen, mt, dsp, bdlen;
! 4633:
! 4634: pf = BGET8(&cdb[1], 4);
! 4635: sp = BGET8(&cdb[1], 0);
! 4636: pllen = cdb[4]; /* Parameter List Length */
! 4637:
! 4638: /* Data-Out */
! 4639: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
! 4640: lu_cmd->iobufsize, pllen);
! 4641: if (rc < 0) {
! 4642: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 4643: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4644: break;
! 4645: }
! 4646: #if 0
! 4647: istgt_dump("MODE SELECT(6)", lu_cmd->iobuf, pllen);
! 4648: #endif
! 4649: data = lu_cmd->iobuf;
! 4650: mdlen = data[0]; /* Mode Data Length */
! 4651: mt = data[1]; /* Medium Type */
! 4652: dsp = data[2]; /* Device-Specific Parameter */
! 4653: bdlen = data[3]; /* Block Descriptor Length */
! 4654:
! 4655: if (bdlen > 0) {
! 4656: /* Short LBA mode parameter block descriptor */
! 4657: /* data[4]-data[7] Number of Blocks */
! 4658: /* data[8]-data[11] Block Length */
! 4659: spec->lblen = (uint64_t) (DGET32(&data[8]) & 0x00ffffffU);
! 4660: #ifdef TAPE_DEBUG
! 4661: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set to lblen=%"PRIu64"\n", spec->lblen);
! 4662: #endif /* TAPE_DEBUG */
! 4663: }
! 4664:
! 4665: /* page data */
! 4666: data_len = istgt_lu_tape_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[4 + bdlen], pllen - (4 + bdlen));
! 4667: if (data_len != 0) {
! 4668: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4669: break;
! 4670: }
! 4671: lu_cmd->data_len = pllen;
! 4672: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4673: break;
! 4674: }
! 4675:
! 4676: case SPC_MODE_SELECT_10:
! 4677: {
! 4678: int pf, sp, pllen;
! 4679: int mdlen, mt, dsp, bdlen;
! 4680: int llba;
! 4681:
! 4682: pf = BGET8(&cdb[1], 4);
! 4683: sp = BGET8(&cdb[1], 0);
! 4684: pllen = DGET16(&cdb[7]); /* Parameter List Length */
! 4685:
! 4686: /* Data-Out */
! 4687: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
! 4688: lu_cmd->iobufsize, pllen);
! 4689: if (rc < 0) {
! 4690: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 4691: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4692: break;
! 4693: }
! 4694: #if 0
! 4695: istgt_dump("MODE SELECT(10)", lu_cmd->iobuf, pllen);
! 4696: #endif
! 4697: data = lu_cmd->iobuf;
! 4698: mdlen = DGET16(&data[0]); /* Mode Data Length */
! 4699: mt = data[2]; /* Medium Type */
! 4700: dsp = data[3]; /* Device-Specific Parameter */
! 4701: llba = BGET8(&data[4], 0); /* Long LBA */
! 4702: bdlen = DGET16(&data[6]); /* Block Descriptor Length */
! 4703:
! 4704: if (llba) {
! 4705: if (bdlen > 0) {
! 4706: /* Long LBA mode parameter block descriptor */
! 4707: /* data[8]-data[15] Number of Blocks */
! 4708: /* data[16]-data[19] Reserved */
! 4709: /* data[20]-data[23] Block Length */
! 4710: spec->lblen = (uint64_t) DGET32(&data[20]);
! 4711: #ifdef TAPE_DEBUG
! 4712: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set to lblen=%"PRIu64"\n", spec->lblen);
! 4713: #endif /* TAPE_DEBUG */
! 4714: }
! 4715: } else {
! 4716: if (bdlen > 0) {
! 4717: /* Short LBA mode parameter block descriptor */
! 4718: /* data[8]-data[11] Number of Blocks */
! 4719: /* data[12]-data[15] Block Length */
! 4720: spec->lblen = (uint64_t) (DGET32(&data[12]) & 0x00ffffffU);
! 4721: #ifdef TAPE_DEBUG
! 4722: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "set to lblen=%"PRIu64"\n", spec->lblen);
! 4723: #endif /* TAPE_DEBUG */
! 4724: }
! 4725: }
! 4726:
! 4727: /* page data */
! 4728: data_len = istgt_lu_tape_scsi_mode_select_page(spec, conn, cdb, pf, sp, &data[8 + bdlen], pllen - (8 + bdlen));
! 4729: if (data_len != 0) {
! 4730: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4731: break;
! 4732: }
! 4733: lu_cmd->data_len = pllen;
! 4734: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4735: break;
! 4736: }
! 4737:
! 4738: case SPC_MODE_SENSE_6:
! 4739: {
! 4740: int dbd, pc, page, subpage;
! 4741:
! 4742: if (lu_cmd->R_bit == 0) {
! 4743: ISTGT_ERRLOG("R_bit == 0\n");
! 4744: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4745: return -1;
! 4746: }
! 4747:
! 4748: dbd = BGET8(&cdb[1], 3);
! 4749: pc = BGET8W(&cdb[2], 7, 2);
! 4750: page = BGET8W(&cdb[2], 5, 6);
! 4751: subpage = cdb[3];
! 4752:
! 4753: allocation_len = cdb[4];
! 4754: if (allocation_len > data_alloc_len) {
! 4755: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4756: data_alloc_len);
! 4757: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4758: return -1;
! 4759: }
! 4760: memset(data, 0, allocation_len);
! 4761:
! 4762: data_len = istgt_lu_tape_scsi_mode_sense6(spec, conn, cdb, dbd, pc, page, subpage, data, data_alloc_len);
! 4763: if (data_len < 0) {
! 4764: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4765: break;
! 4766: }
! 4767: #if 0
! 4768: istgt_dump("MODE SENSE(6)", data, data_len);
! 4769: #endif
! 4770: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4771: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4772: break;
! 4773: }
! 4774:
! 4775: case SPC_MODE_SENSE_10:
! 4776: {
! 4777: int dbd, pc, page, subpage;
! 4778: int llbaa;
! 4779:
! 4780: if (lu_cmd->R_bit == 0) {
! 4781: ISTGT_ERRLOG("R_bit == 0\n");
! 4782: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4783: return -1;
! 4784: }
! 4785:
! 4786: llbaa = BGET8(&cdb[1], 4);
! 4787: dbd = BGET8(&cdb[1], 3);
! 4788: pc = BGET8W(&cdb[2], 7, 2);
! 4789: page = BGET8W(&cdb[2], 5, 6);
! 4790: subpage = cdb[3];
! 4791:
! 4792: allocation_len = DGET16(&cdb[7]);
! 4793: if (allocation_len > data_alloc_len) {
! 4794: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4795: data_alloc_len);
! 4796: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4797: return -1;
! 4798: }
! 4799: memset(data, 0, allocation_len);
! 4800:
! 4801: data_len = istgt_lu_tape_scsi_mode_sense10(spec, conn, cdb, llbaa, dbd, pc, page, subpage, data, data_alloc_len);
! 4802: if (data_len < 0) {
! 4803: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4804: break;
! 4805: }
! 4806: #if 0
! 4807: istgt_dump("MODE SENSE(10)", data, data_len);
! 4808: #endif
! 4809: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4810: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4811: break;
! 4812: }
! 4813:
! 4814: case SPC_LOG_SELECT:
! 4815: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LOG_SELECT\n");
! 4816: /* INVALID COMMAND OPERATION CODE */
! 4817: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
! 4818: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4819: break;
! 4820:
! 4821: case SPC_LOG_SENSE:
! 4822: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LOG_SENSE\n");
! 4823: #if 0
! 4824: /* INVALID FIELD IN CDB */
! 4825: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 4826: /* INVALID FIELD IN PARAMETER LIST */
! 4827: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x00);
! 4828: /* PARAMETER NOT SUPPORTED */
! 4829: BUILD_SENSE(ILLEGAL_REQUEST, 0x26, 0x01);
! 4830: #endif
! 4831: /* INVALID COMMAND OPERATION CODE */
! 4832: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
! 4833: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4834: break;
! 4835:
! 4836: case SPC_REQUEST_SENSE:
! 4837: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REQUEST_SENSE\n");
! 4838: {
! 4839: int desc;
! 4840: int sk, asc, ascq;
! 4841:
! 4842: if (lu_cmd->R_bit == 0) {
! 4843: ISTGT_ERRLOG("R_bit == 0\n");
! 4844: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4845: return -1;
! 4846: }
! 4847:
! 4848: desc = BGET8(&cdb[1], 0);
! 4849: if (desc != 0) {
! 4850: /* INVALID FIELD IN CDB */
! 4851: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 4852: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4853: break;
! 4854: }
! 4855:
! 4856: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4857:
! 4858: /* media state change? */
! 4859: if (spec->mchanged) {
! 4860: /* wait OS polling */
! 4861: if (spec->mwait > 0) {
! 4862: spec->mwait--;
! 4863: } else {
! 4864: /* load new media */
! 4865: spec->mchanged = 0;
! 4866: spec->mload = 1;
! 4867: }
! 4868: }
! 4869:
! 4870: if (data_len != 0) {
! 4871: *sense_len = data_len;
! 4872: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4873: break;
! 4874: }
! 4875:
! 4876: allocation_len = cdb[4];
! 4877: if (allocation_len > data_alloc_len) {
! 4878: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 4879: data_alloc_len);
! 4880: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4881: return -1;
! 4882: }
! 4883: memset(data, 0, allocation_len);
! 4884:
! 4885: if (!spec->sense) {
! 4886: /* NO ADDITIONAL SENSE INFORMATION */
! 4887: sk = ISTGT_SCSI_SENSE_NO_SENSE;
! 4888: asc = 0x00;
! 4889: ascq = 0x00;
! 4890: } else {
! 4891: sk = (spec->sense >> 16) & 0xffU;
! 4892: asc = (spec->sense >> 8) & 0xffU;
! 4893: ascq = spec->sense & 0xffU;
! 4894: }
! 4895: data_len = istgt_lu_tape_build_sense_data(spec, sense_data,
! 4896: sk, asc, ascq);
! 4897: if (data_len < 0 || data_len < 2) {
! 4898: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4899: break;
! 4900: }
! 4901: /* omit SenseLength */
! 4902: data_len -= 2;
! 4903: memcpy(data, sense_data + 2, data_len);
! 4904:
! 4905: lu_cmd->data_len = DMIN32(data_len, lu_cmd->transfer_len);
! 4906: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4907: break;
! 4908: }
! 4909:
! 4910: case SSC_ERASE_6:
! 4911: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "ERASE_6\n");
! 4912: {
! 4913: int xlong;
! 4914:
! 4915: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4916: if (data_len != 0) {
! 4917: *sense_len = data_len;
! 4918: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4919: break;
! 4920: }
! 4921:
! 4922: xlong = BGET8(&cdb[1], 0);
! 4923:
! 4924: if (!xlong) {
! 4925: /* short no operation */
! 4926: lu_cmd->data_len = 0;
! 4927: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4928: break;
! 4929: }
! 4930: data_len = istgt_lu_tape_scsi_erase(spec, conn, lu_cmd, data);
! 4931: if (data_len != 0) {
! 4932: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4933: break;
! 4934: }
! 4935: lu_cmd->data_len = 0;
! 4936: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4937: break;
! 4938: }
! 4939:
! 4940: case SSC_REWIND:
! 4941: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "REWIND\n");
! 4942: {
! 4943: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4944: if (data_len != 0) {
! 4945: *sense_len = data_len;
! 4946: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4947: break;
! 4948: }
! 4949:
! 4950: /* position to BOT */
! 4951: istgt_lu_tape_rewind(spec);
! 4952: lu_cmd->data_len = 0;
! 4953: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4954: break;
! 4955: }
! 4956:
! 4957: case SSC_SPACE_6:
! 4958: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "SPACE_6\n");
! 4959: {
! 4960: int code;
! 4961: int count;
! 4962:
! 4963: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4964: if (data_len != 0) {
! 4965: *sense_len = data_len;
! 4966: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4967: break;
! 4968: }
! 4969:
! 4970: code = BGET8W(&cdb[1], 3, 4);
! 4971: count = istgt_convert_signed_24bits(DGET24(&cdb[2]));
! 4972:
! 4973: #ifdef TAPE_DEBUG
! 4974: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "SPACE %d (code = %d)\n", count, code);
! 4975: #endif /* TAPE_DEBUG */
! 4976: data_len = istgt_lu_tape_scsi_space(spec, conn, lu_cmd, code,
! 4977: count, data);
! 4978: if (data_len != 0) {
! 4979: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4980: break;
! 4981: }
! 4982: lu_cmd->data_len = 0;
! 4983: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 4984: break;
! 4985: }
! 4986:
! 4987: case SSC_WRITE_FILEMARKS_6:
! 4988: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "WRITE_FILEMARKS_6\n");
! 4989: {
! 4990: uint64_t request_len;
! 4991: uint64_t marklen;
! 4992: int wsmk;
! 4993: int count;
! 4994:
! 4995: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 4996: if (data_len != 0) {
! 4997: *sense_len = data_len;
! 4998: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 4999: break;
! 5000: }
! 5001:
! 5002: wsmk = BGET8(&cdb[1], 1);
! 5003: count = (int) DGET24(&cdb[2]);
! 5004:
! 5005: #ifdef TAPE_DEBUG
! 5006: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "WRITE_FILEMARK %d\n", count);
! 5007: #endif /* TAPE_DEBUG */
! 5008: if (wsmk) {
! 5009: /* INVALID FIELD IN CDB */
! 5010: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 5011: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5012: break;
! 5013: }
! 5014: if (count == 0) {
! 5015: /* no mark but flush buffer */
! 5016: if (spec->need_savectl || spec->need_writeeod) {
! 5017: /* flush pending data */
! 5018: rc = istgt_lu_tape_write_pending_data(spec, conn, lu_cmd);
! 5019: if (rc < 0) {
! 5020: ISTGT_ERRLOG("lu_tape_write_pending_data() failed\n");
! 5021: lu_cmd->data_len = 0;
! 5022: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5023: return 0;
! 5024: }
! 5025: }
! 5026: lu_cmd->data_len = 0;
! 5027: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5028: break;
! 5029: }
! 5030: if (spec->index + 1 + count > MAX_FILEMARKS - 1) {
! 5031: /* INVALID FIELD IN CDB */
! 5032: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 5033: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5034: break;
! 5035: }
! 5036:
! 5037: istgt_lu_tape_prepare_offset(spec, conn, lu_cmd);
! 5038: if (spec->eom) {
! 5039: /* END-OF-PARTITION/MEDIUM DETECTED */
! 5040: BUILD_SENSE(VOLUME_OVERFLOW, 0x00, 0x02);
! 5041: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5042: break;
! 5043: }
! 5044:
! 5045: /* EOF x N + EOD */
! 5046: marklen = spec->ctlblock->marklen;
! 5047: request_len = marklen * (uint64_t) count;
! 5048: request_len += marklen;
! 5049: /* write media check */
! 5050: if (istgt_lu_tape_write_media_check(spec, conn, lu_cmd,
! 5051: request_len) < 0) {
! 5052: /* sense data build by function */
! 5053: break;
! 5054: }
! 5055: /* actual wirte to media */
! 5056: if (istgt_lu_tape_write_eof(spec, count, data) < 0) {
! 5057: ISTGT_ERRLOG("lu_tape_write_eof() failed\n");
! 5058: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5059: break;
! 5060: }
! 5061: if (istgt_lu_tape_write_eod(spec, data) < 0) {
! 5062: ISTGT_ERRLOG("lu_tape_write_eod() failed\n");
! 5063: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5064: break;
! 5065: }
! 5066: spec->need_writeeod = 0;
! 5067: if (istgt_lu_tape_save_ctlblock(spec) < 0) {
! 5068: ISTGT_ERRLOG("lu_tape_save_ctlblock() failed\n");
! 5069: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5070: break;
! 5071: }
! 5072: spec->need_savectl = 0;
! 5073: /* dynamic/extend media handle here */
! 5074: /* Control + DATA(BOT/File/EOF) + EOD */
! 5075: request_len = spec->ctlblock->ctlblocklen;
! 5076: request_len += spec->offset;
! 5077: request_len += marklen;
! 5078: if (istgt_lu_tape_shrink_media(spec, conn, lu_cmd,
! 5079: request_len, data) < 0) {
! 5080: ISTGT_ERRLOG("lu_tape_shrink_media() failed\n");
! 5081: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5082: break;
! 5083: }
! 5084: /* write done */
! 5085:
! 5086: lu_cmd->data_len = 0;
! 5087: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5088: break;
! 5089: }
! 5090:
! 5091: case SSC_READ_POSITION:
! 5092: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "READ_POSITION\n");
! 5093: {
! 5094: int sa;
! 5095:
! 5096: if (lu_cmd->R_bit == 0) {
! 5097: ISTGT_ERRLOG("R_bit == 0\n");
! 5098: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5099: return -1;
! 5100: }
! 5101:
! 5102: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 5103: if (data_len != 0) {
! 5104: *sense_len = data_len;
! 5105: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5106: break;
! 5107: }
! 5108:
! 5109: sa = BGET8W(&cdb[1], 4, 5);
! 5110:
! 5111: allocation_len = DGET16(&cdb[7]);
! 5112: if (allocation_len > data_alloc_len) {
! 5113: ISTGT_ERRLOG("data_alloc_len(%d) too small\n",
! 5114: data_alloc_len);
! 5115: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5116: return -1;
! 5117: }
! 5118: memset(data, 0, allocation_len);
! 5119:
! 5120: data_len = istgt_lu_tape_scsi_read_position(spec, conn, lu_cmd,
! 5121: sa, data);
! 5122: if (data_len != 0) {
! 5123: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5124: break;
! 5125: }
! 5126: #if 0
! 5127: istgt_dump("READ_POSITION", data, lu_cmd->data_len);
! 5128: #endif
! 5129: lu_cmd->data_len = DMIN32(lu_cmd->data_len, lu_cmd->transfer_len);
! 5130: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5131: break;
! 5132: }
! 5133:
! 5134: case SSC_LOCATE_10:
! 5135: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LOCATE_10\n");
! 5136: {
! 5137: uint32_t loi;
! 5138: int bt, cp, partition;
! 5139:
! 5140: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 5141: if (data_len != 0) {
! 5142: *sense_len = data_len;
! 5143: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5144: break;
! 5145: }
! 5146:
! 5147: bt = BGET8(&cdb[1], 2);
! 5148: cp = BGET8(&cdb[1], 1);
! 5149: loi = DGET32(&cdb[3]);
! 5150: partition = cdb[8];
! 5151:
! 5152: if (cp) {
! 5153: /* INVALID FIELD IN CDB */
! 5154: BUILD_SENSE(ILLEGAL_REQUEST, 0x24, 0x00);
! 5155: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5156: break;
! 5157: }
! 5158:
! 5159: #ifdef TAPE_DEBUG
! 5160: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LOCATE %u\n", loi);
! 5161: #endif /* TAPE_DEBUG */
! 5162: data_len = istgt_lu_tape_scsi_locate(spec, conn, lu_cmd,
! 5163: loi, data);
! 5164: if (data_len != 0) {
! 5165: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5166: break;
! 5167: }
! 5168: lu_cmd->data_len = 0;
! 5169: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5170: break;
! 5171: }
! 5172:
! 5173: case SSC_READ_6:
! 5174: {
! 5175: int sili, fixed;
! 5176: uint64_t lblen;
! 5177: uint64_t request_len;
! 5178: uint64_t rest;
! 5179:
! 5180: if (lu_cmd->R_bit == 0) {
! 5181: ISTGT_ERRLOG("R_bit == 0\n");
! 5182: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5183: return -1;
! 5184: }
! 5185:
! 5186: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 5187: if (data_len != 0) {
! 5188: *sense_len = data_len;
! 5189: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5190: break;
! 5191: }
! 5192:
! 5193: sili = BGET8(&cdb[1], 1);
! 5194: fixed = BGET8(&cdb[1], 0);
! 5195: transfer_len = DGET24(&cdb[2]);
! 5196: lblen = spec->lblen;
! 5197:
! 5198: if (fixed) {
! 5199: request_len = (uint64_t) transfer_len * lblen;
! 5200: } else {
! 5201: request_len = (uint64_t) transfer_len;
! 5202: }
! 5203:
! 5204: istgt_lu_tape_prepare_offset(spec, conn, lu_cmd);
! 5205: if (spec->eom) {
! 5206: /* END-OF-PARTITION/MEDIUM DETECTED */
! 5207: BUILD_SENSE(MEDIUM_ERROR, 0x00, 0x02);
! 5208: /* INFORMATION */
! 5209: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) transfer_len);
! 5210: lu_cmd->data_len = 0;
! 5211: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5212: break;
! 5213: }
! 5214:
! 5215: /* clear EOF/EOD before reading */
! 5216: spec->eof = spec->eod = 0;
! 5217:
! 5218: if (fixed) {
! 5219: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5220: "READ_6 transfer %u x blocks %u SILI=%d\n",
! 5221: (uint32_t) lblen, (uint32_t) transfer_len,
! 5222: sili);
! 5223: rc = istgt_lu_tape_fixed_lbread(spec, conn, lu_cmd, lblen,
! 5224: (uint32_t) transfer_len);
! 5225: } else {
! 5226: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5227: "READ_6 transfer %u SILI=%d\n",
! 5228: (uint32_t) transfer_len, sili);
! 5229: rc = istgt_lu_tape_variable_lbread(spec, conn, lu_cmd,
! 5230: transfer_len);
! 5231: }
! 5232: if (rc < 0) {
! 5233: ISTGT_ERRLOG("lu_tape_lbread() failed\n");
! 5234: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5235: break;
! 5236: }
! 5237: if (lu_cmd->status != ISTGT_SCSI_STATUS_GOOD) {
! 5238: /* sense data build by function */
! 5239: break;
! 5240: }
! 5241: rest = request_len - lu_cmd->data_len;
! 5242:
! 5243: #if 0
! 5244: istgt_dump("READ", lu_cmd->iobuf, 256);
! 5245: #endif
! 5246:
! 5247: if (spec->eof) {
! 5248: /* position to EOF */
! 5249: spec->index++;
! 5250: spec->offset = spec->ctlblock->marks[spec->index].offset;
! 5251: spec->lbpos = spec->ctlblock->marks[spec->index].lbpos;
! 5252: spec->prev = spec->ctlblock->marks[spec->index].prev;
! 5253: /* position to next block of EOF */
! 5254: spec->lbpos++;
! 5255: spec->prev = spec->offset;
! 5256: spec->offset += spec->ctlblock->marklen;
! 5257: /* FILEMARK DETECTED */
! 5258: BUILD_SENSE(NO_SENSE, 0x00, 0x01);
! 5259: /* INFORMATION */
! 5260: DSET32(&lu_cmd->sense_data[2+3], spec->info);
! 5261: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5262: break;
! 5263: }
! 5264: if (spec->eod) {
! 5265: /* END-OF-DATA DETECTED */
! 5266: BUILD_SENSE(BLANK_CHECK, 0x00, 0x05);
! 5267: /* INFORMATION */
! 5268: DSET32(&lu_cmd->sense_data[2+3], spec->info);
! 5269: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5270: break;
! 5271: }
! 5272:
! 5273: if (lu_cmd->data_len < request_len) {
! 5274: #ifdef TAPE_DEBUG
! 5275: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5276: "Underflow total=%u, transfer_len=%u, lblen=%u\n",
! 5277: lu_cmd->data_len, (uint32_t) request_len,
! 5278: (uint32_t) lblen);
! 5279: #endif /* TAPE_DEBUG */
! 5280: /* over size? */
! 5281: if (rest > spec->size
! 5282: || spec->offset > spec->size - rest) {
! 5283: spec->eom = 1;
! 5284: /* END-OF-PARTITION/MEDIUM DETECTED */
! 5285: BUILD_SENSE(MEDIUM_ERROR, 0x00, 0x02);
! 5286: /* INFORMATION */
! 5287: DSET32(&lu_cmd->sense_data[2+3], spec->info);
! 5288: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5289: break;
! 5290: }
! 5291: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5292: break;
! 5293: }
! 5294:
! 5295: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5296: break;
! 5297: }
! 5298:
! 5299: case SSC_WRITE_6:
! 5300: {
! 5301: int sili, fixed;
! 5302: uint64_t lblen;
! 5303: uint64_t request_len;
! 5304: uint64_t rest;
! 5305: int index_i;
! 5306:
! 5307: if (lu_cmd->W_bit == 0) {
! 5308: ISTGT_ERRLOG("W_bit == 0\n");
! 5309: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5310: return -1;
! 5311: }
! 5312:
! 5313: sili = BGET8(&cdb[1], 1);
! 5314: fixed = BGET8(&cdb[1], 0);
! 5315: transfer_len = DGET24(&cdb[2]);
! 5316: lblen = spec->lblen;
! 5317:
! 5318: if (fixed) {
! 5319: request_len = (uint64_t) transfer_len * lblen;
! 5320: } else {
! 5321: request_len = (uint64_t) transfer_len;
! 5322: }
! 5323:
! 5324: data_len = istgt_lu_tape_build_sense_media(spec, sense_data);
! 5325: if (data_len != 0) {
! 5326: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
! 5327: lu_cmd->iobufsize, request_len);
! 5328: if (rc < 0) {
! 5329: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 5330: lu_cmd->data_len = 0;
! 5331: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5332: break;
! 5333: }
! 5334: *sense_len = data_len;
! 5335: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5336: break;
! 5337: }
! 5338:
! 5339: istgt_lu_tape_prepare_offset(spec, conn, lu_cmd);
! 5340: if (spec->eom) {
! 5341: rc = istgt_lu_tape_transfer_data(conn, lu_cmd, lu_cmd->iobuf,
! 5342: lu_cmd->iobufsize, request_len);
! 5343: if (rc < 0) {
! 5344: ISTGT_ERRLOG("lu_tape_transfer_data() failed\n");
! 5345: lu_cmd->data_len = 0;
! 5346: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5347: break;
! 5348: }
! 5349: /* END-OF-PARTITION/MEDIUM DETECTED */
! 5350: BUILD_SENSE(VOLUME_OVERFLOW, 0x00, 0x02);
! 5351: /* INFORMATION */
! 5352: DSET32(&lu_cmd->sense_data[2+3], (uint32_t) transfer_len);
! 5353: lu_cmd->data_len = 0;
! 5354: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5355: break;
! 5356: }
! 5357:
! 5358: if (fixed) {
! 5359: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5360: "WRITE_6 transfer %u x blocks %u SILI=%d\n",
! 5361: (uint32_t) lblen, (uint32_t) transfer_len,
! 5362: sili);
! 5363: rc = istgt_lu_tape_fixed_lbwrite(spec, conn, lu_cmd, lblen,
! 5364: (uint32_t) transfer_len);
! 5365: } else {
! 5366: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5367: "WRITE_6 transfer %u SILI=%d\n",
! 5368: (uint32_t) transfer_len, sili);
! 5369: rc = istgt_lu_tape_variable_lbwrite(spec, conn, lu_cmd,
! 5370: transfer_len);
! 5371: }
! 5372: if (rc < 0) {
! 5373: ISTGT_ERRLOG("lu_tape_lbwrite() failed\n");
! 5374: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5375: break;
! 5376: }
! 5377: if (lu_cmd->status != ISTGT_SCSI_STATUS_GOOD) {
! 5378: /* sense data build by function */
! 5379: break;
! 5380: }
! 5381: rest = request_len - lu_cmd->data_len;
! 5382:
! 5383: /* clean up marks after this file */
! 5384: index_i = spec->index;
! 5385: if (spec->ctlblock->marks[index_i + 1].offset != MARK_END) {
! 5386: #ifdef TAPE_DEBUG
! 5387: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5388: "save ctlblock and write EOD\n");
! 5389: #endif /* TAPE_DEBUG */
! 5390: spec->ctlblock->marks[index_i + 1].offset = MARK_END;
! 5391: spec->ctlblock->marks[index_i + 1].lbpos = MARK_END;
! 5392: spec->ctlblock->marks[index_i + 1].prev = spec->offset;
! 5393: if (istgt_lu_tape_save_ctlblock(spec) < 0) {
! 5394: ISTGT_ERRLOG("lu_tape_save_ctlblock() failed\n");
! 5395: write_failure:
! 5396: /* INTERNAL TARGET FAILURE */
! 5397: BUILD_SENSE(HARDWARE_ERROR, 0x44, 0x00);
! 5398: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5399: break;
! 5400: }
! 5401: request_len = spec->ctlblock->marklen;
! 5402: if (istgt_lu_tape_write_media_check(spec, conn, lu_cmd,
! 5403: request_len) < 0) {
! 5404: goto write_failure;
! 5405: }
! 5406: if (istgt_lu_tape_write_eod(spec, lu_cmd->data) < 0) {
! 5407: ISTGT_ERRLOG("lu_tape_write_eod() failed\n");
! 5408: goto write_failure;
! 5409: }
! 5410: } else {
! 5411: /* pending some blocks for performance */
! 5412: spec->ctlblock->marks[index_i + 1].prev = spec->offset;
! 5413: spec->need_savectl = 1;
! 5414: spec->need_writeeod = 1;
! 5415: }
! 5416:
! 5417: #if 0
! 5418: if (spec->index == 2) {
! 5419: istgt_dump("WRITE", lu_cmd->iobuf, 256);
! 5420: }
! 5421: #endif
! 5422:
! 5423: if (lu_cmd->data_len < request_len) {
! 5424: #ifdef TAPE_DEBUG
! 5425: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5426: "Underflow total=%u, transfer_len=%u, lblen=%u\n",
! 5427: lu_cmd->data_len, (uint32_t) request_len,
! 5428: (uint32_t) lblen);
! 5429: #endif /* TAPE_DEBUG */
! 5430: spec->eom = 1;
! 5431: /* WRITE ERROR */
! 5432: BUILD_SENSE(MEDIUM_ERROR, 0x0c, 0x00);
! 5433: /* INFORMATION */
! 5434: DSET32(&lu_cmd->sense_data[2+3], spec->info);
! 5435: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5436: break;
! 5437: }
! 5438:
! 5439: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5440: break;
! 5441: }
! 5442:
! 5443: /* XXX TODO: fix */
! 5444: case SPC2_RELEASE_6:
! 5445: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RELEASE_6\n");
! 5446: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5447: break;
! 5448: case SPC2_RELEASE_10:
! 5449: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RELEASE_10\n");
! 5450: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5451: break;
! 5452: case SPC2_RESERVE_6:
! 5453: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RESERVE_6\n");
! 5454: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5455: break;
! 5456: case SPC2_RESERVE_10:
! 5457: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "RESERVE_10\n");
! 5458: lu_cmd->status = ISTGT_SCSI_STATUS_GOOD;
! 5459: break;
! 5460:
! 5461: default:
! 5462: ISTGT_ERRLOG("unsupported SCSI OP=0x%x\n", cdb[0]);
! 5463: /* INVALID COMMAND OPERATION CODE */
! 5464: BUILD_SENSE(ILLEGAL_REQUEST, 0x20, 0x00);
! 5465: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
! 5466: break;
! 5467: }
! 5468:
! 5469: ISTGT_TRACELOG(ISTGT_TRACE_SCSI,
! 5470: "SCSI OP=0x%x, LUN=0x%16.16"PRIx64" status=0x%x,"
! 5471: " complete\n",
! 5472: cdb[0], lu_cmd->lun, lu_cmd->status);
! 5473: return 0;
! 5474: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_lu_tape.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