]> git.proxmox.com Git - mirror_qemu.git/blame - block/iscsi.c
block: make BlockLimits::max_pwrite_zeroes 64bit
[mirror_qemu.git] / block / iscsi.c
CommitLineData
c589b249
RS
1/*
2 * QEMU Block driver for iSCSI images
3 *
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
aef172ff 5 * Copyright (c) 2012-2017 Peter Lieven <pl@kamp.de>
c589b249
RS
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
80c71a24 26#include "qemu/osdep.h"
c589b249
RS
27
28#include <poll.h>
efc6de0d 29#include <math.h>
f4dfa67f 30#include <arpa/inet.h>
a8d25326 31#include "qemu-common.h"
1de7afc9
PB
32#include "qemu/config-file.h"
33#include "qemu/error-report.h"
b03c3805
PL
34#include "qemu/bitops.h"
35#include "qemu/bitmap.h"
737e150e 36#include "block/block_int.h"
609f45ea 37#include "block/qdict.h"
08e2c9f1 38#include "scsi/constants.h"
0a53f010 39#include "qemu/iov.h"
0b8fa32f 40#include "qemu/module.h"
922a01a0 41#include "qemu/option.h"
cea25275 42#include "qemu/uuid.h"
e4ec5ad4 43#include "sysemu/replay.h"
e688df6b 44#include "qapi/error.h"
f68c0147 45#include "qapi/qapi-commands-machine.h"
452fcdbc 46#include "qapi/qmp/qdict.h"
d49b6836 47#include "qapi/qmp/qstring.h"
b189346e 48#include "crypto/secret.h"
e5b5728c 49#include "scsi/utils.h"
ecc983a5 50#include "trace.h"
c589b249 51
e5b5728c
PB
52/* Conflict between scsi/utils.h and libiscsi! :( */
53#define SCSI_XFER_NONE ISCSI_XFER_NONE
c589b249 54#include <iscsi/iscsi.h>
df71ca84 55#define inline __attribute__((gnu_inline)) /* required for libiscsi v1.9.0 */
c589b249 56#include <iscsi/scsi-lowlevel.h>
df71ca84 57#undef inline
e5b5728c
PB
58#undef SCSI_XFER_NONE
59QEMU_BUILD_BUG_ON((int)SCSI_XFER_NONE != (int)ISCSI_XFER_NONE);
c589b249 60
98392453
RS
61#ifdef __linux__
62#include <scsi/sg.h>
98392453 63#endif
c589b249
RS
64
65typedef struct IscsiLun {
66 struct iscsi_context *iscsi;
80cf6257 67 AioContext *aio_context;
c589b249 68 int lun;
dbfff6d7 69 enum scsi_inquiry_peripheral_device_type type;
c589b249 70 int block_size;
c7b4a952 71 uint64_t num_blocks;
c9b9f682 72 int events;
5b5d34ec 73 QEMUTimer *nop_timer;
05b685fb 74 QEMUTimer *event_timer;
d045c466 75 QemuMutex mutex;
f18a7cbb
PL
76 struct scsi_inquiry_logical_block_provisioning lbp;
77 struct scsi_inquiry_block_limits bl;
cc9743c2 78 struct scsi_inquiry_device_designator *dd;
d4cd9615 79 unsigned char *zeroblock;
e1123a3b
PL
80 /* The allocmap tracks which clusters (pages) on the iSCSI target are
81 * allocated and which are not. In case a target returns zeros for
82 * unallocated pages (iscsilun->lprz) we can directly return zeros instead
83 * of reading zeros over the wire if a read request falls within an
84 * unallocated block. As there are 3 possible states we need 2 bitmaps to
85 * track. allocmap_valid keeps track if QEMU's information about a page is
86 * valid. allocmap tracks if a page is allocated or not. In case QEMU has no
87 * valid information about a page the corresponding allocmap entry should be
88 * switched to unallocated as well to force a new lookup of the allocation
89 * status as lookups are generally skipped if a page is suspect to be
90 * allocated. If a iSCSI target is opened with cache.direct = on the
91 * allocmap_valid does not exist turning all cached information invalid so
92 * that a fresh lookup is made for any page even if allocmap entry returns
93 * it's unallocated. */
94 unsigned long *allocmap;
95 unsigned long *allocmap_valid;
96 long allocmap_size;
ba059e7b 97 int cluster_size;
9281fe9e 98 bool use_16_for_rw;
43ae8fb1 99 bool write_protected;
0a386e48
PL
100 bool lbpme;
101 bool lbprz;
752ce451 102 bool dpofua;
0a386e48 103 bool has_write_same;
5dd7a535 104 bool request_timed_out;
c589b249
RS
105} IscsiLun;
106
54a5c1d5
PL
107typedef struct IscsiTask {
108 int status;
109 int complete;
110 int retries;
111 int do_retry;
112 struct scsi_task *task;
113 Coroutine *co;
80cf6257 114 IscsiLun *iscsilun;
efc6de0d 115 QEMUTimer retry_timer;
e01dd3da 116 int err_code;
e38bc234 117 char *err_str;
54a5c1d5
PL
118} IscsiTask;
119
c589b249 120typedef struct IscsiAIOCB {
7c84b1b8 121 BlockAIOCB common;
c589b249
RS
122 QEMUBH *bh;
123 IscsiLun *iscsilun;
124 struct scsi_task *task;
c589b249 125 int status;
1dde716e
PL
126 int64_t sector_num;
127 int nb_sectors;
4bb17ab5 128 int ret;
98392453
RS
129#ifdef __linux__
130 sg_io_hdr_t *ioh;
131#endif
c1004487 132 bool cancelled;
c589b249
RS
133} IscsiAIOCB;
134
5dd7a535
PL
135/* libiscsi uses time_t so its enough to process events every second */
136#define EVENT_INTERVAL 1000
5b5d34ec
PL
137#define NOP_INTERVAL 5000
138#define MAX_NOP_FAILURES 3
efc6de0d 139#define ISCSI_CMD_RETRIES ARRAY_SIZE(iscsi_retry_times)
59dd0a22 140static const unsigned iscsi_retry_times[] = {8, 32, 128, 512, 2048, 8192, 32768};
5b5d34ec 141
5d831be2 142/* this threshold is a trade-off knob to choose between
5917af81
PL
143 * the potential additional overhead of an extra GET_LBA_STATUS request
144 * vs. unnecessarily reading a lot of zero sectors over the wire.
145 * If a read request is greater or equal than ISCSI_CHECKALLOC_THRES
146 * sectors we check the allocation status of the area covered by the
147 * request first if the allocationmap indicates that the area might be
148 * unallocated. */
149#define ISCSI_CHECKALLOC_THRES 64
5b5d34ec 150
d4cef0c6
PMD
151#ifdef __linux__
152
27cbd828 153static void
cfb3f506 154iscsi_bh_cb(void *p)
27cbd828
PB
155{
156 IscsiAIOCB *acb = p;
157
158 qemu_bh_delete(acb->bh);
159
722d9333 160 acb->common.cb(acb->common.opaque, acb->status);
27cbd828 161
1bd075f2
PB
162 if (acb->task != NULL) {
163 scsi_free_scsi_task(acb->task);
164 acb->task = NULL;
165 }
166
8007429a 167 qemu_aio_unref(acb);
27cbd828
PB
168}
169
cfb3f506
PB
170static void
171iscsi_schedule_bh(IscsiAIOCB *acb)
27cbd828 172{
1bd075f2
PB
173 if (acb->bh) {
174 return;
175 }
80cf6257 176 acb->bh = aio_bh_new(acb->iscsilun->aio_context, iscsi_bh_cb, acb);
27cbd828 177 qemu_bh_schedule(acb->bh);
27cbd828
PB
178}
179
d4cef0c6
PMD
180#endif
181
8b9dfe90
PL
182static void iscsi_co_generic_bh_cb(void *opaque)
183{
184 struct IscsiTask *iTask = opaque;
1919631e 185
fcd470d8 186 iTask->complete = 1;
1919631e 187 aio_co_wake(iTask->co);
8b9dfe90
PL
188}
189
efc6de0d
PL
190static void iscsi_retry_timer_expired(void *opaque)
191{
192 struct IscsiTask *iTask = opaque;
fcd470d8 193 iTask->complete = 1;
efc6de0d 194 if (iTask->co) {
2f47da5f 195 aio_co_wake(iTask->co);
efc6de0d
PL
196 }
197}
198
199static inline unsigned exp_random(double mean)
200{
201 return -mean * log((double)rand() / RAND_MAX);
202}
203
e01dd3da
FZ
204/* SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST was introduced in
205 * libiscsi 1.10.0, together with other constants we need. Use it as
206 * a hint that we have to define them ourselves if needed, to keep the
207 * minimum required libiscsi version at 1.9.0. We use an ASCQ macro for
208 * the test because SCSI_STATUS_* is an enum.
209 *
210 * To guard against future changes where SCSI_SENSE_ASCQ_* also becomes
211 * an enum, check against the LIBISCSI_API_VERSION macro, which was
212 * introduced in 1.11.0. If it is present, there is no need to define
213 * anything.
214 */
215#if !defined(SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST) && \
216 !defined(LIBISCSI_API_VERSION)
217#define SCSI_STATUS_TASK_SET_FULL 0x28
218#define SCSI_STATUS_TIMEOUT 0x0f000002
219#define SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST 0x2600
220#define SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR 0x1a00
9049736e
PL
221#endif
222
583ec22e
RS
223#ifndef LIBISCSI_API_VERSION
224#define LIBISCSI_API_VERSION 20130701
225#endif
226
e01dd3da
FZ
227static int iscsi_translate_sense(struct scsi_sense *sense)
228{
8c460269
PB
229 return scsi_sense_to_errno(sense->key,
230 (sense->ascq & 0xFF00) >> 8,
231 sense->ascq & 0xFF);
e01dd3da
FZ
232}
233
d045c466 234/* Called (via iscsi_service) with QemuMutex held. */
54a5c1d5
PL
235static void
236iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
237 void *command_data, void *opaque)
238{
239 struct IscsiTask *iTask = opaque;
240 struct scsi_task *task = command_data;
241
54a5c1d5
PL
242 iTask->status = status;
243 iTask->do_retry = 0;
c58daf76 244 iTask->err_code = 0;
54a5c1d5
PL
245 iTask->task = task;
246
54a5c1d5 247 if (status != SCSI_STATUS_GOOD) {
c58daf76 248 iTask->err_code = -EIO;
efc6de0d 249 if (iTask->retries++ < ISCSI_CMD_RETRIES) {
9049736e 250 if (status == SCSI_STATUS_BUSY ||
e01dd3da
FZ
251 status == SCSI_STATUS_TIMEOUT ||
252 status == SCSI_STATUS_TASK_SET_FULL) {
efc6de0d
PL
253 unsigned retry_time =
254 exp_random(iscsi_retry_times[iTask->retries - 1]);
e01dd3da 255 if (status == SCSI_STATUS_TIMEOUT) {
5dd7a535
PL
256 /* make sure the request is rescheduled AFTER the
257 * reconnect is initiated */
258 retry_time = EVENT_INTERVAL * 2;
259 iTask->iscsilun->request_timed_out = true;
260 }
261 error_report("iSCSI Busy/TaskSetFull/TimeOut"
262 " (retry #%u in %u ms): %s",
efc6de0d
PL
263 iTask->retries, retry_time,
264 iscsi_get_error(iscsi));
265 aio_timer_init(iTask->iscsilun->aio_context,
266 &iTask->retry_timer, QEMU_CLOCK_REALTIME,
267 SCALE_MS, iscsi_retry_timer_expired, iTask);
268 timer_mod(&iTask->retry_timer,
269 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time);
270 iTask->do_retry = 1;
dd3b0020
XY
271 } else if (status == SCSI_STATUS_CHECK_CONDITION) {
272 int error = iscsi_translate_sense(&task->sense);
273 if (error == EAGAIN) {
274 error_report("iSCSI CheckCondition: %s",
275 iscsi_get_error(iscsi));
276 iTask->do_retry = 1;
277 } else {
278 iTask->err_code = -error;
279 iTask->err_str = g_strdup(iscsi_get_error(iscsi));
280 }
efc6de0d
PL
281 }
282 }
54a5c1d5
PL
283 }
284
54a5c1d5 285 if (iTask->co) {
e4ec5ad4
PD
286 replay_bh_schedule_oneshot_event(iTask->iscsilun->aio_context,
287 iscsi_co_generic_bh_cb, iTask);
fcd470d8
PL
288 } else {
289 iTask->complete = 1;
54a5c1d5
PL
290 }
291}
292
293static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
294{
295 *iTask = (struct IscsiTask) {
efc6de0d 296 .co = qemu_coroutine_self(),
efc6de0d 297 .iscsilun = iscsilun,
54a5c1d5
PL
298 };
299}
27cbd828 300
d4cef0c6
PMD
301#ifdef __linux__
302
c1004487 303/* Called (via iscsi_service) with QemuMutex held. */
c589b249
RS
304static void
305iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
306 void *private_data)
307{
1bd075f2
PB
308 IscsiAIOCB *acb = private_data;
309
88e94fd2
SH
310 /* If the command callback hasn't been called yet, drop the task */
311 if (!acb->bh) {
312 /* Call iscsi_aio_ioctl_cb() with SCSI_STATUS_CANCELLED */
313 iscsi_scsi_cancel_task(iscsi, acb->task);
314 }
315
c1004487 316 qemu_aio_unref(acb); /* acquired in iscsi_aio_cancel() */
c589b249
RS
317}
318
319static void
7c84b1b8 320iscsi_aio_cancel(BlockAIOCB *blockacb)
c589b249
RS
321{
322 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
323 IscsiLun *iscsilun = acb->iscsilun;
324
c208b0ef 325 WITH_QEMU_LOCK_GUARD(&iscsilun->mutex) {
c1004487 326
c208b0ef
GQ
327 /* If it was cancelled or completed already, our work is done here */
328 if (acb->cancelled || acb->status != -EINPROGRESS) {
329 return;
330 }
1bd075f2 331
c208b0ef 332 acb->cancelled = true;
c1004487 333
c208b0ef 334 qemu_aio_ref(acb); /* released in iscsi_abort_task_cb() */
c1004487 335
c208b0ef
GQ
336 /* send a task mgmt call to the target to cancel the task on the target */
337 if (iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
338 iscsi_abort_task_cb, acb) < 0) {
339 qemu_aio_unref(acb); /* since iscsi_abort_task_cb() won't be called */
340 }
c1004487 341 }
c589b249
RS
342}
343
d7331bed 344static const AIOCBInfo iscsi_aiocb_info = {
c589b249 345 .aiocb_size = sizeof(IscsiAIOCB),
722d9333 346 .cancel_async = iscsi_aio_cancel,
c589b249
RS
347};
348
d4cef0c6 349#endif
c589b249
RS
350
351static void iscsi_process_read(void *arg);
352static void iscsi_process_write(void *arg);
353
d045c466 354/* Called with QemuMutex held. */
c589b249
RS
355static void
356iscsi_set_events(IscsiLun *iscsilun)
357{
358 struct iscsi_context *iscsi = iscsilun->iscsi;
05b685fb 359 int ev = iscsi_which_events(iscsi);
c9b9f682 360
c9b9f682 361 if (ev != iscsilun->events) {
dca21ef2
FZ
362 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsi),
363 false,
05b685fb 364 (ev & POLLIN) ? iscsi_process_read : NULL,
80cf6257 365 (ev & POLLOUT) ? iscsi_process_write : NULL,
f6a51c84 366 NULL,
80cf6257 367 iscsilun);
05b685fb
PL
368 iscsilun->events = ev;
369 }
05b685fb 370}
c9b9f682 371
5dd7a535 372static void iscsi_timed_check_events(void *opaque)
05b685fb
PL
373{
374 IscsiLun *iscsilun = opaque;
5dd7a535 375
c208b0ef
GQ
376 WITH_QEMU_LOCK_GUARD(&iscsilun->mutex) {
377 /* check for timed out requests */
378 iscsi_service(iscsilun->iscsi, 0);
83d11973 379
c208b0ef
GQ
380 if (iscsilun->request_timed_out) {
381 iscsilun->request_timed_out = false;
382 iscsi_reconnect(iscsilun->iscsi);
383 }
5dd7a535 384
c208b0ef
GQ
385 /*
386 * newer versions of libiscsi may return zero events. Ensure we are
387 * able to return to service once this situation changes.
388 */
389 iscsi_set_events(iscsilun);
5dd7a535
PL
390 }
391
5dd7a535
PL
392 timer_mod(iscsilun->event_timer,
393 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
c589b249
RS
394}
395
396static void
397iscsi_process_read(void *arg)
398{
399 IscsiLun *iscsilun = arg;
400 struct iscsi_context *iscsi = iscsilun->iscsi;
401
d045c466 402 qemu_mutex_lock(&iscsilun->mutex);
c589b249
RS
403 iscsi_service(iscsi, POLLIN);
404 iscsi_set_events(iscsilun);
d045c466 405 qemu_mutex_unlock(&iscsilun->mutex);
c589b249
RS
406}
407
408static void
409iscsi_process_write(void *arg)
410{
411 IscsiLun *iscsilun = arg;
412 struct iscsi_context *iscsi = iscsilun->iscsi;
413
d045c466 414 qemu_mutex_lock(&iscsilun->mutex);
c589b249
RS
415 iscsi_service(iscsi, POLLOUT);
416 iscsi_set_events(iscsilun);
d045c466 417 qemu_mutex_unlock(&iscsilun->mutex);
c589b249
RS
418}
419
0777b5dd
PL
420static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
421{
422 return sector * iscsilun->block_size / BDRV_SECTOR_SIZE;
423}
424
c589b249
RS
425static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
426{
427 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
428}
429
94d047a3
EB
430static bool is_byte_request_lun_aligned(int64_t offset, int count,
431 IscsiLun *iscsilun)
91bea4e2 432{
94d047a3
EB
433 if (offset % iscsilun->block_size || count % iscsilun->block_size) {
434 error_report("iSCSI misaligned request: "
435 "iscsilun->block_size %u, offset %" PRIi64
436 ", count %d",
437 iscsilun->block_size, offset, count);
438 return false;
439 }
440 return true;
441}
442
443static bool is_sector_request_lun_aligned(int64_t sector_num, int nb_sectors,
444 IscsiLun *iscsilun)
445{
0ead9312 446 assert(nb_sectors <= BDRV_REQUEST_MAX_SECTORS);
94d047a3
EB
447 return is_byte_request_lun_aligned(sector_num << BDRV_SECTOR_BITS,
448 nb_sectors << BDRV_SECTOR_BITS,
449 iscsilun);
91bea4e2
PL
450}
451
e1123a3b 452static void iscsi_allocmap_free(IscsiLun *iscsilun)
a9fe4c95 453{
e1123a3b
PL
454 g_free(iscsilun->allocmap);
455 g_free(iscsilun->allocmap_valid);
456 iscsilun->allocmap = NULL;
457 iscsilun->allocmap_valid = NULL;
a9fe4c95
PL
458}
459
e1123a3b
PL
460
461static int iscsi_allocmap_init(IscsiLun *iscsilun, int open_flags)
b03c3805 462{
e1123a3b
PL
463 iscsi_allocmap_free(iscsilun);
464
ba059e7b 465 assert(iscsilun->cluster_size);
e1123a3b 466 iscsilun->allocmap_size =
ba059e7b
EB
467 DIV_ROUND_UP(iscsilun->num_blocks * iscsilun->block_size,
468 iscsilun->cluster_size);
e1123a3b
PL
469
470 iscsilun->allocmap = bitmap_try_new(iscsilun->allocmap_size);
471 if (!iscsilun->allocmap) {
472 return -ENOMEM;
b03c3805 473 }
e1123a3b
PL
474
475 if (open_flags & BDRV_O_NOCACHE) {
ba059e7b 476 /* when cache.direct = on all allocmap entries are
e1123a3b
PL
477 * treated as invalid to force a relookup of the block
478 * status on every read request */
479 return 0;
480 }
481
482 iscsilun->allocmap_valid = bitmap_try_new(iscsilun->allocmap_size);
483 if (!iscsilun->allocmap_valid) {
484 /* if we are under memory pressure free the allocmap as well */
485 iscsi_allocmap_free(iscsilun);
486 return -ENOMEM;
487 }
488
489 return 0;
b03c3805
PL
490}
491
e1123a3b 492static void
04a408fb
EB
493iscsi_allocmap_update(IscsiLun *iscsilun, int64_t offset,
494 int64_t bytes, bool allocated, bool valid)
b03c3805 495{
e1123a3b
PL
496 int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
497
498 if (iscsilun->allocmap == NULL) {
b03c3805
PL
499 return;
500 }
e1123a3b 501 /* expand to entirely contain all affected clusters */
04a408fb
EB
502 assert(iscsilun->cluster_size);
503 cl_num_expanded = offset / iscsilun->cluster_size;
504 nb_cls_expanded = DIV_ROUND_UP(offset + bytes,
505 iscsilun->cluster_size) - cl_num_expanded;
e1123a3b 506 /* shrink to touch only completely contained clusters */
04a408fb
EB
507 cl_num_shrunk = DIV_ROUND_UP(offset, iscsilun->cluster_size);
508 nb_cls_shrunk = (offset + bytes) / iscsilun->cluster_size - cl_num_shrunk;
e1123a3b
PL
509 if (allocated) {
510 bitmap_set(iscsilun->allocmap, cl_num_expanded, nb_cls_expanded);
511 } else {
1da45e0c
PL
512 if (nb_cls_shrunk > 0) {
513 bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk);
514 }
e1123a3b
PL
515 }
516
517 if (iscsilun->allocmap_valid == NULL) {
518 return;
519 }
520 if (valid) {
1da45e0c
PL
521 if (nb_cls_shrunk > 0) {
522 bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);
523 }
e1123a3b
PL
524 } else {
525 bitmap_clear(iscsilun->allocmap_valid, cl_num_expanded,
526 nb_cls_expanded);
527 }
528}
529
530static void
04a408fb
EB
531iscsi_allocmap_set_allocated(IscsiLun *iscsilun, int64_t offset,
532 int64_t bytes)
e1123a3b 533{
04a408fb 534 iscsi_allocmap_update(iscsilun, offset, bytes, true, true);
e1123a3b
PL
535}
536
537static void
04a408fb
EB
538iscsi_allocmap_set_unallocated(IscsiLun *iscsilun, int64_t offset,
539 int64_t bytes)
e1123a3b
PL
540{
541 /* Note: if cache.direct=on the fifth argument to iscsi_allocmap_update
542 * is ignored, so this will in effect be an iscsi_allocmap_set_invalid.
543 */
04a408fb 544 iscsi_allocmap_update(iscsilun, offset, bytes, false, true);
e1123a3b
PL
545}
546
04a408fb
EB
547static void iscsi_allocmap_set_invalid(IscsiLun *iscsilun, int64_t offset,
548 int64_t bytes)
e1123a3b 549{
04a408fb 550 iscsi_allocmap_update(iscsilun, offset, bytes, false, false);
e1123a3b
PL
551}
552
553static void iscsi_allocmap_invalidate(IscsiLun *iscsilun)
554{
555 if (iscsilun->allocmap) {
556 bitmap_zero(iscsilun->allocmap, iscsilun->allocmap_size);
557 }
558 if (iscsilun->allocmap_valid) {
559 bitmap_zero(iscsilun->allocmap_valid, iscsilun->allocmap_size);
560 }
561}
562
563static inline bool
04a408fb
EB
564iscsi_allocmap_is_allocated(IscsiLun *iscsilun, int64_t offset,
565 int64_t bytes)
e1123a3b
PL
566{
567 unsigned long size;
568 if (iscsilun->allocmap == NULL) {
569 return true;
b03c3805 570 }
ba059e7b 571 assert(iscsilun->cluster_size);
04a408fb 572 size = DIV_ROUND_UP(offset + bytes, iscsilun->cluster_size);
e1123a3b 573 return !(find_next_bit(iscsilun->allocmap, size,
04a408fb 574 offset / iscsilun->cluster_size) == size);
e1123a3b
PL
575}
576
577static inline bool iscsi_allocmap_is_valid(IscsiLun *iscsilun,
04a408fb 578 int64_t offset, int64_t bytes)
e1123a3b
PL
579{
580 unsigned long size;
581 if (iscsilun->allocmap_valid == NULL) {
582 return false;
583 }
ba059e7b 584 assert(iscsilun->cluster_size);
04a408fb 585 size = DIV_ROUND_UP(offset + bytes, iscsilun->cluster_size);
e1123a3b 586 return (find_next_zero_bit(iscsilun->allocmap_valid, size,
04a408fb 587 offset / iscsilun->cluster_size) == size);
b03c3805
PL
588}
589
66e75c03
FZ
590static void coroutine_fn iscsi_co_wait_for_task(IscsiTask *iTask,
591 IscsiLun *iscsilun)
592{
593 while (!iTask->complete) {
594 iscsi_set_events(iscsilun);
595 qemu_mutex_unlock(&iscsilun->mutex);
596 qemu_coroutine_yield();
597 qemu_mutex_lock(&iscsilun->mutex);
598 }
599}
600
9f0eb9e1 601static int coroutine_fn
e18a58b4
EB
602iscsi_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
603 QEMUIOVector *iov, int flags)
c589b249 604{
063c3378
PL
605 IscsiLun *iscsilun = bs->opaque;
606 struct IscsiTask iTask;
f4dfa67f 607 uint64_t lba;
063c3378 608 uint32_t num_sectors;
4df863f3 609 bool fua = flags & BDRV_REQ_FUA;
d045c466 610 int r = 0;
c589b249 611
4df863f3
EB
612 if (fua) {
613 assert(iscsilun->dpofua);
614 }
94d047a3 615 if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
063c3378
PL
616 return -EINVAL;
617 }
7371d56f 618
6bd01f14
EB
619 if (bs->bl.max_transfer) {
620 assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer);
dc9e7163
PL
621 }
622
063c3378
PL
623 lba = sector_qemu2lun(sector_num, iscsilun);
624 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
063c3378 625 iscsi_co_init_iscsitask(iscsilun, &iTask);
d045c466 626 qemu_mutex_lock(&iscsilun->mutex);
063c3378 627retry:
9281fe9e 628 if (iscsilun->use_16_for_rw) {
583ec22e
RS
629#if LIBISCSI_API_VERSION >= (20160603)
630 iTask.task = iscsi_write16_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
631 NULL, num_sectors * iscsilun->block_size,
632 iscsilun->block_size, 0, 0, fua, 0, 0,
633 iscsi_co_generic_cb, &iTask,
634 (struct scsi_iovec *)iov->iov, iov->niov);
635 } else {
636 iTask.task = iscsi_write10_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
637 NULL, num_sectors * iscsilun->block_size,
638 iscsilun->block_size, 0, 0, fua, 0, 0,
639 iscsi_co_generic_cb, &iTask,
640 (struct scsi_iovec *)iov->iov, iov->niov);
641 }
642#else
9281fe9e 643 iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,
8c215a9f 644 NULL, num_sectors * iscsilun->block_size,
73b5394e 645 iscsilun->block_size, 0, 0, fua, 0, 0,
9281fe9e
PL
646 iscsi_co_generic_cb, &iTask);
647 } else {
648 iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba,
8c215a9f 649 NULL, num_sectors * iscsilun->block_size,
73b5394e 650 iscsilun->block_size, 0, 0, fua, 0, 0,
9281fe9e
PL
651 iscsi_co_generic_cb, &iTask);
652 }
583ec22e 653#endif
063c3378 654 if (iTask.task == NULL) {
f6eb0b31 655 qemu_mutex_unlock(&iscsilun->mutex);
92397116 656 return -ENOMEM;
f4dfa67f 657 }
583ec22e 658#if LIBISCSI_API_VERSION < (20160603)
063c3378
PL
659 scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,
660 iov->niov);
583ec22e 661#endif
66e75c03 662 iscsi_co_wait_for_task(&iTask, iscsilun);
c589b249 663
063c3378
PL
664 if (iTask.task != NULL) {
665 scsi_free_scsi_task(iTask.task);
666 iTask.task = NULL;
91bea4e2
PL
667 }
668
063c3378 669 if (iTask.do_retry) {
837c3901 670 iTask.complete = 0;
063c3378 671 goto retry;
1dde716e
PL
672 }
673
063c3378 674 if (iTask.status != SCSI_STATUS_GOOD) {
04a408fb
EB
675 iscsi_allocmap_set_invalid(iscsilun, sector_num * BDRV_SECTOR_SIZE,
676 nb_sectors * BDRV_SECTOR_SIZE);
e38bc234
PL
677 error_report("iSCSI WRITE10/16 failed at lba %" PRIu64 ": %s", lba,
678 iTask.err_str);
d045c466
PB
679 r = iTask.err_code;
680 goto out_unlock;
c589b249
RS
681 }
682
04a408fb
EB
683 iscsi_allocmap_set_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE,
684 nb_sectors * BDRV_SECTOR_SIZE);
b03c3805 685
d045c466
PB
686out_unlock:
687 qemu_mutex_unlock(&iscsilun->mutex);
e38bc234 688 g_free(iTask.err_str);
d045c466 689 return r;
c589b249
RS
690}
691
b03c3805 692
b03c3805 693
92809c36
EB
694static int coroutine_fn iscsi_co_block_status(BlockDriverState *bs,
695 bool want_zero, int64_t offset,
696 int64_t bytes, int64_t *pnum,
697 int64_t *map,
698 BlockDriverState **file)
b03c3805
PL
699{
700 IscsiLun *iscsilun = bs->opaque;
701 struct scsi_get_lba_status *lbas = NULL;
702 struct scsi_lba_status_descriptor *lbasd = NULL;
703 struct IscsiTask iTask;
693fd2ac 704 uint64_t lba, max_bytes;
92809c36 705 int ret;
b03c3805 706
79f9c75e
PL
707 iscsi_co_init_iscsitask(iscsilun, &iTask);
708
92809c36 709 assert(QEMU_IS_ALIGNED(offset | bytes, iscsilun->block_size));
b03c3805
PL
710
711 /* default to all sectors allocated */
92809c36
EB
712 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
713 if (map) {
714 *map = offset;
715 }
716 *pnum = bytes;
b03c3805
PL
717
718 /* LUN does not support logical block provisioning */
0a386e48 719 if (!iscsilun->lbpme) {
b03c3805
PL
720 goto out;
721 }
722
92809c36 723 lba = offset / iscsilun->block_size;
693fd2ac 724 max_bytes = (iscsilun->num_blocks - lba) * iscsilun->block_size;
e38bc234 725
d045c466 726 qemu_mutex_lock(&iscsilun->mutex);
b03c3805
PL
727retry:
728 if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,
e38bc234 729 lba, 8 + 16, iscsi_co_generic_cb,
b03c3805
PL
730 &iTask) == NULL) {
731 ret = -ENOMEM;
d045c466 732 goto out_unlock;
b03c3805 733 }
66e75c03 734 iscsi_co_wait_for_task(&iTask, iscsilun);
b03c3805
PL
735
736 if (iTask.do_retry) {
737 if (iTask.task != NULL) {
738 scsi_free_scsi_task(iTask.task);
739 iTask.task = NULL;
740 }
741 iTask.complete = 0;
742 goto retry;
743 }
744
745 if (iTask.status != SCSI_STATUS_GOOD) {
746 /* in case the get_lba_status_callout fails (i.e.
747 * because the device is busy or the cmd is not
748 * supported) we pretend all blocks are allocated
749 * for backwards compatibility */
e38bc234
PL
750 error_report("iSCSI GET_LBA_STATUS failed at lba %" PRIu64 ": %s",
751 lba, iTask.err_str);
d045c466 752 goto out_unlock;
b03c3805
PL
753 }
754
755 lbas = scsi_datain_unmarshall(iTask.task);
5fbf1d56 756 if (lbas == NULL || lbas->num_descriptors == 0) {
b03c3805 757 ret = -EIO;
d045c466 758 goto out_unlock;
b03c3805
PL
759 }
760
761 lbasd = &lbas->descriptors[0];
762
92809c36 763 if (lba != lbasd->lba) {
b03c3805 764 ret = -EIO;
d045c466 765 goto out_unlock;
b03c3805
PL
766 }
767
693fd2ac 768 *pnum = MIN((int64_t) lbasd->num_blocks * iscsilun->block_size, max_bytes);
b03c3805
PL
769
770 if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED ||
771 lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) {
772 ret &= ~BDRV_BLOCK_DATA;
773 if (iscsilun->lbprz) {
774 ret |= BDRV_BLOCK_ZERO;
775 }
776 }
777
778 if (ret & BDRV_BLOCK_ZERO) {
92809c36 779 iscsi_allocmap_set_unallocated(iscsilun, offset, *pnum);
b03c3805 780 } else {
92809c36 781 iscsi_allocmap_set_allocated(iscsilun, offset, *pnum);
b03c3805
PL
782 }
783
d045c466
PB
784out_unlock:
785 qemu_mutex_unlock(&iscsilun->mutex);
e38bc234 786 g_free(iTask.err_str);
b03c3805
PL
787out:
788 if (iTask.task != NULL) {
789 scsi_free_scsi_task(iTask.task);
790 }
92809c36 791 if (ret > 0 && ret & BDRV_BLOCK_OFFSET_VALID && file) {
3399833f
FZ
792 *file = bs;
793 }
b03c3805
PL
794 return ret;
795}
796
063c3378
PL
797static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,
798 int64_t sector_num, int nb_sectors,
799 QEMUIOVector *iov)
c589b249 800{
063c3378
PL
801 IscsiLun *iscsilun = bs->opaque;
802 struct IscsiTask iTask;
1dde716e
PL
803 uint64_t lba;
804 uint32_t num_sectors;
e38bc234 805 int r = 0;
c589b249 806
94d047a3 807 if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
063c3378 808 return -EINVAL;
f4dfa67f 809 }
f4dfa67f 810
6bd01f14
EB
811 if (bs->bl.max_transfer) {
812 assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer);
dc9e7163
PL
813 }
814
e1123a3b
PL
815 /* if cache.direct is off and we have a valid entry in our allocation map
816 * we can skip checking the block status and directly return zeroes if
817 * the request falls within an unallocated area */
04a408fb
EB
818 if (iscsi_allocmap_is_valid(iscsilun, sector_num * BDRV_SECTOR_SIZE,
819 nb_sectors * BDRV_SECTOR_SIZE) &&
820 !iscsi_allocmap_is_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE,
821 nb_sectors * BDRV_SECTOR_SIZE)) {
e1123a3b
PL
822 qemu_iovec_memset(iov, 0, 0x00, iov->size);
823 return 0;
824 }
825
826 if (nb_sectors >= ISCSI_CHECKALLOC_THRES &&
04a408fb
EB
827 !iscsi_allocmap_is_valid(iscsilun, sector_num * BDRV_SECTOR_SIZE,
828 nb_sectors * BDRV_SECTOR_SIZE) &&
829 !iscsi_allocmap_is_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE,
830 nb_sectors * BDRV_SECTOR_SIZE)) {
92809c36 831 int64_t pnum;
e1123a3b
PL
832 /* check the block status from the beginning of the cluster
833 * containing the start sector */
92809c36
EB
834 int64_t head;
835 int ret;
836
837 assert(iscsilun->cluster_size);
838 head = (sector_num * BDRV_SECTOR_SIZE) % iscsilun->cluster_size;
839 ret = iscsi_co_block_status(bs, true,
840 sector_num * BDRV_SECTOR_SIZE - head,
841 BDRV_REQUEST_MAX_BYTES, &pnum, NULL, NULL);
b03c3805
PL
842 if (ret < 0) {
843 return ret;
844 }
e1123a3b 845 /* if the whole request falls into an unallocated area we can avoid
ba059e7b 846 * reading and directly return zeroes instead */
e1123a3b 847 if (ret & BDRV_BLOCK_ZERO &&
92809c36 848 pnum >= nb_sectors * BDRV_SECTOR_SIZE + head) {
b03c3805
PL
849 qemu_iovec_memset(iov, 0, 0x00, iov->size);
850 return 0;
851 }
852 }
b03c3805 853
063c3378
PL
854 lba = sector_qemu2lun(sector_num, iscsilun);
855 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
f4dfa67f 856
063c3378 857 iscsi_co_init_iscsitask(iscsilun, &iTask);
d045c466 858 qemu_mutex_lock(&iscsilun->mutex);
063c3378 859retry:
9281fe9e 860 if (iscsilun->use_16_for_rw) {
583ec22e
RS
861#if LIBISCSI_API_VERSION >= (20160603)
862 iTask.task = iscsi_read16_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
863 num_sectors * iscsilun->block_size,
864 iscsilun->block_size, 0, 0, 0, 0, 0,
865 iscsi_co_generic_cb, &iTask,
866 (struct scsi_iovec *)iov->iov, iov->niov);
867 } else {
868 iTask.task = iscsi_read10_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
869 num_sectors * iscsilun->block_size,
870 iscsilun->block_size,
871 0, 0, 0, 0, 0,
872 iscsi_co_generic_cb, &iTask,
873 (struct scsi_iovec *)iov->iov, iov->niov);
874 }
875#else
063c3378
PL
876 iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba,
877 num_sectors * iscsilun->block_size,
878 iscsilun->block_size, 0, 0, 0, 0, 0,
879 iscsi_co_generic_cb, &iTask);
9281fe9e 880 } else {
063c3378
PL
881 iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,
882 num_sectors * iscsilun->block_size,
219c2521 883 iscsilun->block_size,
219c2521 884 0, 0, 0, 0, 0,
063c3378 885 iscsi_co_generic_cb, &iTask);
f4dfa67f 886 }
583ec22e 887#endif
063c3378 888 if (iTask.task == NULL) {
f6eb0b31 889 qemu_mutex_unlock(&iscsilun->mutex);
92397116 890 return -ENOMEM;
c589b249 891 }
583ec22e 892#if LIBISCSI_API_VERSION < (20160603)
063c3378 893 scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);
583ec22e 894#endif
c589b249 895
66e75c03 896 iscsi_co_wait_for_task(&iTask, iscsilun);
063c3378
PL
897 if (iTask.task != NULL) {
898 scsi_free_scsi_task(iTask.task);
899 iTask.task = NULL;
c589b249
RS
900 }
901
063c3378 902 if (iTask.do_retry) {
837c3901 903 iTask.complete = 0;
063c3378 904 goto retry;
c589b249
RS
905 }
906
063c3378 907 if (iTask.status != SCSI_STATUS_GOOD) {
e38bc234
PL
908 error_report("iSCSI READ10/16 failed at lba %" PRIu64 ": %s",
909 lba, iTask.err_str);
910 r = iTask.err_code;
1dde716e
PL
911 }
912
e38bc234
PL
913 qemu_mutex_unlock(&iscsilun->mutex);
914 g_free(iTask.err_str);
915 return r;
1dde716e
PL
916}
917
063c3378 918static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)
1dde716e
PL
919{
920 IscsiLun *iscsilun = bs->opaque;
063c3378 921 struct IscsiTask iTask;
e38bc234 922 int r = 0;
1dde716e 923
73b5394e 924 iscsi_co_init_iscsitask(iscsilun, &iTask);
d045c466 925 qemu_mutex_lock(&iscsilun->mutex);
063c3378
PL
926retry:
927 if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,
928 0, iscsi_co_generic_cb, &iTask) == NULL) {
f6eb0b31 929 qemu_mutex_unlock(&iscsilun->mutex);
92397116 930 return -ENOMEM;
063c3378 931 }
1dde716e 932
66e75c03 933 iscsi_co_wait_for_task(&iTask, iscsilun);
1dde716e 934
063c3378
PL
935 if (iTask.task != NULL) {
936 scsi_free_scsi_task(iTask.task);
937 iTask.task = NULL;
c589b249
RS
938 }
939
063c3378 940 if (iTask.do_retry) {
837c3901 941 iTask.complete = 0;
063c3378
PL
942 goto retry;
943 }
c589b249 944
063c3378 945 if (iTask.status != SCSI_STATUS_GOOD) {
e38bc234
PL
946 error_report("iSCSI SYNCHRONIZECACHE10 failed: %s", iTask.err_str);
947 r = iTask.err_code;
063c3378
PL
948 }
949
e38bc234
PL
950 qemu_mutex_unlock(&iscsilun->mutex);
951 g_free(iTask.err_str);
952 return r;
c589b249
RS
953}
954
98392453 955#ifdef __linux__
d045c466 956/* Called (via iscsi_service) with QemuMutex held. */
98392453
RS
957static void
958iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
959 void *command_data, void *opaque)
960{
961 IscsiAIOCB *acb = opaque;
962
88e94fd2
SH
963 if (status == SCSI_STATUS_CANCELLED) {
964 if (!acb->bh) {
965 acb->status = -ECANCELED;
966 iscsi_schedule_bh(acb);
967 }
968 return;
969 }
970
98392453
RS
971 acb->status = 0;
972 if (status < 0) {
973 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
974 iscsi_get_error(iscsi));
8c460269 975 acb->status = -iscsi_translate_sense(&acb->task->sense);
98392453
RS
976 }
977
978 acb->ioh->driver_status = 0;
979 acb->ioh->host_status = 0;
980 acb->ioh->resid = 0;
644c6869 981 acb->ioh->status = status;
98392453
RS
982
983#define SG_ERR_DRIVER_SENSE 0x08
984
985 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
986 int ss;
987
988 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
989
990 acb->ioh->sb_len_wr = acb->task->datain.size - 2;
ff0507c2 991 ss = MIN(acb->ioh->mx_sb_len, acb->ioh->sb_len_wr);
98392453
RS
992 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
993 }
994
cfb3f506 995 iscsi_schedule_bh(acb);
98392453
RS
996}
997
4bb17ab5
FZ
998static void iscsi_ioctl_bh_completion(void *opaque)
999{
1000 IscsiAIOCB *acb = opaque;
1001
1002 qemu_bh_delete(acb->bh);
1003 acb->common.cb(acb->common.opaque, acb->ret);
1004 qemu_aio_unref(acb);
1005}
1006
1007static void iscsi_ioctl_handle_emulated(IscsiAIOCB *acb, int req, void *buf)
1008{
1009 BlockDriverState *bs = acb->common.bs;
1010 IscsiLun *iscsilun = bs->opaque;
1011 int ret = 0;
1012
1013 switch (req) {
1014 case SG_GET_VERSION_NUM:
1015 *(int *)buf = 30000;
1016 break;
1017 case SG_GET_SCSI_ID:
1018 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
1019 break;
1020 default:
1021 ret = -EINVAL;
1022 }
1023 assert(!acb->bh);
1024 acb->bh = aio_bh_new(bdrv_get_aio_context(bs),
1025 iscsi_ioctl_bh_completion, acb);
1026 acb->ret = ret;
1027 qemu_bh_schedule(acb->bh);
1028}
1029
7c84b1b8 1030static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
98392453 1031 unsigned long int req, void *buf,
097310b5 1032 BlockCompletionFunc *cb, void *opaque)
98392453
RS
1033{
1034 IscsiLun *iscsilun = bs->opaque;
1035 struct iscsi_context *iscsi = iscsilun->iscsi;
1036 struct iscsi_data data;
1037 IscsiAIOCB *acb;
1038
d7331bed 1039 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
98392453
RS
1040
1041 acb->iscsilun = iscsilun;
1bd075f2
PB
1042 acb->bh = NULL;
1043 acb->status = -EINPROGRESS;
98392453 1044 acb->ioh = buf;
c1004487 1045 acb->cancelled = false;
98392453 1046
4bb17ab5
FZ
1047 if (req != SG_IO) {
1048 iscsi_ioctl_handle_emulated(acb, req, buf);
1049 return &acb->common;
1050 }
1051
a6b3167f
PL
1052 if (acb->ioh->cmd_len > SCSI_CDB_MAX_SIZE) {
1053 error_report("iSCSI: ioctl error CDB exceeds max size (%d > %d)",
1054 acb->ioh->cmd_len, SCSI_CDB_MAX_SIZE);
1055 qemu_aio_unref(acb);
1056 return NULL;
1057 }
1058
98392453
RS
1059 acb->task = malloc(sizeof(struct scsi_task));
1060 if (acb->task == NULL) {
1061 error_report("iSCSI: Failed to allocate task for scsi command. %s",
1062 iscsi_get_error(iscsi));
8007429a 1063 qemu_aio_unref(acb);
98392453
RS
1064 return NULL;
1065 }
1066 memset(acb->task, 0, sizeof(struct scsi_task));
1067
1068 switch (acb->ioh->dxfer_direction) {
1069 case SG_DXFER_TO_DEV:
1070 acb->task->xfer_dir = SCSI_XFER_WRITE;
1071 break;
1072 case SG_DXFER_FROM_DEV:
1073 acb->task->xfer_dir = SCSI_XFER_READ;
1074 break;
1075 default:
1076 acb->task->xfer_dir = SCSI_XFER_NONE;
1077 break;
1078 }
1079
1080 acb->task->cdb_size = acb->ioh->cmd_len;
1081 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
1082 acb->task->expxferlen = acb->ioh->dxfer_len;
1083
0a53f010 1084 data.size = 0;
d045c466 1085 qemu_mutex_lock(&iscsilun->mutex);
98392453 1086 if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
0a53f010
RS
1087 if (acb->ioh->iovec_count == 0) {
1088 data.data = acb->ioh->dxferp;
1089 data.size = acb->ioh->dxfer_len;
1090 } else {
0a53f010
RS
1091 scsi_task_set_iov_out(acb->task,
1092 (struct scsi_iovec *) acb->ioh->dxferp,
1093 acb->ioh->iovec_count);
0a53f010 1094 }
98392453 1095 }
0a53f010 1096
98392453
RS
1097 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
1098 iscsi_aio_ioctl_cb,
0a53f010 1099 (data.size > 0) ? &data : NULL,
98392453 1100 acb) != 0) {
d045c466 1101 qemu_mutex_unlock(&iscsilun->mutex);
98392453 1102 scsi_free_scsi_task(acb->task);
8007429a 1103 qemu_aio_unref(acb);
98392453
RS
1104 return NULL;
1105 }
1106
1107 /* tell libiscsi to read straight into the buffer we got from ioctl */
1108 if (acb->task->xfer_dir == SCSI_XFER_READ) {
0a53f010
RS
1109 if (acb->ioh->iovec_count == 0) {
1110 scsi_task_add_data_in_buffer(acb->task,
1111 acb->ioh->dxfer_len,
1112 acb->ioh->dxferp);
1113 } else {
0a53f010
RS
1114 scsi_task_set_iov_in(acb->task,
1115 (struct scsi_iovec *) acb->ioh->dxferp,
1116 acb->ioh->iovec_count);
0a53f010 1117 }
98392453
RS
1118 }
1119
1120 iscsi_set_events(iscsilun);
d045c466 1121 qemu_mutex_unlock(&iscsilun->mutex);
98392453
RS
1122
1123 return &acb->common;
1124}
1125
98392453
RS
1126#endif
1127
c589b249
RS
1128static int64_t
1129iscsi_getlength(BlockDriverState *bs)
1130{
1131 IscsiLun *iscsilun = bs->opaque;
1132 int64_t len;
1133
1134 len = iscsilun->num_blocks;
1135 len *= iscsilun->block_size;
1136
1137 return len;
1138}
1139
65f3e339 1140static int
f5a5ca79 1141coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
65f3e339
PL
1142{
1143 IscsiLun *iscsilun = bs->opaque;
1144 struct IscsiTask iTask;
1145 struct unmap_list list;
d045c466 1146 int r = 0;
65f3e339 1147
f5a5ca79 1148 if (!is_byte_request_lun_aligned(offset, bytes, iscsilun)) {
49228d1e
EB
1149 return -ENOTSUP;
1150 }
65f3e339
PL
1151
1152 if (!iscsilun->lbp.lbpu) {
1153 /* UNMAP is not supported by the target */
1154 return 0;
1155 }
1156
97c7e85c 1157 list.lba = offset / iscsilun->block_size;
f5a5ca79 1158 list.num = bytes / iscsilun->block_size;
65f3e339 1159
01a6a238 1160 iscsi_co_init_iscsitask(iscsilun, &iTask);
d045c466 1161 qemu_mutex_lock(&iscsilun->mutex);
65f3e339 1162retry:
01a6a238 1163 if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
97c7e85c 1164 iscsi_co_generic_cb, &iTask) == NULL) {
d045c466
PB
1165 r = -ENOMEM;
1166 goto out_unlock;
01a6a238 1167 }
65f3e339 1168
66e75c03 1169 iscsi_co_wait_for_task(&iTask, iscsilun);
65f3e339 1170
01a6a238
PL
1171 if (iTask.task != NULL) {
1172 scsi_free_scsi_task(iTask.task);
1173 iTask.task = NULL;
1174 }
65f3e339 1175
01a6a238 1176 if (iTask.do_retry) {
837c3901 1177 iTask.complete = 0;
01a6a238
PL
1178 goto retry;
1179 }
65f3e339 1180
04a408fb 1181 iscsi_allocmap_set_invalid(iscsilun, offset, bytes);
aef172ff 1182
01a6a238
PL
1183 if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
1184 /* the target might fail with a check condition if it
1185 is not happy with the alignment of the UNMAP request
1186 we silently fail in this case */
d045c466 1187 goto out_unlock;
01a6a238 1188 }
65f3e339 1189
01a6a238 1190 if (iTask.status != SCSI_STATUS_GOOD) {
e38bc234
PL
1191 error_report("iSCSI UNMAP failed at lba %" PRIu64 ": %s",
1192 list.lba, iTask.err_str);
d045c466
PB
1193 r = iTask.err_code;
1194 goto out_unlock;
65f3e339
PL
1195 }
1196
d045c466
PB
1197out_unlock:
1198 qemu_mutex_unlock(&iscsilun->mutex);
e38bc234 1199 g_free(iTask.err_str);
d045c466 1200 return r;
65f3e339
PL
1201}
1202
d4cd9615 1203static int
94d047a3 1204coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
f5a5ca79 1205 int bytes, BdrvRequestFlags flags)
d4cd9615
PL
1206{
1207 IscsiLun *iscsilun = bs->opaque;
1208 struct IscsiTask iTask;
1209 uint64_t lba;
1210 uint32_t nb_blocks;
9281fe9e 1211 bool use_16_for_ws = iscsilun->use_16_for_rw;
d045c466 1212 int r = 0;
d4cd9615 1213
f5a5ca79 1214 if (!is_byte_request_lun_aligned(offset, bytes, iscsilun)) {
94d047a3 1215 return -ENOTSUP;
d4cd9615
PL
1216 }
1217
9281fe9e
PL
1218 if (flags & BDRV_REQ_MAY_UNMAP) {
1219 if (!use_16_for_ws && !iscsilun->lbp.lbpws10) {
1220 /* WRITESAME10 with UNMAP is unsupported try WRITESAME16 */
1221 use_16_for_ws = true;
1222 }
1223 if (use_16_for_ws && !iscsilun->lbp.lbpws) {
1224 /* WRITESAME16 with UNMAP is not supported by the target,
1225 * fall back and try WRITESAME10/16 without UNMAP */
1226 flags &= ~BDRV_REQ_MAY_UNMAP;
1227 use_16_for_ws = iscsilun->use_16_for_rw;
1228 }
fa6252b0
PB
1229 }
1230
dbe5c58f 1231 if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
9281fe9e 1232 /* WRITESAME without UNMAP is not supported by the target */
d4cd9615
PL
1233 return -ENOTSUP;
1234 }
1235
94d047a3 1236 lba = offset / iscsilun->block_size;
f5a5ca79 1237 nb_blocks = bytes / iscsilun->block_size;
d4cd9615
PL
1238
1239 if (iscsilun->zeroblock == NULL) {
4d5a3f88
KW
1240 iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size);
1241 if (iscsilun->zeroblock == NULL) {
1242 return -ENOMEM;
1243 }
d4cd9615
PL
1244 }
1245
d045c466 1246 qemu_mutex_lock(&iscsilun->mutex);
d4cd9615
PL
1247 iscsi_co_init_iscsitask(iscsilun, &iTask);
1248retry:
9281fe9e
PL
1249 if (use_16_for_ws) {
1250 iTask.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
1251 iscsilun->zeroblock, iscsilun->block_size,
1252 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1253 0, 0, iscsi_co_generic_cb, &iTask);
1254 } else {
1255 iTask.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba,
1256 iscsilun->zeroblock, iscsilun->block_size,
1257 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1258 0, 0, iscsi_co_generic_cb, &iTask);
1259 }
1260 if (iTask.task == NULL) {
f6eb0b31 1261 qemu_mutex_unlock(&iscsilun->mutex);
92397116 1262 return -ENOMEM;
d4cd9615
PL
1263 }
1264
66e75c03 1265 iscsi_co_wait_for_task(&iTask, iscsilun);
d4cd9615 1266
d9738fd2
PL
1267 if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
1268 iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
27898a5d
PB
1269 (iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE ||
1270 iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) {
d9738fd2
PL
1271 /* WRITE SAME is not supported by the target */
1272 iscsilun->has_write_same = false;
1273 scsi_free_scsi_task(iTask.task);
d045c466
PB
1274 r = -ENOTSUP;
1275 goto out_unlock;
d9738fd2
PL
1276 }
1277
d4cd9615
PL
1278 if (iTask.task != NULL) {
1279 scsi_free_scsi_task(iTask.task);
1280 iTask.task = NULL;
1281 }
1282
1283 if (iTask.do_retry) {
837c3901 1284 iTask.complete = 0;
d4cd9615
PL
1285 goto retry;
1286 }
1287
1288 if (iTask.status != SCSI_STATUS_GOOD) {
04a408fb 1289 iscsi_allocmap_set_invalid(iscsilun, offset, bytes);
e38bc234
PL
1290 error_report("iSCSI WRITESAME10/16 failed at lba %" PRIu64 ": %s",
1291 lba, iTask.err_str);
d045c466
PB
1292 r = iTask.err_code;
1293 goto out_unlock;
d4cd9615
PL
1294 }
1295
b03c3805 1296 if (flags & BDRV_REQ_MAY_UNMAP) {
04a408fb 1297 iscsi_allocmap_set_invalid(iscsilun, offset, bytes);
b03c3805 1298 } else {
04a408fb 1299 iscsi_allocmap_set_allocated(iscsilun, offset, bytes);
b03c3805
PL
1300 }
1301
d045c466
PB
1302out_unlock:
1303 qemu_mutex_unlock(&iscsilun->mutex);
e38bc234 1304 g_free(iTask.err_str);
d045c466 1305 return r;
d4cd9615
PL
1306}
1307
43171420 1308static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
f2917853 1309 Error **errp)
f9dadc98 1310{
f9dadc98
RS
1311 const char *user = NULL;
1312 const char *password = NULL;
b189346e
DB
1313 const char *secretid;
1314 char *secret = NULL;
f9dadc98 1315
f9dadc98
RS
1316 user = qemu_opt_get(opts, "user");
1317 if (!user) {
f2917853 1318 return;
f9dadc98
RS
1319 }
1320
b189346e 1321 secretid = qemu_opt_get(opts, "password-secret");
f9dadc98 1322 password = qemu_opt_get(opts, "password");
b189346e
DB
1323 if (secretid && password) {
1324 error_setg(errp, "'password' and 'password-secret' properties are "
1325 "mutually exclusive");
1326 return;
1327 }
1328 if (secretid) {
1329 secret = qcrypto_secret_lookup_as_utf8(secretid, errp);
1330 if (!secret) {
1331 return;
1332 }
1333 password = secret;
1334 } else if (!password) {
f2917853
PB
1335 error_setg(errp, "CHAP username specified but no password was given");
1336 return;
f9dadc98
RS
1337 }
1338
1339 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
f2917853 1340 error_setg(errp, "Failed to set initiator username and password");
f9dadc98 1341 }
b189346e
DB
1342
1343 g_free(secret);
f9dadc98
RS
1344}
1345
81aa2a0f 1346static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
f2917853 1347 Error **errp)
f9dadc98 1348{
f9dadc98
RS
1349 const char *digest = NULL;
1350
f9dadc98
RS
1351 digest = qemu_opt_get(opts, "header-digest");
1352 if (!digest) {
81aa2a0f 1353 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
31eb1202 1354 } else if (!strcmp(digest, "crc32c")) {
f9dadc98 1355 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
31eb1202 1356 } else if (!strcmp(digest, "none")) {
f9dadc98 1357 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
31eb1202 1358 } else if (!strcmp(digest, "crc32c-none")) {
f9dadc98 1359 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
31eb1202 1360 } else if (!strcmp(digest, "none-crc32c")) {
f9dadc98
RS
1361 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1362 } else {
f2917853 1363 error_setg(errp, "Invalid header-digest setting : %s", digest);
f9dadc98
RS
1364 }
1365}
1366
d4e79929 1367static char *get_initiator_name(QemuOpts *opts)
f9dadc98 1368{
5accc840
PB
1369 const char *name;
1370 char *iscsi_name;
1371 UuidInfo *uuid_info;
f9dadc98 1372
d4e79929
KW
1373 name = qemu_opt_get(opts, "initiator-name");
1374 if (name) {
1375 return g_strdup(name);
f9dadc98
RS
1376 }
1377
5accc840
PB
1378 uuid_info = qmp_query_uuid(NULL);
1379 if (strcmp(uuid_info->UUID, UUID_NONE) == 0) {
1380 name = qemu_get_vm_name();
f2ef4a6d 1381 } else {
5accc840 1382 name = uuid_info->UUID;
f9dadc98 1383 }
5accc840
PB
1384 iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
1385 name ? ":" : "", name ? name : "");
1386 qapi_free_UuidInfo(uuid_info);
1387 return iscsi_name;
f9dadc98
RS
1388}
1389
5b5d34ec
PL
1390static void iscsi_nop_timed_event(void *opaque)
1391{
1392 IscsiLun *iscsilun = opaque;
1393
6e8a355d 1394 QEMU_LOCK_GUARD(&iscsilun->mutex);
5dd7a535 1395 if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
5b5d34ec 1396 error_report("iSCSI: NOP timeout. Reconnecting...");
5dd7a535
PL
1397 iscsilun->request_timed_out = true;
1398 } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
5b5d34ec 1399 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
6e8a355d 1400 return;
5b5d34ec
PL
1401 }
1402
bc72ad67 1403 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
5b5d34ec
PL
1404 iscsi_set_events(iscsilun);
1405}
5b5d34ec 1406
f2917853 1407static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
cb1b83e7
PL
1408{
1409 struct scsi_task *task = NULL;
1410 struct scsi_readcapacity10 *rc10 = NULL;
1411 struct scsi_readcapacity16 *rc16 = NULL;
cb1b83e7
PL
1412 int retries = ISCSI_CMD_RETRIES;
1413
1288844e
PB
1414 do {
1415 if (task != NULL) {
1416 scsi_free_scsi_task(task);
1417 task = NULL;
cb1b83e7 1418 }
1288844e
PB
1419
1420 switch (iscsilun->type) {
1421 case TYPE_DISK:
1422 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun);
1423 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1424 rc16 = scsi_datain_unmarshall(task);
1425 if (rc16 == NULL) {
f2917853 1426 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity16 data.");
1288844e
PB
1427 } else {
1428 iscsilun->block_size = rc16->block_length;
1429 iscsilun->num_blocks = rc16->returned_lba + 1;
0a386e48
PL
1430 iscsilun->lbpme = !!rc16->lbpme;
1431 iscsilun->lbprz = !!rc16->lbprz;
9281fe9e 1432 iscsilun->use_16_for_rw = (rc16->returned_lba > 0xffffffff);
1288844e 1433 }
1cb6d137 1434 break;
1288844e 1435 }
1cb6d137
ZL
1436 if (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1437 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
1438 break;
1439 }
1440 /* Fall through and try READ CAPACITY(10) instead. */
1288844e
PB
1441 case TYPE_ROM:
1442 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0);
1443 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1444 rc10 = scsi_datain_unmarshall(task);
1445 if (rc10 == NULL) {
f2917853 1446 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity10 data.");
1288844e
PB
1447 } else {
1448 iscsilun->block_size = rc10->block_size;
1449 if (rc10->lba == 0) {
1450 /* blank disk loaded */
1451 iscsilun->num_blocks = 0;
1452 } else {
1453 iscsilun->num_blocks = rc10->lba + 1;
1454 }
1455 }
1456 }
1457 break;
1458 default:
f2917853 1459 return;
cb1b83e7 1460 }
1288844e
PB
1461 } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1462 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION
1463 && retries-- > 0);
cb1b83e7 1464
1288844e 1465 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
240125bc 1466 error_setg(errp, "iSCSI: failed to send readcapacity10/16 command");
6d1f252d
PL
1467 } else if (!iscsilun->block_size ||
1468 iscsilun->block_size % BDRV_SECTOR_SIZE) {
1469 error_setg(errp, "iSCSI: the target returned an invalid "
1470 "block size of %d.", iscsilun->block_size);
1288844e 1471 }
cb1b83e7
PL
1472 if (task) {
1473 scsi_free_scsi_task(task);
1474 }
cb1b83e7
PL
1475}
1476
35cb1748 1477static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
24d3bd67 1478 int evpd, int pc, void **inq, Error **errp)
35cb1748
PB
1479{
1480 int full_size;
1481 struct scsi_task *task = NULL;
1482 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
1483 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1484 goto fail;
1485 }
1486 full_size = scsi_datain_getfullsize(task);
1487 if (full_size > task->datain.size) {
1488 scsi_free_scsi_task(task);
1489
1490 /* we need more data for the full list */
1491 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size);
f18a7cbb
PL
1492 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1493 goto fail;
1494 }
35cb1748 1495 }
f18a7cbb 1496
24d3bd67
PL
1497 *inq = scsi_datain_unmarshall(task);
1498 if (*inq == NULL) {
1499 error_setg(errp, "iSCSI: failed to unmarshall inquiry datain blob");
172fc4dd 1500 goto fail_with_err;
24d3bd67
PL
1501 }
1502
35cb1748 1503 return task;
f18a7cbb
PL
1504
1505fail:
172fc4dd
MA
1506 error_setg(errp, "iSCSI: Inquiry command failed : %s",
1507 iscsi_get_error(iscsi));
1508fail_with_err:
24d3bd67 1509 if (task != NULL) {
35cb1748 1510 scsi_free_scsi_task(task);
35cb1748
PB
1511 }
1512 return NULL;
f18a7cbb
PL
1513}
1514
80cf6257
SH
1515static void iscsi_detach_aio_context(BlockDriverState *bs)
1516{
1517 IscsiLun *iscsilun = bs->opaque;
1518
dca21ef2 1519 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
f6a51c84 1520 false, NULL, NULL, NULL, NULL);
80cf6257
SH
1521 iscsilun->events = 0;
1522
1523 if (iscsilun->nop_timer) {
80cf6257
SH
1524 timer_free(iscsilun->nop_timer);
1525 iscsilun->nop_timer = NULL;
1526 }
05b685fb 1527 if (iscsilun->event_timer) {
05b685fb
PL
1528 timer_free(iscsilun->event_timer);
1529 iscsilun->event_timer = NULL;
1530 }
80cf6257
SH
1531}
1532
1533static void iscsi_attach_aio_context(BlockDriverState *bs,
1534 AioContext *new_context)
1535{
1536 IscsiLun *iscsilun = bs->opaque;
1537
1538 iscsilun->aio_context = new_context;
1539 iscsi_set_events(iscsilun);
1540
80cf6257
SH
1541 /* Set up a timer for sending out iSCSI NOPs */
1542 iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
1543 QEMU_CLOCK_REALTIME, SCALE_MS,
1544 iscsi_nop_timed_event, iscsilun);
1545 timer_mod(iscsilun->nop_timer,
1546 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
05b685fb 1547
5dd7a535
PL
1548 /* Set up a timer for periodic calls to iscsi_set_events and to
1549 * scan for command timeout */
05b685fb
PL
1550 iscsilun->event_timer = aio_timer_new(iscsilun->aio_context,
1551 QEMU_CLOCK_REALTIME, SCALE_MS,
5dd7a535
PL
1552 iscsi_timed_check_events, iscsilun);
1553 timer_mod(iscsilun->event_timer,
1554 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
80cf6257
SH
1555}
1556
7191f208 1557static void iscsi_modesense_sync(IscsiLun *iscsilun)
c1d4096b
FZ
1558{
1559 struct scsi_task *task;
1560 struct scsi_mode_sense *ms = NULL;
7191f208 1561 iscsilun->write_protected = false;
752ce451 1562 iscsilun->dpofua = false;
c1d4096b
FZ
1563
1564 task = iscsi_modesense6_sync(iscsilun->iscsi, iscsilun->lun,
1565 1, SCSI_MODESENSE_PC_CURRENT,
1566 0x3F, 0, 255);
1567 if (task == NULL) {
1568 error_report("iSCSI: Failed to send MODE_SENSE(6) command: %s",
1569 iscsi_get_error(iscsilun->iscsi));
1570 goto out;
1571 }
1572
1573 if (task->status != SCSI_STATUS_GOOD) {
1574 error_report("iSCSI: Failed MODE_SENSE(6), LUN assumed writable");
1575 goto out;
1576 }
1577 ms = scsi_datain_unmarshall(task);
1578 if (!ms) {
1579 error_report("iSCSI: Failed to unmarshall MODE_SENSE(6) data: %s",
1580 iscsi_get_error(iscsilun->iscsi));
1581 goto out;
1582 }
7191f208 1583 iscsilun->write_protected = ms->device_specific_parameter & 0x80;
752ce451 1584 iscsilun->dpofua = ms->device_specific_parameter & 0x10;
c1d4096b
FZ
1585
1586out:
1587 if (task) {
1588 scsi_free_scsi_task(task);
1589 }
c1d4096b
FZ
1590}
1591
43171420
KW
1592static void iscsi_parse_iscsi_option(const char *target, QDict *options)
1593{
1594 QemuOptsList *list;
1595 QemuOpts *opts;
81aa2a0f 1596 const char *user, *password, *password_secret, *initiator_name,
1d560104 1597 *header_digest, *timeout;
43171420
KW
1598
1599 list = qemu_find_opts("iscsi");
1600 if (!list) {
1601 return;
1602 }
1603
1604 opts = qemu_opts_find(list, target);
1605 if (opts == NULL) {
1606 opts = QTAILQ_FIRST(&list->head);
1607 if (!opts) {
1608 return;
1609 }
1610 }
1611
1612 user = qemu_opt_get(opts, "user");
1613 if (user) {
1614 qdict_set_default_str(options, "user", user);
1615 }
1616
1617 password = qemu_opt_get(opts, "password");
1618 if (password) {
1619 qdict_set_default_str(options, "password", password);
1620 }
1621
1622 password_secret = qemu_opt_get(opts, "password-secret");
1623 if (password_secret) {
1624 qdict_set_default_str(options, "password-secret", password_secret);
1625 }
d4e79929
KW
1626
1627 initiator_name = qemu_opt_get(opts, "initiator-name");
1628 if (initiator_name) {
1629 qdict_set_default_str(options, "initiator-name", initiator_name);
1630 }
81aa2a0f
KW
1631
1632 header_digest = qemu_opt_get(opts, "header-digest");
1633 if (header_digest) {
31eb1202
KW
1634 /* -iscsi takes upper case values, but QAPI only supports lower case
1635 * enum constant names, so we have to convert here. */
1636 char *qapi_value = g_ascii_strdown(header_digest, -1);
1637 qdict_set_default_str(options, "header-digest", qapi_value);
1638 g_free(qapi_value);
81aa2a0f 1639 }
1d560104
KW
1640
1641 timeout = qemu_opt_get(opts, "timeout");
1642 if (timeout) {
1643 qdict_set_default_str(options, "timeout", timeout);
1644 }
43171420
KW
1645}
1646
c589b249
RS
1647/*
1648 * We support iscsi url's on the form
1649 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1650 */
d5895fcb
KW
1651static void iscsi_parse_filename(const char *filename, QDict *options,
1652 Error **errp)
1653{
1654 struct iscsi_url *iscsi_url;
1655 const char *transport_name;
1656 char *lun_str;
1657
1658 iscsi_url = iscsi_parse_full_url(NULL, filename);
1659 if (iscsi_url == NULL) {
1660 error_setg(errp, "Failed to parse URL : %s", filename);
1661 return;
1662 }
1663
1664#if LIBISCSI_API_VERSION >= (20160603)
1665 switch (iscsi_url->transport) {
1666 case TCP_TRANSPORT:
1667 transport_name = "tcp";
1668 break;
1669 case ISER_TRANSPORT:
1670 transport_name = "iser";
1671 break;
1672 default:
1673 error_setg(errp, "Unknown transport type (%d)",
1674 iscsi_url->transport);
1675 return;
1676 }
1677#else
1678 transport_name = "tcp";
1679#endif
1680
1681 qdict_set_default_str(options, "transport", transport_name);
1682 qdict_set_default_str(options, "portal", iscsi_url->portal);
1683 qdict_set_default_str(options, "target", iscsi_url->target);
1684
1685 lun_str = g_strdup_printf("%d", iscsi_url->lun);
1686 qdict_set_default_str(options, "lun", lun_str);
1687 g_free(lun_str);
1688
43171420
KW
1689 /* User/password from -iscsi take precedence over those from the URL */
1690 iscsi_parse_iscsi_option(iscsi_url->target, options);
1691
d5895fcb
KW
1692 if (iscsi_url->user[0] != '\0') {
1693 qdict_set_default_str(options, "user", iscsi_url->user);
1694 qdict_set_default_str(options, "password", iscsi_url->passwd);
1695 }
1696
1697 iscsi_destroy_url(iscsi_url);
1698}
1699
d5895fcb
KW
1700static QemuOptsList runtime_opts = {
1701 .name = "iscsi",
1702 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1703 .desc = {
1704 {
1705 .name = "transport",
1706 .type = QEMU_OPT_STRING,
1707 },
1708 {
1709 .name = "portal",
1710 .type = QEMU_OPT_STRING,
1711 },
1712 {
1713 .name = "target",
1714 .type = QEMU_OPT_STRING,
1715 },
1716 {
1717 .name = "user",
1718 .type = QEMU_OPT_STRING,
1719 },
1720 {
1721 .name = "password",
1722 .type = QEMU_OPT_STRING,
1723 },
43171420
KW
1724 {
1725 .name = "password-secret",
1726 .type = QEMU_OPT_STRING,
1727 },
d5895fcb
KW
1728 {
1729 .name = "lun",
1730 .type = QEMU_OPT_NUMBER,
1731 },
d4e79929
KW
1732 {
1733 .name = "initiator-name",
1734 .type = QEMU_OPT_STRING,
1735 },
81aa2a0f
KW
1736 {
1737 .name = "header-digest",
1738 .type = QEMU_OPT_STRING,
1739 },
1d560104
KW
1740 {
1741 .name = "timeout",
1742 .type = QEMU_OPT_NUMBER,
1743 },
d5895fcb
KW
1744 { /* end of list */ }
1745 },
1746};
1747
cc9743c2
FZ
1748static void iscsi_save_designator(IscsiLun *lun,
1749 struct scsi_inquiry_device_identification *inq_di)
1750{
1751 struct scsi_inquiry_device_designator *desig, *copy = NULL;
1752
1753 for (desig = inq_di->designators; desig; desig = desig->next) {
1754 if (desig->association ||
1755 desig->designator_type > SCSI_DESIGNATOR_TYPE_NAA) {
1756 continue;
1757 }
1758 /* NAA works better than T10 vendor ID based designator. */
1759 if (!copy || copy->designator_type < desig->designator_type) {
1760 copy = desig;
1761 }
1762 }
1763 if (copy) {
1764 lun->dd = g_new(struct scsi_inquiry_device_designator, 1);
1765 *lun->dd = *copy;
1766 lun->dd->next = NULL;
1767 lun->dd->designator = g_malloc(copy->designator_length);
1768 memcpy(lun->dd->designator, copy->designator, copy->designator_length);
1769 }
1770}
1771
015a1036
HR
1772static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
1773 Error **errp)
c589b249
RS
1774{
1775 IscsiLun *iscsilun = bs->opaque;
1776 struct iscsi_context *iscsi = NULL;
e829b0bb
PL
1777 struct scsi_task *task = NULL;
1778 struct scsi_inquiry_standard *inq = NULL;
24d3bd67 1779 struct scsi_inquiry_supported_pages *inq_vpd;
f9dadc98 1780 char *initiator_name = NULL;
60beb341
KW
1781 QemuOpts *opts;
1782 Error *local_err = NULL;
deadbb8e 1783 const char *transport_name, *portal, *target;
d5895fcb
KW
1784#if LIBISCSI_API_VERSION >= (20160603)
1785 enum iscsi_transport_type transport;
1786#endif
1787 int i, ret = 0, timeout = 0, lun;
c589b249 1788
87ea75d5 1789 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
af175e85 1790 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
60beb341
KW
1791 ret = -EINVAL;
1792 goto out;
1793 }
1794
d5895fcb
KW
1795 transport_name = qemu_opt_get(opts, "transport");
1796 portal = qemu_opt_get(opts, "portal");
1797 target = qemu_opt_get(opts, "target");
d5895fcb 1798 lun = qemu_opt_get_number(opts, "lun", 0);
60beb341 1799
d5895fcb
KW
1800 if (!transport_name || !portal || !target) {
1801 error_setg(errp, "Need all of transport, portal and target options");
1802 ret = -EINVAL;
1803 goto out;
1804 }
d5895fcb
KW
1805
1806 if (!strcmp(transport_name, "tcp")) {
1807#if LIBISCSI_API_VERSION >= (20160603)
1808 transport = TCP_TRANSPORT;
1809 } else if (!strcmp(transport_name, "iser")) {
1810 transport = ISER_TRANSPORT;
1811#else
1812 /* TCP is what older libiscsi versions always use */
1813#endif
1814 } else {
1815 error_setg(errp, "Unknown transport: %s", transport_name);
c589b249 1816 ret = -EINVAL;
b93c94f7 1817 goto out;
c589b249
RS
1818 }
1819
f9dadc98
RS
1820 memset(iscsilun, 0, sizeof(IscsiLun));
1821
d4e79929 1822 initiator_name = get_initiator_name(opts);
f9dadc98
RS
1823
1824 iscsi = iscsi_create_context(initiator_name);
1825 if (iscsi == NULL) {
f2917853 1826 error_setg(errp, "iSCSI: Failed to create iSCSI context.");
f9dadc98 1827 ret = -ENOMEM;
b93c94f7 1828 goto out;
f9dadc98 1829 }
e0ae4987 1830#if LIBISCSI_API_VERSION >= (20160603)
d5895fcb 1831 if (iscsi_init_transport(iscsi, transport)) {
e0ae4987
RS
1832 error_setg(errp, ("Error initializing transport."));
1833 ret = -EINVAL;
1834 goto out;
1835 }
1836#endif
d5895fcb 1837 if (iscsi_set_targetname(iscsi, target)) {
f2917853 1838 error_setg(errp, "iSCSI: Failed to set target name.");
c589b249 1839 ret = -EINVAL;
b93c94f7 1840 goto out;
c589b249
RS
1841 }
1842
f9dadc98 1843 /* check if we got CHAP username/password via the options */
43171420 1844 apply_chap(iscsi, opts, &local_err);
f2917853
PB
1845 if (local_err != NULL) {
1846 error_propagate(errp, local_err);
f9dadc98 1847 ret = -EINVAL;
b93c94f7 1848 goto out;
f9dadc98
RS
1849 }
1850
c589b249 1851 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
f2917853 1852 error_setg(errp, "iSCSI: Failed to set session type to normal.");
c589b249 1853 ret = -EINVAL;
b93c94f7 1854 goto out;
c589b249
RS
1855 }
1856
f9dadc98 1857 /* check if we got HEADER_DIGEST via the options */
81aa2a0f 1858 apply_header_digest(iscsi, opts, &local_err);
f2917853
PB
1859 if (local_err != NULL) {
1860 error_propagate(errp, local_err);
1861 ret = -EINVAL;
1862 goto out;
1863 }
f9dadc98 1864
9049736e 1865 /* timeout handling is broken in libiscsi before 1.15.0 */
1d560104 1866 timeout = qemu_opt_get_number(opts, "timeout", 0);
583ec22e 1867#if LIBISCSI_API_VERSION >= 20150621
9049736e
PL
1868 iscsi_set_timeout(iscsi, timeout);
1869#else
1870 if (timeout) {
5197f445 1871 warn_report("iSCSI: ignoring timeout value for libiscsi <1.15.0");
9049736e
PL
1872 }
1873#endif
5dd7a535 1874
d5895fcb 1875 if (iscsi_full_connect_sync(iscsi, portal, lun) != 0) {
f2917853 1876 error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
e829b0bb
PL
1877 iscsi_get_error(iscsi));
1878 ret = -EINVAL;
1879 goto out;
1880 }
c589b249
RS
1881
1882 iscsilun->iscsi = iscsi;
80cf6257 1883 iscsilun->aio_context = bdrv_get_aio_context(bs);
d5895fcb 1884 iscsilun->lun = lun;
24d3bd67 1885 iscsilun->has_write_same = true;
c589b249 1886
24d3bd67
PL
1887 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
1888 (void **) &inq, errp);
1889 if (task == NULL) {
c589b249 1890 ret = -EINVAL;
b93c94f7 1891 goto out;
c589b249 1892 }
e829b0bb 1893 iscsilun->type = inq->periperal_device_type;
24d3bd67
PL
1894 scsi_free_scsi_task(task);
1895 task = NULL;
e829b0bb 1896
7191f208 1897 iscsi_modesense_sync(iscsilun);
4df863f3
EB
1898 if (iscsilun->dpofua) {
1899 bs->supported_write_flags = BDRV_REQ_FUA;
1900 }
7191f208 1901
c1d4096b
FZ
1902 /* Check the write protect flag of the LUN if we want to write */
1903 if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
43ae8fb1 1904 iscsilun->write_protected) {
8f3bf50d
KW
1905 ret = bdrv_apply_auto_read_only(bs, "LUN is write protected", errp);
1906 if (ret < 0) {
1907 goto out;
1908 }
1909 flags &= ~BDRV_O_RDWR;
c1d4096b
FZ
1910 }
1911
f2917853
PB
1912 iscsi_readcapacity_sync(iscsilun, &local_err);
1913 if (local_err != NULL) {
1914 error_propagate(errp, local_err);
cd82b6fb 1915 ret = -EINVAL;
cb1b83e7 1916 goto out;
e829b0bb 1917 }
0777b5dd 1918 bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun);
e829b0bb 1919
f47c3f5a
KW
1920 /* We don't have any emulation for devices other than disks and CD-ROMs, so
1921 * this must be sg ioctl compatible. We force it to be sg, otherwise qemu
1922 * will try to read from the device to guess the image format.
622695a4 1923 */
f47c3f5a 1924 if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) {
54115412 1925 bs->sg = true;
622695a4
RS
1926 }
1927
24d3bd67
PL
1928 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1929 SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES,
1930 (void **) &inq_vpd, errp);
1931 if (task == NULL) {
1932 ret = -EINVAL;
1933 goto out;
f18a7cbb 1934 }
24d3bd67
PL
1935 for (i = 0; i < inq_vpd->num_pages; i++) {
1936 struct scsi_task *inq_task;
1937 struct scsi_inquiry_logical_block_provisioning *inq_lbp;
f18a7cbb 1938 struct scsi_inquiry_block_limits *inq_bl;
cc9743c2 1939 struct scsi_inquiry_device_identification *inq_di;
24d3bd67
PL
1940 switch (inq_vpd->pages[i]) {
1941 case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
1942 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1943 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING,
1944 (void **) &inq_lbp, errp);
1945 if (inq_task == NULL) {
1946 ret = -EINVAL;
1947 goto out;
1948 }
1949 memcpy(&iscsilun->lbp, inq_lbp,
1950 sizeof(struct scsi_inquiry_logical_block_provisioning));
1951 scsi_free_scsi_task(inq_task);
1952 break;
1953 case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
1954 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1955 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS,
1956 (void **) &inq_bl, errp);
1957 if (inq_task == NULL) {
1958 ret = -EINVAL;
1959 goto out;
1960 }
1961 memcpy(&iscsilun->bl, inq_bl,
1962 sizeof(struct scsi_inquiry_block_limits));
1963 scsi_free_scsi_task(inq_task);
1964 break;
cc9743c2
FZ
1965 case SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION:
1966 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1967 SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION,
1968 (void **) &inq_di, errp);
1969 if (inq_task == NULL) {
1970 ret = -EINVAL;
1971 goto out;
1972 }
1973 iscsi_save_designator(iscsilun, inq_di);
1974 scsi_free_scsi_task(inq_task);
1975 break;
24d3bd67
PL
1976 default:
1977 break;
f18a7cbb 1978 }
f18a7cbb 1979 }
24d3bd67
PL
1980 scsi_free_scsi_task(task);
1981 task = NULL;
f18a7cbb 1982
d045c466 1983 qemu_mutex_init(&iscsilun->mutex);
80cf6257 1984 iscsi_attach_aio_context(bs, iscsilun->aio_context);
5b5d34ec 1985
b03c3805
PL
1986 /* Guess the internal cluster (page) size of the iscsi target by the means
1987 * of opt_unmap_gran. Transfer the unmap granularity only if it has a
1988 * reasonable size */
3d2acaa3 1989 if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 4 * 1024 &&
b03c3805 1990 iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) {
ba059e7b
EB
1991 iscsilun->cluster_size = iscsilun->bl.opt_unmap_gran *
1992 iscsilun->block_size;
9eac3622 1993 if (iscsilun->lbprz) {
34afc5c2 1994 ret = iscsi_allocmap_init(iscsilun, flags);
b03c3805 1995 }
b03c3805
PL
1996 }
1997
e24d813b
EB
1998 if (iscsilun->lbprz && iscsilun->lbp.lbpws) {
1999 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP;
2000 }
2001
b93c94f7 2002out:
60beb341 2003 qemu_opts_del(opts);
f7047c2d 2004 g_free(initiator_name);
e829b0bb
PL
2005 if (task != NULL) {
2006 scsi_free_scsi_task(task);
2007 }
b93c94f7
PB
2008
2009 if (ret) {
2010 if (iscsi != NULL) {
20474e9a
PL
2011 if (iscsi_is_logged_in(iscsi)) {
2012 iscsi_logout_sync(iscsi);
2013 }
b93c94f7
PB
2014 iscsi_destroy_context(iscsi);
2015 }
2016 memset(iscsilun, 0, sizeof(IscsiLun));
c589b249 2017 }
deadbb8e 2018
c589b249
RS
2019 return ret;
2020}
2021
2022static void iscsi_close(BlockDriverState *bs)
2023{
2024 IscsiLun *iscsilun = bs->opaque;
2025 struct iscsi_context *iscsi = iscsilun->iscsi;
2026
80cf6257 2027 iscsi_detach_aio_context(bs);
20474e9a
PL
2028 if (iscsi_is_logged_in(iscsi)) {
2029 iscsi_logout_sync(iscsi);
2030 }
c589b249 2031 iscsi_destroy_context(iscsi);
cc9743c2
FZ
2032 if (iscsilun->dd) {
2033 g_free(iscsilun->dd->designator);
2034 g_free(iscsilun->dd);
2035 }
d4cd9615 2036 g_free(iscsilun->zeroblock);
e1123a3b 2037 iscsi_allocmap_free(iscsilun);
d045c466 2038 qemu_mutex_destroy(&iscsilun->mutex);
c589b249
RS
2039 memset(iscsilun, 0, sizeof(IscsiLun));
2040}
2041
52f6fa14
PL
2042static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp)
2043{
d34682cd
KW
2044 /* We don't actually refresh here, but just return data queried in
2045 * iscsi_open(): iscsi targets don't change their limits. */
52f6fa14
PL
2046
2047 IscsiLun *iscsilun = bs->opaque;
5def6b80 2048 uint64_t max_xfer_len = iscsilun->use_16_for_rw ? 0xffffffff : 0xffff;
95eaa785 2049 unsigned int block_size = MAX(BDRV_SECTOR_SIZE, iscsilun->block_size);
52f6fa14 2050
95eaa785
EB
2051 assert(iscsilun->block_size >= BDRV_SECTOR_SIZE || bs->sg);
2052
2053 bs->bl.request_alignment = block_size;
c8b3b998 2054
52f6fa14
PL
2055 if (iscsilun->bl.max_xfer_len) {
2056 max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len);
2057 }
2058
95eaa785 2059 if (max_xfer_len * block_size < INT_MAX) {
5def6b80
EB
2060 bs->bl.max_transfer = max_xfer_len * iscsilun->block_size;
2061 }
52f6fa14 2062
c97ca29d 2063 if (iscsilun->lbp.lbpu) {
95eaa785 2064 if (iscsilun->bl.max_unmap < 0xffffffff / block_size) {
b9f7855a
EB
2065 bs->bl.max_pdiscard =
2066 iscsilun->bl.max_unmap * iscsilun->block_size;
d34682cd 2067 }
b9f7855a
EB
2068 bs->bl.pdiscard_alignment =
2069 iscsilun->bl.opt_unmap_gran * iscsilun->block_size;
8b184744 2070 } else {
b9f7855a 2071 bs->bl.pdiscard_alignment = iscsilun->block_size;
c97ca29d 2072 }
d34682cd 2073
95eaa785 2074 if (iscsilun->bl.max_ws_len < 0xffffffff / block_size) {
cf081fca
EB
2075 bs->bl.max_pwrite_zeroes =
2076 iscsilun->bl.max_ws_len * iscsilun->block_size;
c97ca29d
PB
2077 }
2078 if (iscsilun->lbp.lbpws) {
cf081fca
EB
2079 bs->bl.pwrite_zeroes_alignment =
2080 iscsilun->bl.opt_unmap_gran * iscsilun->block_size;
8b184744 2081 } else {
cf081fca 2082 bs->bl.pwrite_zeroes_alignment = iscsilun->block_size;
d34682cd 2083 }
5def6b80 2084 if (iscsilun->bl.opt_xfer_len &&
95eaa785 2085 iscsilun->bl.opt_xfer_len < INT_MAX / block_size) {
5def6b80
EB
2086 bs->bl.opt_transfer = pow2floor(iscsilun->bl.opt_xfer_len *
2087 iscsilun->block_size);
2088 }
e9f526ab 2089}
d34682cd 2090
43ae8fb1
FZ
2091/* Note that this will not re-establish a connection with an iSCSI target - it
2092 * is effectively a NOP. */
dc6afb99
JC
2093static int iscsi_reopen_prepare(BDRVReopenState *state,
2094 BlockReopenQueue *queue, Error **errp)
2095{
43ae8fb1
FZ
2096 IscsiLun *iscsilun = state->bs->opaque;
2097
2098 if (state->flags & BDRV_O_RDWR && iscsilun->write_protected) {
2099 error_setg(errp, "Cannot open a write protected LUN as read-write");
2100 return -EACCES;
2101 }
d34682cd
KW
2102 return 0;
2103}
2104
e1123a3b
PL
2105static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
2106{
2107 IscsiLun *iscsilun = reopen_state->bs->opaque;
2108
2109 /* the cache.direct status might have changed */
2110 if (iscsilun->allocmap != NULL) {
2111 iscsi_allocmap_init(iscsilun, reopen_state->flags);
2112 }
2113}
2114
061ca8a3 2115static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
c80d8b06 2116 bool exact, PreallocMode prealloc,
92b92799 2117 BdrvRequestFlags flags, Error **errp)
cb1b83e7
PL
2118{
2119 IscsiLun *iscsilun = bs->opaque;
82325ae5 2120 int64_t cur_length;
f2917853 2121 Error *local_err = NULL;
cb1b83e7 2122
8243ccb7
HR
2123 if (prealloc != PREALLOC_MODE_OFF) {
2124 error_setg(errp, "Unsupported preallocation mode '%s'",
977c736f 2125 PreallocMode_str(prealloc));
8243ccb7
HR
2126 return -ENOTSUP;
2127 }
2128
cb1b83e7 2129 if (iscsilun->type != TYPE_DISK) {
f59adb32 2130 error_setg(errp, "Cannot resize non-disk iSCSI devices");
cb1b83e7
PL
2131 return -ENOTSUP;
2132 }
2133
f2917853
PB
2134 iscsi_readcapacity_sync(iscsilun, &local_err);
2135 if (local_err != NULL) {
4bff28b8 2136 error_propagate(errp, local_err);
f2917853 2137 return -EIO;
cb1b83e7
PL
2138 }
2139
82325ae5
HR
2140 cur_length = iscsi_getlength(bs);
2141 if (offset != cur_length && exact) {
2142 error_setg(errp, "Cannot resize iSCSI devices");
2143 return -ENOTSUP;
2144 } else if (offset > cur_length) {
f59adb32 2145 error_setg(errp, "Cannot grow iSCSI devices");
cb1b83e7
PL
2146 return -EINVAL;
2147 }
2148
e1123a3b
PL
2149 if (iscsilun->allocmap != NULL) {
2150 iscsi_allocmap_init(iscsilun, bs->open_flags);
b03c3805
PL
2151 }
2152
cb1b83e7
PL
2153 return 0;
2154}
2155
186d4f2b
PL
2156static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2157{
2158 IscsiLun *iscsilun = bs->opaque;
ba059e7b 2159 bdi->cluster_size = iscsilun->cluster_size;
186d4f2b
PL
2160 return 0;
2161}
2162
2b148f39
PB
2163static void coroutine_fn iscsi_co_invalidate_cache(BlockDriverState *bs,
2164 Error **errp)
e1123a3b
PL
2165{
2166 IscsiLun *iscsilun = bs->opaque;
2167 iscsi_allocmap_invalidate(iscsilun);
2168}
2169
604dfaaa
FZ
2170static int coroutine_fn iscsi_co_copy_range_from(BlockDriverState *bs,
2171 BdrvChild *src,
48535049 2172 int64_t src_offset,
604dfaaa 2173 BdrvChild *dst,
48535049
VSO
2174 int64_t dst_offset,
2175 int64_t bytes,
67b51fb9
VSO
2176 BdrvRequestFlags read_flags,
2177 BdrvRequestFlags write_flags)
604dfaaa 2178{
67b51fb9
VSO
2179 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
2180 read_flags, write_flags);
604dfaaa
FZ
2181}
2182
2183static struct scsi_task *iscsi_xcopy_task(int param_len)
2184{
2185 struct scsi_task *task;
2186
2187 task = g_new0(struct scsi_task, 1);
2188
2189 task->cdb[0] = EXTENDED_COPY;
2190 task->cdb[10] = (param_len >> 24) & 0xFF;
2191 task->cdb[11] = (param_len >> 16) & 0xFF;
2192 task->cdb[12] = (param_len >> 8) & 0xFF;
2193 task->cdb[13] = param_len & 0xFF;
2194 task->cdb_size = 16;
2195 task->xfer_dir = SCSI_XFER_WRITE;
2196 task->expxferlen = param_len;
2197
2198 return task;
2199}
2200
2201static void iscsi_populate_target_desc(unsigned char *desc, IscsiLun *lun)
2202{
2203 struct scsi_inquiry_device_designator *dd = lun->dd;
2204
2205 memset(desc, 0, 32);
2206 desc[0] = 0xE4; /* IDENT_DESCR_TGT_DESCR */
2207 desc[4] = dd->code_set;
2208 desc[5] = (dd->designator_type & 0xF)
2209 | ((dd->association & 3) << 4);
2210 desc[7] = dd->designator_length;
1439b9c1 2211 memcpy(desc + 8, dd->designator, MIN(dd->designator_length, 20));
604dfaaa
FZ
2212
2213 desc[28] = 0;
2214 desc[29] = (lun->block_size >> 16) & 0xFF;
2215 desc[30] = (lun->block_size >> 8) & 0xFF;
2216 desc[31] = lun->block_size & 0xFF;
2217}
2218
2219static void iscsi_xcopy_desc_hdr(uint8_t *hdr, int dc, int cat, int src_index,
2220 int dst_index)
2221{
2222 hdr[0] = 0x02; /* BLK_TO_BLK_SEG_DESCR */
2223 hdr[1] = ((dc << 1) | cat) & 0xFF;
2224 hdr[2] = (XCOPY_BLK2BLK_SEG_DESC_SIZE >> 8) & 0xFF;
2225 /* don't account for the first 4 bytes in descriptor header*/
2226 hdr[3] = (XCOPY_BLK2BLK_SEG_DESC_SIZE - 4 /* SEG_DESC_SRC_INDEX_OFFSET */) & 0xFF;
2227 hdr[4] = (src_index >> 8) & 0xFF;
2228 hdr[5] = src_index & 0xFF;
2229 hdr[6] = (dst_index >> 8) & 0xFF;
2230 hdr[7] = dst_index & 0xFF;
2231}
2232
2233static void iscsi_xcopy_populate_desc(uint8_t *desc, int dc, int cat,
2234 int src_index, int dst_index, int num_blks,
2235 uint64_t src_lba, uint64_t dst_lba)
2236{
2237 iscsi_xcopy_desc_hdr(desc, dc, cat, src_index, dst_index);
2238
2239 /* The caller should verify the request size */
2240 assert(num_blks < 65536);
2241 desc[10] = (num_blks >> 8) & 0xFF;
2242 desc[11] = num_blks & 0xFF;
2243 desc[12] = (src_lba >> 56) & 0xFF;
2244 desc[13] = (src_lba >> 48) & 0xFF;
2245 desc[14] = (src_lba >> 40) & 0xFF;
2246 desc[15] = (src_lba >> 32) & 0xFF;
2247 desc[16] = (src_lba >> 24) & 0xFF;
2248 desc[17] = (src_lba >> 16) & 0xFF;
2249 desc[18] = (src_lba >> 8) & 0xFF;
2250 desc[19] = src_lba & 0xFF;
2251 desc[20] = (dst_lba >> 56) & 0xFF;
2252 desc[21] = (dst_lba >> 48) & 0xFF;
2253 desc[22] = (dst_lba >> 40) & 0xFF;
2254 desc[23] = (dst_lba >> 32) & 0xFF;
2255 desc[24] = (dst_lba >> 24) & 0xFF;
2256 desc[25] = (dst_lba >> 16) & 0xFF;
2257 desc[26] = (dst_lba >> 8) & 0xFF;
2258 desc[27] = dst_lba & 0xFF;
2259}
2260
2261static void iscsi_xcopy_populate_header(unsigned char *buf, int list_id, int str,
2262 int list_id_usage, int prio,
2263 int tgt_desc_len,
2264 int seg_desc_len, int inline_data_len)
2265{
2266 buf[0] = list_id;
2267 buf[1] = ((str & 1) << 5) | ((list_id_usage & 3) << 3) | (prio & 7);
2268 buf[2] = (tgt_desc_len >> 8) & 0xFF;
2269 buf[3] = tgt_desc_len & 0xFF;
2270 buf[8] = (seg_desc_len >> 24) & 0xFF;
2271 buf[9] = (seg_desc_len >> 16) & 0xFF;
2272 buf[10] = (seg_desc_len >> 8) & 0xFF;
2273 buf[11] = seg_desc_len & 0xFF;
2274 buf[12] = (inline_data_len >> 24) & 0xFF;
2275 buf[13] = (inline_data_len >> 16) & 0xFF;
2276 buf[14] = (inline_data_len >> 8) & 0xFF;
2277 buf[15] = inline_data_len & 0xFF;
2278}
2279
2280static void iscsi_xcopy_data(struct iscsi_data *data,
2281 IscsiLun *src, int64_t src_lba,
2282 IscsiLun *dst, int64_t dst_lba,
2283 uint16_t num_blocks)
2284{
2285 uint8_t *buf;
2286 const int src_offset = XCOPY_DESC_OFFSET;
2287 const int dst_offset = XCOPY_DESC_OFFSET + IDENT_DESCR_TGT_DESCR_SIZE;
2288 const int seg_offset = dst_offset + IDENT_DESCR_TGT_DESCR_SIZE;
2289
2290 data->size = XCOPY_DESC_OFFSET +
2291 IDENT_DESCR_TGT_DESCR_SIZE * 2 +
2292 XCOPY_BLK2BLK_SEG_DESC_SIZE;
2293 data->data = g_malloc0(data->size);
2294 buf = data->data;
2295
2296 /* Initialise the parameter list header */
2297 iscsi_xcopy_populate_header(buf, 1, 0, 2 /* LIST_ID_USAGE_DISCARD */,
2298 0, 2 * IDENT_DESCR_TGT_DESCR_SIZE,
2299 XCOPY_BLK2BLK_SEG_DESC_SIZE,
2300 0);
2301
2302 /* Initialise CSCD list with one src + one dst descriptor */
2303 iscsi_populate_target_desc(&buf[src_offset], src);
2304 iscsi_populate_target_desc(&buf[dst_offset], dst);
2305
2306 /* Initialise one segment descriptor */
2307 iscsi_xcopy_populate_desc(&buf[seg_offset], 0, 0, 0, 1, num_blocks,
2308 src_lba, dst_lba);
2309}
2310
2311static int coroutine_fn iscsi_co_copy_range_to(BlockDriverState *bs,
2312 BdrvChild *src,
48535049 2313 int64_t src_offset,
604dfaaa 2314 BdrvChild *dst,
48535049
VSO
2315 int64_t dst_offset,
2316 int64_t bytes,
67b51fb9
VSO
2317 BdrvRequestFlags read_flags,
2318 BdrvRequestFlags write_flags)
604dfaaa
FZ
2319{
2320 IscsiLun *dst_lun = dst->bs->opaque;
2321 IscsiLun *src_lun;
2322 struct IscsiTask iscsi_task;
2323 struct iscsi_data data;
2324 int r = 0;
2325 int block_size;
2326
2327 if (src->bs->drv->bdrv_co_copy_range_to != iscsi_co_copy_range_to) {
2328 return -ENOTSUP;
2329 }
2330 src_lun = src->bs->opaque;
2331
2332 if (!src_lun->dd || !dst_lun->dd) {
2333 return -ENOTSUP;
2334 }
2335 if (!is_byte_request_lun_aligned(dst_offset, bytes, dst_lun)) {
2336 return -ENOTSUP;
2337 }
2338 if (!is_byte_request_lun_aligned(src_offset, bytes, src_lun)) {
2339 return -ENOTSUP;
2340 }
2341 if (dst_lun->block_size != src_lun->block_size ||
2342 !dst_lun->block_size) {
2343 return -ENOTSUP;
2344 }
2345
2346 block_size = dst_lun->block_size;
2347 if (bytes / block_size > 65535) {
2348 return -ENOTSUP;
2349 }
2350
2351 iscsi_xcopy_data(&data,
2352 src_lun, src_offset / block_size,
2353 dst_lun, dst_offset / block_size,
2354 bytes / block_size);
2355
2356 iscsi_co_init_iscsitask(dst_lun, &iscsi_task);
2357
2358 qemu_mutex_lock(&dst_lun->mutex);
2359 iscsi_task.task = iscsi_xcopy_task(data.size);
2360retry:
2361 if (iscsi_scsi_command_async(dst_lun->iscsi, dst_lun->lun,
2362 iscsi_task.task, iscsi_co_generic_cb,
2363 &data,
2364 &iscsi_task) != 0) {
2365 r = -EIO;
2366 goto out_unlock;
2367 }
2368
2369 iscsi_co_wait_for_task(&iscsi_task, dst_lun);
2370
2371 if (iscsi_task.do_retry) {
2372 iscsi_task.complete = 0;
2373 goto retry;
2374 }
2375
2376 if (iscsi_task.status != SCSI_STATUS_GOOD) {
2377 r = iscsi_task.err_code;
2378 goto out_unlock;
2379 }
2380
2381out_unlock:
ecc983a5
FZ
2382
2383 trace_iscsi_xcopy(src_lun, src_offset, dst_lun, dst_offset, bytes, r);
604dfaaa
FZ
2384 g_free(iscsi_task.task);
2385 qemu_mutex_unlock(&dst_lun->mutex);
2386 g_free(iscsi_task.err_str);
2387 return r;
2388}
2389
de8864e5 2390
2654267c
HR
2391static const char *const iscsi_strong_runtime_opts[] = {
2392 "transport",
2393 "portal",
2394 "target",
2395 "user",
2396 "password",
2397 "password-secret",
2398 "lun",
2399 "initiator-name",
2400 "header-digest",
2401
2402 NULL
2403};
2404
c589b249
RS
2405static BlockDriver bdrv_iscsi = {
2406 .format_name = "iscsi",
2407 .protocol_name = "iscsi",
2408
d5895fcb
KW
2409 .instance_size = sizeof(IscsiLun),
2410 .bdrv_parse_filename = iscsi_parse_filename,
2411 .bdrv_file_open = iscsi_open,
2412 .bdrv_close = iscsi_close,
5a5e7f8c
ML
2413 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
2414 .create_opts = &bdrv_create_opts_simple,
d5895fcb
KW
2415 .bdrv_reopen_prepare = iscsi_reopen_prepare,
2416 .bdrv_reopen_commit = iscsi_reopen_commit,
2b148f39 2417 .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
c589b249
RS
2418
2419 .bdrv_getlength = iscsi_getlength,
186d4f2b 2420 .bdrv_get_info = iscsi_get_info,
061ca8a3 2421 .bdrv_co_truncate = iscsi_co_truncate,
d34682cd 2422 .bdrv_refresh_limits = iscsi_refresh_limits,
c589b249 2423
92809c36 2424 .bdrv_co_block_status = iscsi_co_block_status,
97c7e85c 2425 .bdrv_co_pdiscard = iscsi_co_pdiscard,
604dfaaa
FZ
2426 .bdrv_co_copy_range_from = iscsi_co_copy_range_from,
2427 .bdrv_co_copy_range_to = iscsi_co_copy_range_to,
94d047a3 2428 .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
063c3378 2429 .bdrv_co_readv = iscsi_co_readv,
e18a58b4 2430 .bdrv_co_writev = iscsi_co_writev,
063c3378 2431 .bdrv_co_flush_to_disk = iscsi_co_flush,
fa6acb0c 2432
98392453 2433#ifdef __linux__
98392453
RS
2434 .bdrv_aio_ioctl = iscsi_aio_ioctl,
2435#endif
80cf6257
SH
2436
2437 .bdrv_detach_aio_context = iscsi_detach_aio_context,
2438 .bdrv_attach_aio_context = iscsi_attach_aio_context,
2654267c
HR
2439
2440 .strong_runtime_opts = iscsi_strong_runtime_opts,
c589b249
RS
2441};
2442
e0ae4987
RS
2443#if LIBISCSI_API_VERSION >= (20160603)
2444static BlockDriver bdrv_iser = {
2445 .format_name = "iser",
2446 .protocol_name = "iser",
2447
d5895fcb
KW
2448 .instance_size = sizeof(IscsiLun),
2449 .bdrv_parse_filename = iscsi_parse_filename,
2450 .bdrv_file_open = iscsi_open,
2451 .bdrv_close = iscsi_close,
5a5e7f8c
ML
2452 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
2453 .create_opts = &bdrv_create_opts_simple,
d5895fcb
KW
2454 .bdrv_reopen_prepare = iscsi_reopen_prepare,
2455 .bdrv_reopen_commit = iscsi_reopen_commit,
b16a7cfa 2456 .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
e0ae4987
RS
2457
2458 .bdrv_getlength = iscsi_getlength,
2459 .bdrv_get_info = iscsi_get_info,
061ca8a3 2460 .bdrv_co_truncate = iscsi_co_truncate,
e0ae4987
RS
2461 .bdrv_refresh_limits = iscsi_refresh_limits,
2462
92809c36 2463 .bdrv_co_block_status = iscsi_co_block_status,
e0ae4987 2464 .bdrv_co_pdiscard = iscsi_co_pdiscard,
604dfaaa
FZ
2465 .bdrv_co_copy_range_from = iscsi_co_copy_range_from,
2466 .bdrv_co_copy_range_to = iscsi_co_copy_range_to,
e0ae4987
RS
2467 .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
2468 .bdrv_co_readv = iscsi_co_readv,
e18a58b4 2469 .bdrv_co_writev = iscsi_co_writev,
e0ae4987
RS
2470 .bdrv_co_flush_to_disk = iscsi_co_flush,
2471
2472#ifdef __linux__
2473 .bdrv_aio_ioctl = iscsi_aio_ioctl,
2474#endif
2475
2476 .bdrv_detach_aio_context = iscsi_detach_aio_context,
2477 .bdrv_attach_aio_context = iscsi_attach_aio_context,
2654267c
HR
2478
2479 .strong_runtime_opts = iscsi_strong_runtime_opts,
e0ae4987
RS
2480};
2481#endif
2482
c589b249
RS
2483static void iscsi_block_init(void)
2484{
2485 bdrv_register(&bdrv_iscsi);
e0ae4987
RS
2486#if LIBISCSI_API_VERSION >= (20160603)
2487 bdrv_register(&bdrv_iser);
2488#endif
c589b249
RS
2489}
2490
2491block_init(iscsi_block_init);