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-error.h" 31 #include "block_int.h" 32 #include "trace.h" 33 #include "hw/scsi-defs.h" 34 35 #include <iscsi/iscsi.h> 36 #include <iscsi/scsi-lowlevel.h> 37 38 39 typedef struct IscsiLun { 40 struct iscsi_context *iscsi; 41 int lun; 42 enum scsi_inquiry_peripheral_device_type type; 43 int block_size; 44 uint64_t num_blocks; 45 int events; 46 } IscsiLun; 47 48 typedef struct IscsiAIOCB { 49 BlockDriverAIOCB common; 50 QEMUIOVector *qiov; 51 QEMUBH *bh; 52 IscsiLun *iscsilun; 53 struct scsi_task *task; 54 uint8_t *buf; 55 int status; 56 int canceled; 57 size_t read_size; 58 size_t read_offset; 59 } IscsiAIOCB; 60 61 struct IscsiTask { 62 IscsiLun *iscsilun; 63 BlockDriverState *bs; 64 int status; 65 int complete; 66 }; 67 68 static void 69 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data, 70 void *private_data) 71 { 72 } 73 74 static void 75 iscsi_aio_cancel(BlockDriverAIOCB *blockacb) 76 { 77 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; 78 IscsiLun *iscsilun = acb->iscsilun; 79 80 acb->common.cb(acb->common.opaque, -ECANCELED); 81 acb->canceled = 1; 82 83 /* send a task mgmt call to the target to cancel the task on the target */ 84 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task, 85 iscsi_abort_task_cb, NULL); 86 87 /* then also cancel the task locally in libiscsi */ 88 iscsi_scsi_task_cancel(iscsilun->iscsi, acb->task); 89 } 90 91 static AIOPool iscsi_aio_pool = { 92 .aiocb_size = sizeof(IscsiAIOCB), 93 .cancel = iscsi_aio_cancel, 94 }; 95 96 97 static void iscsi_process_read(void *arg); 98 static void iscsi_process_write(void *arg); 99 100 static int iscsi_process_flush(void *arg) 101 { 102 IscsiLun *iscsilun = arg; 103 104 return iscsi_queue_length(iscsilun->iscsi) > 0; 105 } 106 107 static void 108 iscsi_set_events(IscsiLun *iscsilun) 109 { 110 struct iscsi_context *iscsi = iscsilun->iscsi; 111 int ev; 112 113 /* We always register a read handler. */ 114 ev = POLLIN; 115 ev |= iscsi_which_events(iscsi); 116 if (ev != iscsilun->events) { 117 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), 118 iscsi_process_read, 119 (ev & POLLOUT) ? iscsi_process_write : NULL, 120 iscsi_process_flush, 121 iscsilun); 122 123 } 124 125 /* If we just added an event, the callback might be delayed 126 * unless we call qemu_notify_event(). 127 */ 128 if (ev & ~iscsilun->events) { 129 qemu_notify_event(); 130 } 131 iscsilun->events = ev; 132 } 133 134 static void 135 iscsi_process_read(void *arg) 136 { 137 IscsiLun *iscsilun = arg; 138 struct iscsi_context *iscsi = iscsilun->iscsi; 139 140 iscsi_service(iscsi, POLLIN); 141 iscsi_set_events(iscsilun); 142 } 143 144 static void 145 iscsi_process_write(void *arg) 146 { 147 IscsiLun *iscsilun = arg; 148 struct iscsi_context *iscsi = iscsilun->iscsi; 149 150 iscsi_service(iscsi, POLLOUT); 151 iscsi_set_events(iscsilun); 152 } 153 154 155 static int 156 iscsi_schedule_bh(QEMUBHFunc *cb, IscsiAIOCB *acb) 157 { 158 acb->bh = qemu_bh_new(cb, acb); 159 if (!acb->bh) { 160 error_report("oom: could not create iscsi bh"); 161 return -EIO; 162 } 163 164 qemu_bh_schedule(acb->bh); 165 return 0; 166 } 167 168 static void 169 iscsi_readv_writev_bh_cb(void *p) 170 { 171 IscsiAIOCB *acb = p; 172 173 qemu_bh_delete(acb->bh); 174 175 if (acb->canceled == 0) { 176 acb->common.cb(acb->common.opaque, acb->status); 177 } 178 179 qemu_aio_release(acb); 180 } 181 182 183 static void 184 iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status, 185 void *command_data, void *opaque) 186 { 187 IscsiAIOCB *acb = opaque; 188 189 trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled); 190 191 g_free(acb->buf); 192 193 if (acb->canceled != 0) { 194 qemu_aio_release(acb); 195 scsi_free_scsi_task(acb->task); 196 acb->task = NULL; 197 return; 198 } 199 200 acb->status = 0; 201 if (status < 0) { 202 error_report("Failed to write16 data to iSCSI lun. %s", 203 iscsi_get_error(iscsi)); 204 acb->status = -EIO; 205 } 206 207 iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb); 208 scsi_free_scsi_task(acb->task); 209 acb->task = NULL; 210 } 211 212 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun) 213 { 214 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size; 215 } 216 217 static BlockDriverAIOCB * 218 iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num, 219 QEMUIOVector *qiov, int nb_sectors, 220 BlockDriverCompletionFunc *cb, 221 void *opaque) 222 { 223 IscsiLun *iscsilun = bs->opaque; 224 struct iscsi_context *iscsi = iscsilun->iscsi; 225 IscsiAIOCB *acb; 226 size_t size; 227 uint32_t num_sectors; 228 uint64_t lba; 229 struct iscsi_data data; 230 231 acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); 232 trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb); 233 234 acb->iscsilun = iscsilun; 235 acb->qiov = qiov; 236 237 acb->canceled = 0; 238 239 /* XXX we should pass the iovec to write16 to avoid the extra copy */ 240 /* this will allow us to get rid of 'buf' completely */ 241 size = nb_sectors * BDRV_SECTOR_SIZE; 242 acb->buf = g_malloc(size); 243 qemu_iovec_to_buffer(acb->qiov, acb->buf); 244 245 246 acb->task = malloc(sizeof(struct scsi_task)); 247 if (acb->task == NULL) { 248 error_report("iSCSI: Failed to allocate task for scsi WRITE16 " 249 "command. %s", iscsi_get_error(iscsi)); 250 qemu_aio_release(acb); 251 return NULL; 252 } 253 memset(acb->task, 0, sizeof(struct scsi_task)); 254 255 acb->task->xfer_dir = SCSI_XFER_WRITE; 256 acb->task->cdb_size = 16; 257 acb->task->cdb[0] = 0x8a; 258 if (!(bs->open_flags & BDRV_O_CACHE_WB)) { 259 /* set FUA on writes when cache mode is write through */ 260 acb->task->cdb[1] |= 0x04; 261 } 262 lba = sector_qemu2lun(sector_num, iscsilun); 263 *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32); 264 *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff); 265 num_sectors = size / iscsilun->block_size; 266 *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors); 267 acb->task->expxferlen = size; 268 269 data.data = acb->buf; 270 data.size = size; 271 272 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, 273 iscsi_aio_write16_cb, 274 &data, 275 acb) != 0) { 276 scsi_free_scsi_task(acb->task); 277 g_free(acb->buf); 278 qemu_aio_release(acb); 279 return NULL; 280 } 281 282 iscsi_set_events(iscsilun); 283 284 return &acb->common; 285 } 286 287 static void 288 iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status, 289 void *command_data, void *opaque) 290 { 291 IscsiAIOCB *acb = opaque; 292 293 trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled); 294 295 if (acb->canceled != 0) { 296 qemu_aio_release(acb); 297 scsi_free_scsi_task(acb->task); 298 acb->task = NULL; 299 return; 300 } 301 302 acb->status = 0; 303 if (status != 0) { 304 error_report("Failed to read16 data from iSCSI lun. %s", 305 iscsi_get_error(iscsi)); 306 acb->status = -EIO; 307 } 308 309 iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb); 310 scsi_free_scsi_task(acb->task); 311 acb->task = NULL; 312 } 313 314 static BlockDriverAIOCB * 315 iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num, 316 QEMUIOVector *qiov, int nb_sectors, 317 BlockDriverCompletionFunc *cb, 318 void *opaque) 319 { 320 IscsiLun *iscsilun = bs->opaque; 321 struct iscsi_context *iscsi = iscsilun->iscsi; 322 IscsiAIOCB *acb; 323 size_t qemu_read_size; 324 int i; 325 uint64_t lba; 326 uint32_t num_sectors; 327 328 qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors; 329 330 acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); 331 trace_iscsi_aio_readv(iscsi, sector_num, nb_sectors, opaque, acb); 332 333 acb->iscsilun = iscsilun; 334 acb->qiov = qiov; 335 336 acb->canceled = 0; 337 acb->read_size = qemu_read_size; 338 acb->buf = NULL; 339 340 /* If LUN blocksize is bigger than BDRV_BLOCK_SIZE a read from QEMU 341 * may be misaligned to the LUN, so we may need to read some extra 342 * data. 343 */ 344 acb->read_offset = 0; 345 if (iscsilun->block_size > BDRV_SECTOR_SIZE) { 346 uint64_t bdrv_offset = BDRV_SECTOR_SIZE * sector_num; 347 348 acb->read_offset = bdrv_offset % iscsilun->block_size; 349 } 350 351 num_sectors = (qemu_read_size + iscsilun->block_size 352 + acb->read_offset - 1) 353 / iscsilun->block_size; 354 355 acb->task = malloc(sizeof(struct scsi_task)); 356 if (acb->task == NULL) { 357 error_report("iSCSI: Failed to allocate task for scsi READ16 " 358 "command. %s", iscsi_get_error(iscsi)); 359 qemu_aio_release(acb); 360 return NULL; 361 } 362 memset(acb->task, 0, sizeof(struct scsi_task)); 363 364 acb->task->xfer_dir = SCSI_XFER_READ; 365 lba = sector_qemu2lun(sector_num, iscsilun); 366 acb->task->expxferlen = qemu_read_size; 367 368 switch (iscsilun->type) { 369 case TYPE_DISK: 370 acb->task->cdb_size = 16; 371 acb->task->cdb[0] = 0x88; 372 *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32); 373 *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff); 374 *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors); 375 break; 376 default: 377 acb->task->cdb_size = 10; 378 acb->task->cdb[0] = 0x28; 379 *(uint32_t *)&acb->task->cdb[2] = htonl(lba); 380 *(uint16_t *)&acb->task->cdb[7] = htons(num_sectors); 381 break; 382 } 383 384 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, 385 iscsi_aio_read16_cb, 386 NULL, 387 acb) != 0) { 388 scsi_free_scsi_task(acb->task); 389 qemu_aio_release(acb); 390 return NULL; 391 } 392 393 for (i = 0; i < acb->qiov->niov; i++) { 394 scsi_task_add_data_in_buffer(acb->task, 395 acb->qiov->iov[i].iov_len, 396 acb->qiov->iov[i].iov_base); 397 } 398 399 iscsi_set_events(iscsilun); 400 401 return &acb->common; 402 } 403 404 405 static void 406 iscsi_synccache10_cb(struct iscsi_context *iscsi, int status, 407 void *command_data, void *opaque) 408 { 409 IscsiAIOCB *acb = opaque; 410 411 if (acb->canceled != 0) { 412 qemu_aio_release(acb); 413 scsi_free_scsi_task(acb->task); 414 acb->task = NULL; 415 return; 416 } 417 418 acb->status = 0; 419 if (status < 0) { 420 error_report("Failed to sync10 data on iSCSI lun. %s", 421 iscsi_get_error(iscsi)); 422 acb->status = -EIO; 423 } 424 425 iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb); 426 scsi_free_scsi_task(acb->task); 427 acb->task = NULL; 428 } 429 430 static BlockDriverAIOCB * 431 iscsi_aio_flush(BlockDriverState *bs, 432 BlockDriverCompletionFunc *cb, void *opaque) 433 { 434 IscsiLun *iscsilun = bs->opaque; 435 struct iscsi_context *iscsi = iscsilun->iscsi; 436 IscsiAIOCB *acb; 437 438 acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); 439 440 acb->iscsilun = iscsilun; 441 acb->canceled = 0; 442 443 acb->task = iscsi_synchronizecache10_task(iscsi, iscsilun->lun, 444 0, 0, 0, 0, 445 iscsi_synccache10_cb, 446 acb); 447 if (acb->task == NULL) { 448 error_report("iSCSI: Failed to send synchronizecache10 command. %s", 449 iscsi_get_error(iscsi)); 450 qemu_aio_release(acb); 451 return NULL; 452 } 453 454 iscsi_set_events(iscsilun); 455 456 return &acb->common; 457 } 458 459 static void 460 iscsi_unmap_cb(struct iscsi_context *iscsi, int status, 461 void *command_data, void *opaque) 462 { 463 IscsiAIOCB *acb = opaque; 464 465 if (acb->canceled != 0) { 466 qemu_aio_release(acb); 467 scsi_free_scsi_task(acb->task); 468 acb->task = NULL; 469 return; 470 } 471 472 acb->status = 0; 473 if (status < 0) { 474 error_report("Failed to unmap data on iSCSI lun. %s", 475 iscsi_get_error(iscsi)); 476 acb->status = -EIO; 477 } 478 479 iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb); 480 scsi_free_scsi_task(acb->task); 481 acb->task = NULL; 482 } 483 484 static BlockDriverAIOCB * 485 iscsi_aio_discard(BlockDriverState *bs, 486 int64_t sector_num, int nb_sectors, 487 BlockDriverCompletionFunc *cb, void *opaque) 488 { 489 IscsiLun *iscsilun = bs->opaque; 490 struct iscsi_context *iscsi = iscsilun->iscsi; 491 IscsiAIOCB *acb; 492 struct unmap_list list[1]; 493 494 acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); 495 496 acb->iscsilun = iscsilun; 497 acb->canceled = 0; 498 499 list[0].lba = sector_qemu2lun(sector_num, iscsilun); 500 list[0].num = nb_sectors * BDRV_SECTOR_SIZE / iscsilun->block_size; 501 502 acb->task = iscsi_unmap_task(iscsi, iscsilun->lun, 503 0, 0, &list[0], 1, 504 iscsi_unmap_cb, 505 acb); 506 if (acb->task == NULL) { 507 error_report("iSCSI: Failed to send unmap command. %s", 508 iscsi_get_error(iscsi)); 509 qemu_aio_release(acb); 510 return NULL; 511 } 512 513 iscsi_set_events(iscsilun); 514 515 return &acb->common; 516 } 517 518 static int64_t 519 iscsi_getlength(BlockDriverState *bs) 520 { 521 IscsiLun *iscsilun = bs->opaque; 522 int64_t len; 523 524 len = iscsilun->num_blocks; 525 len *= iscsilun->block_size; 526 527 return len; 528 } 529 530 static void 531 iscsi_readcapacity16_cb(struct iscsi_context *iscsi, int status, 532 void *command_data, void *opaque) 533 { 534 struct IscsiTask *itask = opaque; 535 struct scsi_readcapacity16 *rc16; 536 struct scsi_task *task = command_data; 537 538 if (status != 0) { 539 error_report("iSCSI: Failed to read capacity of iSCSI lun. %s", 540 iscsi_get_error(iscsi)); 541 itask->status = 1; 542 itask->complete = 1; 543 scsi_free_scsi_task(task); 544 return; 545 } 546 547 rc16 = scsi_datain_unmarshall(task); 548 if (rc16 == NULL) { 549 error_report("iSCSI: Failed to unmarshall readcapacity16 data."); 550 itask->status = 1; 551 itask->complete = 1; 552 scsi_free_scsi_task(task); 553 return; 554 } 555 556 itask->iscsilun->block_size = rc16->block_length; 557 itask->iscsilun->num_blocks = rc16->returned_lba + 1; 558 itask->bs->total_sectors = itask->iscsilun->num_blocks * 559 itask->iscsilun->block_size / BDRV_SECTOR_SIZE ; 560 561 itask->status = 0; 562 itask->complete = 1; 563 scsi_free_scsi_task(task); 564 } 565 566 static void 567 iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status, 568 void *command_data, void *opaque) 569 { 570 struct IscsiTask *itask = opaque; 571 struct scsi_readcapacity10 *rc10; 572 struct scsi_task *task = command_data; 573 574 if (status != 0) { 575 error_report("iSCSI: Failed to read capacity of iSCSI lun. %s", 576 iscsi_get_error(iscsi)); 577 itask->status = 1; 578 itask->complete = 1; 579 scsi_free_scsi_task(task); 580 return; 581 } 582 583 rc10 = scsi_datain_unmarshall(task); 584 if (rc10 == NULL) { 585 error_report("iSCSI: Failed to unmarshall readcapacity10 data."); 586 itask->status = 1; 587 itask->complete = 1; 588 scsi_free_scsi_task(task); 589 return; 590 } 591 592 itask->iscsilun->block_size = rc10->block_size; 593 itask->iscsilun->num_blocks = rc10->lba + 1; 594 itask->bs->total_sectors = itask->iscsilun->num_blocks * 595 itask->iscsilun->block_size / BDRV_SECTOR_SIZE ; 596 597 itask->status = 0; 598 itask->complete = 1; 599 scsi_free_scsi_task(task); 600 } 601 602 static void 603 iscsi_inquiry_cb(struct iscsi_context *iscsi, int status, void *command_data, 604 void *opaque) 605 { 606 struct IscsiTask *itask = opaque; 607 struct scsi_task *task = command_data; 608 struct scsi_inquiry_standard *inq; 609 610 if (status != 0) { 611 itask->status = 1; 612 itask->complete = 1; 613 scsi_free_scsi_task(task); 614 return; 615 } 616 617 inq = scsi_datain_unmarshall(task); 618 if (inq == NULL) { 619 error_report("iSCSI: Failed to unmarshall inquiry data."); 620 itask->status = 1; 621 itask->complete = 1; 622 scsi_free_scsi_task(task); 623 return; 624 } 625 626 itask->iscsilun->type = inq->periperal_device_type; 627 628 scsi_free_scsi_task(task); 629 630 switch (itask->iscsilun->type) { 631 case TYPE_DISK: 632 task = iscsi_readcapacity16_task(iscsi, itask->iscsilun->lun, 633 iscsi_readcapacity16_cb, opaque); 634 if (task == NULL) { 635 error_report("iSCSI: failed to send readcapacity16 command."); 636 itask->status = 1; 637 itask->complete = 1; 638 return; 639 } 640 break; 641 case TYPE_ROM: 642 task = iscsi_readcapacity10_task(iscsi, itask->iscsilun->lun, 643 0, 0, 644 iscsi_readcapacity10_cb, opaque); 645 if (task == NULL) { 646 error_report("iSCSI: failed to send readcapacity16 command."); 647 itask->status = 1; 648 itask->complete = 1; 649 return; 650 } 651 break; 652 default: 653 itask->status = 0; 654 itask->complete = 1; 655 } 656 } 657 658 static void 659 iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data, 660 void *opaque) 661 { 662 struct IscsiTask *itask = opaque; 663 struct scsi_task *task; 664 665 if (status != 0) { 666 itask->status = 1; 667 itask->complete = 1; 668 return; 669 } 670 671 task = iscsi_inquiry_task(iscsi, itask->iscsilun->lun, 672 0, 0, 36, 673 iscsi_inquiry_cb, opaque); 674 if (task == NULL) { 675 error_report("iSCSI: failed to send inquiry command."); 676 itask->status = 1; 677 itask->complete = 1; 678 return; 679 } 680 } 681 682 static int parse_chap(struct iscsi_context *iscsi, const char *target) 683 { 684 QemuOptsList *list; 685 QemuOpts *opts; 686 const char *user = NULL; 687 const char *password = NULL; 688 689 list = qemu_find_opts("iscsi"); 690 if (!list) { 691 return 0; 692 } 693 694 opts = qemu_opts_find(list, target); 695 if (opts == NULL) { 696 opts = QTAILQ_FIRST(&list->head); 697 if (!opts) { 698 return 0; 699 } 700 } 701 702 user = qemu_opt_get(opts, "user"); 703 if (!user) { 704 return 0; 705 } 706 707 password = qemu_opt_get(opts, "password"); 708 if (!password) { 709 error_report("CHAP username specified but no password was given"); 710 return -1; 711 } 712 713 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) { 714 error_report("Failed to set initiator username and password"); 715 return -1; 716 } 717 718 return 0; 719 } 720 721 static void parse_header_digest(struct iscsi_context *iscsi, const char *target) 722 { 723 QemuOptsList *list; 724 QemuOpts *opts; 725 const char *digest = NULL; 726 727 list = qemu_find_opts("iscsi"); 728 if (!list) { 729 return; 730 } 731 732 opts = qemu_opts_find(list, target); 733 if (opts == NULL) { 734 opts = QTAILQ_FIRST(&list->head); 735 if (!opts) { 736 return; 737 } 738 } 739 740 digest = qemu_opt_get(opts, "header-digest"); 741 if (!digest) { 742 return; 743 } 744 745 if (!strcmp(digest, "CRC32C")) { 746 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C); 747 } else if (!strcmp(digest, "NONE")) { 748 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE); 749 } else if (!strcmp(digest, "CRC32C-NONE")) { 750 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE); 751 } else if (!strcmp(digest, "NONE-CRC32C")) { 752 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 753 } else { 754 error_report("Invalid header-digest setting : %s", digest); 755 } 756 } 757 758 static char *parse_initiator_name(const char *target) 759 { 760 QemuOptsList *list; 761 QemuOpts *opts; 762 const char *name = NULL; 763 764 list = qemu_find_opts("iscsi"); 765 if (!list) { 766 return g_strdup("iqn.2008-11.org.linux-kvm"); 767 } 768 769 opts = qemu_opts_find(list, target); 770 if (opts == NULL) { 771 opts = QTAILQ_FIRST(&list->head); 772 if (!opts) { 773 return g_strdup("iqn.2008-11.org.linux-kvm"); 774 } 775 } 776 777 name = qemu_opt_get(opts, "initiator-name"); 778 if (!name) { 779 return g_strdup("iqn.2008-11.org.linux-kvm"); 780 } 781 782 return g_strdup(name); 783 } 784 785 /* 786 * We support iscsi url's on the form 787 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun> 788 */ 789 static int iscsi_open(BlockDriverState *bs, const char *filename, int flags) 790 { 791 IscsiLun *iscsilun = bs->opaque; 792 struct iscsi_context *iscsi = NULL; 793 struct iscsi_url *iscsi_url = NULL; 794 struct IscsiTask task; 795 char *initiator_name = NULL; 796 int ret; 797 798 if ((BDRV_SECTOR_SIZE % 512) != 0) { 799 error_report("iSCSI: Invalid BDRV_SECTOR_SIZE. " 800 "BDRV_SECTOR_SIZE(%lld) is not a multiple " 801 "of 512", BDRV_SECTOR_SIZE); 802 return -EINVAL; 803 } 804 805 iscsi_url = iscsi_parse_full_url(iscsi, filename); 806 if (iscsi_url == NULL) { 807 error_report("Failed to parse URL : %s %s", filename, 808 iscsi_get_error(iscsi)); 809 ret = -EINVAL; 810 goto failed; 811 } 812 813 memset(iscsilun, 0, sizeof(IscsiLun)); 814 815 initiator_name = parse_initiator_name(iscsi_url->target); 816 817 iscsi = iscsi_create_context(initiator_name); 818 if (iscsi == NULL) { 819 error_report("iSCSI: Failed to create iSCSI context."); 820 ret = -ENOMEM; 821 goto failed; 822 } 823 824 if (iscsi_set_targetname(iscsi, iscsi_url->target)) { 825 error_report("iSCSI: Failed to set target name."); 826 ret = -EINVAL; 827 goto failed; 828 } 829 830 if (iscsi_url->user != NULL) { 831 ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user, 832 iscsi_url->passwd); 833 if (ret != 0) { 834 error_report("Failed to set initiator username and password"); 835 ret = -EINVAL; 836 goto failed; 837 } 838 } 839 840 /* check if we got CHAP username/password via the options */ 841 if (parse_chap(iscsi, iscsi_url->target) != 0) { 842 error_report("iSCSI: Failed to set CHAP user/password"); 843 ret = -EINVAL; 844 goto failed; 845 } 846 847 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) { 848 error_report("iSCSI: Failed to set session type to normal."); 849 ret = -EINVAL; 850 goto failed; 851 } 852 853 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 854 855 /* check if we got HEADER_DIGEST via the options */ 856 parse_header_digest(iscsi, iscsi_url->target); 857 858 task.iscsilun = iscsilun; 859 task.status = 0; 860 task.complete = 0; 861 task.bs = bs; 862 863 iscsilun->iscsi = iscsi; 864 iscsilun->lun = iscsi_url->lun; 865 866 if (iscsi_full_connect_async(iscsi, iscsi_url->portal, iscsi_url->lun, 867 iscsi_connect_cb, &task) 868 != 0) { 869 error_report("iSCSI: Failed to start async connect."); 870 ret = -EINVAL; 871 goto failed; 872 } 873 874 while (!task.complete) { 875 iscsi_set_events(iscsilun); 876 qemu_aio_wait(); 877 } 878 if (task.status != 0) { 879 error_report("iSCSI: Failed to connect to LUN : %s", 880 iscsi_get_error(iscsi)); 881 ret = -EINVAL; 882 goto failed; 883 } 884 885 if (iscsi_url != NULL) { 886 iscsi_destroy_url(iscsi_url); 887 } 888 return 0; 889 890 failed: 891 if (initiator_name != NULL) { 892 g_free(initiator_name); 893 } 894 if (iscsi_url != NULL) { 895 iscsi_destroy_url(iscsi_url); 896 } 897 if (iscsi != NULL) { 898 iscsi_destroy_context(iscsi); 899 } 900 memset(iscsilun, 0, sizeof(IscsiLun)); 901 return ret; 902 } 903 904 static void iscsi_close(BlockDriverState *bs) 905 { 906 IscsiLun *iscsilun = bs->opaque; 907 struct iscsi_context *iscsi = iscsilun->iscsi; 908 909 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL, NULL); 910 iscsi_destroy_context(iscsi); 911 memset(iscsilun, 0, sizeof(IscsiLun)); 912 } 913 914 static BlockDriver bdrv_iscsi = { 915 .format_name = "iscsi", 916 .protocol_name = "iscsi", 917 918 .instance_size = sizeof(IscsiLun), 919 .bdrv_file_open = iscsi_open, 920 .bdrv_close = iscsi_close, 921 922 .bdrv_getlength = iscsi_getlength, 923 924 .bdrv_aio_readv = iscsi_aio_readv, 925 .bdrv_aio_writev = iscsi_aio_writev, 926 .bdrv_aio_flush = iscsi_aio_flush, 927 928 .bdrv_aio_discard = iscsi_aio_discard, 929 }; 930 931 static void iscsi_block_init(void) 932 { 933 bdrv_register(&bdrv_iscsi); 934 } 935 936 block_init(iscsi_block_init); 937