?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
block: Add "file" output parameter to block status query functions
[qemu/ar7.git] / block / iscsi.c
blobe182557cfce012580160ff33e31369c6c198bbae
1 /*
2 * QEMU Block driver for iSCSI images
3 *
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
5 * Copyright (c) 2012-2015 Peter Lieven <pl@kamp.de>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27
28 #include <poll.h>
29 #include <math.h>
30 #include <arpa/inet.h>
31 #include "qemu-common.h"
32 #include "qemu/config-file.h"
33 #include "qemu/error-report.h"
34 #include "qemu/bitops.h"
35 #include "qemu/bitmap.h"
36 #include "block/block_int.h"
37 #include "block/scsi.h"
38 #include "qemu/iov.h"
39 #include "sysemu/sysemu.h"
40 #include "qmp-commands.h"
41 #include "qapi/qmp/qstring.h"
42
43 #include <iscsi/iscsi.h>
44 #include <iscsi/scsi-lowlevel.h>
45
46 #ifdef __linux__
47 #include <scsi/sg.h>
48 #include <block/scsi.h>
49 #endif
50
51 typedef struct IscsiLun {
52 struct iscsi_context *iscsi;
53 AioContext *aio_context;
54 int lun;
55 enum scsi_inquiry_peripheral_device_type type;
56 int block_size;
57 uint64_t num_blocks;
58 int events;
59 QEMUTimer *nop_timer;
60 QEMUTimer *event_timer;
61 struct scsi_inquiry_logical_block_provisioning lbp;
62 struct scsi_inquiry_block_limits bl;
63 unsigned char *zeroblock;
64 unsigned long *allocationmap;
65 int cluster_sectors;
66 bool use_16_for_rw;
67 bool write_protected;
68 bool lbpme;
69 bool lbprz;
70 bool dpofua;
71 bool has_write_same;
72 bool force_next_flush;
73 bool request_timed_out;
74 } IscsiLun;
75
76 typedef struct IscsiTask {
77 int status;
78 int complete;
79 int retries;
80 int do_retry;
81 struct scsi_task *task;
82 Coroutine *co;
83 QEMUBH *bh;
84 IscsiLun *iscsilun;
85 QEMUTimer retry_timer;
86 bool force_next_flush;
87 int err_code;
88 } IscsiTask;
89
90 typedef struct IscsiAIOCB {
91 BlockAIOCB common;
92 QEMUIOVector *qiov;
93 QEMUBH *bh;
94 IscsiLun *iscsilun;
95 struct scsi_task *task;
96 uint8_t *buf;
97 int status;
98 int64_t sector_num;
99 int nb_sectors;
100 int ret;
101 #ifdef __linux__
102 sg_io_hdr_t *ioh;
103 #endif
104 } IscsiAIOCB;
105
106 /* libiscsi uses time_t so its enough to process events every second */
107 #define EVENT_INTERVAL 1000
108 #define NOP_INTERVAL 5000
109 #define MAX_NOP_FAILURES 3
110 #define ISCSI_CMD_RETRIES ARRAY_SIZE(iscsi_retry_times)
111 static const unsigned iscsi_retry_times[] = {8, 32, 128, 512, 2048, 8192, 32768};
112
113 /* this threshold is a trade-off knob to choose between
114 * the potential additional overhead of an extra GET_LBA_STATUS request
115 * vs. unnecessarily reading a lot of zero sectors over the wire.
116 * If a read request is greater or equal than ISCSI_CHECKALLOC_THRES
117 * sectors we check the allocation status of the area covered by the
118 * request first if the allocationmap indicates that the area might be
119 * unallocated. */
120 #define ISCSI_CHECKALLOC_THRES 64
121
122 static void
123 iscsi_bh_cb(void *p)
124 {
125 IscsiAIOCB *acb = p;
126
127 qemu_bh_delete(acb->bh);
128
129 g_free(acb->buf);
130 acb->buf = NULL;
131
132 acb->common.cb(acb->common.opaque, acb->status);
133
134 if (acb->task != NULL) {
135 scsi_free_scsi_task(acb->task);
136 acb->task = NULL;
137 }
138
139 qemu_aio_unref(acb);
140 }
141
142 static void
143 iscsi_schedule_bh(IscsiAIOCB *acb)
144 {
145 if (acb->bh) {
146 return;
147 }
148 acb->bh = aio_bh_new(acb->iscsilun->aio_context, iscsi_bh_cb, acb);
149 qemu_bh_schedule(acb->bh);
150 }
151
152 static void iscsi_co_generic_bh_cb(void *opaque)
153 {
154 struct IscsiTask *iTask = opaque;
155 iTask->complete = 1;
156 qemu_bh_delete(iTask->bh);
157 qemu_coroutine_enter(iTask->co, NULL);
158 }
159
160 static void iscsi_retry_timer_expired(void *opaque)
161 {
162 struct IscsiTask *iTask = opaque;
163 iTask->complete = 1;
164 if (iTask->co) {
165 qemu_coroutine_enter(iTask->co, NULL);
166 }
167 }
168
169 static inline unsigned exp_random(double mean)
170 {
171 return -mean * log((double)rand() / RAND_MAX);
172 }
173
174 /* SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST was introduced in
175 * libiscsi 1.10.0, together with other constants we need. Use it as
176 * a hint that we have to define them ourselves if needed, to keep the
177 * minimum required libiscsi version at 1.9.0. We use an ASCQ macro for
178 * the test because SCSI_STATUS_* is an enum.
179 *
180 * To guard against future changes where SCSI_SENSE_ASCQ_* also becomes
181 * an enum, check against the LIBISCSI_API_VERSION macro, which was
182 * introduced in 1.11.0. If it is present, there is no need to define
183 * anything.
184 */
185 #if !defined(SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST) && \
186 !defined(LIBISCSI_API_VERSION)
187 #define SCSI_STATUS_TASK_SET_FULL 0x28
188 #define SCSI_STATUS_TIMEOUT 0x0f000002
189 #define SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST 0x2600
190 #define SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR 0x1a00
191 #endif
192
193 static int iscsi_translate_sense(struct scsi_sense *sense)
194 {
195 int ret;
196
197 switch (sense->key) {
198 case SCSI_SENSE_NOT_READY:
199 return -EBUSY;
200 case SCSI_SENSE_DATA_PROTECTION:
201 return -EACCES;
202 case SCSI_SENSE_COMMAND_ABORTED:
203 return -ECANCELED;
204 case SCSI_SENSE_ILLEGAL_REQUEST:
205 /* Parse ASCQ */
206 break;
207 default:
208 return -EIO;
209 }
210 switch (sense->ascq) {
211 case SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR:
212 case SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE:
213 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB:
214 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST:
215 ret = -EINVAL;
216 break;
217 case SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE:
218 ret = -ENOSPC;
219 break;
220 case SCSI_SENSE_ASCQ_LOGICAL_UNIT_NOT_SUPPORTED:
221 ret = -ENOTSUP;
222 break;
223 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT:
224 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED:
225 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN:
226 ret = -ENOMEDIUM;
227 break;
228 case SCSI_SENSE_ASCQ_WRITE_PROTECTED:
229 ret = -EACCES;
230 break;
231 default:
232 ret = -EIO;
233 break;
234 }
235 return ret;
236 }
237
238 static void
239 iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
240 void *command_data, void *opaque)
241 {
242 struct IscsiTask *iTask = opaque;
243 struct scsi_task *task = command_data;
244
245 iTask->status = status;
246 iTask->do_retry = 0;
247 iTask->task = task;
248
249 if (status != SCSI_STATUS_GOOD) {
250 if (iTask->retries++ < ISCSI_CMD_RETRIES) {
251 if (status == SCSI_STATUS_CHECK_CONDITION
252 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
253 error_report("iSCSI CheckCondition: %s",
254 iscsi_get_error(iscsi));
255 iTask->do_retry = 1;
256 goto out;
257 }
258 if (status == SCSI_STATUS_BUSY ||
259 status == SCSI_STATUS_TIMEOUT ||
260 status == SCSI_STATUS_TASK_SET_FULL) {
261 unsigned retry_time =
262 exp_random(iscsi_retry_times[iTask->retries - 1]);
263 if (status == SCSI_STATUS_TIMEOUT) {
264 /* make sure the request is rescheduled AFTER the
265 * reconnect is initiated */
266 retry_time = EVENT_INTERVAL * 2;
267 iTask->iscsilun->request_timed_out = true;
268 }
269 error_report("iSCSI Busy/TaskSetFull/TimeOut"
270 " (retry #%u in %u ms): %s",
271 iTask->retries, retry_time,
272 iscsi_get_error(iscsi));
273 aio_timer_init(iTask->iscsilun->aio_context,
274 &iTask->retry_timer, QEMU_CLOCK_REALTIME,
275 SCALE_MS, iscsi_retry_timer_expired, iTask);
276 timer_mod(&iTask->retry_timer,
277 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time);
278 iTask->do_retry = 1;
279 return;
280 }
281 }
282 iTask->err_code = iscsi_translate_sense(&task->sense);
283 error_report("iSCSI Failure: %s", iscsi_get_error(iscsi));
284 } else {
285 iTask->iscsilun->force_next_flush |= iTask->force_next_flush;
286 }
287
288 out:
289 if (iTask->co) {
290 iTask->bh = aio_bh_new(iTask->iscsilun->aio_context,
291 iscsi_co_generic_bh_cb, iTask);
292 qemu_bh_schedule(iTask->bh);
293 } else {
294 iTask->complete = 1;
295 }
296 }
297
298 static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
299 {
300 *iTask = (struct IscsiTask) {
301 .co = qemu_coroutine_self(),
302 .iscsilun = iscsilun,
303 };
304 }
305
306 static void
307 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
308 void *private_data)
309 {
310 IscsiAIOCB *acb = private_data;
311
312 acb->status = -ECANCELED;
313 iscsi_schedule_bh(acb);
314 }
315
316 static void
317 iscsi_aio_cancel(BlockAIOCB *blockacb)
318 {
319 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
320 IscsiLun *iscsilun = acb->iscsilun;
321
322 if (acb->status != -EINPROGRESS) {
323 return;
324 }
325
326 /* send a task mgmt call to the target to cancel the task on the target */
327 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
328 iscsi_abort_task_cb, acb);
329
330 }
331
332 static const AIOCBInfo iscsi_aiocb_info = {
333 .aiocb_size = sizeof(IscsiAIOCB),
334 .cancel_async = iscsi_aio_cancel,
335 };
336
337
338 static void iscsi_process_read(void *arg);
339 static void iscsi_process_write(void *arg);
340
341 static void
342 iscsi_set_events(IscsiLun *iscsilun)
343 {
344 struct iscsi_context *iscsi = iscsilun->iscsi;
345 int ev = iscsi_which_events(iscsi);
346
347 if (ev != iscsilun->events) {
348 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsi),
349 false,
350 (ev & POLLIN) ? iscsi_process_read : NULL,
351 (ev & POLLOUT) ? iscsi_process_write : NULL,
352 iscsilun);
353 iscsilun->events = ev;
354 }
355 }
356
357 static void iscsi_timed_check_events(void *opaque)
358 {
359 IscsiLun *iscsilun = opaque;
360
361 /* check for timed out requests */
362 iscsi_service(iscsilun->iscsi, 0);
363
364 if (iscsilun->request_timed_out) {
365 iscsilun->request_timed_out = false;
366 iscsi_reconnect(iscsilun->iscsi);
367 }
368
369 /* newer versions of libiscsi may return zero events. Ensure we are able
370 * to return to service once this situation changes. */
371 iscsi_set_events(iscsilun);
372
373 timer_mod(iscsilun->event_timer,
374 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
375 }
376
377 static void
378 iscsi_process_read(void *arg)
379 {
380 IscsiLun *iscsilun = arg;
381 struct iscsi_context *iscsi = iscsilun->iscsi;
382
383 iscsi_service(iscsi, POLLIN);
384 iscsi_set_events(iscsilun);
385 }
386
387 static void
388 iscsi_process_write(void *arg)
389 {
390 IscsiLun *iscsilun = arg;
391 struct iscsi_context *iscsi = iscsilun->iscsi;
392
393 iscsi_service(iscsi, POLLOUT);
394 iscsi_set_events(iscsilun);
395 }
396
397 static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
398 {
399 return sector * iscsilun->block_size / BDRV_SECTOR_SIZE;
400 }
401
402 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
403 {
404 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
405 }
406
407 static bool is_request_lun_aligned(int64_t sector_num, int nb_sectors,
408 IscsiLun *iscsilun)
409 {
410 if ((sector_num * BDRV_SECTOR_SIZE) % iscsilun->block_size ||
411 (nb_sectors * BDRV_SECTOR_SIZE) % iscsilun->block_size) {
412 error_report("iSCSI misaligned request: "
413 "iscsilun->block_size %u, sector_num %" PRIi64
414 ", nb_sectors %d",
415 iscsilun->block_size, sector_num, nb_sectors);
416 return 0;
417 }
418 return 1;
419 }
420
421 static unsigned long *iscsi_allocationmap_init(IscsiLun *iscsilun)
422 {
423 return bitmap_try_new(DIV_ROUND_UP(sector_lun2qemu(iscsilun->num_blocks,
424 iscsilun),
425 iscsilun->cluster_sectors));
426 }
427
428 static void iscsi_allocationmap_set(IscsiLun *iscsilun, int64_t sector_num,
429 int nb_sectors)
430 {
431 if (iscsilun->allocationmap == NULL) {
432 return;
433 }
434 bitmap_set(iscsilun->allocationmap,
435 sector_num / iscsilun->cluster_sectors,
436 DIV_ROUND_UP(nb_sectors, iscsilun->cluster_sectors));
437 }
438
439 static void iscsi_allocationmap_clear(IscsiLun *iscsilun, int64_t sector_num,
440 int nb_sectors)
441 {
442 int64_t cluster_num, nb_clusters;
443 if (iscsilun->allocationmap == NULL) {
444 return;
445 }
446 cluster_num = DIV_ROUND_UP(sector_num, iscsilun->cluster_sectors);
447 nb_clusters = (sector_num + nb_sectors) / iscsilun->cluster_sectors
448 - cluster_num;
449 if (nb_clusters > 0) {
450 bitmap_clear(iscsilun->allocationmap, cluster_num, nb_clusters);
451 }
452 }
453
454 static int coroutine_fn iscsi_co_writev(BlockDriverState *bs,
455 int64_t sector_num, int nb_sectors,
456 QEMUIOVector *iov)
457 {
458 IscsiLun *iscsilun = bs->opaque;
459 struct IscsiTask iTask;
460 uint64_t lba;
461 uint32_t num_sectors;
462 int fua;
463
464 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
465 return -EINVAL;
466 }
467
468 if (bs->bl.max_transfer_length && nb_sectors > bs->bl.max_transfer_length) {
469 error_report("iSCSI Error: Write of %d sectors exceeds max_xfer_len "
470 "of %d sectors", nb_sectors, bs->bl.max_transfer_length);
471 return -EINVAL;
472 }
473
474 lba = sector_qemu2lun(sector_num, iscsilun);
475 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
476 iscsi_co_init_iscsitask(iscsilun, &iTask);
477 retry:
478 fua = iscsilun->dpofua && !bs->enable_write_cache;
479 iTask.force_next_flush = !fua;
480 if (iscsilun->use_16_for_rw) {
481 iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,
482 NULL, num_sectors * iscsilun->block_size,
483 iscsilun->block_size, 0, 0, fua, 0, 0,
484 iscsi_co_generic_cb, &iTask);
485 } else {
486 iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba,
487 NULL, num_sectors * iscsilun->block_size,
488 iscsilun->block_size, 0, 0, fua, 0, 0,
489 iscsi_co_generic_cb, &iTask);
490 }
491 if (iTask.task == NULL) {
492 return -ENOMEM;
493 }
494 scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,
495 iov->niov);
496 while (!iTask.complete) {
497 iscsi_set_events(iscsilun);
498 qemu_coroutine_yield();
499 }
500
501 if (iTask.task != NULL) {
502 scsi_free_scsi_task(iTask.task);
503 iTask.task = NULL;
504 }
505
506 if (iTask.do_retry) {
507 iTask.complete = 0;
508 goto retry;
509 }
510
511 if (iTask.status != SCSI_STATUS_GOOD) {
512 return iTask.err_code;
513 }
514
515 iscsi_allocationmap_set(iscsilun, sector_num, nb_sectors);
516
517 return 0;
518 }
519
520
521 static bool iscsi_allocationmap_is_allocated(IscsiLun *iscsilun,
522 int64_t sector_num, int nb_sectors)
523 {
524 unsigned long size;
525 if (iscsilun->allocationmap == NULL) {
526 return true;
527 }
528 size = DIV_ROUND_UP(sector_num + nb_sectors, iscsilun->cluster_sectors);
529 return !(find_next_bit(iscsilun->allocationmap, size,
530 sector_num / iscsilun->cluster_sectors) == size);
531 }
532
533 static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs,
534 int64_t sector_num,
535 int nb_sectors, int *pnum,
536 BlockDriverState **file)
537 {
538 IscsiLun *iscsilun = bs->opaque;
539 struct scsi_get_lba_status *lbas = NULL;
540 struct scsi_lba_status_descriptor *lbasd = NULL;
541 struct IscsiTask iTask;
542 int64_t ret;
543
544 iscsi_co_init_iscsitask(iscsilun, &iTask);
545
546 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
547 ret = -EINVAL;
548 goto out;
549 }
550
551 /* default to all sectors allocated */
552 ret = BDRV_BLOCK_DATA;
553 ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID;
554 *pnum = nb_sectors;
555
556 /* LUN does not support logical block provisioning */
557 if (!iscsilun->lbpme) {
558 goto out;
559 }
560
561 retry:
562 if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,
563 sector_qemu2lun(sector_num, iscsilun),
564 8 + 16, iscsi_co_generic_cb,
565 &iTask) == NULL) {
566 ret = -ENOMEM;
567 goto out;
568 }
569
570 while (!iTask.complete) {
571 iscsi_set_events(iscsilun);
572 qemu_coroutine_yield();
573 }
574
575 if (iTask.do_retry) {
576 if (iTask.task != NULL) {
577 scsi_free_scsi_task(iTask.task);
578 iTask.task = NULL;
579 }
580 iTask.complete = 0;
581 goto retry;
582 }
583
584 if (iTask.status != SCSI_STATUS_GOOD) {
585 /* in case the get_lba_status_callout fails (i.e.
586 * because the device is busy or the cmd is not
587 * supported) we pretend all blocks are allocated
588 * for backwards compatibility */
589 goto out;
590 }
591
592 lbas = scsi_datain_unmarshall(iTask.task);
593 if (lbas == NULL) {
594 ret = -EIO;
595 goto out;
596 }
597
598 lbasd = &lbas->descriptors[0];
599
600 if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) {
601 ret = -EIO;
602 goto out;
603 }
604
605 *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun);
606
607 if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED ||
608 lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) {
609 ret &= ~BDRV_BLOCK_DATA;
610 if (iscsilun->lbprz) {
611 ret |= BDRV_BLOCK_ZERO;
612 }
613 }
614
615 if (ret & BDRV_BLOCK_ZERO) {
616 iscsi_allocationmap_clear(iscsilun, sector_num, *pnum);
617 } else {
618 iscsi_allocationmap_set(iscsilun, sector_num, *pnum);
619 }
620
621 if (*pnum > nb_sectors) {
622 *pnum = nb_sectors;
623 }
624 out:
625 if (iTask.task != NULL) {
626 scsi_free_scsi_task(iTask.task);
627 }
628 return ret;
629 }
630
631 static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,
632 int64_t sector_num, int nb_sectors,
633 QEMUIOVector *iov)
634 {
635 IscsiLun *iscsilun = bs->opaque;
636 struct IscsiTask iTask;
637 uint64_t lba;
638 uint32_t num_sectors;
639
640 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
641 return -EINVAL;
642 }
643
644 if (bs->bl.max_transfer_length && nb_sectors > bs->bl.max_transfer_length) {
645 error_report("iSCSI Error: Read of %d sectors exceeds max_xfer_len "
646 "of %d sectors", nb_sectors, bs->bl.max_transfer_length);
647 return -EINVAL;
648 }
649
650 if (iscsilun->lbprz && nb_sectors >= ISCSI_CHECKALLOC_THRES &&
651 !iscsi_allocationmap_is_allocated(iscsilun, sector_num, nb_sectors)) {
652 int64_t ret;
653 int pnum;
654 BlockDriverState *file;
655 ret = iscsi_co_get_block_status(bs, sector_num, INT_MAX, &pnum, &file);
656 if (ret < 0) {
657 return ret;
658 }
659 if (ret & BDRV_BLOCK_ZERO && pnum >= nb_sectors) {
660 qemu_iovec_memset(iov, 0, 0x00, iov->size);
661 return 0;
662 }
663 }
664
665 lba = sector_qemu2lun(sector_num, iscsilun);
666 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
667
668 iscsi_co_init_iscsitask(iscsilun, &iTask);
669 retry:
670 if (iscsilun->use_16_for_rw) {
671 iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba,
672 num_sectors * iscsilun->block_size,
673 iscsilun->block_size, 0, 0, 0, 0, 0,
674 iscsi_co_generic_cb, &iTask);
675 } else {
676 iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,
677 num_sectors * iscsilun->block_size,
678 iscsilun->block_size,
679 0, 0, 0, 0, 0,
680 iscsi_co_generic_cb, &iTask);
681 }
682 if (iTask.task == NULL) {
683 return -ENOMEM;
684 }
685 scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);
686
687 while (!iTask.complete) {
688 iscsi_set_events(iscsilun);
689 qemu_coroutine_yield();
690 }
691
692 if (iTask.task != NULL) {
693 scsi_free_scsi_task(iTask.task);
694 iTask.task = NULL;
695 }
696
697 if (iTask.do_retry) {
698 iTask.complete = 0;
699 goto retry;
700 }
701
702 if (iTask.status != SCSI_STATUS_GOOD) {
703 return iTask.err_code;
704 }
705
706 return 0;
707 }
708
709 static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)
710 {
711 IscsiLun *iscsilun = bs->opaque;
712 struct IscsiTask iTask;
713
714 if (!iscsilun->force_next_flush) {
715 return 0;
716 }
717 iscsilun->force_next_flush = false;
718
719 iscsi_co_init_iscsitask(iscsilun, &iTask);
720 retry:
721 if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,
722 0, iscsi_co_generic_cb, &iTask) == NULL) {
723 return -ENOMEM;
724 }
725
726 while (!iTask.complete) {
727 iscsi_set_events(iscsilun);
728 qemu_coroutine_yield();
729 }
730
731 if (iTask.task != NULL) {
732 scsi_free_scsi_task(iTask.task);
733 iTask.task = NULL;
734 }
735
736 if (iTask.do_retry) {
737 iTask.complete = 0;
738 goto retry;
739 }
740
741 if (iTask.status != SCSI_STATUS_GOOD) {
742 return iTask.err_code;
743 }
744
745 return 0;
746 }
747
748 #ifdef __linux__
749 static void
750 iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
751 void *command_data, void *opaque)
752 {
753 IscsiAIOCB *acb = opaque;
754
755 g_free(acb->buf);
756 acb->buf = NULL;
757
758 acb->status = 0;
759 if (status < 0) {
760 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
761 iscsi_get_error(iscsi));
762 acb->status = iscsi_translate_sense(&acb->task->sense);
763 }
764
765 acb->ioh->driver_status = 0;
766 acb->ioh->host_status = 0;
767 acb->ioh->resid = 0;
768
769 #define SG_ERR_DRIVER_SENSE 0x08
770
771 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
772 int ss;
773
774 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
775
776 acb->ioh->sb_len_wr = acb->task->datain.size - 2;
777 ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?
778 acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;
779 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
780 }
781
782 iscsi_schedule_bh(acb);
783 }
784
785 static void iscsi_ioctl_bh_completion(void *opaque)
786 {
787 IscsiAIOCB *acb = opaque;
788
789 qemu_bh_delete(acb->bh);
790 acb->common.cb(acb->common.opaque, acb->ret);
791 qemu_aio_unref(acb);
792 }
793
794 static void iscsi_ioctl_handle_emulated(IscsiAIOCB *acb, int req, void *buf)
795 {
796 BlockDriverState *bs = acb->common.bs;
797 IscsiLun *iscsilun = bs->opaque;
798 int ret = 0;
799
800 switch (req) {
801 case SG_GET_VERSION_NUM:
802 *(int *)buf = 30000;
803 break;
804 case SG_GET_SCSI_ID:
805 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
806 break;
807 default:
808 ret = -EINVAL;
809 }
810 assert(!acb->bh);
811 acb->bh = aio_bh_new(bdrv_get_aio_context(bs),
812 iscsi_ioctl_bh_completion, acb);
813 acb->ret = ret;
814 qemu_bh_schedule(acb->bh);
815 }
816
817 static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
818 unsigned long int req, void *buf,
819 BlockCompletionFunc *cb, void *opaque)
820 {
821 IscsiLun *iscsilun = bs->opaque;
822 struct iscsi_context *iscsi = iscsilun->iscsi;
823 struct iscsi_data data;
824 IscsiAIOCB *acb;
825
826 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
827
828 acb->iscsilun = iscsilun;
829 acb->bh = NULL;
830 acb->status = -EINPROGRESS;
831 acb->buf = NULL;
832 acb->ioh = buf;
833
834 if (req != SG_IO) {
835 iscsi_ioctl_handle_emulated(acb, req, buf);
836 return &acb->common;
837 }
838
839 acb->task = malloc(sizeof(struct scsi_task));
840 if (acb->task == NULL) {
841 error_report("iSCSI: Failed to allocate task for scsi command. %s",
842 iscsi_get_error(iscsi));
843 qemu_aio_unref(acb);
844 return NULL;
845 }
846 memset(acb->task, 0, sizeof(struct scsi_task));
847
848 switch (acb->ioh->dxfer_direction) {
849 case SG_DXFER_TO_DEV:
850 acb->task->xfer_dir = SCSI_XFER_WRITE;
851 break;
852 case SG_DXFER_FROM_DEV:
853 acb->task->xfer_dir = SCSI_XFER_READ;
854 break;
855 default:
856 acb->task->xfer_dir = SCSI_XFER_NONE;
857 break;
858 }
859
860 acb->task->cdb_size = acb->ioh->cmd_len;
861 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
862 acb->task->expxferlen = acb->ioh->dxfer_len;
863
864 data.size = 0;
865 if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
866 if (acb->ioh->iovec_count == 0) {
867 data.data = acb->ioh->dxferp;
868 data.size = acb->ioh->dxfer_len;
869 } else {
870 scsi_task_set_iov_out(acb->task,
871 (struct scsi_iovec *) acb->ioh->dxferp,
872 acb->ioh->iovec_count);
873 }
874 }
875
876 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
877 iscsi_aio_ioctl_cb,
878 (data.size > 0) ? &data : NULL,
879 acb) != 0) {
880 scsi_free_scsi_task(acb->task);
881 qemu_aio_unref(acb);
882 return NULL;
883 }
884
885 /* tell libiscsi to read straight into the buffer we got from ioctl */
886 if (acb->task->xfer_dir == SCSI_XFER_READ) {
887 if (acb->ioh->iovec_count == 0) {
888 scsi_task_add_data_in_buffer(acb->task,
889 acb->ioh->dxfer_len,
890 acb->ioh->dxferp);
891 } else {
892 scsi_task_set_iov_in(acb->task,
893 (struct scsi_iovec *) acb->ioh->dxferp,
894 acb->ioh->iovec_count);
895 }
896 }
897
898 iscsi_set_events(iscsilun);
899
900 return &acb->common;
901 }
902
903 #endif
904
905 static int64_t
906 iscsi_getlength(BlockDriverState *bs)
907 {
908 IscsiLun *iscsilun = bs->opaque;
909 int64_t len;
910
911 len = iscsilun->num_blocks;
912 len *= iscsilun->block_size;
913
914 return len;
915 }
916
917 static int
918 coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num,
919 int nb_sectors)
920 {
921 IscsiLun *iscsilun = bs->opaque;
922 struct IscsiTask iTask;
923 struct unmap_list list;
924
925 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
926 return -EINVAL;
927 }
928
929 if (!iscsilun->lbp.lbpu) {
930 /* UNMAP is not supported by the target */
931 return 0;
932 }
933
934 list.lba = sector_qemu2lun(sector_num, iscsilun);
935 list.num = sector_qemu2lun(nb_sectors, iscsilun);
936
937 iscsi_co_init_iscsitask(iscsilun, &iTask);
938 retry:
939 if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
940 iscsi_co_generic_cb, &iTask) == NULL) {
941 return -ENOMEM;
942 }
943
944 while (!iTask.complete) {
945 iscsi_set_events(iscsilun);
946 qemu_coroutine_yield();
947 }
948
949 if (iTask.task != NULL) {
950 scsi_free_scsi_task(iTask.task);
951 iTask.task = NULL;
952 }
953
954 if (iTask.do_retry) {
955 iTask.complete = 0;
956 goto retry;
957 }
958
959 if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
960 /* the target might fail with a check condition if it
961 is not happy with the alignment of the UNMAP request
962 we silently fail in this case */
963 return 0;
964 }
965
966 if (iTask.status != SCSI_STATUS_GOOD) {
967 return iTask.err_code;
968 }
969
970 iscsi_allocationmap_clear(iscsilun, sector_num, nb_sectors);
971
972 return 0;
973 }
974
975 static int
976 coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
977 int nb_sectors, BdrvRequestFlags flags)
978 {
979 IscsiLun *iscsilun = bs->opaque;
980 struct IscsiTask iTask;
981 uint64_t lba;
982 uint32_t nb_blocks;
983 bool use_16_for_ws = iscsilun->use_16_for_rw;
984
985 if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
986 return -EINVAL;
987 }
988
989 if (flags & BDRV_REQ_MAY_UNMAP) {
990 if (!use_16_for_ws && !iscsilun->lbp.lbpws10) {
991 /* WRITESAME10 with UNMAP is unsupported try WRITESAME16 */
992 use_16_for_ws = true;
993 }
994 if (use_16_for_ws && !iscsilun->lbp.lbpws) {
995 /* WRITESAME16 with UNMAP is not supported by the target,
996 * fall back and try WRITESAME10/16 without UNMAP */
997 flags &= ~BDRV_REQ_MAY_UNMAP;
998 use_16_for_ws = iscsilun->use_16_for_rw;
999 }
1000 }
1001
1002 if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
1003 /* WRITESAME without UNMAP is not supported by the target */
1004 return -ENOTSUP;
1005 }
1006
1007 lba = sector_qemu2lun(sector_num, iscsilun);
1008 nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);
1009
1010 if (iscsilun->zeroblock == NULL) {
1011 iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size);
1012 if (iscsilun->zeroblock == NULL) {
1013 return -ENOMEM;
1014 }
1015 }
1016
1017 iscsi_co_init_iscsitask(iscsilun, &iTask);
1018 iTask.force_next_flush = true;
1019 retry:
1020 if (use_16_for_ws) {
1021 iTask.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
1022 iscsilun->zeroblock, iscsilun->block_size,
1023 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1024 0, 0, iscsi_co_generic_cb, &iTask);
1025 } else {
1026 iTask.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba,
1027 iscsilun->zeroblock, iscsilun->block_size,
1028 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1029 0, 0, iscsi_co_generic_cb, &iTask);
1030 }
1031 if (iTask.task == NULL) {
1032 return -ENOMEM;
1033 }
1034
1035 while (!iTask.complete) {
1036 iscsi_set_events(iscsilun);
1037 qemu_coroutine_yield();
1038 }
1039
1040 if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
1041 iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
1042 (iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE ||
1043 iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) {
1044 /* WRITE SAME is not supported by the target */
1045 iscsilun->has_write_same = false;
1046 scsi_free_scsi_task(iTask.task);
1047 return -ENOTSUP;
1048 }
1049
1050 if (iTask.task != NULL) {
1051 scsi_free_scsi_task(iTask.task);
1052 iTask.task = NULL;
1053 }
1054
1055 if (iTask.do_retry) {
1056 iTask.complete = 0;
1057 goto retry;
1058 }
1059
1060 if (iTask.status != SCSI_STATUS_GOOD) {
1061 return iTask.err_code;
1062 }
1063
1064 if (flags & BDRV_REQ_MAY_UNMAP) {
1065 iscsi_allocationmap_clear(iscsilun, sector_num, nb_sectors);
1066 } else {
1067 iscsi_allocationmap_set(iscsilun, sector_num, nb_sectors);
1068 }
1069
1070 return 0;
1071 }
1072
1073 static void parse_chap(struct iscsi_context *iscsi, const char *target,
1074 Error **errp)
1075 {
1076 QemuOptsList *list;
1077 QemuOpts *opts;
1078 const char *user = NULL;
1079 const char *password = NULL;
1080
1081 list = qemu_find_opts("iscsi");
1082 if (!list) {
1083 return;
1084 }
1085
1086 opts = qemu_opts_find(list, target);
1087 if (opts == NULL) {
1088 opts = QTAILQ_FIRST(&list->head);
1089 if (!opts) {
1090 return;
1091 }
1092 }
1093
1094 user = qemu_opt_get(opts, "user");
1095 if (!user) {
1096 return;
1097 }
1098
1099 password = qemu_opt_get(opts, "password");
1100 if (!password) {
1101 error_setg(errp, "CHAP username specified but no password was given");
1102 return;
1103 }
1104
1105 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
1106 error_setg(errp, "Failed to set initiator username and password");
1107 }
1108 }
1109
1110 static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
1111 Error **errp)
1112 {
1113 QemuOptsList *list;
1114 QemuOpts *opts;
1115 const char *digest = NULL;
1116
1117 list = qemu_find_opts("iscsi");
1118 if (!list) {
1119 return;
1120 }
1121
1122 opts = qemu_opts_find(list, target);
1123 if (opts == NULL) {
1124 opts = QTAILQ_FIRST(&list->head);
1125 if (!opts) {
1126 return;
1127 }
1128 }
1129
1130 digest = qemu_opt_get(opts, "header-digest");
1131 if (!digest) {
1132 return;
1133 }
1134
1135 if (!strcmp(digest, "CRC32C")) {
1136 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
1137 } else if (!strcmp(digest, "NONE")) {
1138 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
1139 } else if (!strcmp(digest, "CRC32C-NONE")) {
1140 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
1141 } else if (!strcmp(digest, "NONE-CRC32C")) {
1142 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1143 } else {
1144 error_setg(errp, "Invalid header-digest setting : %s", digest);
1145 }
1146 }
1147
1148 static char *parse_initiator_name(const char *target)
1149 {
1150 QemuOptsList *list;
1151 QemuOpts *opts;
1152 const char *name;
1153 char *iscsi_name;
1154 UuidInfo *uuid_info;
1155
1156 list = qemu_find_opts("iscsi");
1157 if (list) {
1158 opts = qemu_opts_find(list, target);
1159 if (!opts) {
1160 opts = QTAILQ_FIRST(&list->head);
1161 }
1162 if (opts) {
1163 name = qemu_opt_get(opts, "initiator-name");
1164 if (name) {
1165 return g_strdup(name);
1166 }
1167 }
1168 }
1169
1170 uuid_info = qmp_query_uuid(NULL);
1171 if (strcmp(uuid_info->UUID, UUID_NONE) == 0) {
1172 name = qemu_get_vm_name();
1173 } else {
1174 name = uuid_info->UUID;
1175 }
1176 iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
1177 name ? ":" : "", name ? name : "");
1178 qapi_free_UuidInfo(uuid_info);
1179 return iscsi_name;
1180 }
1181
1182 static int parse_timeout(const char *target)
1183 {
1184 QemuOptsList *list;
1185 QemuOpts *opts;
1186 const char *timeout;
1187
1188 list = qemu_find_opts("iscsi");
1189 if (list) {
1190 opts = qemu_opts_find(list, target);
1191 if (!opts) {
1192 opts = QTAILQ_FIRST(&list->head);
1193 }
1194 if (opts) {
1195 timeout = qemu_opt_get(opts, "timeout");
1196 if (timeout) {
1197 return atoi(timeout);
1198 }
1199 }
1200 }
1201
1202 return 0;
1203 }
1204
1205 static void iscsi_nop_timed_event(void *opaque)
1206 {
1207 IscsiLun *iscsilun = opaque;
1208
1209 if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
1210 error_report("iSCSI: NOP timeout. Reconnecting...");
1211 iscsilun->request_timed_out = true;
1212 } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
1213 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
1214 return;
1215 }
1216
1217 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1218 iscsi_set_events(iscsilun);
1219 }
1220
1221 static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
1222 {
1223 struct scsi_task *task = NULL;
1224 struct scsi_readcapacity10 *rc10 = NULL;
1225 struct scsi_readcapacity16 *rc16 = NULL;
1226 int retries = ISCSI_CMD_RETRIES;
1227
1228 do {
1229 if (task != NULL) {
1230 scsi_free_scsi_task(task);
1231 task = NULL;
1232 }
1233
1234 switch (iscsilun->type) {
1235 case TYPE_DISK:
1236 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun);
1237 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1238 rc16 = scsi_datain_unmarshall(task);
1239 if (rc16 == NULL) {
1240 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity16 data.");
1241 } else {
1242 iscsilun->block_size = rc16->block_length;
1243 iscsilun->num_blocks = rc16->returned_lba + 1;
1244 iscsilun->lbpme = !!rc16->lbpme;
1245 iscsilun->lbprz = !!rc16->lbprz;
1246 iscsilun->use_16_for_rw = (rc16->returned_lba > 0xffffffff);
1247 }
1248 break;
1249 }
1250 if (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1251 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
1252 break;
1253 }
1254 /* Fall through and try READ CAPACITY(10) instead. */
1255 case TYPE_ROM:
1256 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0);
1257 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1258 rc10 = scsi_datain_unmarshall(task);
1259 if (rc10 == NULL) {
1260 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity10 data.");
1261 } else {
1262 iscsilun->block_size = rc10->block_size;
1263 if (rc10->lba == 0) {
1264 /* blank disk loaded */
1265 iscsilun->num_blocks = 0;
1266 } else {
1267 iscsilun->num_blocks = rc10->lba + 1;
1268 }
1269 }
1270 }
1271 break;
1272 default:
1273 return;
1274 }
1275 } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1276 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION
1277 && retries-- > 0);
1278
1279 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1280 error_setg(errp, "iSCSI: failed to send readcapacity10/16 command");
1281 } else if (!iscsilun->block_size ||
1282 iscsilun->block_size % BDRV_SECTOR_SIZE) {
1283 error_setg(errp, "iSCSI: the target returned an invalid "
1284 "block size of %d.", iscsilun->block_size);
1285 }
1286 if (task) {
1287 scsi_free_scsi_task(task);
1288 }
1289 }
1290
1291 /* TODO Convert to fine grained options */
1292 static QemuOptsList runtime_opts = {
1293 .name = "iscsi",
1294 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1295 .desc = {
1296 {
1297 .name = "filename",
1298 .type = QEMU_OPT_STRING,
1299 .help = "URL to the iscsi image",
1300 },
1301 { /* end of list */ }
1302 },
1303 };
1304
1305 static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
1306 int evpd, int pc, void **inq, Error **errp)
1307 {
1308 int full_size;
1309 struct scsi_task *task = NULL;
1310 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
1311 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1312 goto fail;
1313 }
1314 full_size = scsi_datain_getfullsize(task);
1315 if (full_size > task->datain.size) {
1316 scsi_free_scsi_task(task);
1317
1318 /* we need more data for the full list */
1319 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size);
1320 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1321 goto fail;
1322 }
1323 }
1324
1325 *inq = scsi_datain_unmarshall(task);
1326 if (*inq == NULL) {
1327 error_setg(errp, "iSCSI: failed to unmarshall inquiry datain blob");
1328 goto fail_with_err;
1329 }
1330
1331 return task;
1332
1333 fail:
1334 error_setg(errp, "iSCSI: Inquiry command failed : %s",
1335 iscsi_get_error(iscsi));
1336 fail_with_err:
1337 if (task != NULL) {
1338 scsi_free_scsi_task(task);
1339 }
1340 return NULL;
1341 }
1342
1343 static void iscsi_detach_aio_context(BlockDriverState *bs)
1344 {
1345 IscsiLun *iscsilun = bs->opaque;
1346
1347 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
1348 false, NULL, NULL, NULL);
1349 iscsilun->events = 0;
1350
1351 if (iscsilun->nop_timer) {
1352 timer_del(iscsilun->nop_timer);
1353 timer_free(iscsilun->nop_timer);
1354 iscsilun->nop_timer = NULL;
1355 }
1356 if (iscsilun->event_timer) {
1357 timer_del(iscsilun->event_timer);
1358 timer_free(iscsilun->event_timer);
1359 iscsilun->event_timer = NULL;
1360 }
1361 }
1362
1363 static void iscsi_attach_aio_context(BlockDriverState *bs,
1364 AioContext *new_context)
1365 {
1366 IscsiLun *iscsilun = bs->opaque;
1367
1368 iscsilun->aio_context = new_context;
1369 iscsi_set_events(iscsilun);
1370
1371 /* Set up a timer for sending out iSCSI NOPs */
1372 iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
1373 QEMU_CLOCK_REALTIME, SCALE_MS,
1374 iscsi_nop_timed_event, iscsilun);
1375 timer_mod(iscsilun->nop_timer,
1376 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1377
1378 /* Set up a timer for periodic calls to iscsi_set_events and to
1379 * scan for command timeout */
1380 iscsilun->event_timer = aio_timer_new(iscsilun->aio_context,
1381 QEMU_CLOCK_REALTIME, SCALE_MS,
1382 iscsi_timed_check_events, iscsilun);
1383 timer_mod(iscsilun->event_timer,
1384 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
1385 }
1386
1387 static void iscsi_modesense_sync(IscsiLun *iscsilun)
1388 {
1389 struct scsi_task *task;
1390 struct scsi_mode_sense *ms = NULL;
1391 iscsilun->write_protected = false;
1392 iscsilun->dpofua = false;
1393
1394 task = iscsi_modesense6_sync(iscsilun->iscsi, iscsilun->lun,
1395 1, SCSI_MODESENSE_PC_CURRENT,
1396 0x3F, 0, 255);
1397 if (task == NULL) {
1398 error_report("iSCSI: Failed to send MODE_SENSE(6) command: %s",
1399 iscsi_get_error(iscsilun->iscsi));
1400 goto out;
1401 }
1402
1403 if (task->status != SCSI_STATUS_GOOD) {
1404 error_report("iSCSI: Failed MODE_SENSE(6), LUN assumed writable");
1405 goto out;
1406 }
1407 ms = scsi_datain_unmarshall(task);
1408 if (!ms) {
1409 error_report("iSCSI: Failed to unmarshall MODE_SENSE(6) data: %s",
1410 iscsi_get_error(iscsilun->iscsi));
1411 goto out;
1412 }
1413 iscsilun->write_protected = ms->device_specific_parameter & 0x80;
1414 iscsilun->dpofua = ms->device_specific_parameter & 0x10;
1415
1416 out:
1417 if (task) {
1418 scsi_free_scsi_task(task);
1419 }
1420 }
1421
1422 /*
1423 * We support iscsi url's on the form
1424 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1425 */
1426 static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
1427 Error **errp)
1428 {
1429 IscsiLun *iscsilun = bs->opaque;
1430 struct iscsi_context *iscsi = NULL;
1431 struct iscsi_url *iscsi_url = NULL;
1432 struct scsi_task *task = NULL;
1433 struct scsi_inquiry_standard *inq = NULL;
1434 struct scsi_inquiry_supported_pages *inq_vpd;
1435 char *initiator_name = NULL;
1436 QemuOpts *opts;
1437 Error *local_err = NULL;
1438 const char *filename;
1439 int i, ret = 0, timeout = 0;
1440
1441 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1442 qemu_opts_absorb_qdict(opts, options, &local_err);
1443 if (local_err) {
1444 error_propagate(errp, local_err);
1445 ret = -EINVAL;
1446 goto out;
1447 }
1448
1449 filename = qemu_opt_get(opts, "filename");
1450
1451 iscsi_url = iscsi_parse_full_url(iscsi, filename);
1452 if (iscsi_url == NULL) {
1453 error_setg(errp, "Failed to parse URL : %s", filename);
1454 ret = -EINVAL;
1455 goto out;
1456 }
1457
1458 memset(iscsilun, 0, sizeof(IscsiLun));
1459
1460 initiator_name = parse_initiator_name(iscsi_url->target);
1461
1462 iscsi = iscsi_create_context(initiator_name);
1463 if (iscsi == NULL) {
1464 error_setg(errp, "iSCSI: Failed to create iSCSI context.");
1465 ret = -ENOMEM;
1466 goto out;
1467 }
1468
1469 if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
1470 error_setg(errp, "iSCSI: Failed to set target name.");
1471 ret = -EINVAL;
1472 goto out;
1473 }
1474
1475 if (iscsi_url->user[0] != '\0') {
1476 ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
1477 iscsi_url->passwd);
1478 if (ret != 0) {
1479 error_setg(errp, "Failed to set initiator username and password");
1480 ret = -EINVAL;
1481 goto out;
1482 }
1483 }
1484
1485 /* check if we got CHAP username/password via the options */
1486 parse_chap(iscsi, iscsi_url->target, &local_err);
1487 if (local_err != NULL) {
1488 error_propagate(errp, local_err);
1489 ret = -EINVAL;
1490 goto out;
1491 }
1492
1493 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
1494 error_setg(errp, "iSCSI: Failed to set session type to normal.");
1495 ret = -EINVAL;
1496 goto out;
1497 }
1498
1499 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1500
1501 /* check if we got HEADER_DIGEST via the options */
1502 parse_header_digest(iscsi, iscsi_url->target, &local_err);
1503 if (local_err != NULL) {
1504 error_propagate(errp, local_err);
1505 ret = -EINVAL;
1506 goto out;
1507 }
1508
1509 /* timeout handling is broken in libiscsi before 1.15.0 */
1510 timeout = parse_timeout(iscsi_url->target);
1511 #if defined(LIBISCSI_API_VERSION) && LIBISCSI_API_VERSION >= 20150621
1512 iscsi_set_timeout(iscsi, timeout);
1513 #else
1514 if (timeout) {
1515 error_report("iSCSI: ignoring timeout value for libiscsi <1.15.0");
1516 }
1517 #endif
1518
1519 if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
1520 error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
1521 iscsi_get_error(iscsi));
1522 ret = -EINVAL;
1523 goto out;
1524 }
1525
1526 iscsilun->iscsi = iscsi;
1527 iscsilun->aio_context = bdrv_get_aio_context(bs);
1528 iscsilun->lun = iscsi_url->lun;
1529 iscsilun->has_write_same = true;
1530
1531 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
1532 (void **) &inq, errp);
1533 if (task == NULL) {
1534 ret = -EINVAL;
1535 goto out;
1536 }
1537 iscsilun->type = inq->periperal_device_type;
1538 scsi_free_scsi_task(task);
1539 task = NULL;
1540
1541 iscsi_modesense_sync(iscsilun);
1542
1543 /* Check the write protect flag of the LUN if we want to write */
1544 if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
1545 iscsilun->write_protected) {
1546 error_setg(errp, "Cannot open a write protected LUN as read-write");
1547 ret = -EACCES;
1548 goto out;
1549 }
1550
1551 iscsi_readcapacity_sync(iscsilun, &local_err);
1552 if (local_err != NULL) {
1553 error_propagate(errp, local_err);
1554 ret = -EINVAL;
1555 goto out;
1556 }
1557 bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun);
1558 bs->request_alignment = iscsilun->block_size;
1559
1560 /* We don't have any emulation for devices other than disks and CD-ROMs, so
1561 * this must be sg ioctl compatible. We force it to be sg, otherwise qemu
1562 * will try to read from the device to guess the image format.
1563 */
1564 if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) {
1565 bs->sg = 1;
1566 }
1567
1568 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1569 SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES,
1570 (void **) &inq_vpd, errp);
1571 if (task == NULL) {
1572 ret = -EINVAL;
1573 goto out;
1574 }
1575 for (i = 0; i < inq_vpd->num_pages; i++) {
1576 struct scsi_task *inq_task;
1577 struct scsi_inquiry_logical_block_provisioning *inq_lbp;
1578 struct scsi_inquiry_block_limits *inq_bl;
1579 switch (inq_vpd->pages[i]) {
1580 case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
1581 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1582 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING,
1583 (void **) &inq_lbp, errp);
1584 if (inq_task == NULL) {
1585 ret = -EINVAL;
1586 goto out;
1587 }
1588 memcpy(&iscsilun->lbp, inq_lbp,
1589 sizeof(struct scsi_inquiry_logical_block_provisioning));
1590 scsi_free_scsi_task(inq_task);
1591 break;
1592 case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
1593 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1594 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS,
1595 (void **) &inq_bl, errp);
1596 if (inq_task == NULL) {
1597 ret = -EINVAL;
1598 goto out;
1599 }
1600 memcpy(&iscsilun->bl, inq_bl,
1601 sizeof(struct scsi_inquiry_block_limits));
1602 scsi_free_scsi_task(inq_task);
1603 break;
1604 default:
1605 break;
1606 }
1607 }
1608 scsi_free_scsi_task(task);
1609 task = NULL;
1610
1611 iscsi_attach_aio_context(bs, iscsilun->aio_context);
1612
1613 /* Guess the internal cluster (page) size of the iscsi target by the means
1614 * of opt_unmap_gran. Transfer the unmap granularity only if it has a
1615 * reasonable size */
1616 if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 4 * 1024 &&
1617 iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) {
1618 iscsilun->cluster_sectors = (iscsilun->bl.opt_unmap_gran *
1619 iscsilun->block_size) >> BDRV_SECTOR_BITS;
1620 if (iscsilun->lbprz) {
1621 iscsilun->allocationmap = iscsi_allocationmap_init(iscsilun);
1622 if (iscsilun->allocationmap == NULL) {
1623 ret = -ENOMEM;
1624 }
1625 }
1626 }
1627
1628 out:
1629 qemu_opts_del(opts);
1630 g_free(initiator_name);
1631 if (iscsi_url != NULL) {
1632 iscsi_destroy_url(iscsi_url);
1633 }
1634 if (task != NULL) {
1635 scsi_free_scsi_task(task);
1636 }
1637
1638 if (ret) {
1639 if (iscsi != NULL) {
1640 if (iscsi_is_logged_in(iscsi)) {
1641 iscsi_logout_sync(iscsi);
1642 }
1643 iscsi_destroy_context(iscsi);
1644 }
1645 memset(iscsilun, 0, sizeof(IscsiLun));
1646 }
1647 return ret;
1648 }
1649
1650 static void iscsi_close(BlockDriverState *bs)
1651 {
1652 IscsiLun *iscsilun = bs->opaque;
1653 struct iscsi_context *iscsi = iscsilun->iscsi;
1654
1655 iscsi_detach_aio_context(bs);
1656 if (iscsi_is_logged_in(iscsi)) {
1657 iscsi_logout_sync(iscsi);
1658 }
1659 iscsi_destroy_context(iscsi);
1660 g_free(iscsilun->zeroblock);
1661 g_free(iscsilun->allocationmap);
1662 memset(iscsilun, 0, sizeof(IscsiLun));
1663 }
1664
1665 static int sector_limits_lun2qemu(int64_t sector, IscsiLun *iscsilun)
1666 {
1667 return MIN(sector_lun2qemu(sector, iscsilun), INT_MAX / 2 + 1);
1668 }
1669
1670 static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp)
1671 {
1672 /* We don't actually refresh here, but just return data queried in
1673 * iscsi_open(): iscsi targets don't change their limits. */
1674
1675 IscsiLun *iscsilun = bs->opaque;
1676 uint32_t max_xfer_len = iscsilun->use_16_for_rw ? 0xffffffff : 0xffff;
1677
1678 if (iscsilun->bl.max_xfer_len) {
1679 max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len);
1680 }
1681
1682 bs->bl.max_transfer_length = sector_limits_lun2qemu(max_xfer_len, iscsilun);
1683
1684 if (iscsilun->lbp.lbpu) {
1685 if (iscsilun->bl.max_unmap < 0xffffffff) {
1686 bs->bl.max_discard =
1687 sector_limits_lun2qemu(iscsilun->bl.max_unmap, iscsilun);
1688 }
1689 bs->bl.discard_alignment =
1690 sector_limits_lun2qemu(iscsilun->bl.opt_unmap_gran, iscsilun);
1691 }
1692
1693 if (iscsilun->bl.max_ws_len < 0xffffffff) {
1694 bs->bl.max_write_zeroes =
1695 sector_limits_lun2qemu(iscsilun->bl.max_ws_len, iscsilun);
1696 }
1697 if (iscsilun->lbp.lbpws) {
1698 bs->bl.write_zeroes_alignment =
1699 sector_limits_lun2qemu(iscsilun->bl.opt_unmap_gran, iscsilun);
1700 }
1701 bs->bl.opt_transfer_length =
1702 sector_limits_lun2qemu(iscsilun->bl.opt_xfer_len, iscsilun);
1703 }
1704
1705 /* Note that this will not re-establish a connection with an iSCSI target - it
1706 * is effectively a NOP. */
1707 static int iscsi_reopen_prepare(BDRVReopenState *state,
1708 BlockReopenQueue *queue, Error **errp)
1709 {
1710 IscsiLun *iscsilun = state->bs->opaque;
1711
1712 if (state->flags & BDRV_O_RDWR && iscsilun->write_protected) {
1713 error_setg(errp, "Cannot open a write protected LUN as read-write");
1714 return -EACCES;
1715 }
1716 return 0;
1717 }
1718
1719 static int iscsi_truncate(BlockDriverState *bs, int64_t offset)
1720 {
1721 IscsiLun *iscsilun = bs->opaque;
1722 Error *local_err = NULL;
1723
1724 if (iscsilun->type != TYPE_DISK) {
1725 return -ENOTSUP;
1726 }
1727
1728 iscsi_readcapacity_sync(iscsilun, &local_err);
1729 if (local_err != NULL) {
1730 error_free(local_err);
1731 return -EIO;
1732 }
1733
1734 if (offset > iscsi_getlength(bs)) {
1735 return -EINVAL;
1736 }
1737
1738 if (iscsilun->allocationmap != NULL) {
1739 g_free(iscsilun->allocationmap);
1740 iscsilun->allocationmap = iscsi_allocationmap_init(iscsilun);
1741 }
1742
1743 return 0;
1744 }
1745
1746 static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp)
1747 {
1748 int ret = 0;
1749 int64_t total_size = 0;
1750 BlockDriverState *bs;
1751 IscsiLun *iscsilun = NULL;
1752 QDict *bs_options;
1753
1754 bs = bdrv_new();
1755
1756 /* Read out options */
1757 total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1758 BDRV_SECTOR_SIZE);
1759 bs->opaque = g_new0(struct IscsiLun, 1);
1760 iscsilun = bs->opaque;
1761
1762 bs_options = qdict_new();
1763 qdict_put(bs_options, "filename", qstring_from_str(filename));
1764 ret = iscsi_open(bs, bs_options, 0, NULL);
1765 QDECREF(bs_options);
1766
1767 if (ret != 0) {
1768 goto out;
1769 }
1770 iscsi_detach_aio_context(bs);
1771 if (iscsilun->type != TYPE_DISK) {
1772 ret = -ENODEV;
1773 goto out;
1774 }
1775 if (bs->total_sectors < total_size) {
1776 ret = -ENOSPC;
1777 goto out;
1778 }
1779
1780 ret = 0;
1781 out:
1782 if (iscsilun->iscsi != NULL) {
1783 iscsi_destroy_context(iscsilun->iscsi);
1784 }
1785 g_free(bs->opaque);
1786 bs->opaque = NULL;
1787 bdrv_unref(bs);
1788 return ret;
1789 }
1790
1791 static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1792 {
1793 IscsiLun *iscsilun = bs->opaque;
1794 bdi->unallocated_blocks_are_zero = iscsilun->lbprz;
1795 bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws;
1796 bdi->cluster_size = iscsilun->cluster_sectors * BDRV_SECTOR_SIZE;
1797 return 0;
1798 }
1799
1800 static QemuOptsList iscsi_create_opts = {
1801 .name = "iscsi-create-opts",
1802 .head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head),
1803 .desc = {
1804 {
1805 .name = BLOCK_OPT_SIZE,
1806 .type = QEMU_OPT_SIZE,
1807 .help = "Virtual disk size"
1808 },
1809 { /* end of list */ }
1810 }
1811 };
1812
1813 static BlockDriver bdrv_iscsi = {
1814 .format_name = "iscsi",
1815 .protocol_name = "iscsi",
1816
1817 .instance_size = sizeof(IscsiLun),
1818 .bdrv_needs_filename = true,
1819 .bdrv_file_open = iscsi_open,
1820 .bdrv_close = iscsi_close,
1821 .bdrv_create = iscsi_create,
1822 .create_opts = &iscsi_create_opts,
1823 .bdrv_reopen_prepare = iscsi_reopen_prepare,
1824
1825 .bdrv_getlength = iscsi_getlength,
1826 .bdrv_get_info = iscsi_get_info,
1827 .bdrv_truncate = iscsi_truncate,
1828 .bdrv_refresh_limits = iscsi_refresh_limits,
1829
1830 .bdrv_co_get_block_status = iscsi_co_get_block_status,
1831 .bdrv_co_discard = iscsi_co_discard,
1832 .bdrv_co_write_zeroes = iscsi_co_write_zeroes,
1833 .bdrv_co_readv = iscsi_co_readv,
1834 .bdrv_co_writev = iscsi_co_writev,
1835 .bdrv_co_flush_to_disk = iscsi_co_flush,
1836
1837 #ifdef __linux__
1838 .bdrv_aio_ioctl = iscsi_aio_ioctl,
1839 #endif
1840
1841 .bdrv_detach_aio_context = iscsi_detach_aio_context,
1842 .bdrv_attach_aio_context = iscsi_attach_aio_context,
1843 };
1844
1845 static QemuOptsList qemu_iscsi_opts = {
1846 .name = "iscsi",
1847 .head = QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts.head),
1848 .desc = {
1849 {
1850 .name = "user",
1851 .type = QEMU_OPT_STRING,
1852 .help = "username for CHAP authentication to target",
1853 },{
1854 .name = "password",
1855 .type = QEMU_OPT_STRING,
1856 .help = "password for CHAP authentication to target",
1857 },{
1858 .name = "header-digest",
1859 .type = QEMU_OPT_STRING,
1860 .help = "HeaderDigest setting. "
1861 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}",
1862 },{
1863 .name = "initiator-name",
1864 .type = QEMU_OPT_STRING,
1865 .help = "Initiator iqn name to use when connecting",
1866 },{
1867 .name = "timeout",
1868 .type = QEMU_OPT_NUMBER,
1869 .help = "Request timeout in seconds (default 0 = no timeout)",
1870 },
1871 { /* end of list */ }
1872 },
1873 };
1874
1875 static void iscsi_block_init(void)
1876 {
1877 bdrv_register(&bdrv_iscsi);
1878 qemu_add_opts(&qemu_iscsi_opts);
1879 }
1880
1881 block_init(iscsi_block_init);
AR7 emulation for QEMU