![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_lu.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src|
Return to istgt_lu.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src |
1.1 misho 1: /*
2: * Copyright (C) 2008-2011 Daisuke Aoyama <aoyama@peach.ne.jp>.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17: * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24: * SUCH DAMAGE.
25: *
26: */
27:
28: #ifdef HAVE_CONFIG_H
29: #include "config.h"
30: #endif
31:
32: #include <inttypes.h>
33: #include <stdint.h>
34:
35: #include <ctype.h>
36: #include <errno.h>
37: #include <signal.h>
38: #include <stdio.h>
39: #include <stdlib.h>
40: #include <string.h>
41: #include <limits.h>
42: #include <pthread.h>
43: #ifdef HAVE_PTHREAD_NP_H
44: #include <pthread_np.h>
45: #endif
46: #include <time.h>
47: #include <sys/types.h>
48: #include <sys/stat.h>
49: #include <netinet/in.h>
50: #include <arpa/inet.h>
51:
52: #include <fcntl.h>
53: #include <unistd.h>
54: #include <sys/ioctl.h>
55: #ifdef HAVE_SYS_DISK_H
56: #include <sys/disk.h>
57: #endif
58: #ifdef HAVE_SYS_DISKLABEL_H
59: #include <sys/disklabel.h>
60: #endif
61: #ifdef __linux__
62: #include <linux/fs.h>
63: #endif
64:
65: #include "istgt.h"
66: #include "istgt_ver.h"
67: #include "istgt_log.h"
68: #include "istgt_conf.h"
69: #include "istgt_sock.h"
70: #include "istgt_misc.h"
71: #include "istgt_md5.h"
72: #include "istgt_iscsi.h"
73: #include "istgt_lu.h"
74: #include "istgt_proto.h"
75: #include "istgt_scsi.h"
76:
77: #define MAX_MASKBUF 128
78: static int
79: istgt_lu_allow_ipv6(const char *netmask, const char *addr)
80: {
81: struct in6_addr in6_mask;
82: struct in6_addr in6_addr;
83: char mask[MAX_MASKBUF];
84: const char *p;
85: int bits, bmask;
86: int n;
87: int i;
88:
89: if (netmask[0] != '[')
90: return 0;
91: p = strchr(netmask, ']');
92: if (p == NULL)
93: return 0;
94: n = p - (netmask + 1);
95: if (n + 1 > sizeof mask)
96: return 0;
97:
98: memcpy(mask, netmask + 1, n);
99: mask[n] = '\0';
100: p++;
101:
102: if (p[0] == '/') {
103: bits = (int) strtol(p + 1, NULL, 10);
104: if (bits < 0 || bits > 128)
105: return 0;
106: } else {
107: bits = 128;
108: }
109:
110: #if 0
111: printf("input %s\n", addr);
112: printf("mask %s / %d\n", mask, bits);
113: #endif
114:
115: /* presentation to network order binary */
116: if (inet_pton(AF_INET6, mask, &in6_mask) <= 0
117: || inet_pton(AF_INET6, addr, &in6_addr) <= 0) {
118: return 0;
119: }
120:
121: /* check 128bits */
122: for (i = 0; i < (bits / 8); i++) {
123: if (in6_mask.s6_addr[i] != in6_addr.s6_addr[i])
124: return 0;
125: }
126: if (bits % 8) {
127: bmask = (0xffU << (8 - (bits % 8))) & 0xffU;
128: if ((in6_mask.s6_addr[i] & bmask) != (in6_addr.s6_addr[i] & bmask))
129: return 0;
130: }
131:
132: /* match */
133: return 1;
134: }
135:
136: static int
137: istgt_lu_allow_ipv4(const char *netmask, const char *addr)
138: {
139: struct in_addr in4_mask;
140: struct in_addr in4_addr;
141: char mask[MAX_MASKBUF];
142: const char *p;
143: uint32_t bmask;
144: int bits;
145: int n;
146:
147: p = strchr(netmask, '/');
148: if (p == NULL) {
149: p = netmask + strlen(netmask);
150: }
151: n = p - netmask;
152: if (n + 1 > sizeof mask)
153: return 0;
154:
155: memcpy(mask, netmask, n);
156: mask[n] = '\0';
157:
158: if (p[0] == '/') {
159: bits = (int) strtol(p + 1, NULL, 10);
160: if (bits < 0 || bits > 32)
161: return 0;
162: } else {
163: bits = 32;
164: }
165:
166: #if 0
167: printf("input %s\n", addr);
168: printf("mask %s / %d\n", mask, bits);
169: #endif
170:
171: /* presentation to network order binary */
172: if (inet_pton(AF_INET, mask, &in4_mask) <= 0
173: || inet_pton(AF_INET, addr, &in4_addr) <= 0) {
174: return 0;
175: }
176:
177: /* check 32bits */
178: bmask = (0xffffffffU << (32 - bits)) & 0xffffffffU;
179: if ((ntohl(in4_mask.s_addr) & bmask) != (ntohl(in4_addr.s_addr) & bmask))
180: return 0;
181:
182: /* match */
183: return 1;
184: }
185:
186: int
187: istgt_lu_allow_netmask(const char *netmask, const char *addr)
188: {
189: if (netmask == NULL || addr == NULL)
190: return 0;
191: if (strcasecmp(netmask, "ALL") == 0)
192: return 1;
193: if (netmask[0] == '[') {
194: /* IPv6 */
195: if (istgt_lu_allow_ipv6(netmask, addr))
196: return 1;
197: } else {
198: /* IPv4 */
199: if (istgt_lu_allow_ipv4(netmask, addr))
200: return 1;
201: }
202: return 0;
203: }
204:
205: int
206: istgt_lu_access(CONN_Ptr conn, ISTGT_LU_Ptr lu, const char *iqn, const char *addr)
207: {
208: ISTGT_Ptr istgt;
209: INITIATOR_GROUP *igp;
210: int pg_tag;
211: int ig_tag;
212: int rc;
213: int i, j, k;
214:
215: if (conn == NULL || lu == NULL || iqn == NULL || addr == NULL)
216: return 0;
217: istgt = conn->istgt;
218: pg_tag = conn->portal.tag;
219:
220: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "pg=%d, iqn=%s, addr=%s\n",
221: pg_tag, iqn, addr);
222: for (i = 0; i < lu->maxmap; i++) {
223: /* skip excluding self portal group tag */
224: if (pg_tag != lu->map[i].pg_tag)
225: continue;
226: /* iqn is initiator group? */
227: ig_tag = lu->map[i].ig_tag;
228: igp = istgt_lu_find_initiatorgroup(istgt, ig_tag);
229: if (igp == NULL) {
230: ISTGT_ERRLOG("LU%d: ig_tag not found\n", lu->num);
231: continue;
232: }
233: for (j = 0; j < igp->ninitiators; j++) {
234: /* deny initiators */
235: if (igp->initiators[j][0] == '!'
236: && (strcasecmp(&igp->initiators[j][1], "ALL") == 0
237: || strcasecmp(&igp->initiators[j][1], iqn) == 0)) {
238: /* NG */
239: ISTGT_WARNLOG("access denied from %s (%s) to %s (%s:%s,%d)\n",
240: iqn, addr, conn->target_name, conn->portal.host,
241: conn->portal.port, conn->portal.tag);
242: return 0;
243: }
244: /* allow initiators */
245: if (strcasecmp(igp->initiators[j], "ALL") == 0
246: || strcasecmp(igp->initiators[j], iqn) == 0) {
247: /* OK iqn, check netmask */
248: if (igp->nnetmasks == 0) {
249: /* OK, empty netmask as ALL */
250: return 1;
251: }
252: for (k = 0; k < igp->nnetmasks; k++) {
253: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
254: "netmask=%s, addr=%s\n",
255: igp->netmasks[k], addr);
256: rc = istgt_lu_allow_netmask(igp->netmasks[k], addr);
257: if (rc > 0) {
258: /* OK netmask */
259: return 1;
260: }
261: }
262: /* NG netmask in this group */
263: }
264: }
265: }
266:
267: /* NG */
268: ISTGT_WARNLOG("access denied from %s (%s) to %s (%s:%s,%d)\n",
269: iqn, addr, conn->target_name, conn->portal.host,
270: conn->portal.port, conn->portal.tag);
271: return 0;
272: }
273:
274: int
275: istgt_lu_visible(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu, const char *iqn, int pg_tag)
276: {
277: INITIATOR_GROUP *igp;
278: int match_pg_tag;
279: int ig_tag;
280: int i, j;
281:
282: if (istgt == NULL || lu == NULL || iqn == NULL)
283: return 0;
284: /* pg_tag exist map? */
285: match_pg_tag = 0;
286: for (i = 0; i < lu->maxmap; i++) {
287: if (lu->map[i].pg_tag == pg_tag) {
288: match_pg_tag = 1;
289: break;
290: }
291: }
292: if (match_pg_tag == 0) {
293: /* cat't access from pg_tag */
294: return 0;
295: }
296: for (i = 0; i < lu->maxmap; i++) {
297: /* iqn is initiator group? */
298: ig_tag = lu->map[i].ig_tag;
299: igp = istgt_lu_find_initiatorgroup(istgt, ig_tag);
300: if (igp == NULL) {
301: ISTGT_ERRLOG("LU%d: ig_tag not found\n", lu->num);
302: continue;
303: }
304: for (j = 0; j < igp->ninitiators; j++) {
305: if (igp->initiators[j][0] == '!'
306: && (strcasecmp(&igp->initiators[j][1], "ALL") == 0
307: || strcasecmp(&igp->initiators[j][1], iqn) == 0)) {
308: /* NG */
309: return 0;
310: }
311: if (strcasecmp(igp->initiators[j], "ALL") == 0
312: || strcasecmp(igp->initiators[j], iqn) == 0) {
313: /* OK iqn, no check addr */
314: return 1;
315: }
316: }
317: }
318:
319: /* NG */
320: return 0;
321: }
322:
323: int
324: istgt_lu_sendtargets(CONN_Ptr conn, const char *iiqn, const char *iaddr, const char *tiqn, uint8_t *data, int alloc_len, int data_len)
325: {
326: char buf[MAX_TMPBUF];
327: ISTGT_Ptr istgt;
328: ISTGT_LU_Ptr lu;
329: char *host;
330: int total;
331: int len;
332: int rc;
333: int pg_tag;
334: int i, j, k;
335:
336: if (conn == NULL)
337: return 0;
338: istgt = conn->istgt;
339:
340: total = data_len;
341: if (alloc_len < 1) {
342: return 0;
343: }
344: if (total > alloc_len) {
345: total = alloc_len;
346: data[total - 1] = '\0';
347: return total;
348: }
349:
350: if (alloc_len - total < 1) {
351: ISTGT_ERRLOG("data space small %d\n", alloc_len);
352: return total;
353: }
354:
355: MTX_LOCK(&istgt->mutex);
356: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
357: lu = istgt->logical_unit[i];
358: if (lu == NULL)
359: continue;
360: if (strcasecmp(tiqn, "ALL") != 0
361: && strcasecmp(tiqn, lu->name) != 0) {
362: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
363: "SKIP iqn=%s for %s from %s (%s)\n",
364: tiqn, lu->name, iiqn, iaddr);
365: continue;
366: }
367: rc = istgt_lu_visible(istgt, lu, iiqn, conn->portal.tag);
368: if (rc == 0) {
369: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
370: "SKIP iqn=%s for %s from %s (%s)\n",
371: tiqn, lu->name, iiqn, iaddr);
372: continue;
373: }
374:
375: /* DO SENDTARGETS */
376: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
377: "OK iqn=%s for %s from %s (%s)\n",
378: tiqn, lu->name, iiqn, iaddr);
379:
380: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
381: "TargetName=%s\n", lu->name);
382: len = snprintf((char *) data + total, alloc_len - total,
383: "TargetName=%s", lu->name);
384: total += len + 1;
385:
386: for (j = 0; j < lu->maxmap; j++) {
387: pg_tag = lu->map[j].pg_tag;
388: /* skip same pg_tag */
389: for (k = 0; k < j; k++) {
390: if (lu->map[k].pg_tag == pg_tag) {
391: goto skip_pg_tag;
392: }
393: }
394: /* write to data */
395: for (k = 0; k < istgt->nportal; k++) {
396: if (istgt->portal[k].tag == pg_tag) {
397: if (alloc_len - total < 1) {
398: MTX_UNLOCK(&istgt->mutex);
399: ISTGT_ERRLOG("data space small %d\n", alloc_len);
400: return total;
401: }
402: host = istgt->portal[k].host;
403: /* wildcard? */
404: if (strcasecmp(host, "[::]") == 0
405: || strcasecmp(host, "[*]") == 0
406: || strcasecmp(host, "0.0.0.0") == 0
407: || strcasecmp(host, "*") == 0) {
408: if ((strcasecmp(host, "[::]") == 0
409: || strcasecmp(host, "[*]") == 0)
410: && conn->initiator_family == AF_INET6) {
411: snprintf(buf, sizeof buf, "[%s]",
412: conn->target_addr);
413: host = buf;
414: } else if ((strcasecmp(host, "0.0.0.0") == 0
415: || strcasecmp(host, "*") == 0)
416: && conn->initiator_family == AF_INET) {
417: snprintf(buf, sizeof buf, "%s",
418: conn->target_addr);
419: host = buf;
420: } else {
421: /* skip portal for the family */
422: continue;
423: }
424: }
425: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
426: "TargetAddress=%s:%s,%d\n",
427: host,
428: istgt->portal[k].port,
429: istgt->portal[k].tag);
430: len = snprintf((char *) data + total,
431: alloc_len - total,
432: "TargetAddress=%s:%s,%d",
433: host,
434: istgt->portal[k].port,
435: istgt->portal[k].tag);
436: total += len + 1;
437: }
438: }
439: skip_pg_tag:
440: ;
441: }
442: }
443: MTX_UNLOCK(&istgt->mutex);
444:
445: return total;
446: }
447:
448: ISTGT_LU_Ptr
449: istgt_lu_find_target(ISTGT_Ptr istgt, const char *target_name)
450: {
451: ISTGT_LU_Ptr lu;
452: int i;
453:
454: if (istgt == NULL || target_name == NULL)
455: return NULL;
456: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
457: lu = istgt->logical_unit[i];
458: if (lu == NULL)
459: continue;
460: if (strcasecmp(target_name, lu->name) == 0) {
461: return lu;
462: }
463: }
464: ISTGT_WARNLOG("can't find target %s\n",
465: target_name);
466: return NULL;
467: }
468:
469: uint16_t
470: istgt_lu_allocate_tsih(ISTGT_LU_Ptr lu, const char *initiator_port, int tag)
471: {
472: uint16_t tsih;
473: int retry = 10;
474: int i;
475:
476: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_allocate_tsih\n");
477: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "initiator_port=%s, tag=%d\n",
478: initiator_port, tag);
479: if (lu == NULL || initiator_port == NULL || tag == 0)
480: return 0;
481: /* tsih 0 is reserved */
482: tsih = 0;
483: MTX_LOCK(&lu->mutex);
484: #if 0
485: for (i = 1; i < MAX_LU_TSIH; i++) {
486: if (lu->tsih[i].initiator_port == NULL)
487: continue;
488: if (tag != lu->tsih[i].tag)
489: continue;
490: if (strcasecmp(initiator_port, lu->tsih[i].initiator_port) == 0) {
491: tsih = lu->tsih[i].tsih;
492: break;
493: }
494: }
495: #endif
496: if (tsih == 0) {
497: if (lu->maxtsih >= MAX_LU_TSIH) {
498: ISTGT_ERRLOG("LU%d: tsih is maximum\n", lu->num);
499: MTX_UNLOCK(&lu->mutex);
500: return 0;
501: }
502: retry:
503: lu->last_tsih++;
504: tsih = lu->last_tsih;
505: if (tsih == 0) {
506: if (retry > 0) {
507: retry--;
508: goto retry;
509: }
510: ISTGT_ERRLOG("LU%d: retry error\n", lu->num);
511: MTX_UNLOCK(&lu->mutex);
512: return 0;
513: }
514: for (i = 1; i < MAX_LU_TSIH; i++) {
515: if (lu->tsih[i].initiator_port != NULL
516: && lu->tsih[i].tsih == tsih) {
517: ISTGT_ERRLOG("tsih is found in list\n");
518: if (retry > 0) {
519: retry--;
520: goto retry;
521: }
522: ISTGT_ERRLOG("LU%d: retry error\n", lu->num);
523: MTX_UNLOCK(&lu->mutex);
524: return 0;
525: }
526: }
527: for (i = 1; i < MAX_LU_TSIH; i++) {
528: if (lu->tsih[i].initiator_port == NULL) {
529: lu->tsih[i].tag = tag;
530: lu->tsih[i].tsih = tsih;
531: lu->tsih[i].initiator_port = xstrdup(initiator_port);
532: lu->maxtsih++;
533: break;
534: }
535: }
536: }
537: MTX_UNLOCK(&lu->mutex);
538: return tsih;
539: }
540:
541: void
542: istgt_lu_free_tsih(ISTGT_LU_Ptr lu, uint16_t tsih, char *initiator_port)
543: {
544: int i;
545:
546: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_free_tsih\n");
547: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "tsih=%u, initiator_port=%s\n",
548: tsih, initiator_port);
549: if (lu == NULL || initiator_port == NULL)
550: return;
551: if (tsih == 0)
552: return;
553:
554: MTX_LOCK(&lu->mutex);
555: for (i = 1; i < MAX_LU_TSIH; i++) {
556: if (lu->tsih[i].initiator_port == NULL)
557: continue;
558: if (lu->tsih[i].tsih != tsih)
559: continue;
560:
561: if (strcasecmp(initiator_port, lu->tsih[i].initiator_port) == 0) {
562: lu->tsih[i].tag = 0;
563: lu->tsih[i].tsih = 0;
564: xfree(lu->tsih[i].initiator_port);
565: lu->tsih[i].initiator_port = NULL;
566: lu->maxtsih--;
567: break;
568: }
569: }
570: MTX_UNLOCK(&lu->mutex);
571: return;
572: }
573:
574: char *
575: istgt_lu_get_media_flags_string(int flags, char *buf, size_t len)
576: {
577: char *p;
578: size_t rest;
579:
580: p = buf;
581: rest = len;
582: if (flags & ISTGT_LU_FLAG_MEDIA_READONLY) {
583: snprintf(p, rest, "%s", "ro");
584: } else {
585: snprintf(p, rest, "%s", "rw");
586: }
587: p = buf + strlen(buf);
588: rest = len - strlen(buf);
589: if (flags & ISTGT_LU_FLAG_MEDIA_EXTEND) {
590: snprintf(p, rest, ",%s", "extend");
591: }
592: p = buf + strlen(buf);
593: rest = len - strlen(buf);
594: if (flags & ISTGT_LU_FLAG_MEDIA_DYNAMIC) {
595: snprintf(p, rest, ",%s", "dynamic");
596: }
597: return buf;
598: }
599:
600: uint64_t
601: istgt_lu_get_devsize(const char *file)
602: {
603: uint64_t val;
604: struct stat st;
605: int fd;
606: int rc;
607:
608: val = 0ULL;
609: rc = lstat(file, &st);
610: if (rc != 0)
611: return val;
612: if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode))
613: return val;
614:
615: fd = open(file, O_RDONLY, 0);
616: if (fd >= 0) {
617: #ifdef DIOCGMEDIASIZE
618: if (val == 0) {
619: off_t offset;
620: rc = ioctl(fd, DIOCGMEDIASIZE, &offset);
621: if (rc != -1) {
622: val = (uint64_t) offset;
623: }
624: }
625: #endif /* DIOCGMEDIASIZE */
626: #ifdef DIOCGDINFO
627: if (val == 0) {
628: struct disklabel dl;
629: rc = ioctl(fd, DIOCGDINFO, &dl);
630: if (rc != -1) {
631: val = (uint64_t) dl.d_secperunit;
632: val *= (uint64_t) dl.d_secsize;
633: }
634: }
635: #endif /* DIOCGDINFO */
636: #if defined(DKIOCGETBLOCKSIZE) && defined(DKIOCGETBLOCKCOUNT)
637: if (val == 0) {
638: uint32_t blocklen;
639: uint64_t blockcnt;
640: rc = ioctl(fd, DKIOCGETBLOCKSIZE, &blocklen);
641: if (rc != -1) {
642: rc = ioctl(fd, DKIOCGETBLOCKCOUNT, &blockcnt);
643: if (rc != -1) {
644: val = (uint64_t) blocklen;
645: val *= (uint64_t) blockcnt;
646: }
647: }
648: }
649: #endif /* DKIOCGETBLOCKSIZE && DKIOCGETBLOCKCOUNT */
650: #ifdef __linux__
651: #ifdef BLKGETSIZE64
652: if (val == 0) {
653: uint64_t blocksize;
654: rc = ioctl(fd, BLKGETSIZE64, &blocksize);
655: if (rc != -1) {
656: val = (uint64_t) blocksize;
657: }
658: }
659: #endif /* BLKGETSIZE64 */
660: #ifdef BLKGETSIZE
661: if (val == 0) {
662: uint32_t blocksize;
663: rc = ioctl(fd, BLKGETSIZE, &blocksize);
664: if (rc != -1) {
665: val = (uint64_t) 512;
666: val *= (uint64_t) blocksize;
667: }
668: }
669: #endif /* BLKGETSIZE */
670: #endif /* __linux__ */
671: if (val == 0) {
672: ISTGT_ERRLOG("unknown device size\n");
673: }
674: (void) close(fd);
675: } else {
676: if (g_trace_flag) {
677: ISTGT_WARNLOG("open error %s (errno=%d)\n", file, errno);
678: }
679: val = 0ULL;
680: }
681: return val;
682: }
683:
684: uint64_t
685: istgt_lu_get_filesize(const char *file)
686: {
687: uint64_t val;
688: struct stat st;
689: int rc;
690:
691: val = 0ULL;
692: rc = lstat(file, &st);
693: if (rc < 0)
694: return val;
695: if (S_ISLNK(st.st_mode))
696: return val;
697:
698: if (S_ISCHR(st.st_mode)) {
699: val = istgt_lu_get_devsize(file);
700: } else if (S_ISBLK(st.st_mode)) {
701: val = istgt_lu_get_devsize(file);
702: } else if (S_ISREG(st.st_mode)) {
703: val = st.st_size;
704: } else {
705: ISTGT_ERRLOG("lstat is neither REG, CHR nor BLK\n");
706: val = 0ULL;
707: }
708: return val;
709: }
710:
711: uint64_t
712: istgt_lu_parse_size(const char *size)
713: {
714: uint64_t val, val1, val2;
715: char *endp, *p;
716: size_t idx;
717: int sign;
718:
719: val1 = (uint64_t) strtoull(size, &endp, 10);
720: val = val1;
721: val2 = 0;
722: if (endp != NULL) {
723: p = endp;
724: switch (toupper((int) *p)) {
725: case 'Z': val1 *= (uint64_t) 1024ULL;
726: case 'E': val1 *= (uint64_t) 1024ULL;
727: case 'P': val1 *= (uint64_t) 1024ULL;
728: case 'T': val1 *= (uint64_t) 1024ULL;
729: case 'G': val1 *= (uint64_t) 1024ULL;
730: case 'M': val1 *= (uint64_t) 1024ULL;
731: case 'K': val1 *= (uint64_t) 1024ULL;
732: break;
733: }
734: val = val1;
735: p++;
736: idx = strspn(p, "Bb \t");
737: p += idx;
738: if (*p == '-' || *p == '+') {
739: sign = (int) *p++;
740: idx = strspn(p, " \t");
741: p += idx;
742: val2 = (uint64_t) strtoull(p, &endp, 10);
743: if (endp != NULL) {
744: p = endp;
745: switch (toupper((int) *p)) {
746: case 'Z': val2 *= (uint64_t) 1024ULL;
747: case 'E': val2 *= (uint64_t) 1024ULL;
748: case 'P': val2 *= (uint64_t) 1024ULL;
749: case 'T': val2 *= (uint64_t) 1024ULL;
750: case 'G': val2 *= (uint64_t) 1024ULL;
751: case 'M': val2 *= (uint64_t) 1024ULL;
752: case 'K': val2 *= (uint64_t) 1024ULL;
753: break;
754: }
755: }
756: if (sign == '-') {
757: if (val2 > val1) {
758: /* underflow */
759: val = (uint64_t) 0ULL;
760: } else {
761: val = val1 - val2;
762: }
763: } else {
764: if (val2 > (UINT64_MAX - val1)) {
765: /* overflow */
766: val = UINT64_MAX;
767: } else {
768: val = val1 + val2;
769: }
770: }
771: }
772: }
773: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
774: "size=%s, val=%"PRIu64", val1=%"PRIu64", val2=%"PRIu64"\n",
775: size, val, val1, val2);
776: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
777: "size=%s, val=%"PRIx64", val1=%"PRIx64", val2=%"PRIx64"\n",
778: size, val, val1, val2);
779:
780: return val;
781: }
782:
783: int
784: istgt_lu_parse_media_flags(const char *flags)
785: {
786: char buf[MAX_TMPBUF];
787: const char *delim = ",";
788: char *next_p;
789: char *p;
790: int mflags;
791:
792: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "mflags=%s\n", flags);
793: mflags = 0;
794: strlcpy(buf, flags, MAX_TMPBUF);
795: next_p = buf;
796: while ((p = strsep(&next_p, delim)) != NULL) {
797: if (strcasecmp(p, "ro") == 0) {
798: mflags |= ISTGT_LU_FLAG_MEDIA_READONLY;
799: } else if (strcasecmp(p, "rw") == 0) {
800: mflags &= ~ISTGT_LU_FLAG_MEDIA_READONLY;
801: } else if (strcasecmp(p, "extend") == 0) {
802: mflags |= ISTGT_LU_FLAG_MEDIA_EXTEND;
803: } else if (strcasecmp(p, "dynamic") == 0) {
804: mflags |= ISTGT_LU_FLAG_MEDIA_DYNAMIC;
805: } else {
806: ISTGT_ERRLOG("unknown media flag %.64s\n", p);
807: }
808: }
809:
810: return mflags;
811: }
812:
813: uint64_t
814: istgt_lu_parse_media_size(const char *file, const char *size, int *flags)
815: {
816: uint64_t msize, fsize;
817:
818: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "msize=%s\n", size);
819: if (strcasecmp(file, "/dev/null") == 0) {
820: return 0;
821: }
822: if (strcasecmp(size, "Auto") == 0
823: || strcasecmp(size, "Size") == 0) {
824: msize = istgt_lu_get_filesize(file);
825: if (msize == 0) {
826: msize = ISTGT_LU_MEDIA_SIZE_MIN;
827: }
828: *flags |= ISTGT_LU_FLAG_MEDIA_AUTOSIZE;
829: } else {
830: msize = istgt_lu_parse_size(size);
831: if (*flags & ISTGT_LU_FLAG_MEDIA_EXTEND) {
832: fsize = istgt_lu_get_filesize(file);
833: if (fsize > msize) {
834: msize = fsize;
835: }
836: }
837: }
838:
839: if (*flags & ISTGT_LU_FLAG_MEDIA_DYNAMIC) {
840: if (msize < ISTGT_LU_MEDIA_SIZE_MIN) {
841: msize = ISTGT_LU_MEDIA_SIZE_MIN;
842: }
843: } else {
844: if (msize < ISTGT_LU_MEDIA_SIZE_MIN) {
845: ISTGT_ERRLOG("media size too small\n");
846: return 0ULL;
847: }
848: }
849:
850: return msize;
851: }
852:
853: PORTAL *
854: istgt_lu_find_portalgroup(ISTGT_Ptr istgt, int tag)
855: {
856: PORTAL *pp;
857: int i;
858:
859: for (i = 0; i < istgt->nportal; i++) {
860: if (istgt->portal[i].tag == tag) {
861: pp = &istgt->portal[i];
862: return pp;
863: }
864: }
865: return NULL;
866: }
867:
868: INITIATOR_GROUP *
869: istgt_lu_find_initiatorgroup(ISTGT_Ptr istgt, int tag)
870: {
871: INITIATOR_GROUP *igp;
872: int i;
873:
874: for (i = 0; i < istgt->ninitiator_group; i++) {
875: if (istgt->initiator_group[i].tag == tag) {
876: igp = &istgt->initiator_group[i];
877: return igp;
878: }
879: }
880: return NULL;
881: }
882:
883: static int
884: istgt_lu_check_iscsi_name(const char *name)
885: {
886: const unsigned char *up = (const unsigned char *) name;
887: size_t n;
888:
889: /* valid iSCSI name? */
890: for (n = 0; up[n] != 0; n++) {
891: if (up[n] > 0x00U && up[n] <= 0x2cU)
892: return -1;
893: if (up[n] == 0x2fU)
894: return -1;
895: if (up[n] >= 0x3bU && up[n] <= 0x40U)
896: return -1;
897: if (up[n] >= 0x5bU && up[n] <= 0x60U)
898: return -1;
899: if (up[n] >= 0x7bU && up[n] <= 0x7fU)
900: return -1;
901: if (isspace(up[n]))
902: return -1;
903: }
904: /* valid format? */
905: if (strncasecmp(name, "iqn.", 4) == 0) {
906: /* iqn.YYYY-MM.reversed.domain.name */
907: if (!isdigit(up[4]) || !isdigit(up[5]) || !isdigit(up[6])
908: || !isdigit(up[7]) || up[8] != '-' || !isdigit(up[9])
909: || !isdigit(up[10]) || up[11] != '.') {
910: ISTGT_ERRLOG("invalid iqn format. "
911: "expect \"iqn.YYYY-MM.reversed.domain.name\"\n");
912: return -1;
913: }
914: } else if (strncasecmp(name, "eui.", 4) == 0) {
915: /* EUI-64 -> 16bytes */
916: /* XXX */
917: } else if (strncasecmp(name, "naa.", 4) == 0) {
918: /* 64bit -> 16bytes, 128bit -> 32bytes */
919: /* XXX */
920: }
921: /* OK */
922: return 0;
923: }
924:
925: static uint64_t
926: istgt_lu_get_nbserial(const char *nodebase)
927: {
928: ISTGT_MD5CTX md5ctx;
929: uint8_t nbsmd5[ISTGT_MD5DIGEST_LEN];
930: char buf[MAX_TMPBUF];
931: uint64_t nbs;
932: int idx;
933: int i;
934:
935: snprintf(buf, sizeof buf, "%s", nodebase);
936: if (strcasecmp(buf, "iqn.2007-09.jp.ne.peach.istgt") == 0
937: || strcasecmp(buf, "iqn.2007-09.jp.ne.peach") == 0) {
938: /* always zero */
939: return 0;
940: }
941:
942: istgt_md5init(&md5ctx);
943: istgt_md5update(&md5ctx, buf, strlen(buf));
944: istgt_md5final(nbsmd5, &md5ctx);
945:
946: nbs = 0U;
947: idx = ISTGT_MD5DIGEST_LEN - 8;
948: if (idx < 0) {
949: ISTGT_WARNLOG("missing MD5 length\n");
950: idx = 0;
951: }
952: for (i = idx; i < ISTGT_MD5DIGEST_LEN; i++) {
953: nbs |= (uint64_t) nbsmd5[i];
954: nbs = nbs << 8;
955: }
956: return nbs;
957: }
958:
959: static int
960: istgt_lu_set_local_settings(ISTGT_Ptr istgt, CF_SECTION *sp, ISTGT_LU_Ptr lu)
961: {
962: const char *val;
963:
964: val = istgt_get_val(sp, "MaxOutstandingR2T");
965: if (val == NULL) {
966: lu->MaxOutstandingR2T = lu->istgt->MaxOutstandingR2T;
967: } else {
968: lu->MaxOutstandingR2T = (int)strtol(val, NULL, 10);
969: if (lu->MaxOutstandingR2T < 1) {
970: lu->MaxOutstandingR2T = DEFAULT_MAXOUTSTANDINGR2T;
971: }
972: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "MaxOutstandingR2T %d\n",
973: lu->MaxOutstandingR2T);
974: }
975:
976: val = istgt_get_val(sp, "DefaultTime2Wait");
977: if (val == NULL) {
978: lu->DefaultTime2Wait = lu->istgt->DefaultTime2Wait;
979: } else {
980: lu->DefaultTime2Wait = (int)strtol(val, NULL, 10);
981: if (lu->DefaultTime2Wait < 0) {
982: lu->DefaultTime2Wait = DEFAULT_DEFAULTTIME2WAIT;
983: }
984: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "DefaultTime2Wait %d\n",
985: lu->DefaultTime2Wait);
986: }
987:
988: val = istgt_get_val(sp, "DefaultTime2Retain");
989: if (val == NULL) {
990: lu->DefaultTime2Retain = lu->istgt->DefaultTime2Retain;
991: } else {
992: lu->DefaultTime2Retain = (int)strtol(val, NULL, 10);
993: if (lu->DefaultTime2Retain < 0) {
994: lu->DefaultTime2Retain = DEFAULT_DEFAULTTIME2RETAIN;
995: }
996: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "DefaultTime2Retain %d\n",
997: lu->DefaultTime2Retain);
998: }
999:
1000: /* check size limit - RFC3720(12.15, 12.16, 12.17) */
1001: if (lu->MaxOutstandingR2T > 65535) {
1002: ISTGT_ERRLOG("MaxOutstandingR2T(%d) > 65535\n",
1003: lu->MaxOutstandingR2T);
1004: return -1;
1005: }
1006: if (lu->DefaultTime2Wait > 3600) {
1007: ISTGT_ERRLOG("DefaultTime2Wait(%d) > 3600\n",
1008: lu->DefaultTime2Wait);
1009: return -1;
1010: }
1011: if (lu->DefaultTime2Retain > 3600) {
1012: ISTGT_ERRLOG("DefaultTime2Retain(%d) > 3600\n",
1013: lu->DefaultTime2Retain);
1014: return -1;
1015: }
1016:
1017: val = istgt_get_val(sp, "FirstBurstLength");
1018: if (val == NULL) {
1019: lu->FirstBurstLength = lu->istgt->FirstBurstLength;
1020: } else {
1021: lu->FirstBurstLength = (int)strtol(val, NULL, 10);
1022: if (lu->FirstBurstLength < 0) {
1023: lu->FirstBurstLength = DEFAULT_FIRSTBURSTLENGTH;
1024: }
1025: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "FirstBurstLength %d\n",
1026: lu->FirstBurstLength);
1027: }
1028:
1029: val = istgt_get_val(sp, "MaxBurstLength");
1030: if (val == NULL) {
1031: lu->MaxBurstLength = lu->istgt->MaxBurstLength;
1032: } else {
1033: lu->MaxBurstLength = (int)strtol(val, NULL, 10);
1034: if (lu->MaxBurstLength < 0) {
1035: lu->MaxBurstLength = DEFAULT_MAXBURSTLENGTH;
1036: }
1037: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "MaxBurstLength %d\n",
1038: lu->MaxBurstLength);
1039: }
1040:
1041: val = istgt_get_val(sp, "MaxRecvDataSegmentLength");
1042: if (val == NULL) {
1043: lu->MaxRecvDataSegmentLength
1044: = lu->istgt->MaxRecvDataSegmentLength;
1045: } else {
1046: lu->MaxRecvDataSegmentLength = (int)strtol(val, NULL, 10);
1047: if (lu->MaxRecvDataSegmentLength < 0) {
1048: lu->MaxRecvDataSegmentLength
1049: = DEFAULT_MAXRECVDATASEGMENTLENGTH;
1050: }
1051: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
1052: "MaxRecvDataSegmentLength %d\n",
1053: lu->MaxRecvDataSegmentLength);
1054: }
1055:
1056: /* check size limit (up to 24bits - RFC3720(12.12)) */
1057: if (lu->MaxBurstLength < 512) {
1058: ISTGT_ERRLOG("MaxBurstLength(%d) < 512\n",
1059: lu->MaxBurstLength);
1060: return -1;
1061: }
1062: if (lu->FirstBurstLength < 512) {
1063: ISTGT_ERRLOG("FirstBurstLength(%d) < 512\n",
1064: lu->FirstBurstLength);
1065: return -1;
1066: }
1067: if (lu->FirstBurstLength > lu->MaxBurstLength) {
1068: ISTGT_ERRLOG("FirstBurstLength(%d) > MaxBurstLength(%d)\n",
1069: lu->FirstBurstLength, istgt->MaxBurstLength);
1070: return -1;
1071: }
1072: if (lu->MaxBurstLength > 0x00ffffff) {
1073: ISTGT_ERRLOG("MaxBurstLength(%d) > 0x00ffffff\n",
1074: lu->MaxBurstLength);
1075: return -1;
1076: }
1077: if (lu->MaxRecvDataSegmentLength < 512) {
1078: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) < 512\n",
1079: lu->MaxRecvDataSegmentLength);
1080: return -1;
1081: }
1082: if (lu->MaxRecvDataSegmentLength > 0x00ffffff) {
1083: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) > 0x00ffffff\n",
1084: lu->MaxRecvDataSegmentLength);
1085: return -1;
1086: }
1087:
1088: val = istgt_get_val(sp, "InitialR2T");
1089: if (val == NULL) {
1090: lu->InitialR2T = lu->istgt->InitialR2T;
1091: } else {
1092: if (strcasecmp(val, "Yes") == 0) {
1093: lu->InitialR2T = 1;
1094: } else if (strcasecmp(val, "No") == 0) {
1095: #if 0
1096: lu->InitialR2T = 0;
1097: #else
1098: ISTGT_ERRLOG("not supported value %s\n", val);
1099: return -1;
1100: #endif
1101: } else {
1102: ISTGT_ERRLOG("unknown value %s\n", val);
1103: return -1;
1104: }
1105: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "InitialR2T %s\n",
1106: lu->InitialR2T ? "Yes" : "No");
1107: }
1108:
1109: val = istgt_get_val(sp, "ImmediateData");
1110: if (val == NULL) {
1111: lu->ImmediateData = lu->istgt->ImmediateData;
1112: } else {
1113: if (strcasecmp(val, "Yes") == 0) {
1114: lu->ImmediateData = 1;
1115: } else if (strcasecmp(val, "No") == 0) {
1116: lu->ImmediateData = 0;
1117: } else {
1118: ISTGT_ERRLOG("unknown value %s\n", val);
1119: return -1;
1120: }
1121: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "ImmediateData %s\n",
1122: lu->ImmediateData ? "Yes" : "No");
1123: }
1124:
1125: val = istgt_get_val(sp, "DataPDUInOrder");
1126: if (val == NULL) {
1127: lu->DataPDUInOrder = lu->istgt->DataPDUInOrder;
1128: } else {
1129: if (strcasecmp(val, "Yes") == 0) {
1130: lu->DataPDUInOrder = 1;
1131: } else if (strcasecmp(val, "No") == 0) {
1132: #if 0
1133: lu->DataPDUInOrder = 0;
1134: #else
1135: ISTGT_ERRLOG("not supported value %s\n", val);
1136: return -1;
1137: #endif
1138: } else {
1139: ISTGT_ERRLOG("unknown value %s\n", val);
1140: return -1;
1141: }
1142: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "DataPDUInOrder %s\n",
1143: lu->DataPDUInOrder ? "Yes" : "No");
1144: }
1145:
1146: val = istgt_get_val(sp, "DataSequenceInOrder");
1147: if (val == NULL) {
1148: lu->DataSequenceInOrder = lu->istgt->DataSequenceInOrder;
1149: } else {
1150: if (strcasecmp(val, "Yes") == 0) {
1151: lu->DataSequenceInOrder = 1;
1152: } else if (strcasecmp(val, "No") == 0) {
1153: #if 0
1154: lu->DataSequenceInOrder = 0;
1155: #else
1156: ISTGT_ERRLOG("not supported value %s\n", val);
1157: return -1;
1158: #endif
1159: } else {
1160: ISTGT_ERRLOG("unknown value %s\n", val);
1161: return -1;
1162: }
1163: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "DataSequenceInOrder %s\n",
1164: lu->DataSequenceInOrder ? "Yes" : "No");
1165: }
1166:
1167: val = istgt_get_val(sp, "ErrorRecoveryLevel");
1168: if (val == NULL) {
1169: lu->ErrorRecoveryLevel = lu->istgt->ErrorRecoveryLevel;
1170: } else {
1171: lu->ErrorRecoveryLevel = (int)strtol(val, NULL, 10);
1172: if (lu->ErrorRecoveryLevel < 0) {
1173: lu->ErrorRecoveryLevel = DEFAULT_ERRORRECOVERYLEVEL;
1174: } else if (lu->ErrorRecoveryLevel == 0) {
1175: lu->ErrorRecoveryLevel = 0;
1176: } else if (lu->ErrorRecoveryLevel == 1) {
1177: #if 0
1178: lu->ErrorRecoveryLevel = 1;
1179: #else
1180: ISTGT_ERRLOG("not supported value %d\n",
1181: lu->ErrorRecoveryLevel);
1182: return -1;
1183: #endif
1184: } else if (lu->ErrorRecoveryLevel == 2) {
1185: #if 0
1186: lu->ErrorRecoveryLevel = 2;
1187: #else
1188: ISTGT_ERRLOG("not supported value %d\n",
1189: lu->ErrorRecoveryLevel);
1190: return -1;
1191: #endif
1192: } else {
1193: ISTGT_ERRLOG("not supported value %d\n",
1194: lu->ErrorRecoveryLevel);
1195: return -1;
1196: }
1197: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "ErrorRecoveryLevel %d\n",
1198: istgt->ErrorRecoveryLevel);
1199: }
1200:
1201: return 0;
1202: }
1203:
1204: static int
1205: istgt_lu_add_unit(ISTGT_Ptr istgt, CF_SECTION *sp)
1206: {
1207: char buf[MAX_TMPBUF], buf2[MAX_TMPBUF];
1208: ISTGT_LU_Ptr lu;
1209: const char *vendor, *product, *revision, *serial;
1210: const char *pg_tag, *ig_tag;
1211: const char *ag_tag;
1212: const char *flags, *file, *size;
1213: const char *key, *val;
1214: uint64_t msize;
1215: uint64_t nbs64;
1216: int pg_tag_i, ig_tag_i;
1217: int ag_tag_i;
1218: int rpm, formfactor;
1219: int mflags;
1220: int slot;
1221: int nbs;
1222: int i, j, k;
1223: int rc;
1224:
1225: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "add unit %d\n", sp->num);
1226:
1227: if (sp->num >= MAX_LOGICAL_UNIT) {
1228: ISTGT_ERRLOG("LU%d: over maximum unit number\n", sp->num);
1229: return -1;
1230: }
1231: if (istgt->logical_unit[sp->num] != NULL) {
1232: ISTGT_ERRLOG("LU%d: duplicate unit\n", sp->num);
1233: return -1;
1234: }
1235:
1236: lu = xmalloc(sizeof *lu);
1237: memset(lu, 0, sizeof *lu);
1238: lu->num = sp->num;
1239: lu->istgt = istgt;
1240: istgt_lu_set_state(lu, ISTGT_STATE_INVALID);
1241: nbs64 = istgt_lu_get_nbserial(istgt->nodebase);
1242: #if 0
1243: /* disabled now */
1244: nbs = (int) (nbs64 % 900) * 100000;
1245: #else
1246: nbs = 0;
1247: #endif
1248:
1249: val = istgt_get_val(sp, "Comment");
1250: if (val != NULL) {
1251: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Comment %s\n", val);
1252: }
1253:
1254: val = istgt_get_val(sp, "TargetName");
1255: if (val == NULL) {
1256: ISTGT_ERRLOG("LU%d: TargetName not found\n", lu->num);
1257: goto error_return;
1258: }
1259: if (strncasecmp(val, "iqn.", 4) != 0
1260: && strncasecmp(val, "eui.", 4) != 0
1261: && strncasecmp(val, "naa.", 4) != 0) {
1262: snprintf(buf, sizeof buf, "%s:%s", istgt->nodebase, val);
1263: } else {
1264: snprintf(buf, sizeof buf, "%s", val);
1265: }
1266: if (istgt_lu_check_iscsi_name(buf) != 0) {
1267: ISTGT_ERRLOG("TargetName %s contains an invalid character or format.\n",
1268: buf);
1269: #if 0
1270: goto error_return;
1271: #endif
1272: }
1273: lu->name = xstrdup(buf);
1274: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "TargetName %s\n",
1275: lu->name);
1276:
1277: val = istgt_get_val(sp, "TargetAlias");
1278: if (val == NULL) {
1279: lu->alias = NULL;
1280: } else {
1281: lu->alias = xstrdup(val);
1282: }
1283: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "TargetAlias %s\n",
1284: lu->alias);
1285:
1286: val = istgt_get_val(sp, "Mapping");
1287: if (val == NULL) {
1288: /* no map */
1289: lu->maxmap = 0;
1290: } else {
1291: lu->maxmap = 0;
1292: for (i = 0; ; i++) {
1293: val = istgt_get_nmval(sp, "Mapping", i, 0);
1294: if (val == NULL)
1295: break;
1296: if (lu->maxmap >= MAX_LU_MAP) {
1297: ISTGT_ERRLOG("LU%d: too many mapping\n", lu->num);
1298: goto error_return;
1299: }
1300: pg_tag = istgt_get_nmval(sp, "Mapping", i, 0);
1301: ig_tag = istgt_get_nmval(sp, "Mapping", i, 1);
1302: if (pg_tag == NULL || ig_tag == NULL) {
1303: ISTGT_ERRLOG("LU%d: mapping error\n", lu->num);
1304: goto error_return;
1305: }
1306: if (strncasecmp(pg_tag, "PortalGroup",
1307: strlen("PortalGroup")) != 0
1308: || sscanf(pg_tag, "%*[^0-9]%d", &pg_tag_i) != 1) {
1309: ISTGT_ERRLOG("LU%d: mapping portal error\n", lu->num);
1310: goto error_return;
1311: }
1312: if (strncasecmp(ig_tag, "InitiatorGroup",
1313: strlen("InitiatorGroup")) != 0
1314: || sscanf(ig_tag, "%*[^0-9]%d", &ig_tag_i) != 1) {
1315: ISTGT_ERRLOG("LU%d: mapping initiator error\n", lu->num);
1316: goto error_return;
1317: }
1318: if (pg_tag_i < 1 || ig_tag_i < 1) {
1319: ISTGT_ERRLOG("LU%d: invalid group tag\n", lu->num);
1320: goto error_return;
1321: }
1322: if (istgt_lu_find_portalgroup(istgt, pg_tag_i) == NULL) {
1323: ISTGT_ERRLOG("LU%d: PortalGroup%d not found\n",
1324: lu->num, pg_tag_i);
1325: goto error_return;
1326: }
1327: if (istgt_lu_find_initiatorgroup(istgt, ig_tag_i) == NULL) {
1328: ISTGT_ERRLOG("LU%d: InitiatorGroup%d not found\n",
1329: lu->num, ig_tag_i);
1330: goto error_return;
1331: }
1332: lu->map[i].pg_tag = pg_tag_i;
1333: lu->map[i].pg_aas = AAS_ACTIVE_OPTIMIZED;
1334: //lu->map[i].pg_aas = AAS_ACTIVE_NON_OPTIMIZED;
1335: lu->map[i].pg_aas |= AAS_STATUS_IMPLICIT;
1336: lu->map[i].ig_tag = ig_tag_i;
1337: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
1338: "Mapping PortalGroup%d InitiatorGroup%d\n",
1339: lu->map[i].pg_tag, lu->map[i].ig_tag);
1340: lu->maxmap = i + 1;
1341: }
1342: }
1343: if (lu->maxmap == 0) {
1344: ISTGT_ERRLOG("LU%d: no Mapping\n", lu->num);
1345: goto error_return;
1346: }
1347:
1348: val = istgt_get_val(sp, "AuthMethod");
1349: if (val == NULL) {
1350: /* none */
1351: lu->no_auth_chap = 0;
1352: lu->auth_chap = 0;
1353: lu->auth_chap_mutual = 0;
1354: } else {
1355: lu->no_auth_chap = 0;
1356: for (i = 0; ; i++) {
1357: val = istgt_get_nmval(sp, "AuthMethod", 0, i);
1358: if (val == NULL)
1359: break;
1360: if (strcasecmp(val, "CHAP") == 0) {
1361: lu->auth_chap = 1;
1362: } else if (strcasecmp(val, "Mutual") == 0) {
1363: lu->auth_chap_mutual = 1;
1364: } else if (strcasecmp(val, "Auto") == 0) {
1365: lu->auth_chap = 0;
1366: lu->auth_chap_mutual = 0;
1367: } else if (strcasecmp(val, "None") == 0) {
1368: lu->no_auth_chap = 1;
1369: lu->auth_chap = 0;
1370: lu->auth_chap_mutual = 0;
1371: } else {
1372: ISTGT_ERRLOG("LU%d: unknown auth\n", lu->num);
1373: goto error_return;
1374: }
1375: }
1376: if (lu->auth_chap_mutual && !lu->auth_chap) {
1377: ISTGT_ERRLOG("LU%d: Mutual but not CHAP\n", lu->num);
1378: goto error_return;
1379: }
1380: }
1381: if (lu->no_auth_chap != 0) {
1382: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod None\n");
1383: } else if (lu->auth_chap == 0) {
1384: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod Auto\n");
1385: } else {
1386: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod %s %s\n",
1387: lu->auth_chap ? "CHAP" : "",
1388: lu->auth_chap_mutual ? "Mutual" : "");
1389: }
1390:
1391: val = istgt_get_val(sp, "AuthGroup");
1392: if (val == NULL) {
1393: lu->auth_group = 0;
1394: } else {
1395: ag_tag = val;
1396: if (strcasecmp(ag_tag, "None") == 0) {
1397: ag_tag_i = 0;
1398: } else {
1399: if (strncasecmp(ag_tag, "AuthGroup",
1400: strlen("AuthGroup")) != 0
1401: || sscanf(ag_tag, "%*[^0-9]%d", &ag_tag_i) != 1) {
1402: ISTGT_ERRLOG("LU%d: auth group error\n", lu->num);
1403: goto error_return;
1404: }
1405: if (ag_tag_i == 0) {
1406: ISTGT_ERRLOG("LU%d: invalid auth group %d\n", ag_tag_i);
1407: goto error_return;
1408: }
1409: }
1410: lu->auth_group = ag_tag_i;
1411: }
1412: if (lu->auth_group == 0) {
1413: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthGroup None\n");
1414: } else {
1415: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthGroup AuthGroup%d\n",
1416: lu->auth_group);
1417: }
1418:
1419: val = istgt_get_val(sp, "UseDigest");
1420: if (val != NULL) {
1421: for (i = 0; ; i++) {
1422: val = istgt_get_nmval(sp, "UseDigest", 0, i);
1423: if (val == NULL)
1424: break;
1425: if (strcasecmp(val, "Header") == 0) {
1426: lu->header_digest = 1;
1427: } else if (strcasecmp(val, "Data") == 0) {
1428: lu->data_digest = 1;
1429: } else if (strcasecmp(val, "Auto") == 0) {
1430: lu->header_digest = 0;
1431: lu->data_digest = 0;
1432: } else {
1433: ISTGT_ERRLOG("LU%d: unknown digest\n", lu->num);
1434: goto error_return;
1435: }
1436: }
1437: }
1438: if (lu->header_digest == 0 && lu->data_digest == 0) {
1439: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "UseDigest Auto\n");
1440: } else {
1441: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "UseDigest %s %s\n",
1442: lu->header_digest ? "Header" : "",
1443: lu->data_digest ? "Data" : "");
1444: }
1445:
1446: val = istgt_get_val(sp, "ReadOnly");
1447: if (val == NULL) {
1448: lu->readonly = 0;
1449: } else if (strcasecmp(val, "Yes") == 0) {
1450: lu->readonly = 1;
1451: }
1452: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "ReadOnly %s\n",
1453: lu->readonly ? "Yes" : "No");
1454:
1455: val = istgt_get_val(sp, "UnitType");
1456: if (val == NULL) {
1457: ISTGT_ERRLOG("LU%d: unknown unit type\n", lu->num);
1458: goto error_return;
1459: }
1460: if (strcasecmp(val, "Pass") == 0) {
1461: lu->type = ISTGT_LU_TYPE_PASS;
1462: } else if (strcasecmp(val, "Disk") == 0) {
1463: lu->type = ISTGT_LU_TYPE_DISK;
1464: } else if (strcasecmp(val, "DVD") == 0) {
1465: lu->type = ISTGT_LU_TYPE_DVD;
1466: } else if (strcasecmp(val, "Tape") == 0) {
1467: lu->type = ISTGT_LU_TYPE_TAPE;
1468: } else {
1469: ISTGT_ERRLOG("LU%d: unknown unit type\n", lu->num);
1470: goto error_return;
1471: }
1472: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "UnitType %d (%s)\n",
1473: lu->type, val);
1474:
1475: val = istgt_get_val(sp, "UnitOnline");
1476: if (val == NULL) {
1477: lu->online = 1;
1478: } else if (strcasecmp(val, "Yes") == 0) {
1479: lu->online = 1;
1480: }
1481: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "UnitOnline %s\n",
1482: lu->online ? "Yes" : "No");
1483:
1484: vendor = istgt_get_nmval(sp, "UnitInquiry", 0, 0);
1485: product = istgt_get_nmval(sp, "UnitInquiry", 0, 1);
1486: revision = istgt_get_nmval(sp, "UnitInquiry", 0, 2);
1487: serial = istgt_get_nmval(sp, "UnitInquiry", 0, 3);
1488: switch (lu->type) {
1489: case ISTGT_LU_TYPE_DISK:
1490: if (vendor == NULL || strlen(vendor) == 0)
1491: vendor = DEFAULT_LU_VENDOR_DISK;
1492: if (product == NULL || strlen(product) == 0)
1493: product = DEFAULT_LU_PRODUCT_DISK;
1494: if (revision == NULL || strlen(revision) == 0)
1495: revision = DEFAULT_LU_REVISION_DISK;
1496: if (serial == NULL || strlen(serial) == 0) {
1497: snprintf(buf, sizeof buf, "%.8d", 10000000 + nbs + lu->num);
1498: serial = (const char *) &buf[0];
1499: }
1500: break;
1501: case ISTGT_LU_TYPE_DVD:
1502: if (vendor == NULL || strlen(vendor) == 0)
1503: vendor = DEFAULT_LU_VENDOR_DVD;
1504: if (product == NULL || strlen(product) == 0)
1505: product = DEFAULT_LU_PRODUCT_DVD;
1506: if (revision == NULL || strlen(revision) == 0)
1507: revision = DEFAULT_LU_REVISION_DVD;
1508: if (serial == NULL || strlen(serial) == 0) {
1509: snprintf(buf, sizeof buf, "%.8d", 10000000 + nbs + lu->num);
1510: serial = (const char *) &buf[0];
1511: }
1512: break;
1513: case ISTGT_LU_TYPE_TAPE:
1514: if (vendor == NULL || strlen(vendor) == 0)
1515: vendor = DEFAULT_LU_VENDOR_TAPE;
1516: if (product == NULL || strlen(product) == 0)
1517: product = DEFAULT_LU_PRODUCT_TAPE;
1518: if (revision == NULL || strlen(revision) == 0)
1519: revision = DEFAULT_LU_REVISION_TAPE;
1520: if (serial == NULL || strlen(serial) == 0) {
1521: #ifdef USE_LU_TAPE_DLT8000
1522: snprintf(buf, sizeof buf, "CX%.8d", 10000000 + nbs + lu->num);
1523: #else
1524: snprintf(buf, sizeof buf, "%.8d", 10000000 + nbs + lu->num);
1525: #endif /* USE_LU_TAPE_DLT8000 */
1526: serial = (const char *) &buf[0];
1527: }
1528: break;
1529: default:
1530: if (vendor == NULL || strlen(vendor) == 0)
1531: vendor = DEFAULT_LU_VENDOR;
1532: if (product == NULL || strlen(product) == 0)
1533: product = DEFAULT_LU_PRODUCT;
1534: if (revision == NULL || strlen(revision) == 0)
1535: revision = DEFAULT_LU_REVISION;
1536: if (serial == NULL || strlen(serial) == 0) {
1537: snprintf(buf, sizeof buf, "%.8d", 10000000 + nbs + lu->num);
1538: serial = (const char *) &buf[0];
1539: }
1540: break;
1541: }
1542: lu->inq_vendor = xstrdup(vendor);
1543: lu->inq_product = xstrdup(product);
1544: lu->inq_revision = xstrdup(revision);
1545: lu->inq_serial = xstrdup(serial);
1546: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "UnitInquiry %s %s %s %s\n",
1547: lu->inq_vendor, lu->inq_product, lu->inq_revision,
1548: lu->inq_serial);
1549:
1550: val = istgt_get_val(sp, "BlockLength");
1551: if (val == NULL) {
1552: switch (lu->type) {
1553: case ISTGT_LU_TYPE_DISK:
1554: lu->blocklen = DEFAULT_LU_BLOCKLEN_DISK;
1555: break;
1556: case ISTGT_LU_TYPE_DVD:
1557: lu->blocklen = DEFAULT_LU_BLOCKLEN_DVD;
1558: break;
1559: case ISTGT_LU_TYPE_TAPE:
1560: lu->blocklen = DEFAULT_LU_BLOCKLEN_TAPE;
1561: break;
1562: default:
1563: lu->blocklen = DEFAULT_LU_BLOCKLEN;
1564: break;
1565: }
1566: } else {
1567: lu->blocklen = (int) strtol(val, NULL, 10);
1568: }
1569: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "BlockLength %d\n",
1570: lu->blocklen);
1571:
1572: val = istgt_get_val(sp, "QueueDepth");
1573: if (val == NULL) {
1574: switch (lu->type) {
1575: case ISTGT_LU_TYPE_DISK:
1576: lu->queue_depth = DEFAULT_LU_QUEUE_DEPTH;
1577: //lu->queue_depth = 0;
1578: break;
1579: case ISTGT_LU_TYPE_DVD:
1580: case ISTGT_LU_TYPE_TAPE:
1581: default:
1582: lu->queue_depth = 0;
1583: break;
1584: }
1585: } else {
1586: lu->queue_depth = (int) strtol(val, NULL, 10);
1587: }
1588: if (lu->queue_depth < 0 || lu->queue_depth >= MAX_LU_QUEUE_DEPTH) {
1589: ISTGT_ERRLOG("LU%d: queue depth range error\n");
1590: goto error_return;
1591: }
1592: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "QueueDepth %d\n",
1593: lu->queue_depth);
1594:
1595: lu->maxlun = 0;
1596: for (i = 0; i < MAX_LU_LUN; i++) {
1597: lu->lun[i].type = ISTGT_LU_LUN_TYPE_NONE;
1598: lu->lun[i].rotationrate = DEFAULT_LU_ROTATIONRATE;
1599: lu->lun[i].formfactor = DEFAULT_LU_FORMFACTOR;
1600: lu->lun[i].readcache = 1;
1601: lu->lun[i].writecache = 1;
1602: lu->lun[i].serial = NULL;
1603: lu->lun[i].spec = NULL;
1604: snprintf(buf, sizeof buf, "LUN%d", i);
1605: val = istgt_get_val(sp, buf);
1606: if (val == NULL)
1607: continue;
1608: if (i != 0) {
1609: /* default LUN serial (except LUN0) */
1610: snprintf(buf2, sizeof buf2, "%sL%d", lu->inq_serial, i);
1611: lu->lun[i].serial = xstrdup(buf2);
1612: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LUN%d Serial %s (default)\n",
1613: i, buf2);
1614: }
1615: for (j = 0; ; j++) {
1616: val = istgt_get_nmval(sp, buf, j, 0);
1617: if (val == NULL)
1618: break;
1619: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LUN%d\n", i);
1620: if (strcasecmp(val, "Device") == 0) {
1621: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_NONE) {
1622: ISTGT_ERRLOG("LU%d: duplicate LUN%d\n", lu->num, i);
1623: goto error_return;
1624: }
1625: lu->lun[i].type = ISTGT_LU_LUN_TYPE_DEVICE;
1626:
1627: file = istgt_get_nmval(sp, buf, j, 1);
1628: if (file == NULL) {
1629: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1630: goto error_return;
1631: }
1632: lu->lun[i].u.device.file = xstrdup(file);
1633: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Device file=%s\n",
1634: lu->lun[i].u.device.file);
1635: } else if (strcasecmp(val, "Storage") == 0) {
1636: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_NONE) {
1637: ISTGT_ERRLOG("LU%d: duplicate LUN%d\n", lu->num, i);
1638: goto error_return;
1639: }
1640: lu->lun[i].type = ISTGT_LU_LUN_TYPE_STORAGE;
1641:
1642: file = istgt_get_nmval(sp, buf, j, 1);
1643: size = istgt_get_nmval(sp, buf, j, 2);
1644: if (file == NULL || size == NULL) {
1645: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1646: goto error_return;
1647: }
1648: if (strcasecmp(size, "Auto") == 0
1649: || strcasecmp(size, "Size") == 0) {
1650: lu->lun[i].u.storage.size = istgt_lu_get_filesize(file);
1651: } else {
1652: lu->lun[i].u.storage.size = istgt_lu_parse_size(size);
1653: }
1654: if (lu->lun[i].u.storage.size == 0) {
1655: ISTGT_ERRLOG("LU%d: LUN%d: Auto size error (%s)\n", lu->num, i, file);
1656: goto error_return;
1657: }
1658: lu->lun[i].u.storage.fd = -1;
1659: lu->lun[i].u.storage.file = xstrdup(file);
1660: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
1661: "Storage file=%s, size=%"PRIu64"\n",
1662: lu->lun[i].u.storage.file,
1663: lu->lun[i].u.storage.size);
1664: } else if (strcasecmp(val, "Removable") == 0) {
1665: if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_NONE) {
1666: ISTGT_ERRLOG("LU%d: duplicate LUN%d\n", lu->num, i);
1667: goto error_return;
1668: }
1669: lu->lun[i].type = ISTGT_LU_LUN_TYPE_REMOVABLE;
1670:
1671: flags = istgt_get_nmval(sp, buf, j, 1);
1672: file = istgt_get_nmval(sp, buf, j, 2);
1673: size = istgt_get_nmval(sp, buf, j, 3);
1674: if (flags == NULL || file == NULL || size == NULL) {
1675: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1676: goto error_return;
1677: }
1678: mflags = istgt_lu_parse_media_flags(flags);
1679: msize = istgt_lu_parse_media_size(file, size, &mflags);
1680: if (msize == 0 && strcasecmp(file, "/dev/null") == 0) {
1681: /* empty media */
1682: } else if (msize == 0) {
1683: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1684: goto error_return;
1685: }
1686: lu->lun[i].u.removable.type = 0;
1687: lu->lun[i].u.removable.id = 0;
1688: lu->lun[i].u.removable.fd = -1;
1689: lu->lun[i].u.removable.flags = mflags;
1690: lu->lun[i].u.removable.file = xstrdup(file);
1691: lu->lun[i].u.removable.size = msize;
1692: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
1693: "Removable file=%s, size=%"PRIu64", flags=%x\n",
1694: lu->lun[i].u.removable.file,
1695: lu->lun[i].u.removable.size,
1696: lu->lun[i].u.removable.flags);
1697: } else if (strncasecmp(val, "Slot", 4) == 0) {
1698: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_NONE) {
1699: lu->lun[i].u.slot.maxslot = 0;
1700: for (k = 0; k < MAX_LU_LUN_SLOT; k++) {
1701: lu->lun[i].u.slot.present[k] = 0;
1702: lu->lun[i].u.slot.flags[k] = 0;
1703: lu->lun[i].u.slot.file[k] = NULL;
1704: lu->lun[i].u.slot.size[k] = 0;
1705: }
1706: } else if (lu->lun[i].type != ISTGT_LU_LUN_TYPE_SLOT) {
1707: ISTGT_ERRLOG("LU%d: duplicate LUN%d\n", lu->num, i);
1708: goto error_return;
1709: }
1710: lu->lun[i].type = ISTGT_LU_LUN_TYPE_SLOT;
1711: if (sscanf(val, "%*[^0-9]%d", &slot) != 1) {
1712: ISTGT_ERRLOG("LU%d: slot number error\n", lu->num);
1713: goto error_return;
1714: }
1715: if (slot < 0 || slot >= MAX_LU_LUN_SLOT) {
1716: ISTGT_ERRLOG("LU%d: slot number range error\n", lu->num);
1717: goto error_return;
1718: }
1719: if (lu->lun[i].u.slot.present[slot]) {
1720: ISTGT_ERRLOG("LU%d: duplicate slot %d\n", lu->num, slot);
1721: goto error_return;
1722: }
1723: lu->lun[i].u.slot.present[slot] = 1;
1724: if (slot + 1 > lu->lun[i].u.slot.maxslot) {
1725: lu->lun[i].u.slot.maxslot = slot + 1;
1726: }
1727:
1728: flags = istgt_get_nmval(sp, buf, j, 1);
1729: file = istgt_get_nmval(sp, buf, j, 2);
1730: size = istgt_get_nmval(sp, buf, j, 3);
1731: if (flags == NULL || file == NULL || size == NULL) {
1732: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1733: goto error_return;
1734: }
1735: mflags = istgt_lu_parse_media_flags(flags);
1736: msize = istgt_lu_parse_media_size(file, size, &mflags);
1737: if (msize == 0) {
1738: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1739: goto error_return;
1740: }
1741: lu->lun[i].u.slot.flags[slot] = mflags;
1742: lu->lun[i].u.slot.file[slot] = xstrdup(file);
1743: lu->lun[i].u.slot.size[slot] = msize;
1744: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
1745: "Slot%d file=%s, size=%"PRIu64", flags=%x\n",
1746: slot,
1747: lu->lun[i].u.slot.file[slot],
1748: lu->lun[i].u.slot.size[slot],
1749: lu->lun[i].u.slot.flags[slot]);
1750: } else if (strncasecmp(val, "Option", 6) == 0) {
1751: key = istgt_get_nmval(sp, buf, j, 1);
1752: val = istgt_get_nmval(sp, buf, j, 2);
1753: if (key == NULL || val == NULL) {
1754: ISTGT_ERRLOG("LU%d: LUN%d: format error\n", lu->num, i);
1755: goto error_return;
1756: }
1757: if (strcasecmp(key, "Serial") == 0) {
1758: /* set LUN serial */
1759: if (strlen(val) == 0) {
1760: ISTGT_ERRLOG("LU%d: LUN%d: no serial\n",
1761: lu->num, i);
1762: goto error_return;
1763: }
1764: xfree(lu->lun[i].serial);
1765: lu->lun[i].serial = xstrdup(val);
1766: } else if (strcasecmp(key, "RPM") == 0) {
1767: rpm = (int)strtol(val, NULL, 10);
1768: if (rpm < 0) {
1769: rpm = 0;
1770: } else if (rpm > 0xfffe) {
1771: rpm = 0xfffe;
1772: }
1773: lu->lun[i].rotationrate = rpm;
1774: } else if (strcasecmp(key, "FormFactor") == 0) {
1775: formfactor = (int)strtol(val, NULL, 10);
1776: if (formfactor < 0) {
1777: formfactor = 0;
1778: } else if (formfactor > 0x0f) {
1779: formfactor = 0xf;
1780: }
1781: lu->lun[i].formfactor = formfactor;
1782: } else if (strcasecmp(key, "ReadCache") == 0) {
1783: if (strcasecmp(val, "Enable") == 0) {
1784: lu->lun[i].readcache = 1;
1785: } else if (strcasecmp(val, "Disable") == 0) {
1786: lu->lun[i].readcache = 0;
1787: } else {
1788: ISTGT_ERRLOG("LU%d: LUN%d: unknown val(%s)\n",
1789: lu->num, i, val);
1790: }
1791: } else if (strcasecmp(key, "WriteCache") == 0) {
1792: if (strcasecmp(val, "Enable") == 0) {
1793: lu->lun[i].writecache = 1;
1794: } else if (strcasecmp(val, "Disable") == 0) {
1795: lu->lun[i].writecache = 0;
1796: } else {
1797: ISTGT_ERRLOG("LU%d: LUN%d: unknown val(%s)\n",
1798: lu->num, i, val);
1799: }
1800: } else {
1801: ISTGT_WARNLOG("LU%d: LUN%d: unknown key(%s)\n",
1802: lu->num, i, key);
1803: continue;
1804: }
1805: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LUN%d Option %s => %s\n",
1806: i, key, val);
1807: continue;
1808: } else {
1809: ISTGT_ERRLOG("LU%d: unknown lun type\n", lu->num);
1810: goto error_return;
1811: }
1812: }
1813: if (lu->lun[i].type == ISTGT_LU_LUN_TYPE_SLOT) {
1814: if (lu->lun[i].u.slot.maxslot == 0) {
1815: ISTGT_ERRLOG("LU%d: no slot\n", lu->num);
1816: goto error_return;
1817: }
1818: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "maxslot=%d\n",
1819: lu->lun[i].u.slot.maxslot);
1820: }
1821: lu->maxlun = i + 1;
1822: }
1823: if (lu->maxlun == 0) {
1824: ISTGT_ERRLOG("LU%d: no LUN\n", lu->num);
1825: goto error_return;
1826: }
1827: if (lu->lun[0].type == ISTGT_LU_LUN_TYPE_NONE) {
1828: ISTGT_ERRLOG("LU%d: no LUN0\n", lu->num);
1829: goto error_return;
1830: }
1831:
1832: /* set local values if any */
1833: rc = istgt_lu_set_local_settings(istgt, sp, lu);
1834: if (rc < 0) {
1835: ISTGT_ERRLOG("LU%d: local setting error\n", lu->num);
1836: goto error_return;
1837: }
1838:
1839: /* tsih 0 is reserved */
1840: for (i = 0; i < MAX_LU_TSIH; i++) {
1841: lu->tsih[i].tag = 0;
1842: lu->tsih[i].tsih = 0;
1843: lu->tsih[i].initiator_port = NULL;
1844: }
1845: lu->maxtsih = 1;
1846: lu->last_tsih = 0;
1847:
1848: MTX_LOCK(&istgt->mutex);
1849: istgt->nlogical_unit++;
1850: istgt->logical_unit[lu->num] = lu;
1851: MTX_UNLOCK(&istgt->mutex);
1852: return 0;
1853:
1854: error_return:
1855: xfree(lu->name);
1856: xfree(lu->alias);
1857: xfree(lu->inq_vendor);
1858: xfree(lu->inq_product);
1859: xfree(lu->inq_revision);
1860: for (i = 0; i < MAX_LU_LUN; i++) {
1861: switch (lu->lun[i].type) {
1862: case ISTGT_LU_LUN_TYPE_DEVICE:
1863: xfree(lu->lun[i].u.device.file);
1864: break;
1865: case ISTGT_LU_LUN_TYPE_STORAGE:
1866: xfree(lu->lun[i].u.storage.file);
1867: break;
1868: case ISTGT_LU_LUN_TYPE_REMOVABLE:
1869: xfree(lu->lun[i].u.removable.file);
1870: break;
1871: case ISTGT_LU_LUN_TYPE_SLOT:
1872: for (j = 0; j < lu->lun[i].u.slot.maxslot; j++) {
1873: xfree(lu->lun[i].u.slot.file[j]);
1874: }
1875: break;
1876: case ISTGT_LU_LUN_TYPE_NONE:
1877: default:
1878: break;
1879: }
1880: }
1881: for (i = 0; i < MAX_LU_TSIH; i++) {
1882: xfree(lu->tsih[i].initiator_port);
1883: }
1884: for (i = 0; i < lu->maxmap; i++) {
1885: /* nothing */
1886: }
1887:
1888: xfree(lu);
1889: return -1;
1890: }
1891:
1892: static int
1893: istgt_lu_del_unit(ISTGT_Ptr istgt, ISTGT_LU_Ptr lu)
1894: {
1895: int i, j;
1896:
1897: if (lu ==NULL)
1898: return 0;
1899: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "del unit %d\n", lu->num);
1900:
1901: MTX_LOCK(&istgt->mutex);
1902: istgt->nlogical_unit--;
1903: istgt->logical_unit[lu->num] = NULL;
1904: MTX_UNLOCK(&istgt->mutex);
1905:
1906: xfree(lu->name);
1907: xfree(lu->alias);
1908: xfree(lu->inq_vendor);
1909: xfree(lu->inq_product);
1910: xfree(lu->inq_revision);
1911: xfree(lu->inq_serial);
1912: for (i = 0; i < MAX_LU_LUN; i++) {
1913: xfree(lu->lun[i].serial);
1914: switch (lu->lun[i].type) {
1915: case ISTGT_LU_LUN_TYPE_DEVICE:
1916: xfree(lu->lun[i].u.device.file);
1917: break;
1918: case ISTGT_LU_LUN_TYPE_STORAGE:
1919: xfree(lu->lun[i].u.storage.file);
1920: break;
1921: case ISTGT_LU_LUN_TYPE_REMOVABLE:
1922: xfree(lu->lun[i].u.removable.file);
1923: break;
1924: case ISTGT_LU_LUN_TYPE_SLOT:
1925: for (j = 0; j < lu->lun[i].u.slot.maxslot; j++) {
1926: xfree(lu->lun[i].u.slot.file[j]);
1927: }
1928: break;
1929: case ISTGT_LU_LUN_TYPE_NONE:
1930: default:
1931: break;
1932: }
1933: }
1934: for (i = 0; i < MAX_LU_TSIH; i++) {
1935: xfree(lu->tsih[i].initiator_port);
1936: }
1937: for (i = 0; i < lu->maxmap; i++) {
1938: /* nothing */
1939: }
1940:
1941: return 0;
1942: }
1943:
1944: static void *luworker(void *arg);
1945:
1946: int
1947: istgt_lu_init(ISTGT_Ptr istgt)
1948: {
1949: ISTGT_LU_Ptr lu;
1950: CF_SECTION *sp;
1951: int rc;
1952: int i;
1953:
1954: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_init\n");
1955: sp = istgt_find_cf_section(istgt->config, "Global");
1956: if (sp == NULL) {
1957: ISTGT_ERRLOG("find_cf_section failed()\n");
1958: return -1;
1959: }
1960:
1961: sp = istgt->config->section;
1962: while (sp != NULL) {
1963: if (sp->type == ST_LOGICAL_UNIT) {
1964: if (sp->num == 0) {
1965: ISTGT_ERRLOG("Unit 0 is invalid\n");
1966: return -1;
1967: }
1968: if (sp->num > ISTGT_LU_TAG_MAX) {
1969: ISTGT_ERRLOG("tag %d is invalid\n", sp->num);
1970: return -1;
1971: }
1972: rc = istgt_lu_add_unit(istgt, sp);
1973: if (rc < 0) {
1974: ISTGT_ERRLOG("lu_add_unit() failed\n");
1975: return -1;
1976: }
1977: }
1978: sp = sp->next;
1979: }
1980:
1981: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
1982: lu = istgt->logical_unit[i];
1983: if (lu == NULL)
1984: continue;
1985:
1986: rc = pthread_mutex_init(&lu->mutex, NULL);
1987: if (rc != 0) {
1988: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
1989: return -1;
1990: }
1991: rc = pthread_mutex_init(&lu->state_mutex, NULL);
1992: if (rc != 0) {
1993: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
1994: return -1;
1995: }
1996: rc = pthread_mutex_init(&lu->queue_mutex, NULL);
1997: if (rc != 0) {
1998: ISTGT_ERRLOG("LU%d: mutex_init() failed\n", lu->num);
1999: return -1;
2000: }
2001: rc = pthread_cond_init(&lu->queue_cond, NULL);
2002: if (rc != 0) {
2003: ISTGT_ERRLOG("LU%d: cond_init() failed\n", lu->num);
2004: return -1;
2005: }
2006:
2007: switch (lu->type) {
2008: case ISTGT_LU_TYPE_PASS:
2009: rc = istgt_lu_pass_init(istgt, lu);
2010: if (rc < 0) {
2011: ISTGT_ERRLOG("LU%d: lu_pass_init() failed\n", lu->num);
2012: return -1;
2013: }
2014: break;
2015:
2016: case ISTGT_LU_TYPE_DISK:
2017: rc = istgt_lu_disk_init(istgt, lu);
2018: if (rc < 0) {
2019: ISTGT_ERRLOG("LU%d: lu_disk_init() failed\n", lu->num);
2020: return -1;
2021: }
2022: break;
2023:
2024: case ISTGT_LU_TYPE_DVD:
2025: rc = istgt_lu_dvd_init(istgt, lu);
2026: if (rc < 0) {
2027: ISTGT_ERRLOG("LU%d: lu_dvd_init() failed\n", lu->num);
2028: return -1;
2029: }
2030: break;
2031:
2032: case ISTGT_LU_TYPE_TAPE:
2033: rc = istgt_lu_tape_init(istgt, lu);
2034: if (rc < 0) {
2035: ISTGT_ERRLOG("LU%d: lu_tape_init() failed\n", lu->num);
2036: return -1;
2037: }
2038: break;
2039:
2040: case ISTGT_LU_TYPE_NONE:
2041: //ISTGT_ERRLOG("LU%d: dummy type\n", lu->num);
2042: break;
2043: default:
2044: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2045: return -1;
2046: }
2047:
2048: istgt_lu_set_state(lu, ISTGT_STATE_INITIALIZED);
2049: }
2050:
2051: return 0;
2052: }
2053:
2054: int
2055: istgt_lu_set_all_state(ISTGT_Ptr istgt, ISTGT_STATE state)
2056: {
2057: ISTGT_LU_Ptr lu;
2058: int i;
2059:
2060: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
2061: lu = istgt->logical_unit[i];
2062: if (lu == NULL)
2063: continue;
2064:
2065: istgt_lu_set_state(lu, state);
2066: }
2067:
2068: return 0;
2069: }
2070:
2071: int
2072: istgt_lu_create_threads(ISTGT_Ptr istgt)
2073: {
2074: #ifdef HAVE_PTHREAD_SET_NAME_NP
2075: char buf[MAX_TMPBUF];
2076: #endif
2077: ISTGT_LU_Ptr lu;
2078: int rc;
2079: int i;
2080:
2081: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_create_threads\n");
2082:
2083: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
2084: lu = istgt->logical_unit[i];
2085: if (lu == NULL)
2086: continue;
2087:
2088: if (lu->queue_depth != 0) {
2089: /* create LU thread */
2090: #ifdef ISTGT_STACKSIZE
2091: rc = pthread_create(&lu->thread, &istgt->attr, &luworker, (void *)lu);
2092: #else
2093: rc = pthread_create(&lu->thread, NULL, &luworker, (void *)lu);
2094: #endif
2095: if (rc != 0) {
2096: ISTGT_ERRLOG("pthread_create() failed\n");
2097: return -1;
2098: }
2099: #if 0
2100: rc = pthread_detach(lu->thread);
2101: if (rc != 0) {
2102: ISTGT_ERRLOG("pthread_detach() failed\n");
2103: return -1;
2104: }
2105: #endif
2106: #ifdef HAVE_PTHREAD_SET_NAME_NP
2107: snprintf(buf, sizeof buf, "luthread #%d", i);
2108: pthread_set_name_np(lu->thread, buf);
2109: #endif
2110: }
2111: }
2112:
2113: return 0;
2114: }
2115:
2116: int
2117: istgt_lu_shutdown(ISTGT_Ptr istgt)
2118: {
2119: ISTGT_LU_Ptr lu;
2120: int rc;
2121: int i;
2122:
2123: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_lu_shutdown\n");
2124:
2125: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
2126: lu = istgt->logical_unit[i];
2127: if (lu == NULL)
2128: continue;
2129: istgt_lu_set_state(lu, ISTGT_STATE_SHUTDOWN);
2130:
2131: switch (lu->type) {
2132: case ISTGT_LU_TYPE_PASS:
2133: rc = istgt_lu_pass_shutdown(istgt, lu);
2134: if (rc < 0) {
2135: ISTGT_ERRLOG("LU%d: lu_pass_shutdown() failed\n", lu->num);
2136: /* ignore error */
2137: }
2138: break;
2139:
2140: case ISTGT_LU_TYPE_DISK:
2141: rc = istgt_lu_disk_shutdown(istgt, lu);
2142: if (rc < 0) {
2143: ISTGT_ERRLOG("LU%d: lu_disk_shutdown() failed\n", lu->num);
2144: /* ignore error */
2145: }
2146: break;
2147:
2148: case ISTGT_LU_TYPE_DVD:
2149: rc = istgt_lu_dvd_shutdown(istgt, lu);
2150: if (rc < 0) {
2151: ISTGT_ERRLOG("LU%d: lu_dvd_shutdown() failed\n", lu->num);
2152: /* ignore error */
2153: }
2154: break;
2155:
2156: case ISTGT_LU_TYPE_TAPE:
2157: rc = istgt_lu_tape_shutdown(istgt, lu);
2158: if (rc < 0) {
2159: ISTGT_ERRLOG("LU%d: lu_tape_shutdown() failed\n", lu->num);
2160: /* ignore error */
2161: }
2162: break;
2163:
2164: case ISTGT_LU_TYPE_NONE:
2165: //ISTGT_ERRLOG("LU%d: dummy type\n", lu->num);
2166: break;
2167: default:
2168: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2169: return -1;
2170: }
2171:
2172: rc = istgt_lu_del_unit(istgt, lu);
2173: if (rc < 0) {
2174: ISTGT_ERRLOG("LU%d: lu_del_unit() failed\n", lu->num);
2175: /* ignore error */
2176: }
2177:
2178: if (lu->queue_depth != 0) {
2179: rc = pthread_cond_broadcast(&lu->queue_cond);
2180: if (rc != 0) {
2181: ISTGT_ERRLOG("LU%d: cond_broadcast() failed\n", lu->num);
2182: }
2183: rc = pthread_join(lu->thread, NULL);
2184: if (rc != 0) {
2185: ISTGT_ERRLOG("LU%d: pthread_join() failed\n", lu->num);
2186: }
2187: }
2188: rc = pthread_cond_destroy(&lu->queue_cond);
2189: if (rc != 0) {
2190: ISTGT_ERRLOG("LU%d: cond_destroy() failed\n", lu->num);
2191: /* ignore error */
2192: }
2193: rc = pthread_mutex_destroy(&lu->queue_mutex);
2194: if (rc != 0) {
2195: ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
2196: /* ignore error */
2197: }
2198: rc = pthread_mutex_destroy(&lu->state_mutex);
2199: if (rc != 0) {
2200: ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
2201: /* ignore error */
2202: }
2203: rc = pthread_mutex_destroy(&lu->mutex);
2204: if (rc != 0) {
2205: ISTGT_ERRLOG("LU%d: mutex_destroy() failed\n", lu->num);
2206: /* ignore error */
2207: }
2208: xfree(lu);
2209: istgt->logical_unit[i] = NULL;
2210: }
2211:
2212: return 0;
2213: }
2214:
2215: int
2216: istgt_lu_islun2lun(uint64_t islun)
2217: {
2218: uint64_t fmt_lun;
2219: uint64_t method;
2220: int lun_i;
2221:
2222: fmt_lun = islun;
2223: method = (fmt_lun >> 62) & 0x03U;
2224: fmt_lun = fmt_lun >> 48;
2225: if (method == 0x00U) {
2226: lun_i = (int) (fmt_lun & 0x00ffU);
2227: } else if (method == 0x01U) {
2228: lun_i = (int) (fmt_lun & 0x3fffU);
2229: } else {
2230: lun_i = 0xffffU;
2231: }
2232: return lun_i;
2233: }
2234:
2235: uint64_t
2236: istgt_lu_lun2islun(int lun, int maxlun)
2237: {
2238: uint64_t fmt_lun;
2239: uint64_t method;
2240: uint64_t islun;
2241:
2242: islun = (uint64_t) lun;
2243: if (maxlun <= 0x0100) {
2244: /* below 256 */
2245: method = 0x00U;
2246: fmt_lun = (method & 0x03U) << 62;
2247: fmt_lun |= (islun & 0x00ffU) << 48;
2248: } else if (maxlun <= 0x4000U) {
2249: /* below 16384 */
2250: method = 0x01U;
2251: fmt_lun = (method & 0x03U) << 62;
2252: fmt_lun |= (islun & 0x3fffU) << 48;
2253: } else {
2254: /* XXX */
2255: fmt_lun = ~((uint64_t) 0);
2256: }
2257: return fmt_lun;
2258: }
2259:
2260: int
2261: istgt_lu_reset(ISTGT_LU_Ptr lu, uint64_t lun)
2262: {
2263: int lun_i;
2264: int rc;
2265:
2266: if (lu == NULL)
2267: return -1;
2268:
2269: lun_i = istgt_lu_islun2lun(lun);
2270:
2271: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d: Name=%s, LUN=%d\n",
2272: lu->num, lu->name, lun_i);
2273:
2274: switch (lu->type) {
2275: case ISTGT_LU_TYPE_PASS:
2276: MTX_LOCK(&lu->mutex);
2277: rc = istgt_lu_pass_reset(lu, lun_i);
2278: MTX_UNLOCK(&lu->mutex);
2279: if (rc < 0) {
2280: ISTGT_ERRLOG("LU%d: lu_pass_reset() failed\n", lu->num);
2281: return -1;
2282: }
2283: break;
2284:
2285: case ISTGT_LU_TYPE_DISK:
2286: MTX_LOCK(&lu->mutex);
2287: rc = istgt_lu_disk_reset(lu, lun_i);
2288: MTX_UNLOCK(&lu->mutex);
2289: if (rc < 0) {
2290: ISTGT_ERRLOG("LU%d: lu_disk_reset() failed\n", lu->num);
2291: return -1;
2292: }
2293: break;
2294:
2295: case ISTGT_LU_TYPE_DVD:
2296: MTX_LOCK(&lu->mutex);
2297: rc = istgt_lu_dvd_reset(lu, lun_i);
2298: MTX_UNLOCK(&lu->mutex);
2299: if (rc < 0) {
2300: ISTGT_ERRLOG("LU%d: lu_dvd_reset() failed\n", lu->num);
2301: return -1;
2302: }
2303: break;
2304:
2305: case ISTGT_LU_TYPE_TAPE:
2306: MTX_LOCK(&lu->mutex);
2307: rc = istgt_lu_tape_reset(lu, lun_i);
2308: MTX_UNLOCK(&lu->mutex);
2309: if (rc < 0) {
2310: ISTGT_ERRLOG("LU%d: lu_tape_reset() failed\n", lu->num);
2311: return -1;
2312: }
2313: break;
2314:
2315: case ISTGT_LU_TYPE_NONE:
2316: //ISTGT_ERRLOG("LU%d: dummy type\n", lu->num);
2317: break;
2318: default:
2319: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2320: return -1;
2321: }
2322:
2323: return 0;
2324: }
2325:
2326: int
2327: istgt_lu_execute(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
2328: {
2329: ISTGT_LU_Ptr lu;
2330: int rc;
2331:
2332: if (lu_cmd == NULL)
2333: return -1;
2334: lu = lu_cmd->lu;
2335: if (lu == NULL)
2336: return -1;
2337:
2338: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
2339: "LU%d: PG=0x%4.4x, Name=%s, LUN=0x%16.16"PRIx64"\n",
2340: lu->num, conn->portal.tag, lu->name, lu_cmd->lun);
2341:
2342: if (lu->online == 0) {
2343: ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "LU%d: offline\n", lu->num);
2344: /* LOGICAL UNIT NOT READY, CAUSE NOT REPORTABLE */
2345: lu_cmd->sense_data_len
2346: = istgt_lu_scsi_build_sense_data(lu_cmd->sense_data,
2347: ISTGT_SCSI_SENSE_NOT_READY,
2348: 0x04, 0x00);
2349: lu_cmd->status = ISTGT_SCSI_STATUS_CHECK_CONDITION;
2350: return 0;
2351: }
2352:
2353: rc = 0;
2354: switch (lu->type) {
2355: case ISTGT_LU_TYPE_PASS:
2356: MTX_LOCK(&lu->mutex);
2357: rc = istgt_lu_pass_execute(conn, lu_cmd);
2358: MTX_UNLOCK(&lu->mutex);
2359: if (rc < 0) {
2360: ISTGT_ERRLOG("LU%d: lu_pass_execute() failed\n",
2361: lu->num);
2362: return -1;
2363: }
2364: break;
2365:
2366: case ISTGT_LU_TYPE_DISK:
2367: if (lu->queue_depth != 0) {
2368: //MTX_LOCK(&lu->queue_mutex);
2369: rc = istgt_lu_disk_queue(conn, lu_cmd);
2370: //MTX_UNLOCK(&lu->queue_mutex);
2371: if (rc < 0) {
2372: ISTGT_ERRLOG("LU%d: lu_disk_queue() failed\n",
2373: lu->num);
2374: return -1;
2375: }
2376: } else {
2377: MTX_LOCK(&lu->mutex);
2378: rc = istgt_lu_disk_execute(conn, lu_cmd);
2379: MTX_UNLOCK(&lu->mutex);
2380: if (rc < 0) {
2381: ISTGT_ERRLOG("LU%d: lu_disk_execute() failed\n",
2382: lu->num);
2383: return -1;
2384: }
2385: }
2386: break;
2387:
2388: case ISTGT_LU_TYPE_DVD:
2389: MTX_LOCK(&lu->mutex);
2390: rc = istgt_lu_dvd_execute(conn, lu_cmd);
2391: MTX_UNLOCK(&lu->mutex);
2392: if (rc < 0) {
2393: ISTGT_ERRLOG("LU%d: lu_dvd_execute() failed\n",
2394: lu->num);
2395: return -1;
2396: }
2397: break;
2398:
2399: case ISTGT_LU_TYPE_TAPE:
2400: MTX_LOCK(&lu->mutex);
2401: rc = istgt_lu_tape_execute(conn, lu_cmd);
2402: MTX_UNLOCK(&lu->mutex);
2403: if (rc < 0) {
2404: ISTGT_ERRLOG("LU%d: lu_tape_execute() failed\n",
2405: lu->num);
2406: return -1;
2407: }
2408: break;
2409:
2410: case ISTGT_LU_TYPE_NONE:
2411: //ISTGT_ERRLOG("LU%d: dummy type\n", lu->num);
2412: break;
2413: default:
2414: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2415: return -1;
2416: }
2417:
2418: return rc;
2419: }
2420:
2421: int
2422: istgt_lu_create_task(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, ISTGT_LU_TASK_Ptr lu_task, int lun)
2423: {
2424: ISCSI_PDU_Ptr dst_pdu, src_pdu;
2425: uint8_t *cdb;
2426: int alloc_len;
2427: #if 0
2428: int rc;
2429: #endif
2430:
2431: if (lu_task == NULL)
2432: return -1;
2433:
2434: lu_task->type = ISTGT_LU_TASK_RESPONSE;
2435: lu_task->conn = conn;
2436: strncpy(lu_task->initiator_name, conn->initiator_name,
2437: sizeof lu_task->initiator_name);
2438: strncpy(lu_task->initiator_port, conn->initiator_port,
2439: sizeof lu_task->initiator_port);
2440:
2441: lu_task->lun = (int) lun;
2442: lu_task->use_cond = 0;
2443: lu_task->dup_iobuf = 0;
2444: lu_task->iobuf = NULL;
2445: lu_task->data = NULL;
2446: lu_task->sense_data = NULL;
2447: lu_task->create_time = 0;
2448: lu_task->condwait = 0;
2449: lu_task->offset = 0;
2450: lu_task->req_execute = 0;
2451: lu_task->req_transfer_out = 0;
2452: lu_task->error = 0;
2453: lu_task->abort = 0;
2454: lu_task->execute = 0;
2455: lu_task->complete = 0;
2456: lu_task->lock = 0;
2457:
2458: #if 0
2459: rc = pthread_mutex_init(&lu_task->trans_mutex, NULL);
2460: if (rc != 0) {
2461: ISTGT_ERRLOG("mutex_init() failed\n");
2462: return -1;
2463: }
2464: rc = pthread_cond_init(&lu_task->trans_cond, NULL);
2465: if (rc != 0) {
2466: ISTGT_ERRLOG("cond_init() failed\n");
2467: return -1;
2468: }
2469: rc = pthread_cond_init(&lu_task->exec_cond, NULL);
2470: if (rc != 0) {
2471: ISTGT_ERRLOG("cond_init() failed\n");
2472: return -1;
2473: }
2474: #endif
2475:
2476: lu_task->lu_cmd.pdu = xmalloc(sizeof *lu_task->lu_cmd.pdu);
2477: memset(lu_task->lu_cmd.pdu, 0, sizeof *lu_task->lu_cmd.pdu);
2478:
2479: /* copy PDU */
2480: dst_pdu = lu_task->lu_cmd.pdu;
2481: src_pdu = lu_cmd->pdu;
2482: memcpy(&dst_pdu->bhs, &src_pdu->bhs, ISCSI_BHS_LEN);
2483: dst_pdu->ahs = src_pdu->ahs;
2484: memcpy(dst_pdu->header_digest, src_pdu->header_digest, ISCSI_DIGEST_LEN);
2485: if (src_pdu->data == src_pdu->shortdata) {
2486: memcpy(dst_pdu->shortdata, src_pdu->shortdata,
2487: sizeof src_pdu->shortdata);
2488: dst_pdu->data = dst_pdu->shortdata;
2489: } else {
2490: dst_pdu->data = src_pdu->data;
2491: }
2492: memcpy(dst_pdu->data_digest, src_pdu->data_digest, ISCSI_DIGEST_LEN);
2493: dst_pdu->total_ahs_len = src_pdu->total_ahs_len;
2494: dst_pdu->data_segment_len = src_pdu->data_segment_len;
2495: dst_pdu->copy_pdu = 0;
2496: src_pdu->copy_pdu = 1;
2497:
2498: /* copy other lu_cmd */
2499: lu_task->lu_cmd.lu = lu_cmd->lu;
2500: cdb = ((uint8_t *) &lu_task->lu_cmd.pdu->bhs) + 32;
2501: lu_task->lu_cmd.I_bit = lu_cmd->I_bit;
2502: lu_task->lu_cmd.F_bit = lu_cmd->F_bit;
2503: lu_task->lu_cmd.R_bit = lu_cmd->R_bit;
2504: lu_task->lu_cmd.W_bit = lu_cmd->W_bit;
2505: lu_task->lu_cmd.Attr_bit = lu_cmd->Attr_bit;
2506: lu_task->lu_cmd.lun = lu_cmd->lun;
2507: lu_task->lu_cmd.task_tag = lu_cmd->task_tag;
2508: lu_task->lu_cmd.transfer_len = lu_cmd->transfer_len;
2509: //lu_task->lu_cmd.cdb = lu_cmd->cdb;
2510: lu_task->lu_cmd.cdb = cdb;
2511: lu_task->lu_cmd.CmdSN = lu_cmd->CmdSN;
2512:
2513: //lu_task->lu_cmd.iobuf = lu_cmd->iobuf;
2514: lu_task->lu_cmd.iobuf = NULL;
2515: lu_task->lu_cmd.iobufsize = lu_cmd->iobufsize;
2516: lu_task->lu_cmd.data = lu_cmd->data;
2517: lu_task->lu_cmd.data_len = lu_cmd->data_len;
2518: lu_task->lu_cmd.alloc_len = lu_cmd->alloc_len;
2519:
2520: lu_task->lu_cmd.status = lu_cmd->status;
2521: lu_task->lu_cmd.sense_data = lu_cmd->sense_data;
2522: lu_task->lu_cmd.sense_data_len = lu_cmd->sense_data_len;
2523: lu_task->lu_cmd.sense_alloc_len = lu_cmd->sense_alloc_len;
2524:
2525: /* pre allocate buffer */
2526: lu_task->lu_cmd.iobufsize = lu_cmd->transfer_len + 65536;
2527: #if 0
2528: lu_task->data = xmalloc(lu_cmd->alloc_len);
2529: lu_task->sense_data = xmalloc(lu_cmd->sense_alloc_len);
2530: lu_task->iobuf = xmalloc(lu_task->lu_cmd.iobufsize);
2531: #else
2532: alloc_len = ISCSI_ALIGN(lu_cmd->alloc_len);
2533: alloc_len += ISCSI_ALIGN(lu_cmd->sense_alloc_len);
2534: alloc_len += ISCSI_ALIGN(lu_task->lu_cmd.iobufsize);
2535: lu_task->data = xmalloc(alloc_len);
2536: lu_task->sense_data = lu_task->data + ISCSI_ALIGN(lu_cmd->alloc_len);
2537: lu_task->iobuf = lu_task->sense_data + ISCSI_ALIGN(lu_cmd->sense_alloc_len);
2538: #endif
2539:
2540: /* creation time */
2541: lu_task->create_time = time(NULL);
2542: /* wait time */
2543: lu_task->condwait = conn->timeout * 1000;
2544: if (lu_task->condwait < ISTGT_CONDWAIT_MIN) {
2545: lu_task->condwait = ISTGT_CONDWAIT_MIN;
2546: }
2547:
2548: return 0;
2549: }
2550:
2551: int
2552: istgt_lu_destroy_task(ISTGT_LU_TASK_Ptr lu_task)
2553: {
2554: int rc;
2555:
2556: if (lu_task == NULL)
2557: return -1;
2558:
2559: if (lu_task->use_cond != 0) {
2560: rc = pthread_mutex_destroy(&lu_task->trans_mutex);
2561: if (rc != 0) {
2562: ISTGT_ERRLOG("mutex_destroy() failed\n");
2563: return -1;
2564: }
2565: rc = pthread_cond_destroy(&lu_task->trans_cond);
2566: if (rc != 0) {
2567: ISTGT_ERRLOG("cond_destroy() failed\n");
2568: return -1;
2569: }
2570: rc = pthread_cond_destroy(&lu_task->exec_cond);
2571: if (rc != 0) {
2572: ISTGT_ERRLOG("cond_destroy() failed\n");
2573: return -1;
2574: }
2575: }
2576: if (lu_task->lu_cmd.pdu != NULL) {
2577: if (lu_task->lu_cmd.pdu->copy_pdu == 0) {
2578: xfree(lu_task->lu_cmd.pdu->ahs);
2579: if (lu_task->lu_cmd.pdu->data
2580: != lu_task->lu_cmd.pdu->shortdata) {
2581: xfree(lu_task->lu_cmd.pdu->data);
2582: }
2583: }
2584: xfree(lu_task->lu_cmd.pdu);
2585: }
2586: #if 0
2587: if (lu_task->dup_iobuf == 0) {
2588: xfree(lu_task->iobuf);
2589: }
2590: xfree(lu_task->data);
2591: xfree(lu_task->sense_data);
2592: #else
2593: xfree(lu_task->data);
2594: #endif
2595: xfree(lu_task);
2596: return 0;
2597: }
2598:
2599: int
2600: istgt_lu_clear_task_IT(CONN_Ptr conn, ISTGT_LU_Ptr lu)
2601: {
2602: int rc;
2603:
2604: if (lu == NULL)
2605: return -1;
2606:
2607: if (lu->queue_depth == 0)
2608: return 0;
2609:
2610: rc = 0;
2611: switch (lu->type) {
2612: case ISTGT_LU_TYPE_DISK:
2613: MTX_LOCK(&lu->mutex);
2614: rc = istgt_lu_disk_queue_clear_IT(conn, lu);
2615: MTX_UNLOCK(&lu->mutex);
2616: if (rc < 0) {
2617: ISTGT_ERRLOG("LU%d: lu_disk_queue_clear_IT() failed\n", lu->num);
2618: return -1;
2619: }
2620: break;
2621:
2622: case ISTGT_LU_TYPE_DVD:
2623: case ISTGT_LU_TYPE_TAPE:
2624: case ISTGT_LU_TYPE_NONE:
2625: default:
2626: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2627: return -1;
2628: }
2629:
2630: return 0;
2631: }
2632:
2633: int
2634: istgt_lu_clear_task_ITL(CONN_Ptr conn, ISTGT_LU_Ptr lu, uint64_t lun)
2635: {
2636: int lun_i;
2637: int rc;
2638:
2639: if (lu == NULL)
2640: return -1;
2641:
2642: if (lu->queue_depth == 0)
2643: return 0;
2644:
2645: lun_i = istgt_lu_islun2lun(lun);
2646:
2647: rc = 0;
2648: switch (lu->type) {
2649: case ISTGT_LU_TYPE_DISK:
2650: MTX_LOCK(&lu->mutex);
2651: rc = istgt_lu_disk_queue_clear_ITL(conn, lu, lun_i);
2652: MTX_UNLOCK(&lu->mutex);
2653: if (rc < 0) {
2654: ISTGT_ERRLOG("LU%d: lu_disk_queue_clear_ITL() failed\n", lu->num);
2655: return -1;
2656: }
2657: break;
2658:
2659: case ISTGT_LU_TYPE_DVD:
2660: case ISTGT_LU_TYPE_TAPE:
2661: case ISTGT_LU_TYPE_NONE:
2662: default:
2663: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2664: return -1;
2665: }
2666:
2667: return 0;
2668: }
2669:
2670: int
2671: istgt_lu_clear_task_ITLQ(CONN_Ptr conn, ISTGT_LU_Ptr lu, uint64_t lun, uint32_t CmdSN)
2672: {
2673: int lun_i;
2674: int rc;
2675:
2676: if (lu == NULL)
2677: return -1;
2678:
2679: if (lu->queue_depth == 0)
2680: return 0;
2681:
2682: lun_i = istgt_lu_islun2lun(lun);
2683:
2684: rc = 0;
2685: switch (lu->type) {
2686: case ISTGT_LU_TYPE_DISK:
2687: MTX_LOCK(&lu->mutex);
2688: rc = istgt_lu_disk_queue_clear_ITLQ(conn, lu, lun_i, CmdSN);
2689: MTX_UNLOCK(&lu->mutex);
2690: if (rc < 0) {
2691: ISTGT_ERRLOG("LU%d: lu_disk_queue_clear_ITLQ() failed\n", lu->num);
2692: return -1;
2693: }
2694: break;
2695:
2696: case ISTGT_LU_TYPE_DVD:
2697: case ISTGT_LU_TYPE_TAPE:
2698: case ISTGT_LU_TYPE_NONE:
2699: default:
2700: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2701: return -1;
2702: }
2703:
2704: return 0;
2705: }
2706:
2707: int
2708: istgt_lu_clear_all_task(ISTGT_LU_Ptr lu, uint64_t lun)
2709: {
2710: int rc;
2711:
2712: if (lu == NULL)
2713: return -1;
2714:
2715: if (lu->queue_depth == 0)
2716: return 0;
2717:
2718: rc = 0;
2719: switch (lu->type) {
2720: case ISTGT_LU_TYPE_DISK:
2721: MTX_LOCK(&lu->mutex);
2722: rc = istgt_lu_disk_queue_clear_all(lu, lun);
2723: MTX_UNLOCK(&lu->mutex);
2724: if (rc < 0) {
2725: ISTGT_ERRLOG("LU%d: lu_disk_queue_clear_all() failed\n", lu->num);
2726: return -1;
2727: }
2728: break;
2729:
2730: case ISTGT_LU_TYPE_DVD:
2731: case ISTGT_LU_TYPE_TAPE:
2732: case ISTGT_LU_TYPE_NONE:
2733: default:
2734: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2735: return -1;
2736: }
2737:
2738: return 0;
2739: }
2740:
2741: static void *
2742: luworker(void *arg)
2743: {
2744: ISTGT_LU_Ptr lu = (ISTGT_LU_Ptr) arg;
2745: sigset_t signew, sigold;
2746: #if 0
2747: struct timespec abstime;
2748: time_t now;
2749: int timeout = 20; /* XXX */
2750: #endif
2751: int qcnt;
2752: int lun;
2753: int rc;
2754:
2755: sigemptyset(&signew);
2756: sigemptyset(&sigold);
2757: sigaddset(&signew, ISTGT_SIGWAKEUP);
2758: pthread_sigmask(SIG_UNBLOCK, &signew, &sigold);
2759:
2760: while (istgt_get_state(lu->istgt) != ISTGT_STATE_RUNNING) {
2761: if (istgt_get_state(lu->istgt) == ISTGT_STATE_EXITING
2762: || istgt_get_state(lu->istgt) == ISTGT_STATE_SHUTDOWN) {
2763: ISTGT_ERRLOG("exit before running\n");
2764: return NULL;
2765: }
2766: //ISTGT_WARNLOG("Wait for running\n");
2767: sleep(1);
2768: continue;
2769: }
2770:
2771: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d loop start\n", lu->num);
2772: lun = 0;
2773: qcnt = 0;
2774: #if 0
2775: memset(&abstime, 0, sizeof abstime);
2776: #endif
2777: while (1) {
2778: switch (lu->type) {
2779: case ISTGT_LU_TYPE_DISK:
2780: while (1) {
2781: if (istgt_lu_get_state(lu) != ISTGT_STATE_RUNNING) {
2782: goto loop_exit;
2783: }
2784: MTX_LOCK(&lu->queue_mutex);
2785: qcnt = istgt_lu_disk_queue_count(lu, &lun);
2786: if (qcnt == 0) {
2787: #if 0
2788: now = time(NULL);
2789: abstime.tv_sec = now + timeout;
2790: abstime.tv_nsec = 0;
2791: rc = pthread_cond_timedwait(&lu->queue_cond,
2792: &lu->queue_mutex, &abstime);
2793: if (rc == ETIMEDOUT) {
2794: /* nothing */
2795: }
2796: #else
2797: pthread_cond_wait(&lu->queue_cond,
2798: &lu->queue_mutex);
2799: #endif
2800: qcnt = istgt_lu_disk_queue_count(lu, &lun);
2801: if (qcnt == 0) {
2802: MTX_UNLOCK(&lu->queue_mutex);
2803: continue;
2804: }
2805: }
2806: MTX_UNLOCK(&lu->queue_mutex);
2807: break;
2808: }
2809: if (qcnt < 0) {
2810: ISTGT_ERRLOG("LU%d: lu_disk_queue_count() failed\n",
2811: lu->num);
2812: break;
2813: }
2814: rc = istgt_lu_disk_queue_start(lu, lun);
2815: lun++;
2816: if (rc == -2) {
2817: ISTGT_WARNLOG("LU%d: lu_disk_queue_start() aborted\n",
2818: lu->num);
2819: break;
2820: }
2821: if (rc < 0) {
2822: ISTGT_ERRLOG("LU%d: lu_disk_queue_start() failed\n",
2823: lu->num);
2824: break;
2825: }
2826: break;
2827:
2828: case ISTGT_LU_TYPE_DVD:
2829: case ISTGT_LU_TYPE_TAPE:
2830: case ISTGT_LU_TYPE_NONE:
2831: default:
2832: ISTGT_ERRLOG("LU%d: unsupported type\n", lu->num);
2833: return NULL;
2834: }
2835:
2836: #if 0
2837: /* still running? */
2838: if (qcnt <= 1) {
2839: if (istgt_lu_get_state(lu) != ISTGT_STATE_RUNNING) {
2840: goto loop_exit;
2841: }
2842: }
2843: #endif
2844: }
2845: loop_exit:
2846: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "LU%d loop ended\n", lu->num);
2847:
2848: return NULL;
2849: }