1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
|
/*
* Copyright (c) 2004-2018 Douglas Gilbert.
* All rights reserved.
* Use of this source code is governed by a BSD-style
* license that can be found in the BSD_LICENSE file.
*/
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <getopt.h>
#define __STDC_FORMAT_MACROS 1
#include <inttypes.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "sg_lib.h"
#include "sg_cmds_basic.h"
#include "sg_unaligned.h"
#include "sg_pr2serr.h"
/* A utility program originally written for the Linux OS SCSI subsystem.
*
*
* This program issues the SCSI REPORT LUNS command to the given SCSI device
* and decodes the response.
*/
static const char * version_str = "1.42 20180626";
#define MAX_RLUNS_BUFF_LEN (1024 * 1024)
#define DEF_RLUNS_BUFF_LEN (1024 * 8)
static struct option long_options[] = {
{"decode", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"hex", no_argument, 0, 'H'},
#ifdef SG_LIB_LINUX
{"linux", no_argument, 0, 'l'},
#endif
{"lu_cong", no_argument, 0, 'L'},
{"lu-cong", no_argument, 0, 'L'},
{"maxlen", required_argument, 0, 'm'},
{"quiet", no_argument, 0, 'q'},
{"raw", no_argument, 0, 'r'},
{"readonly", no_argument, 0, 'R'},
{"select", required_argument, 0, 's'},
{"test", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{0, 0, 0, 0},
};
static void
usage()
{
#ifdef SG_LIB_LINUX
pr2serr("Usage: sg_luns [--decode] [--help] [--hex] [--linux] "
"[--lu_cong]\n"
" [--maxlen=LEN] [--quiet] [--raw] "
"[--readonly]\n"
" [--select=SR] [--verbose] [--version] "
"DEVICE\n");
#else
pr2serr("Usage: sg_luns [--decode] [--help] [--hex] [--lu_cong] "
"[--maxlen=LEN]\n"
" [--quiet] [--raw] [--readonly] "
"[--select=SR]\n"
" [--verbose] [--version] DEVICE\n");
#endif
pr2serr(" or\n"
" sg_luns --test=ALUN [--decode] [--hex] [--lu_cong] "
"[--verbose]\n"
" where:\n"
" --decode|-d decode all luns into component parts\n"
" --help|-h print out usage message\n"
" --hex|-H output response in hexadecimal; used "
"twice\n"
" shows decoded values in hex\n");
#ifdef SG_LIB_LINUX
pr2serr(" --linux|-l show Linux integer lun after T10 "
"representation\n");
#endif
pr2serr(" --lu_cong|-L decode as if LU_CONG is set; used "
"twice:\n"
" decode as if LU_CONG is clear\n"
" --maxlen=LEN|-m LEN max response length (allocation "
"length in cdb)\n"
" (def: 0 -> %d bytes)\n"
" --quiet|-q output only ASCII hex lun values\n"
" --raw|-r output response in binary\n"
" --readonly|-R open DEVICE read-only (def: read-write)\n"
" --select=SR|-s SR select report SR (def: 0)\n"
" 0 -> luns apart from 'well "
"known' lus\n"
" 1 -> only 'well known' "
"logical unit numbers\n"
" 2 -> all luns\n"
" 0x10 -> administrative luns\n"
" 0x11 -> admin luns + "
"non-conglomerate luns\n"
" 0x12 -> admin lun + its "
"subsidiary luns\n"
" --test=ALUN|-t ALUN decode ALUN and ignore most other "
"options\n"
" and DEVICE (apart from '-H')\n"
" --verbose|-v increase verbosity\n"
" --version|-V print version string and exit\n\n"
"Performs a SCSI REPORT LUNS command or decodes the given ALUN. "
"When SR is\n0x10 or 0x11 DEVICE must be LUN 0 or REPORT LUNS "
"well known logical unit;\nwhen SR is 0x12 DEVICE must be an "
"administrative logical unit. When the\n--test=ALUN option is "
"given, decodes ALUN rather than sending a REPORT\nLUNS "
"command.\n", DEF_RLUNS_BUFF_LEN );
}
/* Decoded according to SAM-5 rev 10. Note that one draft: BCC rev 0,
* defines its own "bridge addressing method" in place of the SAM-3
* "logical addressing method". */
static void
decode_lun(const char * leadin, const uint8_t * lunp, bool lu_cong,
int do_hex, int verbose)
{
bool next_level, admin_lu_cong;
int k, x, a_method, bus_id, target, lun, len_fld, e_a_method;
uint64_t ull;
char l_leadin[128];
char b[256];
if (0xff == lunp[0]) {
printf("%sLogical unit _not_ specified\n", leadin);
return;
}
admin_lu_cong = lu_cong;
memset(l_leadin, 0, sizeof(l_leadin));
for (k = 0; k < 4; ++k, lunp += 2) {
next_level = false;
strncpy(l_leadin, leadin, sizeof(l_leadin) - 3);
if (k > 0) {
if (lu_cong) {
admin_lu_cong = false;
if ((0 == lunp[0]) && (0 == lunp[1])) {
printf("%s>>>> Administrative LU\n", l_leadin);
if (do_hex || verbose)
printf(" since Subsidiary element is "
"0x0000\n");
break;
} else
printf("%s>>Subsidiary element:\n", l_leadin);
} else
printf("%s>>%s level addressing:\n", l_leadin, ((1 == k) ?
"Second" : ((2 == k) ? "Third" : "Fourth")));
strcat(l_leadin, " ");
} else if (lu_cong) {
printf("%s>>Administrative element:\n", l_leadin);
strcat(l_leadin, " ");
}
a_method = (lunp[0] >> 6) & 0x3;
switch (a_method) {
case 0: /* peripheral device addressing method */
if (lu_cong) {
snprintf(b, sizeof(b), "%sSimple lu addressing: ",
l_leadin);
x = 0x3fff & sg_get_unaligned_be16(lunp + 0);
if (do_hex)
printf("%s0x%04x\n", b, x);
else
printf("%s%d\n", b, x);
if (admin_lu_cong)
next_level = true;
} else {
bus_id = lunp[0] & 0x3f;
snprintf(b, sizeof(b), "%sPeripheral device addressing: ",
l_leadin);
if ((0 == bus_id) && (0 == verbose)) {
if (do_hex)
printf("%slun=0x%02x\n", b, lunp[1]);
else
printf("%slun=%d\n", b, lunp[1]);
} else {
if (do_hex)
printf("%sbus_id=0x%02x, %s=0x%02x\n", b, bus_id,
(bus_id ? "target" : "lun"), lunp[1]);
else
printf("%sbus_id=%d, %s=%d\n", b, bus_id,
(bus_id ? "target" : "lun"), lunp[1]);
}
if (bus_id)
next_level = true;
}
break;
case 1: /* flat space addressing method */
lun = 0x3fff & sg_get_unaligned_be16(lunp + 0);
if (lu_cong) {
printf("%sSince LU_CONG=1, unexpected Flat space "
"addressing: lun=0x%04x\n", l_leadin, lun);
break;
}
if (do_hex)
printf("%sFlat space addressing: lun=0x%04x\n", l_leadin,
lun);
else
printf("%sFlat space addressing: lun=%d\n", l_leadin, lun);
break;
case 2: /* logical unit addressing method */
target = (lunp[0] & 0x3f);
bus_id = (lunp[1] >> 5) & 0x7;
lun = lunp[1] & 0x1f;
if (lu_cong) {
printf("%sSince LU_CONG=1, unexpected lu addressing: "
"bus_id=0x%x, target=0x%02x, lun=0x%02x\n", l_leadin,
bus_id, target, lun);
break;
}
if (do_hex)
printf("%sLogical unit addressing: bus_id=0x%x, "
"target=0x%02x, lun=0x%02x\n", l_leadin, bus_id,
target, lun);
else
printf("%sLogical unit addressing: bus_id=%d, target=%d, "
"lun=%d\n", l_leadin, bus_id, target, lun);
break;
case 3: /* extended logical unit + flat space addressing */
len_fld = (lunp[0] & 0x30) >> 4;
e_a_method = lunp[0] & 0xf;
x = lunp[1];
if ((0 == len_fld) && (1 == e_a_method)) {
snprintf(b, sizeof(b), "well known logical unit");
switch (x) {
case 1:
printf("%sREPORT LUNS %s\n", l_leadin, b);
break;
case 2: /* obsolete in spc5r01 */
printf("%sACCESS CONTROLS %s\n", l_leadin, b);
break;
case 3:
printf("%sTARGET LOG PAGES %s\n", l_leadin, b);
break;
case 4:
printf("%sSECURITY PROTOCOL %s\n", l_leadin, b);
break;
case 5:
printf("%sMANAGEMENT PROTOCOL %s\n", l_leadin, b);
break;
default:
if (do_hex)
printf("%s%s 0x%02x\n", l_leadin, b, x);
else
printf("%s%s %d\n", l_leadin, b, x);
break;
}
} else if ((1 == len_fld) && (2 == e_a_method)) {
x = sg_get_unaligned_be24(lunp + 1);
if (do_hex)
printf("%sExtended flat space addressing: lun=0x%06x\n",
l_leadin, x);
else
printf("%sExtended flat space addressing: lun=%d\n",
l_leadin, x);
} else if ((2 == len_fld) && (2 == e_a_method)) {
ull = sg_get_unaligned_be(5, lunp + 1);
if (do_hex)
printf("%sLong extended flat space addressing: "
"lun=0x%010" PRIx64 "\n", l_leadin, ull);
else
printf("%sLong extended flat space addressing: "
"lun=%" PRIu64 "\n", l_leadin, ull);
} else if ((3 == len_fld) && (0xf == e_a_method))
printf("%sLogical unit _not_ specified addressing\n",
l_leadin);
else {
if (len_fld < 2) {
if (1 == len_fld)
x = sg_get_unaligned_be24(lunp + 1);
if (do_hex)
printf("%sExtended logical unit addressing: "
"length=%d, e.a. method=%d, value=0x%06x\n",
l_leadin, len_fld, e_a_method, x);
else
printf("%sExtended logical unit addressing: "
"length=%d, e.a. method=%d, value=%d\n",
l_leadin, len_fld, e_a_method, x);
} else {
ull = sg_get_unaligned_be(((2 == len_fld) ? 5 : 7),
lunp + 1);
if (do_hex) {
printf("%sExtended logical unit addressing: "
"length=%d, e. a. method=%d, ", l_leadin,
len_fld, e_a_method);
if (5 == len_fld)
printf("value=0x%010" PRIx64 "\n", ull);
else
printf("value=0x%014" PRIx64 "\n", ull);
} else
printf("%sExtended logical unit addressing: "
"length=%d, e. a. method=%d, value=%" PRIu64
"\n", l_leadin, len_fld, e_a_method, ull);
}
}
break;
default:
printf("%s<<%s: faulty logic>>\n", l_leadin, __func__);
break;
}
if (next_level)
continue;
if ((2 == a_method) && (k < 3) && (lunp[2] || lunp[3]))
printf("%s<<unexpected data at next level, continue>>\n",
l_leadin);
break;
}
}
#ifdef SG_LIB_LINUX
static void
linux2t10_lun(uint64_t linux_lun, uint8_t t10_lun[])
{
int k;
for (k = 0; k < 8; k += 2, linux_lun >>= 16)
sg_put_unaligned_be16((uint16_t)linux_lun, t10_lun + k);
}
static uint64_t
t10_2linux_lun(const uint8_t t10_lun[])
{
int k;
const uint8_t * cp;
uint64_t res;
res = sg_get_unaligned_be16(t10_lun + 6);
for (cp = t10_lun + 4, k = 0; k < 3; ++k, cp -= 2)
res = (res << 16) + sg_get_unaligned_be16(cp);
return res;
}
#endif /* SG_LIB_LINUX */
static void
dStrRaw(const char * str, int len)
{
int k;
for (k = 0; k < len; ++k)
printf("%c", str[k]);
}
int
main(int argc, char * argv[])
{
#ifdef SG_LIB_LINUX
bool do_linux = false;
#endif
bool do_quiet = false;
bool do_raw = false;
bool lu_cong_arg_given = false;
bool o_readonly = false;
#ifdef SG_LIB_LINUX
bool test_linux_in = false;
bool test_linux_out = false;
#endif
bool trunc;
bool verbose_given = false;
bool version_given = false;
int sg_fd, k, m, off, res, c, list_len, len_cap, luns;
int decode_arg = 0;
int do_hex = 0;
int lu_cong_arg = 0;
int maxlen = 0;
int ret = 0;
int select_rep = 0;
int verbose = 0;
unsigned int h;
const char * test_arg = NULL;
const char * device_name = NULL;
const char * cp;
uint8_t * reportLunsBuff = NULL;
uint8_t * free_reportLunsBuff = NULL;
uint8_t lun_arr[8];
struct sg_simple_inquiry_resp sir;
while (1) {
int option_index = 0;
#ifdef SG_LIB_LINUX
c = getopt_long(argc, argv, "dhHlLm:qrRs:t:vV", long_options,
&option_index);
#else
c = getopt_long(argc, argv, "dhHLm:qrRs:t:vV", long_options,
&option_index);
#endif
if (c == -1)
break;
switch (c) {
case 'd':
++decode_arg;
break;
case 'h':
case '?':
usage();
return 0;
case 'H':
++do_hex;
break;
#ifdef SG_LIB_LINUX
case 'l':
do_linux = false;
break;
#endif
case 'L':
++lu_cong_arg;
lu_cong_arg_given = true;
break;
case 'm':
maxlen = sg_get_num(optarg);
if ((maxlen < 0) || (maxlen > MAX_RLUNS_BUFF_LEN)) {
pr2serr("argument to '--maxlen' should be %d or less\n",
MAX_RLUNS_BUFF_LEN);
return SG_LIB_SYNTAX_ERROR;
}
break;
case 'q':
do_quiet = true;
break;
case 'r':
do_raw = true;
break;
case 'R':
o_readonly = true;
break;
case 's':
select_rep = sg_get_num(optarg);
if ((select_rep < 0) || (select_rep > 255)) {
pr2serr("bad argument to '--select', expect 0 to 255\n");
return SG_LIB_SYNTAX_ERROR;
}
break;
case 't':
test_arg = optarg;
break;
case 'v':
verbose_given = true;
++verbose;
break;
case 'V':
version_given = true;
break;
default:
pr2serr("unrecognised option code 0x%x ??\n", c);
usage();
return SG_LIB_SYNTAX_ERROR;
}
}
if (optind < argc) {
if (NULL == device_name) {
device_name = argv[optind];
++optind;
}
if (optind < argc) {
for (; optind < argc; ++optind)
pr2serr("Unexpected extra argument: %s\n", argv[optind]);
usage();
return SG_LIB_SYNTAX_ERROR;
}
}
#ifdef DEBUG
pr2serr("In DEBUG mode, ");
if (verbose_given && version_given) {
pr2serr("but override: '-vV' given, zero verbose and continue\n");
verbose_given = false;
version_given = false;
verbose = 0;
} else if (! verbose_given) {
pr2serr("set '-vv'\n");
verbose = 2;
} else
pr2serr("keep verbose=%d\n", verbose);
#else
if (verbose_given && version_given)
pr2serr("Not in DEBUG mode, so '-vV' has no special action\n");
#endif
if (version_given) {
pr2serr("version: %s\n", version_str);
return 0;
}
if (test_arg) {
memset(lun_arr, 0, sizeof(lun_arr));
cp = test_arg;
/* check for leading 'L' */
#ifdef SG_LIB_LINUX
if ('L' == toupper(cp[0])) {
uint64_t ull;
if (('0' == cp[1]) && ('X' == toupper(cp[2])))
k = sscanf(cp + 3, " %" SCNx64, &ull);
else
k = sscanf(cp + 1, " %" SCNu64, &ull);
if (1 != k) {
pr2serr("Unable to read Linux style LUN integer given to "
"--test=\n");
return SG_LIB_SYNTAX_ERROR;
}
linux2t10_lun(ull, lun_arr);
test_linux_in = true;
} else
#endif
{
/* Check if trailing 'L' */
#ifdef SG_LIB_LINUX
m = strlen(cp); /* must be at least 1 char in test_arg */
if ('L' == toupper(cp[m - 1]))
test_linux_out = true;
#endif
if (('0' == cp[0]) && ('X' == toupper(cp[1])))
cp += 2;
if (strchr(cp, ' ') || strchr(cp, '\t') || strchr(cp, '-')) {
for (k = 0; k < 8; ++k, cp += 2) {
c = *cp;
if ('\0' == c)
break;
else if (! isxdigit(c))
++cp;
if (1 != sscanf(cp, "%2x", &h))
break;
lun_arr[k] = h & 0xff;
}
} else {
for (k = 0; k < 8; ++k, cp += 2) {
if (1 != sscanf(cp, "%2x", &h))
break;
lun_arr[k] = h & 0xff;
}
}
if (0 == k) {
pr2serr("expected a hex number, optionally prefixed by "
"'0x'\n");
return SG_LIB_SYNTAX_ERROR;
}
}
#ifdef SG_LIB_LINUX
if (verbose || test_linux_in || decode_arg)
#else
if (verbose || decode_arg)
#endif
{
if (decode_arg > 1) {
printf("64 bit LUN in T10 (hex, dashed) format: ");
for (k = 0; k < 8; k += 2)
printf("%c%02x%02x", (k ? '-' : ' '), lun_arr[k],
lun_arr[k + 1]);
} else {
printf("64 bit LUN in T10 preferred (hex) format: ");
for (k = 0; k < 8; ++k)
printf(" %02x", lun_arr[k]);
}
printf("\n");
}
#ifdef SG_LIB_LINUX
if (test_linux_out) {
if (do_hex > 1)
printf("Linux 'word flipped' integer LUN representation: "
"0x%016" PRIx64 "\n", t10_2linux_lun(lun_arr));
else if (do_hex)
printf("Linux 'word flipped' integer LUN representation: 0x%"
PRIx64 "\n", t10_2linux_lun(lun_arr));
else
printf("Linux 'word flipped' integer LUN representation: %"
PRIu64 "\n", t10_2linux_lun(lun_arr));
}
#endif
printf("Decoded LUN:\n");
decode_lun(" ", lun_arr, (lu_cong_arg % 2), do_hex, verbose);
return 0;
}
if (NULL == device_name) {
pr2serr("missing device name!\n");
usage();
return SG_LIB_SYNTAX_ERROR;
}
if (do_raw) {
if (sg_set_binary_mode(STDOUT_FILENO) < 0) {
perror("sg_set_binary_mode");
return SG_LIB_FILE_ERROR;
}
}
sg_fd = sg_cmds_open_device(device_name, o_readonly, verbose);
if (sg_fd < 0) {
pr2serr("open error: %s: %s\n", device_name, safe_strerror(-sg_fd));
return sg_convert_errno(-sg_fd);
}
if (decode_arg && (! lu_cong_arg_given)) {
if (verbose > 1)
pr2serr("in order to decode LUN and since --lu_cong not given, "
"do standard\nINQUIRY to find LU_CONG bit\n");
/* check if LU_CONG set in standard INQUIRY response */
res = sg_simple_inquiry(sg_fd, &sir, false, verbose);
ret = res;
if (res) {
pr2serr("fetching standard INQUIRY response failed\n");
goto the_end;
}
lu_cong_arg = !!(0x40 & sir.byte_1);
if (verbose && lu_cong_arg)
pr2serr("LU_CONG bit set in standard INQUIRY response\n");
}
if (0 == maxlen)
maxlen = DEF_RLUNS_BUFF_LEN;
reportLunsBuff = (uint8_t *)sg_memalign(maxlen, 0, &free_reportLunsBuff,
verbose > 3);
if (NULL == reportLunsBuff) {
pr2serr("unable to sg_memalign %d bytes\n", maxlen);
return sg_convert_errno(ENOMEM);
}
trunc = false;
res = sg_ll_report_luns(sg_fd, select_rep, reportLunsBuff, maxlen, true,
verbose);
ret = res;
if (0 == res) {
list_len = sg_get_unaligned_be32(reportLunsBuff + 0);
len_cap = list_len + 8;
if (len_cap > maxlen)
len_cap = maxlen;
if (do_raw) {
dStrRaw((const char *)reportLunsBuff, len_cap);
goto the_end;
}
if (1 == do_hex) {
hex2stdout(reportLunsBuff, len_cap, 1);
goto the_end;
}
luns = (list_len / 8);
if (! do_quiet)
printf("Lun list length = %d which imples %d lun entr%s\n",
list_len, luns, ((1 == luns) ? "y" : "ies"));
if ((list_len + 8) > maxlen) {
luns = ((maxlen - 8) / 8);
trunc = true;
pr2serr(" <<too many luns for internal buffer, will show %d "
"lun%s>>\n", luns, ((1 == luns) ? "" : "s"));
}
if (verbose > 1) {
pr2serr("\nOutput response in hex\n");
hex2stderr(reportLunsBuff, (trunc ? maxlen : list_len + 8), 1);
}
for (k = 0, off = 8; k < luns; ++k, off += 8) {
if (! do_quiet) {
if (0 == k)
printf("Report luns [select_report=0x%x]:\n", select_rep);
printf(" ");
}
for (m = 0; m < 8; ++m)
printf("%02x", reportLunsBuff[off + m]);
#ifdef SG_LIB_LINUX
if (do_linux) {
uint64_t lin_lun;
lin_lun = t10_2linux_lun(reportLunsBuff + off);
if (do_hex > 1)
printf(" [0x%" PRIx64 "]", lin_lun);
else
printf(" [%" PRIu64 "]", lin_lun);
}
#endif
printf("\n");
if (decode_arg)
decode_lun(" ", reportLunsBuff + off,
(bool)(lu_cong_arg % 2), do_hex, verbose);
}
} else if (SG_LIB_CAT_INVALID_OP == res)
pr2serr("Report Luns command not supported (support mandatory in "
"SPC-3)\n");
else if (SG_LIB_CAT_ABORTED_COMMAND == res)
pr2serr("Report Luns, aborted command\n");
else if (SG_LIB_CAT_ILLEGAL_REQ == res)
pr2serr("Report Luns command has bad field in cdb\n");
else {
char b[80];
sg_get_category_sense_str(res, sizeof(b), b, verbose);
pr2serr("Report Luns command: %s\n", b);
}
the_end:
if (free_reportLunsBuff)
free(free_reportLunsBuff);
res = sg_cmds_close_device(sg_fd);
if (res < 0) {
pr2serr("close error: %s\n", safe_strerror(-res));
if (0 == ret)
return sg_convert_errno(-res);
}
if (0 == verbose) {
if (! sg_if_can2stderr("sg_luns failed: ", ret))
pr2serr("Some error occurred, try again with '-v' or '-vv' for "
"more information\n");
}
return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
}
|
