1 /* 2 * QEMU Block driver for iSCSI images 3 * 4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com> 5 * Copyright (c) 2012-2013 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 <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" 34 #include "trace.h" 35 #include "block/scsi.h" 36 #include "qemu/iov.h" 37 #include "sysemu/sysemu.h" 38 #include "qmp-commands.h" 39 40 #include <iscsi/iscsi.h> 41 #include <iscsi/scsi-lowlevel.h> 42 43 #ifdef __linux__ 44 #include <scsi/sg.h> 45 #include <block/scsi.h> 46 #endif 47 48 typedef struct IscsiLun { 49 struct iscsi_context *iscsi; 50 int lun; 51 enum scsi_inquiry_peripheral_device_type type; 52 int block_size; 53 uint64_t num_blocks; 54 int events; 55 QEMUTimer *nop_timer; 56 uint8_t lbpme; 57 uint8_t lbprz; 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; 62 } IscsiLun; 63 64 typedef struct IscsiTask { 65 int status; 66 int complete; 67 int retries; 68 int do_retry; 69 struct scsi_task *task; 70 Coroutine *co; 71 QEMUBH *bh; 72 } IscsiTask; 73 74 typedef struct IscsiAIOCB { 75 BlockDriverAIOCB common; 76 QEMUIOVector *qiov; 77 QEMUBH *bh; 78 IscsiLun *iscsilun; 79 struct scsi_task *task; 80 uint8_t *buf; 81 int status; 82 int canceled; 83 int retries; 84 int64_t sector_num; 85 int nb_sectors; 86 #ifdef __linux__ 87 sg_io_hdr_t *ioh; 88 #endif 89 } IscsiAIOCB; 90 91 #define NOP_INTERVAL 5000 92 #define MAX_NOP_FAILURES 3 93 #define ISCSI_CMD_RETRIES 5 94 95 static void 96 iscsi_bh_cb(void *p) 97 { 98 IscsiAIOCB *acb = p; 99 100 qemu_bh_delete(acb->bh); 101 102 g_free(acb->buf); 103 acb->buf = NULL; 104 105 if (acb->canceled == 0) { 106 acb->common.cb(acb->common.opaque, acb->status); 107 } 108 109 if (acb->task != NULL) { 110 scsi_free_scsi_task(acb->task); 111 acb->task = NULL; 112 } 113 114 qemu_aio_release(acb); 115 } 116 117 static void 118 iscsi_schedule_bh(IscsiAIOCB *acb) 119 { 120 if (acb->bh) { 121 return; 122 } 123 acb->bh = qemu_bh_new(iscsi_bh_cb, acb); 124 qemu_bh_schedule(acb->bh); 125 } 126 127 static void iscsi_co_generic_bh_cb(void *opaque) 128 { 129 struct IscsiTask *iTask = opaque; 130 qemu_bh_delete(iTask->bh); 131 qemu_coroutine_enter(iTask->co, NULL); 132 } 133 134 static void 135 iscsi_co_generic_cb(struct iscsi_context *iscsi, int status, 136 void *command_data, void *opaque) 137 { 138 struct IscsiTask *iTask = opaque; 139 struct scsi_task *task = command_data; 140 141 iTask->complete = 1; 142 iTask->status = status; 143 iTask->do_retry = 0; 144 iTask->task = task; 145 146 if (iTask->retries-- > 0 && status == SCSI_STATUS_CHECK_CONDITION 147 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) { 148 iTask->do_retry = 1; 149 goto out; 150 } 151 152 if (status != SCSI_STATUS_GOOD) { 153 error_report("iSCSI: Failure. %s", iscsi_get_error(iscsi)); 154 } 155 156 out: 157 if (iTask->co) { 158 iTask->bh = qemu_bh_new(iscsi_co_generic_bh_cb, iTask); 159 qemu_bh_schedule(iTask->bh); 160 } 161 } 162 163 static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask) 164 { 165 *iTask = (struct IscsiTask) { 166 .co = qemu_coroutine_self(), 167 .retries = ISCSI_CMD_RETRIES, 168 }; 169 } 170 171 static void 172 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data, 173 void *private_data) 174 { 175 IscsiAIOCB *acb = private_data; 176 177 acb->status = -ECANCELED; 178 iscsi_schedule_bh(acb); 179 } 180 181 static void 182 iscsi_aio_cancel(BlockDriverAIOCB *blockacb) 183 { 184 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; 185 IscsiLun *iscsilun = acb->iscsilun; 186 187 if (acb->status != -EINPROGRESS) { 188 return; 189 } 190 191 acb->canceled = 1; 192 193 /* send a task mgmt call to the target to cancel the task on the target */ 194 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task, 195 iscsi_abort_task_cb, acb); 196 197 while (acb->status == -EINPROGRESS) { 198 qemu_aio_wait(); 199 } 200 } 201 202 static const AIOCBInfo iscsi_aiocb_info = { 203 .aiocb_size = sizeof(IscsiAIOCB), 204 .cancel = iscsi_aio_cancel, 205 }; 206 207 208 static void iscsi_process_read(void *arg); 209 static void iscsi_process_write(void *arg); 210 211 static void 212 iscsi_set_events(IscsiLun *iscsilun) 213 { 214 struct iscsi_context *iscsi = iscsilun->iscsi; 215 int ev; 216 217 /* We always register a read handler. */ 218 ev = POLLIN; 219 ev |= iscsi_which_events(iscsi); 220 if (ev != iscsilun->events) { 221 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), 222 iscsi_process_read, 223 (ev & POLLOUT) ? iscsi_process_write : NULL, 224 iscsilun); 225 226 } 227 228 iscsilun->events = ev; 229 } 230 231 static void 232 iscsi_process_read(void *arg) 233 { 234 IscsiLun *iscsilun = arg; 235 struct iscsi_context *iscsi = iscsilun->iscsi; 236 237 iscsi_service(iscsi, POLLIN); 238 iscsi_set_events(iscsilun); 239 } 240 241 static void 242 iscsi_process_write(void *arg) 243 { 244 IscsiLun *iscsilun = arg; 245 struct iscsi_context *iscsi = iscsilun->iscsi; 246 247 iscsi_service(iscsi, POLLOUT); 248 iscsi_set_events(iscsilun); 249 } 250 251 static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun) 252 { 253 return sector * iscsilun->block_size / BDRV_SECTOR_SIZE; 254 } 255 256 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun) 257 { 258 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size; 259 } 260 261 static bool is_request_lun_aligned(int64_t sector_num, int nb_sectors, 262 IscsiLun *iscsilun) 263 { 264 if ((sector_num * BDRV_SECTOR_SIZE) % iscsilun->block_size || 265 (nb_sectors * BDRV_SECTOR_SIZE) % iscsilun->block_size) { 266 error_report("iSCSI misaligned request: " 267 "iscsilun->block_size %u, sector_num %" PRIi64 268 ", nb_sectors %d", 269 iscsilun->block_size, sector_num, nb_sectors); 270 return 0; 271 } 272 return 1; 273 } 274 275 static int coroutine_fn iscsi_co_writev(BlockDriverState *bs, 276 int64_t sector_num, int nb_sectors, 277 QEMUIOVector *iov) 278 { 279 IscsiLun *iscsilun = bs->opaque; 280 struct IscsiTask iTask; 281 uint64_t lba; 282 uint32_t num_sectors; 283 uint8_t *data = NULL; 284 uint8_t *buf = NULL; 285 286 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 287 return -EINVAL; 288 } 289 290 lba = sector_qemu2lun(sector_num, iscsilun); 291 num_sectors = sector_qemu2lun(nb_sectors, iscsilun); 292 #if !defined(LIBISCSI_FEATURE_IOVECTOR) 293 /* if the iovec only contains one buffer we can pass it directly */ 294 if (iov->niov == 1) { 295 data = iov->iov[0].iov_base; 296 } else { 297 size_t size = MIN(nb_sectors * BDRV_SECTOR_SIZE, iov->size); 298 buf = g_malloc(size); 299 qemu_iovec_to_buf(iov, 0, buf, size); 300 data = buf; 301 } 302 #endif 303 iscsi_co_init_iscsitask(iscsilun, &iTask); 304 retry: 305 iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba, 306 data, num_sectors * iscsilun->block_size, 307 iscsilun->block_size, 0, 0, 0, 0, 0, 308 iscsi_co_generic_cb, &iTask); 309 if (iTask.task == NULL) { 310 g_free(buf); 311 return -ENOMEM; 312 } 313 #if defined(LIBISCSI_FEATURE_IOVECTOR) 314 scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov, 315 iov->niov); 316 #endif 317 while (!iTask.complete) { 318 iscsi_set_events(iscsilun); 319 qemu_coroutine_yield(); 320 } 321 322 if (iTask.task != NULL) { 323 scsi_free_scsi_task(iTask.task); 324 iTask.task = NULL; 325 } 326 327 if (iTask.do_retry) { 328 goto retry; 329 } 330 331 g_free(buf); 332 333 if (iTask.status != SCSI_STATUS_GOOD) { 334 return -EIO; 335 } 336 337 return 0; 338 } 339 340 static int coroutine_fn iscsi_co_readv(BlockDriverState *bs, 341 int64_t sector_num, int nb_sectors, 342 QEMUIOVector *iov) 343 { 344 IscsiLun *iscsilun = bs->opaque; 345 struct IscsiTask iTask; 346 uint64_t lba; 347 uint32_t num_sectors; 348 #if !defined(LIBISCSI_FEATURE_IOVECTOR) 349 int i; 350 #endif 351 352 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 353 return -EINVAL; 354 } 355 356 lba = sector_qemu2lun(sector_num, iscsilun); 357 num_sectors = sector_qemu2lun(nb_sectors, iscsilun); 358 359 iscsi_co_init_iscsitask(iscsilun, &iTask); 360 retry: 361 switch (iscsilun->type) { 362 case TYPE_DISK: 363 iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba, 364 num_sectors * iscsilun->block_size, 365 iscsilun->block_size, 0, 0, 0, 0, 0, 366 iscsi_co_generic_cb, &iTask); 367 break; 368 default: 369 iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba, 370 num_sectors * iscsilun->block_size, 371 iscsilun->block_size, 372 #if !defined(CONFIG_LIBISCSI_1_4) /* API change from 1.4.0 to 1.5.0 */ 373 0, 0, 0, 0, 0, 374 #endif 375 iscsi_co_generic_cb, &iTask); 376 break; 377 } 378 if (iTask.task == NULL) { 379 return -ENOMEM; 380 } 381 #if defined(LIBISCSI_FEATURE_IOVECTOR) 382 scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov); 383 #else 384 for (i = 0; i < iov->niov; i++) { 385 scsi_task_add_data_in_buffer(iTask.task, 386 iov->iov[i].iov_len, 387 iov->iov[i].iov_base); 388 } 389 #endif 390 391 while (!iTask.complete) { 392 iscsi_set_events(iscsilun); 393 qemu_coroutine_yield(); 394 } 395 396 if (iTask.task != NULL) { 397 scsi_free_scsi_task(iTask.task); 398 iTask.task = NULL; 399 } 400 401 if (iTask.do_retry) { 402 goto retry; 403 } 404 405 if (iTask.status != SCSI_STATUS_GOOD) { 406 return -EIO; 407 } 408 409 return 0; 410 } 411 412 static int coroutine_fn iscsi_co_flush(BlockDriverState *bs) 413 { 414 IscsiLun *iscsilun = bs->opaque; 415 struct IscsiTask iTask; 416 417 iscsi_co_init_iscsitask(iscsilun, &iTask); 418 419 retry: 420 if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0, 421 0, iscsi_co_generic_cb, &iTask) == NULL) { 422 return -ENOMEM; 423 } 424 425 while (!iTask.complete) { 426 iscsi_set_events(iscsilun); 427 qemu_coroutine_yield(); 428 } 429 430 if (iTask.task != NULL) { 431 scsi_free_scsi_task(iTask.task); 432 iTask.task = NULL; 433 } 434 435 if (iTask.do_retry) { 436 goto retry; 437 } 438 439 if (iTask.status != SCSI_STATUS_GOOD) { 440 return -EIO; 441 } 442 443 return 0; 444 } 445 446 #ifdef __linux__ 447 static void 448 iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status, 449 void *command_data, void *opaque) 450 { 451 IscsiAIOCB *acb = opaque; 452 453 g_free(acb->buf); 454 acb->buf = NULL; 455 456 if (acb->canceled != 0) { 457 return; 458 } 459 460 acb->status = 0; 461 if (status < 0) { 462 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s", 463 iscsi_get_error(iscsi)); 464 acb->status = -EIO; 465 } 466 467 acb->ioh->driver_status = 0; 468 acb->ioh->host_status = 0; 469 acb->ioh->resid = 0; 470 471 #define SG_ERR_DRIVER_SENSE 0x08 472 473 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) { 474 int ss; 475 476 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE; 477 478 acb->ioh->sb_len_wr = acb->task->datain.size - 2; 479 ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ? 480 acb->ioh->mx_sb_len : acb->ioh->sb_len_wr; 481 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss); 482 } 483 484 iscsi_schedule_bh(acb); 485 } 486 487 static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, 488 unsigned long int req, void *buf, 489 BlockDriverCompletionFunc *cb, void *opaque) 490 { 491 IscsiLun *iscsilun = bs->opaque; 492 struct iscsi_context *iscsi = iscsilun->iscsi; 493 struct iscsi_data data; 494 IscsiAIOCB *acb; 495 496 assert(req == SG_IO); 497 498 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque); 499 500 acb->iscsilun = iscsilun; 501 acb->canceled = 0; 502 acb->bh = NULL; 503 acb->status = -EINPROGRESS; 504 acb->buf = NULL; 505 acb->ioh = buf; 506 507 acb->task = malloc(sizeof(struct scsi_task)); 508 if (acb->task == NULL) { 509 error_report("iSCSI: Failed to allocate task for scsi command. %s", 510 iscsi_get_error(iscsi)); 511 qemu_aio_release(acb); 512 return NULL; 513 } 514 memset(acb->task, 0, sizeof(struct scsi_task)); 515 516 switch (acb->ioh->dxfer_direction) { 517 case SG_DXFER_TO_DEV: 518 acb->task->xfer_dir = SCSI_XFER_WRITE; 519 break; 520 case SG_DXFER_FROM_DEV: 521 acb->task->xfer_dir = SCSI_XFER_READ; 522 break; 523 default: 524 acb->task->xfer_dir = SCSI_XFER_NONE; 525 break; 526 } 527 528 acb->task->cdb_size = acb->ioh->cmd_len; 529 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len); 530 acb->task->expxferlen = acb->ioh->dxfer_len; 531 532 data.size = 0; 533 if (acb->task->xfer_dir == SCSI_XFER_WRITE) { 534 if (acb->ioh->iovec_count == 0) { 535 data.data = acb->ioh->dxferp; 536 data.size = acb->ioh->dxfer_len; 537 } else { 538 #if defined(LIBISCSI_FEATURE_IOVECTOR) 539 scsi_task_set_iov_out(acb->task, 540 (struct scsi_iovec *) acb->ioh->dxferp, 541 acb->ioh->iovec_count); 542 #else 543 struct iovec *iov = (struct iovec *)acb->ioh->dxferp; 544 545 acb->buf = g_malloc(acb->ioh->dxfer_len); 546 data.data = acb->buf; 547 data.size = iov_to_buf(iov, acb->ioh->iovec_count, 0, 548 acb->buf, acb->ioh->dxfer_len); 549 #endif 550 } 551 } 552 553 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, 554 iscsi_aio_ioctl_cb, 555 (data.size > 0) ? &data : NULL, 556 acb) != 0) { 557 scsi_free_scsi_task(acb->task); 558 qemu_aio_release(acb); 559 return NULL; 560 } 561 562 /* tell libiscsi to read straight into the buffer we got from ioctl */ 563 if (acb->task->xfer_dir == SCSI_XFER_READ) { 564 if (acb->ioh->iovec_count == 0) { 565 scsi_task_add_data_in_buffer(acb->task, 566 acb->ioh->dxfer_len, 567 acb->ioh->dxferp); 568 } else { 569 #if defined(LIBISCSI_FEATURE_IOVECTOR) 570 scsi_task_set_iov_in(acb->task, 571 (struct scsi_iovec *) acb->ioh->dxferp, 572 acb->ioh->iovec_count); 573 #else 574 int i; 575 for (i = 0; i < acb->ioh->iovec_count; i++) { 576 struct iovec *iov = (struct iovec *)acb->ioh->dxferp; 577 578 scsi_task_add_data_in_buffer(acb->task, 579 iov[i].iov_len, 580 iov[i].iov_base); 581 } 582 #endif 583 } 584 } 585 586 iscsi_set_events(iscsilun); 587 588 return &acb->common; 589 } 590 591 592 static void ioctl_cb(void *opaque, int status) 593 { 594 int *p_status = opaque; 595 *p_status = status; 596 } 597 598 static int iscsi_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 599 { 600 IscsiLun *iscsilun = bs->opaque; 601 int status; 602 603 switch (req) { 604 case SG_GET_VERSION_NUM: 605 *(int *)buf = 30000; 606 break; 607 case SG_GET_SCSI_ID: 608 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type; 609 break; 610 case SG_IO: 611 status = -EINPROGRESS; 612 iscsi_aio_ioctl(bs, req, buf, ioctl_cb, &status); 613 614 while (status == -EINPROGRESS) { 615 qemu_aio_wait(); 616 } 617 618 return 0; 619 default: 620 return -1; 621 } 622 return 0; 623 } 624 #endif 625 626 static int64_t 627 iscsi_getlength(BlockDriverState *bs) 628 { 629 IscsiLun *iscsilun = bs->opaque; 630 int64_t len; 631 632 len = iscsilun->num_blocks; 633 len *= iscsilun->block_size; 634 635 return len; 636 } 637 638 #if defined(LIBISCSI_FEATURE_IOVECTOR) 639 640 static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs, 641 int64_t sector_num, 642 int nb_sectors, int *pnum) 643 { 644 IscsiLun *iscsilun = bs->opaque; 645 struct scsi_get_lba_status *lbas = NULL; 646 struct scsi_lba_status_descriptor *lbasd = NULL; 647 struct IscsiTask iTask; 648 int64_t ret; 649 650 iscsi_co_init_iscsitask(iscsilun, &iTask); 651 652 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 653 ret = -EINVAL; 654 goto out; 655 } 656 657 /* default to all sectors allocated */ 658 ret = BDRV_BLOCK_DATA; 659 ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID; 660 *pnum = nb_sectors; 661 662 /* LUN does not support logical block provisioning */ 663 if (iscsilun->lbpme == 0) { 664 goto out; 665 } 666 667 retry: 668 if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun, 669 sector_qemu2lun(sector_num, iscsilun), 670 8 + 16, iscsi_co_generic_cb, 671 &iTask) == NULL) { 672 ret = -ENOMEM; 673 goto out; 674 } 675 676 while (!iTask.complete) { 677 iscsi_set_events(iscsilun); 678 qemu_coroutine_yield(); 679 } 680 681 if (iTask.do_retry) { 682 if (iTask.task != NULL) { 683 scsi_free_scsi_task(iTask.task); 684 iTask.task = NULL; 685 } 686 goto retry; 687 } 688 689 if (iTask.status != SCSI_STATUS_GOOD) { 690 /* in case the get_lba_status_callout fails (i.e. 691 * because the device is busy or the cmd is not 692 * supported) we pretend all blocks are allocated 693 * for backwards compatibility */ 694 goto out; 695 } 696 697 lbas = scsi_datain_unmarshall(iTask.task); 698 if (lbas == NULL) { 699 ret = -EIO; 700 goto out; 701 } 702 703 lbasd = &lbas->descriptors[0]; 704 705 if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) { 706 ret = -EIO; 707 goto out; 708 } 709 710 *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun); 711 if (*pnum > nb_sectors) { 712 *pnum = nb_sectors; 713 } 714 715 if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED || 716 lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) { 717 ret &= ~BDRV_BLOCK_DATA; 718 if (iscsilun->lbprz) { 719 ret |= BDRV_BLOCK_ZERO; 720 } 721 } 722 723 out: 724 if (iTask.task != NULL) { 725 scsi_free_scsi_task(iTask.task); 726 } 727 return ret; 728 } 729 730 #endif /* LIBISCSI_FEATURE_IOVECTOR */ 731 732 static int 733 coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num, 734 int nb_sectors) 735 { 736 IscsiLun *iscsilun = bs->opaque; 737 struct IscsiTask iTask; 738 struct unmap_list list; 739 740 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 741 return -EINVAL; 742 } 743 744 if (!iscsilun->lbp.lbpu) { 745 /* UNMAP is not supported by the target */ 746 return 0; 747 } 748 749 list.lba = sector_qemu2lun(sector_num, iscsilun); 750 list.num = sector_qemu2lun(nb_sectors, iscsilun); 751 752 iscsi_co_init_iscsitask(iscsilun, &iTask); 753 retry: 754 if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1, 755 iscsi_co_generic_cb, &iTask) == NULL) { 756 return -ENOMEM; 757 } 758 759 while (!iTask.complete) { 760 iscsi_set_events(iscsilun); 761 qemu_coroutine_yield(); 762 } 763 764 if (iTask.task != NULL) { 765 scsi_free_scsi_task(iTask.task); 766 iTask.task = NULL; 767 } 768 769 if (iTask.do_retry) { 770 goto retry; 771 } 772 773 if (iTask.status == SCSI_STATUS_CHECK_CONDITION) { 774 /* the target might fail with a check condition if it 775 is not happy with the alignment of the UNMAP request 776 we silently fail in this case */ 777 return 0; 778 } 779 780 if (iTask.status != SCSI_STATUS_GOOD) { 781 return -EIO; 782 } 783 784 return 0; 785 } 786 787 #if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED) 788 789 static int 790 coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num, 791 int nb_sectors, BdrvRequestFlags flags) 792 { 793 IscsiLun *iscsilun = bs->opaque; 794 struct IscsiTask iTask; 795 uint64_t lba; 796 uint32_t nb_blocks; 797 798 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 799 return -EINVAL; 800 } 801 802 if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) { 803 /* WRITE SAME without UNMAP is not supported by the target */ 804 return -ENOTSUP; 805 } 806 807 if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) { 808 /* WRITE SAME with UNMAP is not supported by the target */ 809 return -ENOTSUP; 810 } 811 812 lba = sector_qemu2lun(sector_num, iscsilun); 813 nb_blocks = sector_qemu2lun(nb_sectors, iscsilun); 814 815 if (iscsilun->zeroblock == NULL) { 816 iscsilun->zeroblock = g_malloc0(iscsilun->block_size); 817 } 818 819 iscsi_co_init_iscsitask(iscsilun, &iTask); 820 retry: 821 if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba, 822 iscsilun->zeroblock, iscsilun->block_size, 823 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP), 824 0, 0, iscsi_co_generic_cb, &iTask) == NULL) { 825 return -ENOMEM; 826 } 827 828 while (!iTask.complete) { 829 iscsi_set_events(iscsilun); 830 qemu_coroutine_yield(); 831 } 832 833 if (iTask.task != NULL) { 834 scsi_free_scsi_task(iTask.task); 835 iTask.task = NULL; 836 } 837 838 if (iTask.do_retry) { 839 goto retry; 840 } 841 842 if (iTask.status != SCSI_STATUS_GOOD) { 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 /* WRITE SAME is not supported by the target */ 847 iscsilun->has_write_same = false; 848 return -ENOTSUP; 849 } 850 851 return -EIO; 852 } 853 854 return 0; 855 } 856 857 #endif /* SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED */ 858 859 static int parse_chap(struct iscsi_context *iscsi, const char *target) 860 { 861 QemuOptsList *list; 862 QemuOpts *opts; 863 const char *user = NULL; 864 const char *password = NULL; 865 866 list = qemu_find_opts("iscsi"); 867 if (!list) { 868 return 0; 869 } 870 871 opts = qemu_opts_find(list, target); 872 if (opts == NULL) { 873 opts = QTAILQ_FIRST(&list->head); 874 if (!opts) { 875 return 0; 876 } 877 } 878 879 user = qemu_opt_get(opts, "user"); 880 if (!user) { 881 return 0; 882 } 883 884 password = qemu_opt_get(opts, "password"); 885 if (!password) { 886 error_report("CHAP username specified but no password was given"); 887 return -1; 888 } 889 890 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) { 891 error_report("Failed to set initiator username and password"); 892 return -1; 893 } 894 895 return 0; 896 } 897 898 static void parse_header_digest(struct iscsi_context *iscsi, const char *target) 899 { 900 QemuOptsList *list; 901 QemuOpts *opts; 902 const char *digest = NULL; 903 904 list = qemu_find_opts("iscsi"); 905 if (!list) { 906 return; 907 } 908 909 opts = qemu_opts_find(list, target); 910 if (opts == NULL) { 911 opts = QTAILQ_FIRST(&list->head); 912 if (!opts) { 913 return; 914 } 915 } 916 917 digest = qemu_opt_get(opts, "header-digest"); 918 if (!digest) { 919 return; 920 } 921 922 if (!strcmp(digest, "CRC32C")) { 923 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C); 924 } else if (!strcmp(digest, "NONE")) { 925 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE); 926 } else if (!strcmp(digest, "CRC32C-NONE")) { 927 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE); 928 } else if (!strcmp(digest, "NONE-CRC32C")) { 929 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 930 } else { 931 error_report("Invalid header-digest setting : %s", digest); 932 } 933 } 934 935 static char *parse_initiator_name(const char *target) 936 { 937 QemuOptsList *list; 938 QemuOpts *opts; 939 const char *name; 940 char *iscsi_name; 941 UuidInfo *uuid_info; 942 943 list = qemu_find_opts("iscsi"); 944 if (list) { 945 opts = qemu_opts_find(list, target); 946 if (!opts) { 947 opts = QTAILQ_FIRST(&list->head); 948 } 949 if (opts) { 950 name = qemu_opt_get(opts, "initiator-name"); 951 if (name) { 952 return g_strdup(name); 953 } 954 } 955 } 956 957 uuid_info = qmp_query_uuid(NULL); 958 if (strcmp(uuid_info->UUID, UUID_NONE) == 0) { 959 name = qemu_get_vm_name(); 960 } else { 961 name = uuid_info->UUID; 962 } 963 iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s", 964 name ? ":" : "", name ? name : ""); 965 qapi_free_UuidInfo(uuid_info); 966 return iscsi_name; 967 } 968 969 #if defined(LIBISCSI_FEATURE_NOP_COUNTER) 970 static void iscsi_nop_timed_event(void *opaque) 971 { 972 IscsiLun *iscsilun = opaque; 973 974 if (iscsi_get_nops_in_flight(iscsilun->iscsi) > MAX_NOP_FAILURES) { 975 error_report("iSCSI: NOP timeout. Reconnecting..."); 976 iscsi_reconnect(iscsilun->iscsi); 977 } 978 979 if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) { 980 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages."); 981 return; 982 } 983 984 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL); 985 iscsi_set_events(iscsilun); 986 } 987 #endif 988 989 static int iscsi_readcapacity_sync(IscsiLun *iscsilun) 990 { 991 struct scsi_task *task = NULL; 992 struct scsi_readcapacity10 *rc10 = NULL; 993 struct scsi_readcapacity16 *rc16 = NULL; 994 int ret = 0; 995 int retries = ISCSI_CMD_RETRIES; 996 997 do { 998 if (task != NULL) { 999 scsi_free_scsi_task(task); 1000 task = NULL; 1001 } 1002 1003 switch (iscsilun->type) { 1004 case TYPE_DISK: 1005 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun); 1006 if (task != NULL && task->status == SCSI_STATUS_GOOD) { 1007 rc16 = scsi_datain_unmarshall(task); 1008 if (rc16 == NULL) { 1009 error_report("iSCSI: Failed to unmarshall readcapacity16 data."); 1010 ret = -EINVAL; 1011 } else { 1012 iscsilun->block_size = rc16->block_length; 1013 iscsilun->num_blocks = rc16->returned_lba + 1; 1014 iscsilun->lbpme = rc16->lbpme; 1015 iscsilun->lbprz = rc16->lbprz; 1016 } 1017 } 1018 break; 1019 case TYPE_ROM: 1020 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0); 1021 if (task != NULL && task->status == SCSI_STATUS_GOOD) { 1022 rc10 = scsi_datain_unmarshall(task); 1023 if (rc10 == NULL) { 1024 error_report("iSCSI: Failed to unmarshall readcapacity10 data."); 1025 ret = -EINVAL; 1026 } else { 1027 iscsilun->block_size = rc10->block_size; 1028 if (rc10->lba == 0) { 1029 /* blank disk loaded */ 1030 iscsilun->num_blocks = 0; 1031 } else { 1032 iscsilun->num_blocks = rc10->lba + 1; 1033 } 1034 } 1035 } 1036 break; 1037 default: 1038 return 0; 1039 } 1040 } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION 1041 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION 1042 && retries-- > 0); 1043 1044 if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1045 error_report("iSCSI: failed to send readcapacity10 command."); 1046 ret = -EINVAL; 1047 } 1048 if (task) { 1049 scsi_free_scsi_task(task); 1050 } 1051 return ret; 1052 } 1053 1054 /* TODO Convert to fine grained options */ 1055 static QemuOptsList runtime_opts = { 1056 .name = "iscsi", 1057 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 1058 .desc = { 1059 { 1060 .name = "filename", 1061 .type = QEMU_OPT_STRING, 1062 .help = "URL to the iscsi image", 1063 }, 1064 { /* end of list */ } 1065 }, 1066 }; 1067 1068 static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, 1069 int lun, int evpd, int pc) { 1070 int full_size; 1071 struct scsi_task *task = NULL; 1072 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64); 1073 if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1074 goto fail; 1075 } 1076 full_size = scsi_datain_getfullsize(task); 1077 if (full_size > task->datain.size) { 1078 scsi_free_scsi_task(task); 1079 1080 /* we need more data for the full list */ 1081 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size); 1082 if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1083 goto fail; 1084 } 1085 } 1086 1087 return task; 1088 1089 fail: 1090 error_report("iSCSI: Inquiry command failed : %s", 1091 iscsi_get_error(iscsi)); 1092 if (task) { 1093 scsi_free_scsi_task(task); 1094 return NULL; 1095 } 1096 return NULL; 1097 } 1098 1099 /* 1100 * We support iscsi url's on the form 1101 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun> 1102 * 1103 * Note: flags are currently not used by iscsi_open. If this function 1104 * is changed such that flags are used, please examine iscsi_reopen_prepare() 1105 * to see if needs to be changed as well. 1106 */ 1107 static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, 1108 Error **errp) 1109 { 1110 IscsiLun *iscsilun = bs->opaque; 1111 struct iscsi_context *iscsi = NULL; 1112 struct iscsi_url *iscsi_url = NULL; 1113 struct scsi_task *task = NULL; 1114 struct scsi_inquiry_standard *inq = NULL; 1115 char *initiator_name = NULL; 1116 QemuOpts *opts; 1117 Error *local_err = NULL; 1118 const char *filename; 1119 int ret; 1120 1121 if ((BDRV_SECTOR_SIZE % 512) != 0) { 1122 error_report("iSCSI: Invalid BDRV_SECTOR_SIZE. " 1123 "BDRV_SECTOR_SIZE(%lld) is not a multiple " 1124 "of 512", BDRV_SECTOR_SIZE); 1125 return -EINVAL; 1126 } 1127 1128 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 1129 qemu_opts_absorb_qdict(opts, options, &local_err); 1130 if (error_is_set(&local_err)) { 1131 qerror_report_err(local_err); 1132 error_free(local_err); 1133 ret = -EINVAL; 1134 goto out; 1135 } 1136 1137 filename = qemu_opt_get(opts, "filename"); 1138 1139 1140 iscsi_url = iscsi_parse_full_url(iscsi, filename); 1141 if (iscsi_url == NULL) { 1142 error_report("Failed to parse URL : %s", filename); 1143 ret = -EINVAL; 1144 goto out; 1145 } 1146 1147 memset(iscsilun, 0, sizeof(IscsiLun)); 1148 1149 initiator_name = parse_initiator_name(iscsi_url->target); 1150 1151 iscsi = iscsi_create_context(initiator_name); 1152 if (iscsi == NULL) { 1153 error_report("iSCSI: Failed to create iSCSI context."); 1154 ret = -ENOMEM; 1155 goto out; 1156 } 1157 1158 if (iscsi_set_targetname(iscsi, iscsi_url->target)) { 1159 error_report("iSCSI: Failed to set target name."); 1160 ret = -EINVAL; 1161 goto out; 1162 } 1163 1164 if (iscsi_url->user != NULL) { 1165 ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user, 1166 iscsi_url->passwd); 1167 if (ret != 0) { 1168 error_report("Failed to set initiator username and password"); 1169 ret = -EINVAL; 1170 goto out; 1171 } 1172 } 1173 1174 /* check if we got CHAP username/password via the options */ 1175 if (parse_chap(iscsi, iscsi_url->target) != 0) { 1176 error_report("iSCSI: Failed to set CHAP user/password"); 1177 ret = -EINVAL; 1178 goto out; 1179 } 1180 1181 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) { 1182 error_report("iSCSI: Failed to set session type to normal."); 1183 ret = -EINVAL; 1184 goto out; 1185 } 1186 1187 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 1188 1189 /* check if we got HEADER_DIGEST via the options */ 1190 parse_header_digest(iscsi, iscsi_url->target); 1191 1192 if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) { 1193 error_report("iSCSI: Failed to connect to LUN : %s", 1194 iscsi_get_error(iscsi)); 1195 ret = -EINVAL; 1196 goto out; 1197 } 1198 1199 iscsilun->iscsi = iscsi; 1200 iscsilun->lun = iscsi_url->lun; 1201 1202 task = iscsi_inquiry_sync(iscsi, iscsilun->lun, 0, 0, 36); 1203 1204 if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1205 error_report("iSCSI: failed to send inquiry command."); 1206 ret = -EINVAL; 1207 goto out; 1208 } 1209 1210 inq = scsi_datain_unmarshall(task); 1211 if (inq == NULL) { 1212 error_report("iSCSI: Failed to unmarshall inquiry data."); 1213 ret = -EINVAL; 1214 goto out; 1215 } 1216 1217 iscsilun->type = inq->periperal_device_type; 1218 iscsilun->has_write_same = true; 1219 1220 if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) { 1221 goto out; 1222 } 1223 bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun); 1224 bs->request_alignment = iscsilun->block_size; 1225 1226 /* Medium changer or tape. We dont have any emulation for this so this must 1227 * be sg ioctl compatible. We force it to be sg, otherwise qemu will try 1228 * to read from the device to guess the image format. 1229 */ 1230 if (iscsilun->type == TYPE_MEDIUM_CHANGER || 1231 iscsilun->type == TYPE_TAPE) { 1232 bs->sg = 1; 1233 } 1234 1235 if (iscsilun->lbpme) { 1236 struct scsi_inquiry_logical_block_provisioning *inq_lbp; 1237 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, 1238 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING); 1239 if (task == NULL) { 1240 ret = -EINVAL; 1241 goto out; 1242 } 1243 inq_lbp = scsi_datain_unmarshall(task); 1244 if (inq_lbp == NULL) { 1245 error_report("iSCSI: failed to unmarshall inquiry datain blob"); 1246 ret = -EINVAL; 1247 goto out; 1248 } 1249 memcpy(&iscsilun->lbp, inq_lbp, 1250 sizeof(struct scsi_inquiry_logical_block_provisioning)); 1251 scsi_free_scsi_task(task); 1252 task = NULL; 1253 } 1254 1255 if (iscsilun->lbp.lbpu || iscsilun->lbp.lbpws) { 1256 struct scsi_inquiry_block_limits *inq_bl; 1257 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, 1258 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS); 1259 if (task == NULL) { 1260 ret = -EINVAL; 1261 goto out; 1262 } 1263 inq_bl = scsi_datain_unmarshall(task); 1264 if (inq_bl == NULL) { 1265 error_report("iSCSI: failed to unmarshall inquiry datain blob"); 1266 ret = -EINVAL; 1267 goto out; 1268 } 1269 memcpy(&iscsilun->bl, inq_bl, 1270 sizeof(struct scsi_inquiry_block_limits)); 1271 scsi_free_scsi_task(task); 1272 task = NULL; 1273 } 1274 1275 #if defined(LIBISCSI_FEATURE_NOP_COUNTER) 1276 /* Set up a timer for sending out iSCSI NOPs */ 1277 iscsilun->nop_timer = timer_new_ms(QEMU_CLOCK_REALTIME, iscsi_nop_timed_event, iscsilun); 1278 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL); 1279 #endif 1280 1281 out: 1282 qemu_opts_del(opts); 1283 if (initiator_name != NULL) { 1284 g_free(initiator_name); 1285 } 1286 if (iscsi_url != NULL) { 1287 iscsi_destroy_url(iscsi_url); 1288 } 1289 if (task != NULL) { 1290 scsi_free_scsi_task(task); 1291 } 1292 1293 if (ret) { 1294 if (iscsi != NULL) { 1295 iscsi_destroy_context(iscsi); 1296 } 1297 memset(iscsilun, 0, sizeof(IscsiLun)); 1298 } 1299 return ret; 1300 } 1301 1302 static void iscsi_close(BlockDriverState *bs) 1303 { 1304 IscsiLun *iscsilun = bs->opaque; 1305 struct iscsi_context *iscsi = iscsilun->iscsi; 1306 1307 if (iscsilun->nop_timer) { 1308 timer_del(iscsilun->nop_timer); 1309 timer_free(iscsilun->nop_timer); 1310 } 1311 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL); 1312 iscsi_destroy_context(iscsi); 1313 g_free(iscsilun->zeroblock); 1314 memset(iscsilun, 0, sizeof(IscsiLun)); 1315 } 1316 1317 static int iscsi_refresh_limits(BlockDriverState *bs) 1318 { 1319 IscsiLun *iscsilun = bs->opaque; 1320 1321 /* We don't actually refresh here, but just return data queried in 1322 * iscsi_open(): iscsi targets don't change their limits. */ 1323 if (iscsilun->lbp.lbpu || iscsilun->lbp.lbpws) { 1324 if (iscsilun->bl.max_unmap < 0xffffffff) { 1325 bs->bl.max_discard = sector_lun2qemu(iscsilun->bl.max_unmap, 1326 iscsilun); 1327 } 1328 bs->bl.discard_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, 1329 iscsilun); 1330 1331 if (iscsilun->bl.max_ws_len < 0xffffffff) { 1332 bs->bl.max_write_zeroes = sector_lun2qemu(iscsilun->bl.max_ws_len, 1333 iscsilun); 1334 } 1335 bs->bl.write_zeroes_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, 1336 iscsilun); 1337 } 1338 bs->bl.opt_transfer_length = sector_lun2qemu(iscsilun->bl.opt_xfer_len, 1339 iscsilun); 1340 return 0; 1341 } 1342 1343 /* Since iscsi_open() ignores bdrv_flags, there is nothing to do here in 1344 * prepare. Note that this will not re-establish a connection with an iSCSI 1345 * target - it is effectively a NOP. */ 1346 static int iscsi_reopen_prepare(BDRVReopenState *state, 1347 BlockReopenQueue *queue, Error **errp) 1348 { 1349 /* NOP */ 1350 return 0; 1351 } 1352 1353 static int iscsi_truncate(BlockDriverState *bs, int64_t offset) 1354 { 1355 IscsiLun *iscsilun = bs->opaque; 1356 int ret = 0; 1357 1358 if (iscsilun->type != TYPE_DISK) { 1359 return -ENOTSUP; 1360 } 1361 1362 if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) { 1363 return ret; 1364 } 1365 1366 if (offset > iscsi_getlength(bs)) { 1367 return -EINVAL; 1368 } 1369 1370 return 0; 1371 } 1372 1373 static int iscsi_create(const char *filename, QEMUOptionParameter *options, 1374 Error **errp) 1375 { 1376 int ret = 0; 1377 int64_t total_size = 0; 1378 BlockDriverState *bs; 1379 IscsiLun *iscsilun = NULL; 1380 QDict *bs_options; 1381 1382 bs = bdrv_new(""); 1383 1384 /* Read out options */ 1385 while (options && options->name) { 1386 if (!strcmp(options->name, "size")) { 1387 total_size = options->value.n / BDRV_SECTOR_SIZE; 1388 } 1389 options++; 1390 } 1391 1392 bs->opaque = g_malloc0(sizeof(struct IscsiLun)); 1393 iscsilun = bs->opaque; 1394 1395 bs_options = qdict_new(); 1396 qdict_put(bs_options, "filename", qstring_from_str(filename)); 1397 ret = iscsi_open(bs, bs_options, 0, NULL); 1398 QDECREF(bs_options); 1399 1400 if (ret != 0) { 1401 goto out; 1402 } 1403 if (iscsilun->nop_timer) { 1404 timer_del(iscsilun->nop_timer); 1405 timer_free(iscsilun->nop_timer); 1406 } 1407 if (iscsilun->type != TYPE_DISK) { 1408 ret = -ENODEV; 1409 goto out; 1410 } 1411 if (bs->total_sectors < total_size) { 1412 ret = -ENOSPC; 1413 goto out; 1414 } 1415 1416 ret = 0; 1417 out: 1418 if (iscsilun->iscsi != NULL) { 1419 iscsi_destroy_context(iscsilun->iscsi); 1420 } 1421 g_free(bs->opaque); 1422 bs->opaque = NULL; 1423 bdrv_unref(bs); 1424 return ret; 1425 } 1426 1427 static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1428 { 1429 IscsiLun *iscsilun = bs->opaque; 1430 bdi->unallocated_blocks_are_zero = !!iscsilun->lbprz; 1431 bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws; 1432 /* Guess the internal cluster (page) size of the iscsi target by the means 1433 * of opt_unmap_gran. Transfer the unmap granularity only if it has a 1434 * reasonable size for bdi->cluster_size */ 1435 if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 64 * 1024 && 1436 iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) { 1437 bdi->cluster_size = iscsilun->bl.opt_unmap_gran * iscsilun->block_size; 1438 } 1439 return 0; 1440 } 1441 1442 static QEMUOptionParameter iscsi_create_options[] = { 1443 { 1444 .name = BLOCK_OPT_SIZE, 1445 .type = OPT_SIZE, 1446 .help = "Virtual disk size" 1447 }, 1448 { NULL } 1449 }; 1450 1451 static BlockDriver bdrv_iscsi = { 1452 .format_name = "iscsi", 1453 .protocol_name = "iscsi", 1454 1455 .instance_size = sizeof(IscsiLun), 1456 .bdrv_needs_filename = true, 1457 .bdrv_file_open = iscsi_open, 1458 .bdrv_close = iscsi_close, 1459 .bdrv_create = iscsi_create, 1460 .create_options = iscsi_create_options, 1461 .bdrv_reopen_prepare = iscsi_reopen_prepare, 1462 1463 .bdrv_getlength = iscsi_getlength, 1464 .bdrv_get_info = iscsi_get_info, 1465 .bdrv_truncate = iscsi_truncate, 1466 .bdrv_refresh_limits = iscsi_refresh_limits, 1467 1468 #if defined(LIBISCSI_FEATURE_IOVECTOR) 1469 .bdrv_co_get_block_status = iscsi_co_get_block_status, 1470 #endif 1471 .bdrv_co_discard = iscsi_co_discard, 1472 #if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED) 1473 .bdrv_co_write_zeroes = iscsi_co_write_zeroes, 1474 #endif 1475 .bdrv_co_readv = iscsi_co_readv, 1476 .bdrv_co_writev = iscsi_co_writev, 1477 .bdrv_co_flush_to_disk = iscsi_co_flush, 1478 1479 #ifdef __linux__ 1480 .bdrv_ioctl = iscsi_ioctl, 1481 .bdrv_aio_ioctl = iscsi_aio_ioctl, 1482 #endif 1483 }; 1484 1485 static QemuOptsList qemu_iscsi_opts = { 1486 .name = "iscsi", 1487 .head = QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts.head), 1488 .desc = { 1489 { 1490 .name = "user", 1491 .type = QEMU_OPT_STRING, 1492 .help = "username for CHAP authentication to target", 1493 },{ 1494 .name = "password", 1495 .type = QEMU_OPT_STRING, 1496 .help = "password for CHAP authentication to target", 1497 },{ 1498 .name = "header-digest", 1499 .type = QEMU_OPT_STRING, 1500 .help = "HeaderDigest setting. " 1501 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}", 1502 },{ 1503 .name = "initiator-name", 1504 .type = QEMU_OPT_STRING, 1505 .help = "Initiator iqn name to use when connecting", 1506 }, 1507 { /* end of list */ } 1508 }, 1509 }; 1510 1511 static void iscsi_block_init(void) 1512 { 1513 bdrv_register(&bdrv_iscsi); 1514 qemu_add_opts(&qemu_iscsi_opts); 1515 } 1516 1517 block_init(iscsi_block_init); 1518