From 45b274aec8c5bb74d5b9d14c8ef323fb85f2a951 Mon Sep 17 00:00:00 2001 From: zhenwei pi Date: Fri, 28 Jul 2023 18:34:10 +0800 Subject: [PATCH] iscsi-md5sum: Add new tool The new tool 'iscsi-md5sum' is used to calculate MD5 value of an iSCSI target. This help users to verify data at range [LBA, Length). For example, double-write on a RAID1 of 2 iSCSI targets, a daemon process runs iscsi-md5sum to check data periodically. Originally, we have to use several steps to achieve: 1, use iscsiadm to login.(root privilege required) 2, use dd(dd if=/dev/sdX of=/TMPPATH bs=4k count=LENGTH skip=LBA) to dump data. (root privilege required, additional disk space required) 3, use md5sum to calculate MD5 value 4, remove data. Instead, a single command iscsi-md5sum without root privilege is enough. Signed-off-by: zhenwei pi --- utils/Makefile.am | 2 +- utils/iscsi-md5sum.c | 595 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 596 insertions(+), 1 deletion(-) create mode 100644 utils/iscsi-md5sum.c diff --git a/utils/Makefile.am b/utils/Makefile.am index 931731a..b03f4d0 100644 --- a/utils/Makefile.am +++ b/utils/Makefile.am @@ -3,7 +3,7 @@ AM_CFLAGS = $(WARN_CFLAGS) AM_LDFLAGS = -no-undefined LIBS = ../lib/libiscsi.la -bin_PROGRAMS = iscsi-inq iscsi-ls iscsi-swp iscsi-pr iscsi-discard +bin_PROGRAMS = iscsi-inq iscsi-ls iscsi-swp iscsi-pr iscsi-discard iscsi-md5sum if !TARGET_OS_IS_WIN32 bin_PROGRAMS += iscsi-perf iscsi-readcapacity16 endif diff --git a/utils/iscsi-md5sum.c b/utils/iscsi-md5sum.c new file mode 100644 index 0000000..278794e --- /dev/null +++ b/utils/iscsi-md5sum.c @@ -0,0 +1,595 @@ +/* + Copyright (C) 2023 by zhenwei pi + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "iscsi.h" +#include "scsi-lowlevel.h" + +/* MD5 related codes come from glibc with a few change(to avoid symbol conflict) */ +# if __BYTE_ORDER == __BIG_ENDIAN +# define WORDS_BIGENDIAN 1 +# endif + +#ifdef WORDS_BIGENDIAN +# define SWAP(n) \ + (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) +#else +# define SWAP(n) (n) +#endif + +typedef unsigned int libiscsi_md5_uint32; + +struct libiscsi_md5_ctx { + libiscsi_md5_uint32 A; + libiscsi_md5_uint32 B; + libiscsi_md5_uint32 C; + libiscsi_md5_uint32 D; + + libiscsi_md5_uint32 total[2]; + libiscsi_md5_uint32 buflen; + union + { + char buffer[128]; + libiscsi_md5_uint32 buffer32[32]; + }; +}; + +/* These are the four functions used in the four steps of the MD5 algorithm + and defined in the RFC 1321. The first function is a little bit optimized + (as found in Colin Plumbs public domain implementation). */ +/* #define FF(b, c, d) ((b & c) | (~b & d)) */ +#define FF(b, c, d) (d ^ (b & (c ^ d))) +#define FG(b, c, d) FF (d, b, c) +#define FH(b, c, d) (b ^ c ^ d) +#define FI(b, c, d) (c ^ (b | ~d)) + +/* Process LEN bytes of BUFFER, accumulating context into CTX. + It is assumed that LEN % 64 == 0. */ + +static void +libiscsi_md5_process_block (const void *buffer, size_t len, struct libiscsi_md5_ctx *ctx) +{ + libiscsi_md5_uint32 correct_words[16]; + const libiscsi_md5_uint32 *words = buffer; + size_t nwords = len / sizeof (libiscsi_md5_uint32); + const libiscsi_md5_uint32 *endp = words + nwords; + libiscsi_md5_uint32 A = ctx->A; + libiscsi_md5_uint32 B = ctx->B; + libiscsi_md5_uint32 C = ctx->C; + libiscsi_md5_uint32 D = ctx->D; + libiscsi_md5_uint32 lolen = len; + + /* First increment the byte count. RFC 1321 specifies the possible + length of the file up to 2^64 bits. Here we only compute the + number of bytes. Do a double word increment. */ + ctx->total[0] += lolen; + ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen); + + /* Process all bytes in the buffer with 64 bytes in each round of + the loop. */ + while (words < endp) + { + libiscsi_md5_uint32 *cwp = correct_words; + libiscsi_md5_uint32 A_save = A; + libiscsi_md5_uint32 B_save = B; + libiscsi_md5_uint32 C_save = C; + libiscsi_md5_uint32 D_save = D; + + /* First round: using the given function, the context and a constant + the next context is computed. Because the algorithms processing + unit is a 32-bit word and it is determined to work on words in + little endian byte order we perhaps have to change the byte order + before the computation. To reduce the work for the next steps + we store the swapped words in the array CORRECT_WORDS. */ + +#define OP(a, b, c, d, s, T) \ + do \ + { \ + a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \ + ++words; \ + CYCLIC (a, s); \ + a += b; \ + } \ + while (0) + + /* It is unfortunate that C does not provide an operator for + cyclic rotation. Hope the C compiler is smart enough. */ +#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s))) + + /* Before we start, one word to the strange constants. + They are defined in RFC 1321 as + + T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 + */ + + /* Round 1. */ + OP (A, B, C, D, 7, 0xd76aa478); + OP (D, A, B, C, 12, 0xe8c7b756); + OP (C, D, A, B, 17, 0x242070db); + OP (B, C, D, A, 22, 0xc1bdceee); + OP (A, B, C, D, 7, 0xf57c0faf); + OP (D, A, B, C, 12, 0x4787c62a); + OP (C, D, A, B, 17, 0xa8304613); + OP (B, C, D, A, 22, 0xfd469501); + OP (A, B, C, D, 7, 0x698098d8); + OP (D, A, B, C, 12, 0x8b44f7af); + OP (C, D, A, B, 17, 0xffff5bb1); + OP (B, C, D, A, 22, 0x895cd7be); + OP (A, B, C, D, 7, 0x6b901122); + OP (D, A, B, C, 12, 0xfd987193); + OP (C, D, A, B, 17, 0xa679438e); + OP (B, C, D, A, 22, 0x49b40821); + + /* For the second to fourth round we have the possibly swapped words + in CORRECT_WORDS. Redefine the macro to take an additional first + argument specifying the function to use. */ +#undef OP +#define OP(f, a, b, c, d, k, s, T) \ + do \ + { \ + a += f (b, c, d) + correct_words[k] + T; \ + CYCLIC (a, s); \ + a += b; \ + } \ + while (0) + + /* Round 2. */ + OP (FG, A, B, C, D, 1, 5, 0xf61e2562); + OP (FG, D, A, B, C, 6, 9, 0xc040b340); + OP (FG, C, D, A, B, 11, 14, 0x265e5a51); + OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); + OP (FG, A, B, C, D, 5, 5, 0xd62f105d); + OP (FG, D, A, B, C, 10, 9, 0x02441453); + OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); + OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); + OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); + OP (FG, D, A, B, C, 14, 9, 0xc33707d6); + OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); + OP (FG, B, C, D, A, 8, 20, 0x455a14ed); + OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); + OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); + OP (FG, C, D, A, B, 7, 14, 0x676f02d9); + OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); + + /* Round 3. */ + OP (FH, A, B, C, D, 5, 4, 0xfffa3942); + OP (FH, D, A, B, C, 8, 11, 0x8771f681); + OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); + OP (FH, B, C, D, A, 14, 23, 0xfde5380c); + OP (FH, A, B, C, D, 1, 4, 0xa4beea44); + OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); + OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); + OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); + OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); + OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); + OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); + OP (FH, B, C, D, A, 6, 23, 0x04881d05); + OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); + OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); + OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); + OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); + + /* Round 4. */ + OP (FI, A, B, C, D, 0, 6, 0xf4292244); + OP (FI, D, A, B, C, 7, 10, 0x432aff97); + OP (FI, C, D, A, B, 14, 15, 0xab9423a7); + OP (FI, B, C, D, A, 5, 21, 0xfc93a039); + OP (FI, A, B, C, D, 12, 6, 0x655b59c3); + OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); + OP (FI, C, D, A, B, 10, 15, 0xffeff47d); + OP (FI, B, C, D, A, 1, 21, 0x85845dd1); + OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); + OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); + OP (FI, C, D, A, B, 6, 15, 0xa3014314); + OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); + OP (FI, A, B, C, D, 4, 6, 0xf7537e82); + OP (FI, D, A, B, C, 11, 10, 0xbd3af235); + OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); + OP (FI, B, C, D, A, 9, 21, 0xeb86d391); + + /* Add the starting values of the context. */ + A += A_save; + B += B_save; + C += C_save; + D += D_save; + } + + /* Put checksum in context given as argument. */ + ctx->A = A; + ctx->B = B; + ctx->C = C; + ctx->D = D; +} +/* This array contains the bytes used to pad the buffer to the next + 64-byte boundary. (RFC 1321, 3.1: Step 1) */ +static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; + +/* Initialize structure containing state of computation. + (RFC 1321, 3.3: Step 3) */ +static void +libiscsi_md5_init_ctx (struct libiscsi_md5_ctx *ctx) +{ + ctx->A = 0x67452301; + ctx->B = 0xefcdab89; + ctx->C = 0x98badcfe; + ctx->D = 0x10325476; + + ctx->total[0] = ctx->total[1] = 0; + ctx->buflen = 0; +} + +/* Put result from CTX in first 16 bytes following RESBUF. The result + must be in little endian byte order. + +IMPORTANT: On some systems it is required that RESBUF is correctly +aligned for a 32 bits value. */ +static void * +libiscsi_md5_read_ctx (const struct libiscsi_md5_ctx *ctx, void *resbuf) +{ + ((libiscsi_md5_uint32 *) resbuf)[0] = SWAP (ctx->A); + ((libiscsi_md5_uint32 *) resbuf)[1] = SWAP (ctx->B); + ((libiscsi_md5_uint32 *) resbuf)[2] = SWAP (ctx->C); + ((libiscsi_md5_uint32 *) resbuf)[3] = SWAP (ctx->D); + + return resbuf; +} + +/* Process the remaining bytes in the internal buffer and the usual + prolog according to the standard and write the result to RESBUF. + +IMPORTANT: On some systems it is required that RESBUF is correctly +aligned for a 32 bits value. */ +static void * +libiscsi_md5_finish_ctx (struct libiscsi_md5_ctx *ctx, void *resbuf) +{ + /* Take yet unprocessed bytes into account. */ + libiscsi_md5_uint32 bytes = ctx->buflen; + size_t pad; + + /* Now count remaining bytes. */ + ctx->total[0] += bytes; + if (ctx->total[0] < bytes) + ++ctx->total[1]; + + pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes; + memcpy (&ctx->buffer[bytes], fillbuf, pad); + + /* Put the 64-bit file length in *bits* at the end of the buffer. */ + ctx->buffer32[(bytes + pad) / 4] = SWAP (ctx->total[0] << 3); + ctx->buffer32[(bytes + pad + 4) / 4] = SWAP ((ctx->total[1] << 3) + | (ctx->total[0] >> 29)); + + /* Process last bytes. */ + libiscsi_md5_process_block (ctx->buffer, bytes + pad + 8, ctx); + + return libiscsi_md5_read_ctx (ctx, resbuf); +} + +static void +libiscsi_md5_process_bytes (const void *buffer, size_t len, struct libiscsi_md5_ctx *ctx) +{ + /* When we already have some bits in our internal buffer concatenate + both inputs first. */ + if (ctx->buflen != 0) + { + size_t left_over = ctx->buflen; + size_t add = 128 - left_over > len ? len : 128 - left_over; + + memcpy (&ctx->buffer[left_over], buffer, add); + ctx->buflen += add; + + if (ctx->buflen > 64) + { + libiscsi_md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx); + + ctx->buflen &= 63; + /* The regions in the following copy operation cannot overlap. */ + memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63], + ctx->buflen); + } + + buffer = (const char *) buffer + add; + len -= add; + } + + /* Process available complete blocks. */ + if (len >= 64) + { + while (len > 64) + { + libiscsi_md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx); + buffer = (const char *) buffer + 64; + len -= 64; + } + } + + /* Move remaining bytes in internal buffer. */ + if (len > 0) + { + size_t left_over = ctx->buflen; + + memcpy (&ctx->buffer[left_over], buffer, len); + left_over += len; + if (left_over >= 64) + { + libiscsi_md5_process_block (ctx->buffer, 64, ctx); + left_over -= 64; + memcpy (ctx->buffer, &ctx->buffer[64], left_over); + } + ctx->buflen = left_over; + } +} + +/* iSCSI codes */ +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +static const char *initiator = "iqn.2007-10.com.github:sahlberg:libiscsi:iscsi-md5sum"; + +static void print_help(const char *prog) +{ + fprintf(stderr, "Usage: %s [OPTION...] \n", prog); + fprintf(stderr, " -i, --initiator-name=iqn-name Initiatorname to use\n"); + fprintf(stderr, " -o, --offset " + "Byte offset into the target from which to start calculating. " + "The provided value must be aligned to the target sector size. " + "The default value is zero.\n"); + fprintf(stderr, " -l, --length " + "The number of bytes to calculate (counting from the starting point). " + "The provided value must be aligned to the target sector size. " + "If the specified value extends past the end of the device, " + "%s will stop at the device size boundary. " + "The default value extends to the end of the device.\n", prog); + fprintf(stderr, " -d, --debug=integer debug level (0=disabled)\n"); + fprintf(stderr, "\n"); + fprintf(stderr, "Help options:\n"); + fprintf(stderr, " -?, --help Show this help message\n"); + fprintf(stderr, "\n"); + fprintf(stderr, "iSCSI URL format : %s\n", ISCSI_URL_SYNTAX); + fprintf(stderr, "\n"); + fprintf(stderr, " is either of:\n"); + fprintf(stderr, " \"hostname\" iscsi.example\n"); + fprintf(stderr, " \"ipv4-address\" 10.1.1.27\n"); + fprintf(stderr, " \"ipv6-address\" [fce0::1]\n"); + + exit(0); +} + +void inquiry_block_limits(struct scsi_inquiry_block_limits *inq) +{ + printf("wsnz:%d\n", inq->wsnz); + printf("maximum compare and write length:%" PRIu8 "\n", inq->max_cmp); + printf("optimal transfer length granularity:%" PRIu16 "\n", inq->opt_gran); + printf("maximum transfer length:%" PRIu32 "\n", inq->max_xfer_len); + printf("optimal transfer length:%" PRIu32 "\n",inq->opt_xfer_len); + printf("maximum prefetch xdread xdwrite transfer length:%" PRIu32 "\n", inq->max_prefetch); + printf("maximum unmap lba count:%" PRIu32 "\n", inq->max_unmap); + printf("maximum unmap block descriptor count:%" PRIu32 "\n", inq->max_unmap_bdc); + printf("optimal unmap granularity:%" PRIu32 "\n", inq->opt_unmap_gran); + printf("ugavalid:%d\n", inq->ugavalid); + printf("unmap granularity alignment:%" PRIu32 "\n", inq->unmap_gran_align); + printf("maximum write same length:%" PRIu64 "\n", inq->max_ws_len); +} + +static unsigned long inquiry_xfer_len(struct iscsi_context *iscsi, int lun, unsigned int block_length) +{ + struct scsi_task *task; + int full_size; + struct scsi_inquiry_block_limits *inq; + unsigned long max_xfer_len = 1024 * 1024; /* default size 1M */ + + /* See how big this inquiry data is */ + task = iscsi_inquiry_sync(iscsi, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, 64); + if (task == NULL || task->status != SCSI_STATUS_GOOD) { + fprintf(stderr, "Inquiry command failed : %s\n", iscsi_get_error(iscsi)); + exit(EIO); + } + + full_size = scsi_datain_getfullsize(task); + if (full_size > task->datain.size) { + scsi_free_scsi_task(task); + + /* we need more data for the full list */ + if ((task = iscsi_inquiry_sync(iscsi, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, full_size)) == NULL) { + fprintf(stderr, "Inquiry command failed : %s\n", iscsi_get_error(iscsi)); + exit(EIO); + } + } + + inq = scsi_datain_unmarshall(task); + if (inq == NULL) { + fprintf(stderr, "failed to unmarshall inquiry datain blob\n"); + exit(EIO); + } + + if (inq->max_xfer_len) + max_xfer_len = MIN(max_xfer_len, inq->max_xfer_len * block_length); + + scsi_free_scsi_task(task); + + return max_xfer_len; +} + +static void pread16(struct iscsi_context *iscsi, int lun, void *buf, uint64_t lba, uint32_t datalen, unsigned int block_size) +{ + struct scsi_iovec iov = { .iov_base = buf, .iov_len = datalen }; + struct scsi_task *task; + + task = iscsi_read16_iov_sync(iscsi, lun, lba, datalen, block_size, 0, 0, 0, 0, 0, &iov, 1); + if (task == NULL || task->status != SCSI_STATUS_GOOD) { + fprintf(stderr, "read16 command failed : %s\n", iscsi_get_error(iscsi)); + exit(EIO); + } + + scsi_free_scsi_task(task); +} + +int main(int argc, char *argv[]) +{ + struct iscsi_context *iscsi; + char *url = NULL; + struct iscsi_url *iscsi_url = NULL; + int debug = 0; + int option_index, c; + unsigned int block_length; + long long offset = 0, length = 0, capacity, max_xfer_len, end; + struct scsi_task *task; + struct scsi_readcapacity16 *rc16; + struct libiscsi_md5_ctx ctx; + unsigned char sum[16]; + unsigned char *buf; + int ret = EINVAL; + + static struct option long_options[] = { + {"offset", required_argument, NULL, 'o'}, + {"length", required_argument, NULL, 'l'}, + {"debug", required_argument, NULL, 'd'}, + {"help", no_argument, NULL, 'h'}, + {"initiator-name", required_argument, NULL, 'i'}, + {0, 0, 0, 0} + }; + + while ((c = getopt_long(argc, argv, "o:l:d:i:h?", long_options, + &option_index)) != -1) { + switch (c) { + case 'o': + offset = strtoll(optarg, NULL, 0); + break; + case 'l': + length = strtoll(optarg, NULL, 0); + break; + case 'd': + debug = strtol(optarg, NULL, 0); + break; + case 'i': + initiator = optarg; + break; + case 'h': + case '?': + print_help(argv[0]); + break; + default: + fprintf(stderr, "Unrecognized option '%c'\n\n", c); + print_help(argv[0]); + break; + } + } + + iscsi = iscsi_create_context(initiator); + if (iscsi == NULL) { + fprintf(stderr, "Failed to create context\n"); + exit(EINVAL); + } + + if (debug > 0) { + iscsi_set_log_fn(iscsi, iscsi_log_to_stderr); + iscsi_set_log_level(iscsi, debug); + } + + if (argv[optind] != NULL) { + url = strdup(argv[optind]); + } + if (url == NULL) { + fprintf(stderr, "You must specify the URL\n"); + print_help(argv[0]); + } + iscsi_url = iscsi_parse_full_url(iscsi, url); + + free(url); + + if (iscsi_url == NULL) { + fprintf(stderr, "Failed to parse URL: %s\n", + iscsi_get_error(iscsi)); + exit(EINVAL); + } + + iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL); + iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); + + if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) { + fprintf(stderr, "Login Failed. %s\n", iscsi_get_error(iscsi)); + goto out; + } + + task = iscsi_readcapacity16_sync(iscsi, iscsi_url->lun); + if (task == NULL || task->status != SCSI_STATUS_GOOD) { + fprintf(stderr,"Failed to send readcapacity command\n"); + goto out; + } + + rc16 = scsi_datain_unmarshall(task); + if (rc16 == NULL) { + fprintf(stderr,"Failed to unmarshall readcapacity16 data\n"); + goto out; + } + + block_length = rc16->block_length; + if (offset & (block_length - 1)) { + fprintf(stderr,"Unaligned offset of %u\n", block_length); + goto free_task; + } + + capacity = block_length * (rc16->returned_lba + 1); + if (offset > capacity) { + fprintf(stderr,"Offset(%lld) exceeds capacity(%lld)\n", offset, capacity); + goto free_task; + } + + if (!length || (offset + length > capacity)) { + length = block_length * (rc16->returned_lba + 1) - offset; + } + + /* free readcapacity16 task */ + scsi_free_scsi_task(task); + + libiscsi_md5_init_ctx(&ctx); + max_xfer_len = inquiry_xfer_len(iscsi, iscsi_url->lun, block_length); + buf = calloc(1, max_xfer_len); + for (end = offset + length; offset < end; offset += max_xfer_len) { + long long _len = MIN(end - offset, max_xfer_len); + pread16(iscsi, iscsi_url->lun, buf, offset / block_length, _len, block_length); + libiscsi_md5_process_bytes(buf, _len, &ctx); + } + + libiscsi_md5_finish_ctx(&ctx, sum); + free(buf); + + /* show MD5 sum in HEX */ + for (size_t i = 0; i < sizeof(sum); i++) + printf("%02x", sum[i]); + + printf("\n"); + + ret = 0; + goto out; + +free_task: + scsi_free_scsi_task(task); + +out: + iscsi_destroy_url(iscsi_url); + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + + return ret; +}