block/iscsi.c

   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 "qemu-common.h"
  29 #include "qemu-error.h"
  30 #include "block_int.h"
  31 #include "trace.h"
  32
  33 #include <iscsi/iscsi.h>
  34 #include <iscsi/scsi-lowlevel.h>
  35
  36
  37 typedef struct IscsiLun {
  38     struct iscsi_context *iscsi;
  39     int lun;
  40     int block_size;
  41     unsigned long num_blocks;
  42 } IscsiLun;
  43
  44 typedef struct IscsiAIOCB {
  45     BlockDriverAIOCB common;
  46     QEMUIOVector *qiov;
  47     QEMUBH *bh;
  48     IscsiLun *iscsilun;
  49     struct scsi_task *task;
  50     uint8_t *buf;
  51     int status;
  52     int canceled;
  53     size_t read_size;
  54     size_t read_offset;
  55 } IscsiAIOCB;
  56
  57 struct IscsiTask {
  58     IscsiLun *iscsilun;
  59     BlockDriverState *bs;
  60     int status;
  61     int complete;
  62 };
  63
  64 static void
  65 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
  66                     void *private_data)
  67 {
  68 }
  69
  70 static void
  71 iscsi_aio_cancel(BlockDriverAIOCB *blockacb)
  72 {
  73     IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
  74     IscsiLun *iscsilun = acb->iscsilun;
  75
  76     acb->common.cb(acb->common.opaque, -ECANCELED);
  77     acb->canceled = 1;
  78
  79     /* send a task mgmt call to the target to cancel the task on the target */
  80     iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
  81                                      iscsi_abort_task_cb, NULL);
  82
  83     /* then also cancel the task locally in libiscsi */
  84     iscsi_scsi_task_cancel(iscsilun->iscsi, acb->task);
  85 }
  86
  87 static AIOPool iscsi_aio_pool = {
  88     .aiocb_size         = sizeof(IscsiAIOCB),
  89     .cancel             = iscsi_aio_cancel,
  90 };
  91
  92
  93 static void iscsi_process_read(void *arg);
  94 static void iscsi_process_write(void *arg);
  95
  96 static int iscsi_process_flush(void *arg)
  97 {
  98     IscsiLun *iscsilun = arg;
  99
 100     return iscsi_queue_length(iscsilun->iscsi) > 0;
 101 }
 102
 103 static void
 104 iscsi_set_events(IscsiLun *iscsilun)
 105 {
 106     struct iscsi_context *iscsi = iscsilun->iscsi;
 107
 108     qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), iscsi_process_read,
 109                            (iscsi_which_events(iscsi) & POLLOUT)
 110                            ? iscsi_process_write : NULL,
 111                            iscsi_process_flush, NULL, iscsilun);
 112 }
 113
 114 static void
 115 iscsi_process_read(void *arg)
 116 {
 117     IscsiLun *iscsilun = arg;
 118     struct iscsi_context *iscsi = iscsilun->iscsi;
 119
 120     iscsi_service(iscsi, POLLIN);
 121     iscsi_set_events(iscsilun);
 122 }
 123
 124 static void
 125 iscsi_process_write(void *arg)
 126 {
 127     IscsiLun *iscsilun = arg;
 128     struct iscsi_context *iscsi = iscsilun->iscsi;
 129
 130     iscsi_service(iscsi, POLLOUT);
 131     iscsi_set_events(iscsilun);
 132 }
 133
 134
 135 static int
 136 iscsi_schedule_bh(QEMUBHFunc *cb, IscsiAIOCB *acb)
 137 {
 138     acb->bh = qemu_bh_new(cb, acb);
 139     if (!acb->bh) {
 140         error_report("oom: could not create iscsi bh");
 141         return -EIO;
 142     }
 143
 144     qemu_bh_schedule(acb->bh);
 145     return 0;
 146 }
 147
 148 static void
 149 iscsi_readv_writev_bh_cb(void *p)
 150 {
 151     IscsiAIOCB *acb = p;
 152
 153     qemu_bh_delete(acb->bh);
 154
 155     if (acb->canceled == 0) {
 156         acb->common.cb(acb->common.opaque, acb->status);
 157     }
 158
 159     qemu_aio_release(acb);
 160 }
 161
 162
 163 static void
 164 iscsi_aio_write10_cb(struct iscsi_context *iscsi, int status,
 165                      void *command_data, void *opaque)
 166 {
 167     IscsiAIOCB *acb = opaque;
 168
 169     trace_iscsi_aio_write10_cb(iscsi, status, acb, acb->canceled);
 170
 171     g_free(acb->buf);
 172
 173     if (acb->canceled != 0) {
 174         qemu_aio_release(acb);
 175         scsi_free_scsi_task(acb->task);
 176         acb->task = NULL;
 177         return;
 178     }
 179
 180     acb->status = 0;
 181     if (status < 0) {
 182         error_report("Failed to write10 data to iSCSI lun. %s",
 183                      iscsi_get_error(iscsi));
 184         acb->status = -EIO;
 185     }
 186
 187     iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb);
 188     scsi_free_scsi_task(acb->task);
 189     acb->task = NULL;
 190 }
 191
 192 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
 193 {
 194     return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
 195 }
 196
 197 static BlockDriverAIOCB *
 198 iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num,
 199                  QEMUIOVector *qiov, int nb_sectors,
 200                  BlockDriverCompletionFunc *cb,
 201                  void *opaque)
 202 {
 203     IscsiLun *iscsilun = bs->opaque;
 204     struct iscsi_context *iscsi = iscsilun->iscsi;
 205     IscsiAIOCB *acb;
 206     size_t size;
 207     int fua = 0;
 208
 209     /* set FUA on writes when cache mode is write through */
 210     if (!(bs->open_flags & BDRV_O_CACHE_WB)) {
 211         fua = 1;
 212     }
 213
 214     acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);
 215     trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb);
 216
 217     acb->iscsilun = iscsilun;
 218     acb->qiov     = qiov;
 219
 220     acb->canceled   = 0;
 221
 222     /* XXX we should pass the iovec to write10 to avoid the extra copy */
 223     /* this will allow us to get rid of 'buf' completely */
 224     size = nb_sectors * BDRV_SECTOR_SIZE;
 225     acb->buf = g_malloc(size);
 226     qemu_iovec_to_buffer(acb->qiov, acb->buf);
 227     acb->task = iscsi_write10_task(iscsi, iscsilun->lun, acb->buf, size,
 228                               sector_qemu2lun(sector_num, iscsilun),
 229                               fua, 0, iscsilun->block_size,
 230                               iscsi_aio_write10_cb, acb);
 231     if (acb->task == NULL) {
 232         error_report("iSCSI: Failed to send write10 command. %s",
 233                      iscsi_get_error(iscsi));
 234         g_free(acb->buf);
 235         qemu_aio_release(acb);
 236         return NULL;
 237     }
 238
 239     iscsi_set_events(iscsilun);
 240
 241     return &acb->common;
 242 }
 243
 244 static void
 245 iscsi_aio_read10_cb(struct iscsi_context *iscsi, int status,
 246                     void *command_data, void *opaque)
 247 {
 248     IscsiAIOCB *acb = opaque;
 249
 250     trace_iscsi_aio_read10_cb(iscsi, status, acb, acb->canceled);
 251
 252     if (acb->canceled != 0) {
 253         qemu_aio_release(acb);
 254         scsi_free_scsi_task(acb->task);
 255         acb->task = NULL;
 256         return;
 257     }
 258
 259     acb->status = 0;
 260     if (status != 0) {
 261         error_report("Failed to read10 data from iSCSI lun. %s",
 262                      iscsi_get_error(iscsi));
 263         acb->status = -EIO;
 264     }
 265
 266     iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb);
 267     scsi_free_scsi_task(acb->task);
 268     acb->task = NULL;
 269 }
 270
 271 static BlockDriverAIOCB *
 272 iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num,
 273                 QEMUIOVector *qiov, int nb_sectors,
 274                 BlockDriverCompletionFunc *cb,
 275                 void *opaque)
 276 {
 277     IscsiLun *iscsilun = bs->opaque;
 278     struct iscsi_context *iscsi = iscsilun->iscsi;
 279     IscsiAIOCB *acb;
 280     size_t qemu_read_size, lun_read_size;
 281     int i;
 282
 283     qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors;
 284
 285     acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);
 286     trace_iscsi_aio_readv(iscsi, sector_num, nb_sectors, opaque, acb);
 287
 288     acb->iscsilun = iscsilun;
 289     acb->qiov     = qiov;
 290
 291     acb->canceled    = 0;
 292     acb->read_size   = qemu_read_size;
 293     acb->buf         = NULL;
 294
 295     /* If LUN blocksize is bigger than BDRV_BLOCK_SIZE a read from QEMU
 296      * may be misaligned to the LUN, so we may need to read some extra
 297      * data.
 298      */
 299     acb->read_offset = 0;
 300     if (iscsilun->block_size > BDRV_SECTOR_SIZE) {
 301         uint64_t bdrv_offset = BDRV_SECTOR_SIZE * sector_num;
 302
 303         acb->read_offset  = bdrv_offset % iscsilun->block_size;
 304     }
 305
 306     lun_read_size  = (qemu_read_size + iscsilun->block_size
 307                      + acb->read_offset - 1)
 308                      / iscsilun->block_size * iscsilun->block_size;
 309     acb->task = iscsi_read10_task(iscsi, iscsilun->lun,
 310                              sector_qemu2lun(sector_num, iscsilun),
 311                              lun_read_size, iscsilun->block_size,
 312                              iscsi_aio_read10_cb, acb);
 313     if (acb->task == NULL) {
 314         error_report("iSCSI: Failed to send read10 command. %s",
 315                      iscsi_get_error(iscsi));
 316         qemu_aio_release(acb);
 317         return NULL;
 318     }
 319
 320     for (i = 0; i < acb->qiov->niov; i++) {
 321         scsi_task_add_data_in_buffer(acb->task,
 322                 acb->qiov->iov[i].iov_len,
 323                 acb->qiov->iov[i].iov_base);
 324     }
 325
 326     iscsi_set_events(iscsilun);
 327
 328     return &acb->common;
 329 }
 330
 331
 332 static void
 333 iscsi_synccache10_cb(struct iscsi_context *iscsi, int status,
 334                      void *command_data, void *opaque)
 335 {
 336     IscsiAIOCB *acb = opaque;
 337
 338     if (acb->canceled != 0) {
 339         qemu_aio_release(acb);
 340         scsi_free_scsi_task(acb->task);
 341         acb->task = NULL;
 342         return;
 343     }
 344
 345     acb->status = 0;
 346     if (status < 0) {
 347         error_report("Failed to sync10 data on iSCSI lun. %s",
 348                      iscsi_get_error(iscsi));
 349         acb->status = -EIO;
 350     }
 351
 352     iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb);
 353     scsi_free_scsi_task(acb->task);
 354     acb->task = NULL;
 355 }
 356
 357 static BlockDriverAIOCB *
 358 iscsi_aio_flush(BlockDriverState *bs,
 359                 BlockDriverCompletionFunc *cb, void *opaque)
 360 {
 361     IscsiLun *iscsilun = bs->opaque;
 362     struct iscsi_context *iscsi = iscsilun->iscsi;
 363     IscsiAIOCB *acb;
 364
 365     acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);
 366
 367     acb->iscsilun = iscsilun;
 368     acb->canceled   = 0;
 369
 370     acb->task = iscsi_synchronizecache10_task(iscsi, iscsilun->lun,
 371                                          0, 0, 0, 0,
 372                                          iscsi_synccache10_cb,
 373                                          acb);
 374     if (acb->task == NULL) {
 375         error_report("iSCSI: Failed to send synchronizecache10 command. %s",
 376                      iscsi_get_error(iscsi));
 377         qemu_aio_release(acb);
 378         return NULL;
 379     }
 380
 381     iscsi_set_events(iscsilun);
 382
 383     return &acb->common;
 384 }
 385
 386 static int64_t
 387 iscsi_getlength(BlockDriverState *bs)
 388 {
 389     IscsiLun *iscsilun = bs->opaque;
 390     int64_t len;
 391
 392     len  = iscsilun->num_blocks;
 393     len *= iscsilun->block_size;
 394
 395     return len;
 396 }
 397
 398 static void
 399 iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status,
 400                         void *command_data, void *opaque)
 401 {
 402     struct IscsiTask *itask = opaque;
 403     struct scsi_readcapacity10 *rc10;
 404     struct scsi_task *task = command_data;
 405
 406     if (status != 0) {
 407         error_report("iSCSI: Failed to read capacity of iSCSI lun. %s",
 408                      iscsi_get_error(iscsi));
 409         itask->status   = 1;
 410         itask->complete = 1;
 411         scsi_free_scsi_task(task);
 412         return;
 413     }
 414
 415     rc10 = scsi_datain_unmarshall(task);
 416     if (rc10 == NULL) {
 417         error_report("iSCSI: Failed to unmarshall readcapacity10 data.");
 418         itask->status   = 1;
 419         itask->complete = 1;
 420         scsi_free_scsi_task(task);
 421         return;
 422     }
 423
 424     itask->iscsilun->block_size = rc10->block_size;
 425     itask->iscsilun->num_blocks = rc10->lba;
 426     itask->bs->total_sectors = (uint64_t)rc10->lba *
 427                                rc10->block_size / BDRV_SECTOR_SIZE ;
 428
 429     itask->status   = 0;
 430     itask->complete = 1;
 431     scsi_free_scsi_task(task);
 432 }
 433
 434
 435 static void
 436 iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data,
 437                  void *opaque)
 438 {
 439     struct IscsiTask *itask = opaque;
 440     struct scsi_task *task;
 441
 442     if (status != 0) {
 443         itask->status   = 1;
 444         itask->complete = 1;
 445         return;
 446     }
 447
 448     task = iscsi_readcapacity10_task(iscsi, itask->iscsilun->lun, 0, 0,
 449                                    iscsi_readcapacity10_cb, opaque);
 450     if (task == NULL) {
 451         error_report("iSCSI: failed to send readcapacity command.");
 452         itask->status   = 1;
 453         itask->complete = 1;
 454         return;
 455     }
 456 }
 457
 458 /*
 459  * We support iscsi url's on the form
 460  * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
 461  */
 462 static int iscsi_open(BlockDriverState *bs, const char *filename, int flags)
 463 {
 464     IscsiLun *iscsilun = bs->opaque;
 465     struct iscsi_context *iscsi = NULL;
 466     struct iscsi_url *iscsi_url = NULL;
 467     struct IscsiTask task;
 468     int ret;
 469
 470     if ((BDRV_SECTOR_SIZE % 512) != 0) {
 471         error_report("iSCSI: Invalid BDRV_SECTOR_SIZE. "
 472                      "BDRV_SECTOR_SIZE(%lld) is not a multiple "
 473                      "of 512", BDRV_SECTOR_SIZE);
 474         return -EINVAL;
 475     }
 476
 477     memset(iscsilun, 0, sizeof(IscsiLun));
 478
 479     /* Should really append the KVM name after the ':' here */
 480     iscsi = iscsi_create_context("iqn.2008-11.org.linux-kvm:");
 481     if (iscsi == NULL) {
 482         error_report("iSCSI: Failed to create iSCSI context.");
 483         ret = -ENOMEM;
 484         goto failed;
 485     }
 486
 487     iscsi_url = iscsi_parse_full_url(iscsi, filename);
 488     if (iscsi_url == NULL) {
 489         error_report("Failed to parse URL : %s %s", filename,
 490                      iscsi_get_error(iscsi));
 491         ret = -EINVAL;
 492         goto failed;
 493     }
 494
 495     if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
 496         error_report("iSCSI: Failed to set target name.");
 497         ret = -EINVAL;
 498         goto failed;
 499     }
 500
 501     if (iscsi_url->user != NULL) {
 502         ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
 503                                               iscsi_url->passwd);
 504         if (ret != 0) {
 505             error_report("Failed to set initiator username and password");
 506             ret = -EINVAL;
 507             goto failed;
 508         }
 509     }
 510     if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
 511         error_report("iSCSI: Failed to set session type to normal.");
 512         ret = -EINVAL;
 513         goto failed;
 514     }
 515
 516     iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
 517
 518     task.iscsilun = iscsilun;
 519     task.status = 0;
 520     task.complete = 0;
 521     task.bs = bs;
 522
 523     iscsilun->iscsi = iscsi;
 524     iscsilun->lun   = iscsi_url->lun;
 525
 526     if (iscsi_full_connect_async(iscsi, iscsi_url->portal, iscsi_url->lun,
 527                                  iscsi_connect_cb, &task)
 528         != 0) {
 529         error_report("iSCSI: Failed to start async connect.");
 530         ret = -EINVAL;
 531         goto failed;
 532     }
 533
 534     while (!task.complete) {
 535         iscsi_set_events(iscsilun);
 536         qemu_aio_wait();
 537     }
 538     if (task.status != 0) {
 539         error_report("iSCSI: Failed to connect to LUN : %s",
 540                      iscsi_get_error(iscsi));
 541         ret = -EINVAL;
 542         goto failed;
 543     }
 544
 545     if (iscsi_url != NULL) {
 546         iscsi_destroy_url(iscsi_url);
 547     }
 548     return 0;
 549
 550 failed:
 551     if (iscsi_url != NULL) {
 552         iscsi_destroy_url(iscsi_url);
 553     }
 554     if (iscsi != NULL) {
 555         iscsi_destroy_context(iscsi);
 556     }
 557     memset(iscsilun, 0, sizeof(IscsiLun));
 558     return ret;
 559 }
 560
 561 static void iscsi_close(BlockDriverState *bs)
 562 {
 563     IscsiLun *iscsilun = bs->opaque;
 564     struct iscsi_context *iscsi = iscsilun->iscsi;
 565
 566     qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL, NULL, NULL);
 567     iscsi_destroy_context(iscsi);
 568     memset(iscsilun, 0, sizeof(IscsiLun));
 569 }
 570
 571 static BlockDriver bdrv_iscsi = {
 572     .format_name     = "iscsi",
 573     .protocol_name   = "iscsi",
 574
 575     .instance_size   = sizeof(IscsiLun),
 576     .bdrv_file_open  = iscsi_open,
 577     .bdrv_close      = iscsi_close,
 578
 579     .bdrv_getlength  = iscsi_getlength,
 580
 581     .bdrv_aio_readv  = iscsi_aio_readv,
 582     .bdrv_aio_writev = iscsi_aio_writev,
 583     .bdrv_aio_flush  = iscsi_aio_flush,
 584 };
 585
 586 static void iscsi_block_init(void)
 587 {
 588     bdrv_register(&bdrv_iscsi);
 589 }
 590
 591 block_init(iscsi_block_init);