?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
migration_is_setup_or_active
[qemu.git] / block / iscsi.c
blob080ef523452400b451633b1bf1ba9b76349bdc64
1 /*
2 * QEMU Block driver for iSCSI images
3 *
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
5 * Copyright (c) 2012-2015 Peter Lieven <pl@kamp.de>
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
26 #include "config-host.h"
27
28 #include <poll.h>
29 #include <math.h>
30 #include <arpa/inet.h>
31 #include "qemu-common.h"
32 #include "qemu/config-file.h"
33 #include "qemu/error-report.h"
34 #include "qemu/bitops.h"
35 #include "qemu/bitmap.h"
36 #include "block/block_int.h"
37 #include "block/scsi.h"
38 #include "qemu/iov.h"
39 #include "sysemu/sysemu.h"
40 #include "qmp-commands.h"
41 #include "qapi/qmp/qstring.h"
42
43 #include <iscsi/iscsi.h>
44 #include <iscsi/scsi-lowlevel.h>
45
46 #ifdef __linux__
47 #include <scsi/sg.h>
48 #include <block/scsi.h>
49 #endif
50
51 typedef struct IscsiLun {
52 struct iscsi_context *iscsi;
53 AioContext *aio_context;
54 int lun;
55 enum scsi_inquiry_peripheral_device_type type;
56 int block_size;
57 uint64_t num_blocks;
58 int events;
59 QEMUTimer *nop_timer;
60 QEMUTimer *event_timer;
61 struct scsi_inquiry_logical_block_provisioning lbp;
62 struct scsi_inquiry_block_limits bl;
63 unsigned char *zeroblock;
64 unsigned long *allocationmap;
65 int cluster_sectors;
66 bool use_16_for_rw;
67 bool write_protected;
68 bool lbpme;
69 bool lbprz;
70 bool dpofua;
71 bool has_write_same;
72 bool force_next_flush;
73 bool request_timed_out;
74 } IscsiLun;
75
76 typedef struct IscsiTask {
77 int status;
78 int complete;
79 int retries;
80 int do_retry;
81 struct scsi_task *task;
82 Coroutine *co;
83 QEMUBH *bh;
84 IscsiLun *iscsilun;
85 QEMUTimer retry_timer;
86 bool force_next_flush;
87 int err_code;
88 } IscsiTask;
89
90 typedef struct IscsiAIOCB {
91 BlockAIOCB common;
92 QEMUIOVector *qiov;
93 QEMUBH *bh;
94 IscsiLun *iscsilun;
95 struct scsi_task *task;
96 uint8_t *buf;
97 int status;
98 int64_t sector_num;
99 int nb_sectors;
100 #ifdef __linux__
101 sg_io_hdr_t *ioh;
102 #endif
103 } IscsiAIOCB;
104
105 /* libiscsi uses time_t so its enough to process events every second */
106 #define EVENT_INTERVAL 1000
107 #define NOP_INTERVAL 5000
108 #define MAX_NOP_FAILURES 3
109 #define ISCSI_CMD_RETRIES ARRAY_SIZE(iscsi_retry_times)
110 static const unsigned iscsi_retry_times[] = {8, 32, 128, 512, 2048, 8192, 32768};
111
112 /* this threshold is a trade-off knob to choose between
113 * the potential additional overhead of an extra GET_LBA_STATUS request
114 * vs. unnecessarily reading a lot of zero sectors over the wire.
115 * If a read request is greater or equal than ISCSI_CHECKALLOC_THRES
116 * sectors we check the allocation status of the area covered by the
117 * request first if the allocationmap indicates that the area might be
118 * unallocated. */
119 #define ISCSI_CHECKALLOC_THRES 64
120
121 static void
122 iscsi_bh_cb(void *p)
123 {
124 IscsiAIOCB *acb = p;
125
126 qemu_bh_delete(acb->bh);
127
128 g_free(acb->buf);
129 acb->buf = NULL;
130
131 acb->common.cb(acb->common.opaque, acb->status);
132
133 if (acb->task != NULL) {
134 scsi_free_scsi_task(acb->task);
135 acb->task = NULL;
136 }
137
138 qemu_aio_unref(acb);
139 }
140
141 static void
142 iscsi_schedule_bh(IscsiAIOCB *acb)
143 {
144 if (acb->bh) {
145 return;
146 }
147 acb->bh = aio_bh_new(acb->iscsilun->aio_context, iscsi_bh_cb, acb);
148 qemu_bh_schedule(acb->bh);
149 }
150
151 static void iscsi_co_generic_bh_cb(void *opaque)
152 {
153 struct IscsiTask *iTask = opaque;
154 iTask->complete = 1;
155 qemu_bh_delete(iTask->bh);
156 qemu_coroutine_enter(iTask->co, NULL);
157 }
158
159 static void iscsi_retry_timer_expired(void *opaque)
160 {
161 struct IscsiTask *iTask = opaque;
162 iTask->complete = 1;
163 if (iTask->co) {
164 qemu_coroutine_enter(iTask->co, NULL);
165 }
166 }
167
168 static inline unsigned exp_random(double mean)
169 {
170 return -mean * log((double)rand() / RAND_MAX);
171 }
172
173 /* SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST was introduced in
174 * libiscsi 1.10.0, together with other constants we need. Use it as
175 * a hint that we have to define them ourselves if needed, to keep the
176 * minimum required libiscsi version at 1.9.0. We use an ASCQ macro for
177 * the test because SCSI_STATUS_* is an enum.
178 *
179 * To guard against future changes where SCSI_SENSE_ASCQ_* also becomes
180 * an enum, check against the LIBISCSI_API_VERSION macro, which was
181 * introduced in 1.11.0. If it is present, there is no need to define
182 * anything.
183 */
184 #if !defined(SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST) && \
185 !defined(LIBISCSI_API_VERSION)
186 #define SCSI_STATUS_TASK_SET_FULL 0x28
187 #define SCSI_STATUS_TIMEOUT 0x0f000002
188 #define SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST 0x2600
189 #define SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR 0x1a00
190 #endif
191
192 static int iscsi_translate_sense(struct scsi_sense *sense)
193 {
194 int ret;
195
196 switch (sense->key) {
197 case SCSI_SENSE_NOT_READY:
198 return -EBUSY;
199 case SCSI_SENSE_DATA_PROTECTION:
200 return -EACCES;
201 case SCSI_SENSE_COMMAND_ABORTED:
202 return -ECANCELED;
203 case SCSI_SENSE_ILLEGAL_REQUEST:
204 /* Parse ASCQ */
205 break;
206 default:
207 return -EIO;
208 }
209 switch (sense->ascq) {
210 case SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR:
211 case SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE:
212 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB:
213 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST:
214 ret = -EINVAL;
215 break;
216 case SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE:
217 ret = -ENOSPC;
218 break;
219 case SCSI_SENSE_ASCQ_LOGICAL_UNIT_NOT_SUPPORTED:
220 ret = -ENOTSUP;
221 break;
222 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT:
223 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED:
224 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN:
225 ret = -ENOMEDIUM;
226 break;
227 case SCSI_SENSE_ASCQ_WRITE_PROTECTED:
228 ret = -EACCES;
229 break;
230 default:
231 ret = -EIO;
232 break;
233 }
234 return ret;
235 }
236
237 static void
238 iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
239 void *command_data, void *opaque)
240 {
241 struct IscsiTask *iTask = opaque;
242 struct scsi_task *task = command_data;
243
244 iTask->status = status;
245 iTask->do_retry = 0;
246 iTask->task = task;
247
248 if (status != SCSI_STATUS_GOOD) {
249 if (iTask->retries++ < ISCSI_CMD_RETRIES) {
250 if (status == SCSI_STATUS_CHECK_CONDITION
251 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
252 error_report("iSCSI CheckCondition: %s",
253 iscsi_get_error(iscsi));
254 iTask->do_retry = 1;
255 goto out;
256 }
257 if (status == SCSI_STATUS_BUSY ||
258 status == SCSI_STATUS_TIMEOUT ||
259 status == SCSI_STATUS_TASK_SET_FULL) {
260 unsigned retry_time =
261 exp_random(iscsi_retry_times[iTask->retries - 1]);
262 if (status == SCSI_STATUS_TIMEOUT) {
263 /* make sure the request is rescheduled AFTER the
264 * reconnect is initiated */
265 retry_time = EVENT_INTERVAL * 2;
266 iTask->iscsilun->request_timed_out = true;
267 }
268 error_report("iSCSI Busy/TaskSetFull/TimeOut"
269 " (retry #%u in %u ms): %s",
270 iTask->retries, retry_time,
271 iscsi_get_error(iscsi));
272 aio_timer_init(iTask->iscsilun->aio_context,
273 &iTask->retry_timer, QEMU_CLOCK_REALTIME,
274 SCALE_MS, iscsi_retry_timer_expired, iTask);
275 timer_mod(&iTask->retry_timer,
276 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time);
277 iTask->do_retry = 1;
278 return;
279 }
280 }
281 iTask->err_code = iscsi_translate_sense(&task->sense);
282 error_report("iSCSI Failure: %s", iscsi_get_error(iscsi));
283 } else {
284 iTask->iscsilun->force_next_flush |= iTask->force_next_flush;
285 }
286
287 out:
288 if (iTask->co) {
289 iTask->bh = aio_bh_new(iTask->iscsilun->aio_context,
290 iscsi_co_generic_bh_cb, iTask);
291 qemu_bh_schedule(iTask->bh);
292 } else {
293 iTask->complete = 1;
294 }
295 }
296
297 static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
298 {
299 *iTask = (struct IscsiTask) {
300 .co = qemu_coroutine_self(),
301 .iscsilun = iscsilun,
302 };
303 }
304
305 static void
306 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
307 void *private_data)
308 {
309 IscsiAIOCB *acb = private_data;
310
311 acb->status = -ECANCELED;
312 iscsi_schedule_bh(acb);
313 }
314
315 static void
316 iscsi_aio_cancel(BlockAIOCB *blockacb)
317 {
318 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
319 IscsiLun *iscsilun = acb->iscsilun;
320
321 if (acb->status != -EINPROGRESS) {
322 return;
323 }
324
325 /* send a task mgmt call to the target to cancel the task on the target */
326 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
327 iscsi_abort_task_cb, acb);
328
329 }
330
331 static const AIOCBInfo iscsi_aiocb_info = {
332 .aiocb_size = sizeof(IscsiAIOCB),
333 .cancel_async = iscsi_aio_cancel,
334 };
335
336
337 static void iscsi_process_read(void *arg);
338 static void iscsi_process_write(void *arg);
339
340 static void
341 iscsi_set_events(IscsiLun *iscsilun)
342 {
343 struct iscsi_context *iscsi = iscsilun->iscsi;
344 int ev = iscsi_which_events(iscsi);
345
346 if (ev != iscsilun->events) {
347 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsi),
348 false,
349 (ev & POLLIN) ? iscsi_process_read : NULL,
350 (ev & POLLOUT) ? iscsi_process_write : NULL,
351 iscsilun);
352 iscsilun->events = ev;
353 }
354 }
355
356 static void iscsi_timed_check_events(void *opaque)
357 {
358 IscsiLun *iscsilun = opaque;
359
360 /* check for timed out requests */
361 iscsi_service(iscsilun->iscsi, 0);
362
363 if (iscsilun->request_timed_out) {
364 iscsilun->request_timed_out = false;
365 iscsi_reconnect(iscsilun->iscsi);
366 }
367
368 /* newer versions of libiscsi may return zero events. Ensure we are able
369 * to return to service once this situation changes. */
370 iscsi_set_events(iscsilun);
371
372 timer_mod(iscsilun->event_timer,
373 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
374 }
375
376 static void
377 iscsi_process_read(void *arg)
378 {
379 IscsiLun *iscsilun = arg;
380 struct iscsi_context *iscsi = iscsilun->iscsi;
381
382 iscsi_service(iscsi, POLLIN);
383 iscsi_set_events(iscsilun);
384 }
385
386 static void
387 iscsi_process_write(void *arg)
388 {
389 IscsiLun *iscsilun = arg;
390 struct iscsi_context *iscsi = iscsilun->iscsi;
391
392 iscsi_service(iscsi, POLLOUT);
393 iscsi_set_events(iscsilun);
394 }
395
396 static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
397 {
398 return sector * iscsilun->block_size / BDRV_SECTOR_SIZE;
399 }
400
401 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
402 {
403 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
404 }
405
406 static bool is_request_lun_aligned(int64_t sector_num, int nb_sectors,
407 IscsiLun *iscsilun)
408 {
409 if ((sector_num * BDRV_SECTOR_SIZE) % iscsilun->block_size ||
410 (nb_sectors * BDRV_SECTOR_SIZE) % iscsilun->block_size) {
411 error_report("iSCSI misaligned request: "
412 "iscsilun->block_size %u, sector_num %" PRIi64
413 ", nb_sectors %d",
414 iscsilun->block_size, sector_num, nb_sectors);
415 return 0;
416 }
417 return 1;
418 }
419
420 static unsigned long *iscsi_allocationmap_init(IscsiLun *iscsilun)
421 {
422 return bitmap_try_new(DIV_ROUND_UP(sector_lun2qemu(iscsilun->num_blocks,
423 iscsilun),
424 iscsilun->cluster_sectors));
425 }
426
427 static void iscsi_allocationmap_set(IscsiLun *iscsilun, int64_t sector_num,
428 int nb_sectors)
429 {
430 if (iscsilun->allocationmap == NULL) {
431 return;
432 }
433 bitmap_set(iscsilun->allocationmap,
434 sector_num / iscsilun->cluster_sectors,
435 DIV_ROUND_UP(nb_sectors, iscsilun->cluster_sectors));
436 }
437
438 static void iscsi_allocationmap_clear(IscsiLun *iscsilun, int64_t sector_num,
439 int nb_sectors)
440 {
441 int64_t cluster_num, nb_clusters;
442 if (iscsilun->allocationmap == NULL) {
443 return;
444 }
445 cluster_num = DIV_ROUND_UP(sector_num, iscsilun->cluster_sectors);
446 nb_clusters = (sector_num + nb_sectors) / iscsilun->cluster_sectors
447 - cluster_num;
448 if (nb_clusters > 0) {
449 bitmap_clear(iscsilun->allocationmap, cluster_num, nb_clusters);
450 }
451 }
452
453 static int coroutine_fn iscsi_co_writev(BlockDriverState *bs,
454 int64_t sector_num, int nb_sectors,
455 QEMUIOVector *iov)
456 {
457 IscsiLun *iscsilun = bs->opaque;
458 struct IscsiTask iTask;
459 uint64_t lba;
460 uint32_t num_sectors;
461 int fua;
462
463 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
464 return -EINVAL;
465 }
466
467 if (bs->bl.max_transfer_length && nb_sectors > bs->bl.max_transfer_length) {
468 error_report("iSCSI Error: Write of %d sectors exceeds max_xfer_len "
469 "of %d sectors", nb_sectors, bs->bl.max_transfer_length);
470 return -EINVAL;
471 }
472
473 lba = sector_qemu2lun(sector_num, iscsilun);
474 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
475 iscsi_co_init_iscsitask(iscsilun, &iTask);
476 retry:
477 fua = iscsilun->dpofua && !bs->enable_write_cache;
478 iTask.force_next_flush = !fua;
479 if (iscsilun->use_16_for_rw) {
480 iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,
481 NULL, num_sectors * iscsilun->block_size,
482 iscsilun->block_size, 0, 0, fua, 0, 0,
483 iscsi_co_generic_cb, &iTask);
484 } else {
485 iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba,
486 NULL, num_sectors * iscsilun->block_size,
487 iscsilun->block_size, 0, 0, fua, 0, 0,
488 iscsi_co_generic_cb, &iTask);
489 }
490 if (iTask.task == NULL) {
491 return -ENOMEM;
492 }
493 scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,
494 iov->niov);
495 while (!iTask.complete) {
496 iscsi_set_events(iscsilun);
497 qemu_coroutine_yield();
498 }
499
500 if (iTask.task != NULL) {
501 scsi_free_scsi_task(iTask.task);
502 iTask.task = NULL;
503 }
504
505 if (iTask.do_retry) {
506 iTask.complete = 0;
507 goto retry;
508 }
509
510 if (iTask.status != SCSI_STATUS_GOOD) {
511 return iTask.err_code;
512 }
513
514 iscsi_allocationmap_set(iscsilun, sector_num, nb_sectors);
515
516 return 0;
517 }
518
519
520 static bool iscsi_allocationmap_is_allocated(IscsiLun *iscsilun,
521 int64_t sector_num, int nb_sectors)
522 {
523 unsigned long size;
524 if (iscsilun->allocationmap == NULL) {
525 return true;
526 }
527 size = DIV_ROUND_UP(sector_num + nb_sectors, iscsilun->cluster_sectors);
528 return !(find_next_bit(iscsilun->allocationmap, size,
529 sector_num / iscsilun->cluster_sectors) == size);
530 }
531
532 static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs,
533 int64_t sector_num,
534 int nb_sectors, int *pnum)
535 {
536 IscsiLun *iscsilun = bs->opaque;
537 struct scsi_get_lba_status *lbas = NULL;
538 struct scsi_lba_status_descriptor *lbasd = NULL;
539 struct IscsiTask iTask;
540 int64_t ret;
541
542 iscsi_co_init_iscsitask(iscsilun, &iTask);
543
544 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
545 ret = -EINVAL;
546 goto out;
547 }
548
549 /* default to all sectors allocated */
550 ret = BDRV_BLOCK_DATA;
551 ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID;
552 *pnum = nb_sectors;
553
554 /* LUN does not support logical block provisioning */
555 if (!iscsilun->lbpme) {
556 goto out;
557 }
558
559 retry:
560 if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,
561 sector_qemu2lun(sector_num, iscsilun),
562 8 + 16, iscsi_co_generic_cb,
563 &iTask) == NULL) {
564 ret = -ENOMEM;
565 goto out;
566 }
567
568 while (!iTask.complete) {
569 iscsi_set_events(iscsilun);
570 qemu_coroutine_yield();
571 }
572
573 if (iTask.do_retry) {
574 if (iTask.task != NULL) {
575 scsi_free_scsi_task(iTask.task);
576 iTask.task = NULL;
577 }
578 iTask.complete = 0;
579 goto retry;
580 }
581
582 if (iTask.status != SCSI_STATUS_GOOD) {
583 /* in case the get_lba_status_callout fails (i.e.
584 * because the device is busy or the cmd is not
585 * supported) we pretend all blocks are allocated
586 * for backwards compatibility */
587 goto out;
588 }
589
590 lbas = scsi_datain_unmarshall(iTask.task);
591 if (lbas == NULL) {
592 ret = -EIO;
593 goto out;
594 }
595
596 lbasd = &lbas->descriptors[0];
597
598 if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) {
599 ret = -EIO;
600 goto out;
601 }
602
603 *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun);
604
605 if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED ||
606 lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) {
607 ret &= ~BDRV_BLOCK_DATA;
608 if (iscsilun->lbprz) {
609 ret |= BDRV_BLOCK_ZERO;
610 }
611 }
612
613 if (ret & BDRV_BLOCK_ZERO) {
614 iscsi_allocationmap_clear(iscsilun, sector_num, *pnum);
615 } else {
616 iscsi_allocationmap_set(iscsilun, sector_num, *pnum);
617 }
618
619 if (*pnum > nb_sectors) {
620 *pnum = nb_sectors;
621 }
622 out:
623 if (iTask.task != NULL) {
624 scsi_free_scsi_task(iTask.task);
625 }
626 return ret;
627 }
628
629 static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,
630 int64_t sector_num, int nb_sectors,
631 QEMUIOVector *iov)
632 {
633 IscsiLun *iscsilun = bs->opaque;
634 struct IscsiTask iTask;
635 uint64_t lba;
636 uint32_t num_sectors;
637
638 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
639 return -EINVAL;
640 }
641
642 if (bs->bl.max_transfer_length && nb_sectors > bs->bl.max_transfer_length) {
643 error_report("iSCSI Error: Read of %d sectors exceeds max_xfer_len "
644 "of %d sectors", nb_sectors, bs->bl.max_transfer_length);
645 return -EINVAL;
646 }
647
648 if (iscsilun->lbprz && nb_sectors >= ISCSI_CHECKALLOC_THRES &&
649 !iscsi_allocationmap_is_allocated(iscsilun, sector_num, nb_sectors)) {
650 int64_t ret;
651 int pnum;
652 ret = iscsi_co_get_block_status(bs, sector_num, INT_MAX, &pnum);
653 if (ret < 0) {
654 return ret;
655 }
656 if (ret & BDRV_BLOCK_ZERO && pnum >= nb_sectors) {
657 qemu_iovec_memset(iov, 0, 0x00, iov->size);
658 return 0;
659 }
660 }
661
662 lba = sector_qemu2lun(sector_num, iscsilun);
663 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
664
665 iscsi_co_init_iscsitask(iscsilun, &iTask);
666 retry:
667 if (iscsilun->use_16_for_rw) {
668 iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba,
669 num_sectors * iscsilun->block_size,
670 iscsilun->block_size, 0, 0, 0, 0, 0,
671 iscsi_co_generic_cb, &iTask);
672 } else {
673 iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,
674 num_sectors * iscsilun->block_size,
675 iscsilun->block_size,
676 0, 0, 0, 0, 0,
677 iscsi_co_generic_cb, &iTask);
678 }
679 if (iTask.task == NULL) {
680 return -ENOMEM;
681 }
682 scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);
683
684 while (!iTask.complete) {
685 iscsi_set_events(iscsilun);
686 qemu_coroutine_yield();
687 }
688
689 if (iTask.task != NULL) {
690 scsi_free_scsi_task(iTask.task);
691 iTask.task = NULL;
692 }
693
694 if (iTask.do_retry) {
695 iTask.complete = 0;
696 goto retry;
697 }
698
699 if (iTask.status != SCSI_STATUS_GOOD) {
700 return iTask.err_code;
701 }
702
703 return 0;
704 }
705
706 static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)
707 {
708 IscsiLun *iscsilun = bs->opaque;
709 struct IscsiTask iTask;
710
711 if (!iscsilun->force_next_flush) {
712 return 0;
713 }
714 iscsilun->force_next_flush = false;
715
716 iscsi_co_init_iscsitask(iscsilun, &iTask);
717 retry:
718 if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,
719 0, iscsi_co_generic_cb, &iTask) == NULL) {
720 return -ENOMEM;
721 }
722
723 while (!iTask.complete) {
724 iscsi_set_events(iscsilun);
725 qemu_coroutine_yield();
726 }
727
728 if (iTask.task != NULL) {
729 scsi_free_scsi_task(iTask.task);
730 iTask.task = NULL;
731 }
732
733 if (iTask.do_retry) {
734 iTask.complete = 0;
735 goto retry;
736 }
737
738 if (iTask.status != SCSI_STATUS_GOOD) {
739 return iTask.err_code;
740 }
741
742 return 0;
743 }
744
745 #ifdef __linux__
746 static void
747 iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
748 void *command_data, void *opaque)
749 {
750 IscsiAIOCB *acb = opaque;
751
752 g_free(acb->buf);
753 acb->buf = NULL;
754
755 acb->status = 0;
756 if (status < 0) {
757 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
758 iscsi_get_error(iscsi));
759 acb->status = iscsi_translate_sense(&acb->task->sense);
760 }
761
762 acb->ioh->driver_status = 0;
763 acb->ioh->host_status = 0;
764 acb->ioh->resid = 0;
765
766 #define SG_ERR_DRIVER_SENSE 0x08
767
768 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
769 int ss;
770
771 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
772
773 acb->ioh->sb_len_wr = acb->task->datain.size - 2;
774 ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?
775 acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;
776 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
777 }
778
779 iscsi_schedule_bh(acb);
780 }
781
782 static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
783 unsigned long int req, void *buf,
784 BlockCompletionFunc *cb, void *opaque)
785 {
786 IscsiLun *iscsilun = bs->opaque;
787 struct iscsi_context *iscsi = iscsilun->iscsi;
788 struct iscsi_data data;
789 IscsiAIOCB *acb;
790
791 assert(req == SG_IO);
792
793 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
794
795 acb->iscsilun = iscsilun;
796 acb->bh = NULL;
797 acb->status = -EINPROGRESS;
798 acb->buf = NULL;
799 acb->ioh = buf;
800
801 acb->task = malloc(sizeof(struct scsi_task));
802 if (acb->task == NULL) {
803 error_report("iSCSI: Failed to allocate task for scsi command. %s",
804 iscsi_get_error(iscsi));
805 qemu_aio_unref(acb);
806 return NULL;
807 }
808 memset(acb->task, 0, sizeof(struct scsi_task));
809
810 switch (acb->ioh->dxfer_direction) {
811 case SG_DXFER_TO_DEV:
812 acb->task->xfer_dir = SCSI_XFER_WRITE;
813 break;
814 case SG_DXFER_FROM_DEV:
815 acb->task->xfer_dir = SCSI_XFER_READ;
816 break;
817 default:
818 acb->task->xfer_dir = SCSI_XFER_NONE;
819 break;
820 }
821
822 acb->task->cdb_size = acb->ioh->cmd_len;
823 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
824 acb->task->expxferlen = acb->ioh->dxfer_len;
825
826 data.size = 0;
827 if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
828 if (acb->ioh->iovec_count == 0) {
829 data.data = acb->ioh->dxferp;
830 data.size = acb->ioh->dxfer_len;
831 } else {
832 scsi_task_set_iov_out(acb->task,
833 (struct scsi_iovec *) acb->ioh->dxferp,
834 acb->ioh->iovec_count);
835 }
836 }
837
838 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
839 iscsi_aio_ioctl_cb,
840 (data.size > 0) ? &data : NULL,
841 acb) != 0) {
842 scsi_free_scsi_task(acb->task);
843 qemu_aio_unref(acb);
844 return NULL;
845 }
846
847 /* tell libiscsi to read straight into the buffer we got from ioctl */
848 if (acb->task->xfer_dir == SCSI_XFER_READ) {
849 if (acb->ioh->iovec_count == 0) {
850 scsi_task_add_data_in_buffer(acb->task,
851 acb->ioh->dxfer_len,
852 acb->ioh->dxferp);
853 } else {
854 scsi_task_set_iov_in(acb->task,
855 (struct scsi_iovec *) acb->ioh->dxferp,
856 acb->ioh->iovec_count);
857 }
858 }
859
860 iscsi_set_events(iscsilun);
861
862 return &acb->common;
863 }
864
865 static void ioctl_cb(void *opaque, int status)
866 {
867 int *p_status = opaque;
868 *p_status = status;
869 }
870
871 static int iscsi_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
872 {
873 IscsiLun *iscsilun = bs->opaque;
874 int status;
875
876 switch (req) {
877 case SG_GET_VERSION_NUM:
878 *(int *)buf = 30000;
879 break;
880 case SG_GET_SCSI_ID:
881 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
882 break;
883 case SG_IO:
884 status = -EINPROGRESS;
885 iscsi_aio_ioctl(bs, req, buf, ioctl_cb, &status);
886
887 while (status == -EINPROGRESS) {
888 aio_poll(iscsilun->aio_context, true);
889 }
890
891 return 0;
892 default:
893 return -1;
894 }
895 return 0;
896 }
897 #endif
898
899 static int64_t
900 iscsi_getlength(BlockDriverState *bs)
901 {
902 IscsiLun *iscsilun = bs->opaque;
903 int64_t len;
904
905 len = iscsilun->num_blocks;
906 len *= iscsilun->block_size;
907
908 return len;
909 }
910
911 static int
912 coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num,
913 int nb_sectors)
914 {
915 IscsiLun *iscsilun = bs->opaque;
916 struct IscsiTask iTask;
917 struct unmap_list list;
918
919 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
920 return -EINVAL;
921 }
922
923 if (!iscsilun->lbp.lbpu) {
924 /* UNMAP is not supported by the target */
925 return 0;
926 }
927
928 list.lba = sector_qemu2lun(sector_num, iscsilun);
929 list.num = sector_qemu2lun(nb_sectors, iscsilun);
930
931 iscsi_co_init_iscsitask(iscsilun, &iTask);
932 retry:
933 if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
934 iscsi_co_generic_cb, &iTask) == NULL) {
935 return -ENOMEM;
936 }
937
938 while (!iTask.complete) {
939 iscsi_set_events(iscsilun);
940 qemu_coroutine_yield();
941 }
942
943 if (iTask.task != NULL) {
944 scsi_free_scsi_task(iTask.task);
945 iTask.task = NULL;
946 }
947
948 if (iTask.do_retry) {
949 iTask.complete = 0;
950 goto retry;
951 }
952
953 if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
954 /* the target might fail with a check condition if it
955 is not happy with the alignment of the UNMAP request
956 we silently fail in this case */
957 return 0;
958 }
959
960 if (iTask.status != SCSI_STATUS_GOOD) {
961 return iTask.err_code;
962 }
963
964 iscsi_allocationmap_clear(iscsilun, sector_num, nb_sectors);
965
966 return 0;
967 }
968
969 static int
970 coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
971 int nb_sectors, BdrvRequestFlags flags)
972 {
973 IscsiLun *iscsilun = bs->opaque;
974 struct IscsiTask iTask;
975 uint64_t lba;
976 uint32_t nb_blocks;
977 bool use_16_for_ws = iscsilun->use_16_for_rw;
978
979 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
980 return -EINVAL;
981 }
982
983 if (flags & BDRV_REQ_MAY_UNMAP) {
984 if (!use_16_for_ws && !iscsilun->lbp.lbpws10) {
985 /* WRITESAME10 with UNMAP is unsupported try WRITESAME16 */
986 use_16_for_ws = true;
987 }
988 if (use_16_for_ws && !iscsilun->lbp.lbpws) {
989 /* WRITESAME16 with UNMAP is not supported by the target,
990 * fall back and try WRITESAME10/16 without UNMAP */
991 flags &= ~BDRV_REQ_MAY_UNMAP;
992 use_16_for_ws = iscsilun->use_16_for_rw;
993 }
994 }
995
996 if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
997 /* WRITESAME without UNMAP is not supported by the target */
998 return -ENOTSUP;
999 }
1000
1001 lba = sector_qemu2lun(sector_num, iscsilun);
1002 nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);
1003
1004 if (iscsilun->zeroblock == NULL) {
1005 iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size);
1006 if (iscsilun->zeroblock == NULL) {
1007 return -ENOMEM;
1008 }
1009 }
1010
1011 iscsi_co_init_iscsitask(iscsilun, &iTask);
1012 iTask.force_next_flush = true;
1013 retry:
1014 if (use_16_for_ws) {
1015 iTask.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
1016 iscsilun->zeroblock, iscsilun->block_size,
1017 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1018 0, 0, iscsi_co_generic_cb, &iTask);
1019 } else {
1020 iTask.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba,
1021 iscsilun->zeroblock, iscsilun->block_size,
1022 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1023 0, 0, iscsi_co_generic_cb, &iTask);
1024 }
1025 if (iTask.task == NULL) {
1026 return -ENOMEM;
1027 }
1028
1029 while (!iTask.complete) {
1030 iscsi_set_events(iscsilun);
1031 qemu_coroutine_yield();
1032 }
1033
1034 if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
1035 iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
1036 (iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE ||
1037 iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) {
1038 /* WRITE SAME is not supported by the target */
1039 iscsilun->has_write_same = false;
1040 scsi_free_scsi_task(iTask.task);
1041 return -ENOTSUP;
1042 }
1043
1044 if (iTask.task != NULL) {
1045 scsi_free_scsi_task(iTask.task);
1046 iTask.task = NULL;
1047 }
1048
1049 if (iTask.do_retry) {
1050 iTask.complete = 0;
1051 goto retry;
1052 }
1053
1054 if (iTask.status != SCSI_STATUS_GOOD) {
1055 return iTask.err_code;
1056 }
1057
1058 if (flags & BDRV_REQ_MAY_UNMAP) {
1059 iscsi_allocationmap_clear(iscsilun, sector_num, nb_sectors);
1060 } else {
1061 iscsi_allocationmap_set(iscsilun, sector_num, nb_sectors);
1062 }
1063
1064 return 0;
1065 }
1066
1067 static void parse_chap(struct iscsi_context *iscsi, const char *target,
1068 Error **errp)
1069 {
1070 QemuOptsList *list;
1071 QemuOpts *opts;
1072 const char *user = NULL;
1073 const char *password = NULL;
1074
1075 list = qemu_find_opts("iscsi");
1076 if (!list) {
1077 return;
1078 }
1079
1080 opts = qemu_opts_find(list, target);
1081 if (opts == NULL) {
1082 opts = QTAILQ_FIRST(&list->head);
1083 if (!opts) {
1084 return;
1085 }
1086 }
1087
1088 user = qemu_opt_get(opts, "user");
1089 if (!user) {
1090 return;
1091 }
1092
1093 password = qemu_opt_get(opts, "password");
1094 if (!password) {
1095 error_setg(errp, "CHAP username specified but no password was given");
1096 return;
1097 }
1098
1099 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
1100 error_setg(errp, "Failed to set initiator username and password");
1101 }
1102 }
1103
1104 static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
1105 Error **errp)
1106 {
1107 QemuOptsList *list;
1108 QemuOpts *opts;
1109 const char *digest = NULL;
1110
1111 list = qemu_find_opts("iscsi");
1112 if (!list) {
1113 return;
1114 }
1115
1116 opts = qemu_opts_find(list, target);
1117 if (opts == NULL) {
1118 opts = QTAILQ_FIRST(&list->head);
1119 if (!opts) {
1120 return;
1121 }
1122 }
1123
1124 digest = qemu_opt_get(opts, "header-digest");
1125 if (!digest) {
1126 return;
1127 }
1128
1129 if (!strcmp(digest, "CRC32C")) {
1130 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
1131 } else if (!strcmp(digest, "NONE")) {
1132 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
1133 } else if (!strcmp(digest, "CRC32C-NONE")) {
1134 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
1135 } else if (!strcmp(digest, "NONE-CRC32C")) {
1136 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1137 } else {
1138 error_setg(errp, "Invalid header-digest setting : %s", digest);
1139 }
1140 }
1141
1142 static char *parse_initiator_name(const char *target)
1143 {
1144 QemuOptsList *list;
1145 QemuOpts *opts;
1146 const char *name;
1147 char *iscsi_name;
1148 UuidInfo *uuid_info;
1149
1150 list = qemu_find_opts("iscsi");
1151 if (list) {
1152 opts = qemu_opts_find(list, target);
1153 if (!opts) {
1154 opts = QTAILQ_FIRST(&list->head);
1155 }
1156 if (opts) {
1157 name = qemu_opt_get(opts, "initiator-name");
1158 if (name) {
1159 return g_strdup(name);
1160 }
1161 }
1162 }
1163
1164 uuid_info = qmp_query_uuid(NULL);
1165 if (strcmp(uuid_info->UUID, UUID_NONE) == 0) {
1166 name = qemu_get_vm_name();
1167 } else {
1168 name = uuid_info->UUID;
1169 }
1170 iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
1171 name ? ":" : "", name ? name : "");
1172 qapi_free_UuidInfo(uuid_info);
1173 return iscsi_name;
1174 }
1175
1176 static int parse_timeout(const char *target)
1177 {
1178 QemuOptsList *list;
1179 QemuOpts *opts;
1180 const char *timeout;
1181
1182 list = qemu_find_opts("iscsi");
1183 if (list) {
1184 opts = qemu_opts_find(list, target);
1185 if (!opts) {
1186 opts = QTAILQ_FIRST(&list->head);
1187 }
1188 if (opts) {
1189 timeout = qemu_opt_get(opts, "timeout");
1190 if (timeout) {
1191 return atoi(timeout);
1192 }
1193 }
1194 }
1195
1196 return 0;
1197 }
1198
1199 static void iscsi_nop_timed_event(void *opaque)
1200 {
1201 IscsiLun *iscsilun = opaque;
1202
1203 if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
1204 error_report("iSCSI: NOP timeout. Reconnecting...");
1205 iscsilun->request_timed_out = true;
1206 } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
1207 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
1208 return;
1209 }
1210
1211 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1212 iscsi_set_events(iscsilun);
1213 }
1214
1215 static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
1216 {
1217 struct scsi_task *task = NULL;
1218 struct scsi_readcapacity10 *rc10 = NULL;
1219 struct scsi_readcapacity16 *rc16 = NULL;
1220 int retries = ISCSI_CMD_RETRIES;
1221
1222 do {
1223 if (task != NULL) {
1224 scsi_free_scsi_task(task);
1225 task = NULL;
1226 }
1227
1228 switch (iscsilun->type) {
1229 case TYPE_DISK:
1230 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun);
1231 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1232 rc16 = scsi_datain_unmarshall(task);
1233 if (rc16 == NULL) {
1234 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity16 data.");
1235 } else {
1236 iscsilun->block_size = rc16->block_length;
1237 iscsilun->num_blocks = rc16->returned_lba + 1;
1238 iscsilun->lbpme = !!rc16->lbpme;
1239 iscsilun->lbprz = !!rc16->lbprz;
1240 iscsilun->use_16_for_rw = (rc16->returned_lba > 0xffffffff);
1241 }
1242 }
1243 break;
1244 case TYPE_ROM:
1245 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0);
1246 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1247 rc10 = scsi_datain_unmarshall(task);
1248 if (rc10 == NULL) {
1249 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity10 data.");
1250 } else {
1251 iscsilun->block_size = rc10->block_size;
1252 if (rc10->lba == 0) {
1253 /* blank disk loaded */
1254 iscsilun->num_blocks = 0;
1255 } else {
1256 iscsilun->num_blocks = rc10->lba + 1;
1257 }
1258 }
1259 }
1260 break;
1261 default:
1262 return;
1263 }
1264 } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1265 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION
1266 && retries-- > 0);
1267
1268 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1269 error_setg(errp, "iSCSI: failed to send readcapacity10 command.");
1270 } else if (!iscsilun->block_size ||
1271 iscsilun->block_size % BDRV_SECTOR_SIZE) {
1272 error_setg(errp, "iSCSI: the target returned an invalid "
1273 "block size of %d.", iscsilun->block_size);
1274 }
1275 if (task) {
1276 scsi_free_scsi_task(task);
1277 }
1278 }
1279
1280 /* TODO Convert to fine grained options */
1281 static QemuOptsList runtime_opts = {
1282 .name = "iscsi",
1283 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1284 .desc = {
1285 {
1286 .name = "filename",
1287 .type = QEMU_OPT_STRING,
1288 .help = "URL to the iscsi image",
1289 },
1290 { /* end of list */ }
1291 },
1292 };
1293
1294 static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
1295 int evpd, int pc, void **inq, Error **errp)
1296 {
1297 int full_size;
1298 struct scsi_task *task = NULL;
1299 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
1300 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1301 goto fail;
1302 }
1303 full_size = scsi_datain_getfullsize(task);
1304 if (full_size > task->datain.size) {
1305 scsi_free_scsi_task(task);
1306
1307 /* we need more data for the full list */
1308 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size);
1309 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1310 goto fail;
1311 }
1312 }
1313
1314 *inq = scsi_datain_unmarshall(task);
1315 if (*inq == NULL) {
1316 error_setg(errp, "iSCSI: failed to unmarshall inquiry datain blob");
1317 goto fail_with_err;
1318 }
1319
1320 return task;
1321
1322 fail:
1323 error_setg(errp, "iSCSI: Inquiry command failed : %s",
1324 iscsi_get_error(iscsi));
1325 fail_with_err:
1326 if (task != NULL) {
1327 scsi_free_scsi_task(task);
1328 }
1329 return NULL;
1330 }
1331
1332 static void iscsi_detach_aio_context(BlockDriverState *bs)
1333 {
1334 IscsiLun *iscsilun = bs->opaque;
1335
1336 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
1337 false, NULL, NULL, NULL);
1338 iscsilun->events = 0;
1339
1340 if (iscsilun->nop_timer) {
1341 timer_del(iscsilun->nop_timer);
1342 timer_free(iscsilun->nop_timer);
1343 iscsilun->nop_timer = NULL;
1344 }
1345 if (iscsilun->event_timer) {
1346 timer_del(iscsilun->event_timer);
1347 timer_free(iscsilun->event_timer);
1348 iscsilun->event_timer = NULL;
1349 }
1350 }
1351
1352 static void iscsi_attach_aio_context(BlockDriverState *bs,
1353 AioContext *new_context)
1354 {
1355 IscsiLun *iscsilun = bs->opaque;
1356
1357 iscsilun->aio_context = new_context;
1358 iscsi_set_events(iscsilun);
1359
1360 /* Set up a timer for sending out iSCSI NOPs */
1361 iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
1362 QEMU_CLOCK_REALTIME, SCALE_MS,
1363 iscsi_nop_timed_event, iscsilun);
1364 timer_mod(iscsilun->nop_timer,
1365 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1366
1367 /* Set up a timer for periodic calls to iscsi_set_events and to
1368 * scan for command timeout */
1369 iscsilun->event_timer = aio_timer_new(iscsilun->aio_context,
1370 QEMU_CLOCK_REALTIME, SCALE_MS,
1371 iscsi_timed_check_events, iscsilun);
1372 timer_mod(iscsilun->event_timer,
1373 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
1374 }
1375
1376 static void iscsi_modesense_sync(IscsiLun *iscsilun)
1377 {
1378 struct scsi_task *task;
1379 struct scsi_mode_sense *ms = NULL;
1380 iscsilun->write_protected = false;
1381 iscsilun->dpofua = false;
1382
1383 task = iscsi_modesense6_sync(iscsilun->iscsi, iscsilun->lun,
1384 1, SCSI_MODESENSE_PC_CURRENT,
1385 0x3F, 0, 255);
1386 if (task == NULL) {
1387 error_report("iSCSI: Failed to send MODE_SENSE(6) command: %s",
1388 iscsi_get_error(iscsilun->iscsi));
1389 goto out;
1390 }
1391
1392 if (task->status != SCSI_STATUS_GOOD) {
1393 error_report("iSCSI: Failed MODE_SENSE(6), LUN assumed writable");
1394 goto out;
1395 }
1396 ms = scsi_datain_unmarshall(task);
1397 if (!ms) {
1398 error_report("iSCSI: Failed to unmarshall MODE_SENSE(6) data: %s",
1399 iscsi_get_error(iscsilun->iscsi));
1400 goto out;
1401 }
1402 iscsilun->write_protected = ms->device_specific_parameter & 0x80;
1403 iscsilun->dpofua = ms->device_specific_parameter & 0x10;
1404
1405 out:
1406 if (task) {
1407 scsi_free_scsi_task(task);
1408 }
1409 }
1410
1411 /*
1412 * We support iscsi url's on the form
1413 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1414 */
1415 static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
1416 Error **errp)
1417 {
1418 IscsiLun *iscsilun = bs->opaque;
1419 struct iscsi_context *iscsi = NULL;
1420 struct iscsi_url *iscsi_url = NULL;
1421 struct scsi_task *task = NULL;
1422 struct scsi_inquiry_standard *inq = NULL;
1423 struct scsi_inquiry_supported_pages *inq_vpd;
1424 char *initiator_name = NULL;
1425 QemuOpts *opts;
1426 Error *local_err = NULL;
1427 const char *filename;
1428 int i, ret = 0, timeout = 0;
1429
1430 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1431 qemu_opts_absorb_qdict(opts, options, &local_err);
1432 if (local_err) {
1433 error_propagate(errp, local_err);
1434 ret = -EINVAL;
1435 goto out;
1436 }
1437
1438 filename = qemu_opt_get(opts, "filename");
1439
1440 iscsi_url = iscsi_parse_full_url(iscsi, filename);
1441 if (iscsi_url == NULL) {
1442 error_setg(errp, "Failed to parse URL : %s", filename);
1443 ret = -EINVAL;
1444 goto out;
1445 }
1446
1447 memset(iscsilun, 0, sizeof(IscsiLun));
1448
1449 initiator_name = parse_initiator_name(iscsi_url->target);
1450
1451 iscsi = iscsi_create_context(initiator_name);
1452 if (iscsi == NULL) {
1453 error_setg(errp, "iSCSI: Failed to create iSCSI context.");
1454 ret = -ENOMEM;
1455 goto out;
1456 }
1457
1458 if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
1459 error_setg(errp, "iSCSI: Failed to set target name.");
1460 ret = -EINVAL;
1461 goto out;
1462 }
1463
1464 if (iscsi_url->user[0] != '\0') {
1465 ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
1466 iscsi_url->passwd);
1467 if (ret != 0) {
1468 error_setg(errp, "Failed to set initiator username and password");
1469 ret = -EINVAL;
1470 goto out;
1471 }
1472 }
1473
1474 /* check if we got CHAP username/password via the options */
1475 parse_chap(iscsi, iscsi_url->target, &local_err);
1476 if (local_err != NULL) {
1477 error_propagate(errp, local_err);
1478 ret = -EINVAL;
1479 goto out;
1480 }
1481
1482 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
1483 error_setg(errp, "iSCSI: Failed to set session type to normal.");
1484 ret = -EINVAL;
1485 goto out;
1486 }
1487
1488 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1489
1490 /* check if we got HEADER_DIGEST via the options */
1491 parse_header_digest(iscsi, iscsi_url->target, &local_err);
1492 if (local_err != NULL) {
1493 error_propagate(errp, local_err);
1494 ret = -EINVAL;
1495 goto out;
1496 }
1497
1498 /* timeout handling is broken in libiscsi before 1.15.0 */
1499 timeout = parse_timeout(iscsi_url->target);
1500 #if defined(LIBISCSI_API_VERSION) && LIBISCSI_API_VERSION >= 20150621
1501 iscsi_set_timeout(iscsi, timeout);
1502 #else
1503 if (timeout) {
1504 error_report("iSCSI: ignoring timeout value for libiscsi <1.15.0");
1505 }
1506 #endif
1507
1508 if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
1509 error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
1510 iscsi_get_error(iscsi));
1511 ret = -EINVAL;
1512 goto out;
1513 }
1514
1515 iscsilun->iscsi = iscsi;
1516 iscsilun->aio_context = bdrv_get_aio_context(bs);
1517 iscsilun->lun = iscsi_url->lun;
1518 iscsilun->has_write_same = true;
1519
1520 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
1521 (void **) &inq, errp);
1522 if (task == NULL) {
1523 ret = -EINVAL;
1524 goto out;
1525 }
1526 iscsilun->type = inq->periperal_device_type;
1527 scsi_free_scsi_task(task);
1528 task = NULL;
1529
1530 iscsi_modesense_sync(iscsilun);
1531
1532 /* Check the write protect flag of the LUN if we want to write */
1533 if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
1534 iscsilun->write_protected) {
1535 error_setg(errp, "Cannot open a write protected LUN as read-write");
1536 ret = -EACCES;
1537 goto out;
1538 }
1539
1540 iscsi_readcapacity_sync(iscsilun, &local_err);
1541 if (local_err != NULL) {
1542 error_propagate(errp, local_err);
1543 ret = -EINVAL;
1544 goto out;
1545 }
1546 bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun);
1547 bs->request_alignment = iscsilun->block_size;
1548
1549 /* We don't have any emulation for devices other than disks and CD-ROMs, so
1550 * this must be sg ioctl compatible. We force it to be sg, otherwise qemu
1551 * will try to read from the device to guess the image format.
1552 */
1553 if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) {
1554 bs->sg = 1;
1555 }
1556
1557 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1558 SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES,
1559 (void **) &inq_vpd, errp);
1560 if (task == NULL) {
1561 ret = -EINVAL;
1562 goto out;
1563 }
1564 for (i = 0; i < inq_vpd->num_pages; i++) {
1565 struct scsi_task *inq_task;
1566 struct scsi_inquiry_logical_block_provisioning *inq_lbp;
1567 struct scsi_inquiry_block_limits *inq_bl;
1568 switch (inq_vpd->pages[i]) {
1569 case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
1570 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1571 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING,
1572 (void **) &inq_lbp, errp);
1573 if (inq_task == NULL) {
1574 ret = -EINVAL;
1575 goto out;
1576 }
1577 memcpy(&iscsilun->lbp, inq_lbp,
1578 sizeof(struct scsi_inquiry_logical_block_provisioning));
1579 scsi_free_scsi_task(inq_task);
1580 break;
1581 case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
1582 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1583 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS,
1584 (void **) &inq_bl, errp);
1585 if (inq_task == NULL) {
1586 ret = -EINVAL;
1587 goto out;
1588 }
1589 memcpy(&iscsilun->bl, inq_bl,
1590 sizeof(struct scsi_inquiry_block_limits));
1591 scsi_free_scsi_task(inq_task);
1592 break;
1593 default:
1594 break;
1595 }
1596 }
1597 scsi_free_scsi_task(task);
1598 task = NULL;
1599
1600 iscsi_attach_aio_context(bs, iscsilun->aio_context);
1601
1602 /* Guess the internal cluster (page) size of the iscsi target by the means
1603 * of opt_unmap_gran. Transfer the unmap granularity only if it has a
1604 * reasonable size */
1605 if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 4 * 1024 &&
1606 iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) {
1607 iscsilun->cluster_sectors = (iscsilun->bl.opt_unmap_gran *
1608 iscsilun->block_size) >> BDRV_SECTOR_BITS;
1609 if (iscsilun->lbprz) {
1610 iscsilun->allocationmap = iscsi_allocationmap_init(iscsilun);
1611 if (iscsilun->allocationmap == NULL) {
1612 ret = -ENOMEM;
1613 }
1614 }
1615 }
1616
1617 out:
1618 qemu_opts_del(opts);
1619 g_free(initiator_name);
1620 if (iscsi_url != NULL) {
1621 iscsi_destroy_url(iscsi_url);
1622 }
1623 if (task != NULL) {
1624 scsi_free_scsi_task(task);
1625 }
1626
1627 if (ret) {
1628 if (iscsi != NULL) {
1629 if (iscsi_is_logged_in(iscsi)) {
1630 iscsi_logout_sync(iscsi);
1631 }
1632 iscsi_destroy_context(iscsi);
1633 }
1634 memset(iscsilun, 0, sizeof(IscsiLun));
1635 }
1636 return ret;
1637 }
1638
1639 static void iscsi_close(BlockDriverState *bs)
1640 {
1641 IscsiLun *iscsilun = bs->opaque;
1642 struct iscsi_context *iscsi = iscsilun->iscsi;
1643
1644 iscsi_detach_aio_context(bs);
1645 if (iscsi_is_logged_in(iscsi)) {
1646 iscsi_logout_sync(iscsi);
1647 }
1648 iscsi_destroy_context(iscsi);
1649 g_free(iscsilun->zeroblock);
1650 g_free(iscsilun->allocationmap);
1651 memset(iscsilun, 0, sizeof(IscsiLun));
1652 }
1653
1654 static int sector_limits_lun2qemu(int64_t sector, IscsiLun *iscsilun)
1655 {
1656 return MIN(sector_lun2qemu(sector, iscsilun), INT_MAX / 2 + 1);
1657 }
1658
1659 static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp)
1660 {
1661 /* We don't actually refresh here, but just return data queried in
1662 * iscsi_open(): iscsi targets don't change their limits. */
1663
1664 IscsiLun *iscsilun = bs->opaque;
1665 uint32_t max_xfer_len = iscsilun->use_16_for_rw ? 0xffffffff : 0xffff;
1666
1667 if (iscsilun->bl.max_xfer_len) {
1668 max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len);
1669 }
1670
1671 bs->bl.max_transfer_length = sector_limits_lun2qemu(max_xfer_len, iscsilun);
1672
1673 if (iscsilun->lbp.lbpu) {
1674 if (iscsilun->bl.max_unmap < 0xffffffff) {
1675 bs->bl.max_discard =
1676 sector_limits_lun2qemu(iscsilun->bl.max_unmap, iscsilun);
1677 }
1678 bs->bl.discard_alignment =
1679 sector_limits_lun2qemu(iscsilun->bl.opt_unmap_gran, iscsilun);
1680 }
1681
1682 if (iscsilun->bl.max_ws_len < 0xffffffff) {
1683 bs->bl.max_write_zeroes =
1684 sector_limits_lun2qemu(iscsilun->bl.max_ws_len, iscsilun);
1685 }
1686 if (iscsilun->lbp.lbpws) {
1687 bs->bl.write_zeroes_alignment =
1688 sector_limits_lun2qemu(iscsilun->bl.opt_unmap_gran, iscsilun);
1689 }
1690 bs->bl.opt_transfer_length =
1691 sector_limits_lun2qemu(iscsilun->bl.opt_xfer_len, iscsilun);
1692 }
1693
1694 /* Note that this will not re-establish a connection with an iSCSI target - it
1695 * is effectively a NOP. */
1696 static int iscsi_reopen_prepare(BDRVReopenState *state,
1697 BlockReopenQueue *queue, Error **errp)
1698 {
1699 IscsiLun *iscsilun = state->bs->opaque;
1700
1701 if (state->flags & BDRV_O_RDWR && iscsilun->write_protected) {
1702 error_setg(errp, "Cannot open a write protected LUN as read-write");
1703 return -EACCES;
1704 }
1705 return 0;
1706 }
1707
1708 static int iscsi_truncate(BlockDriverState *bs, int64_t offset)
1709 {
1710 IscsiLun *iscsilun = bs->opaque;
1711 Error *local_err = NULL;
1712
1713 if (iscsilun->type != TYPE_DISK) {
1714 return -ENOTSUP;
1715 }
1716
1717 iscsi_readcapacity_sync(iscsilun, &local_err);
1718 if (local_err != NULL) {
1719 error_free(local_err);
1720 return -EIO;
1721 }
1722
1723 if (offset > iscsi_getlength(bs)) {
1724 return -EINVAL;
1725 }
1726
1727 if (iscsilun->allocationmap != NULL) {
1728 g_free(iscsilun->allocationmap);
1729 iscsilun->allocationmap = iscsi_allocationmap_init(iscsilun);
1730 }
1731
1732 return 0;
1733 }
1734
1735 static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp)
1736 {
1737 int ret = 0;
1738 int64_t total_size = 0;
1739 BlockDriverState *bs;
1740 IscsiLun *iscsilun = NULL;
1741 QDict *bs_options;
1742
1743 bs = bdrv_new();
1744
1745 /* Read out options */
1746 total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1747 BDRV_SECTOR_SIZE);
1748 bs->opaque = g_new0(struct IscsiLun, 1);
1749 iscsilun = bs->opaque;
1750
1751 bs_options = qdict_new();
1752 qdict_put(bs_options, "filename", qstring_from_str(filename));
1753 ret = iscsi_open(bs, bs_options, 0, NULL);
1754 QDECREF(bs_options);
1755
1756 if (ret != 0) {
1757 goto out;
1758 }
1759 iscsi_detach_aio_context(bs);
1760 if (iscsilun->type != TYPE_DISK) {
1761 ret = -ENODEV;
1762 goto out;
1763 }
1764 if (bs->total_sectors < total_size) {
1765 ret = -ENOSPC;
1766 goto out;
1767 }
1768
1769 ret = 0;
1770 out:
1771 if (iscsilun->iscsi != NULL) {
1772 iscsi_destroy_context(iscsilun->iscsi);
1773 }
1774 g_free(bs->opaque);
1775 bs->opaque = NULL;
1776 bdrv_unref(bs);
1777 return ret;
1778 }
1779
1780 static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1781 {
1782 IscsiLun *iscsilun = bs->opaque;
1783 bdi->unallocated_blocks_are_zero = iscsilun->lbprz;
1784 bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws;
1785 bdi->cluster_size = iscsilun->cluster_sectors * BDRV_SECTOR_SIZE;
1786 return 0;
1787 }
1788
1789 static QemuOptsList iscsi_create_opts = {
1790 .name = "iscsi-create-opts",
1791 .head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head),
1792 .desc = {
1793 {
1794 .name = BLOCK_OPT_SIZE,
1795 .type = QEMU_OPT_SIZE,
1796 .help = "Virtual disk size"
1797 },
1798 { /* end of list */ }
1799 }
1800 };
1801
1802 static BlockDriver bdrv_iscsi = {
1803 .format_name = "iscsi",
1804 .protocol_name = "iscsi",
1805
1806 .instance_size = sizeof(IscsiLun),
1807 .bdrv_needs_filename = true,
1808 .bdrv_file_open = iscsi_open,
1809 .bdrv_close = iscsi_close,
1810 .bdrv_create = iscsi_create,
1811 .create_opts = &iscsi_create_opts,
1812 .bdrv_reopen_prepare = iscsi_reopen_prepare,
1813
1814 .bdrv_getlength = iscsi_getlength,
1815 .bdrv_get_info = iscsi_get_info,
1816 .bdrv_truncate = iscsi_truncate,
1817 .bdrv_refresh_limits = iscsi_refresh_limits,
1818
1819 .bdrv_co_get_block_status = iscsi_co_get_block_status,
1820 .bdrv_co_discard = iscsi_co_discard,
1821 .bdrv_co_write_zeroes = iscsi_co_write_zeroes,
1822 .bdrv_co_readv = iscsi_co_readv,
1823 .bdrv_co_writev = iscsi_co_writev,
1824 .bdrv_co_flush_to_disk = iscsi_co_flush,
1825
1826 #ifdef __linux__
1827 .bdrv_ioctl = iscsi_ioctl,
1828 .bdrv_aio_ioctl = iscsi_aio_ioctl,
1829 #endif
1830
1831 .bdrv_detach_aio_context = iscsi_detach_aio_context,
1832 .bdrv_attach_aio_context = iscsi_attach_aio_context,
1833 };
1834
1835 static QemuOptsList qemu_iscsi_opts = {
1836 .name = "iscsi",
1837 .head = QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts.head),
1838 .desc = {
1839 {
1840 .name = "user",
1841 .type = QEMU_OPT_STRING,
1842 .help = "username for CHAP authentication to target",
1843 },{
1844 .name = "password",
1845 .type = QEMU_OPT_STRING,
1846 .help = "password for CHAP authentication to target",
1847 },{
1848 .name = "header-digest",
1849 .type = QEMU_OPT_STRING,
1850 .help = "HeaderDigest setting. "
1851 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}",
1852 },{
1853 .name = "initiator-name",
1854 .type = QEMU_OPT_STRING,
1855 .help = "Initiator iqn name to use when connecting",
1856 },{
1857 .name = "timeout",
1858 .type = QEMU_OPT_NUMBER,
1859 .help = "Request timeout in seconds (default 0 = no timeout)",
1860 },
1861 { /* end of list */ }
1862 },
1863 };
1864
1865 static void iscsi_block_init(void)
1866 {
1867 bdrv_register(&bdrv_iscsi);
1868 qemu_add_opts(&qemu_iscsi_opts);
1869 }
1870
1871 block_init(iscsi_block_init);
QEmu