1c589b249SRonnie Sahlberg /* 2c589b249SRonnie Sahlberg * QEMU Block driver for iSCSI images 3c589b249SRonnie Sahlberg * 4c589b249SRonnie Sahlberg * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com> 5aef172ffSPeter Lieven * Copyright (c) 2012-2017 Peter Lieven <pl@kamp.de> 6c589b249SRonnie Sahlberg * 7c589b249SRonnie Sahlberg * Permission is hereby granted, free of charge, to any person obtaining a copy 8c589b249SRonnie Sahlberg * of this software and associated documentation files (the "Software"), to deal 9c589b249SRonnie Sahlberg * in the Software without restriction, including without limitation the rights 10c589b249SRonnie Sahlberg * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11c589b249SRonnie Sahlberg * copies of the Software, and to permit persons to whom the Software is 12c589b249SRonnie Sahlberg * furnished to do so, subject to the following conditions: 13c589b249SRonnie Sahlberg * 14c589b249SRonnie Sahlberg * The above copyright notice and this permission notice shall be included in 15c589b249SRonnie Sahlberg * all copies or substantial portions of the Software. 16c589b249SRonnie Sahlberg * 17c589b249SRonnie Sahlberg * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18c589b249SRonnie Sahlberg * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19c589b249SRonnie Sahlberg * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20c589b249SRonnie Sahlberg * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21c589b249SRonnie Sahlberg * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22c589b249SRonnie Sahlberg * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23c589b249SRonnie Sahlberg * THE SOFTWARE. 24c589b249SRonnie Sahlberg */ 25c589b249SRonnie Sahlberg 2680c71a24SPeter Maydell #include "qemu/osdep.h" 27c589b249SRonnie Sahlberg 28c589b249SRonnie Sahlberg #include <poll.h> 29efc6de0dSPeter Lieven #include <math.h> 30f4dfa67fSRonnie Sahlberg #include <arpa/inet.h> 311de7afc9SPaolo Bonzini #include "qemu/config-file.h" 321de7afc9SPaolo Bonzini #include "qemu/error-report.h" 33b03c3805SPeter Lieven #include "qemu/bitops.h" 34b03c3805SPeter Lieven #include "qemu/bitmap.h" 35737e150eSPaolo Bonzini #include "block/block_int.h" 3608e2c9f1SPaolo Bonzini #include "scsi/constants.h" 370a53f010SRonnie Sahlberg #include "qemu/iov.h" 38922a01a0SMarkus Armbruster #include "qemu/option.h" 39cea25275SFam Zheng #include "qemu/uuid.h" 40e688df6bSMarkus Armbruster #include "qapi/error.h" 41112ed241SMarkus Armbruster #include "qapi/qapi-commands-misc.h" 42452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h" 43d49b6836SMarkus Armbruster #include "qapi/qmp/qstring.h" 44b189346eSDaniel P. Berrange #include "crypto/secret.h" 45e5b5728cSPaolo Bonzini #include "scsi/utils.h" 46c589b249SRonnie Sahlberg 47e5b5728cSPaolo Bonzini /* Conflict between scsi/utils.h and libiscsi! :( */ 48e5b5728cSPaolo Bonzini #define SCSI_XFER_NONE ISCSI_XFER_NONE 49c589b249SRonnie Sahlberg #include <iscsi/iscsi.h> 50c589b249SRonnie Sahlberg #include <iscsi/scsi-lowlevel.h> 51e5b5728cSPaolo Bonzini #undef SCSI_XFER_NONE 52e5b5728cSPaolo Bonzini QEMU_BUILD_BUG_ON((int)SCSI_XFER_NONE != (int)ISCSI_XFER_NONE); 53c589b249SRonnie Sahlberg 5498392453SRonnie Sahlberg #ifdef __linux__ 5598392453SRonnie Sahlberg #include <scsi/sg.h> 5698392453SRonnie Sahlberg #endif 57c589b249SRonnie Sahlberg 58c589b249SRonnie Sahlberg typedef struct IscsiLun { 59c589b249SRonnie Sahlberg struct iscsi_context *iscsi; 6080cf6257SStefan Hajnoczi AioContext *aio_context; 61c589b249SRonnie Sahlberg int lun; 62dbfff6d7SRonnie Sahlberg enum scsi_inquiry_peripheral_device_type type; 63c589b249SRonnie Sahlberg int block_size; 64c7b4a952SPaolo Bonzini uint64_t num_blocks; 65c9b9f682SRonnie Sahlberg int events; 665b5d34ecSPeter Lieven QEMUTimer *nop_timer; 6705b685fbSPeter Lieven QEMUTimer *event_timer; 68d045c466SPaolo Bonzini QemuMutex mutex; 69f18a7cbbSPeter Lieven struct scsi_inquiry_logical_block_provisioning lbp; 70f18a7cbbSPeter Lieven struct scsi_inquiry_block_limits bl; 71d4cd9615SPeter Lieven unsigned char *zeroblock; 72e1123a3bSPeter Lieven /* The allocmap tracks which clusters (pages) on the iSCSI target are 73e1123a3bSPeter Lieven * allocated and which are not. In case a target returns zeros for 74e1123a3bSPeter Lieven * unallocated pages (iscsilun->lprz) we can directly return zeros instead 75e1123a3bSPeter Lieven * of reading zeros over the wire if a read request falls within an 76e1123a3bSPeter Lieven * unallocated block. As there are 3 possible states we need 2 bitmaps to 77e1123a3bSPeter Lieven * track. allocmap_valid keeps track if QEMU's information about a page is 78e1123a3bSPeter Lieven * valid. allocmap tracks if a page is allocated or not. In case QEMU has no 79e1123a3bSPeter Lieven * valid information about a page the corresponding allocmap entry should be 80e1123a3bSPeter Lieven * switched to unallocated as well to force a new lookup of the allocation 81e1123a3bSPeter Lieven * status as lookups are generally skipped if a page is suspect to be 82e1123a3bSPeter Lieven * allocated. If a iSCSI target is opened with cache.direct = on the 83e1123a3bSPeter Lieven * allocmap_valid does not exist turning all cached information invalid so 84e1123a3bSPeter Lieven * that a fresh lookup is made for any page even if allocmap entry returns 85e1123a3bSPeter Lieven * it's unallocated. */ 86e1123a3bSPeter Lieven unsigned long *allocmap; 87e1123a3bSPeter Lieven unsigned long *allocmap_valid; 88e1123a3bSPeter Lieven long allocmap_size; 89ba059e7bSEric Blake int cluster_size; 909281fe9eSPeter Lieven bool use_16_for_rw; 9143ae8fb1SFam Zheng bool write_protected; 920a386e48SPeter Lieven bool lbpme; 930a386e48SPeter Lieven bool lbprz; 94752ce451SPeter Lieven bool dpofua; 950a386e48SPeter Lieven bool has_write_same; 965dd7a535SPeter Lieven bool request_timed_out; 97c589b249SRonnie Sahlberg } IscsiLun; 98c589b249SRonnie Sahlberg 9954a5c1d5SPeter Lieven typedef struct IscsiTask { 10054a5c1d5SPeter Lieven int status; 10154a5c1d5SPeter Lieven int complete; 10254a5c1d5SPeter Lieven int retries; 10354a5c1d5SPeter Lieven int do_retry; 10454a5c1d5SPeter Lieven struct scsi_task *task; 10554a5c1d5SPeter Lieven Coroutine *co; 10680cf6257SStefan Hajnoczi IscsiLun *iscsilun; 107efc6de0dSPeter Lieven QEMUTimer retry_timer; 108e01dd3daSFam Zheng int err_code; 109e38bc234SPeter Lieven char *err_str; 11054a5c1d5SPeter Lieven } IscsiTask; 11154a5c1d5SPeter Lieven 112c589b249SRonnie Sahlberg typedef struct IscsiAIOCB { 1137c84b1b8SMarkus Armbruster BlockAIOCB common; 114c589b249SRonnie Sahlberg QEMUBH *bh; 115c589b249SRonnie Sahlberg IscsiLun *iscsilun; 116c589b249SRonnie Sahlberg struct scsi_task *task; 117c589b249SRonnie Sahlberg uint8_t *buf; 118c589b249SRonnie Sahlberg int status; 1191dde716eSPeter Lieven int64_t sector_num; 1201dde716eSPeter Lieven int nb_sectors; 1214bb17ab5SFam Zheng int ret; 12298392453SRonnie Sahlberg #ifdef __linux__ 12398392453SRonnie Sahlberg sg_io_hdr_t *ioh; 12498392453SRonnie Sahlberg #endif 125c589b249SRonnie Sahlberg } IscsiAIOCB; 126c589b249SRonnie Sahlberg 1275dd7a535SPeter Lieven /* libiscsi uses time_t so its enough to process events every second */ 1285dd7a535SPeter Lieven #define EVENT_INTERVAL 1000 1295b5d34ecSPeter Lieven #define NOP_INTERVAL 5000 1305b5d34ecSPeter Lieven #define MAX_NOP_FAILURES 3 131efc6de0dSPeter Lieven #define ISCSI_CMD_RETRIES ARRAY_SIZE(iscsi_retry_times) 13259dd0a22SPeter Lieven static const unsigned iscsi_retry_times[] = {8, 32, 128, 512, 2048, 8192, 32768}; 1335b5d34ecSPeter Lieven 1345d831be2SStefan Weil /* this threshold is a trade-off knob to choose between 1355917af81SPeter Lieven * the potential additional overhead of an extra GET_LBA_STATUS request 1365917af81SPeter Lieven * vs. unnecessarily reading a lot of zero sectors over the wire. 1375917af81SPeter Lieven * If a read request is greater or equal than ISCSI_CHECKALLOC_THRES 1385917af81SPeter Lieven * sectors we check the allocation status of the area covered by the 1395917af81SPeter Lieven * request first if the allocationmap indicates that the area might be 1405917af81SPeter Lieven * unallocated. */ 1415917af81SPeter Lieven #define ISCSI_CHECKALLOC_THRES 64 142c589b249SRonnie Sahlberg 143c589b249SRonnie Sahlberg static void 144cfb3f506SPaolo Bonzini iscsi_bh_cb(void *p) 14527cbd828SPaolo Bonzini { 14627cbd828SPaolo Bonzini IscsiAIOCB *acb = p; 14727cbd828SPaolo Bonzini 14827cbd828SPaolo Bonzini qemu_bh_delete(acb->bh); 14927cbd828SPaolo Bonzini 1504790b03dSPaolo Bonzini g_free(acb->buf); 1514790b03dSPaolo Bonzini acb->buf = NULL; 1524790b03dSPaolo Bonzini 15327cbd828SPaolo Bonzini acb->common.cb(acb->common.opaque, acb->status); 15427cbd828SPaolo Bonzini 1551bd075f2SPaolo Bonzini if (acb->task != NULL) { 1561bd075f2SPaolo Bonzini scsi_free_scsi_task(acb->task); 1571bd075f2SPaolo Bonzini acb->task = NULL; 1581bd075f2SPaolo Bonzini } 1591bd075f2SPaolo Bonzini 1608007429aSFam Zheng qemu_aio_unref(acb); 16127cbd828SPaolo Bonzini } 16227cbd828SPaolo Bonzini 163cfb3f506SPaolo Bonzini static void 164cfb3f506SPaolo Bonzini iscsi_schedule_bh(IscsiAIOCB *acb) 16527cbd828SPaolo Bonzini { 1661bd075f2SPaolo Bonzini if (acb->bh) { 1671bd075f2SPaolo Bonzini return; 1681bd075f2SPaolo Bonzini } 16980cf6257SStefan Hajnoczi acb->bh = aio_bh_new(acb->iscsilun->aio_context, iscsi_bh_cb, acb); 17027cbd828SPaolo Bonzini qemu_bh_schedule(acb->bh); 17127cbd828SPaolo Bonzini } 17227cbd828SPaolo Bonzini 1738b9dfe90SPeter Lieven static void iscsi_co_generic_bh_cb(void *opaque) 1748b9dfe90SPeter Lieven { 1758b9dfe90SPeter Lieven struct IscsiTask *iTask = opaque; 1761919631eSPaolo Bonzini 177fcd470d8SPeter Lieven iTask->complete = 1; 1781919631eSPaolo Bonzini aio_co_wake(iTask->co); 1798b9dfe90SPeter Lieven } 1808b9dfe90SPeter Lieven 181efc6de0dSPeter Lieven static void iscsi_retry_timer_expired(void *opaque) 182efc6de0dSPeter Lieven { 183efc6de0dSPeter Lieven struct IscsiTask *iTask = opaque; 184fcd470d8SPeter Lieven iTask->complete = 1; 185efc6de0dSPeter Lieven if (iTask->co) { 1862f47da5fSPaolo Bonzini aio_co_wake(iTask->co); 187efc6de0dSPeter Lieven } 188efc6de0dSPeter Lieven } 189efc6de0dSPeter Lieven 190efc6de0dSPeter Lieven static inline unsigned exp_random(double mean) 191efc6de0dSPeter Lieven { 192efc6de0dSPeter Lieven return -mean * log((double)rand() / RAND_MAX); 193efc6de0dSPeter Lieven } 194efc6de0dSPeter Lieven 195e01dd3daSFam Zheng /* SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST was introduced in 196e01dd3daSFam Zheng * libiscsi 1.10.0, together with other constants we need. Use it as 197e01dd3daSFam Zheng * a hint that we have to define them ourselves if needed, to keep the 198e01dd3daSFam Zheng * minimum required libiscsi version at 1.9.0. We use an ASCQ macro for 199e01dd3daSFam Zheng * the test because SCSI_STATUS_* is an enum. 200e01dd3daSFam Zheng * 201e01dd3daSFam Zheng * To guard against future changes where SCSI_SENSE_ASCQ_* also becomes 202e01dd3daSFam Zheng * an enum, check against the LIBISCSI_API_VERSION macro, which was 203e01dd3daSFam Zheng * introduced in 1.11.0. If it is present, there is no need to define 204e01dd3daSFam Zheng * anything. 205e01dd3daSFam Zheng */ 206e01dd3daSFam Zheng #if !defined(SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST) && \ 207e01dd3daSFam Zheng !defined(LIBISCSI_API_VERSION) 208e01dd3daSFam Zheng #define SCSI_STATUS_TASK_SET_FULL 0x28 209e01dd3daSFam Zheng #define SCSI_STATUS_TIMEOUT 0x0f000002 210e01dd3daSFam Zheng #define SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST 0x2600 211e01dd3daSFam Zheng #define SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR 0x1a00 2129049736eSPeter Lieven #endif 2139049736eSPeter Lieven 214583ec22eSRoy Shterman #ifndef LIBISCSI_API_VERSION 215583ec22eSRoy Shterman #define LIBISCSI_API_VERSION 20130701 216583ec22eSRoy Shterman #endif 217583ec22eSRoy Shterman 218e01dd3daSFam Zheng static int iscsi_translate_sense(struct scsi_sense *sense) 219e01dd3daSFam Zheng { 22028751358SFam Zheng return - scsi_sense_to_errno(sense->key, 22128751358SFam Zheng (sense->ascq & 0xFF00) >> 8, 22228751358SFam Zheng sense->ascq & 0xFF); 223e01dd3daSFam Zheng } 224e01dd3daSFam Zheng 225d045c466SPaolo Bonzini /* Called (via iscsi_service) with QemuMutex held. */ 22654a5c1d5SPeter Lieven static void 22754a5c1d5SPeter Lieven iscsi_co_generic_cb(struct iscsi_context *iscsi, int status, 22854a5c1d5SPeter Lieven void *command_data, void *opaque) 22954a5c1d5SPeter Lieven { 23054a5c1d5SPeter Lieven struct IscsiTask *iTask = opaque; 23154a5c1d5SPeter Lieven struct scsi_task *task = command_data; 23254a5c1d5SPeter Lieven 23354a5c1d5SPeter Lieven iTask->status = status; 23454a5c1d5SPeter Lieven iTask->do_retry = 0; 23554a5c1d5SPeter Lieven iTask->task = task; 23654a5c1d5SPeter Lieven 237efc6de0dSPeter Lieven if (status != SCSI_STATUS_GOOD) { 238efc6de0dSPeter Lieven if (iTask->retries++ < ISCSI_CMD_RETRIES) { 239efc6de0dSPeter Lieven if (status == SCSI_STATUS_CHECK_CONDITION 24054a5c1d5SPeter Lieven && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) { 241efc6de0dSPeter Lieven error_report("iSCSI CheckCondition: %s", 242efc6de0dSPeter Lieven iscsi_get_error(iscsi)); 24354a5c1d5SPeter Lieven iTask->do_retry = 1; 24454a5c1d5SPeter Lieven goto out; 24554a5c1d5SPeter Lieven } 2469049736eSPeter Lieven if (status == SCSI_STATUS_BUSY || 247e01dd3daSFam Zheng status == SCSI_STATUS_TIMEOUT || 248e01dd3daSFam Zheng status == SCSI_STATUS_TASK_SET_FULL) { 249efc6de0dSPeter Lieven unsigned retry_time = 250efc6de0dSPeter Lieven exp_random(iscsi_retry_times[iTask->retries - 1]); 251e01dd3daSFam Zheng if (status == SCSI_STATUS_TIMEOUT) { 2525dd7a535SPeter Lieven /* make sure the request is rescheduled AFTER the 2535dd7a535SPeter Lieven * reconnect is initiated */ 2545dd7a535SPeter Lieven retry_time = EVENT_INTERVAL * 2; 2555dd7a535SPeter Lieven iTask->iscsilun->request_timed_out = true; 2565dd7a535SPeter Lieven } 2575dd7a535SPeter Lieven error_report("iSCSI Busy/TaskSetFull/TimeOut" 2585dd7a535SPeter Lieven " (retry #%u in %u ms): %s", 259efc6de0dSPeter Lieven iTask->retries, retry_time, 260efc6de0dSPeter Lieven iscsi_get_error(iscsi)); 261efc6de0dSPeter Lieven aio_timer_init(iTask->iscsilun->aio_context, 262efc6de0dSPeter Lieven &iTask->retry_timer, QEMU_CLOCK_REALTIME, 263efc6de0dSPeter Lieven SCALE_MS, iscsi_retry_timer_expired, iTask); 264efc6de0dSPeter Lieven timer_mod(&iTask->retry_timer, 265efc6de0dSPeter Lieven qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time); 266efc6de0dSPeter Lieven iTask->do_retry = 1; 267efc6de0dSPeter Lieven return; 268efc6de0dSPeter Lieven } 269efc6de0dSPeter Lieven } 270e01dd3daSFam Zheng iTask->err_code = iscsi_translate_sense(&task->sense); 271e38bc234SPeter Lieven iTask->err_str = g_strdup(iscsi_get_error(iscsi)); 27254a5c1d5SPeter Lieven } 27354a5c1d5SPeter Lieven 27454a5c1d5SPeter Lieven out: 27554a5c1d5SPeter Lieven if (iTask->co) { 276fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(iTask->iscsilun->aio_context, 27780cf6257SStefan Hajnoczi iscsi_co_generic_bh_cb, iTask); 278fcd470d8SPeter Lieven } else { 279fcd470d8SPeter Lieven iTask->complete = 1; 28054a5c1d5SPeter Lieven } 28154a5c1d5SPeter Lieven } 28254a5c1d5SPeter Lieven 28354a5c1d5SPeter Lieven static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask) 28454a5c1d5SPeter Lieven { 28554a5c1d5SPeter Lieven *iTask = (struct IscsiTask) { 28654a5c1d5SPeter Lieven .co = qemu_coroutine_self(), 28780cf6257SStefan Hajnoczi .iscsilun = iscsilun, 28854a5c1d5SPeter Lieven }; 28954a5c1d5SPeter Lieven } 29027cbd828SPaolo Bonzini 29127cbd828SPaolo Bonzini static void 292c589b249SRonnie Sahlberg iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data, 293c589b249SRonnie Sahlberg void *private_data) 294c589b249SRonnie Sahlberg { 2951bd075f2SPaolo Bonzini IscsiAIOCB *acb = private_data; 2961bd075f2SPaolo Bonzini 2971bd075f2SPaolo Bonzini acb->status = -ECANCELED; 2981bd075f2SPaolo Bonzini iscsi_schedule_bh(acb); 299c589b249SRonnie Sahlberg } 300c589b249SRonnie Sahlberg 301c589b249SRonnie Sahlberg static void 3027c84b1b8SMarkus Armbruster iscsi_aio_cancel(BlockAIOCB *blockacb) 303c589b249SRonnie Sahlberg { 304c589b249SRonnie Sahlberg IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; 305c589b249SRonnie Sahlberg IscsiLun *iscsilun = acb->iscsilun; 306c589b249SRonnie Sahlberg 3071bd075f2SPaolo Bonzini if (acb->status != -EINPROGRESS) { 3081bd075f2SPaolo Bonzini return; 3091bd075f2SPaolo Bonzini } 3101bd075f2SPaolo Bonzini 311b2090919SPaolo Bonzini /* send a task mgmt call to the target to cancel the task on the target */ 31264e69e80SStefan Priebe iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task, 3131bd075f2SPaolo Bonzini iscsi_abort_task_cb, acb); 314b2090919SPaolo Bonzini 315c589b249SRonnie Sahlberg } 316c589b249SRonnie Sahlberg 317d7331bedSStefan Hajnoczi static const AIOCBInfo iscsi_aiocb_info = { 318c589b249SRonnie Sahlberg .aiocb_size = sizeof(IscsiAIOCB), 319722d9333SFam Zheng .cancel_async = iscsi_aio_cancel, 320c589b249SRonnie Sahlberg }; 321c589b249SRonnie Sahlberg 322c589b249SRonnie Sahlberg 323c589b249SRonnie Sahlberg static void iscsi_process_read(void *arg); 324c589b249SRonnie Sahlberg static void iscsi_process_write(void *arg); 325c589b249SRonnie Sahlberg 326d045c466SPaolo Bonzini /* Called with QemuMutex held. */ 327c589b249SRonnie Sahlberg static void 328c589b249SRonnie Sahlberg iscsi_set_events(IscsiLun *iscsilun) 329c589b249SRonnie Sahlberg { 330c589b249SRonnie Sahlberg struct iscsi_context *iscsi = iscsilun->iscsi; 33105b685fbSPeter Lieven int ev = iscsi_which_events(iscsi); 332c589b249SRonnie Sahlberg 333c9b9f682SRonnie Sahlberg if (ev != iscsilun->events) { 334dca21ef2SFam Zheng aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsi), 335dca21ef2SFam Zheng false, 33605b685fbSPeter Lieven (ev & POLLIN) ? iscsi_process_read : NULL, 337c9b9f682SRonnie Sahlberg (ev & POLLOUT) ? iscsi_process_write : NULL, 338f6a51c84SStefan Hajnoczi NULL, 339c9b9f682SRonnie Sahlberg iscsilun); 34005b685fbSPeter Lieven iscsilun->events = ev; 341c9b9f682SRonnie Sahlberg } 34205b685fbSPeter Lieven } 34305b685fbSPeter Lieven 3445dd7a535SPeter Lieven static void iscsi_timed_check_events(void *opaque) 34505b685fbSPeter Lieven { 34605b685fbSPeter Lieven IscsiLun *iscsilun = opaque; 3475dd7a535SPeter Lieven 3485dd7a535SPeter Lieven /* check for timed out requests */ 3495dd7a535SPeter Lieven iscsi_service(iscsilun->iscsi, 0); 3505dd7a535SPeter Lieven 3515dd7a535SPeter Lieven if (iscsilun->request_timed_out) { 3525dd7a535SPeter Lieven iscsilun->request_timed_out = false; 3535dd7a535SPeter Lieven iscsi_reconnect(iscsilun->iscsi); 3545dd7a535SPeter Lieven } 3555dd7a535SPeter Lieven 3565dd7a535SPeter Lieven /* newer versions of libiscsi may return zero events. Ensure we are able 3575dd7a535SPeter Lieven * to return to service once this situation changes. */ 35805b685fbSPeter Lieven iscsi_set_events(iscsilun); 3595dd7a535SPeter Lieven 3605dd7a535SPeter Lieven timer_mod(iscsilun->event_timer, 3615dd7a535SPeter Lieven qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL); 362c589b249SRonnie Sahlberg } 363c589b249SRonnie Sahlberg 364c589b249SRonnie Sahlberg static void 365c589b249SRonnie Sahlberg iscsi_process_read(void *arg) 366c589b249SRonnie Sahlberg { 367c589b249SRonnie Sahlberg IscsiLun *iscsilun = arg; 368c589b249SRonnie Sahlberg struct iscsi_context *iscsi = iscsilun->iscsi; 369c589b249SRonnie Sahlberg 370d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 371c589b249SRonnie Sahlberg iscsi_service(iscsi, POLLIN); 372c589b249SRonnie Sahlberg iscsi_set_events(iscsilun); 373d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 374c589b249SRonnie Sahlberg } 375c589b249SRonnie Sahlberg 376c589b249SRonnie Sahlberg static void 377c589b249SRonnie Sahlberg iscsi_process_write(void *arg) 378c589b249SRonnie Sahlberg { 379c589b249SRonnie Sahlberg IscsiLun *iscsilun = arg; 380c589b249SRonnie Sahlberg struct iscsi_context *iscsi = iscsilun->iscsi; 381c589b249SRonnie Sahlberg 382d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 383c589b249SRonnie Sahlberg iscsi_service(iscsi, POLLOUT); 384c589b249SRonnie Sahlberg iscsi_set_events(iscsilun); 385d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 386c589b249SRonnie Sahlberg } 387c589b249SRonnie Sahlberg 3880777b5ddSPeter Lieven static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun) 3890777b5ddSPeter Lieven { 3900777b5ddSPeter Lieven return sector * iscsilun->block_size / BDRV_SECTOR_SIZE; 3910777b5ddSPeter Lieven } 3920777b5ddSPeter Lieven 393c589b249SRonnie Sahlberg static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun) 394c589b249SRonnie Sahlberg { 395c589b249SRonnie Sahlberg return sector * BDRV_SECTOR_SIZE / iscsilun->block_size; 396c589b249SRonnie Sahlberg } 397c589b249SRonnie Sahlberg 39894d047a3SEric Blake static bool is_byte_request_lun_aligned(int64_t offset, int count, 39991bea4e2SPeter Lieven IscsiLun *iscsilun) 40091bea4e2SPeter Lieven { 40194d047a3SEric Blake if (offset % iscsilun->block_size || count % iscsilun->block_size) { 402f5075224SRichard W.M. Jones error_report("iSCSI misaligned request: " 40394d047a3SEric Blake "iscsilun->block_size %u, offset %" PRIi64 40494d047a3SEric Blake ", count %d", 40594d047a3SEric Blake iscsilun->block_size, offset, count); 40694d047a3SEric Blake return false; 40791bea4e2SPeter Lieven } 40894d047a3SEric Blake return true; 40994d047a3SEric Blake } 41094d047a3SEric Blake 41194d047a3SEric Blake static bool is_sector_request_lun_aligned(int64_t sector_num, int nb_sectors, 41294d047a3SEric Blake IscsiLun *iscsilun) 41394d047a3SEric Blake { 4140ead9312SPeter Lieven assert(nb_sectors <= BDRV_REQUEST_MAX_SECTORS); 41594d047a3SEric Blake return is_byte_request_lun_aligned(sector_num << BDRV_SECTOR_BITS, 41694d047a3SEric Blake nb_sectors << BDRV_SECTOR_BITS, 41794d047a3SEric Blake iscsilun); 41891bea4e2SPeter Lieven } 41991bea4e2SPeter Lieven 420e1123a3bSPeter Lieven static void iscsi_allocmap_free(IscsiLun *iscsilun) 421a9fe4c95SPeter Lieven { 422e1123a3bSPeter Lieven g_free(iscsilun->allocmap); 423e1123a3bSPeter Lieven g_free(iscsilun->allocmap_valid); 424e1123a3bSPeter Lieven iscsilun->allocmap = NULL; 425e1123a3bSPeter Lieven iscsilun->allocmap_valid = NULL; 426a9fe4c95SPeter Lieven } 427a9fe4c95SPeter Lieven 428e1123a3bSPeter Lieven 429e1123a3bSPeter Lieven static int iscsi_allocmap_init(IscsiLun *iscsilun, int open_flags) 430b03c3805SPeter Lieven { 431e1123a3bSPeter Lieven iscsi_allocmap_free(iscsilun); 432e1123a3bSPeter Lieven 433ba059e7bSEric Blake assert(iscsilun->cluster_size); 434e1123a3bSPeter Lieven iscsilun->allocmap_size = 435ba059e7bSEric Blake DIV_ROUND_UP(iscsilun->num_blocks * iscsilun->block_size, 436ba059e7bSEric Blake iscsilun->cluster_size); 437e1123a3bSPeter Lieven 438e1123a3bSPeter Lieven iscsilun->allocmap = bitmap_try_new(iscsilun->allocmap_size); 439e1123a3bSPeter Lieven if (!iscsilun->allocmap) { 440e1123a3bSPeter Lieven return -ENOMEM; 441b03c3805SPeter Lieven } 442b03c3805SPeter Lieven 443e1123a3bSPeter Lieven if (open_flags & BDRV_O_NOCACHE) { 444ba059e7bSEric Blake /* when cache.direct = on all allocmap entries are 445e1123a3bSPeter Lieven * treated as invalid to force a relookup of the block 446e1123a3bSPeter Lieven * status on every read request */ 447e1123a3bSPeter Lieven return 0; 448e1123a3bSPeter Lieven } 449e1123a3bSPeter Lieven 450e1123a3bSPeter Lieven iscsilun->allocmap_valid = bitmap_try_new(iscsilun->allocmap_size); 451e1123a3bSPeter Lieven if (!iscsilun->allocmap_valid) { 452e1123a3bSPeter Lieven /* if we are under memory pressure free the allocmap as well */ 453e1123a3bSPeter Lieven iscsi_allocmap_free(iscsilun); 454e1123a3bSPeter Lieven return -ENOMEM; 455e1123a3bSPeter Lieven } 456e1123a3bSPeter Lieven 457e1123a3bSPeter Lieven return 0; 458e1123a3bSPeter Lieven } 459e1123a3bSPeter Lieven 460e1123a3bSPeter Lieven static void 46104a408fbSEric Blake iscsi_allocmap_update(IscsiLun *iscsilun, int64_t offset, 46204a408fbSEric Blake int64_t bytes, bool allocated, bool valid) 463b03c3805SPeter Lieven { 464e1123a3bSPeter Lieven int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk; 465e1123a3bSPeter Lieven 466e1123a3bSPeter Lieven if (iscsilun->allocmap == NULL) { 467b03c3805SPeter Lieven return; 468b03c3805SPeter Lieven } 469e1123a3bSPeter Lieven /* expand to entirely contain all affected clusters */ 47004a408fbSEric Blake assert(iscsilun->cluster_size); 47104a408fbSEric Blake cl_num_expanded = offset / iscsilun->cluster_size; 47204a408fbSEric Blake nb_cls_expanded = DIV_ROUND_UP(offset + bytes, 47304a408fbSEric Blake iscsilun->cluster_size) - cl_num_expanded; 474e1123a3bSPeter Lieven /* shrink to touch only completely contained clusters */ 47504a408fbSEric Blake cl_num_shrunk = DIV_ROUND_UP(offset, iscsilun->cluster_size); 47604a408fbSEric Blake nb_cls_shrunk = (offset + bytes) / iscsilun->cluster_size - cl_num_shrunk; 477e1123a3bSPeter Lieven if (allocated) { 478e1123a3bSPeter Lieven bitmap_set(iscsilun->allocmap, cl_num_expanded, nb_cls_expanded); 479e1123a3bSPeter Lieven } else { 4801da45e0cSPeter Lieven if (nb_cls_shrunk > 0) { 481e1123a3bSPeter Lieven bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk); 482b03c3805SPeter Lieven } 4831da45e0cSPeter Lieven } 484e1123a3bSPeter Lieven 485e1123a3bSPeter Lieven if (iscsilun->allocmap_valid == NULL) { 486e1123a3bSPeter Lieven return; 487e1123a3bSPeter Lieven } 488e1123a3bSPeter Lieven if (valid) { 4891da45e0cSPeter Lieven if (nb_cls_shrunk > 0) { 490e1123a3bSPeter Lieven bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk); 4911da45e0cSPeter Lieven } 492e1123a3bSPeter Lieven } else { 493e1123a3bSPeter Lieven bitmap_clear(iscsilun->allocmap_valid, cl_num_expanded, 494e1123a3bSPeter Lieven nb_cls_expanded); 495e1123a3bSPeter Lieven } 496e1123a3bSPeter Lieven } 497e1123a3bSPeter Lieven 498e1123a3bSPeter Lieven static void 49904a408fbSEric Blake iscsi_allocmap_set_allocated(IscsiLun *iscsilun, int64_t offset, 50004a408fbSEric Blake int64_t bytes) 501e1123a3bSPeter Lieven { 50204a408fbSEric Blake iscsi_allocmap_update(iscsilun, offset, bytes, true, true); 503e1123a3bSPeter Lieven } 504e1123a3bSPeter Lieven 505e1123a3bSPeter Lieven static void 50604a408fbSEric Blake iscsi_allocmap_set_unallocated(IscsiLun *iscsilun, int64_t offset, 50704a408fbSEric Blake int64_t bytes) 508e1123a3bSPeter Lieven { 509e1123a3bSPeter Lieven /* Note: if cache.direct=on the fifth argument to iscsi_allocmap_update 510e1123a3bSPeter Lieven * is ignored, so this will in effect be an iscsi_allocmap_set_invalid. 511e1123a3bSPeter Lieven */ 51204a408fbSEric Blake iscsi_allocmap_update(iscsilun, offset, bytes, false, true); 513e1123a3bSPeter Lieven } 514e1123a3bSPeter Lieven 51504a408fbSEric Blake static void iscsi_allocmap_set_invalid(IscsiLun *iscsilun, int64_t offset, 51604a408fbSEric Blake int64_t bytes) 517e1123a3bSPeter Lieven { 51804a408fbSEric Blake iscsi_allocmap_update(iscsilun, offset, bytes, false, false); 519e1123a3bSPeter Lieven } 520e1123a3bSPeter Lieven 521e1123a3bSPeter Lieven static void iscsi_allocmap_invalidate(IscsiLun *iscsilun) 522e1123a3bSPeter Lieven { 523e1123a3bSPeter Lieven if (iscsilun->allocmap) { 524e1123a3bSPeter Lieven bitmap_zero(iscsilun->allocmap, iscsilun->allocmap_size); 525e1123a3bSPeter Lieven } 526e1123a3bSPeter Lieven if (iscsilun->allocmap_valid) { 527e1123a3bSPeter Lieven bitmap_zero(iscsilun->allocmap_valid, iscsilun->allocmap_size); 528e1123a3bSPeter Lieven } 529e1123a3bSPeter Lieven } 530e1123a3bSPeter Lieven 531e1123a3bSPeter Lieven static inline bool 53204a408fbSEric Blake iscsi_allocmap_is_allocated(IscsiLun *iscsilun, int64_t offset, 53304a408fbSEric Blake int64_t bytes) 534e1123a3bSPeter Lieven { 535e1123a3bSPeter Lieven unsigned long size; 536e1123a3bSPeter Lieven if (iscsilun->allocmap == NULL) { 537e1123a3bSPeter Lieven return true; 538e1123a3bSPeter Lieven } 539ba059e7bSEric Blake assert(iscsilun->cluster_size); 54004a408fbSEric Blake size = DIV_ROUND_UP(offset + bytes, iscsilun->cluster_size); 541e1123a3bSPeter Lieven return !(find_next_bit(iscsilun->allocmap, size, 54204a408fbSEric Blake offset / iscsilun->cluster_size) == size); 543e1123a3bSPeter Lieven } 544e1123a3bSPeter Lieven 545e1123a3bSPeter Lieven static inline bool iscsi_allocmap_is_valid(IscsiLun *iscsilun, 54604a408fbSEric Blake int64_t offset, int64_t bytes) 547e1123a3bSPeter Lieven { 548e1123a3bSPeter Lieven unsigned long size; 549e1123a3bSPeter Lieven if (iscsilun->allocmap_valid == NULL) { 550e1123a3bSPeter Lieven return false; 551e1123a3bSPeter Lieven } 552ba059e7bSEric Blake assert(iscsilun->cluster_size); 55304a408fbSEric Blake size = DIV_ROUND_UP(offset + bytes, iscsilun->cluster_size); 554e1123a3bSPeter Lieven return (find_next_zero_bit(iscsilun->allocmap_valid, size, 55504a408fbSEric Blake offset / iscsilun->cluster_size) == size); 556b03c3805SPeter Lieven } 557b03c3805SPeter Lieven 5589f0eb9e1SKevin Wolf static int coroutine_fn 5599f0eb9e1SKevin Wolf iscsi_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors, 5609f0eb9e1SKevin Wolf QEMUIOVector *iov, int flags) 561c589b249SRonnie Sahlberg { 562063c3378SPeter Lieven IscsiLun *iscsilun = bs->opaque; 563063c3378SPeter Lieven struct IscsiTask iTask; 564f4dfa67fSRonnie Sahlberg uint64_t lba; 565063c3378SPeter Lieven uint32_t num_sectors; 5664df863f3SEric Blake bool fua = flags & BDRV_REQ_FUA; 567d045c466SPaolo Bonzini int r = 0; 568063c3378SPeter Lieven 5694df863f3SEric Blake if (fua) { 5704df863f3SEric Blake assert(iscsilun->dpofua); 5714df863f3SEric Blake } 57294d047a3SEric Blake if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 573063c3378SPeter Lieven return -EINVAL; 574063c3378SPeter Lieven } 575063c3378SPeter Lieven 5766bd01f14SEric Blake if (bs->bl.max_transfer) { 5776bd01f14SEric Blake assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer); 578dc9e7163SPeter Lieven } 579dc9e7163SPeter Lieven 580063c3378SPeter Lieven lba = sector_qemu2lun(sector_num, iscsilun); 581063c3378SPeter Lieven num_sectors = sector_qemu2lun(nb_sectors, iscsilun); 582063c3378SPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 583d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 584063c3378SPeter Lieven retry: 5859281fe9eSPeter Lieven if (iscsilun->use_16_for_rw) { 586583ec22eSRoy Shterman #if LIBISCSI_API_VERSION >= (20160603) 587583ec22eSRoy Shterman iTask.task = iscsi_write16_iov_task(iscsilun->iscsi, iscsilun->lun, lba, 588583ec22eSRoy Shterman NULL, num_sectors * iscsilun->block_size, 589583ec22eSRoy Shterman iscsilun->block_size, 0, 0, fua, 0, 0, 590583ec22eSRoy Shterman iscsi_co_generic_cb, &iTask, 591583ec22eSRoy Shterman (struct scsi_iovec *)iov->iov, iov->niov); 592583ec22eSRoy Shterman } else { 593583ec22eSRoy Shterman iTask.task = iscsi_write10_iov_task(iscsilun->iscsi, iscsilun->lun, lba, 594583ec22eSRoy Shterman NULL, num_sectors * iscsilun->block_size, 595583ec22eSRoy Shterman iscsilun->block_size, 0, 0, fua, 0, 0, 596583ec22eSRoy Shterman iscsi_co_generic_cb, &iTask, 597583ec22eSRoy Shterman (struct scsi_iovec *)iov->iov, iov->niov); 598583ec22eSRoy Shterman } 599583ec22eSRoy Shterman #else 600063c3378SPeter Lieven iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba, 6018c215a9fSPeter Lieven NULL, num_sectors * iscsilun->block_size, 60273b5394eSPeter Lieven iscsilun->block_size, 0, 0, fua, 0, 0, 603063c3378SPeter Lieven iscsi_co_generic_cb, &iTask); 6049281fe9eSPeter Lieven } else { 6059281fe9eSPeter Lieven iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba, 6068c215a9fSPeter Lieven NULL, num_sectors * iscsilun->block_size, 60773b5394eSPeter Lieven iscsilun->block_size, 0, 0, fua, 0, 0, 6089281fe9eSPeter Lieven iscsi_co_generic_cb, &iTask); 6099281fe9eSPeter Lieven } 610583ec22eSRoy Shterman #endif 611063c3378SPeter Lieven if (iTask.task == NULL) { 612f6eb0b31SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 61392397116SPeter Lieven return -ENOMEM; 614f4dfa67fSRonnie Sahlberg } 615583ec22eSRoy Shterman #if LIBISCSI_API_VERSION < (20160603) 616063c3378SPeter Lieven scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov, 617063c3378SPeter Lieven iov->niov); 618583ec22eSRoy Shterman #endif 619063c3378SPeter Lieven while (!iTask.complete) { 620063c3378SPeter Lieven iscsi_set_events(iscsilun); 621d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 622063c3378SPeter Lieven qemu_coroutine_yield(); 623d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 624c589b249SRonnie Sahlberg } 625c589b249SRonnie Sahlberg 626063c3378SPeter Lieven if (iTask.task != NULL) { 627063c3378SPeter Lieven scsi_free_scsi_task(iTask.task); 628063c3378SPeter Lieven iTask.task = NULL; 629063c3378SPeter Lieven } 630063c3378SPeter Lieven 631063c3378SPeter Lieven if (iTask.do_retry) { 632837c3901SPeter Lieven iTask.complete = 0; 633063c3378SPeter Lieven goto retry; 634063c3378SPeter Lieven } 635063c3378SPeter Lieven 636063c3378SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 63704a408fbSEric Blake iscsi_allocmap_set_invalid(iscsilun, sector_num * BDRV_SECTOR_SIZE, 63804a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE); 639e38bc234SPeter Lieven error_report("iSCSI WRITE10/16 failed at lba %" PRIu64 ": %s", lba, 640e38bc234SPeter Lieven iTask.err_str); 641d045c466SPaolo Bonzini r = iTask.err_code; 642d045c466SPaolo Bonzini goto out_unlock; 643063c3378SPeter Lieven } 6447371d56fSPeter Lieven 64504a408fbSEric Blake iscsi_allocmap_set_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE, 64604a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE); 647b03c3805SPeter Lieven 648d045c466SPaolo Bonzini out_unlock: 649d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 650e38bc234SPeter Lieven g_free(iTask.err_str); 651d045c466SPaolo Bonzini return r; 6521dde716eSPeter Lieven } 653c589b249SRonnie Sahlberg 654b03c3805SPeter Lieven 655b03c3805SPeter Lieven 65692809c36SEric Blake static int coroutine_fn iscsi_co_block_status(BlockDriverState *bs, 65792809c36SEric Blake bool want_zero, int64_t offset, 65892809c36SEric Blake int64_t bytes, int64_t *pnum, 65992809c36SEric Blake int64_t *map, 66067a0fd2aSFam Zheng BlockDriverState **file) 661b03c3805SPeter Lieven { 662b03c3805SPeter Lieven IscsiLun *iscsilun = bs->opaque; 663b03c3805SPeter Lieven struct scsi_get_lba_status *lbas = NULL; 664b03c3805SPeter Lieven struct scsi_lba_status_descriptor *lbasd = NULL; 665b03c3805SPeter Lieven struct IscsiTask iTask; 666e38bc234SPeter Lieven uint64_t lba; 66792809c36SEric Blake int ret; 668b03c3805SPeter Lieven 66979f9c75eSPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 67079f9c75eSPeter Lieven 67192809c36SEric Blake assert(QEMU_IS_ALIGNED(offset | bytes, iscsilun->block_size)); 672b03c3805SPeter Lieven 673b03c3805SPeter Lieven /* default to all sectors allocated */ 67492809c36SEric Blake ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; 67592809c36SEric Blake if (map) { 67692809c36SEric Blake *map = offset; 67792809c36SEric Blake } 67892809c36SEric Blake *pnum = bytes; 679b03c3805SPeter Lieven 680b03c3805SPeter Lieven /* LUN does not support logical block provisioning */ 6810a386e48SPeter Lieven if (!iscsilun->lbpme) { 682b03c3805SPeter Lieven goto out; 683b03c3805SPeter Lieven } 684b03c3805SPeter Lieven 68592809c36SEric Blake lba = offset / iscsilun->block_size; 686e38bc234SPeter Lieven 687d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 688b03c3805SPeter Lieven retry: 689b03c3805SPeter Lieven if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun, 690e38bc234SPeter Lieven lba, 8 + 16, iscsi_co_generic_cb, 691b03c3805SPeter Lieven &iTask) == NULL) { 692b03c3805SPeter Lieven ret = -ENOMEM; 693d045c466SPaolo Bonzini goto out_unlock; 694b03c3805SPeter Lieven } 695b03c3805SPeter Lieven 696b03c3805SPeter Lieven while (!iTask.complete) { 697b03c3805SPeter Lieven iscsi_set_events(iscsilun); 698d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 699b03c3805SPeter Lieven qemu_coroutine_yield(); 700d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 701b03c3805SPeter Lieven } 702b03c3805SPeter Lieven 703b03c3805SPeter Lieven if (iTask.do_retry) { 704b03c3805SPeter Lieven if (iTask.task != NULL) { 705b03c3805SPeter Lieven scsi_free_scsi_task(iTask.task); 706b03c3805SPeter Lieven iTask.task = NULL; 707b03c3805SPeter Lieven } 708b03c3805SPeter Lieven iTask.complete = 0; 709b03c3805SPeter Lieven goto retry; 710b03c3805SPeter Lieven } 711b03c3805SPeter Lieven 712b03c3805SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 713b03c3805SPeter Lieven /* in case the get_lba_status_callout fails (i.e. 714b03c3805SPeter Lieven * because the device is busy or the cmd is not 715b03c3805SPeter Lieven * supported) we pretend all blocks are allocated 716b03c3805SPeter Lieven * for backwards compatibility */ 717e38bc234SPeter Lieven error_report("iSCSI GET_LBA_STATUS failed at lba %" PRIu64 ": %s", 718e38bc234SPeter Lieven lba, iTask.err_str); 719d045c466SPaolo Bonzini goto out_unlock; 720b03c3805SPeter Lieven } 721b03c3805SPeter Lieven 722b03c3805SPeter Lieven lbas = scsi_datain_unmarshall(iTask.task); 723b03c3805SPeter Lieven if (lbas == NULL) { 724b03c3805SPeter Lieven ret = -EIO; 725d045c466SPaolo Bonzini goto out_unlock; 726b03c3805SPeter Lieven } 727b03c3805SPeter Lieven 728b03c3805SPeter Lieven lbasd = &lbas->descriptors[0]; 729b03c3805SPeter Lieven 73092809c36SEric Blake if (lba != lbasd->lba) { 731b03c3805SPeter Lieven ret = -EIO; 732d045c466SPaolo Bonzini goto out_unlock; 733b03c3805SPeter Lieven } 734b03c3805SPeter Lieven 73592809c36SEric Blake *pnum = lbasd->num_blocks * iscsilun->block_size; 736b03c3805SPeter Lieven 737b03c3805SPeter Lieven if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED || 738b03c3805SPeter Lieven lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) { 739b03c3805SPeter Lieven ret &= ~BDRV_BLOCK_DATA; 740b03c3805SPeter Lieven if (iscsilun->lbprz) { 741b03c3805SPeter Lieven ret |= BDRV_BLOCK_ZERO; 742b03c3805SPeter Lieven } 743b03c3805SPeter Lieven } 744b03c3805SPeter Lieven 745b03c3805SPeter Lieven if (ret & BDRV_BLOCK_ZERO) { 74692809c36SEric Blake iscsi_allocmap_set_unallocated(iscsilun, offset, *pnum); 747b03c3805SPeter Lieven } else { 74892809c36SEric Blake iscsi_allocmap_set_allocated(iscsilun, offset, *pnum); 749b03c3805SPeter Lieven } 750b03c3805SPeter Lieven 75192809c36SEric Blake if (*pnum > bytes) { 75292809c36SEric Blake *pnum = bytes; 753b03c3805SPeter Lieven } 754d045c466SPaolo Bonzini out_unlock: 755d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 756e38bc234SPeter Lieven g_free(iTask.err_str); 757b03c3805SPeter Lieven out: 758b03c3805SPeter Lieven if (iTask.task != NULL) { 759b03c3805SPeter Lieven scsi_free_scsi_task(iTask.task); 760b03c3805SPeter Lieven } 76192809c36SEric Blake if (ret > 0 && ret & BDRV_BLOCK_OFFSET_VALID && file) { 7623399833fSFam Zheng *file = bs; 7633399833fSFam Zheng } 764b03c3805SPeter Lieven return ret; 765b03c3805SPeter Lieven } 766b03c3805SPeter Lieven 767063c3378SPeter Lieven static int coroutine_fn iscsi_co_readv(BlockDriverState *bs, 768063c3378SPeter Lieven int64_t sector_num, int nb_sectors, 769063c3378SPeter Lieven QEMUIOVector *iov) 7701dde716eSPeter Lieven { 7711dde716eSPeter Lieven IscsiLun *iscsilun = bs->opaque; 772063c3378SPeter Lieven struct IscsiTask iTask; 7731dde716eSPeter Lieven uint64_t lba; 7741dde716eSPeter Lieven uint32_t num_sectors; 775e38bc234SPeter Lieven int r = 0; 776c589b249SRonnie Sahlberg 77794d047a3SEric Blake if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { 778063c3378SPeter Lieven return -EINVAL; 779f4dfa67fSRonnie Sahlberg } 780f4dfa67fSRonnie Sahlberg 7816bd01f14SEric Blake if (bs->bl.max_transfer) { 7826bd01f14SEric Blake assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer); 783dc9e7163SPeter Lieven } 784dc9e7163SPeter Lieven 785e1123a3bSPeter Lieven /* if cache.direct is off and we have a valid entry in our allocation map 786e1123a3bSPeter Lieven * we can skip checking the block status and directly return zeroes if 787e1123a3bSPeter Lieven * the request falls within an unallocated area */ 78804a408fbSEric Blake if (iscsi_allocmap_is_valid(iscsilun, sector_num * BDRV_SECTOR_SIZE, 78904a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE) && 79004a408fbSEric Blake !iscsi_allocmap_is_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE, 79104a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE)) { 792e1123a3bSPeter Lieven qemu_iovec_memset(iov, 0, 0x00, iov->size); 793e1123a3bSPeter Lieven return 0; 794e1123a3bSPeter Lieven } 795e1123a3bSPeter Lieven 796e1123a3bSPeter Lieven if (nb_sectors >= ISCSI_CHECKALLOC_THRES && 79704a408fbSEric Blake !iscsi_allocmap_is_valid(iscsilun, sector_num * BDRV_SECTOR_SIZE, 79804a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE) && 79904a408fbSEric Blake !iscsi_allocmap_is_allocated(iscsilun, sector_num * BDRV_SECTOR_SIZE, 80004a408fbSEric Blake nb_sectors * BDRV_SECTOR_SIZE)) { 80192809c36SEric Blake int64_t pnum; 802e1123a3bSPeter Lieven /* check the block status from the beginning of the cluster 803e1123a3bSPeter Lieven * containing the start sector */ 80492809c36SEric Blake int64_t head; 80592809c36SEric Blake int ret; 806ba059e7bSEric Blake 80792809c36SEric Blake assert(iscsilun->cluster_size); 80892809c36SEric Blake head = (sector_num * BDRV_SECTOR_SIZE) % iscsilun->cluster_size; 80992809c36SEric Blake ret = iscsi_co_block_status(bs, true, 81092809c36SEric Blake sector_num * BDRV_SECTOR_SIZE - head, 81192809c36SEric Blake BDRV_REQUEST_MAX_BYTES, &pnum, NULL, NULL); 812b03c3805SPeter Lieven if (ret < 0) { 813b03c3805SPeter Lieven return ret; 814b03c3805SPeter Lieven } 815e1123a3bSPeter Lieven /* if the whole request falls into an unallocated area we can avoid 816ba059e7bSEric Blake * reading and directly return zeroes instead */ 817e1123a3bSPeter Lieven if (ret & BDRV_BLOCK_ZERO && 81892809c36SEric Blake pnum >= nb_sectors * BDRV_SECTOR_SIZE + head) { 819b03c3805SPeter Lieven qemu_iovec_memset(iov, 0, 0x00, iov->size); 820b03c3805SPeter Lieven return 0; 821b03c3805SPeter Lieven } 822b03c3805SPeter Lieven } 823b03c3805SPeter Lieven 824063c3378SPeter Lieven lba = sector_qemu2lun(sector_num, iscsilun); 825063c3378SPeter Lieven num_sectors = sector_qemu2lun(nb_sectors, iscsilun); 826f4dfa67fSRonnie Sahlberg 827063c3378SPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 828d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 829063c3378SPeter Lieven retry: 8309281fe9eSPeter Lieven if (iscsilun->use_16_for_rw) { 831583ec22eSRoy Shterman #if LIBISCSI_API_VERSION >= (20160603) 832583ec22eSRoy Shterman iTask.task = iscsi_read16_iov_task(iscsilun->iscsi, iscsilun->lun, lba, 833583ec22eSRoy Shterman num_sectors * iscsilun->block_size, 834583ec22eSRoy Shterman iscsilun->block_size, 0, 0, 0, 0, 0, 835583ec22eSRoy Shterman iscsi_co_generic_cb, &iTask, 836583ec22eSRoy Shterman (struct scsi_iovec *)iov->iov, iov->niov); 837583ec22eSRoy Shterman } else { 838583ec22eSRoy Shterman iTask.task = iscsi_read10_iov_task(iscsilun->iscsi, iscsilun->lun, lba, 839583ec22eSRoy Shterman num_sectors * iscsilun->block_size, 840583ec22eSRoy Shterman iscsilun->block_size, 841583ec22eSRoy Shterman 0, 0, 0, 0, 0, 842583ec22eSRoy Shterman iscsi_co_generic_cb, &iTask, 843583ec22eSRoy Shterman (struct scsi_iovec *)iov->iov, iov->niov); 844583ec22eSRoy Shterman } 845583ec22eSRoy Shterman #else 846063c3378SPeter Lieven iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba, 847063c3378SPeter Lieven num_sectors * iscsilun->block_size, 848063c3378SPeter Lieven iscsilun->block_size, 0, 0, 0, 0, 0, 849063c3378SPeter Lieven iscsi_co_generic_cb, &iTask); 8509281fe9eSPeter Lieven } else { 851063c3378SPeter Lieven iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba, 852063c3378SPeter Lieven num_sectors * iscsilun->block_size, 853219c2521SStefan Weil iscsilun->block_size, 854219c2521SStefan Weil 0, 0, 0, 0, 0, 855063c3378SPeter Lieven iscsi_co_generic_cb, &iTask); 856f4dfa67fSRonnie Sahlberg } 857583ec22eSRoy Shterman #endif 858063c3378SPeter Lieven if (iTask.task == NULL) { 859f6eb0b31SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 86092397116SPeter Lieven return -ENOMEM; 861c589b249SRonnie Sahlberg } 862583ec22eSRoy Shterman #if LIBISCSI_API_VERSION < (20160603) 863063c3378SPeter Lieven scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov); 864583ec22eSRoy Shterman #endif 865063c3378SPeter Lieven while (!iTask.complete) { 866c589b249SRonnie Sahlberg iscsi_set_events(iscsilun); 867d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 868063c3378SPeter Lieven qemu_coroutine_yield(); 869d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 870c589b249SRonnie Sahlberg } 871c589b249SRonnie Sahlberg 872063c3378SPeter Lieven if (iTask.task != NULL) { 873063c3378SPeter Lieven scsi_free_scsi_task(iTask.task); 874063c3378SPeter Lieven iTask.task = NULL; 875c589b249SRonnie Sahlberg } 876c589b249SRonnie Sahlberg 877063c3378SPeter Lieven if (iTask.do_retry) { 878837c3901SPeter Lieven iTask.complete = 0; 879063c3378SPeter Lieven goto retry; 880c589b249SRonnie Sahlberg } 881c589b249SRonnie Sahlberg 882063c3378SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 883e38bc234SPeter Lieven error_report("iSCSI READ10/16 failed at lba %" PRIu64 ": %s", 884e38bc234SPeter Lieven lba, iTask.err_str); 885e38bc234SPeter Lieven r = iTask.err_code; 8861dde716eSPeter Lieven } 8871dde716eSPeter Lieven 888e38bc234SPeter Lieven qemu_mutex_unlock(&iscsilun->mutex); 889e38bc234SPeter Lieven g_free(iTask.err_str); 890e38bc234SPeter Lieven return r; 8911dde716eSPeter Lieven } 8921dde716eSPeter Lieven 893063c3378SPeter Lieven static int coroutine_fn iscsi_co_flush(BlockDriverState *bs) 8941dde716eSPeter Lieven { 8951dde716eSPeter Lieven IscsiLun *iscsilun = bs->opaque; 896063c3378SPeter Lieven struct IscsiTask iTask; 897e38bc234SPeter Lieven int r = 0; 8981dde716eSPeter Lieven 89973b5394eSPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 900d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 901063c3378SPeter Lieven retry: 902063c3378SPeter Lieven if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0, 903063c3378SPeter Lieven 0, iscsi_co_generic_cb, &iTask) == NULL) { 904f6eb0b31SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 90592397116SPeter Lieven return -ENOMEM; 906c589b249SRonnie Sahlberg } 907c589b249SRonnie Sahlberg 908063c3378SPeter Lieven while (!iTask.complete) { 909c589b249SRonnie Sahlberg iscsi_set_events(iscsilun); 910d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 911063c3378SPeter Lieven qemu_coroutine_yield(); 912d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 913063c3378SPeter Lieven } 914c589b249SRonnie Sahlberg 915063c3378SPeter Lieven if (iTask.task != NULL) { 916063c3378SPeter Lieven scsi_free_scsi_task(iTask.task); 917063c3378SPeter Lieven iTask.task = NULL; 918063c3378SPeter Lieven } 919063c3378SPeter Lieven 920063c3378SPeter Lieven if (iTask.do_retry) { 921837c3901SPeter Lieven iTask.complete = 0; 922063c3378SPeter Lieven goto retry; 923063c3378SPeter Lieven } 924063c3378SPeter Lieven 925063c3378SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 926e38bc234SPeter Lieven error_report("iSCSI SYNCHRONIZECACHE10 failed: %s", iTask.err_str); 927e38bc234SPeter Lieven r = iTask.err_code; 928063c3378SPeter Lieven } 929063c3378SPeter Lieven 930e38bc234SPeter Lieven qemu_mutex_unlock(&iscsilun->mutex); 931e38bc234SPeter Lieven g_free(iTask.err_str); 932e38bc234SPeter Lieven return r; 933c589b249SRonnie Sahlberg } 934c589b249SRonnie Sahlberg 93598392453SRonnie Sahlberg #ifdef __linux__ 936d045c466SPaolo Bonzini /* Called (via iscsi_service) with QemuMutex held. */ 93798392453SRonnie Sahlberg static void 93898392453SRonnie Sahlberg iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status, 93998392453SRonnie Sahlberg void *command_data, void *opaque) 94098392453SRonnie Sahlberg { 94198392453SRonnie Sahlberg IscsiAIOCB *acb = opaque; 94298392453SRonnie Sahlberg 9430a53f010SRonnie Sahlberg g_free(acb->buf); 9440a53f010SRonnie Sahlberg acb->buf = NULL; 9450a53f010SRonnie Sahlberg 94698392453SRonnie Sahlberg acb->status = 0; 94798392453SRonnie Sahlberg if (status < 0) { 94898392453SRonnie Sahlberg error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s", 94998392453SRonnie Sahlberg iscsi_get_error(iscsi)); 950e01dd3daSFam Zheng acb->status = iscsi_translate_sense(&acb->task->sense); 95198392453SRonnie Sahlberg } 95298392453SRonnie Sahlberg 95398392453SRonnie Sahlberg acb->ioh->driver_status = 0; 95498392453SRonnie Sahlberg acb->ioh->host_status = 0; 95598392453SRonnie Sahlberg acb->ioh->resid = 0; 956644c6869SVadim Rozenfeld acb->ioh->status = status; 95798392453SRonnie Sahlberg 95898392453SRonnie Sahlberg #define SG_ERR_DRIVER_SENSE 0x08 95998392453SRonnie Sahlberg 96098392453SRonnie Sahlberg if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) { 96198392453SRonnie Sahlberg int ss; 96298392453SRonnie Sahlberg 96398392453SRonnie Sahlberg acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE; 96498392453SRonnie Sahlberg 96598392453SRonnie Sahlberg acb->ioh->sb_len_wr = acb->task->datain.size - 2; 96698392453SRonnie Sahlberg ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ? 96798392453SRonnie Sahlberg acb->ioh->mx_sb_len : acb->ioh->sb_len_wr; 96898392453SRonnie Sahlberg memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss); 96998392453SRonnie Sahlberg } 97098392453SRonnie Sahlberg 971cfb3f506SPaolo Bonzini iscsi_schedule_bh(acb); 97298392453SRonnie Sahlberg } 97398392453SRonnie Sahlberg 9744bb17ab5SFam Zheng static void iscsi_ioctl_bh_completion(void *opaque) 9754bb17ab5SFam Zheng { 9764bb17ab5SFam Zheng IscsiAIOCB *acb = opaque; 9774bb17ab5SFam Zheng 9784bb17ab5SFam Zheng qemu_bh_delete(acb->bh); 9794bb17ab5SFam Zheng acb->common.cb(acb->common.opaque, acb->ret); 9804bb17ab5SFam Zheng qemu_aio_unref(acb); 9814bb17ab5SFam Zheng } 9824bb17ab5SFam Zheng 9834bb17ab5SFam Zheng static void iscsi_ioctl_handle_emulated(IscsiAIOCB *acb, int req, void *buf) 9844bb17ab5SFam Zheng { 9854bb17ab5SFam Zheng BlockDriverState *bs = acb->common.bs; 9864bb17ab5SFam Zheng IscsiLun *iscsilun = bs->opaque; 9874bb17ab5SFam Zheng int ret = 0; 9884bb17ab5SFam Zheng 9894bb17ab5SFam Zheng switch (req) { 9904bb17ab5SFam Zheng case SG_GET_VERSION_NUM: 9914bb17ab5SFam Zheng *(int *)buf = 30000; 9924bb17ab5SFam Zheng break; 9934bb17ab5SFam Zheng case SG_GET_SCSI_ID: 9944bb17ab5SFam Zheng ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type; 9954bb17ab5SFam Zheng break; 9964bb17ab5SFam Zheng default: 9974bb17ab5SFam Zheng ret = -EINVAL; 9984bb17ab5SFam Zheng } 9994bb17ab5SFam Zheng assert(!acb->bh); 10004bb17ab5SFam Zheng acb->bh = aio_bh_new(bdrv_get_aio_context(bs), 10014bb17ab5SFam Zheng iscsi_ioctl_bh_completion, acb); 10024bb17ab5SFam Zheng acb->ret = ret; 10034bb17ab5SFam Zheng qemu_bh_schedule(acb->bh); 10044bb17ab5SFam Zheng } 10054bb17ab5SFam Zheng 10067c84b1b8SMarkus Armbruster static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, 100798392453SRonnie Sahlberg unsigned long int req, void *buf, 1008097310b5SMarkus Armbruster BlockCompletionFunc *cb, void *opaque) 100998392453SRonnie Sahlberg { 101098392453SRonnie Sahlberg IscsiLun *iscsilun = bs->opaque; 101198392453SRonnie Sahlberg struct iscsi_context *iscsi = iscsilun->iscsi; 101298392453SRonnie Sahlberg struct iscsi_data data; 101398392453SRonnie Sahlberg IscsiAIOCB *acb; 101498392453SRonnie Sahlberg 1015d7331bedSStefan Hajnoczi acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque); 101698392453SRonnie Sahlberg 101798392453SRonnie Sahlberg acb->iscsilun = iscsilun; 10181bd075f2SPaolo Bonzini acb->bh = NULL; 10191bd075f2SPaolo Bonzini acb->status = -EINPROGRESS; 102098392453SRonnie Sahlberg acb->buf = NULL; 102198392453SRonnie Sahlberg acb->ioh = buf; 102298392453SRonnie Sahlberg 10234bb17ab5SFam Zheng if (req != SG_IO) { 10244bb17ab5SFam Zheng iscsi_ioctl_handle_emulated(acb, req, buf); 10254bb17ab5SFam Zheng return &acb->common; 10264bb17ab5SFam Zheng } 10274bb17ab5SFam Zheng 1028a6b3167fSPeter Lieven if (acb->ioh->cmd_len > SCSI_CDB_MAX_SIZE) { 1029a6b3167fSPeter Lieven error_report("iSCSI: ioctl error CDB exceeds max size (%d > %d)", 1030a6b3167fSPeter Lieven acb->ioh->cmd_len, SCSI_CDB_MAX_SIZE); 1031a6b3167fSPeter Lieven qemu_aio_unref(acb); 1032a6b3167fSPeter Lieven return NULL; 1033a6b3167fSPeter Lieven } 1034a6b3167fSPeter Lieven 103598392453SRonnie Sahlberg acb->task = malloc(sizeof(struct scsi_task)); 103698392453SRonnie Sahlberg if (acb->task == NULL) { 103798392453SRonnie Sahlberg error_report("iSCSI: Failed to allocate task for scsi command. %s", 103898392453SRonnie Sahlberg iscsi_get_error(iscsi)); 10398007429aSFam Zheng qemu_aio_unref(acb); 104098392453SRonnie Sahlberg return NULL; 104198392453SRonnie Sahlberg } 104298392453SRonnie Sahlberg memset(acb->task, 0, sizeof(struct scsi_task)); 104398392453SRonnie Sahlberg 104498392453SRonnie Sahlberg switch (acb->ioh->dxfer_direction) { 104598392453SRonnie Sahlberg case SG_DXFER_TO_DEV: 104698392453SRonnie Sahlberg acb->task->xfer_dir = SCSI_XFER_WRITE; 104798392453SRonnie Sahlberg break; 104898392453SRonnie Sahlberg case SG_DXFER_FROM_DEV: 104998392453SRonnie Sahlberg acb->task->xfer_dir = SCSI_XFER_READ; 105098392453SRonnie Sahlberg break; 105198392453SRonnie Sahlberg default: 105298392453SRonnie Sahlberg acb->task->xfer_dir = SCSI_XFER_NONE; 105398392453SRonnie Sahlberg break; 105498392453SRonnie Sahlberg } 105598392453SRonnie Sahlberg 105698392453SRonnie Sahlberg acb->task->cdb_size = acb->ioh->cmd_len; 105798392453SRonnie Sahlberg memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len); 105898392453SRonnie Sahlberg acb->task->expxferlen = acb->ioh->dxfer_len; 105998392453SRonnie Sahlberg 10600a53f010SRonnie Sahlberg data.size = 0; 1061d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 106298392453SRonnie Sahlberg if (acb->task->xfer_dir == SCSI_XFER_WRITE) { 10630a53f010SRonnie Sahlberg if (acb->ioh->iovec_count == 0) { 106498392453SRonnie Sahlberg data.data = acb->ioh->dxferp; 106598392453SRonnie Sahlberg data.size = acb->ioh->dxfer_len; 10660a53f010SRonnie Sahlberg } else { 10670a53f010SRonnie Sahlberg scsi_task_set_iov_out(acb->task, 10680a53f010SRonnie Sahlberg (struct scsi_iovec *) acb->ioh->dxferp, 10690a53f010SRonnie Sahlberg acb->ioh->iovec_count); 107098392453SRonnie Sahlberg } 10710a53f010SRonnie Sahlberg } 10720a53f010SRonnie Sahlberg 107398392453SRonnie Sahlberg if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, 107498392453SRonnie Sahlberg iscsi_aio_ioctl_cb, 10750a53f010SRonnie Sahlberg (data.size > 0) ? &data : NULL, 107698392453SRonnie Sahlberg acb) != 0) { 1077d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 107898392453SRonnie Sahlberg scsi_free_scsi_task(acb->task); 10798007429aSFam Zheng qemu_aio_unref(acb); 108098392453SRonnie Sahlberg return NULL; 108198392453SRonnie Sahlberg } 108298392453SRonnie Sahlberg 108398392453SRonnie Sahlberg /* tell libiscsi to read straight into the buffer we got from ioctl */ 108498392453SRonnie Sahlberg if (acb->task->xfer_dir == SCSI_XFER_READ) { 10850a53f010SRonnie Sahlberg if (acb->ioh->iovec_count == 0) { 108698392453SRonnie Sahlberg scsi_task_add_data_in_buffer(acb->task, 108798392453SRonnie Sahlberg acb->ioh->dxfer_len, 108898392453SRonnie Sahlberg acb->ioh->dxferp); 10890a53f010SRonnie Sahlberg } else { 10900a53f010SRonnie Sahlberg scsi_task_set_iov_in(acb->task, 10910a53f010SRonnie Sahlberg (struct scsi_iovec *) acb->ioh->dxferp, 10920a53f010SRonnie Sahlberg acb->ioh->iovec_count); 10930a53f010SRonnie Sahlberg } 109498392453SRonnie Sahlberg } 109598392453SRonnie Sahlberg 109698392453SRonnie Sahlberg iscsi_set_events(iscsilun); 1097d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 109898392453SRonnie Sahlberg 109998392453SRonnie Sahlberg return &acb->common; 110098392453SRonnie Sahlberg } 110198392453SRonnie Sahlberg 110298392453SRonnie Sahlberg #endif 110398392453SRonnie Sahlberg 1104c589b249SRonnie Sahlberg static int64_t 1105c589b249SRonnie Sahlberg iscsi_getlength(BlockDriverState *bs) 1106c589b249SRonnie Sahlberg { 1107c589b249SRonnie Sahlberg IscsiLun *iscsilun = bs->opaque; 1108c589b249SRonnie Sahlberg int64_t len; 1109c589b249SRonnie Sahlberg 1110c589b249SRonnie Sahlberg len = iscsilun->num_blocks; 1111c589b249SRonnie Sahlberg len *= iscsilun->block_size; 1112c589b249SRonnie Sahlberg 1113c589b249SRonnie Sahlberg return len; 1114c589b249SRonnie Sahlberg } 1115c589b249SRonnie Sahlberg 111665f3e339SPeter Lieven static int 1117f5a5ca79SManos Pitsidianakis coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes) 111865f3e339SPeter Lieven { 111965f3e339SPeter Lieven IscsiLun *iscsilun = bs->opaque; 112065f3e339SPeter Lieven struct IscsiTask iTask; 112165f3e339SPeter Lieven struct unmap_list list; 1122d045c466SPaolo Bonzini int r = 0; 112365f3e339SPeter Lieven 1124f5a5ca79SManos Pitsidianakis if (!is_byte_request_lun_aligned(offset, bytes, iscsilun)) { 112549228d1eSEric Blake return -ENOTSUP; 112649228d1eSEric Blake } 112765f3e339SPeter Lieven 112865f3e339SPeter Lieven if (!iscsilun->lbp.lbpu) { 112965f3e339SPeter Lieven /* UNMAP is not supported by the target */ 113065f3e339SPeter Lieven return 0; 113165f3e339SPeter Lieven } 113265f3e339SPeter Lieven 113397c7e85cSEric Blake list.lba = offset / iscsilun->block_size; 1134f5a5ca79SManos Pitsidianakis list.num = bytes / iscsilun->block_size; 113565f3e339SPeter Lieven 113665f3e339SPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 1137d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 113865f3e339SPeter Lieven retry: 113965f3e339SPeter Lieven if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1, 114065f3e339SPeter Lieven iscsi_co_generic_cb, &iTask) == NULL) { 1141d045c466SPaolo Bonzini r = -ENOMEM; 1142d045c466SPaolo Bonzini goto out_unlock; 114365f3e339SPeter Lieven } 114465f3e339SPeter Lieven 114565f3e339SPeter Lieven while (!iTask.complete) { 114665f3e339SPeter Lieven iscsi_set_events(iscsilun); 1147d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 114865f3e339SPeter Lieven qemu_coroutine_yield(); 1149d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 115065f3e339SPeter Lieven } 115165f3e339SPeter Lieven 115265f3e339SPeter Lieven if (iTask.task != NULL) { 115365f3e339SPeter Lieven scsi_free_scsi_task(iTask.task); 115465f3e339SPeter Lieven iTask.task = NULL; 115565f3e339SPeter Lieven } 115665f3e339SPeter Lieven 115765f3e339SPeter Lieven if (iTask.do_retry) { 1158837c3901SPeter Lieven iTask.complete = 0; 115965f3e339SPeter Lieven goto retry; 116065f3e339SPeter Lieven } 116165f3e339SPeter Lieven 116204a408fbSEric Blake iscsi_allocmap_set_invalid(iscsilun, offset, bytes); 1163aef172ffSPeter Lieven 116465f3e339SPeter Lieven if (iTask.status == SCSI_STATUS_CHECK_CONDITION) { 116565f3e339SPeter Lieven /* the target might fail with a check condition if it 116665f3e339SPeter Lieven is not happy with the alignment of the UNMAP request 116765f3e339SPeter Lieven we silently fail in this case */ 1168d045c466SPaolo Bonzini goto out_unlock; 116965f3e339SPeter Lieven } 117065f3e339SPeter Lieven 117165f3e339SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 1172e38bc234SPeter Lieven error_report("iSCSI UNMAP failed at lba %" PRIu64 ": %s", 1173e38bc234SPeter Lieven list.lba, iTask.err_str); 1174d045c466SPaolo Bonzini r = iTask.err_code; 1175d045c466SPaolo Bonzini goto out_unlock; 117665f3e339SPeter Lieven } 117765f3e339SPeter Lieven 1178d045c466SPaolo Bonzini out_unlock: 1179d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 1180e38bc234SPeter Lieven g_free(iTask.err_str); 1181d045c466SPaolo Bonzini return r; 118265f3e339SPeter Lieven } 118365f3e339SPeter Lieven 1184d4cd9615SPeter Lieven static int 118594d047a3SEric Blake coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, 1186f5a5ca79SManos Pitsidianakis int bytes, BdrvRequestFlags flags) 1187d4cd9615SPeter Lieven { 1188d4cd9615SPeter Lieven IscsiLun *iscsilun = bs->opaque; 1189d4cd9615SPeter Lieven struct IscsiTask iTask; 1190d4cd9615SPeter Lieven uint64_t lba; 1191d4cd9615SPeter Lieven uint32_t nb_blocks; 11929281fe9eSPeter Lieven bool use_16_for_ws = iscsilun->use_16_for_rw; 1193d045c466SPaolo Bonzini int r = 0; 1194d4cd9615SPeter Lieven 1195f5a5ca79SManos Pitsidianakis if (!is_byte_request_lun_aligned(offset, bytes, iscsilun)) { 119694d047a3SEric Blake return -ENOTSUP; 1197d4cd9615SPeter Lieven } 1198d4cd9615SPeter Lieven 11999281fe9eSPeter Lieven if (flags & BDRV_REQ_MAY_UNMAP) { 12009281fe9eSPeter Lieven if (!use_16_for_ws && !iscsilun->lbp.lbpws10) { 12019281fe9eSPeter Lieven /* WRITESAME10 with UNMAP is unsupported try WRITESAME16 */ 12029281fe9eSPeter Lieven use_16_for_ws = true; 12039281fe9eSPeter Lieven } 12049281fe9eSPeter Lieven if (use_16_for_ws && !iscsilun->lbp.lbpws) { 12059281fe9eSPeter Lieven /* WRITESAME16 with UNMAP is not supported by the target, 12069281fe9eSPeter Lieven * fall back and try WRITESAME10/16 without UNMAP */ 1207dbe5c58fSPeter Lieven flags &= ~BDRV_REQ_MAY_UNMAP; 12089281fe9eSPeter Lieven use_16_for_ws = iscsilun->use_16_for_rw; 12099281fe9eSPeter Lieven } 1210fa6252b0SPaolo Bonzini } 1211fa6252b0SPaolo Bonzini 1212dbe5c58fSPeter Lieven if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) { 1213dbe5c58fSPeter Lieven /* WRITESAME without UNMAP is not supported by the target */ 1214d4cd9615SPeter Lieven return -ENOTSUP; 1215d4cd9615SPeter Lieven } 1216d4cd9615SPeter Lieven 121794d047a3SEric Blake lba = offset / iscsilun->block_size; 1218f5a5ca79SManos Pitsidianakis nb_blocks = bytes / iscsilun->block_size; 1219d4cd9615SPeter Lieven 1220d4cd9615SPeter Lieven if (iscsilun->zeroblock == NULL) { 12214d5a3f88SKevin Wolf iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size); 12224d5a3f88SKevin Wolf if (iscsilun->zeroblock == NULL) { 12234d5a3f88SKevin Wolf return -ENOMEM; 12244d5a3f88SKevin Wolf } 1225d4cd9615SPeter Lieven } 1226d4cd9615SPeter Lieven 1227d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 1228d4cd9615SPeter Lieven iscsi_co_init_iscsitask(iscsilun, &iTask); 1229d4cd9615SPeter Lieven retry: 12309281fe9eSPeter Lieven if (use_16_for_ws) { 12319281fe9eSPeter Lieven iTask.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba, 1232d4cd9615SPeter Lieven iscsilun->zeroblock, iscsilun->block_size, 1233d4cd9615SPeter Lieven nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP), 12349281fe9eSPeter Lieven 0, 0, iscsi_co_generic_cb, &iTask); 12359281fe9eSPeter Lieven } else { 12369281fe9eSPeter Lieven iTask.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba, 12379281fe9eSPeter Lieven iscsilun->zeroblock, iscsilun->block_size, 12389281fe9eSPeter Lieven nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP), 12399281fe9eSPeter Lieven 0, 0, iscsi_co_generic_cb, &iTask); 12409281fe9eSPeter Lieven } 12419281fe9eSPeter Lieven if (iTask.task == NULL) { 1242f6eb0b31SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 124392397116SPeter Lieven return -ENOMEM; 1244d4cd9615SPeter Lieven } 1245d4cd9615SPeter Lieven 1246d4cd9615SPeter Lieven while (!iTask.complete) { 1247d4cd9615SPeter Lieven iscsi_set_events(iscsilun); 1248d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 1249d4cd9615SPeter Lieven qemu_coroutine_yield(); 1250d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 1251d4cd9615SPeter Lieven } 1252d4cd9615SPeter Lieven 1253d9738fd2SPeter Lieven if (iTask.status == SCSI_STATUS_CHECK_CONDITION && 1254d9738fd2SPeter Lieven iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST && 125527898a5dSPaolo Bonzini (iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE || 125627898a5dSPaolo Bonzini iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) { 1257d9738fd2SPeter Lieven /* WRITE SAME is not supported by the target */ 1258d9738fd2SPeter Lieven iscsilun->has_write_same = false; 1259d9738fd2SPeter Lieven scsi_free_scsi_task(iTask.task); 1260d045c466SPaolo Bonzini r = -ENOTSUP; 1261d045c466SPaolo Bonzini goto out_unlock; 1262d9738fd2SPeter Lieven } 1263d9738fd2SPeter Lieven 1264d4cd9615SPeter Lieven if (iTask.task != NULL) { 1265d4cd9615SPeter Lieven scsi_free_scsi_task(iTask.task); 1266d4cd9615SPeter Lieven iTask.task = NULL; 1267d4cd9615SPeter Lieven } 1268d4cd9615SPeter Lieven 1269d4cd9615SPeter Lieven if (iTask.do_retry) { 1270837c3901SPeter Lieven iTask.complete = 0; 1271d4cd9615SPeter Lieven goto retry; 1272d4cd9615SPeter Lieven } 1273d4cd9615SPeter Lieven 1274d4cd9615SPeter Lieven if (iTask.status != SCSI_STATUS_GOOD) { 127504a408fbSEric Blake iscsi_allocmap_set_invalid(iscsilun, offset, bytes); 1276e38bc234SPeter Lieven error_report("iSCSI WRITESAME10/16 failed at lba %" PRIu64 ": %s", 1277e38bc234SPeter Lieven lba, iTask.err_str); 1278d045c466SPaolo Bonzini r = iTask.err_code; 1279d045c466SPaolo Bonzini goto out_unlock; 1280d4cd9615SPeter Lieven } 1281d4cd9615SPeter Lieven 1282b03c3805SPeter Lieven if (flags & BDRV_REQ_MAY_UNMAP) { 128304a408fbSEric Blake iscsi_allocmap_set_invalid(iscsilun, offset, bytes); 1284b03c3805SPeter Lieven } else { 128504a408fbSEric Blake iscsi_allocmap_set_allocated(iscsilun, offset, bytes); 1286b03c3805SPeter Lieven } 1287b03c3805SPeter Lieven 1288d045c466SPaolo Bonzini out_unlock: 1289d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 1290e38bc234SPeter Lieven g_free(iTask.err_str); 1291d045c466SPaolo Bonzini return r; 1292d4cd9615SPeter Lieven } 1293d4cd9615SPeter Lieven 129443171420SKevin Wolf static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts, 1295f2917853SPaolo Bonzini Error **errp) 1296f9dadc98SRonnie Sahlberg { 1297f9dadc98SRonnie Sahlberg const char *user = NULL; 1298f9dadc98SRonnie Sahlberg const char *password = NULL; 1299b189346eSDaniel P. Berrange const char *secretid; 1300b189346eSDaniel P. Berrange char *secret = NULL; 1301f9dadc98SRonnie Sahlberg 1302f9dadc98SRonnie Sahlberg user = qemu_opt_get(opts, "user"); 1303f9dadc98SRonnie Sahlberg if (!user) { 1304f2917853SPaolo Bonzini return; 1305f9dadc98SRonnie Sahlberg } 1306f9dadc98SRonnie Sahlberg 1307b189346eSDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 1308f9dadc98SRonnie Sahlberg password = qemu_opt_get(opts, "password"); 1309b189346eSDaniel P. Berrange if (secretid && password) { 1310b189346eSDaniel P. Berrange error_setg(errp, "'password' and 'password-secret' properties are " 1311b189346eSDaniel P. Berrange "mutually exclusive"); 1312b189346eSDaniel P. Berrange return; 1313b189346eSDaniel P. Berrange } 1314b189346eSDaniel P. Berrange if (secretid) { 1315b189346eSDaniel P. Berrange secret = qcrypto_secret_lookup_as_utf8(secretid, errp); 1316b189346eSDaniel P. Berrange if (!secret) { 1317b189346eSDaniel P. Berrange return; 1318b189346eSDaniel P. Berrange } 1319b189346eSDaniel P. Berrange password = secret; 1320b189346eSDaniel P. Berrange } else if (!password) { 1321f2917853SPaolo Bonzini error_setg(errp, "CHAP username specified but no password was given"); 1322f2917853SPaolo Bonzini return; 1323f9dadc98SRonnie Sahlberg } 1324f9dadc98SRonnie Sahlberg 1325f9dadc98SRonnie Sahlberg if (iscsi_set_initiator_username_pwd(iscsi, user, password)) { 1326f2917853SPaolo Bonzini error_setg(errp, "Failed to set initiator username and password"); 1327f2917853SPaolo Bonzini } 1328b189346eSDaniel P. Berrange 1329b189346eSDaniel P. Berrange g_free(secret); 1330f9dadc98SRonnie Sahlberg } 1331f9dadc98SRonnie Sahlberg 133281aa2a0fSKevin Wolf static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts, 1333f2917853SPaolo Bonzini Error **errp) 1334f9dadc98SRonnie Sahlberg { 1335f9dadc98SRonnie Sahlberg const char *digest = NULL; 1336f9dadc98SRonnie Sahlberg 1337f9dadc98SRonnie Sahlberg digest = qemu_opt_get(opts, "header-digest"); 1338f9dadc98SRonnie Sahlberg if (!digest) { 133981aa2a0fSKevin Wolf iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 134031eb1202SKevin Wolf } else if (!strcmp(digest, "crc32c")) { 1341f9dadc98SRonnie Sahlberg iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C); 134231eb1202SKevin Wolf } else if (!strcmp(digest, "none")) { 1343f9dadc98SRonnie Sahlberg iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE); 134431eb1202SKevin Wolf } else if (!strcmp(digest, "crc32c-none")) { 1345f9dadc98SRonnie Sahlberg iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE); 134631eb1202SKevin Wolf } else if (!strcmp(digest, "none-crc32c")) { 1347f9dadc98SRonnie Sahlberg iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C); 1348f9dadc98SRonnie Sahlberg } else { 1349f2917853SPaolo Bonzini error_setg(errp, "Invalid header-digest setting : %s", digest); 1350f9dadc98SRonnie Sahlberg } 1351f9dadc98SRonnie Sahlberg } 1352f9dadc98SRonnie Sahlberg 1353d4e79929SKevin Wolf static char *get_initiator_name(QemuOpts *opts) 1354f9dadc98SRonnie Sahlberg { 13555accc840SPaolo Bonzini const char *name; 13565accc840SPaolo Bonzini char *iscsi_name; 13575accc840SPaolo Bonzini UuidInfo *uuid_info; 1358f9dadc98SRonnie Sahlberg 1359f9dadc98SRonnie Sahlberg name = qemu_opt_get(opts, "initiator-name"); 13605accc840SPaolo Bonzini if (name) { 13615accc840SPaolo Bonzini return g_strdup(name); 13625accc840SPaolo Bonzini } 1363f9dadc98SRonnie Sahlberg 13645accc840SPaolo Bonzini uuid_info = qmp_query_uuid(NULL); 13655accc840SPaolo Bonzini if (strcmp(uuid_info->UUID, UUID_NONE) == 0) { 13665accc840SPaolo Bonzini name = qemu_get_vm_name(); 1367f2ef4a6dSPaolo Bonzini } else { 13685accc840SPaolo Bonzini name = uuid_info->UUID; 1369f2ef4a6dSPaolo Bonzini } 13705accc840SPaolo Bonzini iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s", 13715accc840SPaolo Bonzini name ? ":" : "", name ? name : ""); 13725accc840SPaolo Bonzini qapi_free_UuidInfo(uuid_info); 13735accc840SPaolo Bonzini return iscsi_name; 1374f9dadc98SRonnie Sahlberg } 1375f9dadc98SRonnie Sahlberg 13765b5d34ecSPeter Lieven static void iscsi_nop_timed_event(void *opaque) 13775b5d34ecSPeter Lieven { 13785b5d34ecSPeter Lieven IscsiLun *iscsilun = opaque; 13795b5d34ecSPeter Lieven 1380d045c466SPaolo Bonzini qemu_mutex_lock(&iscsilun->mutex); 13815dd7a535SPeter Lieven if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) { 13825b5d34ecSPeter Lieven error_report("iSCSI: NOP timeout. Reconnecting..."); 13835dd7a535SPeter Lieven iscsilun->request_timed_out = true; 13845dd7a535SPeter Lieven } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) { 13855b5d34ecSPeter Lieven error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages."); 13862f47da5fSPaolo Bonzini goto out; 13875b5d34ecSPeter Lieven } 13885b5d34ecSPeter Lieven 1389bc72ad67SAlex Bligh timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL); 13905b5d34ecSPeter Lieven iscsi_set_events(iscsilun); 13912f47da5fSPaolo Bonzini 13922f47da5fSPaolo Bonzini out: 1393d045c466SPaolo Bonzini qemu_mutex_unlock(&iscsilun->mutex); 13945b5d34ecSPeter Lieven } 13955b5d34ecSPeter Lieven 1396f2917853SPaolo Bonzini static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp) 1397cb1b83e7SPeter Lieven { 1398cb1b83e7SPeter Lieven struct scsi_task *task = NULL; 1399cb1b83e7SPeter Lieven struct scsi_readcapacity10 *rc10 = NULL; 1400cb1b83e7SPeter Lieven struct scsi_readcapacity16 *rc16 = NULL; 1401cb1b83e7SPeter Lieven int retries = ISCSI_CMD_RETRIES; 1402cb1b83e7SPeter Lieven 14031288844eSPaolo Bonzini do { 14041288844eSPaolo Bonzini if (task != NULL) { 14051288844eSPaolo Bonzini scsi_free_scsi_task(task); 14061288844eSPaolo Bonzini task = NULL; 14071288844eSPaolo Bonzini } 14081288844eSPaolo Bonzini 1409cb1b83e7SPeter Lieven switch (iscsilun->type) { 1410cb1b83e7SPeter Lieven case TYPE_DISK: 1411cb1b83e7SPeter Lieven task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun); 14121288844eSPaolo Bonzini if (task != NULL && task->status == SCSI_STATUS_GOOD) { 1413cb1b83e7SPeter Lieven rc16 = scsi_datain_unmarshall(task); 1414cb1b83e7SPeter Lieven if (rc16 == NULL) { 1415f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to unmarshall readcapacity16 data."); 14161288844eSPaolo Bonzini } else { 1417cb1b83e7SPeter Lieven iscsilun->block_size = rc16->block_length; 1418cb1b83e7SPeter Lieven iscsilun->num_blocks = rc16->returned_lba + 1; 14190a386e48SPeter Lieven iscsilun->lbpme = !!rc16->lbpme; 14200a386e48SPeter Lieven iscsilun->lbprz = !!rc16->lbprz; 14219281fe9eSPeter Lieven iscsilun->use_16_for_rw = (rc16->returned_lba > 0xffffffff); 14221288844eSPaolo Bonzini } 1423cb1b83e7SPeter Lieven break; 14241cb6d137SZhu Lingshan } 14251cb6d137SZhu Lingshan if (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION 14261cb6d137SZhu Lingshan && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) { 14271cb6d137SZhu Lingshan break; 14281cb6d137SZhu Lingshan } 14291cb6d137SZhu Lingshan /* Fall through and try READ CAPACITY(10) instead. */ 1430cb1b83e7SPeter Lieven case TYPE_ROM: 1431cb1b83e7SPeter Lieven task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0); 14321288844eSPaolo Bonzini if (task != NULL && task->status == SCSI_STATUS_GOOD) { 1433cb1b83e7SPeter Lieven rc10 = scsi_datain_unmarshall(task); 1434cb1b83e7SPeter Lieven if (rc10 == NULL) { 1435f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to unmarshall readcapacity10 data."); 14361288844eSPaolo Bonzini } else { 1437cb1b83e7SPeter Lieven iscsilun->block_size = rc10->block_size; 1438cb1b83e7SPeter Lieven if (rc10->lba == 0) { 1439cb1b83e7SPeter Lieven /* blank disk loaded */ 1440cb1b83e7SPeter Lieven iscsilun->num_blocks = 0; 1441cb1b83e7SPeter Lieven } else { 1442cb1b83e7SPeter Lieven iscsilun->num_blocks = rc10->lba + 1; 1443cb1b83e7SPeter Lieven } 14441288844eSPaolo Bonzini } 14451288844eSPaolo Bonzini } 1446cb1b83e7SPeter Lieven break; 1447cb1b83e7SPeter Lieven default: 1448f2917853SPaolo Bonzini return; 1449cb1b83e7SPeter Lieven } 14501288844eSPaolo Bonzini } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION 14511288844eSPaolo Bonzini && task->sense.key == SCSI_SENSE_UNIT_ATTENTION 14521288844eSPaolo Bonzini && retries-- > 0); 1453cb1b83e7SPeter Lieven 14541288844eSPaolo Bonzini if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1455240125bcSZhu Lingshan error_setg(errp, "iSCSI: failed to send readcapacity10/16 command"); 14566d1f252dSPeter Lieven } else if (!iscsilun->block_size || 14576d1f252dSPeter Lieven iscsilun->block_size % BDRV_SECTOR_SIZE) { 14586d1f252dSPeter Lieven error_setg(errp, "iSCSI: the target returned an invalid " 14596d1f252dSPeter Lieven "block size of %d.", iscsilun->block_size); 14601288844eSPaolo Bonzini } 1461cb1b83e7SPeter Lieven if (task) { 1462cb1b83e7SPeter Lieven scsi_free_scsi_task(task); 1463cb1b83e7SPeter Lieven } 1464cb1b83e7SPeter Lieven } 1465cb1b83e7SPeter Lieven 146635cb1748SPaolo Bonzini static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun, 146724d3bd67SPeter Lieven int evpd, int pc, void **inq, Error **errp) 146835cb1748SPaolo Bonzini { 1469f18a7cbbSPeter Lieven int full_size; 1470f18a7cbbSPeter Lieven struct scsi_task *task = NULL; 1471f18a7cbbSPeter Lieven task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64); 1472f18a7cbbSPeter Lieven if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1473f18a7cbbSPeter Lieven goto fail; 1474f18a7cbbSPeter Lieven } 1475f18a7cbbSPeter Lieven full_size = scsi_datain_getfullsize(task); 1476f18a7cbbSPeter Lieven if (full_size > task->datain.size) { 1477f18a7cbbSPeter Lieven scsi_free_scsi_task(task); 1478f18a7cbbSPeter Lieven 1479f18a7cbbSPeter Lieven /* we need more data for the full list */ 1480f18a7cbbSPeter Lieven task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size); 1481f18a7cbbSPeter Lieven if (task == NULL || task->status != SCSI_STATUS_GOOD) { 1482f18a7cbbSPeter Lieven goto fail; 1483f18a7cbbSPeter Lieven } 1484f18a7cbbSPeter Lieven } 1485f18a7cbbSPeter Lieven 148624d3bd67SPeter Lieven *inq = scsi_datain_unmarshall(task); 148724d3bd67SPeter Lieven if (*inq == NULL) { 148824d3bd67SPeter Lieven error_setg(errp, "iSCSI: failed to unmarshall inquiry datain blob"); 1489172fc4ddSMarkus Armbruster goto fail_with_err; 149024d3bd67SPeter Lieven } 149124d3bd67SPeter Lieven 1492f18a7cbbSPeter Lieven return task; 1493f18a7cbbSPeter Lieven 1494f18a7cbbSPeter Lieven fail: 1495f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Inquiry command failed : %s", 1496f18a7cbbSPeter Lieven iscsi_get_error(iscsi)); 1497172fc4ddSMarkus Armbruster fail_with_err: 149824d3bd67SPeter Lieven if (task != NULL) { 1499f18a7cbbSPeter Lieven scsi_free_scsi_task(task); 1500f18a7cbbSPeter Lieven } 1501f18a7cbbSPeter Lieven return NULL; 1502f18a7cbbSPeter Lieven } 1503f18a7cbbSPeter Lieven 150480cf6257SStefan Hajnoczi static void iscsi_detach_aio_context(BlockDriverState *bs) 150580cf6257SStefan Hajnoczi { 150680cf6257SStefan Hajnoczi IscsiLun *iscsilun = bs->opaque; 150780cf6257SStefan Hajnoczi 1508dca21ef2SFam Zheng aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi), 1509f6a51c84SStefan Hajnoczi false, NULL, NULL, NULL, NULL); 151080cf6257SStefan Hajnoczi iscsilun->events = 0; 151180cf6257SStefan Hajnoczi 151280cf6257SStefan Hajnoczi if (iscsilun->nop_timer) { 151380cf6257SStefan Hajnoczi timer_del(iscsilun->nop_timer); 151480cf6257SStefan Hajnoczi timer_free(iscsilun->nop_timer); 151580cf6257SStefan Hajnoczi iscsilun->nop_timer = NULL; 151680cf6257SStefan Hajnoczi } 151705b685fbSPeter Lieven if (iscsilun->event_timer) { 151805b685fbSPeter Lieven timer_del(iscsilun->event_timer); 151905b685fbSPeter Lieven timer_free(iscsilun->event_timer); 152005b685fbSPeter Lieven iscsilun->event_timer = NULL; 152105b685fbSPeter Lieven } 152280cf6257SStefan Hajnoczi } 152380cf6257SStefan Hajnoczi 152480cf6257SStefan Hajnoczi static void iscsi_attach_aio_context(BlockDriverState *bs, 152580cf6257SStefan Hajnoczi AioContext *new_context) 152680cf6257SStefan Hajnoczi { 152780cf6257SStefan Hajnoczi IscsiLun *iscsilun = bs->opaque; 152880cf6257SStefan Hajnoczi 152980cf6257SStefan Hajnoczi iscsilun->aio_context = new_context; 153080cf6257SStefan Hajnoczi iscsi_set_events(iscsilun); 153180cf6257SStefan Hajnoczi 153280cf6257SStefan Hajnoczi /* Set up a timer for sending out iSCSI NOPs */ 153380cf6257SStefan Hajnoczi iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context, 153480cf6257SStefan Hajnoczi QEMU_CLOCK_REALTIME, SCALE_MS, 153580cf6257SStefan Hajnoczi iscsi_nop_timed_event, iscsilun); 153680cf6257SStefan Hajnoczi timer_mod(iscsilun->nop_timer, 153780cf6257SStefan Hajnoczi qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL); 153805b685fbSPeter Lieven 15395dd7a535SPeter Lieven /* Set up a timer for periodic calls to iscsi_set_events and to 15405dd7a535SPeter Lieven * scan for command timeout */ 154105b685fbSPeter Lieven iscsilun->event_timer = aio_timer_new(iscsilun->aio_context, 154205b685fbSPeter Lieven QEMU_CLOCK_REALTIME, SCALE_MS, 15435dd7a535SPeter Lieven iscsi_timed_check_events, iscsilun); 15445dd7a535SPeter Lieven timer_mod(iscsilun->event_timer, 15455dd7a535SPeter Lieven qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL); 154680cf6257SStefan Hajnoczi } 154780cf6257SStefan Hajnoczi 15487191f208SPeter Lieven static void iscsi_modesense_sync(IscsiLun *iscsilun) 1549c1d4096bSFam Zheng { 1550c1d4096bSFam Zheng struct scsi_task *task; 1551c1d4096bSFam Zheng struct scsi_mode_sense *ms = NULL; 15527191f208SPeter Lieven iscsilun->write_protected = false; 1553752ce451SPeter Lieven iscsilun->dpofua = false; 1554c1d4096bSFam Zheng 1555c1d4096bSFam Zheng task = iscsi_modesense6_sync(iscsilun->iscsi, iscsilun->lun, 1556c1d4096bSFam Zheng 1, SCSI_MODESENSE_PC_CURRENT, 1557c1d4096bSFam Zheng 0x3F, 0, 255); 1558c1d4096bSFam Zheng if (task == NULL) { 1559c1d4096bSFam Zheng error_report("iSCSI: Failed to send MODE_SENSE(6) command: %s", 1560c1d4096bSFam Zheng iscsi_get_error(iscsilun->iscsi)); 1561c1d4096bSFam Zheng goto out; 1562c1d4096bSFam Zheng } 1563c1d4096bSFam Zheng 1564c1d4096bSFam Zheng if (task->status != SCSI_STATUS_GOOD) { 1565c1d4096bSFam Zheng error_report("iSCSI: Failed MODE_SENSE(6), LUN assumed writable"); 1566c1d4096bSFam Zheng goto out; 1567c1d4096bSFam Zheng } 1568c1d4096bSFam Zheng ms = scsi_datain_unmarshall(task); 1569c1d4096bSFam Zheng if (!ms) { 1570c1d4096bSFam Zheng error_report("iSCSI: Failed to unmarshall MODE_SENSE(6) data: %s", 1571c1d4096bSFam Zheng iscsi_get_error(iscsilun->iscsi)); 1572c1d4096bSFam Zheng goto out; 1573c1d4096bSFam Zheng } 15747191f208SPeter Lieven iscsilun->write_protected = ms->device_specific_parameter & 0x80; 1575752ce451SPeter Lieven iscsilun->dpofua = ms->device_specific_parameter & 0x10; 1576c1d4096bSFam Zheng 1577c1d4096bSFam Zheng out: 1578c1d4096bSFam Zheng if (task) { 1579c1d4096bSFam Zheng scsi_free_scsi_task(task); 1580c1d4096bSFam Zheng } 1581c1d4096bSFam Zheng } 1582c1d4096bSFam Zheng 158343171420SKevin Wolf static void iscsi_parse_iscsi_option(const char *target, QDict *options) 158443171420SKevin Wolf { 158543171420SKevin Wolf QemuOptsList *list; 158643171420SKevin Wolf QemuOpts *opts; 158781aa2a0fSKevin Wolf const char *user, *password, *password_secret, *initiator_name, 15881d560104SKevin Wolf *header_digest, *timeout; 158943171420SKevin Wolf 159043171420SKevin Wolf list = qemu_find_opts("iscsi"); 159143171420SKevin Wolf if (!list) { 159243171420SKevin Wolf return; 159343171420SKevin Wolf } 159443171420SKevin Wolf 159543171420SKevin Wolf opts = qemu_opts_find(list, target); 159643171420SKevin Wolf if (opts == NULL) { 159743171420SKevin Wolf opts = QTAILQ_FIRST(&list->head); 159843171420SKevin Wolf if (!opts) { 159943171420SKevin Wolf return; 160043171420SKevin Wolf } 160143171420SKevin Wolf } 160243171420SKevin Wolf 160343171420SKevin Wolf user = qemu_opt_get(opts, "user"); 160443171420SKevin Wolf if (user) { 160543171420SKevin Wolf qdict_set_default_str(options, "user", user); 160643171420SKevin Wolf } 160743171420SKevin Wolf 160843171420SKevin Wolf password = qemu_opt_get(opts, "password"); 160943171420SKevin Wolf if (password) { 161043171420SKevin Wolf qdict_set_default_str(options, "password", password); 161143171420SKevin Wolf } 161243171420SKevin Wolf 161343171420SKevin Wolf password_secret = qemu_opt_get(opts, "password-secret"); 161443171420SKevin Wolf if (password_secret) { 161543171420SKevin Wolf qdict_set_default_str(options, "password-secret", password_secret); 161643171420SKevin Wolf } 1617d4e79929SKevin Wolf 1618d4e79929SKevin Wolf initiator_name = qemu_opt_get(opts, "initiator-name"); 1619d4e79929SKevin Wolf if (initiator_name) { 1620d4e79929SKevin Wolf qdict_set_default_str(options, "initiator-name", initiator_name); 1621d4e79929SKevin Wolf } 162281aa2a0fSKevin Wolf 162381aa2a0fSKevin Wolf header_digest = qemu_opt_get(opts, "header-digest"); 162481aa2a0fSKevin Wolf if (header_digest) { 162531eb1202SKevin Wolf /* -iscsi takes upper case values, but QAPI only supports lower case 162631eb1202SKevin Wolf * enum constant names, so we have to convert here. */ 162731eb1202SKevin Wolf char *qapi_value = g_ascii_strdown(header_digest, -1); 162831eb1202SKevin Wolf qdict_set_default_str(options, "header-digest", qapi_value); 162931eb1202SKevin Wolf g_free(qapi_value); 163081aa2a0fSKevin Wolf } 16311d560104SKevin Wolf 16321d560104SKevin Wolf timeout = qemu_opt_get(opts, "timeout"); 16331d560104SKevin Wolf if (timeout) { 16341d560104SKevin Wolf qdict_set_default_str(options, "timeout", timeout); 16351d560104SKevin Wolf } 163643171420SKevin Wolf } 163743171420SKevin Wolf 1638c589b249SRonnie Sahlberg /* 1639c589b249SRonnie Sahlberg * We support iscsi url's on the form 1640c589b249SRonnie Sahlberg * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun> 1641c589b249SRonnie Sahlberg */ 1642d5895fcbSKevin Wolf static void iscsi_parse_filename(const char *filename, QDict *options, 1643d5895fcbSKevin Wolf Error **errp) 1644d5895fcbSKevin Wolf { 1645d5895fcbSKevin Wolf struct iscsi_url *iscsi_url; 1646d5895fcbSKevin Wolf const char *transport_name; 1647d5895fcbSKevin Wolf char *lun_str; 1648d5895fcbSKevin Wolf 1649d5895fcbSKevin Wolf iscsi_url = iscsi_parse_full_url(NULL, filename); 1650d5895fcbSKevin Wolf if (iscsi_url == NULL) { 1651d5895fcbSKevin Wolf error_setg(errp, "Failed to parse URL : %s", filename); 1652d5895fcbSKevin Wolf return; 1653d5895fcbSKevin Wolf } 1654d5895fcbSKevin Wolf 1655d5895fcbSKevin Wolf #if LIBISCSI_API_VERSION >= (20160603) 1656d5895fcbSKevin Wolf switch (iscsi_url->transport) { 1657d5895fcbSKevin Wolf case TCP_TRANSPORT: 1658d5895fcbSKevin Wolf transport_name = "tcp"; 1659d5895fcbSKevin Wolf break; 1660d5895fcbSKevin Wolf case ISER_TRANSPORT: 1661d5895fcbSKevin Wolf transport_name = "iser"; 1662d5895fcbSKevin Wolf break; 1663d5895fcbSKevin Wolf default: 1664d5895fcbSKevin Wolf error_setg(errp, "Unknown transport type (%d)", 1665d5895fcbSKevin Wolf iscsi_url->transport); 1666d5895fcbSKevin Wolf return; 1667d5895fcbSKevin Wolf } 1668d5895fcbSKevin Wolf #else 1669d5895fcbSKevin Wolf transport_name = "tcp"; 1670d5895fcbSKevin Wolf #endif 1671d5895fcbSKevin Wolf 1672d5895fcbSKevin Wolf qdict_set_default_str(options, "transport", transport_name); 1673d5895fcbSKevin Wolf qdict_set_default_str(options, "portal", iscsi_url->portal); 1674d5895fcbSKevin Wolf qdict_set_default_str(options, "target", iscsi_url->target); 1675d5895fcbSKevin Wolf 1676d5895fcbSKevin Wolf lun_str = g_strdup_printf("%d", iscsi_url->lun); 1677d5895fcbSKevin Wolf qdict_set_default_str(options, "lun", lun_str); 1678d5895fcbSKevin Wolf g_free(lun_str); 1679d5895fcbSKevin Wolf 168043171420SKevin Wolf /* User/password from -iscsi take precedence over those from the URL */ 168143171420SKevin Wolf iscsi_parse_iscsi_option(iscsi_url->target, options); 168243171420SKevin Wolf 1683d5895fcbSKevin Wolf if (iscsi_url->user[0] != '\0') { 1684d5895fcbSKevin Wolf qdict_set_default_str(options, "user", iscsi_url->user); 1685d5895fcbSKevin Wolf qdict_set_default_str(options, "password", iscsi_url->passwd); 1686d5895fcbSKevin Wolf } 1687d5895fcbSKevin Wolf 1688d5895fcbSKevin Wolf iscsi_destroy_url(iscsi_url); 1689d5895fcbSKevin Wolf } 1690d5895fcbSKevin Wolf 1691d5895fcbSKevin Wolf static QemuOptsList runtime_opts = { 1692d5895fcbSKevin Wolf .name = "iscsi", 1693d5895fcbSKevin Wolf .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 1694d5895fcbSKevin Wolf .desc = { 1695d5895fcbSKevin Wolf { 1696d5895fcbSKevin Wolf .name = "transport", 1697d5895fcbSKevin Wolf .type = QEMU_OPT_STRING, 1698d5895fcbSKevin Wolf }, 1699d5895fcbSKevin Wolf { 1700d5895fcbSKevin Wolf .name = "portal", 1701d5895fcbSKevin Wolf .type = QEMU_OPT_STRING, 1702d5895fcbSKevin Wolf }, 1703d5895fcbSKevin Wolf { 1704d5895fcbSKevin Wolf .name = "target", 1705d5895fcbSKevin Wolf .type = QEMU_OPT_STRING, 1706d5895fcbSKevin Wolf }, 1707d5895fcbSKevin Wolf { 1708d5895fcbSKevin Wolf .name = "user", 1709d5895fcbSKevin Wolf .type = QEMU_OPT_STRING, 1710d5895fcbSKevin Wolf }, 1711d5895fcbSKevin Wolf { 1712d5895fcbSKevin Wolf .name = "password", 1713d5895fcbSKevin Wolf .type = QEMU_OPT_STRING, 1714d5895fcbSKevin Wolf }, 1715d5895fcbSKevin Wolf { 171643171420SKevin Wolf .name = "password-secret", 171743171420SKevin Wolf .type = QEMU_OPT_STRING, 171843171420SKevin Wolf }, 171943171420SKevin Wolf { 1720d5895fcbSKevin Wolf .name = "lun", 1721d5895fcbSKevin Wolf .type = QEMU_OPT_NUMBER, 1722d5895fcbSKevin Wolf }, 1723d4e79929SKevin Wolf { 1724d4e79929SKevin Wolf .name = "initiator-name", 1725d4e79929SKevin Wolf .type = QEMU_OPT_STRING, 1726d4e79929SKevin Wolf }, 172781aa2a0fSKevin Wolf { 172881aa2a0fSKevin Wolf .name = "header-digest", 172981aa2a0fSKevin Wolf .type = QEMU_OPT_STRING, 173081aa2a0fSKevin Wolf }, 17311d560104SKevin Wolf { 17321d560104SKevin Wolf .name = "timeout", 17331d560104SKevin Wolf .type = QEMU_OPT_NUMBER, 17341d560104SKevin Wolf }, 17355c3ad1a6SJeff Cody { 17365c3ad1a6SJeff Cody .name = "filename", 17375c3ad1a6SJeff Cody .type = QEMU_OPT_STRING, 17385c3ad1a6SJeff Cody }, 1739d5895fcbSKevin Wolf { /* end of list */ } 1740d5895fcbSKevin Wolf }, 1741d5895fcbSKevin Wolf }; 1742d5895fcbSKevin Wolf 1743015a1036SMax Reitz static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, 1744015a1036SMax Reitz Error **errp) 1745c589b249SRonnie Sahlberg { 1746c589b249SRonnie Sahlberg IscsiLun *iscsilun = bs->opaque; 1747c589b249SRonnie Sahlberg struct iscsi_context *iscsi = NULL; 1748e829b0bbSPeter Lieven struct scsi_task *task = NULL; 1749e829b0bbSPeter Lieven struct scsi_inquiry_standard *inq = NULL; 175024d3bd67SPeter Lieven struct scsi_inquiry_supported_pages *inq_vpd; 1751f9dadc98SRonnie Sahlberg char *initiator_name = NULL; 175260beb341SKevin Wolf QemuOpts *opts; 175360beb341SKevin Wolf Error *local_err = NULL; 17545c3ad1a6SJeff Cody const char *transport_name, *portal, *target, *filename; 1755d5895fcbSKevin Wolf #if LIBISCSI_API_VERSION >= (20160603) 1756d5895fcbSKevin Wolf enum iscsi_transport_type transport; 1757d5895fcbSKevin Wolf #endif 1758d5895fcbSKevin Wolf int i, ret = 0, timeout = 0, lun; 1759c589b249SRonnie Sahlberg 17605c3ad1a6SJeff Cody /* If we are given a filename, parse the filename, with precedence given to 17615c3ad1a6SJeff Cody * filename encoded options */ 17625c3ad1a6SJeff Cody filename = qdict_get_try_str(options, "filename"); 17635c3ad1a6SJeff Cody if (filename) { 17643dc6f869SAlistair Francis warn_report("'filename' option specified. " 17655c3ad1a6SJeff Cody "This is an unsupported option, and may be deprecated " 17665c3ad1a6SJeff Cody "in the future"); 17675c3ad1a6SJeff Cody iscsi_parse_filename(filename, options, &local_err); 17685c3ad1a6SJeff Cody if (local_err) { 17695c3ad1a6SJeff Cody ret = -EINVAL; 17705c3ad1a6SJeff Cody error_propagate(errp, local_err); 17715c3ad1a6SJeff Cody goto exit; 17725c3ad1a6SJeff Cody } 17735c3ad1a6SJeff Cody } 17745c3ad1a6SJeff Cody 177587ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 177660beb341SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 177784d18f06SMarkus Armbruster if (local_err) { 1778f2917853SPaolo Bonzini error_propagate(errp, local_err); 177960beb341SKevin Wolf ret = -EINVAL; 178060beb341SKevin Wolf goto out; 178160beb341SKevin Wolf } 178260beb341SKevin Wolf 1783d5895fcbSKevin Wolf transport_name = qemu_opt_get(opts, "transport"); 1784d5895fcbSKevin Wolf portal = qemu_opt_get(opts, "portal"); 1785d5895fcbSKevin Wolf target = qemu_opt_get(opts, "target"); 1786d5895fcbSKevin Wolf lun = qemu_opt_get_number(opts, "lun", 0); 178760beb341SKevin Wolf 1788d5895fcbSKevin Wolf if (!transport_name || !portal || !target) { 1789d5895fcbSKevin Wolf error_setg(errp, "Need all of transport, portal and target options"); 1790d5895fcbSKevin Wolf ret = -EINVAL; 1791d5895fcbSKevin Wolf goto out; 1792d5895fcbSKevin Wolf } 1793d5895fcbSKevin Wolf 1794d5895fcbSKevin Wolf if (!strcmp(transport_name, "tcp")) { 1795d5895fcbSKevin Wolf #if LIBISCSI_API_VERSION >= (20160603) 1796d5895fcbSKevin Wolf transport = TCP_TRANSPORT; 1797d5895fcbSKevin Wolf } else if (!strcmp(transport_name, "iser")) { 1798d5895fcbSKevin Wolf transport = ISER_TRANSPORT; 1799d5895fcbSKevin Wolf #else 1800d5895fcbSKevin Wolf /* TCP is what older libiscsi versions always use */ 1801d5895fcbSKevin Wolf #endif 1802d5895fcbSKevin Wolf } else { 1803d5895fcbSKevin Wolf error_setg(errp, "Unknown transport: %s", transport_name); 1804c589b249SRonnie Sahlberg ret = -EINVAL; 1805b93c94f7SPaolo Bonzini goto out; 1806c589b249SRonnie Sahlberg } 1807c589b249SRonnie Sahlberg 1808f9dadc98SRonnie Sahlberg memset(iscsilun, 0, sizeof(IscsiLun)); 1809f9dadc98SRonnie Sahlberg 1810d4e79929SKevin Wolf initiator_name = get_initiator_name(opts); 1811f9dadc98SRonnie Sahlberg 1812f9dadc98SRonnie Sahlberg iscsi = iscsi_create_context(initiator_name); 1813f9dadc98SRonnie Sahlberg if (iscsi == NULL) { 1814f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to create iSCSI context."); 1815f9dadc98SRonnie Sahlberg ret = -ENOMEM; 1816b93c94f7SPaolo Bonzini goto out; 1817f9dadc98SRonnie Sahlberg } 1818e0ae4987SRoy Shterman #if LIBISCSI_API_VERSION >= (20160603) 1819d5895fcbSKevin Wolf if (iscsi_init_transport(iscsi, transport)) { 1820e0ae4987SRoy Shterman error_setg(errp, ("Error initializing transport.")); 1821e0ae4987SRoy Shterman ret = -EINVAL; 1822e0ae4987SRoy Shterman goto out; 1823e0ae4987SRoy Shterman } 1824e0ae4987SRoy Shterman #endif 1825d5895fcbSKevin Wolf if (iscsi_set_targetname(iscsi, target)) { 1826f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to set target name."); 1827c589b249SRonnie Sahlberg ret = -EINVAL; 1828b93c94f7SPaolo Bonzini goto out; 1829c589b249SRonnie Sahlberg } 1830c589b249SRonnie Sahlberg 1831f9dadc98SRonnie Sahlberg /* check if we got CHAP username/password via the options */ 183243171420SKevin Wolf apply_chap(iscsi, opts, &local_err); 1833f2917853SPaolo Bonzini if (local_err != NULL) { 1834f2917853SPaolo Bonzini error_propagate(errp, local_err); 1835f9dadc98SRonnie Sahlberg ret = -EINVAL; 1836b93c94f7SPaolo Bonzini goto out; 1837f9dadc98SRonnie Sahlberg } 1838f9dadc98SRonnie Sahlberg 1839c589b249SRonnie Sahlberg if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) { 1840f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to set session type to normal."); 1841c589b249SRonnie Sahlberg ret = -EINVAL; 1842b93c94f7SPaolo Bonzini goto out; 1843c589b249SRonnie Sahlberg } 1844c589b249SRonnie Sahlberg 1845f9dadc98SRonnie Sahlberg /* check if we got HEADER_DIGEST via the options */ 184681aa2a0fSKevin Wolf apply_header_digest(iscsi, opts, &local_err); 1847f2917853SPaolo Bonzini if (local_err != NULL) { 1848f2917853SPaolo Bonzini error_propagate(errp, local_err); 1849f2917853SPaolo Bonzini ret = -EINVAL; 1850f2917853SPaolo Bonzini goto out; 1851f2917853SPaolo Bonzini } 1852f9dadc98SRonnie Sahlberg 18539049736eSPeter Lieven /* timeout handling is broken in libiscsi before 1.15.0 */ 18541d560104SKevin Wolf timeout = qemu_opt_get_number(opts, "timeout", 0); 1855583ec22eSRoy Shterman #if LIBISCSI_API_VERSION >= 20150621 18569049736eSPeter Lieven iscsi_set_timeout(iscsi, timeout); 18579049736eSPeter Lieven #else 18589049736eSPeter Lieven if (timeout) { 18599049736eSPeter Lieven error_report("iSCSI: ignoring timeout value for libiscsi <1.15.0"); 18609049736eSPeter Lieven } 18619049736eSPeter Lieven #endif 18625dd7a535SPeter Lieven 1863d5895fcbSKevin Wolf if (iscsi_full_connect_sync(iscsi, portal, lun) != 0) { 1864f2917853SPaolo Bonzini error_setg(errp, "iSCSI: Failed to connect to LUN : %s", 1865c589b249SRonnie Sahlberg iscsi_get_error(iscsi)); 1866c589b249SRonnie Sahlberg ret = -EINVAL; 1867b93c94f7SPaolo Bonzini goto out; 1868c589b249SRonnie Sahlberg } 1869622695a4SRonnie Sahlberg 1870e829b0bbSPeter Lieven iscsilun->iscsi = iscsi; 187180cf6257SStefan Hajnoczi iscsilun->aio_context = bdrv_get_aio_context(bs); 1872d5895fcbSKevin Wolf iscsilun->lun = lun; 1873fa6252b0SPaolo Bonzini iscsilun->has_write_same = true; 1874e829b0bbSPeter Lieven 187524d3bd67SPeter Lieven task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0, 187624d3bd67SPeter Lieven (void **) &inq, errp); 187724d3bd67SPeter Lieven if (task == NULL) { 187824d3bd67SPeter Lieven ret = -EINVAL; 187924d3bd67SPeter Lieven goto out; 188024d3bd67SPeter Lieven } 188124d3bd67SPeter Lieven iscsilun->type = inq->periperal_device_type; 188224d3bd67SPeter Lieven scsi_free_scsi_task(task); 188324d3bd67SPeter Lieven task = NULL; 188424d3bd67SPeter Lieven 18857191f208SPeter Lieven iscsi_modesense_sync(iscsilun); 18864df863f3SEric Blake if (iscsilun->dpofua) { 18874df863f3SEric Blake bs->supported_write_flags = BDRV_REQ_FUA; 18884df863f3SEric Blake } 18897191f208SPeter Lieven 1890c1d4096bSFam Zheng /* Check the write protect flag of the LUN if we want to write */ 1891c1d4096bSFam Zheng if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) && 189243ae8fb1SFam Zheng iscsilun->write_protected) { 1893c1d4096bSFam Zheng error_setg(errp, "Cannot open a write protected LUN as read-write"); 1894c1d4096bSFam Zheng ret = -EACCES; 1895c1d4096bSFam Zheng goto out; 1896c1d4096bSFam Zheng } 1897c1d4096bSFam Zheng 1898f2917853SPaolo Bonzini iscsi_readcapacity_sync(iscsilun, &local_err); 1899f2917853SPaolo Bonzini if (local_err != NULL) { 1900f2917853SPaolo Bonzini error_propagate(errp, local_err); 1901cd82b6fbSFam Zheng ret = -EINVAL; 1902e829b0bbSPeter Lieven goto out; 1903e829b0bbSPeter Lieven } 19040777b5ddSPeter Lieven bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun); 1905e829b0bbSPeter Lieven 1906f47c3f5aSKevin Wolf /* We don't have any emulation for devices other than disks and CD-ROMs, so 1907f47c3f5aSKevin Wolf * this must be sg ioctl compatible. We force it to be sg, otherwise qemu 1908f47c3f5aSKevin Wolf * will try to read from the device to guess the image format. 1909622695a4SRonnie Sahlberg */ 1910f47c3f5aSKevin Wolf if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) { 191154115412SEric Blake bs->sg = true; 1912622695a4SRonnie Sahlberg } 1913622695a4SRonnie Sahlberg 1914f18a7cbbSPeter Lieven task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, 191524d3bd67SPeter Lieven SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES, 191624d3bd67SPeter Lieven (void **) &inq_vpd, errp); 1917f18a7cbbSPeter Lieven if (task == NULL) { 1918f18a7cbbSPeter Lieven ret = -EINVAL; 1919f18a7cbbSPeter Lieven goto out; 1920f18a7cbbSPeter Lieven } 192124d3bd67SPeter Lieven for (i = 0; i < inq_vpd->num_pages; i++) { 192224d3bd67SPeter Lieven struct scsi_task *inq_task; 192324d3bd67SPeter Lieven struct scsi_inquiry_logical_block_provisioning *inq_lbp; 192424d3bd67SPeter Lieven struct scsi_inquiry_block_limits *inq_bl; 192524d3bd67SPeter Lieven switch (inq_vpd->pages[i]) { 192624d3bd67SPeter Lieven case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING: 192724d3bd67SPeter Lieven inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, 192824d3bd67SPeter Lieven SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING, 192924d3bd67SPeter Lieven (void **) &inq_lbp, errp); 193024d3bd67SPeter Lieven if (inq_task == NULL) { 1931f18a7cbbSPeter Lieven ret = -EINVAL; 1932f18a7cbbSPeter Lieven goto out; 1933f18a7cbbSPeter Lieven } 1934f18a7cbbSPeter Lieven memcpy(&iscsilun->lbp, inq_lbp, 1935f18a7cbbSPeter Lieven sizeof(struct scsi_inquiry_logical_block_provisioning)); 193624d3bd67SPeter Lieven scsi_free_scsi_task(inq_task); 193724d3bd67SPeter Lieven break; 193824d3bd67SPeter Lieven case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS: 193924d3bd67SPeter Lieven inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, 194024d3bd67SPeter Lieven SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, 194124d3bd67SPeter Lieven (void **) &inq_bl, errp); 194224d3bd67SPeter Lieven if (inq_task == NULL) { 1943f18a7cbbSPeter Lieven ret = -EINVAL; 1944f18a7cbbSPeter Lieven goto out; 1945f18a7cbbSPeter Lieven } 1946f18a7cbbSPeter Lieven memcpy(&iscsilun->bl, inq_bl, 1947f18a7cbbSPeter Lieven sizeof(struct scsi_inquiry_block_limits)); 194824d3bd67SPeter Lieven scsi_free_scsi_task(inq_task); 194924d3bd67SPeter Lieven break; 195024d3bd67SPeter Lieven default: 195124d3bd67SPeter Lieven break; 195224d3bd67SPeter Lieven } 195324d3bd67SPeter Lieven } 1954f18a7cbbSPeter Lieven scsi_free_scsi_task(task); 1955f18a7cbbSPeter Lieven task = NULL; 1956f18a7cbbSPeter Lieven 1957d045c466SPaolo Bonzini qemu_mutex_init(&iscsilun->mutex); 195880cf6257SStefan Hajnoczi iscsi_attach_aio_context(bs, iscsilun->aio_context); 19595b5d34ecSPeter Lieven 1960b03c3805SPeter Lieven /* Guess the internal cluster (page) size of the iscsi target by the means 1961b03c3805SPeter Lieven * of opt_unmap_gran. Transfer the unmap granularity only if it has a 1962b03c3805SPeter Lieven * reasonable size */ 19633d2acaa3SPeter Lieven if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 4 * 1024 && 1964b03c3805SPeter Lieven iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) { 1965ba059e7bSEric Blake iscsilun->cluster_size = iscsilun->bl.opt_unmap_gran * 1966ba059e7bSEric Blake iscsilun->block_size; 19679eac3622SPeter Lieven if (iscsilun->lbprz) { 1968e1123a3bSPeter Lieven ret = iscsi_allocmap_init(iscsilun, bs->open_flags); 1969b03c3805SPeter Lieven } 1970b03c3805SPeter Lieven } 1971b03c3805SPeter Lieven 1972e24d813bSEric Blake if (iscsilun->lbprz && iscsilun->lbp.lbpws) { 1973e24d813bSEric Blake bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP; 1974e24d813bSEric Blake } 1975e24d813bSEric Blake 1976b93c94f7SPaolo Bonzini out: 197760beb341SKevin Wolf qemu_opts_del(opts); 1978f9dadc98SRonnie Sahlberg g_free(initiator_name); 1979e829b0bbSPeter Lieven if (task != NULL) { 1980e829b0bbSPeter Lieven scsi_free_scsi_task(task); 1981e829b0bbSPeter Lieven } 1982b93c94f7SPaolo Bonzini 1983b93c94f7SPaolo Bonzini if (ret) { 1984c589b249SRonnie Sahlberg if (iscsi != NULL) { 198520474e9aSPeter Lieven if (iscsi_is_logged_in(iscsi)) { 198620474e9aSPeter Lieven iscsi_logout_sync(iscsi); 198720474e9aSPeter Lieven } 1988c589b249SRonnie Sahlberg iscsi_destroy_context(iscsi); 1989c589b249SRonnie Sahlberg } 1990c589b249SRonnie Sahlberg memset(iscsilun, 0, sizeof(IscsiLun)); 1991b93c94f7SPaolo Bonzini } 19925c3ad1a6SJeff Cody exit: 1993c589b249SRonnie Sahlberg return ret; 1994c589b249SRonnie Sahlberg } 1995c589b249SRonnie Sahlberg 1996c589b249SRonnie Sahlberg static void iscsi_close(BlockDriverState *bs) 1997c589b249SRonnie Sahlberg { 1998c589b249SRonnie Sahlberg IscsiLun *iscsilun = bs->opaque; 1999c589b249SRonnie Sahlberg struct iscsi_context *iscsi = iscsilun->iscsi; 2000c589b249SRonnie Sahlberg 200180cf6257SStefan Hajnoczi iscsi_detach_aio_context(bs); 200220474e9aSPeter Lieven if (iscsi_is_logged_in(iscsi)) { 200320474e9aSPeter Lieven iscsi_logout_sync(iscsi); 200420474e9aSPeter Lieven } 2005c589b249SRonnie Sahlberg iscsi_destroy_context(iscsi); 2006d4cd9615SPeter Lieven g_free(iscsilun->zeroblock); 2007e1123a3bSPeter Lieven iscsi_allocmap_free(iscsilun); 2008d045c466SPaolo Bonzini qemu_mutex_destroy(&iscsilun->mutex); 2009c589b249SRonnie Sahlberg memset(iscsilun, 0, sizeof(IscsiLun)); 2010c589b249SRonnie Sahlberg } 2011c589b249SRonnie Sahlberg 20123baca891SKevin Wolf static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp) 2013d34682cdSKevin Wolf { 2014d34682cdSKevin Wolf /* We don't actually refresh here, but just return data queried in 2015d34682cdSKevin Wolf * iscsi_open(): iscsi targets don't change their limits. */ 201652f6fa14SPeter Lieven 201752f6fa14SPeter Lieven IscsiLun *iscsilun = bs->opaque; 20185def6b80SEric Blake uint64_t max_xfer_len = iscsilun->use_16_for_rw ? 0xffffffff : 0xffff; 201995eaa785SEric Blake unsigned int block_size = MAX(BDRV_SECTOR_SIZE, iscsilun->block_size); 202052f6fa14SPeter Lieven 202195eaa785SEric Blake assert(iscsilun->block_size >= BDRV_SECTOR_SIZE || bs->sg); 202295eaa785SEric Blake 202395eaa785SEric Blake bs->bl.request_alignment = block_size; 2024c8b3b998SEric Blake 202552f6fa14SPeter Lieven if (iscsilun->bl.max_xfer_len) { 202652f6fa14SPeter Lieven max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len); 202752f6fa14SPeter Lieven } 202852f6fa14SPeter Lieven 202995eaa785SEric Blake if (max_xfer_len * block_size < INT_MAX) { 20305def6b80SEric Blake bs->bl.max_transfer = max_xfer_len * iscsilun->block_size; 20315def6b80SEric Blake } 203252f6fa14SPeter Lieven 2033c97ca29dSPaolo Bonzini if (iscsilun->lbp.lbpu) { 203495eaa785SEric Blake if (iscsilun->bl.max_unmap < 0xffffffff / block_size) { 2035b9f7855aSEric Blake bs->bl.max_pdiscard = 2036b9f7855aSEric Blake iscsilun->bl.max_unmap * iscsilun->block_size; 2037d34682cdSKevin Wolf } 2038b9f7855aSEric Blake bs->bl.pdiscard_alignment = 2039b9f7855aSEric Blake iscsilun->bl.opt_unmap_gran * iscsilun->block_size; 20408b184744SEric Blake } else { 2041b9f7855aSEric Blake bs->bl.pdiscard_alignment = iscsilun->block_size; 2042c97ca29dSPaolo Bonzini } 2043d34682cdSKevin Wolf 204495eaa785SEric Blake if (iscsilun->bl.max_ws_len < 0xffffffff / block_size) { 2045cf081fcaSEric Blake bs->bl.max_pwrite_zeroes = 2046cf081fcaSEric Blake iscsilun->bl.max_ws_len * iscsilun->block_size; 2047d34682cdSKevin Wolf } 2048c97ca29dSPaolo Bonzini if (iscsilun->lbp.lbpws) { 2049cf081fcaSEric Blake bs->bl.pwrite_zeroes_alignment = 2050cf081fcaSEric Blake iscsilun->bl.opt_unmap_gran * iscsilun->block_size; 20518b184744SEric Blake } else { 2052cf081fcaSEric Blake bs->bl.pwrite_zeroes_alignment = iscsilun->block_size; 20535d259fc7SPeter Lieven } 20545def6b80SEric Blake if (iscsilun->bl.opt_xfer_len && 205595eaa785SEric Blake iscsilun->bl.opt_xfer_len < INT_MAX / block_size) { 20565def6b80SEric Blake bs->bl.opt_transfer = pow2floor(iscsilun->bl.opt_xfer_len * 20575def6b80SEric Blake iscsilun->block_size); 20585def6b80SEric Blake } 2059e9f526abSAnthony Liguori } 2060d34682cdSKevin Wolf 206143ae8fb1SFam Zheng /* Note that this will not re-establish a connection with an iSCSI target - it 206243ae8fb1SFam Zheng * is effectively a NOP. */ 2063dc6afb99SJeff Cody static int iscsi_reopen_prepare(BDRVReopenState *state, 2064dc6afb99SJeff Cody BlockReopenQueue *queue, Error **errp) 2065dc6afb99SJeff Cody { 206643ae8fb1SFam Zheng IscsiLun *iscsilun = state->bs->opaque; 206743ae8fb1SFam Zheng 206843ae8fb1SFam Zheng if (state->flags & BDRV_O_RDWR && iscsilun->write_protected) { 206943ae8fb1SFam Zheng error_setg(errp, "Cannot open a write protected LUN as read-write"); 207043ae8fb1SFam Zheng return -EACCES; 207143ae8fb1SFam Zheng } 2072d34682cdSKevin Wolf return 0; 2073d34682cdSKevin Wolf } 2074d34682cdSKevin Wolf 2075e1123a3bSPeter Lieven static void iscsi_reopen_commit(BDRVReopenState *reopen_state) 2076e1123a3bSPeter Lieven { 2077e1123a3bSPeter Lieven IscsiLun *iscsilun = reopen_state->bs->opaque; 2078e1123a3bSPeter Lieven 2079e1123a3bSPeter Lieven /* the cache.direct status might have changed */ 2080e1123a3bSPeter Lieven if (iscsilun->allocmap != NULL) { 2081e1123a3bSPeter Lieven iscsi_allocmap_init(iscsilun, reopen_state->flags); 2082e1123a3bSPeter Lieven } 2083e1123a3bSPeter Lieven } 2084e1123a3bSPeter Lieven 20858243ccb7SMax Reitz static int iscsi_truncate(BlockDriverState *bs, int64_t offset, 20868243ccb7SMax Reitz PreallocMode prealloc, Error **errp) 2087cb1b83e7SPeter Lieven { 2088cb1b83e7SPeter Lieven IscsiLun *iscsilun = bs->opaque; 2089f2917853SPaolo Bonzini Error *local_err = NULL; 2090cb1b83e7SPeter Lieven 20918243ccb7SMax Reitz if (prealloc != PREALLOC_MODE_OFF) { 20928243ccb7SMax Reitz error_setg(errp, "Unsupported preallocation mode '%s'", 2093977c736fSMarkus Armbruster PreallocMode_str(prealloc)); 20948243ccb7SMax Reitz return -ENOTSUP; 20958243ccb7SMax Reitz } 20968243ccb7SMax Reitz 2097cb1b83e7SPeter Lieven if (iscsilun->type != TYPE_DISK) { 2098f59adb32SMax Reitz error_setg(errp, "Cannot resize non-disk iSCSI devices"); 2099cb1b83e7SPeter Lieven return -ENOTSUP; 2100cb1b83e7SPeter Lieven } 2101cb1b83e7SPeter Lieven 2102f2917853SPaolo Bonzini iscsi_readcapacity_sync(iscsilun, &local_err); 2103f2917853SPaolo Bonzini if (local_err != NULL) { 21044bff28b8SMax Reitz error_propagate(errp, local_err); 2105f2917853SPaolo Bonzini return -EIO; 2106cb1b83e7SPeter Lieven } 2107cb1b83e7SPeter Lieven 2108cb1b83e7SPeter Lieven if (offset > iscsi_getlength(bs)) { 2109f59adb32SMax Reitz error_setg(errp, "Cannot grow iSCSI devices"); 2110cb1b83e7SPeter Lieven return -EINVAL; 2111cb1b83e7SPeter Lieven } 2112cb1b83e7SPeter Lieven 2113e1123a3bSPeter Lieven if (iscsilun->allocmap != NULL) { 2114e1123a3bSPeter Lieven iscsi_allocmap_init(iscsilun, bs->open_flags); 2115b03c3805SPeter Lieven } 2116b03c3805SPeter Lieven 2117cb1b83e7SPeter Lieven return 0; 2118cb1b83e7SPeter Lieven } 2119cb1b83e7SPeter Lieven 2120efc75e2aSStefan Hajnoczi static int coroutine_fn iscsi_co_create_opts(const char *filename, QemuOpts *opts, 2121efc75e2aSStefan Hajnoczi Error **errp) 2122de8864e5SPeter Lieven { 2123de8864e5SPeter Lieven int ret = 0; 2124de8864e5SPeter Lieven int64_t total_size = 0; 212513c91cb7SFam Zheng BlockDriverState *bs; 2126de8864e5SPeter Lieven IscsiLun *iscsilun = NULL; 212760beb341SKevin Wolf QDict *bs_options; 21282ec9a782SFam Zheng Error *local_err = NULL; 2129de8864e5SPeter Lieven 2130e4e9986bSMarkus Armbruster bs = bdrv_new(); 2131de8864e5SPeter Lieven 2132de8864e5SPeter Lieven /* Read out options */ 2133c2eb918eSHu Tao total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 2134c2eb918eSHu Tao BDRV_SECTOR_SIZE); 21355839e53bSMarkus Armbruster bs->opaque = g_new0(struct IscsiLun, 1); 213613c91cb7SFam Zheng iscsilun = bs->opaque; 2137de8864e5SPeter Lieven 213860beb341SKevin Wolf bs_options = qdict_new(); 21392ec9a782SFam Zheng iscsi_parse_filename(filename, bs_options, &local_err); 21402ec9a782SFam Zheng if (local_err) { 21412ec9a782SFam Zheng error_propagate(errp, local_err); 21422ec9a782SFam Zheng ret = -EINVAL; 21432ec9a782SFam Zheng } else { 2144015a1036SMax Reitz ret = iscsi_open(bs, bs_options, 0, NULL); 21452ec9a782SFam Zheng } 2146*cb3e7f08SMarc-André Lureau qobject_unref(bs_options); 214760beb341SKevin Wolf 2148de8864e5SPeter Lieven if (ret != 0) { 2149de8864e5SPeter Lieven goto out; 2150de8864e5SPeter Lieven } 215180cf6257SStefan Hajnoczi iscsi_detach_aio_context(bs); 2152de8864e5SPeter Lieven if (iscsilun->type != TYPE_DISK) { 2153de8864e5SPeter Lieven ret = -ENODEV; 2154de8864e5SPeter Lieven goto out; 2155de8864e5SPeter Lieven } 215613c91cb7SFam Zheng if (bs->total_sectors < total_size) { 2157de8864e5SPeter Lieven ret = -ENOSPC; 2158d3bda7bcSPeter Lieven goto out; 2159de8864e5SPeter Lieven } 2160de8864e5SPeter Lieven 2161de8864e5SPeter Lieven ret = 0; 2162de8864e5SPeter Lieven out: 2163de8864e5SPeter Lieven if (iscsilun->iscsi != NULL) { 2164de8864e5SPeter Lieven iscsi_destroy_context(iscsilun->iscsi); 2165de8864e5SPeter Lieven } 216613c91cb7SFam Zheng g_free(bs->opaque); 216713c91cb7SFam Zheng bs->opaque = NULL; 21684f6fd349SFam Zheng bdrv_unref(bs); 2169de8864e5SPeter Lieven return ret; 2170de8864e5SPeter Lieven } 2171de8864e5SPeter Lieven 2172186d4f2bSPeter Lieven static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 2173186d4f2bSPeter Lieven { 2174186d4f2bSPeter Lieven IscsiLun *iscsilun = bs->opaque; 21750a386e48SPeter Lieven bdi->unallocated_blocks_are_zero = iscsilun->lbprz; 2176ba059e7bSEric Blake bdi->cluster_size = iscsilun->cluster_size; 2177186d4f2bSPeter Lieven return 0; 2178186d4f2bSPeter Lieven } 2179186d4f2bSPeter Lieven 21802b148f39SPaolo Bonzini static void coroutine_fn iscsi_co_invalidate_cache(BlockDriverState *bs, 2181e1123a3bSPeter Lieven Error **errp) 2182e1123a3bSPeter Lieven { 2183e1123a3bSPeter Lieven IscsiLun *iscsilun = bs->opaque; 2184e1123a3bSPeter Lieven iscsi_allocmap_invalidate(iscsilun); 2185e1123a3bSPeter Lieven } 2186e1123a3bSPeter Lieven 2187a59479e3SChunyan Liu static QemuOptsList iscsi_create_opts = { 2188a59479e3SChunyan Liu .name = "iscsi-create-opts", 2189a59479e3SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head), 2190a59479e3SChunyan Liu .desc = { 2191de8864e5SPeter Lieven { 2192de8864e5SPeter Lieven .name = BLOCK_OPT_SIZE, 2193a59479e3SChunyan Liu .type = QEMU_OPT_SIZE, 2194de8864e5SPeter Lieven .help = "Virtual disk size" 2195de8864e5SPeter Lieven }, 2196a59479e3SChunyan Liu { /* end of list */ } 2197a59479e3SChunyan Liu } 2198de8864e5SPeter Lieven }; 2199de8864e5SPeter Lieven 2200c589b249SRonnie Sahlberg static BlockDriver bdrv_iscsi = { 2201c589b249SRonnie Sahlberg .format_name = "iscsi", 2202c589b249SRonnie Sahlberg .protocol_name = "iscsi", 2203c589b249SRonnie Sahlberg 2204c589b249SRonnie Sahlberg .instance_size = sizeof(IscsiLun), 2205d5895fcbSKevin Wolf .bdrv_parse_filename = iscsi_parse_filename, 2206c589b249SRonnie Sahlberg .bdrv_file_open = iscsi_open, 2207c589b249SRonnie Sahlberg .bdrv_close = iscsi_close, 2208efc75e2aSStefan Hajnoczi .bdrv_co_create_opts = iscsi_co_create_opts, 2209a59479e3SChunyan Liu .create_opts = &iscsi_create_opts, 2210dc6afb99SJeff Cody .bdrv_reopen_prepare = iscsi_reopen_prepare, 2211e1123a3bSPeter Lieven .bdrv_reopen_commit = iscsi_reopen_commit, 22122b148f39SPaolo Bonzini .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, 2213c589b249SRonnie Sahlberg 2214c589b249SRonnie Sahlberg .bdrv_getlength = iscsi_getlength, 2215186d4f2bSPeter Lieven .bdrv_get_info = iscsi_get_info, 2216cb1b83e7SPeter Lieven .bdrv_truncate = iscsi_truncate, 2217d34682cdSKevin Wolf .bdrv_refresh_limits = iscsi_refresh_limits, 2218c589b249SRonnie Sahlberg 221992809c36SEric Blake .bdrv_co_block_status = iscsi_co_block_status, 222097c7e85cSEric Blake .bdrv_co_pdiscard = iscsi_co_pdiscard, 222194d047a3SEric Blake .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes, 2222063c3378SPeter Lieven .bdrv_co_readv = iscsi_co_readv, 22239f0eb9e1SKevin Wolf .bdrv_co_writev_flags = iscsi_co_writev_flags, 2224063c3378SPeter Lieven .bdrv_co_flush_to_disk = iscsi_co_flush, 2225fa6acb0cSRonnie Sahlberg 222698392453SRonnie Sahlberg #ifdef __linux__ 222798392453SRonnie Sahlberg .bdrv_aio_ioctl = iscsi_aio_ioctl, 222898392453SRonnie Sahlberg #endif 222980cf6257SStefan Hajnoczi 223080cf6257SStefan Hajnoczi .bdrv_detach_aio_context = iscsi_detach_aio_context, 223180cf6257SStefan Hajnoczi .bdrv_attach_aio_context = iscsi_attach_aio_context, 2232c589b249SRonnie Sahlberg }; 2233c589b249SRonnie Sahlberg 2234e0ae4987SRoy Shterman #if LIBISCSI_API_VERSION >= (20160603) 2235e0ae4987SRoy Shterman static BlockDriver bdrv_iser = { 2236e0ae4987SRoy Shterman .format_name = "iser", 2237e0ae4987SRoy Shterman .protocol_name = "iser", 2238e0ae4987SRoy Shterman 2239e0ae4987SRoy Shterman .instance_size = sizeof(IscsiLun), 2240d5895fcbSKevin Wolf .bdrv_parse_filename = iscsi_parse_filename, 2241e0ae4987SRoy Shterman .bdrv_file_open = iscsi_open, 2242e0ae4987SRoy Shterman .bdrv_close = iscsi_close, 2243efc75e2aSStefan Hajnoczi .bdrv_co_create_opts = iscsi_co_create_opts, 2244e0ae4987SRoy Shterman .create_opts = &iscsi_create_opts, 2245e0ae4987SRoy Shterman .bdrv_reopen_prepare = iscsi_reopen_prepare, 2246e0ae4987SRoy Shterman .bdrv_reopen_commit = iscsi_reopen_commit, 2247b16a7cfaSPaolo Bonzini .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache, 2248e0ae4987SRoy Shterman 2249e0ae4987SRoy Shterman .bdrv_getlength = iscsi_getlength, 2250e0ae4987SRoy Shterman .bdrv_get_info = iscsi_get_info, 2251e0ae4987SRoy Shterman .bdrv_truncate = iscsi_truncate, 2252e0ae4987SRoy Shterman .bdrv_refresh_limits = iscsi_refresh_limits, 2253e0ae4987SRoy Shterman 225492809c36SEric Blake .bdrv_co_block_status = iscsi_co_block_status, 2255e0ae4987SRoy Shterman .bdrv_co_pdiscard = iscsi_co_pdiscard, 2256e0ae4987SRoy Shterman .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes, 2257e0ae4987SRoy Shterman .bdrv_co_readv = iscsi_co_readv, 2258e0ae4987SRoy Shterman .bdrv_co_writev_flags = iscsi_co_writev_flags, 2259e0ae4987SRoy Shterman .bdrv_co_flush_to_disk = iscsi_co_flush, 2260e0ae4987SRoy Shterman 2261e0ae4987SRoy Shterman #ifdef __linux__ 2262e0ae4987SRoy Shterman .bdrv_aio_ioctl = iscsi_aio_ioctl, 2263e0ae4987SRoy Shterman #endif 2264e0ae4987SRoy Shterman 2265e0ae4987SRoy Shterman .bdrv_detach_aio_context = iscsi_detach_aio_context, 2266e0ae4987SRoy Shterman .bdrv_attach_aio_context = iscsi_attach_aio_context, 2267e0ae4987SRoy Shterman }; 2268e0ae4987SRoy Shterman #endif 2269e0ae4987SRoy Shterman 2270c589b249SRonnie Sahlberg static void iscsi_block_init(void) 2271c589b249SRonnie Sahlberg { 2272c589b249SRonnie Sahlberg bdrv_register(&bdrv_iscsi); 2273e0ae4987SRoy Shterman #if LIBISCSI_API_VERSION >= (20160603) 2274e0ae4987SRoy Shterman bdrv_register(&bdrv_iser); 2275e0ae4987SRoy Shterman #endif 2276c589b249SRonnie Sahlberg } 2277c589b249SRonnie Sahlberg 2278c589b249SRonnie Sahlberg block_init(iscsi_block_init); 2279