?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target-sh4: Introduce SuperHCPU subclasses
[qemu/agraf.git] / block / iscsi.c
blob3d529213ff329975d45b778aa4c0dd134c7aa4f1
1 /*
2 * QEMU Block driver for iSCSI images
3 *
4 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "config-host.h"
26
27 #include <poll.h>
28 #include <arpa/inet.h>
29 #include "qemu-common.h"
30 #include "qemu/config-file.h"
31 #include "qemu/error-report.h"
32 #include "block/block_int.h"
33 #include "trace.h"
34 #include "hw/scsi-defs.h"
35
36 #include <iscsi/iscsi.h>
37 #include <iscsi/scsi-lowlevel.h>
38
39 #ifdef __linux__
40 #include <scsi/sg.h>
41 #include <hw/scsi-defs.h>
42 #endif
43
44 typedef struct IscsiLun {
45 struct iscsi_context *iscsi;
46 int lun;
47 enum scsi_inquiry_peripheral_device_type type;
48 int block_size;
49 uint64_t num_blocks;
50 int events;
51 QEMUTimer *nop_timer;
52 } IscsiLun;
53
54 typedef struct IscsiAIOCB {
55 BlockDriverAIOCB common;
56 QEMUIOVector *qiov;
57 QEMUBH *bh;
58 IscsiLun *iscsilun;
59 struct scsi_task *task;
60 uint8_t *buf;
61 int status;
62 int canceled;
63 int retries;
64 size_t read_size;
65 size_t read_offset;
66 int64_t sector_num;
67 int nb_sectors;
68 #ifdef __linux__
69 sg_io_hdr_t *ioh;
70 #endif
71 } IscsiAIOCB;
72
73 #define NOP_INTERVAL 5000
74 #define MAX_NOP_FAILURES 3
75 #define ISCSI_CMD_RETRIES 5
76
77 static void
78 iscsi_bh_cb(void *p)
79 {
80 IscsiAIOCB *acb = p;
81
82 qemu_bh_delete(acb->bh);
83
84 g_free(acb->buf);
85 acb->buf = NULL;
86
87 if (acb->canceled == 0) {
88 acb->common.cb(acb->common.opaque, acb->status);
89 }
90
91 if (acb->task != NULL) {
92 scsi_free_scsi_task(acb->task);
93 acb->task = NULL;
94 }
95
96 qemu_aio_release(acb);
97 }
98
99 static void
100 iscsi_schedule_bh(IscsiAIOCB *acb)
101 {
102 if (acb->bh) {
103 return;
104 }
105 acb->bh = qemu_bh_new(iscsi_bh_cb, acb);
106 qemu_bh_schedule(acb->bh);
107 }
108
109
110 static void
111 iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,
112 void *private_data)
113 {
114 IscsiAIOCB *acb = private_data;
115
116 acb->status = -ECANCELED;
117 iscsi_schedule_bh(acb);
118 }
119
120 static void
121 iscsi_aio_cancel(BlockDriverAIOCB *blockacb)
122 {
123 IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;
124 IscsiLun *iscsilun = acb->iscsilun;
125
126 if (acb->status != -EINPROGRESS) {
127 return;
128 }
129
130 acb->canceled = 1;
131
132 /* send a task mgmt call to the target to cancel the task on the target */
133 iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,
134 iscsi_abort_task_cb, acb);
135
136 while (acb->status == -EINPROGRESS) {
137 qemu_aio_wait();
138 }
139 }
140
141 static const AIOCBInfo iscsi_aiocb_info = {
142 .aiocb_size = sizeof(IscsiAIOCB),
143 .cancel = iscsi_aio_cancel,
144 };
145
146
147 static void iscsi_process_read(void *arg);
148 static void iscsi_process_write(void *arg);
149
150 static int iscsi_process_flush(void *arg)
151 {
152 IscsiLun *iscsilun = arg;
153
154 return iscsi_queue_length(iscsilun->iscsi) > 0;
155 }
156
157 static void
158 iscsi_set_events(IscsiLun *iscsilun)
159 {
160 struct iscsi_context *iscsi = iscsilun->iscsi;
161 int ev;
162
163 /* We always register a read handler. */
164 ev = POLLIN;
165 ev |= iscsi_which_events(iscsi);
166 if (ev != iscsilun->events) {
167 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi),
168 iscsi_process_read,
169 (ev & POLLOUT) ? iscsi_process_write : NULL,
170 iscsi_process_flush,
171 iscsilun);
172
173 }
174
175 iscsilun->events = ev;
176 }
177
178 static void
179 iscsi_process_read(void *arg)
180 {
181 IscsiLun *iscsilun = arg;
182 struct iscsi_context *iscsi = iscsilun->iscsi;
183
184 iscsi_service(iscsi, POLLIN);
185 iscsi_set_events(iscsilun);
186 }
187
188 static void
189 iscsi_process_write(void *arg)
190 {
191 IscsiLun *iscsilun = arg;
192 struct iscsi_context *iscsi = iscsilun->iscsi;
193
194 iscsi_service(iscsi, POLLOUT);
195 iscsi_set_events(iscsilun);
196 }
197
198 static int
199 iscsi_aio_writev_acb(IscsiAIOCB *acb);
200
201 static void
202 iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status,
203 void *command_data, void *opaque)
204 {
205 IscsiAIOCB *acb = opaque;
206
207 trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled);
208
209 g_free(acb->buf);
210 acb->buf = NULL;
211
212 if (acb->canceled != 0) {
213 return;
214 }
215
216 acb->status = 0;
217 if (status != 0) {
218 if (status == SCSI_STATUS_CHECK_CONDITION
219 && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION
220 && acb->retries-- > 0) {
221 if (acb->task != NULL) {
222 scsi_free_scsi_task(acb->task);
223 acb->task = NULL;
224 }
225 if (iscsi_aio_writev_acb(acb) == 0) {
226 iscsi_set_events(acb->iscsilun);
227 return;
228 }
229 }
230 error_report("Failed to write16 data to iSCSI lun. %s",
231 iscsi_get_error(iscsi));
232 acb->status = -EIO;
233 }
234
235 iscsi_schedule_bh(acb);
236 }
237
238 static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)
239 {
240 return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;
241 }
242
243 static int
244 iscsi_aio_writev_acb(IscsiAIOCB *acb)
245 {
246 struct iscsi_context *iscsi = acb->iscsilun->iscsi;
247 size_t size;
248 uint32_t num_sectors;
249 uint64_t lba;
250 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
251 struct iscsi_data data;
252 #endif
253 int ret;
254
255 acb->canceled = 0;
256 acb->bh = NULL;
257 acb->status = -EINPROGRESS;
258 acb->buf = NULL;
259
260 /* this will allow us to get rid of 'buf' completely */
261 size = acb->nb_sectors * BDRV_SECTOR_SIZE;
262
263 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
264 data.size = MIN(size, acb->qiov->size);
265
266 /* if the iovec only contains one buffer we can pass it directly */
267 if (acb->qiov->niov == 1) {
268 data.data = acb->qiov->iov[0].iov_base;
269 } else {
270 acb->buf = g_malloc(data.size);
271 qemu_iovec_to_buf(acb->qiov, 0, acb->buf, data.size);
272 data.data = acb->buf;
273 }
274 #endif
275
276 acb->task = malloc(sizeof(struct scsi_task));
277 if (acb->task == NULL) {
278 error_report("iSCSI: Failed to allocate task for scsi WRITE16 "
279 "command. %s", iscsi_get_error(iscsi));
280 return -1;
281 }
282 memset(acb->task, 0, sizeof(struct scsi_task));
283
284 acb->task->xfer_dir = SCSI_XFER_WRITE;
285 acb->task->cdb_size = 16;
286 acb->task->cdb[0] = 0x8a;
287 lba = sector_qemu2lun(acb->sector_num, acb->iscsilun);
288 *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32);
289 *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff);
290 num_sectors = size / acb->iscsilun->block_size;
291 *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors);
292 acb->task->expxferlen = size;
293
294 #if defined(LIBISCSI_FEATURE_IOVECTOR)
295 ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,
296 iscsi_aio_write16_cb,
297 NULL,
298 acb);
299 #else
300 ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,
301 iscsi_aio_write16_cb,
302 &data,
303 acb);
304 #endif
305 if (ret != 0) {
306 g_free(acb->buf);
307 return -1;
308 }
309
310 #if defined(LIBISCSI_FEATURE_IOVECTOR)
311 scsi_task_set_iov_out(acb->task, (struct scsi_iovec*) acb->qiov->iov, acb->qiov->niov);
312 #endif
313
314 return 0;
315 }
316
317 static BlockDriverAIOCB *
318 iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num,
319 QEMUIOVector *qiov, int nb_sectors,
320 BlockDriverCompletionFunc *cb,
321 void *opaque)
322 {
323 IscsiLun *iscsilun = bs->opaque;
324 IscsiAIOCB *acb;
325
326 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
327 trace_iscsi_aio_writev(iscsilun->iscsi, sector_num, nb_sectors, opaque, acb);
328
329 acb->iscsilun = iscsilun;
330 acb->qiov = qiov;
331 acb->nb_sectors = nb_sectors;
332 acb->sector_num = sector_num;
333 acb->retries = ISCSI_CMD_RETRIES;
334
335 if (iscsi_aio_writev_acb(acb) != 0) {
336 if (acb->task) {
337 scsi_free_scsi_task(acb->task);
338 }
339 qemu_aio_release(acb);
340 return NULL;
341 }
342
343 iscsi_set_events(iscsilun);
344 return &acb->common;
345 }
346
347 static int
348 iscsi_aio_readv_acb(IscsiAIOCB *acb);
349
350 static void
351 iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status,
352 void *command_data, void *opaque)
353 {
354 IscsiAIOCB *acb = opaque;
355
356 trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled);
357
358 if (acb->canceled != 0) {
359 return;
360 }
361
362 acb->status = 0;
363 if (status != 0) {
364 if (status == SCSI_STATUS_CHECK_CONDITION
365 && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION
366 && acb->retries-- > 0) {
367 if (acb->task != NULL) {
368 scsi_free_scsi_task(acb->task);
369 acb->task = NULL;
370 }
371 if (iscsi_aio_readv_acb(acb) == 0) {
372 iscsi_set_events(acb->iscsilun);
373 return;
374 }
375 }
376 error_report("Failed to read16 data from iSCSI lun. %s",
377 iscsi_get_error(iscsi));
378 acb->status = -EIO;
379 }
380
381 iscsi_schedule_bh(acb);
382 }
383
384 static int
385 iscsi_aio_readv_acb(IscsiAIOCB *acb)
386 {
387 struct iscsi_context *iscsi = acb->iscsilun->iscsi;
388 uint64_t lba;
389 uint32_t num_sectors;
390 int ret;
391 #if !defined(LIBISCSI_FEATURE_IOVECTOR)
392 int i;
393 #endif
394
395 acb->canceled = 0;
396 acb->bh = NULL;
397 acb->status = -EINPROGRESS;
398 acb->buf = NULL;
399
400 /* If LUN blocksize is bigger than BDRV_BLOCK_SIZE a read from QEMU
401 * may be misaligned to the LUN, so we may need to read some extra
402 * data.
403 */
404 acb->read_offset = 0;
405 if (acb->iscsilun->block_size > BDRV_SECTOR_SIZE) {
406 uint64_t bdrv_offset = BDRV_SECTOR_SIZE * acb->sector_num;
407
408 acb->read_offset = bdrv_offset % acb->iscsilun->block_size;
409 }
410
411 num_sectors = (acb->read_size + acb->iscsilun->block_size
412 + acb->read_offset - 1)
413 / acb->iscsilun->block_size;
414
415 acb->task = malloc(sizeof(struct scsi_task));
416 if (acb->task == NULL) {
417 error_report("iSCSI: Failed to allocate task for scsi READ16 "
418 "command. %s", iscsi_get_error(iscsi));
419 return -1;
420 }
421 memset(acb->task, 0, sizeof(struct scsi_task));
422
423 acb->task->xfer_dir = SCSI_XFER_READ;
424 lba = sector_qemu2lun(acb->sector_num, acb->iscsilun);
425 acb->task->expxferlen = acb->read_size;
426
427 switch (acb->iscsilun->type) {
428 case TYPE_DISK:
429 acb->task->cdb_size = 16;
430 acb->task->cdb[0] = 0x88;
431 *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32);
432 *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff);
433 *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors);
434 break;
435 default:
436 acb->task->cdb_size = 10;
437 acb->task->cdb[0] = 0x28;
438 *(uint32_t *)&acb->task->cdb[2] = htonl(lba);
439 *(uint16_t *)&acb->task->cdb[7] = htons(num_sectors);
440 break;
441 }
442
443 ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,
444 iscsi_aio_read16_cb,
445 NULL,
446 acb);
447 if (ret != 0) {
448 return -1;
449 }
450
451 #if defined(LIBISCSI_FEATURE_IOVECTOR)
452 scsi_task_set_iov_in(acb->task, (struct scsi_iovec*) acb->qiov->iov, acb->qiov->niov);
453 #else
454 for (i = 0; i < acb->qiov->niov; i++) {
455 scsi_task_add_data_in_buffer(acb->task,
456 acb->qiov->iov[i].iov_len,
457 acb->qiov->iov[i].iov_base);
458 }
459 #endif
460 return 0;
461 }
462
463 static BlockDriverAIOCB *
464 iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num,
465 QEMUIOVector *qiov, int nb_sectors,
466 BlockDriverCompletionFunc *cb,
467 void *opaque)
468 {
469 IscsiLun *iscsilun = bs->opaque;
470 IscsiAIOCB *acb;
471
472 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
473 trace_iscsi_aio_readv(iscsilun->iscsi, sector_num, nb_sectors, opaque, acb);
474
475 acb->nb_sectors = nb_sectors;
476 acb->sector_num = sector_num;
477 acb->iscsilun = iscsilun;
478 acb->qiov = qiov;
479 acb->read_size = BDRV_SECTOR_SIZE * (size_t)acb->nb_sectors;
480 acb->retries = ISCSI_CMD_RETRIES;
481
482 if (iscsi_aio_readv_acb(acb) != 0) {
483 if (acb->task) {
484 scsi_free_scsi_task(acb->task);
485 }
486 qemu_aio_release(acb);
487 return NULL;
488 }
489
490 iscsi_set_events(iscsilun);
491 return &acb->common;
492 }
493
494 static int
495 iscsi_aio_flush_acb(IscsiAIOCB *acb);
496
497 static void
498 iscsi_synccache10_cb(struct iscsi_context *iscsi, int status,
499 void *command_data, void *opaque)
500 {
501 IscsiAIOCB *acb = opaque;
502
503 if (acb->canceled != 0) {
504 return;
505 }
506
507 acb->status = 0;
508 if (status != 0) {
509 if (status == SCSI_STATUS_CHECK_CONDITION
510 && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION
511 && acb->retries-- > 0) {
512 if (acb->task != NULL) {
513 scsi_free_scsi_task(acb->task);
514 acb->task = NULL;
515 }
516 if (iscsi_aio_flush_acb(acb) == 0) {
517 iscsi_set_events(acb->iscsilun);
518 return;
519 }
520 }
521 error_report("Failed to sync10 data on iSCSI lun. %s",
522 iscsi_get_error(iscsi));
523 acb->status = -EIO;
524 }
525
526 iscsi_schedule_bh(acb);
527 }
528
529 static int
530 iscsi_aio_flush_acb(IscsiAIOCB *acb)
531 {
532 struct iscsi_context *iscsi = acb->iscsilun->iscsi;
533
534 acb->canceled = 0;
535 acb->bh = NULL;
536 acb->status = -EINPROGRESS;
537 acb->buf = NULL;
538
539 acb->task = iscsi_synchronizecache10_task(iscsi, acb->iscsilun->lun,
540 0, 0, 0, 0,
541 iscsi_synccache10_cb,
542 acb);
543 if (acb->task == NULL) {
544 error_report("iSCSI: Failed to send synchronizecache10 command. %s",
545 iscsi_get_error(iscsi));
546 return -1;
547 }
548
549 return 0;
550 }
551
552 static BlockDriverAIOCB *
553 iscsi_aio_flush(BlockDriverState *bs,
554 BlockDriverCompletionFunc *cb, void *opaque)
555 {
556 IscsiLun *iscsilun = bs->opaque;
557
558 IscsiAIOCB *acb;
559
560 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
561
562 acb->iscsilun = iscsilun;
563 acb->retries = ISCSI_CMD_RETRIES;
564
565 if (iscsi_aio_flush_acb(acb) != 0) {
566 qemu_aio_release(acb);
567 return NULL;
568 }
569
570 iscsi_set_events(iscsilun);
571
572 return &acb->common;
573 }
574
575 static int iscsi_aio_discard_acb(IscsiAIOCB *acb);
576
577 static void
578 iscsi_unmap_cb(struct iscsi_context *iscsi, int status,
579 void *command_data, void *opaque)
580 {
581 IscsiAIOCB *acb = opaque;
582
583 if (acb->canceled != 0) {
584 return;
585 }
586
587 acb->status = 0;
588 if (status != 0) {
589 if (status == SCSI_STATUS_CHECK_CONDITION
590 && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION
591 && acb->retries-- > 0) {
592 if (acb->task != NULL) {
593 scsi_free_scsi_task(acb->task);
594 acb->task = NULL;
595 }
596 if (iscsi_aio_discard_acb(acb) == 0) {
597 iscsi_set_events(acb->iscsilun);
598 return;
599 }
600 }
601 error_report("Failed to unmap data on iSCSI lun. %s",
602 iscsi_get_error(iscsi));
603 acb->status = -EIO;
604 }
605
606 iscsi_schedule_bh(acb);
607 }
608
609 static int iscsi_aio_discard_acb(IscsiAIOCB *acb) {
610 struct iscsi_context *iscsi = acb->iscsilun->iscsi;
611 struct unmap_list list[1];
612
613 acb->canceled = 0;
614 acb->bh = NULL;
615 acb->status = -EINPROGRESS;
616 acb->buf = NULL;
617
618 list[0].lba = sector_qemu2lun(acb->sector_num, acb->iscsilun);
619 list[0].num = acb->nb_sectors * BDRV_SECTOR_SIZE / acb->iscsilun->block_size;
620
621 acb->task = iscsi_unmap_task(iscsi, acb->iscsilun->lun,
622 0, 0, &list[0], 1,
623 iscsi_unmap_cb,
624 acb);
625 if (acb->task == NULL) {
626 error_report("iSCSI: Failed to send unmap command. %s",
627 iscsi_get_error(iscsi));
628 return -1;
629 }
630
631 return 0;
632 }
633
634 static BlockDriverAIOCB *
635 iscsi_aio_discard(BlockDriverState *bs,
636 int64_t sector_num, int nb_sectors,
637 BlockDriverCompletionFunc *cb, void *opaque)
638 {
639 IscsiLun *iscsilun = bs->opaque;
640 IscsiAIOCB *acb;
641
642 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
643
644 acb->iscsilun = iscsilun;
645 acb->nb_sectors = nb_sectors;
646 acb->sector_num = sector_num;
647 acb->retries = ISCSI_CMD_RETRIES;
648
649 if (iscsi_aio_discard_acb(acb) != 0) {
650 if (acb->task) {
651 scsi_free_scsi_task(acb->task);
652 }
653 qemu_aio_release(acb);
654 return NULL;
655 }
656
657 iscsi_set_events(iscsilun);
658
659 return &acb->common;
660 }
661
662 #ifdef __linux__
663 static void
664 iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
665 void *command_data, void *opaque)
666 {
667 IscsiAIOCB *acb = opaque;
668
669 if (acb->canceled != 0) {
670 return;
671 }
672
673 acb->status = 0;
674 if (status < 0) {
675 error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
676 iscsi_get_error(iscsi));
677 acb->status = -EIO;
678 }
679
680 acb->ioh->driver_status = 0;
681 acb->ioh->host_status = 0;
682 acb->ioh->resid = 0;
683
684 #define SG_ERR_DRIVER_SENSE 0x08
685
686 if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
687 int ss;
688
689 acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
690
691 acb->ioh->sb_len_wr = acb->task->datain.size - 2;
692 ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?
693 acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;
694 memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
695 }
696
697 iscsi_schedule_bh(acb);
698 }
699
700 static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
701 unsigned long int req, void *buf,
702 BlockDriverCompletionFunc *cb, void *opaque)
703 {
704 IscsiLun *iscsilun = bs->opaque;
705 struct iscsi_context *iscsi = iscsilun->iscsi;
706 struct iscsi_data data;
707 IscsiAIOCB *acb;
708
709 assert(req == SG_IO);
710
711 acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
712
713 acb->iscsilun = iscsilun;
714 acb->canceled = 0;
715 acb->bh = NULL;
716 acb->status = -EINPROGRESS;
717 acb->buf = NULL;
718 acb->ioh = buf;
719
720 acb->task = malloc(sizeof(struct scsi_task));
721 if (acb->task == NULL) {
722 error_report("iSCSI: Failed to allocate task for scsi command. %s",
723 iscsi_get_error(iscsi));
724 qemu_aio_release(acb);
725 return NULL;
726 }
727 memset(acb->task, 0, sizeof(struct scsi_task));
728
729 switch (acb->ioh->dxfer_direction) {
730 case SG_DXFER_TO_DEV:
731 acb->task->xfer_dir = SCSI_XFER_WRITE;
732 break;
733 case SG_DXFER_FROM_DEV:
734 acb->task->xfer_dir = SCSI_XFER_READ;
735 break;
736 default:
737 acb->task->xfer_dir = SCSI_XFER_NONE;
738 break;
739 }
740
741 acb->task->cdb_size = acb->ioh->cmd_len;
742 memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
743 acb->task->expxferlen = acb->ioh->dxfer_len;
744
745 if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
746 data.data = acb->ioh->dxferp;
747 data.size = acb->ioh->dxfer_len;
748 }
749 if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
750 iscsi_aio_ioctl_cb,
751 (acb->task->xfer_dir == SCSI_XFER_WRITE) ?
752 &data : NULL,
753 acb) != 0) {
754 scsi_free_scsi_task(acb->task);
755 qemu_aio_release(acb);
756 return NULL;
757 }
758
759 /* tell libiscsi to read straight into the buffer we got from ioctl */
760 if (acb->task->xfer_dir == SCSI_XFER_READ) {
761 scsi_task_add_data_in_buffer(acb->task,
762 acb->ioh->dxfer_len,
763 acb->ioh->dxferp);
764 }
765
766 iscsi_set_events(iscsilun);
767
768 return &acb->common;
769 }
770
771
772 static void ioctl_cb(void *opaque, int status)
773 {
774 int *p_status = opaque;
775 *p_status = status;
776 }
777
778 static int iscsi_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
779 {
780 IscsiLun *iscsilun = bs->opaque;
781 int status;
782
783 switch (req) {
784 case SG_GET_VERSION_NUM:
785 *(int *)buf = 30000;
786 break;
787 case SG_GET_SCSI_ID:
788 ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
789 break;
790 case SG_IO:
791 status = -EINPROGRESS;
792 iscsi_aio_ioctl(bs, req, buf, ioctl_cb, &status);
793
794 while (status == -EINPROGRESS) {
795 qemu_aio_wait();
796 }
797
798 return 0;
799 default:
800 return -1;
801 }
802 return 0;
803 }
804 #endif
805
806 static int64_t
807 iscsi_getlength(BlockDriverState *bs)
808 {
809 IscsiLun *iscsilun = bs->opaque;
810 int64_t len;
811
812 len = iscsilun->num_blocks;
813 len *= iscsilun->block_size;
814
815 return len;
816 }
817
818 static int parse_chap(struct iscsi_context *iscsi, const char *target)
819 {
820 QemuOptsList *list;
821 QemuOpts *opts;
822 const char *user = NULL;
823 const char *password = NULL;
824
825 list = qemu_find_opts("iscsi");
826 if (!list) {
827 return 0;
828 }
829
830 opts = qemu_opts_find(list, target);
831 if (opts == NULL) {
832 opts = QTAILQ_FIRST(&list->head);
833 if (!opts) {
834 return 0;
835 }
836 }
837
838 user = qemu_opt_get(opts, "user");
839 if (!user) {
840 return 0;
841 }
842
843 password = qemu_opt_get(opts, "password");
844 if (!password) {
845 error_report("CHAP username specified but no password was given");
846 return -1;
847 }
848
849 if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
850 error_report("Failed to set initiator username and password");
851 return -1;
852 }
853
854 return 0;
855 }
856
857 static void parse_header_digest(struct iscsi_context *iscsi, const char *target)
858 {
859 QemuOptsList *list;
860 QemuOpts *opts;
861 const char *digest = NULL;
862
863 list = qemu_find_opts("iscsi");
864 if (!list) {
865 return;
866 }
867
868 opts = qemu_opts_find(list, target);
869 if (opts == NULL) {
870 opts = QTAILQ_FIRST(&list->head);
871 if (!opts) {
872 return;
873 }
874 }
875
876 digest = qemu_opt_get(opts, "header-digest");
877 if (!digest) {
878 return;
879 }
880
881 if (!strcmp(digest, "CRC32C")) {
882 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
883 } else if (!strcmp(digest, "NONE")) {
884 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
885 } else if (!strcmp(digest, "CRC32C-NONE")) {
886 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
887 } else if (!strcmp(digest, "NONE-CRC32C")) {
888 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
889 } else {
890 error_report("Invalid header-digest setting : %s", digest);
891 }
892 }
893
894 static char *parse_initiator_name(const char *target)
895 {
896 QemuOptsList *list;
897 QemuOpts *opts;
898 const char *name = NULL;
899 const char *iscsi_name = qemu_get_vm_name();
900
901 list = qemu_find_opts("iscsi");
902 if (list) {
903 opts = qemu_opts_find(list, target);
904 if (!opts) {
905 opts = QTAILQ_FIRST(&list->head);
906 }
907 if (opts) {
908 name = qemu_opt_get(opts, "initiator-name");
909 }
910 }
911
912 if (name) {
913 return g_strdup(name);
914 } else {
915 return g_strdup_printf("iqn.2008-11.org.linux-kvm%s%s",
916 iscsi_name ? ":" : "",
917 iscsi_name ? iscsi_name : "");
918 }
919 }
920
921 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
922 static void iscsi_nop_timed_event(void *opaque)
923 {
924 IscsiLun *iscsilun = opaque;
925
926 if (iscsi_get_nops_in_flight(iscsilun->iscsi) > MAX_NOP_FAILURES) {
927 error_report("iSCSI: NOP timeout. Reconnecting...");
928 iscsi_reconnect(iscsilun->iscsi);
929 }
930
931 if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
932 error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
933 return;
934 }
935
936 qemu_mod_timer(iscsilun->nop_timer, qemu_get_clock_ms(rt_clock) + NOP_INTERVAL);
937 iscsi_set_events(iscsilun);
938 }
939 #endif
940
941 static int iscsi_readcapacity_sync(IscsiLun *iscsilun)
942 {
943 struct scsi_task *task = NULL;
944 struct scsi_readcapacity10 *rc10 = NULL;
945 struct scsi_readcapacity16 *rc16 = NULL;
946 int ret = 0;
947 int retries = ISCSI_CMD_RETRIES;
948
949 try_again:
950 switch (iscsilun->type) {
951 case TYPE_DISK:
952 task = iscsi_readcapacity16_sync(iscsilun->iscsi, iscsilun->lun);
953 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
954 if (task != NULL && task->status == SCSI_STATUS_CHECK_CONDITION
955 && task->sense.key == SCSI_SENSE_UNIT_ATTENTION
956 && retries-- > 0) {
957 scsi_free_scsi_task(task);
958 goto try_again;
959 }
960 error_report("iSCSI: failed to send readcapacity16 command.");
961 ret = -EINVAL;
962 goto out;
963 }
964 rc16 = scsi_datain_unmarshall(task);
965 if (rc16 == NULL) {
966 error_report("iSCSI: Failed to unmarshall readcapacity16 data.");
967 ret = -EINVAL;
968 goto out;
969 }
970 iscsilun->block_size = rc16->block_length;
971 iscsilun->num_blocks = rc16->returned_lba + 1;
972 break;
973 case TYPE_ROM:
974 task = iscsi_readcapacity10_sync(iscsilun->iscsi, iscsilun->lun, 0, 0);
975 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
976 error_report("iSCSI: failed to send readcapacity10 command.");
977 ret = -EINVAL;
978 goto out;
979 }
980 rc10 = scsi_datain_unmarshall(task);
981 if (rc10 == NULL) {
982 error_report("iSCSI: Failed to unmarshall readcapacity10 data.");
983 ret = -EINVAL;
984 goto out;
985 }
986 iscsilun->block_size = rc10->block_size;
987 if (rc10->lba == 0) {
988 /* blank disk loaded */
989 iscsilun->num_blocks = 0;
990 } else {
991 iscsilun->num_blocks = rc10->lba + 1;
992 }
993 break;
994 default:
995 break;
996 }
997
998 out:
999 if (task) {
1000 scsi_free_scsi_task(task);
1001 }
1002
1003 return ret;
1004 }
1005
1006 /*
1007 * We support iscsi url's on the form
1008 * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
1009 */
1010 static int iscsi_open(BlockDriverState *bs, const char *filename, int flags)
1011 {
1012 IscsiLun *iscsilun = bs->opaque;
1013 struct iscsi_context *iscsi = NULL;
1014 struct iscsi_url *iscsi_url = NULL;
1015 struct scsi_task *task = NULL;
1016 struct scsi_inquiry_standard *inq = NULL;
1017 char *initiator_name = NULL;
1018 int ret;
1019
1020 if ((BDRV_SECTOR_SIZE % 512) != 0) {
1021 error_report("iSCSI: Invalid BDRV_SECTOR_SIZE. "
1022 "BDRV_SECTOR_SIZE(%lld) is not a multiple "
1023 "of 512", BDRV_SECTOR_SIZE);
1024 return -EINVAL;
1025 }
1026
1027 iscsi_url = iscsi_parse_full_url(iscsi, filename);
1028 if (iscsi_url == NULL) {
1029 error_report("Failed to parse URL : %s", filename);
1030 ret = -EINVAL;
1031 goto out;
1032 }
1033
1034 memset(iscsilun, 0, sizeof(IscsiLun));
1035
1036 initiator_name = parse_initiator_name(iscsi_url->target);
1037
1038 iscsi = iscsi_create_context(initiator_name);
1039 if (iscsi == NULL) {
1040 error_report("iSCSI: Failed to create iSCSI context.");
1041 ret = -ENOMEM;
1042 goto out;
1043 }
1044
1045 if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
1046 error_report("iSCSI: Failed to set target name.");
1047 ret = -EINVAL;
1048 goto out;
1049 }
1050
1051 if (iscsi_url->user != NULL) {
1052 ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
1053 iscsi_url->passwd);
1054 if (ret != 0) {
1055 error_report("Failed to set initiator username and password");
1056 ret = -EINVAL;
1057 goto out;
1058 }
1059 }
1060
1061 /* check if we got CHAP username/password via the options */
1062 if (parse_chap(iscsi, iscsi_url->target) != 0) {
1063 error_report("iSCSI: Failed to set CHAP user/password");
1064 ret = -EINVAL;
1065 goto out;
1066 }
1067
1068 if (iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL) != 0) {
1069 error_report("iSCSI: Failed to set session type to normal.");
1070 ret = -EINVAL;
1071 goto out;
1072 }
1073
1074 iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
1075
1076 /* check if we got HEADER_DIGEST via the options */
1077 parse_header_digest(iscsi, iscsi_url->target);
1078
1079 if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
1080 error_report("iSCSI: Failed to connect to LUN : %s",
1081 iscsi_get_error(iscsi));
1082 ret = -EINVAL;
1083 goto out;
1084 }
1085
1086 iscsilun->iscsi = iscsi;
1087 iscsilun->lun = iscsi_url->lun;
1088
1089 task = iscsi_inquiry_sync(iscsi, iscsilun->lun, 0, 0, 36);
1090
1091 if (task == NULL || task->status != SCSI_STATUS_GOOD) {
1092 error_report("iSCSI: failed to send inquiry command.");
1093 ret = -EINVAL;
1094 goto out;
1095 }
1096
1097 inq = scsi_datain_unmarshall(task);
1098 if (inq == NULL) {
1099 error_report("iSCSI: Failed to unmarshall inquiry data.");
1100 ret = -EINVAL;
1101 goto out;
1102 }
1103
1104 iscsilun->type = inq->periperal_device_type;
1105
1106 if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) {
1107 goto out;
1108 }
1109 bs->total_sectors = iscsilun->num_blocks *
1110 iscsilun->block_size / BDRV_SECTOR_SIZE ;
1111
1112 /* Medium changer or tape. We dont have any emulation for this so this must
1113 * be sg ioctl compatible. We force it to be sg, otherwise qemu will try
1114 * to read from the device to guess the image format.
1115 */
1116 if (iscsilun->type == TYPE_MEDIUM_CHANGER ||
1117 iscsilun->type == TYPE_TAPE) {
1118 bs->sg = 1;
1119 }
1120
1121 #if defined(LIBISCSI_FEATURE_NOP_COUNTER)
1122 /* Set up a timer for sending out iSCSI NOPs */
1123 iscsilun->nop_timer = qemu_new_timer_ms(rt_clock, iscsi_nop_timed_event, iscsilun);
1124 qemu_mod_timer(iscsilun->nop_timer, qemu_get_clock_ms(rt_clock) + NOP_INTERVAL);
1125 #endif
1126
1127 out:
1128 if (initiator_name != NULL) {
1129 g_free(initiator_name);
1130 }
1131 if (iscsi_url != NULL) {
1132 iscsi_destroy_url(iscsi_url);
1133 }
1134 if (task != NULL) {
1135 scsi_free_scsi_task(task);
1136 }
1137
1138 if (ret) {
1139 if (iscsi != NULL) {
1140 iscsi_destroy_context(iscsi);
1141 }
1142 memset(iscsilun, 0, sizeof(IscsiLun));
1143 }
1144 return ret;
1145 }
1146
1147 static void iscsi_close(BlockDriverState *bs)
1148 {
1149 IscsiLun *iscsilun = bs->opaque;
1150 struct iscsi_context *iscsi = iscsilun->iscsi;
1151
1152 if (iscsilun->nop_timer) {
1153 qemu_del_timer(iscsilun->nop_timer);
1154 qemu_free_timer(iscsilun->nop_timer);
1155 }
1156 qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL, NULL);
1157 iscsi_destroy_context(iscsi);
1158 memset(iscsilun, 0, sizeof(IscsiLun));
1159 }
1160
1161 static int iscsi_truncate(BlockDriverState *bs, int64_t offset)
1162 {
1163 IscsiLun *iscsilun = bs->opaque;
1164 int ret = 0;
1165
1166 if (iscsilun->type != TYPE_DISK) {
1167 return -ENOTSUP;
1168 }
1169
1170 if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) {
1171 return ret;
1172 }
1173
1174 if (offset > iscsi_getlength(bs)) {
1175 return -EINVAL;
1176 }
1177
1178 return 0;
1179 }
1180
1181 static int iscsi_has_zero_init(BlockDriverState *bs)
1182 {
1183 return 0;
1184 }
1185
1186 static int iscsi_create(const char *filename, QEMUOptionParameter *options)
1187 {
1188 int ret = 0;
1189 int64_t total_size = 0;
1190 BlockDriverState bs;
1191 IscsiLun *iscsilun = NULL;
1192
1193 memset(&bs, 0, sizeof(BlockDriverState));
1194
1195 /* Read out options */
1196 while (options && options->name) {
1197 if (!strcmp(options->name, "size")) {
1198 total_size = options->value.n / BDRV_SECTOR_SIZE;
1199 }
1200 options++;
1201 }
1202
1203 bs.opaque = g_malloc0(sizeof(struct IscsiLun));
1204 iscsilun = bs.opaque;
1205
1206 ret = iscsi_open(&bs, filename, 0);
1207 if (ret != 0) {
1208 goto out;
1209 }
1210 if (iscsilun->nop_timer) {
1211 qemu_del_timer(iscsilun->nop_timer);
1212 qemu_free_timer(iscsilun->nop_timer);
1213 }
1214 if (iscsilun->type != TYPE_DISK) {
1215 ret = -ENODEV;
1216 goto out;
1217 }
1218 if (bs.total_sectors < total_size) {
1219 ret = -ENOSPC;
1220 }
1221
1222 ret = 0;
1223 out:
1224 if (iscsilun->iscsi != NULL) {
1225 iscsi_destroy_context(iscsilun->iscsi);
1226 }
1227 g_free(bs.opaque);
1228 return ret;
1229 }
1230
1231 static QEMUOptionParameter iscsi_create_options[] = {
1232 {
1233 .name = BLOCK_OPT_SIZE,
1234 .type = OPT_SIZE,
1235 .help = "Virtual disk size"
1236 },
1237 { NULL }
1238 };
1239
1240 static BlockDriver bdrv_iscsi = {
1241 .format_name = "iscsi",
1242 .protocol_name = "iscsi",
1243
1244 .instance_size = sizeof(IscsiLun),
1245 .bdrv_file_open = iscsi_open,
1246 .bdrv_close = iscsi_close,
1247 .bdrv_create = iscsi_create,
1248 .create_options = iscsi_create_options,
1249
1250 .bdrv_getlength = iscsi_getlength,
1251 .bdrv_truncate = iscsi_truncate,
1252
1253 .bdrv_aio_readv = iscsi_aio_readv,
1254 .bdrv_aio_writev = iscsi_aio_writev,
1255 .bdrv_aio_flush = iscsi_aio_flush,
1256
1257 .bdrv_aio_discard = iscsi_aio_discard,
1258 .bdrv_has_zero_init = iscsi_has_zero_init,
1259
1260 #ifdef __linux__
1261 .bdrv_ioctl = iscsi_ioctl,
1262 .bdrv_aio_ioctl = iscsi_aio_ioctl,
1263 #endif
1264 };
1265
1266 static QemuOptsList qemu_iscsi_opts = {
1267 .name = "iscsi",
1268 .head = QTAILQ_HEAD_INITIALIZER(qemu_iscsi_opts.head),
1269 .desc = {
1270 {
1271 .name = "user",
1272 .type = QEMU_OPT_STRING,
1273 .help = "username for CHAP authentication to target",
1274 },{
1275 .name = "password",
1276 .type = QEMU_OPT_STRING,
1277 .help = "password for CHAP authentication to target",
1278 },{
1279 .name = "header-digest",
1280 .type = QEMU_OPT_STRING,
1281 .help = "HeaderDigest setting. "
1282 "{CRC32C|CRC32C-NONE|NONE-CRC32C|NONE}",
1283 },{
1284 .name = "initiator-name",
1285 .type = QEMU_OPT_STRING,
1286 .help = "Initiator iqn name to use when connecting",
1287 },
1288 { /* end of list */ }
1289 },
1290 };
1291
1292 static void iscsi_block_init(void)
1293 {
1294 bdrv_register(&bdrv_iscsi);
1295 qemu_add_opts(&qemu_iscsi_opts);
1296 }
1297
1298 block_init(iscsi_block_init);
Qemu with PowerPC KVM improvements