?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390x: bump ADAPTER_ROUTES_MAX_GSI
[qemu/ar7.git] / block / iscsi.c
blobc4f813bfd216dd8965ee22c50324248b5014c561
1 /*
2 * QEMU Block driver for iSCSI images
3 *
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
5 * Copyright (c) 2012-2016 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 "qemu/uuid.h"
40 #include "qmp-commands.h"
41 #include "qapi/qmp/qstring.h"
42 #include "crypto/secret.h"
43
44 #include <iscsi/iscsi.h>
45 #include <iscsi/scsi-lowlevel.h>
46
47 #ifdef __linux__
48 #include <scsi/sg.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 /* The allocmap tracks which clusters (pages) on the iSCSI target are
65 * allocated and which are not. In case a target returns zeros for
66 * unallocated pages (iscsilun->lprz) we can directly return zeros instead
67 * of reading zeros over the wire if a read request falls within an
68 * unallocated block. As there are 3 possible states we need 2 bitmaps to
69 * track. allocmap_valid keeps track if QEMU's information about a page is
70 * valid. allocmap tracks if a page is allocated or not. In case QEMU has no
71 * valid information about a page the corresponding allocmap entry should be
72 * switched to unallocated as well to force a new lookup of the allocation
73 * status as lookups are generally skipped if a page is suspect to be
74 * allocated. If a iSCSI target is opened with cache.direct = on the
75 * allocmap_valid does not exist turning all cached information invalid so
76 * that a fresh lookup is made for any page even if allocmap entry returns
77 * it's unallocated. */
78 unsigned long *allocmap;
79 unsigned long *allocmap_valid;
80 long allocmap_size;
81 int cluster_sectors;
82 bool use_16_for_rw;
83 bool write_protected;
84 bool lbpme;
85 bool lbprz;
86 bool dpofua;
87 bool has_write_same;
88 bool request_timed_out;
89 } IscsiLun;
90
91 typedef struct IscsiTask {
92 int status;
93 int complete;
94 int retries;
95 int do_retry;
96 struct scsi_task *task;
97 Coroutine *co;
98 IscsiLun *iscsilun;
99 QEMUTimer retry_timer;
100 int err_code;
101 } IscsiTask;
102
103 typedef struct IscsiAIOCB {
104 BlockAIOCB common;
105 QEMUIOVector *qiov;
106 QEMUBH *bh;
107 IscsiLun *iscsilun;
108 struct scsi_task *task;
109 uint8_t *buf;
110 int status;
111 int64_t sector_num;
112 int nb_sectors;
113 int ret;
114 #ifdef __linux__
115 sg_io_hdr_t *ioh;
116 #endif
117 } IscsiAIOCB;
118
119 /* libiscsi uses time_t so its enough to process events every second */
120 #define EVENT_INTERVAL 1000
121 #define NOP_INTERVAL 5000
122 #define MAX_NOP_FAILURES 3
123 #define ISCSI_CMD_RETRIES ARRAY_SIZE(iscsi_retry_times)
124 static const unsigned iscsi_retry_times[] = {8, 32, 128, 512, 2048, 8192, 32768};
125
126 /* this threshold is a trade-off knob to choose between
127 * the potential additional overhead of an extra GET_LBA_STATUS request
128 * vs. unnecessarily reading a lot of zero sectors over the wire.
129 * If a read request is greater or equal than ISCSI_CHECKALLOC_THRES
130 * sectors we check the allocation status of the area covered by the
131 * request first if the allocationmap indicates that the area might be
132 * unallocated. */
133 #define ISCSI_CHECKALLOC_THRES 64
134
135 static void
136 iscsi_bh_cb(void *p)
137 {
138 IscsiAIOCB *acb = p;
139
140 qemu_bh_delete(acb->bh);
141
142 g_free(acb->buf);
143 acb->buf = NULL;
144
145 acb->common.cb(acb->common.opaque, acb->status);
146
147 if (acb->task != NULL) {
148 scsi_free_scsi_task(acb->task);
149 acb->task = NULL;
150 }
151
152 qemu_aio_unref(acb);
153 }
154
155 static void
156 iscsi_schedule_bh(IscsiAIOCB *acb)
157 {
158 if (acb->bh) {
159 return;
160 }
161 acb->bh = aio_bh_new(acb->iscsilun->aio_context, iscsi_bh_cb, acb);
162 qemu_bh_schedule(acb->bh);
163 }
164
165 static void iscsi_co_generic_bh_cb(void *opaque)
166 {
167 struct IscsiTask *iTask = opaque;
168
169 iTask->complete = 1;
170 aio_co_wake(iTask->co);
171 }
172
173 static void iscsi_retry_timer_expired(void *opaque)
174 {
175 struct IscsiTask *iTask = opaque;
176 iTask->complete = 1;
177 if (iTask->co) {
178 aio_co_wake(iTask->co);
179 }
180 }
181
182 static inline unsigned exp_random(double mean)
183 {
184 return -mean * log((double)rand() / RAND_MAX);
185 }
186
187 /* SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST was introduced in
188 * libiscsi 1.10.0, together with other constants we need. Use it as
189 * a hint that we have to define them ourselves if needed, to keep the
190 * minimum required libiscsi version at 1.9.0. We use an ASCQ macro for
191 * the test because SCSI_STATUS_* is an enum.
192 *
193 * To guard against future changes where SCSI_SENSE_ASCQ_* also becomes
194 * an enum, check against the LIBISCSI_API_VERSION macro, which was
195 * introduced in 1.11.0. If it is present, there is no need to define
196 * anything.
197 */
198 #if !defined(SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST) && \
199 !defined(LIBISCSI_API_VERSION)
200 #define SCSI_STATUS_TASK_SET_FULL 0x28
201 #define SCSI_STATUS_TIMEOUT 0x0f000002
202 #define SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST 0x2600
203 #define SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR 0x1a00
204 #endif
205
206 #ifndef LIBISCSI_API_VERSION
207 #define LIBISCSI_API_VERSION 20130701
208 #endif
209
210 static int iscsi_translate_sense(struct scsi_sense *sense)
211 {
212 int ret;
213
214 switch (sense->key) {
215 case SCSI_SENSE_NOT_READY:
216 return -EBUSY;
217 case SCSI_SENSE_DATA_PROTECTION:
218 return -EACCES;
219 case SCSI_SENSE_COMMAND_ABORTED:
220 return -ECANCELED;
221 case SCSI_SENSE_ILLEGAL_REQUEST:
222 /* Parse ASCQ */
223 break;
224 default:
225 return -EIO;
226 }
227 switch (sense->ascq) {
228 case SCSI_SENSE_ASCQ_PARAMETER_LIST_LENGTH_ERROR:
229 case SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE:
230 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB:
231 case SCSI_SENSE_ASCQ_INVALID_FIELD_IN_PARAMETER_LIST:
232 ret = -EINVAL;
233 break;
234 case SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE:
235 ret = -ENOSPC;
236 break;
237 case SCSI_SENSE_ASCQ_LOGICAL_UNIT_NOT_SUPPORTED:
238 ret = -ENOTSUP;
239 break;
240 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT:
241 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED:
242 case SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN:
243 ret = -ENOMEDIUM;
244 break;
245 case SCSI_SENSE_ASCQ_WRITE_PROTECTED:
246 ret = -EACCES;
247 break;
248 default:
249 ret = -EIO;
250 break;
251 }
252 return ret;
253 }
254
255 static void
256 iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
257 void *command_data, void *opaque)
258 {
259 struct IscsiTask *iTask = opaque;
260 struct scsi_task *task = command_data;
261
262 iTask->status = status;
263 iTask->do_retry = 0;
264 iTask->task = task;
265
266 if (status != SCSI_STATUS_GOOD) {
267 if (iTask->retries++ < ISCSI_CMD_RETRIES) {
268 if (status == SCSI_STATUS_CHECK_CONDITION
269 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
270 error_report("iSCSI CheckCondition: %s",
271 iscsi_get_error(iscsi));
272 iTask->do_retry = 1;
273 goto out;
274 }
275 if (status == SCSI_STATUS_BUSY ||
276 status == SCSI_STATUS_TIMEOUT ||
277 status == SCSI_STATUS_TASK_SET_FULL) {
278 unsigned retry_time =
279 exp_random(iscsi_retry_times[iTask->retries - 1]);
280 if (status == SCSI_STATUS_TIMEOUT) {
281 /* make sure the request is rescheduled AFTER the
282 * reconnect is initiated */
283 retry_time = EVENT_INTERVAL * 2;
284 iTask->iscsilun->request_timed_out = true;
285 }
286 error_report("iSCSI Busy/TaskSetFull/TimeOut"
287 " (retry #%u in %u ms): %s",
288 iTask->retries, retry_time,
289 iscsi_get_error(iscsi));
290 aio_timer_init(iTask->iscsilun->aio_context,
291 &iTask->retry_timer, QEMU_CLOCK_REALTIME,
292 SCALE_MS, iscsi_retry_timer_expired, iTask);
293 timer_mod(&iTask->retry_timer,
294 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time);
295 iTask->do_retry = 1;
296 return;
297 }
298 }
299 iTask->err_code = iscsi_translate_sense(&task->sense);
300 error_report("iSCSI Failure: %s", iscsi_get_error(iscsi));
301 }
302
303 out:
304 if (iTask->co) {
305 aio_bh_schedule_oneshot(iTask->iscsilun->aio_context,
306 iscsi_co_generic_bh_cb, iTask);
307 } else {
308 iTask->complete = 1;
309 }
310 }
311
312 static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
313 {
314 *iTask = (struct IscsiTask) {
315 .co = qemu_coroutine_self(),
316 .iscsilun = iscsilun,
317 };
318 }
319
320 static void
321 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
322 void *private_data)
323 {
324 IscsiAIOCB *acb = private_data;
325
326 acb->status = -ECANCELED;
327 iscsi_schedule_bh(acb);
328 }
329
330 static void
331 iscsi_aio_cancel(BlockAIOCB *blockacb)
332 {
333 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
334 IscsiLun *iscsilun = acb->iscsilun;
335
336 if (acb->status != -EINPROGRESS) {
337 return;
338 }
339
340 /* send a task mgmt call to the target to cancel the task on the target */
341 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
342 iscsi_abort_task_cb, acb);
343
344 }
345
346 static const AIOCBInfo iscsi_aiocb_info = {
347 .aiocb_size = sizeof(IscsiAIOCB),
348 .cancel_async = iscsi_aio_cancel,
349 };
350
351
352 static void iscsi_process_read(void *arg);
353 static void iscsi_process_write(void *arg);
354
355 static void
356 iscsi_set_events(IscsiLun *iscsilun)
357 {
358 struct iscsi_context *iscsi = iscsilun->iscsi;
359 int ev = iscsi_which_events(iscsi);
360
361 if (ev != iscsilun->events) {
362 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsi),
363 false,
364 (ev & POLLIN) ? iscsi_process_read : NULL,
365 (ev & POLLOUT) ? iscsi_process_write : NULL,
366 NULL,
367 iscsilun);
368 iscsilun->events = ev;
369 }
370 }
371
372 static void iscsi_timed_check_events(void *opaque)
373 {
374 IscsiLun *iscsilun = opaque;
375
376 /* check for timed out requests */
377 iscsi_service(iscsilun->iscsi, 0);
378
379 if (iscsilun->request_timed_out) {
380 iscsilun->request_timed_out = false;
381 iscsi_reconnect(iscsilun->iscsi);
382 }
383
384 /* newer versions of libiscsi may return zero events. Ensure we are able
385 * to return to service once this situation changes. */
386 iscsi_set_events(iscsilun);
387
388 timer_mod(iscsilun->event_timer,
389 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
390 }
391
392 static void
393 iscsi_process_read(void *arg)
394 {
395 IscsiLun *iscsilun = arg;
396 struct iscsi_context *iscsi = iscsilun->iscsi;
397
398 aio_context_acquire(iscsilun->aio_context);
399 iscsi_service(iscsi, POLLIN);
400 iscsi_set_events(iscsilun);
401 aio_context_release(iscsilun->aio_context);
402 }
403
404 static void
405 iscsi_process_write(void *arg)
406 {
407 IscsiLun *iscsilun = arg;
408 struct iscsi_context *iscsi = iscsilun->iscsi;
409
410 aio_context_acquire(iscsilun->aio_context);
411 iscsi_service(iscsi, POLLOUT);
412 iscsi_set_events(iscsilun);
413 aio_context_release(iscsilun->aio_context);
414 }
415
416 static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
417 {
418 return sector * iscsilun->block_size / BDRV_SECTOR_SIZE;
419 }
420
421 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
422 {
423 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
424 }
425
426 static bool is_byte_request_lun_aligned(int64_t offset, int count,
427 IscsiLun *iscsilun)
428 {
429 if (offset % iscsilun->block_size || count % iscsilun->block_size) {
430 error_report("iSCSI misaligned request: "
431 "iscsilun->block_size %u, offset %" PRIi64
432 ", count %d",
433 iscsilun->block_size, offset, count);
434 return false;
435 }
436 return true;
437 }
438
439 static bool is_sector_request_lun_aligned(int64_t sector_num, int nb_sectors,
440 IscsiLun *iscsilun)
441 {
442 assert(nb_sectors <= BDRV_REQUEST_MAX_SECTORS);
443 return is_byte_request_lun_aligned(sector_num << BDRV_SECTOR_BITS,
444 nb_sectors << BDRV_SECTOR_BITS,
445 iscsilun);
446 }
447
448 static void iscsi_allocmap_free(IscsiLun *iscsilun)
449 {
450 g_free(iscsilun->allocmap);
451 g_free(iscsilun->allocmap_valid);
452 iscsilun->allocmap = NULL;
453 iscsilun->allocmap_valid = NULL;
454 }
455
456
457 static int iscsi_allocmap_init(IscsiLun *iscsilun, int open_flags)
458 {
459 iscsi_allocmap_free(iscsilun);
460
461 iscsilun->allocmap_size =
462 DIV_ROUND_UP(sector_lun2qemu(iscsilun->num_blocks, iscsilun),
463 iscsilun->cluster_sectors);
464
465 iscsilun->allocmap = bitmap_try_new(iscsilun->allocmap_size);
466 if (!iscsilun->allocmap) {
467 return -ENOMEM;
468 }
469
470 if (open_flags & BDRV_O_NOCACHE) {
471 /* in case that cache.direct = on all allocmap entries are
472 * treated as invalid to force a relookup of the block
473 * status on every read request */
474 return 0;
475 }
476
477 iscsilun->allocmap_valid = bitmap_try_new(iscsilun->allocmap_size);
478 if (!iscsilun->allocmap_valid) {
479 /* if we are under memory pressure free the allocmap as well */
480 iscsi_allocmap_free(iscsilun);
481 return -ENOMEM;
482 }
483
484 return 0;
485 }
486
487 static void
488 iscsi_allocmap_update(IscsiLun *iscsilun, int64_t sector_num,
489 int nb_sectors, bool allocated, bool valid)
490 {
491 int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
492
493 if (iscsilun->allocmap == NULL) {
494 return;
495 }
496 /* expand to entirely contain all affected clusters */
497 cl_num_expanded = sector_num / iscsilun->cluster_sectors;
498 nb_cls_expanded = DIV_ROUND_UP(sector_num + nb_sectors,
499 iscsilun->cluster_sectors) - cl_num_expanded;
500 /* shrink to touch only completely contained clusters */
501 cl_num_shrunk = DIV_ROUND_UP(sector_num, iscsilun->cluster_sectors);
502 nb_cls_shrunk = (sector_num + nb_sectors) / iscsilun->cluster_sectors
503 - cl_num_shrunk;
504 if (allocated) {
505 bitmap_set(iscsilun->allocmap, cl_num_expanded, nb_cls_expanded);
506 } else {
507 if (nb_cls_shrunk > 0) {
508 bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk);
509 }
510 }
511
512 if (iscsilun->allocmap_valid == NULL) {
513 return;
514 }
515 if (valid) {
516 if (nb_cls_shrunk > 0) {
517 bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);
518 }
519 } else {
520 bitmap_clear(iscsilun->allocmap_valid, cl_num_expanded,
521 nb_cls_expanded);
522 }
523 }
524
525 static void
526 iscsi_allocmap_set_allocated(IscsiLun *iscsilun, int64_t sector_num,
527 int nb_sectors)
528 {
529 iscsi_allocmap_update(iscsilun, sector_num, nb_sectors, true, true);
530 }
531
532 static void
533 iscsi_allocmap_set_unallocated(IscsiLun *iscsilun, int64_t sector_num,
534 int nb_sectors)
535 {
536 /* Note: if cache.direct=on the fifth argument to iscsi_allocmap_update
537 * is ignored, so this will in effect be an iscsi_allocmap_set_invalid.
538 */
539 iscsi_allocmap_update(iscsilun, sector_num, nb_sectors, false, true);
540 }
541
542 static void iscsi_allocmap_set_invalid(IscsiLun *iscsilun, int64_t sector_num,
543 int nb_sectors)
544 {
545 iscsi_allocmap_update(iscsilun, sector_num, nb_sectors, false, false);
546 }
547
548 static void iscsi_allocmap_invalidate(IscsiLun *iscsilun)
549 {
550 if (iscsilun->allocmap) {
551 bitmap_zero(iscsilun->allocmap, iscsilun->allocmap_size);
552 }
553 if (iscsilun->allocmap_valid) {
554 bitmap_zero(iscsilun->allocmap_valid, iscsilun->allocmap_size);
555 }
556 }
557
558 static inline bool
559 iscsi_allocmap_is_allocated(IscsiLun *iscsilun, int64_t sector_num,
560 int nb_sectors)
561 {
562 unsigned long size;
563 if (iscsilun->allocmap == NULL) {
564 return true;
565 }
566 size = DIV_ROUND_UP(sector_num + nb_sectors, iscsilun->cluster_sectors);
567 return !(find_next_bit(iscsilun->allocmap, size,
568 sector_num / iscsilun->cluster_sectors) == size);
569 }
570
571 static inline bool iscsi_allocmap_is_valid(IscsiLun *iscsilun,
572 int64_t sector_num, int nb_sectors)
573 {
574 unsigned long size;
575 if (iscsilun->allocmap_valid == NULL) {
576 return false;
577 }
578 size = DIV_ROUND_UP(sector_num + nb_sectors, iscsilun->cluster_sectors);
579 return (find_next_zero_bit(iscsilun->allocmap_valid, size,
580 sector_num / iscsilun->cluster_sectors) == size);
581 }
582
583 static int coroutine_fn
584 iscsi_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
585 QEMUIOVector *iov, int flags)
586 {
587 IscsiLun *iscsilun = bs->opaque;
588 struct IscsiTask iTask;
589 uint64_t lba;
590 uint32_t num_sectors;
591 bool fua = flags & BDRV_REQ_FUA;
592
593 if (fua) {
594 assert(iscsilun->dpofua);
595 }
596 if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
597 return -EINVAL;
598 }
599
600 if (bs->bl.max_transfer) {
601 assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer);
602 }
603
604 lba = sector_qemu2lun(sector_num, iscsilun);
605 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
606 iscsi_co_init_iscsitask(iscsilun, &iTask);
607 retry:
608 if (iscsilun->use_16_for_rw) {
609 #if LIBISCSI_API_VERSION >= (20160603)
610 iTask.task = iscsi_write16_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
611 NULL, num_sectors * iscsilun->block_size,
612 iscsilun->block_size, 0, 0, fua, 0, 0,
613 iscsi_co_generic_cb, &iTask,
614 (struct scsi_iovec *)iov->iov, iov->niov);
615 } else {
616 iTask.task = iscsi_write10_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
617 NULL, num_sectors * iscsilun->block_size,
618 iscsilun->block_size, 0, 0, fua, 0, 0,
619 iscsi_co_generic_cb, &iTask,
620 (struct scsi_iovec *)iov->iov, iov->niov);
621 }
622 #else
623 iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,
624 NULL, num_sectors * iscsilun->block_size,
625 iscsilun->block_size, 0, 0, fua, 0, 0,
626 iscsi_co_generic_cb, &iTask);
627 } else {
628 iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba,
629 NULL, num_sectors * iscsilun->block_size,
630 iscsilun->block_size, 0, 0, fua, 0, 0,
631 iscsi_co_generic_cb, &iTask);
632 }
633 #endif
634 if (iTask.task == NULL) {
635 return -ENOMEM;
636 }
637 #if LIBISCSI_API_VERSION < (20160603)
638 scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,
639 iov->niov);
640 #endif
641 while (!iTask.complete) {
642 iscsi_set_events(iscsilun);
643 qemu_coroutine_yield();
644 }
645
646 if (iTask.task != NULL) {
647 scsi_free_scsi_task(iTask.task);
648 iTask.task = NULL;
649 }
650
651 if (iTask.do_retry) {
652 iTask.complete = 0;
653 goto retry;
654 }
655
656 if (iTask.status != SCSI_STATUS_GOOD) {
657 iscsi_allocmap_set_invalid(iscsilun, sector_num, nb_sectors);
658 return iTask.err_code;
659 }
660
661 iscsi_allocmap_set_allocated(iscsilun, sector_num, nb_sectors);
662
663 return 0;
664 }
665
666
667
668 static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs,
669 int64_t sector_num,
670 int nb_sectors, int *pnum,
671 BlockDriverState **file)
672 {
673 IscsiLun *iscsilun = bs->opaque;
674 struct scsi_get_lba_status *lbas = NULL;
675 struct scsi_lba_status_descriptor *lbasd = NULL;
676 struct IscsiTask iTask;
677 int64_t ret;
678
679 iscsi_co_init_iscsitask(iscsilun, &iTask);
680
681 if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
682 ret = -EINVAL;
683 goto out;
684 }
685
686 /* default to all sectors allocated */
687 ret = BDRV_BLOCK_DATA;
688 ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID;
689 *pnum = nb_sectors;
690
691 /* LUN does not support logical block provisioning */
692 if (!iscsilun->lbpme) {
693 goto out;
694 }
695
696 retry:
697 if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,
698 sector_qemu2lun(sector_num, iscsilun),
699 8 + 16, iscsi_co_generic_cb,
700 &iTask) == NULL) {
701 ret = -ENOMEM;
702 goto out;
703 }
704
705 while (!iTask.complete) {
706 iscsi_set_events(iscsilun);
707 qemu_coroutine_yield();
708 }
709
710 if (iTask.do_retry) {
711 if (iTask.task != NULL) {
712 scsi_free_scsi_task(iTask.task);
713 iTask.task = NULL;
714 }
715 iTask.complete = 0;
716 goto retry;
717 }
718
719 if (iTask.status != SCSI_STATUS_GOOD) {
720 /* in case the get_lba_status_callout fails (i.e.
721 * because the device is busy or the cmd is not
722 * supported) we pretend all blocks are allocated
723 * for backwards compatibility */
724 goto out;
725 }
726
727 lbas = scsi_datain_unmarshall(iTask.task);
728 if (lbas == NULL) {
729 ret = -EIO;
730 goto out;
731 }
732
733 lbasd = &lbas->descriptors[0];
734
735 if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) {
736 ret = -EIO;
737 goto out;
738 }
739
740 *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun);
741
742 if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED ||
743 lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) {
744 ret &= ~BDRV_BLOCK_DATA;
745 if (iscsilun->lbprz) {
746 ret |= BDRV_BLOCK_ZERO;
747 }
748 }
749
750 if (ret & BDRV_BLOCK_ZERO) {
751 iscsi_allocmap_set_unallocated(iscsilun, sector_num, *pnum);
752 } else {
753 iscsi_allocmap_set_allocated(iscsilun, sector_num, *pnum);
754 }
755
756 if (*pnum > nb_sectors) {
757 *pnum = nb_sectors;
758 }
759 out:
760 if (iTask.task != NULL) {
761 scsi_free_scsi_task(iTask.task);
762 }
763 if (ret > 0 && ret & BDRV_BLOCK_OFFSET_VALID) {
764 *file = bs;
765 }
766 return ret;
767 }
768
769 static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,
770 int64_t sector_num, int nb_sectors,
771 QEMUIOVector *iov)
772 {
773 IscsiLun *iscsilun = bs->opaque;
774 struct IscsiTask iTask;
775 uint64_t lba;
776 uint32_t num_sectors;
777
778 if (!is_sector_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
779 return -EINVAL;
780 }
781
782 if (bs->bl.max_transfer) {
783 assert(nb_sectors << BDRV_SECTOR_BITS <= bs->bl.max_transfer);
784 }
785
786 /* if cache.direct is off and we have a valid entry in our allocation map
787 * we can skip checking the block status and directly return zeroes if
788 * the request falls within an unallocated area */
789 if (iscsi_allocmap_is_valid(iscsilun, sector_num, nb_sectors) &&
790 !iscsi_allocmap_is_allocated(iscsilun, sector_num, nb_sectors)) {
791 qemu_iovec_memset(iov, 0, 0x00, iov->size);
792 return 0;
793 }
794
795 if (nb_sectors >= ISCSI_CHECKALLOC_THRES &&
796 !iscsi_allocmap_is_valid(iscsilun, sector_num, nb_sectors) &&
797 !iscsi_allocmap_is_allocated(iscsilun, sector_num, nb_sectors)) {
798 int pnum;
799 BlockDriverState *file;
800 /* check the block status from the beginning of the cluster
801 * containing the start sector */
802 int64_t ret = iscsi_co_get_block_status(bs,
803 sector_num - sector_num % iscsilun->cluster_sectors,
804 BDRV_REQUEST_MAX_SECTORS, &pnum, &file);
805 if (ret < 0) {
806 return ret;
807 }
808 /* if the whole request falls into an unallocated area we can avoid
809 * to read and directly return zeroes instead */
810 if (ret & BDRV_BLOCK_ZERO &&
811 pnum >= nb_sectors + sector_num % iscsilun->cluster_sectors) {
812 qemu_iovec_memset(iov, 0, 0x00, iov->size);
813 return 0;
814 }
815 }
816
817 lba = sector_qemu2lun(sector_num, iscsilun);
818 num_sectors = sector_qemu2lun(nb_sectors, iscsilun);
819
820 iscsi_co_init_iscsitask(iscsilun, &iTask);
821 retry:
822 if (iscsilun->use_16_for_rw) {
823 #if LIBISCSI_API_VERSION >= (20160603)
824 iTask.task = iscsi_read16_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
825 num_sectors * iscsilun->block_size,
826 iscsilun->block_size, 0, 0, 0, 0, 0,
827 iscsi_co_generic_cb, &iTask,
828 (struct scsi_iovec *)iov->iov, iov->niov);
829 } else {
830 iTask.task = iscsi_read10_iov_task(iscsilun->iscsi, iscsilun->lun, lba,
831 num_sectors * iscsilun->block_size,
832 iscsilun->block_size,
833 0, 0, 0, 0, 0,
834 iscsi_co_generic_cb, &iTask,
835 (struct scsi_iovec *)iov->iov, iov->niov);
836 }
837 #else
838 iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba,
839 num_sectors * iscsilun->block_size,
840 iscsilun->block_size, 0, 0, 0, 0, 0,
841 iscsi_co_generic_cb, &iTask);
842 } else {
843 iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,
844 num_sectors * iscsilun->block_size,
845 iscsilun->block_size,
846 0, 0, 0, 0, 0,
847 iscsi_co_generic_cb, &iTask);
848 }
849 #endif
850 if (iTask.task == NULL) {
851 return -ENOMEM;
852 }
853 #if LIBISCSI_API_VERSION < (20160603)
854 scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);
855 #endif
856 while (!iTask.complete) {
857 iscsi_set_events(iscsilun);
858 qemu_coroutine_yield();
859 }
860
861 if (iTask.task != NULL) {
862 scsi_free_scsi_task(iTask.task);
863 iTask.task = NULL;
864 }
865
866 if (iTask.do_retry) {
867 iTask.complete = 0;
868 goto retry;
869 }
870
871 if (iTask.status != SCSI_STATUS_GOOD) {
872 return iTask.err_code;
873 }
874
875 return 0;
876 }
877
878 static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)
879 {
880 IscsiLun *iscsilun = bs->opaque;
881 struct IscsiTask iTask;
882
883 iscsi_co_init_iscsitask(iscsilun, &iTask);
884 retry:
885 if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,
886 0, iscsi_co_generic_cb, &iTask) == NULL) {
887 return -ENOMEM;
888 }
889
890 while (!iTask.complete) {
891 iscsi_set_events(iscsilun);
892 qemu_coroutine_yield();
893 }
894
895 if (iTask.task != NULL) {
896 scsi_free_scsi_task(iTask.task);
897 iTask.task = NULL;
898 }
899
900 if (iTask.do_retry) {
901 iTask.complete = 0;
902 goto retry;
903 }
904
905 if (iTask.status != SCSI_STATUS_GOOD) {
906 return iTask.err_code;
907 }
908
909 return 0;
910 }
911
912 #ifdef __linux__
913 static void
914 iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
915 void *command_data, void *opaque)
916 {
917 IscsiAIOCB *acb = opaque;
918
919 g_free(acb->buf);
920 acb->buf = NULL;
921
922 acb->status = 0;
923 if (status < 0) {
924 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
925 iscsi_get_error(iscsi));
926 acb->status = iscsi_translate_sense(&acb->task->sense);
927 }
928
929 acb->ioh->driver_status = 0;
930 acb->ioh->host_status = 0;
931 acb->ioh->resid = 0;
932 acb->ioh->status = status;
933
934 #define SG_ERR_DRIVER_SENSE 0x08
935
936 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
937 int ss;
938
939 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
940
941 acb->ioh->sb_len_wr = acb->task->datain.size - 2;
942 ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?
943 acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;
944 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
945 }
946
947 iscsi_schedule_bh(acb);
948 }
949
950 static void iscsi_ioctl_bh_completion(void *opaque)
951 {
952 IscsiAIOCB *acb = opaque;
953
954 qemu_bh_delete(acb->bh);
955 acb->common.cb(acb->common.opaque, acb->ret);
956 qemu_aio_unref(acb);
957 }
958
959 static void iscsi_ioctl_handle_emulated(IscsiAIOCB *acb, int req, void *buf)
960 {
961 BlockDriverState *bs = acb->common.bs;
962 IscsiLun *iscsilun = bs->opaque;
963 int ret = 0;
964
965 switch (req) {
966 case SG_GET_VERSION_NUM:
967 *(int *)buf = 30000;
968 break;
969 case SG_GET_SCSI_ID:
970 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
971 break;
972 default:
973 ret = -EINVAL;
974 }
975 assert(!acb->bh);
976 acb->bh = aio_bh_new(bdrv_get_aio_context(bs),
977 iscsi_ioctl_bh_completion, acb);
978 acb->ret = ret;
979 qemu_bh_schedule(acb->bh);
980 }
981
982 static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
983 unsigned long int req, void *buf,
984 BlockCompletionFunc *cb, void *opaque)
985 {
986 IscsiLun *iscsilun = bs->opaque;
987 struct iscsi_context *iscsi = iscsilun->iscsi;
988 struct iscsi_data data;
989 IscsiAIOCB *acb;
990
991 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
992
993 acb->iscsilun = iscsilun;
994 acb->bh = NULL;
995 acb->status = -EINPROGRESS;
996 acb->buf = NULL;
997 acb->ioh = buf;
998
999 if (req != SG_IO) {
1000 iscsi_ioctl_handle_emulated(acb, req, buf);
1001 return &acb->common;
1002 }
1003
1004 if (acb->ioh->cmd_len > SCSI_CDB_MAX_SIZE) {
1005 error_report("iSCSI: ioctl error CDB exceeds max size (%d > %d)",
1006 acb->ioh->cmd_len, SCSI_CDB_MAX_SIZE);
1007 qemu_aio_unref(acb);
1008 return NULL;
1009 }
1010
1011 acb->task = malloc(sizeof(struct scsi_task));
1012 if (acb->task == NULL) {
1013 error_report("iSCSI: Failed to allocate task for scsi command. %s",
1014 iscsi_get_error(iscsi));
1015 qemu_aio_unref(acb);
1016 return NULL;
1017 }
1018 memset(acb->task, 0, sizeof(struct scsi_task));
1019
1020 switch (acb->ioh->dxfer_direction) {
1021 case SG_DXFER_TO_DEV:
1022 acb->task->xfer_dir = SCSI_XFER_WRITE;
1023 break;
1024 case SG_DXFER_FROM_DEV:
1025 acb->task->xfer_dir = SCSI_XFER_READ;
1026 break;
1027 default:
1028 acb->task->xfer_dir = SCSI_XFER_NONE;
1029 break;
1030 }
1031
1032 acb->task->cdb_size = acb->ioh->cmd_len;
1033 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
1034 acb->task->expxferlen = acb->ioh->dxfer_len;
1035
1036 data.size = 0;
1037 if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
1038 if (acb->ioh->iovec_count == 0) {
1039 data.data = acb->ioh->dxferp;
1040 data.size = acb->ioh->dxfer_len;
1041 } else {
1042 scsi_task_set_iov_out(acb->task,
1043 (struct scsi_iovec *) acb->ioh->dxferp,
1044 acb->ioh->iovec_count);
1045 }
1046 }
1047
1048 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
1049 iscsi_aio_ioctl_cb,
1050 (data.size > 0) ? &data : NULL,
1051 acb) != 0) {
1052 scsi_free_scsi_task(acb->task);
1053 qemu_aio_unref(acb);
1054 return NULL;
1055 }
1056
1057 /* tell libiscsi to read straight into the buffer we got from ioctl */
1058 if (acb->task->xfer_dir == SCSI_XFER_READ) {
1059 if (acb->ioh->iovec_count == 0) {
1060 scsi_task_add_data_in_buffer(acb->task,
1061 acb->ioh->dxfer_len,
1062 acb->ioh->dxferp);
1063 } else {
1064 scsi_task_set_iov_in(acb->task,
1065 (struct scsi_iovec *) acb->ioh->dxferp,
1066 acb->ioh->iovec_count);
1067 }
1068 }
1069
1070 iscsi_set_events(iscsilun);
1071
1072 return &acb->common;
1073 }
1074
1075 #endif
1076
1077 static int64_t
1078 iscsi_getlength(BlockDriverState *bs)
1079 {
1080 IscsiLun *iscsilun = bs->opaque;
1081 int64_t len;
1082
1083 len = iscsilun->num_blocks;
1084 len *= iscsilun->block_size;
1085
1086 return len;
1087 }
1088
1089 static int
1090 coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
1091 {
1092 IscsiLun *iscsilun = bs->opaque;
1093 struct IscsiTask iTask;
1094 struct unmap_list list;
1095
1096 if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {
1097 return -ENOTSUP;
1098 }
1099
1100 if (!iscsilun->lbp.lbpu) {
1101 /* UNMAP is not supported by the target */
1102 return 0;
1103 }
1104
1105 list.lba = offset / iscsilun->block_size;
1106 list.num = count / iscsilun->block_size;
1107
1108 iscsi_co_init_iscsitask(iscsilun, &iTask);
1109 retry:
1110 if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
1111 iscsi_co_generic_cb, &iTask) == NULL) {
1112 return -ENOMEM;
1113 }
1114
1115 while (!iTask.complete) {
1116 iscsi_set_events(iscsilun);
1117 qemu_coroutine_yield();
1118 }
1119
1120 if (iTask.task != NULL) {
1121 scsi_free_scsi_task(iTask.task);
1122 iTask.task = NULL;
1123 }
1124
1125 if (iTask.do_retry) {
1126 iTask.complete = 0;
1127 goto retry;
1128 }
1129
1130 if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
1131 /* the target might fail with a check condition if it
1132 is not happy with the alignment of the UNMAP request
1133 we silently fail in this case */
1134 return 0;
1135 }
1136
1137 if (iTask.status != SCSI_STATUS_GOOD) {
1138 return iTask.err_code;
1139 }
1140
1141 iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
1142 count >> BDRV_SECTOR_BITS);
1143
1144 return 0;
1145 }
1146
1147 static int
1148 coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
1149 int count, BdrvRequestFlags flags)
1150 {
1151 IscsiLun *iscsilun = bs->opaque;
1152 struct IscsiTask iTask;
1153 uint64_t lba;
1154 uint32_t nb_blocks;
1155 bool use_16_for_ws = iscsilun->use_16_for_rw;
1156
1157 if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {
1158 return -ENOTSUP;
1159 }
1160
1161 if (flags & BDRV_REQ_MAY_UNMAP) {
1162 if (!use_16_for_ws && !iscsilun->lbp.lbpws10) {
1163 /* WRITESAME10 with UNMAP is unsupported try WRITESAME16 */
1164 use_16_for_ws = true;
1165 }
1166 if (use_16_for_ws && !iscsilun->lbp.lbpws) {
1167 /* WRITESAME16 with UNMAP is not supported by the target,
1168 * fall back and try WRITESAME10/16 without UNMAP */
1169 flags &= ~BDRV_REQ_MAY_UNMAP;
1170 use_16_for_ws = iscsilun->use_16_for_rw;
1171 }
1172 }
1173
1174 if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
1175 /* WRITESAME without UNMAP is not supported by the target */
1176 return -ENOTSUP;
1177 }
1178
1179 lba = offset / iscsilun->block_size;
1180 nb_blocks = count / iscsilun->block_size;
1181
1182 if (iscsilun->zeroblock == NULL) {
1183 iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size);
1184 if (iscsilun->zeroblock == NULL) {
1185 return -ENOMEM;
1186 }
1187 }
1188
1189 iscsi_co_init_iscsitask(iscsilun, &iTask);
1190 retry:
1191 if (use_16_for_ws) {
1192 iTask.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
1193 iscsilun->zeroblock, iscsilun->block_size,
1194 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1195 0, 0, iscsi_co_generic_cb, &iTask);
1196 } else {
1197 iTask.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba,
1198 iscsilun->zeroblock, iscsilun->block_size,
1199 nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
1200 0, 0, iscsi_co_generic_cb, &iTask);
1201 }
1202 if (iTask.task == NULL) {
1203 return -ENOMEM;
1204 }
1205
1206 while (!iTask.complete) {
1207 iscsi_set_events(iscsilun);
1208 qemu_coroutine_yield();
1209 }
1210
1211 if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
1212 iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
1213 (iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE ||
1214 iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) {
1215 /* WRITE SAME is not supported by the target */
1216 iscsilun->has_write_same = false;
1217 scsi_free_scsi_task(iTask.task);
1218 return -ENOTSUP;
1219 }
1220
1221 if (iTask.task != NULL) {
1222 scsi_free_scsi_task(iTask.task);
1223 iTask.task = NULL;
1224 }
1225
1226 if (iTask.do_retry) {
1227 iTask.complete = 0;
1228 goto retry;
1229 }
1230
1231 if (iTask.status != SCSI_STATUS_GOOD) {
1232 iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
1233 count >> BDRV_SECTOR_BITS);
1234 return iTask.err_code;
1235 }
1236
1237 if (flags & BDRV_REQ_MAY_UNMAP) {
1238 iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
1239 count >> BDRV_SECTOR_BITS);
1240 } else {
1241 iscsi_allocmap_set_allocated(iscsilun, offset >> BDRV_SECTOR_BITS,
1242 count >> BDRV_SECTOR_BITS);
1243 }
1244
1245 return 0;
1246 }
1247
1248 static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
1249 Error **errp)
1250 {
1251 const char *user = NULL;
1252 const char *password = NULL;
1253 const char *secretid;
1254 char *secret = NULL;
1255
1256 user = qemu_opt_get(opts, "user");
1257 if (!user) {
1258 return;
1259 }
1260
1261 secretid = qemu_opt_get(opts, "password-secret");
1262 password = qemu_opt_get(opts, "password");
1263 if (secretid && password) {
1264 error_setg(errp, "'password' and 'password-secret' properties are "
1265 "mutually exclusive");
1266 return;
1267 }
1268 if (secretid) {
1269 secret = qcrypto_secret_lookup_as_utf8(secretid, errp);
1270 if (!secret) {
1271 return;
1272 }
1273 password = secret;
1274 } else if (!password) {
1275 error_setg(errp, "CHAP username specified but no password was given");
1276 return;
1277 }
1278
1279 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
1280 error_setg(errp, "Failed to set initiator username and password");
1281 }
1282
1283 g_free(secret);
1284 }
1285
1286 static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
1287 Error **errp)
1288 {
1289 const char *digest = NULL;
1290
1291 digest = qemu_opt_get(opts, "header-digest");
1292 if (!digest) {
1293 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1294 } else if (!strcmp(digest, "crc32c")) {
1295 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
1296 } else if (!strcmp(digest, "none")) {
1297 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
1298 } else if (!strcmp(digest, "crc32c-none")) {
1299 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
1300 } else if (!strcmp(digest, "none-crc32c")) {
1301 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1302 } else {
1303 error_setg(errp, "Invalid header-digest setting : %s", digest);
1304 }
1305 }
1306
1307 static char *get_initiator_name(QemuOpts *opts)
1308 {
1309 const char *name;
1310 char *iscsi_name;
1311 UuidInfo *uuid_info;
1312
1313 name = qemu_opt_get(opts, "initiator-name");
1314 if (name) {
1315 return g_strdup(name);
1316 }
1317
1318 uuid_info = qmp_query_uuid(NULL);
1319 if (strcmp(uuid_info->UUID, UUID_NONE) == 0) {
1320 name = qemu_get_vm_name();
1321 } else {
1322 name = uuid_info->UUID;
1323 }
1324 iscsi_name = g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
1325 name ? ":" : "", name ? name : "");
1326 qapi_free_UuidInfo(uuid_info);
1327 return iscsi_name;
1328 }
1329
1330 static void iscsi_nop_timed_event(void *opaque)
1331 {
1332 IscsiLun *iscsilun = opaque;
1333
1334 aio_context_acquire(iscsilun->aio_context);
1335 if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
1336 error_report("iSCSI: NOP timeout. Reconnecting...");
1337 iscsilun->request_timed_out = true;
1338 } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
1339 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
1340 goto out;
1341 }
1342
1343 timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1344 iscsi_set_events(iscsilun);
1345
1346 out:
1347 aio_context_release(iscsilun->aio_context);
1348 }
1349
1350 static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
1351 {
1352 struct scsi_task *task = NULL;
1353 struct scsi_readcapacity10 *rc10 = NULL;
1354 struct scsi_readcapacity16 *rc16 = NULL;
1355 int retries = ISCSI_CMD_RETRIES;
1356
1357 do {
1358 if (task != NULL) {
1359 scsi_free_scsi_task(task);
1360 task = NULL;
1361 }
1362
1363 switch (iscsilun->type) {
1364 case TYPE_DISK:
1365 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun);
1366 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1367 rc16 = scsi_datain_unmarshall(task);
1368 if (rc16 == NULL) {
1369 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity16 data.");
1370 } else {
1371 iscsilun->block_size = rc16->block_length;
1372 iscsilun->num_blocks = rc16->returned_lba + 1;
1373 iscsilun->lbpme = !!rc16->lbpme;
1374 iscsilun->lbprz = !!rc16->lbprz;
1375 iscsilun->use_16_for_rw = (rc16->returned_lba > 0xffffffff);
1376 }
1377 break;
1378 }
1379 if (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1380 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {
1381 break;
1382 }
1383 /* Fall through and try READ CAPACITY(10) instead. */
1384 case TYPE_ROM:
1385 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0);
1386 if (task != NULL && task->status == SCSI_STATUS_GOOD) {
1387 rc10 = scsi_datain_unmarshall(task);
1388 if (rc10 == NULL) {
1389 error_setg(errp, "iSCSI: Failed to unmarshall readcapacity10 data.");
1390 } else {
1391 iscsilun->block_size = rc10->block_size;
1392 if (rc10->lba == 0) {
1393 /* blank disk loaded */
1394 iscsilun->num_blocks = 0;
1395 } else {
1396 iscsilun->num_blocks = rc10->lba + 1;
1397 }
1398 }
1399 }
1400 break;
1401 default:
1402 return;
1403 }
1404 } while (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
1405 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION
1406 && retries-- > 0);
1407
1408 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1409 error_setg(errp, "iSCSI: failed to send readcapacity10/16 command");
1410 } else if (!iscsilun->block_size ||
1411 iscsilun->block_size % BDRV_SECTOR_SIZE) {
1412 error_setg(errp, "iSCSI: the target returned an invalid "
1413 "block size of %d.", iscsilun->block_size);
1414 }
1415 if (task) {
1416 scsi_free_scsi_task(task);
1417 }
1418 }
1419
1420 static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
1421 int evpd, int pc, void **inq, Error **errp)
1422 {
1423 int full_size;
1424 struct scsi_task *task = NULL;
1425 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
1426 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1427 goto fail;
1428 }
1429 full_size = scsi_datain_getfullsize(task);
1430 if (full_size > task->datain.size) {
1431 scsi_free_scsi_task(task);
1432
1433 /* we need more data for the full list */
1434 task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size);
1435 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1436 goto fail;
1437 }
1438 }
1439
1440 *inq = scsi_datain_unmarshall(task);
1441 if (*inq == NULL) {
1442 error_setg(errp, "iSCSI: failed to unmarshall inquiry datain blob");
1443 goto fail_with_err;
1444 }
1445
1446 return task;
1447
1448 fail:
1449 error_setg(errp, "iSCSI: Inquiry command failed : %s",
1450 iscsi_get_error(iscsi));
1451 fail_with_err:
1452 if (task != NULL) {
1453 scsi_free_scsi_task(task);
1454 }
1455 return NULL;
1456 }
1457
1458 static void iscsi_detach_aio_context(BlockDriverState *bs)
1459 {
1460 IscsiLun *iscsilun = bs->opaque;
1461
1462 aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
1463 false, NULL, NULL, NULL, NULL);
1464 iscsilun->events = 0;
1465
1466 if (iscsilun->nop_timer) {
1467 timer_del(iscsilun->nop_timer);
1468 timer_free(iscsilun->nop_timer);
1469 iscsilun->nop_timer = NULL;
1470 }
1471 if (iscsilun->event_timer) {
1472 timer_del(iscsilun->event_timer);
1473 timer_free(iscsilun->event_timer);
1474 iscsilun->event_timer = NULL;
1475 }
1476 }
1477
1478 static void iscsi_attach_aio_context(BlockDriverState *bs,
1479 AioContext *new_context)
1480 {
1481 IscsiLun *iscsilun = bs->opaque;
1482
1483 iscsilun->aio_context = new_context;
1484 iscsi_set_events(iscsilun);
1485
1486 /* Set up a timer for sending out iSCSI NOPs */
1487 iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
1488 QEMU_CLOCK_REALTIME, SCALE_MS,
1489 iscsi_nop_timed_event, iscsilun);
1490 timer_mod(iscsilun->nop_timer,
1491 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
1492
1493 /* Set up a timer for periodic calls to iscsi_set_events and to
1494 * scan for command timeout */
1495 iscsilun->event_timer = aio_timer_new(iscsilun->aio_context,
1496 QEMU_CLOCK_REALTIME, SCALE_MS,
1497 iscsi_timed_check_events, iscsilun);
1498 timer_mod(iscsilun->event_timer,
1499 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL);
1500 }
1501
1502 static void iscsi_modesense_sync(IscsiLun *iscsilun)
1503 {
1504 struct scsi_task *task;
1505 struct scsi_mode_sense *ms = NULL;
1506 iscsilun->write_protected = false;
1507 iscsilun->dpofua = false;
1508
1509 task = iscsi_modesense6_sync(iscsilun->iscsi, iscsilun->lun,
1510 1, SCSI_MODESENSE_PC_CURRENT,
1511 0x3F, 0, 255);
1512 if (task == NULL) {
1513 error_report("iSCSI: Failed to send MODE_SENSE(6) command: %s",
1514 iscsi_get_error(iscsilun->iscsi));
1515 goto out;
1516 }
1517
1518 if (task->status != SCSI_STATUS_GOOD) {
1519 error_report("iSCSI: Failed MODE_SENSE(6), LUN assumed writable");
1520 goto out;
1521 }
1522 ms = scsi_datain_unmarshall(task);
1523 if (!ms) {
1524 error_report("iSCSI: Failed to unmarshall MODE_SENSE(6) data: %s",
1525 iscsi_get_error(iscsilun->iscsi));
1526 goto out;
1527 }
1528 iscsilun->write_protected = ms->device_specific_parameter & 0x80;
1529 iscsilun->dpofua = ms->device_specific_parameter & 0x10;
1530
1531 out:
1532 if (task) {
1533 scsi_free_scsi_task(task);
1534 }
1535 }
1536
1537 static void iscsi_parse_iscsi_option(const char *target, QDict *options)
1538 {
1539 QemuOptsList *list;
1540 QemuOpts *opts;
1541 const char *user, *password, *password_secret, *initiator_name,
1542 *header_digest, *timeout;
1543
1544 list = qemu_find_opts("iscsi");
1545 if (!list) {
1546 return;
1547 }
1548
1549 opts = qemu_opts_find(list, target);
1550 if (opts == NULL) {
1551 opts = QTAILQ_FIRST(&list->head);
1552 if (!opts) {
1553 return;
1554 }
1555 }
1556
1557 user = qemu_opt_get(opts, "user");
1558 if (user) {
1559 qdict_set_default_str(options, "user", user);
1560 }
1561
1562 password = qemu_opt_get(opts, "password");
1563 if (password) {
1564 qdict_set_default_str(options, "password", password);
1565 }
1566
1567 password_secret = qemu_opt_get(opts, "password-secret");
1568 if (password_secret) {
1569 qdict_set_default_str(options, "password-secret", password_secret);
1570 }
1571
1572 initiator_name = qemu_opt_get(opts, "initiator-name");
1573 if (initiator_name) {
1574 qdict_set_default_str(options, "initiator-name", initiator_name);
1575 }
1576
1577 header_digest = qemu_opt_get(opts, "header-digest");
1578 if (header_digest) {
1579 /* -iscsi takes upper case values, but QAPI only supports lower case
1580 * enum constant names, so we have to convert here. */
1581 char *qapi_value = g_ascii_strdown(header_digest, -1);
1582 qdict_set_default_str(options, "header-digest", qapi_value);
1583 g_free(qapi_value);
1584 }
1585
1586 timeout = qemu_opt_get(opts, "timeout");
1587 if (timeout) {
1588 qdict_set_default_str(options, "timeout", timeout);
1589 }
1590 }
1591
1592 /*
1593 * We support iscsi url's on the form
1594 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1595 */
1596 static void iscsi_parse_filename(const char *filename, QDict *options,
1597 Error **errp)
1598 {
1599 struct iscsi_url *iscsi_url;
1600 const char *transport_name;
1601 char *lun_str;
1602
1603 iscsi_url = iscsi_parse_full_url(NULL, filename);
1604 if (iscsi_url == NULL) {
1605 error_setg(errp, "Failed to parse URL : %s", filename);
1606 return;
1607 }
1608
1609 #if LIBISCSI_API_VERSION >= (20160603)
1610 switch (iscsi_url->transport) {
1611 case TCP_TRANSPORT:
1612 transport_name = "tcp";
1613 break;
1614 case ISER_TRANSPORT:
1615 transport_name = "iser";
1616 break;
1617 default:
1618 error_setg(errp, "Unknown transport type (%d)",
1619 iscsi_url->transport);
1620 return;
1621 }
1622 #else
1623 transport_name = "tcp";
1624 #endif
1625
1626 qdict_set_default_str(options, "transport", transport_name);
1627 qdict_set_default_str(options, "portal", iscsi_url->portal);
1628 qdict_set_default_str(options, "target", iscsi_url->target);
1629
1630 lun_str = g_strdup_printf("%d", iscsi_url->lun);
1631 qdict_set_default_str(options, "lun", lun_str);
1632 g_free(lun_str);
1633
1634 /* User/password from -iscsi take precedence over those from the URL */
1635 iscsi_parse_iscsi_option(iscsi_url->target, options);
1636
1637 if (iscsi_url->user[0] != '\0') {
1638 qdict_set_default_str(options, "user", iscsi_url->user);
1639 qdict_set_default_str(options, "password", iscsi_url->passwd);
1640 }
1641
1642 iscsi_destroy_url(iscsi_url);
1643 }
1644
1645 static QemuOptsList runtime_opts = {
1646 .name = "iscsi",
1647 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1648 .desc = {
1649 {
1650 .name = "transport",
1651 .type = QEMU_OPT_STRING,
1652 },
1653 {
1654 .name = "portal",
1655 .type = QEMU_OPT_STRING,
1656 },
1657 {
1658 .name = "target",
1659 .type = QEMU_OPT_STRING,
1660 },
1661 {
1662 .name = "user",
1663 .type = QEMU_OPT_STRING,
1664 },
1665 {
1666 .name = "password",
1667 .type = QEMU_OPT_STRING,
1668 },
1669 {
1670 .name = "password-secret",
1671 .type = QEMU_OPT_STRING,
1672 },
1673 {
1674 .name = "lun",
1675 .type = QEMU_OPT_NUMBER,
1676 },
1677 {
1678 .name = "initiator-name",
1679 .type = QEMU_OPT_STRING,
1680 },
1681 {
1682 .name = "header-digest",
1683 .type = QEMU_OPT_STRING,
1684 },
1685 {
1686 .name = "timeout",
1687 .type = QEMU_OPT_NUMBER,
1688 },
1689 { /* end of list */ }
1690 },
1691 };
1692
1693 static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
1694 Error **errp)
1695 {
1696 IscsiLun *iscsilun = bs->opaque;
1697 struct iscsi_context *iscsi = NULL;
1698 struct scsi_task *task = NULL;
1699 struct scsi_inquiry_standard *inq = NULL;
1700 struct scsi_inquiry_supported_pages *inq_vpd;
1701 char *initiator_name = NULL;
1702 QemuOpts *opts;
1703 Error *local_err = NULL;
1704 const char *transport_name, *portal, *target;
1705 #if LIBISCSI_API_VERSION >= (20160603)
1706 enum iscsi_transport_type transport;
1707 #endif
1708 int i, ret = 0, timeout = 0, lun;
1709
1710 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1711 qemu_opts_absorb_qdict(opts, options, &local_err);
1712 if (local_err) {
1713 error_propagate(errp, local_err);
1714 ret = -EINVAL;
1715 goto out;
1716 }
1717
1718 transport_name = qemu_opt_get(opts, "transport");
1719 portal = qemu_opt_get(opts, "portal");
1720 target = qemu_opt_get(opts, "target");
1721 lun = qemu_opt_get_number(opts, "lun", 0);
1722
1723 if (!transport_name || !portal || !target) {
1724 error_setg(errp, "Need all of transport, portal and target options");
1725 ret = -EINVAL;
1726 goto out;
1727 }
1728
1729 if (!strcmp(transport_name, "tcp")) {
1730 #if LIBISCSI_API_VERSION >= (20160603)
1731 transport = TCP_TRANSPORT;
1732 } else if (!strcmp(transport_name, "iser")) {
1733 transport = ISER_TRANSPORT;
1734 #else
1735 /* TCP is what older libiscsi versions always use */
1736 #endif
1737 } else {
1738 error_setg(errp, "Unknown transport: %s", transport_name);
1739 ret = -EINVAL;
1740 goto out;
1741 }
1742
1743 memset(iscsilun, 0, sizeof(IscsiLun));
1744
1745 initiator_name = get_initiator_name(opts);
1746
1747 iscsi = iscsi_create_context(initiator_name);
1748 if (iscsi == NULL) {
1749 error_setg(errp, "iSCSI: Failed to create iSCSI context.");
1750 ret = -ENOMEM;
1751 goto out;
1752 }
1753 #if LIBISCSI_API_VERSION >= (20160603)
1754 if (iscsi_init_transport(iscsi, transport)) {
1755 error_setg(errp, ("Error initializing transport."));
1756 ret = -EINVAL;
1757 goto out;
1758 }
1759 #endif
1760 if (iscsi_set_targetname(iscsi, target)) {
1761 error_setg(errp, "iSCSI: Failed to set target name.");
1762 ret = -EINVAL;
1763 goto out;
1764 }
1765
1766 /* check if we got CHAP username/password via the options */
1767 apply_chap(iscsi, opts, &local_err);
1768 if (local_err != NULL) {
1769 error_propagate(errp, local_err);
1770 ret = -EINVAL;
1771 goto out;
1772 }
1773
1774 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
1775 error_setg(errp, "iSCSI: Failed to set session type to normal.");
1776 ret = -EINVAL;
1777 goto out;
1778 }
1779
1780 /* check if we got HEADER_DIGEST via the options */
1781 apply_header_digest(iscsi, opts, &local_err);
1782 if (local_err != NULL) {
1783 error_propagate(errp, local_err);
1784 ret = -EINVAL;
1785 goto out;
1786 }
1787
1788 /* timeout handling is broken in libiscsi before 1.15.0 */
1789 timeout = qemu_opt_get_number(opts, "timeout", 0);
1790 #if LIBISCSI_API_VERSION >= 20150621
1791 iscsi_set_timeout(iscsi, timeout);
1792 #else
1793 if (timeout) {
1794 error_report("iSCSI: ignoring timeout value for libiscsi <1.15.0");
1795 }
1796 #endif
1797
1798 if (iscsi_full_connect_sync(iscsi, portal, lun) != 0) {
1799 error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
1800 iscsi_get_error(iscsi));
1801 ret = -EINVAL;
1802 goto out;
1803 }
1804
1805 iscsilun->iscsi = iscsi;
1806 iscsilun->aio_context = bdrv_get_aio_context(bs);
1807 iscsilun->lun = lun;
1808 iscsilun->has_write_same = true;
1809
1810 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
1811 (void **) &inq, errp);
1812 if (task == NULL) {
1813 ret = -EINVAL;
1814 goto out;
1815 }
1816 iscsilun->type = inq->periperal_device_type;
1817 scsi_free_scsi_task(task);
1818 task = NULL;
1819
1820 iscsi_modesense_sync(iscsilun);
1821 if (iscsilun->dpofua) {
1822 bs->supported_write_flags = BDRV_REQ_FUA;
1823 }
1824 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP;
1825
1826 /* Check the write protect flag of the LUN if we want to write */
1827 if (iscsilun->type == TYPE_DISK && (flags & BDRV_O_RDWR) &&
1828 iscsilun->write_protected) {
1829 error_setg(errp, "Cannot open a write protected LUN as read-write");
1830 ret = -EACCES;
1831 goto out;
1832 }
1833
1834 iscsi_readcapacity_sync(iscsilun, &local_err);
1835 if (local_err != NULL) {
1836 error_propagate(errp, local_err);
1837 ret = -EINVAL;
1838 goto out;
1839 }
1840 bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun);
1841
1842 /* We don't have any emulation for devices other than disks and CD-ROMs, so
1843 * this must be sg ioctl compatible. We force it to be sg, otherwise qemu
1844 * will try to read from the device to guess the image format.
1845 */
1846 if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) {
1847 bs->sg = true;
1848 }
1849
1850 task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1851 SCSI_INQUIRY_PAGECODE_SUPPORTED_VPD_PAGES,
1852 (void **) &inq_vpd, errp);
1853 if (task == NULL) {
1854 ret = -EINVAL;
1855 goto out;
1856 }
1857 for (i = 0; i < inq_vpd->num_pages; i++) {
1858 struct scsi_task *inq_task;
1859 struct scsi_inquiry_logical_block_provisioning *inq_lbp;
1860 struct scsi_inquiry_block_limits *inq_bl;
1861 switch (inq_vpd->pages[i]) {
1862 case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
1863 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1864 SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING,
1865 (void **) &inq_lbp, errp);
1866 if (inq_task == NULL) {
1867 ret = -EINVAL;
1868 goto out;
1869 }
1870 memcpy(&iscsilun->lbp, inq_lbp,
1871 sizeof(struct scsi_inquiry_logical_block_provisioning));
1872 scsi_free_scsi_task(inq_task);
1873 break;
1874 case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
1875 inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
1876 SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS,
1877 (void **) &inq_bl, errp);
1878 if (inq_task == NULL) {
1879 ret = -EINVAL;
1880 goto out;
1881 }
1882 memcpy(&iscsilun->bl, inq_bl,
1883 sizeof(struct scsi_inquiry_block_limits));
1884 scsi_free_scsi_task(inq_task);
1885 break;
1886 default:
1887 break;
1888 }
1889 }
1890 scsi_free_scsi_task(task);
1891 task = NULL;
1892
1893 iscsi_attach_aio_context(bs, iscsilun->aio_context);
1894
1895 /* Guess the internal cluster (page) size of the iscsi target by the means
1896 * of opt_unmap_gran. Transfer the unmap granularity only if it has a
1897 * reasonable size */
1898 if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 4 * 1024 &&
1899 iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) {
1900 iscsilun->cluster_sectors = (iscsilun->bl.opt_unmap_gran *
1901 iscsilun->block_size) >> BDRV_SECTOR_BITS;
1902 if (iscsilun->lbprz) {
1903 ret = iscsi_allocmap_init(iscsilun, bs->open_flags);
1904 }
1905 }
1906
1907 out:
1908 qemu_opts_del(opts);
1909 g_free(initiator_name);
1910 if (task != NULL) {
1911 scsi_free_scsi_task(task);
1912 }
1913
1914 if (ret) {
1915 if (iscsi != NULL) {
1916 if (iscsi_is_logged_in(iscsi)) {
1917 iscsi_logout_sync(iscsi);
1918 }
1919 iscsi_destroy_context(iscsi);
1920 }
1921 memset(iscsilun, 0, sizeof(IscsiLun));
1922 }
1923 return ret;
1924 }
1925
1926 static void iscsi_close(BlockDriverState *bs)
1927 {
1928 IscsiLun *iscsilun = bs->opaque;
1929 struct iscsi_context *iscsi = iscsilun->iscsi;
1930
1931 iscsi_detach_aio_context(bs);
1932 if (iscsi_is_logged_in(iscsi)) {
1933 iscsi_logout_sync(iscsi);
1934 }
1935 iscsi_destroy_context(iscsi);
1936 g_free(iscsilun->zeroblock);
1937 iscsi_allocmap_free(iscsilun);
1938 memset(iscsilun, 0, sizeof(IscsiLun));
1939 }
1940
1941 static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp)
1942 {
1943 /* We don't actually refresh here, but just return data queried in
1944 * iscsi_open(): iscsi targets don't change their limits. */
1945
1946 IscsiLun *iscsilun = bs->opaque;
1947 uint64_t max_xfer_len = iscsilun->use_16_for_rw ? 0xffffffff : 0xffff;
1948 unsigned int block_size = MAX(BDRV_SECTOR_SIZE, iscsilun->block_size);
1949
1950 assert(iscsilun->block_size >= BDRV_SECTOR_SIZE || bs->sg);
1951
1952 bs->bl.request_alignment = block_size;
1953
1954 if (iscsilun->bl.max_xfer_len) {
1955 max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len);
1956 }
1957
1958 if (max_xfer_len * block_size < INT_MAX) {
1959 bs->bl.max_transfer = max_xfer_len * iscsilun->block_size;
1960 }
1961
1962 if (iscsilun->lbp.lbpu) {
1963 if (iscsilun->bl.max_unmap < 0xffffffff / block_size) {
1964 bs->bl.max_pdiscard =
1965 iscsilun->bl.max_unmap * iscsilun->block_size;
1966 }
1967 bs->bl.pdiscard_alignment =
1968 iscsilun->bl.opt_unmap_gran * iscsilun->block_size;
1969 } else {
1970 bs->bl.pdiscard_alignment = iscsilun->block_size;
1971 }
1972
1973 if (iscsilun->bl.max_ws_len < 0xffffffff / block_size) {
1974 bs->bl.max_pwrite_zeroes =
1975 iscsilun->bl.max_ws_len * iscsilun->block_size;
1976 }
1977 if (iscsilun->lbp.lbpws) {
1978 bs->bl.pwrite_zeroes_alignment =
1979 iscsilun->bl.opt_unmap_gran * iscsilun->block_size;
1980 } else {
1981 bs->bl.pwrite_zeroes_alignment = iscsilun->block_size;
1982 }
1983 if (iscsilun->bl.opt_xfer_len &&
1984 iscsilun->bl.opt_xfer_len < INT_MAX / block_size) {
1985 bs->bl.opt_transfer = pow2floor(iscsilun->bl.opt_xfer_len *
1986 iscsilun->block_size);
1987 }
1988 }
1989
1990 /* Note that this will not re-establish a connection with an iSCSI target - it
1991 * is effectively a NOP. */
1992 static int iscsi_reopen_prepare(BDRVReopenState *state,
1993 BlockReopenQueue *queue, Error **errp)
1994 {
1995 IscsiLun *iscsilun = state->bs->opaque;
1996
1997 if (state->flags & BDRV_O_RDWR && iscsilun->write_protected) {
1998 error_setg(errp, "Cannot open a write protected LUN as read-write");
1999 return -EACCES;
2000 }
2001 return 0;
2002 }
2003
2004 static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
2005 {
2006 IscsiLun *iscsilun = reopen_state->bs->opaque;
2007
2008 /* the cache.direct status might have changed */
2009 if (iscsilun->allocmap != NULL) {
2010 iscsi_allocmap_init(iscsilun, reopen_state->flags);
2011 }
2012 }
2013
2014 static int iscsi_truncate(BlockDriverState *bs, int64_t offset)
2015 {
2016 IscsiLun *iscsilun = bs->opaque;
2017 Error *local_err = NULL;
2018
2019 if (iscsilun->type != TYPE_DISK) {
2020 return -ENOTSUP;
2021 }
2022
2023 iscsi_readcapacity_sync(iscsilun, &local_err);
2024 if (local_err != NULL) {
2025 error_free(local_err);
2026 return -EIO;
2027 }
2028
2029 if (offset > iscsi_getlength(bs)) {
2030 return -EINVAL;
2031 }
2032
2033 if (iscsilun->allocmap != NULL) {
2034 iscsi_allocmap_init(iscsilun, bs->open_flags);
2035 }
2036
2037 return 0;
2038 }
2039
2040 static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp)
2041 {
2042 int ret = 0;
2043 int64_t total_size = 0;
2044 BlockDriverState *bs;
2045 IscsiLun *iscsilun = NULL;
2046 QDict *bs_options;
2047
2048 bs = bdrv_new();
2049
2050 /* Read out options */
2051 total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2052 BDRV_SECTOR_SIZE);
2053 bs->opaque = g_new0(struct IscsiLun, 1);
2054 iscsilun = bs->opaque;
2055
2056 bs_options = qdict_new();
2057 qdict_put(bs_options, "filename", qstring_from_str(filename));
2058 ret = iscsi_open(bs, bs_options, 0, NULL);
2059 QDECREF(bs_options);
2060
2061 if (ret != 0) {
2062 goto out;
2063 }
2064 iscsi_detach_aio_context(bs);
2065 if (iscsilun->type != TYPE_DISK) {
2066 ret = -ENODEV;
2067 goto out;
2068 }
2069 if (bs->total_sectors < total_size) {
2070 ret = -ENOSPC;
2071 goto out;
2072 }
2073
2074 ret = 0;
2075 out:
2076 if (iscsilun->iscsi != NULL) {
2077 iscsi_destroy_context(iscsilun->iscsi);
2078 }
2079 g_free(bs->opaque);
2080 bs->opaque = NULL;
2081 bdrv_unref(bs);
2082 return ret;
2083 }
2084
2085 static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2086 {
2087 IscsiLun *iscsilun = bs->opaque;
2088 bdi->unallocated_blocks_are_zero = iscsilun->lbprz;
2089 bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws;
2090 bdi->cluster_size = iscsilun->cluster_sectors * BDRV_SECTOR_SIZE;
2091 return 0;
2092 }
2093
2094 static void iscsi_invalidate_cache(BlockDriverState *bs,
2095 Error **errp)
2096 {
2097 IscsiLun *iscsilun = bs->opaque;
2098 iscsi_allocmap_invalidate(iscsilun);
2099 }
2100
2101 static QemuOptsList iscsi_create_opts = {
2102 .name = "iscsi-create-opts",
2103 .head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head),
2104 .desc = {
2105 {
2106 .name = BLOCK_OPT_SIZE,
2107 .type = QEMU_OPT_SIZE,
2108 .help = "Virtual disk size"
2109 },
2110 { /* end of list */ }
2111 }
2112 };
2113
2114 static BlockDriver bdrv_iscsi = {
2115 .format_name = "iscsi",
2116 .protocol_name = "iscsi",
2117
2118 .instance_size = sizeof(IscsiLun),
2119 .bdrv_parse_filename = iscsi_parse_filename,
2120 .bdrv_file_open = iscsi_open,
2121 .bdrv_close = iscsi_close,
2122 .bdrv_create = iscsi_create,
2123 .create_opts = &iscsi_create_opts,
2124 .bdrv_reopen_prepare = iscsi_reopen_prepare,
2125 .bdrv_reopen_commit = iscsi_reopen_commit,
2126 .bdrv_invalidate_cache = iscsi_invalidate_cache,
2127
2128 .bdrv_getlength = iscsi_getlength,
2129 .bdrv_get_info = iscsi_get_info,
2130 .bdrv_truncate = iscsi_truncate,
2131 .bdrv_refresh_limits = iscsi_refresh_limits,
2132
2133 .bdrv_co_get_block_status = iscsi_co_get_block_status,
2134 .bdrv_co_pdiscard = iscsi_co_pdiscard,
2135 .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
2136 .bdrv_co_readv = iscsi_co_readv,
2137 .bdrv_co_writev_flags = iscsi_co_writev_flags,
2138 .bdrv_co_flush_to_disk = iscsi_co_flush,
2139
2140 #ifdef __linux__
2141 .bdrv_aio_ioctl = iscsi_aio_ioctl,
2142 #endif
2143
2144 .bdrv_detach_aio_context = iscsi_detach_aio_context,
2145 .bdrv_attach_aio_context = iscsi_attach_aio_context,
2146 };
2147
2148 #if LIBISCSI_API_VERSION >= (20160603)
2149 static BlockDriver bdrv_iser = {
2150 .format_name = "iser",
2151 .protocol_name = "iser",
2152
2153 .instance_size = sizeof(IscsiLun),
2154 .bdrv_parse_filename = iscsi_parse_filename,
2155 .bdrv_file_open = iscsi_open,
2156 .bdrv_close = iscsi_close,
2157 .bdrv_create = iscsi_create,
2158 .create_opts = &iscsi_create_opts,
2159 .bdrv_reopen_prepare = iscsi_reopen_prepare,
2160 .bdrv_reopen_commit = iscsi_reopen_commit,
2161 .bdrv_invalidate_cache = iscsi_invalidate_cache,
2162
2163 .bdrv_getlength = iscsi_getlength,
2164 .bdrv_get_info = iscsi_get_info,
2165 .bdrv_truncate = iscsi_truncate,
2166 .bdrv_refresh_limits = iscsi_refresh_limits,
2167
2168 .bdrv_co_get_block_status = iscsi_co_get_block_status,
2169 .bdrv_co_pdiscard = iscsi_co_pdiscard,
2170 .bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
2171 .bdrv_co_readv = iscsi_co_readv,
2172 .bdrv_co_writev_flags = iscsi_co_writev_flags,
2173 .bdrv_co_flush_to_disk = iscsi_co_flush,
2174
2175 #ifdef __linux__
2176 .bdrv_aio_ioctl = iscsi_aio_ioctl,
2177 #endif
2178
2179 .bdrv_detach_aio_context = iscsi_detach_aio_context,
2180 .bdrv_attach_aio_context = iscsi_attach_aio_context,
2181 };
2182 #endif
2183
2184 static void iscsi_block_init(void)
2185 {
2186 bdrv_register(&bdrv_iscsi);
2187 #if LIBISCSI_API_VERSION >= (20160603)
2188 bdrv_register(&bdrv_iser);
2189 #endif
2190 }
2191
2192 block_init(iscsi_block_init);
AR7 emulation for QEMU