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