Return to iscsi.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / block

Annotation of qemu/block/iscsi.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * QEMU Block driver for iSCSI images
        !             3:  *
        !             4:  * Copyright (c) 2010-2011 Ronnie Sahlberg <[email protected]>
        !             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);

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.