2 * QEMU Block driver for iSCSI images
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
5 * Copyright (c) 2012-2013 Peter Lieven <pl@kamp.de>
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
26 #include "config-host.h"
29 #include <arpa/inet.h>
30 #include "qemu-common.h"
31 #include "qemu/config-file.h"
32 #include "qemu/error-report.h"
33 #include "block/block_int.h"
35 #include "block/scsi.h"
37 #include "sysemu/sysemu.h"
38 #include "qmp-commands.h"
40 #include <iscsi/iscsi.h>
41 #include <iscsi/scsi-lowlevel.h>
45 #include <block/scsi.h>
48 typedef struct IscsiLun
{
49 struct iscsi_context
*iscsi
;
51 enum scsi_inquiry_peripheral_device_type type
;
58 uint8_t has_write_same
;
59 struct scsi_inquiry_logical_block_provisioning lbp
;
60 struct scsi_inquiry_block_limits bl
;
61 unsigned char *zeroblock
;
64 typedef struct IscsiTask
{
69 struct scsi_task
*task
;
74 typedef struct IscsiAIOCB
{
75 BlockDriverAIOCB common
;
79 struct scsi_task
*task
;
91 #define NOP_INTERVAL 5000
92 #define MAX_NOP_FAILURES 3
93 #define ISCSI_CMD_RETRIES 5
100 qemu_bh_delete(acb
->bh
);
105 if (acb
->canceled
== 0) {
106 acb
->common
.cb(acb
->common
.opaque
, acb
->status
);
109 if (acb
->task
!= NULL
) {
110 scsi_free_scsi_task(acb
->task
);
114 qemu_aio_release(acb
);
118 iscsi_schedule_bh(IscsiAIOCB
*acb
)
123 acb
->bh
= qemu_bh_new(iscsi_bh_cb
, acb
);
124 qemu_bh_schedule(acb
->bh
);
127 static void iscsi_co_generic_bh_cb(void *opaque
)
129 struct IscsiTask
*iTask
= opaque
;
130 qemu_bh_delete(iTask
->bh
);
131 qemu_coroutine_enter(iTask
->co
, NULL
);
135 iscsi_co_generic_cb(struct iscsi_context
*iscsi
, int status
,
136 void *command_data
, void *opaque
)
138 struct IscsiTask
*iTask
= opaque
;
139 struct scsi_task
*task
= command_data
;
142 iTask
->status
= status
;
146 if (iTask
->retries
-- > 0 && status
== SCSI_STATUS_CHECK_CONDITION
147 && task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
) {
148 error_report("iSCSI CheckCondition: %s", iscsi_get_error(iscsi
));
153 if (status
!= SCSI_STATUS_GOOD
) {
154 error_report("iSCSI Failure: %s", iscsi_get_error(iscsi
));
159 iTask
->bh
= qemu_bh_new(iscsi_co_generic_bh_cb
, iTask
);
160 qemu_bh_schedule(iTask
->bh
);
164 static void iscsi_co_init_iscsitask(IscsiLun
*iscsilun
, struct IscsiTask
*iTask
)
166 *iTask
= (struct IscsiTask
) {
167 .co
= qemu_coroutine_self(),
168 .retries
= ISCSI_CMD_RETRIES
,
173 iscsi_abort_task_cb(struct iscsi_context
*iscsi
, int status
, void *command_data
,
176 IscsiAIOCB
*acb
= private_data
;
178 acb
->status
= -ECANCELED
;
179 iscsi_schedule_bh(acb
);
183 iscsi_aio_cancel(BlockDriverAIOCB
*blockacb
)
185 IscsiAIOCB
*acb
= (IscsiAIOCB
*)blockacb
;
186 IscsiLun
*iscsilun
= acb
->iscsilun
;
188 if (acb
->status
!= -EINPROGRESS
) {
194 /* send a task mgmt call to the target to cancel the task on the target */
195 iscsi_task_mgmt_abort_task_async(iscsilun
->iscsi
, acb
->task
,
196 iscsi_abort_task_cb
, acb
);
198 while (acb
->status
== -EINPROGRESS
) {
203 static const AIOCBInfo iscsi_aiocb_info
= {
204 .aiocb_size
= sizeof(IscsiAIOCB
),
205 .cancel
= iscsi_aio_cancel
,
209 static void iscsi_process_read(void *arg
);
210 static void iscsi_process_write(void *arg
);
213 iscsi_set_events(IscsiLun
*iscsilun
)
215 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
218 /* We always register a read handler. */
220 ev
|= iscsi_which_events(iscsi
);
221 if (ev
!= iscsilun
->events
) {
222 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi
),
224 (ev
& POLLOUT
) ? iscsi_process_write
: NULL
,
229 iscsilun
->events
= ev
;
233 iscsi_process_read(void *arg
)
235 IscsiLun
*iscsilun
= arg
;
236 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
238 iscsi_service(iscsi
, POLLIN
);
239 iscsi_set_events(iscsilun
);
243 iscsi_process_write(void *arg
)
245 IscsiLun
*iscsilun
= arg
;
246 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
248 iscsi_service(iscsi
, POLLOUT
);
249 iscsi_set_events(iscsilun
);
252 static int64_t sector_lun2qemu(int64_t sector
, IscsiLun
*iscsilun
)
254 return sector
* iscsilun
->block_size
/ BDRV_SECTOR_SIZE
;
257 static int64_t sector_qemu2lun(int64_t sector
, IscsiLun
*iscsilun
)
259 return sector
* BDRV_SECTOR_SIZE
/ iscsilun
->block_size
;
262 static bool is_request_lun_aligned(int64_t sector_num
, int nb_sectors
,
265 if ((sector_num
* BDRV_SECTOR_SIZE
) % iscsilun
->block_size
||
266 (nb_sectors
* BDRV_SECTOR_SIZE
) % iscsilun
->block_size
) {
267 error_report("iSCSI misaligned request: "
268 "iscsilun->block_size %u, sector_num %" PRIi64
270 iscsilun
->block_size
, sector_num
, nb_sectors
);
276 static int coroutine_fn
iscsi_co_writev(BlockDriverState
*bs
,
277 int64_t sector_num
, int nb_sectors
,
280 IscsiLun
*iscsilun
= bs
->opaque
;
281 struct IscsiTask iTask
;
283 uint32_t num_sectors
;
284 uint8_t *data
= NULL
;
287 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
291 lba
= sector_qemu2lun(sector_num
, iscsilun
);
292 num_sectors
= sector_qemu2lun(nb_sectors
, iscsilun
);
293 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
294 /* if the iovec only contains one buffer we can pass it directly */
295 if (iov
->niov
== 1) {
296 data
= iov
->iov
[0].iov_base
;
298 size_t size
= MIN(nb_sectors
* BDRV_SECTOR_SIZE
, iov
->size
);
299 buf
= g_malloc(size
);
300 qemu_iovec_to_buf(iov
, 0, buf
, size
);
304 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
306 iTask
.task
= iscsi_write16_task(iscsilun
->iscsi
, iscsilun
->lun
, lba
,
307 data
, num_sectors
* iscsilun
->block_size
,
308 iscsilun
->block_size
, 0, 0, 0, 0, 0,
309 iscsi_co_generic_cb
, &iTask
);
310 if (iTask
.task
== NULL
) {
314 #if defined(LIBISCSI_FEATURE_IOVECTOR)
315 scsi_task_set_iov_out(iTask
.task
, (struct scsi_iovec
*) iov
->iov
,
318 while (!iTask
.complete
) {
319 iscsi_set_events(iscsilun
);
320 qemu_coroutine_yield();
323 if (iTask
.task
!= NULL
) {
324 scsi_free_scsi_task(iTask
.task
);
328 if (iTask
.do_retry
) {
335 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
342 static int coroutine_fn
iscsi_co_readv(BlockDriverState
*bs
,
343 int64_t sector_num
, int nb_sectors
,
346 IscsiLun
*iscsilun
= bs
->opaque
;
347 struct IscsiTask iTask
;
349 uint32_t num_sectors
;
350 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
354 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
358 lba
= sector_qemu2lun(sector_num
, iscsilun
);
359 num_sectors
= sector_qemu2lun(nb_sectors
, iscsilun
);
361 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
363 switch (iscsilun
->type
) {
365 iTask
.task
= iscsi_read16_task(iscsilun
->iscsi
, iscsilun
->lun
, lba
,
366 num_sectors
* iscsilun
->block_size
,
367 iscsilun
->block_size
, 0, 0, 0, 0, 0,
368 iscsi_co_generic_cb
, &iTask
);
371 iTask
.task
= iscsi_read10_task(iscsilun
->iscsi
, iscsilun
->lun
, lba
,
372 num_sectors
* iscsilun
->block_size
,
373 iscsilun
->block_size
,
374 #if !defined(CONFIG_LIBISCSI_1_4) /* API change from 1.4.0 to 1.5.0 */
377 iscsi_co_generic_cb
, &iTask
);
380 if (iTask
.task
== NULL
) {
383 #if defined(LIBISCSI_FEATURE_IOVECTOR)
384 scsi_task_set_iov_in(iTask
.task
, (struct scsi_iovec
*) iov
->iov
, iov
->niov
);
386 for (i
= 0; i
< iov
->niov
; i
++) {
387 scsi_task_add_data_in_buffer(iTask
.task
,
389 iov
->iov
[i
].iov_base
);
393 while (!iTask
.complete
) {
394 iscsi_set_events(iscsilun
);
395 qemu_coroutine_yield();
398 if (iTask
.task
!= NULL
) {
399 scsi_free_scsi_task(iTask
.task
);
403 if (iTask
.do_retry
) {
408 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
415 static int coroutine_fn
iscsi_co_flush(BlockDriverState
*bs
)
417 IscsiLun
*iscsilun
= bs
->opaque
;
418 struct IscsiTask iTask
;
424 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
427 if (iscsi_synchronizecache10_task(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0, 0,
428 0, iscsi_co_generic_cb
, &iTask
) == NULL
) {
432 while (!iTask
.complete
) {
433 iscsi_set_events(iscsilun
);
434 qemu_coroutine_yield();
437 if (iTask
.task
!= NULL
) {
438 scsi_free_scsi_task(iTask
.task
);
442 if (iTask
.do_retry
) {
447 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
456 iscsi_aio_ioctl_cb(struct iscsi_context
*iscsi
, int status
,
457 void *command_data
, void *opaque
)
459 IscsiAIOCB
*acb
= opaque
;
464 if (acb
->canceled
!= 0) {
470 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
471 iscsi_get_error(iscsi
));
475 acb
->ioh
->driver_status
= 0;
476 acb
->ioh
->host_status
= 0;
479 #define SG_ERR_DRIVER_SENSE 0x08
481 if (status
== SCSI_STATUS_CHECK_CONDITION
&& acb
->task
->datain
.size
>= 2) {
484 acb
->ioh
->driver_status
|= SG_ERR_DRIVER_SENSE
;
486 acb
->ioh
->sb_len_wr
= acb
->task
->datain
.size
- 2;
487 ss
= (acb
->ioh
->mx_sb_len
>= acb
->ioh
->sb_len_wr
) ?
488 acb
->ioh
->mx_sb_len
: acb
->ioh
->sb_len_wr
;
489 memcpy(acb
->ioh
->sbp
, &acb
->task
->datain
.data
[2], ss
);
492 iscsi_schedule_bh(acb
);
495 static BlockDriverAIOCB
*iscsi_aio_ioctl(BlockDriverState
*bs
,
496 unsigned long int req
, void *buf
,
497 BlockDriverCompletionFunc
*cb
, void *opaque
)
499 IscsiLun
*iscsilun
= bs
->opaque
;
500 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
501 struct iscsi_data data
;
504 assert(req
== SG_IO
);
506 acb
= qemu_aio_get(&iscsi_aiocb_info
, bs
, cb
, opaque
);
508 acb
->iscsilun
= iscsilun
;
511 acb
->status
= -EINPROGRESS
;
515 acb
->task
= malloc(sizeof(struct scsi_task
));
516 if (acb
->task
== NULL
) {
517 error_report("iSCSI: Failed to allocate task for scsi command. %s",
518 iscsi_get_error(iscsi
));
519 qemu_aio_release(acb
);
522 memset(acb
->task
, 0, sizeof(struct scsi_task
));
524 switch (acb
->ioh
->dxfer_direction
) {
525 case SG_DXFER_TO_DEV
:
526 acb
->task
->xfer_dir
= SCSI_XFER_WRITE
;
528 case SG_DXFER_FROM_DEV
:
529 acb
->task
->xfer_dir
= SCSI_XFER_READ
;
532 acb
->task
->xfer_dir
= SCSI_XFER_NONE
;
536 acb
->task
->cdb_size
= acb
->ioh
->cmd_len
;
537 memcpy(&acb
->task
->cdb
[0], acb
->ioh
->cmdp
, acb
->ioh
->cmd_len
);
538 acb
->task
->expxferlen
= acb
->ioh
->dxfer_len
;
541 if (acb
->task
->xfer_dir
== SCSI_XFER_WRITE
) {
542 if (acb
->ioh
->iovec_count
== 0) {
543 data
.data
= acb
->ioh
->dxferp
;
544 data
.size
= acb
->ioh
->dxfer_len
;
546 #if defined(LIBISCSI_FEATURE_IOVECTOR)
547 scsi_task_set_iov_out(acb
->task
,
548 (struct scsi_iovec
*) acb
->ioh
->dxferp
,
549 acb
->ioh
->iovec_count
);
551 struct iovec
*iov
= (struct iovec
*)acb
->ioh
->dxferp
;
553 acb
->buf
= g_malloc(acb
->ioh
->dxfer_len
);
554 data
.data
= acb
->buf
;
555 data
.size
= iov_to_buf(iov
, acb
->ioh
->iovec_count
, 0,
556 acb
->buf
, acb
->ioh
->dxfer_len
);
561 if (iscsi_scsi_command_async(iscsi
, iscsilun
->lun
, acb
->task
,
563 (data
.size
> 0) ? &data
: NULL
,
565 scsi_free_scsi_task(acb
->task
);
566 qemu_aio_release(acb
);
570 /* tell libiscsi to read straight into the buffer we got from ioctl */
571 if (acb
->task
->xfer_dir
== SCSI_XFER_READ
) {
572 if (acb
->ioh
->iovec_count
== 0) {
573 scsi_task_add_data_in_buffer(acb
->task
,
577 #if defined(LIBISCSI_FEATURE_IOVECTOR)
578 scsi_task_set_iov_in(acb
->task
,
579 (struct scsi_iovec
*) acb
->ioh
->dxferp
,
580 acb
->ioh
->iovec_count
);
583 for (i
= 0; i
< acb
->ioh
->iovec_count
; i
++) {
584 struct iovec
*iov
= (struct iovec
*)acb
->ioh
->dxferp
;
586 scsi_task_add_data_in_buffer(acb
->task
,
594 iscsi_set_events(iscsilun
);
600 static void ioctl_cb(void *opaque
, int status
)
602 int *p_status
= opaque
;
606 static int iscsi_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
608 IscsiLun
*iscsilun
= bs
->opaque
;
612 case SG_GET_VERSION_NUM
:
616 ((struct sg_scsi_id
*)buf
)->scsi_type
= iscsilun
->type
;
619 status
= -EINPROGRESS
;
620 iscsi_aio_ioctl(bs
, req
, buf
, ioctl_cb
, &status
);
622 while (status
== -EINPROGRESS
) {
635 iscsi_getlength(BlockDriverState
*bs
)
637 IscsiLun
*iscsilun
= bs
->opaque
;
640 len
= iscsilun
->num_blocks
;
641 len
*= iscsilun
->block_size
;
646 #if defined(LIBISCSI_FEATURE_IOVECTOR)
648 static int64_t coroutine_fn
iscsi_co_get_block_status(BlockDriverState
*bs
,
650 int nb_sectors
, int *pnum
)
652 IscsiLun
*iscsilun
= bs
->opaque
;
653 struct scsi_get_lba_status
*lbas
= NULL
;
654 struct scsi_lba_status_descriptor
*lbasd
= NULL
;
655 struct IscsiTask iTask
;
658 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
660 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
665 /* default to all sectors allocated */
666 ret
= BDRV_BLOCK_DATA
;
667 ret
|= (sector_num
<< BDRV_SECTOR_BITS
) | BDRV_BLOCK_OFFSET_VALID
;
670 /* LUN does not support logical block provisioning */
671 if (iscsilun
->lbpme
== 0) {
676 if (iscsi_get_lba_status_task(iscsilun
->iscsi
, iscsilun
->lun
,
677 sector_qemu2lun(sector_num
, iscsilun
),
678 8 + 16, iscsi_co_generic_cb
,
684 while (!iTask
.complete
) {
685 iscsi_set_events(iscsilun
);
686 qemu_coroutine_yield();
689 if (iTask
.do_retry
) {
690 if (iTask
.task
!= NULL
) {
691 scsi_free_scsi_task(iTask
.task
);
698 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
699 /* in case the get_lba_status_callout fails (i.e.
700 * because the device is busy or the cmd is not
701 * supported) we pretend all blocks are allocated
702 * for backwards compatibility */
706 lbas
= scsi_datain_unmarshall(iTask
.task
);
712 lbasd
= &lbas
->descriptors
[0];
714 if (sector_qemu2lun(sector_num
, iscsilun
) != lbasd
->lba
) {
719 *pnum
= sector_lun2qemu(lbasd
->num_blocks
, iscsilun
);
720 if (*pnum
> nb_sectors
) {
724 if (lbasd
->provisioning
== SCSI_PROVISIONING_TYPE_DEALLOCATED
||
725 lbasd
->provisioning
== SCSI_PROVISIONING_TYPE_ANCHORED
) {
726 ret
&= ~BDRV_BLOCK_DATA
;
727 if (iscsilun
->lbprz
) {
728 ret
|= BDRV_BLOCK_ZERO
;
733 if (iTask
.task
!= NULL
) {
734 scsi_free_scsi_task(iTask
.task
);
739 #endif /* LIBISCSI_FEATURE_IOVECTOR */
742 coroutine_fn
iscsi_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
745 IscsiLun
*iscsilun
= bs
->opaque
;
746 struct IscsiTask iTask
;
747 struct unmap_list list
;
749 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
753 if (!iscsilun
->lbp
.lbpu
) {
754 /* UNMAP is not supported by the target */
758 list
.lba
= sector_qemu2lun(sector_num
, iscsilun
);
759 list
.num
= sector_qemu2lun(nb_sectors
, iscsilun
);
761 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
763 if (iscsi_unmap_task(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0, &list
, 1,
764 iscsi_co_generic_cb
, &iTask
) == NULL
) {
768 while (!iTask
.complete
) {
769 iscsi_set_events(iscsilun
);
770 qemu_coroutine_yield();
773 if (iTask
.task
!= NULL
) {
774 scsi_free_scsi_task(iTask
.task
);
778 if (iTask
.do_retry
) {
783 if (iTask
.status
== SCSI_STATUS_CHECK_CONDITION
) {
784 /* the target might fail with a check condition if it
785 is not happy with the alignment of the UNMAP request
786 we silently fail in this case */
790 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
797 #if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED)
800 coroutine_fn
iscsi_co_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
801 int nb_sectors
, BdrvRequestFlags flags
)
803 IscsiLun
*iscsilun
= bs
->opaque
;
804 struct IscsiTask iTask
;
808 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
812 if (!(flags
& BDRV_REQ_MAY_UNMAP
) && !iscsilun
->has_write_same
) {
813 /* WRITE SAME without UNMAP is not supported by the target */
817 if ((flags
& BDRV_REQ_MAY_UNMAP
) && !iscsilun
->lbp
.lbpws
) {
818 /* WRITE SAME with UNMAP is not supported by the target */
822 lba
= sector_qemu2lun(sector_num
, iscsilun
);
823 nb_blocks
= sector_qemu2lun(nb_sectors
, iscsilun
);
825 if (iscsilun
->zeroblock
== NULL
) {
826 iscsilun
->zeroblock
= g_malloc0(iscsilun
->block_size
);
829 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
831 if (iscsi_writesame16_task(iscsilun
->iscsi
, iscsilun
->lun
, lba
,
832 iscsilun
->zeroblock
, iscsilun
->block_size
,
833 nb_blocks
, 0, !!(flags
& BDRV_REQ_MAY_UNMAP
),
834 0, 0, iscsi_co_generic_cb
, &iTask
) == NULL
) {
838 while (!iTask
.complete
) {
839 iscsi_set_events(iscsilun
);
840 qemu_coroutine_yield();
843 if (iTask
.status
== SCSI_STATUS_CHECK_CONDITION
&&
844 iTask
.task
->sense
.key
== SCSI_SENSE_ILLEGAL_REQUEST
&&
845 (iTask
.task
->sense
.ascq
== SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE
||
846 iTask
.task
->sense
.ascq
== SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB
)) {
847 /* WRITE SAME is not supported by the target */
848 iscsilun
->has_write_same
= false;
849 scsi_free_scsi_task(iTask
.task
);
853 if (iTask
.task
!= NULL
) {
854 scsi_free_scsi_task(iTask
.task
);
858 if (iTask
.do_retry
) {
863 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
870 #endif /* SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED */
872 static void parse_chap(struct iscsi_context
*iscsi
, const char *target
,
877 const char *user
= NULL
;
878 const char *password
= NULL
;
880 list
= qemu_find_opts("iscsi");
885 opts
= qemu_opts_find(list
, target
);
887 opts
= QTAILQ_FIRST(&list
->head
);
893 user
= qemu_opt_get(opts
, "user");
898 password
= qemu_opt_get(opts
, "password");
900 error_setg(errp
, "CHAP username specified but no password was given");
904 if (iscsi_set_initiator_username_pwd(iscsi
, user
, password
)) {
905 error_setg(errp
, "Failed to set initiator username and password");
909 static void parse_header_digest(struct iscsi_context
*iscsi
, const char *target
,
914 const char *digest
= NULL
;
916 list
= qemu_find_opts("iscsi");
921 opts
= qemu_opts_find(list
, target
);
923 opts
= QTAILQ_FIRST(&list
->head
);
929 digest
= qemu_opt_get(opts
, "header-digest");
934 if (!strcmp(digest
, "CRC32C")) {
935 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_CRC32C
);
936 } else if (!strcmp(digest
, "NONE")) {
937 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE
);
938 } else if (!strcmp(digest
, "CRC32C-NONE")) {
939 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_CRC32C_NONE
);
940 } else if (!strcmp(digest
, "NONE-CRC32C")) {
941 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE_CRC32C
);
943 error_setg(errp
, "Invalid header-digest setting : %s", digest
);
947 static char *parse_initiator_name(const char *target
)
955 list
= qemu_find_opts("iscsi");
957 opts
= qemu_opts_find(list
, target
);
959 opts
= QTAILQ_FIRST(&list
->head
);
962 name
= qemu_opt_get(opts
, "initiator-name");
964 return g_strdup(name
);
969 uuid_info
= qmp_query_uuid(NULL
);
970 if (strcmp(uuid_info
->UUID
, UUID_NONE
) == 0) {
971 name
= qemu_get_vm_name();
973 name
= uuid_info
->UUID
;
975 iscsi_name
= g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
976 name
? ":" : "", name
? name
: "");
977 qapi_free_UuidInfo(uuid_info
);
981 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
982 static void iscsi_nop_timed_event(void *opaque
)
984 IscsiLun
*iscsilun
= opaque
;
986 if (iscsi_get_nops_in_flight(iscsilun
->iscsi
) > MAX_NOP_FAILURES
) {
987 error_report("iSCSI: NOP timeout. Reconnecting...");
988 iscsi_reconnect(iscsilun
->iscsi
);
991 if (iscsi_nop_out_async(iscsilun
->iscsi
, NULL
, NULL
, 0, NULL
) != 0) {
992 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
996 timer_mod(iscsilun
->nop_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + NOP_INTERVAL
);
997 iscsi_set_events(iscsilun
);
1001 static void iscsi_readcapacity_sync(IscsiLun
*iscsilun
, Error
**errp
)
1003 struct scsi_task
*task
= NULL
;
1004 struct scsi_readcapacity10
*rc10
= NULL
;
1005 struct scsi_readcapacity16
*rc16
= NULL
;
1006 int retries
= ISCSI_CMD_RETRIES
;
1010 scsi_free_scsi_task(task
);
1014 switch (iscsilun
->type
) {
1016 task
= iscsi_readcapacity16_sync(iscsilun
->iscsi
, iscsilun
->lun
);
1017 if (task
!= NULL
&& task
->status
== SCSI_STATUS_GOOD
) {
1018 rc16
= scsi_datain_unmarshall(task
);
1020 error_setg(errp
, "iSCSI: Failed to unmarshall readcapacity16 data.");
1022 iscsilun
->block_size
= rc16
->block_length
;
1023 iscsilun
->num_blocks
= rc16
->returned_lba
+ 1;
1024 iscsilun
->lbpme
= rc16
->lbpme
;
1025 iscsilun
->lbprz
= rc16
->lbprz
;
1030 task
= iscsi_readcapacity10_sync(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0);
1031 if (task
!= NULL
&& task
->status
== SCSI_STATUS_GOOD
) {
1032 rc10
= scsi_datain_unmarshall(task
);
1034 error_setg(errp
, "iSCSI: Failed to unmarshall readcapacity10 data.");
1036 iscsilun
->block_size
= rc10
->block_size
;
1037 if (rc10
->lba
== 0) {
1038 /* blank disk loaded */
1039 iscsilun
->num_blocks
= 0;
1041 iscsilun
->num_blocks
= rc10
->lba
+ 1;
1049 } while (task
!= NULL
&& task
->status
== SCSI_STATUS_CHECK_CONDITION
1050 && task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
1053 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1054 error_setg(errp
, "iSCSI: failed to send readcapacity10 command.");
1057 scsi_free_scsi_task(task
);
1061 /* TODO Convert to fine grained options */
1062 static QemuOptsList runtime_opts
= {
1064 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
1068 .type
= QEMU_OPT_STRING
,
1069 .help
= "URL to the iscsi image",
1071 { /* end of list */ }
1075 static struct scsi_task
*iscsi_do_inquiry(struct iscsi_context
*iscsi
, int lun
,
1076 int evpd
, int pc
, void **inq
, Error
**errp
)
1079 struct scsi_task
*task
= NULL
;
1080 task
= iscsi_inquiry_sync(iscsi
, lun
, evpd
, pc
, 64);
1081 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1084 full_size
= scsi_datain_getfullsize(task
);
1085 if (full_size
> task
->datain
.size
) {
1086 scsi_free_scsi_task(task
);
1088 /* we need more data for the full list */
1089 task
= iscsi_inquiry_sync(iscsi
, lun
, evpd
, pc
, full_size
);
1090 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1095 *inq
= scsi_datain_unmarshall(task
);
1097 error_setg(errp
, "iSCSI: failed to unmarshall inquiry datain blob");
1104 if (!error_is_set(errp
)) {
1105 error_setg(errp
, "iSCSI: Inquiry command failed : %s",
1106 iscsi_get_error(iscsi
));
1109 scsi_free_scsi_task(task
);
1115 * We support iscsi url's on the form
1116 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1118 * Note: flags are currently not used by iscsi_open. If this function
1119 * is changed such that flags are used, please examine iscsi_reopen_prepare()
1120 * to see if needs to be changed as well.
1122 static int iscsi_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1125 IscsiLun
*iscsilun
= bs
->opaque
;
1126 struct iscsi_context
*iscsi
= NULL
;
1127 struct iscsi_url
*iscsi_url
= NULL
;
1128 struct scsi_task
*task
= NULL
;
1129 struct scsi_inquiry_standard
*inq
= NULL
;
1130 struct scsi_inquiry_supported_pages
*inq_vpd
;
1131 char *initiator_name
= NULL
;
1133 Error
*local_err
= NULL
;
1134 const char *filename
;
1137 if ((BDRV_SECTOR_SIZE
% 512) != 0) {
1138 error_setg(errp
, "iSCSI: Invalid BDRV_SECTOR_SIZE. "
1139 "BDRV_SECTOR_SIZE(%lld) is not a multiple "
1140 "of 512", BDRV_SECTOR_SIZE
);
1144 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
1145 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1147 error_propagate(errp
, local_err
);
1152 filename
= qemu_opt_get(opts
, "filename");
1154 iscsi_url
= iscsi_parse_full_url(iscsi
, filename
);
1155 if (iscsi_url
== NULL
) {
1156 error_setg(errp
, "Failed to parse URL : %s", filename
);
1161 memset(iscsilun
, 0, sizeof(IscsiLun
));
1163 initiator_name
= parse_initiator_name(iscsi_url
->target
);
1165 iscsi
= iscsi_create_context(initiator_name
);
1166 if (iscsi
== NULL
) {
1167 error_setg(errp
, "iSCSI: Failed to create iSCSI context.");
1172 if (iscsi_set_targetname(iscsi
, iscsi_url
->target
)) {
1173 error_setg(errp
, "iSCSI: Failed to set target name.");
1178 if (iscsi_url
->user
!= NULL
) {
1179 ret
= iscsi_set_initiator_username_pwd(iscsi
, iscsi_url
->user
,
1182 error_setg(errp
, "Failed to set initiator username and password");
1188 /* check if we got CHAP username/password via the options */
1189 parse_chap(iscsi
, iscsi_url
->target
, &local_err
);
1190 if (local_err
!= NULL
) {
1191 error_propagate(errp
, local_err
);
1196 if (iscsi_set_session_type(iscsi
, ISCSI_SESSION_NORMAL
) != 0) {
1197 error_setg(errp
, "iSCSI: Failed to set session type to normal.");
1202 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE_CRC32C
);
1204 /* check if we got HEADER_DIGEST via the options */
1205 parse_header_digest(iscsi
, iscsi_url
->target
, &local_err
);
1206 if (local_err
!= NULL
) {
1207 error_propagate(errp
, local_err
);
1212 if (iscsi_full_connect_sync(iscsi
, iscsi_url
->portal
, iscsi_url
->lun
) != 0) {
1213 error_setg(errp
, "iSCSI: Failed to connect to LUN : %s",
1214 iscsi_get_error(iscsi
));
1219 iscsilun
->iscsi
= iscsi
;
1220 iscsilun
->lun
= iscsi_url
->lun
;
1221 iscsilun
->has_write_same
= true;
1223 task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0,
1224 (void **) &inq
, errp
);
1229 iscsilun
->type
= inq
->periperal_device_type
;
1230 scsi_free_scsi_task(task
);
1233 iscsi_readcapacity_sync(iscsilun
, &local_err
);
1234 if (local_err
!= NULL
) {
1235 error_propagate(errp
, local_err
);
1239 bs
->total_sectors
= sector_lun2qemu(iscsilun
->num_blocks
, iscsilun
);
1240 bs
->request_alignment
= iscsilun
->block_size
;
1242 /* We don't have any emulation for devices other than disks and CD-ROMs, so
1243 * this must be sg ioctl compatible. We force it to be sg, otherwise qemu
1244 * will try to read from the device to guess the image format.
1246 if (iscsilun
->type
!= TYPE_DISK
&& iscsilun
->type
!= TYPE_ROM
) {
1250 task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 1,
1251 SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES
,
1252 (void **) &inq_vpd
, errp
);
1257 for (i
= 0; i
< inq_vpd
->num_pages
; i
++) {
1258 struct scsi_task
*inq_task
;
1259 struct scsi_inquiry_logical_block_provisioning
*inq_lbp
;
1260 struct scsi_inquiry_block_limits
*inq_bl
;
1261 switch (inq_vpd
->pages
[i
]) {
1262 case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING
:
1263 inq_task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 1,
1264 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING
,
1265 (void **) &inq_lbp
, errp
);
1266 if (inq_task
== NULL
) {
1270 memcpy(&iscsilun
->lbp
, inq_lbp
,
1271 sizeof(struct scsi_inquiry_logical_block_provisioning
));
1272 scsi_free_scsi_task(inq_task
);
1274 case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS
:
1275 inq_task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 1,
1276 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS
,
1277 (void **) &inq_bl
, errp
);
1278 if (inq_task
== NULL
) {
1282 memcpy(&iscsilun
->bl
, inq_bl
,
1283 sizeof(struct scsi_inquiry_block_limits
));
1284 scsi_free_scsi_task(inq_task
);
1290 scsi_free_scsi_task(task
);
1293 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
1294 /* Set up a timer for sending out iSCSI NOPs */
1295 iscsilun
->nop_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, iscsi_nop_timed_event
, iscsilun
);
1296 timer_mod(iscsilun
->nop_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + NOP_INTERVAL
);
1300 qemu_opts_del(opts
);
1301 if (initiator_name
!= NULL
) {
1302 g_free(initiator_name
);
1304 if (iscsi_url
!= NULL
) {
1305 iscsi_destroy_url(iscsi_url
);
1308 scsi_free_scsi_task(task
);
1312 if (iscsi
!= NULL
) {
1313 iscsi_destroy_context(iscsi
);
1315 memset(iscsilun
, 0, sizeof(IscsiLun
));
1320 static void iscsi_close(BlockDriverState
*bs
)
1322 IscsiLun
*iscsilun
= bs
->opaque
;
1323 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
1325 if (iscsilun
->nop_timer
) {
1326 timer_del(iscsilun
->nop_timer
);
1327 timer_free(iscsilun
->nop_timer
);
1329 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi
), NULL
, NULL
, NULL
);
1330 iscsi_destroy_context(iscsi
);
1331 g_free(iscsilun
->zeroblock
);
1332 memset(iscsilun
, 0, sizeof(IscsiLun
));
1335 static int iscsi_refresh_limits(BlockDriverState
*bs
)
1337 IscsiLun
*iscsilun
= bs
->opaque
;
1339 /* We don't actually refresh here, but just return data queried in
1340 * iscsi_open(): iscsi targets don't change their limits. */
1341 if (iscsilun
->lbp
.lbpu
) {
1342 if (iscsilun
->bl
.max_unmap
< 0xffffffff) {
1343 bs
->bl
.max_discard
= sector_lun2qemu(iscsilun
->bl
.max_unmap
,
1346 bs
->bl
.discard_alignment
= sector_lun2qemu(iscsilun
->bl
.opt_unmap_gran
,
1350 if (iscsilun
->bl
.max_ws_len
< 0xffffffff) {
1351 bs
->bl
.max_write_zeroes
= sector_lun2qemu(iscsilun
->bl
.max_ws_len
,
1354 if (iscsilun
->lbp
.lbpws
) {
1355 bs
->bl
.write_zeroes_alignment
= sector_lun2qemu(iscsilun
->bl
.opt_unmap_gran
,
1358 bs
->bl
.opt_transfer_length
= sector_lun2qemu(iscsilun
->bl
.opt_xfer_len
,
1363 /* Since iscsi_open() ignores bdrv_flags, there is nothing to do here in
1364 * prepare. Note that this will not re-establish a connection with an iSCSI
1365 * target - it is effectively a NOP. */
1366 static int iscsi_reopen_prepare(BDRVReopenState
*state
,
1367 BlockReopenQueue
*queue
, Error
**errp
)
1373 static int iscsi_truncate(BlockDriverState
*bs
, int64_t offset
)
1375 IscsiLun
*iscsilun
= bs
->opaque
;
1376 Error
*local_err
= NULL
;
1378 if (iscsilun
->type
!= TYPE_DISK
) {
1382 iscsi_readcapacity_sync(iscsilun
, &local_err
);
1383 if (local_err
!= NULL
) {
1384 error_free(local_err
);
1388 if (offset
> iscsi_getlength(bs
)) {
1395 static int iscsi_create(const char *filename
, QEMUOptionParameter
*options
,
1399 int64_t total_size
= 0;
1400 BlockDriverState
*bs
;
1401 IscsiLun
*iscsilun
= NULL
;
1406 /* Read out options */
1407 while (options
&& options
->name
) {
1408 if (!strcmp(options
->name
, "size")) {
1409 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
1414 bs
->opaque
= g_malloc0(sizeof(struct IscsiLun
));
1415 iscsilun
= bs
->opaque
;
1417 bs_options
= qdict_new();
1418 qdict_put(bs_options
, "filename", qstring_from_str(filename
));
1419 ret
= iscsi_open(bs
, bs_options
, 0, NULL
);
1420 QDECREF(bs_options
);
1425 if (iscsilun
->nop_timer
) {
1426 timer_del(iscsilun
->nop_timer
);
1427 timer_free(iscsilun
->nop_timer
);
1429 if (iscsilun
->type
!= TYPE_DISK
) {
1433 if (bs
->total_sectors
< total_size
) {
1440 if (iscsilun
->iscsi
!= NULL
) {
1441 iscsi_destroy_context(iscsilun
->iscsi
);
1449 static int iscsi_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1451 IscsiLun
*iscsilun
= bs
->opaque
;
1452 bdi
->unallocated_blocks_are_zero
= !!iscsilun
->lbprz
;
1453 bdi
->can_write_zeroes_with_unmap
= iscsilun
->lbprz
&& iscsilun
->lbp
.lbpws
;
1454 /* Guess the internal cluster (page) size of the iscsi target by the means
1455 * of opt_unmap_gran. Transfer the unmap granularity only if it has a
1456 * reasonable size for bdi->cluster_size */
1457 if (iscsilun
->bl
.opt_unmap_gran
* iscsilun
->block_size
>= 64 * 1024 &&
1458 iscsilun
->bl
.opt_unmap_gran
* iscsilun
->block_size
<= 16 * 1024 * 1024) {
1459 bdi
->cluster_size
= iscsilun
->bl
.opt_unmap_gran
* iscsilun
->block_size
;
1464 static QEMUOptionParameter iscsi_create_options
[] = {
1466 .name
= BLOCK_OPT_SIZE
,
1468 .help
= "Virtual disk size"
1473 static BlockDriver bdrv_iscsi
= {
1474 .format_name
= "iscsi",
1475 .protocol_name
= "iscsi",
1477 .instance_size
= sizeof(IscsiLun
),
1478 .bdrv_needs_filename
= true,
1479 .bdrv_file_open
= iscsi_open
,
1480 .bdrv_close
= iscsi_close
,
1481 .bdrv_create
= iscsi_create
,
1482 .create_options
= iscsi_create_options
,
1483 .bdrv_reopen_prepare
= iscsi_reopen_prepare
,
1485 .bdrv_getlength
= iscsi_getlength
,
1486 .bdrv_get_info
= iscsi_get_info
,
1487 .bdrv_truncate
= iscsi_truncate
,
1488 .bdrv_refresh_limits
= iscsi_refresh_limits
,
1490 #if defined(LIBISCSI_FEATURE_IOVECTOR)
1491 .bdrv_co_get_block_status
= iscsi_co_get_block_status
,
1493 .bdrv_co_discard
= iscsi_co_discard
,
1494 #if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED)
1495 .bdrv_co_write_zeroes
= iscsi_co_write_zeroes
,
1497 .bdrv_co_readv
= iscsi_co_readv
,
1498 .bdrv_co_writev
= iscsi_co_writev
,
1499 .bdrv_co_flush_to_disk
= iscsi_co_flush
,
1502 .bdrv_ioctl
= iscsi_ioctl
,
1503 .bdrv_aio_ioctl
= iscsi_aio_ioctl
,
1507 static QemuOptsList qemu_iscsi_opts
= {
1509 .head
= QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts
.head
),
1513 .type
= QEMU_OPT_STRING
,
1514 .help
= "username for CHAP authentication to target",
1517 .type
= QEMU_OPT_STRING
,
1518 .help
= "password for CHAP authentication to target",
1520 .name
= "header-digest",
1521 .type
= QEMU_OPT_STRING
,
1522 .help
= "HeaderDigest setting. "
1523 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}",
1525 .name
= "initiator-name",
1526 .type
= QEMU_OPT_STRING
,
1527 .help
= "Initiator iqn name to use when connecting",
1529 { /* end of list */ }
1533 static void iscsi_block_init(void)
1535 bdrv_register(&bdrv_iscsi
);
1536 qemu_add_opts(&qemu_iscsi_opts
);
1539 block_init(iscsi_block_init
);