2 * QEMU Block driver for iSCSI images
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "config-host.h"
28 #include <arpa/inet.h>
29 #include "qemu-common.h"
30 #include "qemu/config-file.h"
31 #include "qemu/error-report.h"
32 #include "block/block_int.h"
34 #include "block/scsi.h"
36 #include "sysemu/sysemu.h"
37 #include "qmp-commands.h"
39 #include <iscsi/iscsi.h>
40 #include <iscsi/scsi-lowlevel.h>
44 #include <block/scsi.h>
47 typedef struct IscsiLun
{
48 struct iscsi_context
*iscsi
;
50 enum scsi_inquiry_peripheral_device_type type
;
57 struct scsi_inquiry_logical_block_provisioning lbp
;
58 struct scsi_inquiry_block_limits bl
;
61 typedef struct IscsiTask
{
66 struct scsi_task
*task
;
70 typedef struct IscsiAIOCB
{
71 BlockDriverAIOCB common
;
75 struct scsi_task
*task
;
87 #define NOP_INTERVAL 5000
88 #define MAX_NOP_FAILURES 3
89 #define ISCSI_CMD_RETRIES 5
90 #define ISCSI_MAX_UNMAP 131072
97 qemu_bh_delete(acb
->bh
);
102 if (acb
->canceled
== 0) {
103 acb
->common
.cb(acb
->common
.opaque
, acb
->status
);
106 if (acb
->task
!= NULL
) {
107 scsi_free_scsi_task(acb
->task
);
111 qemu_aio_release(acb
);
115 iscsi_schedule_bh(IscsiAIOCB
*acb
)
120 acb
->bh
= qemu_bh_new(iscsi_bh_cb
, acb
);
121 qemu_bh_schedule(acb
->bh
);
125 iscsi_co_generic_cb(struct iscsi_context
*iscsi
, int status
,
126 void *command_data
, void *opaque
)
128 struct IscsiTask
*iTask
= opaque
;
129 struct scsi_task
*task
= command_data
;
132 iTask
->status
= status
;
136 if (iTask
->retries
-- > 0 && status
== SCSI_STATUS_CHECK_CONDITION
137 && task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
) {
142 if (status
!= SCSI_STATUS_GOOD
) {
143 error_report("iSCSI: Failure. %s", iscsi_get_error(iscsi
));
148 qemu_coroutine_enter(iTask
->co
, NULL
);
152 static void iscsi_co_init_iscsitask(IscsiLun
*iscsilun
, struct IscsiTask
*iTask
)
154 *iTask
= (struct IscsiTask
) {
155 .co
= qemu_coroutine_self(),
156 .retries
= ISCSI_CMD_RETRIES
,
161 iscsi_abort_task_cb(struct iscsi_context
*iscsi
, int status
, void *command_data
,
164 IscsiAIOCB
*acb
= private_data
;
166 acb
->status
= -ECANCELED
;
167 iscsi_schedule_bh(acb
);
171 iscsi_aio_cancel(BlockDriverAIOCB
*blockacb
)
173 IscsiAIOCB
*acb
= (IscsiAIOCB
*)blockacb
;
174 IscsiLun
*iscsilun
= acb
->iscsilun
;
176 if (acb
->status
!= -EINPROGRESS
) {
182 /* send a task mgmt call to the target to cancel the task on the target */
183 iscsi_task_mgmt_abort_task_async(iscsilun
->iscsi
, acb
->task
,
184 iscsi_abort_task_cb
, acb
);
186 while (acb
->status
== -EINPROGRESS
) {
191 static const AIOCBInfo iscsi_aiocb_info
= {
192 .aiocb_size
= sizeof(IscsiAIOCB
),
193 .cancel
= iscsi_aio_cancel
,
197 static void iscsi_process_read(void *arg
);
198 static void iscsi_process_write(void *arg
);
201 iscsi_set_events(IscsiLun
*iscsilun
)
203 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
206 /* We always register a read handler. */
208 ev
|= iscsi_which_events(iscsi
);
209 if (ev
!= iscsilun
->events
) {
210 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi
),
212 (ev
& POLLOUT
) ? iscsi_process_write
: NULL
,
217 iscsilun
->events
= ev
;
221 iscsi_process_read(void *arg
)
223 IscsiLun
*iscsilun
= arg
;
224 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
226 iscsi_service(iscsi
, POLLIN
);
227 iscsi_set_events(iscsilun
);
231 iscsi_process_write(void *arg
)
233 IscsiLun
*iscsilun
= arg
;
234 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
236 iscsi_service(iscsi
, POLLOUT
);
237 iscsi_set_events(iscsilun
);
241 iscsi_aio_writev_acb(IscsiAIOCB
*acb
);
244 iscsi_aio_write16_cb(struct iscsi_context
*iscsi
, int status
,
245 void *command_data
, void *opaque
)
247 IscsiAIOCB
*acb
= opaque
;
249 trace_iscsi_aio_write16_cb(iscsi
, status
, acb
, acb
->canceled
);
254 if (acb
->canceled
!= 0) {
260 if (status
== SCSI_STATUS_CHECK_CONDITION
261 && acb
->task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
262 && acb
->retries
-- > 0) {
263 scsi_free_scsi_task(acb
->task
);
265 if (iscsi_aio_writev_acb(acb
) == 0) {
266 iscsi_set_events(acb
->iscsilun
);
270 error_report("Failed to write16 data to iSCSI lun. %s",
271 iscsi_get_error(iscsi
));
275 iscsi_schedule_bh(acb
);
278 static int64_t sector_lun2qemu(int64_t sector
, IscsiLun
*iscsilun
)
280 return sector
* iscsilun
->block_size
/ BDRV_SECTOR_SIZE
;
283 static int64_t sector_qemu2lun(int64_t sector
, IscsiLun
*iscsilun
)
285 return sector
* BDRV_SECTOR_SIZE
/ iscsilun
->block_size
;
288 static bool is_request_lun_aligned(int64_t sector_num
, int nb_sectors
,
291 if ((sector_num
* BDRV_SECTOR_SIZE
) % iscsilun
->block_size
||
292 (nb_sectors
* BDRV_SECTOR_SIZE
) % iscsilun
->block_size
) {
293 error_report("iSCSI misaligned request: "
294 "iscsilun->block_size %u, sector_num %" PRIi64
296 iscsilun
->block_size
, sector_num
, nb_sectors
);
303 iscsi_aio_writev_acb(IscsiAIOCB
*acb
)
305 struct iscsi_context
*iscsi
= acb
->iscsilun
->iscsi
;
307 uint32_t num_sectors
;
309 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
310 struct iscsi_data data
;
316 acb
->status
= -EINPROGRESS
;
319 /* this will allow us to get rid of 'buf' completely */
320 size
= acb
->nb_sectors
* BDRV_SECTOR_SIZE
;
322 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
323 data
.size
= MIN(size
, acb
->qiov
->size
);
325 /* if the iovec only contains one buffer we can pass it directly */
326 if (acb
->qiov
->niov
== 1) {
327 data
.data
= acb
->qiov
->iov
[0].iov_base
;
329 acb
->buf
= g_malloc(data
.size
);
330 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->buf
, data
.size
);
331 data
.data
= acb
->buf
;
335 acb
->task
= malloc(sizeof(struct scsi_task
));
336 if (acb
->task
== NULL
) {
337 error_report("iSCSI: Failed to allocate task for scsi WRITE16 "
338 "command. %s", iscsi_get_error(iscsi
));
341 memset(acb
->task
, 0, sizeof(struct scsi_task
));
343 acb
->task
->xfer_dir
= SCSI_XFER_WRITE
;
344 acb
->task
->cdb_size
= 16;
345 acb
->task
->cdb
[0] = 0x8a;
346 lba
= sector_qemu2lun(acb
->sector_num
, acb
->iscsilun
);
347 *(uint32_t *)&acb
->task
->cdb
[2] = htonl(lba
>> 32);
348 *(uint32_t *)&acb
->task
->cdb
[6] = htonl(lba
& 0xffffffff);
349 num_sectors
= sector_qemu2lun(acb
->nb_sectors
, acb
->iscsilun
);
350 *(uint32_t *)&acb
->task
->cdb
[10] = htonl(num_sectors
);
351 acb
->task
->expxferlen
= size
;
353 #if defined(LIBISCSI_FEATURE_IOVECTOR)
354 ret
= iscsi_scsi_command_async(iscsi
, acb
->iscsilun
->lun
, acb
->task
,
355 iscsi_aio_write16_cb
,
359 ret
= iscsi_scsi_command_async(iscsi
, acb
->iscsilun
->lun
, acb
->task
,
360 iscsi_aio_write16_cb
,
365 scsi_free_scsi_task(acb
->task
);
370 #if defined(LIBISCSI_FEATURE_IOVECTOR)
371 scsi_task_set_iov_out(acb
->task
, (struct scsi_iovec
*) acb
->qiov
->iov
, acb
->qiov
->niov
);
377 static BlockDriverAIOCB
*
378 iscsi_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
379 QEMUIOVector
*qiov
, int nb_sectors
,
380 BlockDriverCompletionFunc
*cb
,
383 IscsiLun
*iscsilun
= bs
->opaque
;
386 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
390 acb
= qemu_aio_get(&iscsi_aiocb_info
, bs
, cb
, opaque
);
391 trace_iscsi_aio_writev(iscsilun
->iscsi
, sector_num
, nb_sectors
, opaque
, acb
);
393 acb
->iscsilun
= iscsilun
;
395 acb
->nb_sectors
= nb_sectors
;
396 acb
->sector_num
= sector_num
;
397 acb
->retries
= ISCSI_CMD_RETRIES
;
399 if (iscsi_aio_writev_acb(acb
) != 0) {
400 qemu_aio_release(acb
);
404 iscsi_set_events(iscsilun
);
409 iscsi_aio_readv_acb(IscsiAIOCB
*acb
);
412 iscsi_aio_read16_cb(struct iscsi_context
*iscsi
, int status
,
413 void *command_data
, void *opaque
)
415 IscsiAIOCB
*acb
= opaque
;
417 trace_iscsi_aio_read16_cb(iscsi
, status
, acb
, acb
->canceled
);
419 if (acb
->canceled
!= 0) {
425 if (status
== SCSI_STATUS_CHECK_CONDITION
426 && acb
->task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
427 && acb
->retries
-- > 0) {
428 scsi_free_scsi_task(acb
->task
);
430 if (iscsi_aio_readv_acb(acb
) == 0) {
431 iscsi_set_events(acb
->iscsilun
);
435 error_report("Failed to read16 data from iSCSI lun. %s",
436 iscsi_get_error(iscsi
));
440 iscsi_schedule_bh(acb
);
444 iscsi_aio_readv_acb(IscsiAIOCB
*acb
)
446 struct iscsi_context
*iscsi
= acb
->iscsilun
->iscsi
;
449 uint32_t num_sectors
;
451 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
457 acb
->status
= -EINPROGRESS
;
460 size
= acb
->nb_sectors
* BDRV_SECTOR_SIZE
;
462 acb
->task
= malloc(sizeof(struct scsi_task
));
463 if (acb
->task
== NULL
) {
464 error_report("iSCSI: Failed to allocate task for scsi READ16 "
465 "command. %s", iscsi_get_error(iscsi
));
468 memset(acb
->task
, 0, sizeof(struct scsi_task
));
470 acb
->task
->xfer_dir
= SCSI_XFER_READ
;
471 acb
->task
->expxferlen
= size
;
472 lba
= sector_qemu2lun(acb
->sector_num
, acb
->iscsilun
);
473 num_sectors
= sector_qemu2lun(acb
->nb_sectors
, acb
->iscsilun
);
475 switch (acb
->iscsilun
->type
) {
477 acb
->task
->cdb_size
= 16;
478 acb
->task
->cdb
[0] = 0x88;
479 *(uint32_t *)&acb
->task
->cdb
[2] = htonl(lba
>> 32);
480 *(uint32_t *)&acb
->task
->cdb
[6] = htonl(lba
& 0xffffffff);
481 *(uint32_t *)&acb
->task
->cdb
[10] = htonl(num_sectors
);
484 acb
->task
->cdb_size
= 10;
485 acb
->task
->cdb
[0] = 0x28;
486 *(uint32_t *)&acb
->task
->cdb
[2] = htonl(lba
);
487 *(uint16_t *)&acb
->task
->cdb
[7] = htons(num_sectors
);
491 ret
= iscsi_scsi_command_async(iscsi
, acb
->iscsilun
->lun
, acb
->task
,
496 scsi_free_scsi_task(acb
->task
);
500 #if defined(LIBISCSI_FEATURE_IOVECTOR)
501 scsi_task_set_iov_in(acb
->task
, (struct scsi_iovec
*) acb
->qiov
->iov
, acb
->qiov
->niov
);
503 for (i
= 0; i
< acb
->qiov
->niov
; i
++) {
504 scsi_task_add_data_in_buffer(acb
->task
,
505 acb
->qiov
->iov
[i
].iov_len
,
506 acb
->qiov
->iov
[i
].iov_base
);
512 static BlockDriverAIOCB
*
513 iscsi_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
514 QEMUIOVector
*qiov
, int nb_sectors
,
515 BlockDriverCompletionFunc
*cb
,
518 IscsiLun
*iscsilun
= bs
->opaque
;
521 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
525 acb
= qemu_aio_get(&iscsi_aiocb_info
, bs
, cb
, opaque
);
526 trace_iscsi_aio_readv(iscsilun
->iscsi
, sector_num
, nb_sectors
, opaque
, acb
);
528 acb
->nb_sectors
= nb_sectors
;
529 acb
->sector_num
= sector_num
;
530 acb
->iscsilun
= iscsilun
;
532 acb
->retries
= ISCSI_CMD_RETRIES
;
534 if (iscsi_aio_readv_acb(acb
) != 0) {
535 qemu_aio_release(acb
);
539 iscsi_set_events(iscsilun
);
544 iscsi_aio_flush_acb(IscsiAIOCB
*acb
);
547 iscsi_synccache10_cb(struct iscsi_context
*iscsi
, int status
,
548 void *command_data
, void *opaque
)
550 IscsiAIOCB
*acb
= opaque
;
552 if (acb
->canceled
!= 0) {
558 if (status
== SCSI_STATUS_CHECK_CONDITION
559 && acb
->task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
560 && acb
->retries
-- > 0) {
561 scsi_free_scsi_task(acb
->task
);
563 if (iscsi_aio_flush_acb(acb
) == 0) {
564 iscsi_set_events(acb
->iscsilun
);
568 error_report("Failed to sync10 data on iSCSI lun. %s",
569 iscsi_get_error(iscsi
));
573 iscsi_schedule_bh(acb
);
577 iscsi_aio_flush_acb(IscsiAIOCB
*acb
)
579 struct iscsi_context
*iscsi
= acb
->iscsilun
->iscsi
;
583 acb
->status
= -EINPROGRESS
;
586 acb
->task
= iscsi_synchronizecache10_task(iscsi
, acb
->iscsilun
->lun
,
588 iscsi_synccache10_cb
,
590 if (acb
->task
== NULL
) {
591 error_report("iSCSI: Failed to send synchronizecache10 command. %s",
592 iscsi_get_error(iscsi
));
599 static BlockDriverAIOCB
*
600 iscsi_aio_flush(BlockDriverState
*bs
,
601 BlockDriverCompletionFunc
*cb
, void *opaque
)
603 IscsiLun
*iscsilun
= bs
->opaque
;
607 acb
= qemu_aio_get(&iscsi_aiocb_info
, bs
, cb
, opaque
);
609 acb
->iscsilun
= iscsilun
;
610 acb
->retries
= ISCSI_CMD_RETRIES
;
612 if (iscsi_aio_flush_acb(acb
) != 0) {
613 qemu_aio_release(acb
);
617 iscsi_set_events(iscsilun
);
624 iscsi_aio_ioctl_cb(struct iscsi_context
*iscsi
, int status
,
625 void *command_data
, void *opaque
)
627 IscsiAIOCB
*acb
= opaque
;
632 if (acb
->canceled
!= 0) {
638 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
639 iscsi_get_error(iscsi
));
643 acb
->ioh
->driver_status
= 0;
644 acb
->ioh
->host_status
= 0;
647 #define SG_ERR_DRIVER_SENSE 0x08
649 if (status
== SCSI_STATUS_CHECK_CONDITION
&& acb
->task
->datain
.size
>= 2) {
652 acb
->ioh
->driver_status
|= SG_ERR_DRIVER_SENSE
;
654 acb
->ioh
->sb_len_wr
= acb
->task
->datain
.size
- 2;
655 ss
= (acb
->ioh
->mx_sb_len
>= acb
->ioh
->sb_len_wr
) ?
656 acb
->ioh
->mx_sb_len
: acb
->ioh
->sb_len_wr
;
657 memcpy(acb
->ioh
->sbp
, &acb
->task
->datain
.data
[2], ss
);
660 iscsi_schedule_bh(acb
);
663 static BlockDriverAIOCB
*iscsi_aio_ioctl(BlockDriverState
*bs
,
664 unsigned long int req
, void *buf
,
665 BlockDriverCompletionFunc
*cb
, void *opaque
)
667 IscsiLun
*iscsilun
= bs
->opaque
;
668 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
669 struct iscsi_data data
;
672 assert(req
== SG_IO
);
674 acb
= qemu_aio_get(&iscsi_aiocb_info
, bs
, cb
, opaque
);
676 acb
->iscsilun
= iscsilun
;
679 acb
->status
= -EINPROGRESS
;
683 acb
->task
= malloc(sizeof(struct scsi_task
));
684 if (acb
->task
== NULL
) {
685 error_report("iSCSI: Failed to allocate task for scsi command. %s",
686 iscsi_get_error(iscsi
));
687 qemu_aio_release(acb
);
690 memset(acb
->task
, 0, sizeof(struct scsi_task
));
692 switch (acb
->ioh
->dxfer_direction
) {
693 case SG_DXFER_TO_DEV
:
694 acb
->task
->xfer_dir
= SCSI_XFER_WRITE
;
696 case SG_DXFER_FROM_DEV
:
697 acb
->task
->xfer_dir
= SCSI_XFER_READ
;
700 acb
->task
->xfer_dir
= SCSI_XFER_NONE
;
704 acb
->task
->cdb_size
= acb
->ioh
->cmd_len
;
705 memcpy(&acb
->task
->cdb
[0], acb
->ioh
->cmdp
, acb
->ioh
->cmd_len
);
706 acb
->task
->expxferlen
= acb
->ioh
->dxfer_len
;
709 if (acb
->task
->xfer_dir
== SCSI_XFER_WRITE
) {
710 if (acb
->ioh
->iovec_count
== 0) {
711 data
.data
= acb
->ioh
->dxferp
;
712 data
.size
= acb
->ioh
->dxfer_len
;
714 #if defined(LIBISCSI_FEATURE_IOVECTOR)
715 scsi_task_set_iov_out(acb
->task
,
716 (struct scsi_iovec
*) acb
->ioh
->dxferp
,
717 acb
->ioh
->iovec_count
);
719 struct iovec
*iov
= (struct iovec
*)acb
->ioh
->dxferp
;
721 acb
->buf
= g_malloc(acb
->ioh
->dxfer_len
);
722 data
.data
= acb
->buf
;
723 data
.size
= iov_to_buf(iov
, acb
->ioh
->iovec_count
, 0,
724 acb
->buf
, acb
->ioh
->dxfer_len
);
729 if (iscsi_scsi_command_async(iscsi
, iscsilun
->lun
, acb
->task
,
731 (data
.size
> 0) ? &data
: NULL
,
733 scsi_free_scsi_task(acb
->task
);
734 qemu_aio_release(acb
);
738 /* tell libiscsi to read straight into the buffer we got from ioctl */
739 if (acb
->task
->xfer_dir
== SCSI_XFER_READ
) {
740 if (acb
->ioh
->iovec_count
== 0) {
741 scsi_task_add_data_in_buffer(acb
->task
,
745 #if defined(LIBISCSI_FEATURE_IOVECTOR)
746 scsi_task_set_iov_in(acb
->task
,
747 (struct scsi_iovec
*) acb
->ioh
->dxferp
,
748 acb
->ioh
->iovec_count
);
751 for (i
= 0; i
< acb
->ioh
->iovec_count
; i
++) {
752 struct iovec
*iov
= (struct iovec
*)acb
->ioh
->dxferp
;
754 scsi_task_add_data_in_buffer(acb
->task
,
762 iscsi_set_events(iscsilun
);
768 static void ioctl_cb(void *opaque
, int status
)
770 int *p_status
= opaque
;
774 static int iscsi_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
776 IscsiLun
*iscsilun
= bs
->opaque
;
780 case SG_GET_VERSION_NUM
:
784 ((struct sg_scsi_id
*)buf
)->scsi_type
= iscsilun
->type
;
787 status
= -EINPROGRESS
;
788 iscsi_aio_ioctl(bs
, req
, buf
, ioctl_cb
, &status
);
790 while (status
== -EINPROGRESS
) {
803 iscsi_getlength(BlockDriverState
*bs
)
805 IscsiLun
*iscsilun
= bs
->opaque
;
808 len
= iscsilun
->num_blocks
;
809 len
*= iscsilun
->block_size
;
814 #if defined(LIBISCSI_FEATURE_IOVECTOR)
816 static int64_t coroutine_fn
iscsi_co_get_block_status(BlockDriverState
*bs
,
818 int nb_sectors
, int *pnum
)
820 IscsiLun
*iscsilun
= bs
->opaque
;
821 struct scsi_get_lba_status
*lbas
= NULL
;
822 struct scsi_lba_status_descriptor
*lbasd
= NULL
;
823 struct IscsiTask iTask
;
826 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
828 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
833 /* default to all sectors allocated */
834 ret
= BDRV_BLOCK_DATA
;
835 ret
|= (sector_num
<< BDRV_SECTOR_BITS
) | BDRV_BLOCK_OFFSET_VALID
;
838 /* LUN does not support logical block provisioning */
839 if (iscsilun
->lbpme
== 0) {
844 if (iscsi_get_lba_status_task(iscsilun
->iscsi
, iscsilun
->lun
,
845 sector_qemu2lun(sector_num
, iscsilun
),
846 8 + 16, iscsi_co_generic_cb
,
852 while (!iTask
.complete
) {
853 iscsi_set_events(iscsilun
);
854 qemu_coroutine_yield();
857 if (iTask
.do_retry
) {
858 if (iTask
.task
!= NULL
) {
859 scsi_free_scsi_task(iTask
.task
);
865 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
866 /* in case the get_lba_status_callout fails (i.e.
867 * because the device is busy or the cmd is not
868 * supported) we pretend all blocks are allocated
869 * for backwards compatiblity */
873 lbas
= scsi_datain_unmarshall(iTask
.task
);
879 lbasd
= &lbas
->descriptors
[0];
881 if (sector_qemu2lun(sector_num
, iscsilun
) != lbasd
->lba
) {
886 *pnum
= sector_lun2qemu(lbasd
->num_blocks
, iscsilun
);
887 if (*pnum
> nb_sectors
) {
891 if (lbasd
->provisioning
== SCSI_PROVISIONING_TYPE_DEALLOCATED
||
892 lbasd
->provisioning
== SCSI_PROVISIONING_TYPE_ANCHORED
) {
893 ret
&= ~BDRV_BLOCK_DATA
;
894 if (iscsilun
->lbprz
) {
895 ret
|= BDRV_BLOCK_ZERO
;
900 if (iTask
.task
!= NULL
) {
901 scsi_free_scsi_task(iTask
.task
);
906 #endif /* LIBISCSI_FEATURE_IOVECTOR */
909 coroutine_fn
iscsi_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
912 IscsiLun
*iscsilun
= bs
->opaque
;
913 struct IscsiTask iTask
;
914 struct unmap_list list
;
918 if (!is_request_lun_aligned(sector_num
, nb_sectors
, iscsilun
)) {
922 if (!iscsilun
->lbp
.lbpu
) {
923 /* UNMAP is not supported by the target */
927 list
.lba
= sector_qemu2lun(sector_num
, iscsilun
);
928 nb_blocks
= sector_qemu2lun(nb_sectors
, iscsilun
);
930 max_unmap
= iscsilun
->bl
.max_unmap
;
931 if (max_unmap
== 0xffffffff) {
932 max_unmap
= ISCSI_MAX_UNMAP
;
935 while (nb_blocks
> 0) {
936 iscsi_co_init_iscsitask(iscsilun
, &iTask
);
937 list
.num
= nb_blocks
;
938 if (list
.num
> max_unmap
) {
939 list
.num
= max_unmap
;
942 if (iscsi_unmap_task(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0, &list
, 1,
943 iscsi_co_generic_cb
, &iTask
) == NULL
) {
947 while (!iTask
.complete
) {
948 iscsi_set_events(iscsilun
);
949 qemu_coroutine_yield();
952 if (iTask
.task
!= NULL
) {
953 scsi_free_scsi_task(iTask
.task
);
957 if (iTask
.do_retry
) {
961 if (iTask
.status
== SCSI_STATUS_CHECK_CONDITION
) {
962 /* the target might fail with a check condition if it
963 is not happy with the alignment of the UNMAP request
964 we silently fail in this case */
968 if (iTask
.status
!= SCSI_STATUS_GOOD
) {
972 list
.lba
+= list
.num
;
973 nb_blocks
-= list
.num
;
979 static int parse_chap(struct iscsi_context
*iscsi
, const char *target
)
983 const char *user
= NULL
;
984 const char *password
= NULL
;
986 list
= qemu_find_opts("iscsi");
991 opts
= qemu_opts_find(list
, target
);
993 opts
= QTAILQ_FIRST(&list
->head
);
999 user
= qemu_opt_get(opts
, "user");
1004 password
= qemu_opt_get(opts
, "password");
1006 error_report("CHAP username specified but no password was given");
1010 if (iscsi_set_initiator_username_pwd(iscsi
, user
, password
)) {
1011 error_report("Failed to set initiator username and password");
1018 static void parse_header_digest(struct iscsi_context
*iscsi
, const char *target
)
1022 const char *digest
= NULL
;
1024 list
= qemu_find_opts("iscsi");
1029 opts
= qemu_opts_find(list
, target
);
1031 opts
= QTAILQ_FIRST(&list
->head
);
1037 digest
= qemu_opt_get(opts
, "header-digest");
1042 if (!strcmp(digest
, "CRC32C")) {
1043 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_CRC32C
);
1044 } else if (!strcmp(digest
, "NONE")) {
1045 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE
);
1046 } else if (!strcmp(digest
, "CRC32C-NONE")) {
1047 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_CRC32C_NONE
);
1048 } else if (!strcmp(digest
, "NONE-CRC32C")) {
1049 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE_CRC32C
);
1051 error_report("Invalid header-digest setting : %s", digest
);
1055 static char *parse_initiator_name(const char *target
)
1061 UuidInfo
*uuid_info
;
1063 list
= qemu_find_opts("iscsi");
1065 opts
= qemu_opts_find(list
, target
);
1067 opts
= QTAILQ_FIRST(&list
->head
);
1070 name
= qemu_opt_get(opts
, "initiator-name");
1072 return g_strdup(name
);
1077 uuid_info
= qmp_query_uuid(NULL
);
1078 if (strcmp(uuid_info
->UUID
, UUID_NONE
) == 0) {
1079 name
= qemu_get_vm_name();
1081 name
= uuid_info
->UUID
;
1083 iscsi_name
= g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
1084 name
? ":" : "", name
? name
: "");
1085 qapi_free_UuidInfo(uuid_info
);
1089 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
1090 static void iscsi_nop_timed_event(void *opaque
)
1092 IscsiLun
*iscsilun
= opaque
;
1094 if (iscsi_get_nops_in_flight(iscsilun
->iscsi
) > MAX_NOP_FAILURES
) {
1095 error_report("iSCSI: NOP timeout. Reconnecting...");
1096 iscsi_reconnect(iscsilun
->iscsi
);
1099 if (iscsi_nop_out_async(iscsilun
->iscsi
, NULL
, NULL
, 0, NULL
) != 0) {
1100 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
1104 timer_mod(iscsilun
->nop_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + NOP_INTERVAL
);
1105 iscsi_set_events(iscsilun
);
1109 static int iscsi_readcapacity_sync(IscsiLun
*iscsilun
)
1111 struct scsi_task
*task
= NULL
;
1112 struct scsi_readcapacity10
*rc10
= NULL
;
1113 struct scsi_readcapacity16
*rc16
= NULL
;
1115 int retries
= ISCSI_CMD_RETRIES
;
1119 scsi_free_scsi_task(task
);
1123 switch (iscsilun
->type
) {
1125 task
= iscsi_readcapacity16_sync(iscsilun
->iscsi
, iscsilun
->lun
);
1126 if (task
!= NULL
&& task
->status
== SCSI_STATUS_GOOD
) {
1127 rc16
= scsi_datain_unmarshall(task
);
1129 error_report("iSCSI: Failed to unmarshall readcapacity16 data.");
1132 iscsilun
->block_size
= rc16
->block_length
;
1133 iscsilun
->num_blocks
= rc16
->returned_lba
+ 1;
1134 iscsilun
->lbpme
= rc16
->lbpme
;
1135 iscsilun
->lbprz
= rc16
->lbprz
;
1140 task
= iscsi_readcapacity10_sync(iscsilun
->iscsi
, iscsilun
->lun
, 0, 0);
1141 if (task
!= NULL
&& task
->status
== SCSI_STATUS_GOOD
) {
1142 rc10
= scsi_datain_unmarshall(task
);
1144 error_report("iSCSI: Failed to unmarshall readcapacity10 data.");
1147 iscsilun
->block_size
= rc10
->block_size
;
1148 if (rc10
->lba
== 0) {
1149 /* blank disk loaded */
1150 iscsilun
->num_blocks
= 0;
1152 iscsilun
->num_blocks
= rc10
->lba
+ 1;
1160 } while (task
!= NULL
&& task
->status
== SCSI_STATUS_CHECK_CONDITION
1161 && task
->sense
.key
== SCSI_SENSE_UNIT_ATTENTION
1164 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1165 error_report("iSCSI: failed to send readcapacity10 command.");
1169 scsi_free_scsi_task(task
);
1174 /* TODO Convert to fine grained options */
1175 static QemuOptsList runtime_opts
= {
1177 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
1181 .type
= QEMU_OPT_STRING
,
1182 .help
= "URL to the iscsi image",
1184 { /* end of list */ }
1188 static struct scsi_task
*iscsi_do_inquiry(struct iscsi_context
*iscsi
,
1189 int lun
, int evpd
, int pc
) {
1191 struct scsi_task
*task
= NULL
;
1192 task
= iscsi_inquiry_sync(iscsi
, lun
, evpd
, pc
, 64);
1193 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1196 full_size
= scsi_datain_getfullsize(task
);
1197 if (full_size
> task
->datain
.size
) {
1198 scsi_free_scsi_task(task
);
1200 /* we need more data for the full list */
1201 task
= iscsi_inquiry_sync(iscsi
, lun
, evpd
, pc
, full_size
);
1202 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1210 error_report("iSCSI: Inquiry command failed : %s",
1211 iscsi_get_error(iscsi
));
1213 scsi_free_scsi_task(task
);
1220 * We support iscsi url's on the form
1221 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1223 static int iscsi_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1226 IscsiLun
*iscsilun
= bs
->opaque
;
1227 struct iscsi_context
*iscsi
= NULL
;
1228 struct iscsi_url
*iscsi_url
= NULL
;
1229 struct scsi_task
*task
= NULL
;
1230 struct scsi_inquiry_standard
*inq
= NULL
;
1231 char *initiator_name
= NULL
;
1233 Error
*local_err
= NULL
;
1234 const char *filename
;
1237 if ((BDRV_SECTOR_SIZE
% 512) != 0) {
1238 error_report("iSCSI: Invalid BDRV_SECTOR_SIZE. "
1239 "BDRV_SECTOR_SIZE(%lld) is not a multiple "
1240 "of 512", BDRV_SECTOR_SIZE
);
1244 opts
= qemu_opts_create_nofail(&runtime_opts
);
1245 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1246 if (error_is_set(&local_err
)) {
1247 qerror_report_err(local_err
);
1248 error_free(local_err
);
1253 filename
= qemu_opt_get(opts
, "filename");
1256 iscsi_url
= iscsi_parse_full_url(iscsi
, filename
);
1257 if (iscsi_url
== NULL
) {
1258 error_report("Failed to parse URL : %s", filename
);
1263 memset(iscsilun
, 0, sizeof(IscsiLun
));
1265 initiator_name
= parse_initiator_name(iscsi_url
->target
);
1267 iscsi
= iscsi_create_context(initiator_name
);
1268 if (iscsi
== NULL
) {
1269 error_report("iSCSI: Failed to create iSCSI context.");
1274 if (iscsi_set_targetname(iscsi
, iscsi_url
->target
)) {
1275 error_report("iSCSI: Failed to set target name.");
1280 if (iscsi_url
->user
!= NULL
) {
1281 ret
= iscsi_set_initiator_username_pwd(iscsi
, iscsi_url
->user
,
1284 error_report("Failed to set initiator username and password");
1290 /* check if we got CHAP username/password via the options */
1291 if (parse_chap(iscsi
, iscsi_url
->target
) != 0) {
1292 error_report("iSCSI: Failed to set CHAP user/password");
1297 if (iscsi_set_session_type(iscsi
, ISCSI_SESSION_NORMAL
) != 0) {
1298 error_report("iSCSI: Failed to set session type to normal.");
1303 iscsi_set_header_digest(iscsi
, ISCSI_HEADER_DIGEST_NONE_CRC32C
);
1305 /* check if we got HEADER_DIGEST via the options */
1306 parse_header_digest(iscsi
, iscsi_url
->target
);
1308 if (iscsi_full_connect_sync(iscsi
, iscsi_url
->portal
, iscsi_url
->lun
) != 0) {
1309 error_report("iSCSI: Failed to connect to LUN : %s",
1310 iscsi_get_error(iscsi
));
1315 iscsilun
->iscsi
= iscsi
;
1316 iscsilun
->lun
= iscsi_url
->lun
;
1318 task
= iscsi_inquiry_sync(iscsi
, iscsilun
->lun
, 0, 0, 36);
1320 if (task
== NULL
|| task
->status
!= SCSI_STATUS_GOOD
) {
1321 error_report("iSCSI: failed to send inquiry command.");
1326 inq
= scsi_datain_unmarshall(task
);
1328 error_report("iSCSI: Failed to unmarshall inquiry data.");
1333 iscsilun
->type
= inq
->periperal_device_type
;
1335 if ((ret
= iscsi_readcapacity_sync(iscsilun
)) != 0) {
1338 bs
->total_sectors
= sector_lun2qemu(iscsilun
->num_blocks
, iscsilun
);
1340 /* Medium changer or tape. We dont have any emulation for this so this must
1341 * be sg ioctl compatible. We force it to be sg, otherwise qemu will try
1342 * to read from the device to guess the image format.
1344 if (iscsilun
->type
== TYPE_MEDIUM_CHANGER
||
1345 iscsilun
->type
== TYPE_TAPE
) {
1349 if (iscsilun
->lbpme
) {
1350 struct scsi_inquiry_logical_block_provisioning
*inq_lbp
;
1351 task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 1,
1352 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING
);
1357 inq_lbp
= scsi_datain_unmarshall(task
);
1358 if (inq_lbp
== NULL
) {
1359 error_report("iSCSI: failed to unmarshall inquiry datain blob");
1363 memcpy(&iscsilun
->lbp
, inq_lbp
,
1364 sizeof(struct scsi_inquiry_logical_block_provisioning
));
1365 scsi_free_scsi_task(task
);
1369 if (iscsilun
->lbp
.lbpu
|| iscsilun
->lbp
.lbpws
) {
1370 struct scsi_inquiry_block_limits
*inq_bl
;
1371 task
= iscsi_do_inquiry(iscsilun
->iscsi
, iscsilun
->lun
, 1,
1372 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS
);
1377 inq_bl
= scsi_datain_unmarshall(task
);
1378 if (inq_bl
== NULL
) {
1379 error_report("iSCSI: failed to unmarshall inquiry datain blob");
1383 memcpy(&iscsilun
->bl
, inq_bl
,
1384 sizeof(struct scsi_inquiry_block_limits
));
1385 scsi_free_scsi_task(task
);
1389 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
1390 /* Set up a timer for sending out iSCSI NOPs */
1391 iscsilun
->nop_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, iscsi_nop_timed_event
, iscsilun
);
1392 timer_mod(iscsilun
->nop_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + NOP_INTERVAL
);
1396 qemu_opts_del(opts
);
1397 if (initiator_name
!= NULL
) {
1398 g_free(initiator_name
);
1400 if (iscsi_url
!= NULL
) {
1401 iscsi_destroy_url(iscsi_url
);
1404 scsi_free_scsi_task(task
);
1408 if (iscsi
!= NULL
) {
1409 iscsi_destroy_context(iscsi
);
1411 memset(iscsilun
, 0, sizeof(IscsiLun
));
1416 static void iscsi_close(BlockDriverState
*bs
)
1418 IscsiLun
*iscsilun
= bs
->opaque
;
1419 struct iscsi_context
*iscsi
= iscsilun
->iscsi
;
1421 if (iscsilun
->nop_timer
) {
1422 timer_del(iscsilun
->nop_timer
);
1423 timer_free(iscsilun
->nop_timer
);
1425 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi
), NULL
, NULL
, NULL
);
1426 iscsi_destroy_context(iscsi
);
1427 memset(iscsilun
, 0, sizeof(IscsiLun
));
1430 static int iscsi_truncate(BlockDriverState
*bs
, int64_t offset
)
1432 IscsiLun
*iscsilun
= bs
->opaque
;
1435 if (iscsilun
->type
!= TYPE_DISK
) {
1439 if ((ret
= iscsi_readcapacity_sync(iscsilun
)) != 0) {
1443 if (offset
> iscsi_getlength(bs
)) {
1450 static int iscsi_has_zero_init(BlockDriverState
*bs
)
1455 static int iscsi_create(const char *filename
, QEMUOptionParameter
*options
,
1459 int64_t total_size
= 0;
1460 BlockDriverState
*bs
;
1461 IscsiLun
*iscsilun
= NULL
;
1466 /* Read out options */
1467 while (options
&& options
->name
) {
1468 if (!strcmp(options
->name
, "size")) {
1469 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
1474 bs
->opaque
= g_malloc0(sizeof(struct IscsiLun
));
1475 iscsilun
= bs
->opaque
;
1477 bs_options
= qdict_new();
1478 qdict_put(bs_options
, "filename", qstring_from_str(filename
));
1479 ret
= iscsi_open(bs
, bs_options
, 0, NULL
);
1480 QDECREF(bs_options
);
1485 if (iscsilun
->nop_timer
) {
1486 timer_del(iscsilun
->nop_timer
);
1487 timer_free(iscsilun
->nop_timer
);
1489 if (iscsilun
->type
!= TYPE_DISK
) {
1493 if (bs
->total_sectors
< total_size
) {
1500 if (iscsilun
->iscsi
!= NULL
) {
1501 iscsi_destroy_context(iscsilun
->iscsi
);
1509 static QEMUOptionParameter iscsi_create_options
[] = {
1511 .name
= BLOCK_OPT_SIZE
,
1513 .help
= "Virtual disk size"
1518 static BlockDriver bdrv_iscsi
= {
1519 .format_name
= "iscsi",
1520 .protocol_name
= "iscsi",
1522 .instance_size
= sizeof(IscsiLun
),
1523 .bdrv_needs_filename
= true,
1524 .bdrv_file_open
= iscsi_open
,
1525 .bdrv_close
= iscsi_close
,
1526 .bdrv_create
= iscsi_create
,
1527 .create_options
= iscsi_create_options
,
1529 .bdrv_getlength
= iscsi_getlength
,
1530 .bdrv_truncate
= iscsi_truncate
,
1532 #if defined(LIBISCSI_FEATURE_IOVECTOR)
1533 .bdrv_co_get_block_status
= iscsi_co_get_block_status
,
1535 .bdrv_co_discard
= iscsi_co_discard
,
1537 .bdrv_aio_readv
= iscsi_aio_readv
,
1538 .bdrv_aio_writev
= iscsi_aio_writev
,
1539 .bdrv_aio_flush
= iscsi_aio_flush
,
1541 .bdrv_has_zero_init
= iscsi_has_zero_init
,
1544 .bdrv_ioctl
= iscsi_ioctl
,
1545 .bdrv_aio_ioctl
= iscsi_aio_ioctl
,
1549 static QemuOptsList qemu_iscsi_opts
= {
1551 .head
= QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts
.head
),
1555 .type
= QEMU_OPT_STRING
,
1556 .help
= "username for CHAP authentication to target",
1559 .type
= QEMU_OPT_STRING
,
1560 .help
= "password for CHAP authentication to target",
1562 .name
= "header-digest",
1563 .type
= QEMU_OPT_STRING
,
1564 .help
= "HeaderDigest setting. "
1565 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}",
1567 .name
= "initiator-name",
1568 .type
= QEMU_OPT_STRING
,
1569 .help
= "Initiator iqn name to use when connecting",
1571 { /* end of list */ }
1575 static void iscsi_block_init(void)
1577 bdrv_register(&bdrv_iscsi
);
1578 qemu_add_opts(&qemu_iscsi_opts
);
1581 block_init(iscsi_block_init
);