← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to hw/scsi-disk.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/scsi-disk.c
9
9
 * This code is licenced under the LGPL.
10
10
 *
11
11
 * Note that this file only handles the SCSI architecture model and device
12
 
 * commands.  Emultion of interface/link layer protocols is handled by
13
 
 * the host adapter emulation.
 
12
 * commands.  Emulation of interface/link layer protocols is handled by
 
13
 * the host adapter emulator.
14
14
 */
15
15
 
 
16
#include <qemu-common.h>
 
17
#include <sysemu.h>
16
18
//#define DEBUG_SCSI
17
19
 
18
20
#ifdef DEBUG_SCSI
34
36
#define SENSE_HARDWARE_ERROR  4
35
37
#define SENSE_ILLEGAL_REQUEST 5
36
38
 
37
 
#define SCSI_DMA_BUF_SIZE    65536
 
39
#define STATUS_GOOD            0
 
40
#define STATUS_CHECK_CONDITION 2
 
41
 
 
42
#define SCSI_DMA_BUF_SIZE    131072
 
43
#define SCSI_MAX_INQUIRY_LEN 256
 
44
 
 
45
#define SCSI_REQ_STATUS_RETRY 0x01
38
46
 
39
47
typedef struct SCSIRequest {
40
48
    SCSIDeviceState *dev;
41
49
    uint32_t tag;
42
 
    /* ??? We should probably keep track of whether the data trasfer is
 
50
    /* ??? We should probably keep track of whether the data transfer is
43
51
       a read or a write.  Currently we rely on the host getting it right.  */
44
52
    /* Both sector and sector_count are in terms of qemu 512 byte blocks.  */
45
 
    int sector;
46
 
    int sector_count;
 
53
    uint64_t sector;
 
54
    uint32_t sector_count;
47
55
    /* The amounnt of data in the buffer.  */
48
56
    int buf_len;
49
57
    uint8_t *dma_buf;
50
58
    BlockDriverAIOCB *aiocb;
51
59
    struct SCSIRequest *next;
 
60
    uint32_t status;
52
61
} SCSIRequest;
53
62
 
54
63
struct SCSIDeviceState
58
67
    /* The qemu block layer uses a fixed 512 byte sector size.
59
68
       This is the number of 512 byte blocks in a single scsi sector.  */
60
69
    int cluster_size;
 
70
    uint64_t max_lba;
61
71
    int sense;
62
72
    int tcq;
63
73
    /* Completion functions may be called from either scsi_{read,write}_data
64
74
       or from the AIO completion routines.  */
65
75
    scsi_completionfn completion;
66
76
    void *opaque;
 
77
    char drive_serial_str[21];
67
78
};
68
79
 
69
80
/* Global pool of SCSIRequest structures.  */
85
96
    r->sector_count = 0;
86
97
    r->buf_len = 0;
87
98
    r->aiocb = NULL;
 
99
    r->status = 0;
88
100
 
89
101
    r->next = s->requests;
90
102
    s->requests = r;
124
136
}
125
137
 
126
138
/* Helper function for command completion.  */
127
 
static void scsi_command_complete(SCSIRequest *r, int sense)
 
139
static void scsi_command_complete(SCSIRequest *r, int status, int sense)
128
140
{
129
141
    SCSIDeviceState *s = r->dev;
130
142
    uint32_t tag;
131
 
    DPRINTF("Command complete tag=0x%x sense=%d\n", r->tag, sense);
 
143
    DPRINTF("Command complete tag=0x%x status=%d sense=%d\n", r->tag, status, sense);
132
144
    s->sense = sense;
133
145
    tag = r->tag;
134
146
    scsi_remove_request(r);
135
 
    s->completion(s->opaque, SCSI_REASON_DONE, tag, sense);
 
147
    s->completion(s->opaque, SCSI_REASON_DONE, tag, status);
136
148
}
137
149
 
138
150
/* Cancel a pending data transfer.  */
157
169
 
158
170
    if (ret) {
159
171
        DPRINTF("IO error\n");
160
 
        scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 
172
        s->completion(s->opaque, SCSI_REASON_DATA, r->tag, 0);
 
173
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_NO_SENSE);
161
174
        return;
162
175
    }
163
176
    DPRINTF("Data ready tag=0x%x len=%d\n", r->tag, r->buf_len);
176
189
    if (!r) {
177
190
        BADF("Bad read tag 0x%x\n", tag);
178
191
        /* ??? This is the wrong error.  */
179
 
        scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 
192
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_HARDWARE_ERROR);
180
193
        return;
181
194
    }
182
195
    if (r->sector_count == (uint32_t)-1) {
187
200
    }
188
201
    DPRINTF("Read sector_count=%d\n", r->sector_count);
189
202
    if (r->sector_count == 0) {
190
 
        scsi_command_complete(r, SENSE_NO_SENSE);
 
203
        scsi_command_complete(r, STATUS_GOOD, SENSE_NO_SENSE);
191
204
        return;
192
205
    }
193
206
 
199
212
    r->aiocb = bdrv_aio_read(s->bdrv, r->sector, r->dma_buf, n,
200
213
                             scsi_read_complete, r);
201
214
    if (r->aiocb == NULL)
202
 
        scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 
215
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_HARDWARE_ERROR);
203
216
    r->sector += n;
204
217
    r->sector_count -= n;
205
218
}
206
219
 
 
220
static int scsi_handle_write_error(SCSIRequest *r, int error)
 
221
{
 
222
    BlockInterfaceErrorAction action = drive_get_onerror(r->dev->bdrv);
 
223
 
 
224
    if (action == BLOCK_ERR_IGNORE)
 
225
        return 0;
 
226
 
 
227
    if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
 
228
            || action == BLOCK_ERR_STOP_ANY) {
 
229
        r->status |= SCSI_REQ_STATUS_RETRY;
 
230
        vm_stop(0);
 
231
    } else {
 
232
        scsi_command_complete(r, STATUS_CHECK_CONDITION,
 
233
                SENSE_HARDWARE_ERROR);
 
234
    }
 
235
 
 
236
    return 1;
 
237
}
 
238
 
207
239
static void scsi_write_complete(void * opaque, int ret)
208
240
{
209
241
    SCSIRequest *r = (SCSIRequest *)opaque;
210
242
    SCSIDeviceState *s = r->dev;
211
243
    uint32_t len;
 
244
    uint32_t n;
 
245
 
 
246
    r->aiocb = NULL;
212
247
 
213
248
    if (ret) {
214
 
        fprintf(stderr, "scsi-disc: IO write error\n");
215
 
        exit(1);
 
249
        if (scsi_handle_write_error(r, -ret))
 
250
            return;
216
251
    }
217
252
 
218
 
    r->aiocb = NULL;
 
253
    n = r->buf_len / 512;
 
254
    r->sector += n;
 
255
    r->sector_count -= n;
219
256
    if (r->sector_count == 0) {
220
 
        scsi_command_complete(r, SENSE_NO_SENSE);
 
257
        scsi_command_complete(r, STATUS_GOOD, SENSE_NO_SENSE);
221
258
    } else {
222
259
        len = r->sector_count * 512;
223
260
        if (len > SCSI_DMA_BUF_SIZE) {
229
266
    }
230
267
}
231
268
 
 
269
static void scsi_write_request(SCSIRequest *r)
 
270
{
 
271
    SCSIDeviceState *s = r->dev;
 
272
    uint32_t n;
 
273
 
 
274
    n = r->buf_len / 512;
 
275
    if (n) {
 
276
        r->aiocb = bdrv_aio_write(s->bdrv, r->sector, r->dma_buf, n,
 
277
                                  scsi_write_complete, r);
 
278
        if (r->aiocb == NULL)
 
279
            scsi_command_complete(r, STATUS_CHECK_CONDITION,
 
280
                                  SENSE_HARDWARE_ERROR);
 
281
    } else {
 
282
        /* Invoke completion routine to fetch data from host.  */
 
283
        scsi_write_complete(r, 0);
 
284
    }
 
285
}
 
286
 
232
287
/* Write data to a scsi device.  Returns nonzero on failure.
233
288
   The transfer may complete asynchronously.  */
234
289
static int scsi_write_data(SCSIDevice *d, uint32_t tag)
235
290
{
236
291
    SCSIDeviceState *s = d->state;
237
292
    SCSIRequest *r;
238
 
    uint32_t n;
239
293
 
240
294
    DPRINTF("Write data tag=0x%x\n", tag);
241
295
    r = scsi_find_request(s, tag);
242
296
    if (!r) {
243
297
        BADF("Bad write tag 0x%x\n", tag);
244
 
        scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 
298
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_HARDWARE_ERROR);
245
299
        return 1;
246
300
    }
 
301
 
247
302
    if (r->aiocb)
248
303
        BADF("Data transfer already in progress\n");
249
 
    n = r->buf_len / 512;
250
 
    if (n) {
251
 
        r->aiocb = bdrv_aio_write(s->bdrv, r->sector, r->dma_buf, n,
252
 
                                  scsi_write_complete, r);
253
 
        if (r->aiocb == NULL)
254
 
            scsi_command_complete(r, SENSE_HARDWARE_ERROR);
255
 
        r->sector += n;
256
 
        r->sector_count -= n;
257
 
    } else {
258
 
        /* Invoke completion routine to fetch data from host.  */
259
 
        scsi_write_complete(r, 0);
260
 
    }
 
304
 
 
305
    scsi_write_request(r);
261
306
 
262
307
    return 0;
263
308
}
264
309
 
 
310
static void scsi_dma_restart_cb(void *opaque, int running, int reason)
 
311
{
 
312
    SCSIDeviceState *s = opaque;
 
313
    SCSIRequest *r = s->requests;
 
314
    if (!running)
 
315
        return;
 
316
 
 
317
    while (r) {
 
318
        if (r->status & SCSI_REQ_STATUS_RETRY) {
 
319
            r->status &= ~SCSI_REQ_STATUS_RETRY;
 
320
            scsi_write_request(r); 
 
321
        }
 
322
        r = r->next;
 
323
    }
 
324
}
 
325
 
265
326
/* Return a pointer to the data buffer.  */
266
327
static uint8_t *scsi_get_buf(SCSIDevice *d, uint32_t tag)
267
328
{
286
347
{
287
348
    SCSIDeviceState *s = d->state;
288
349
    uint64_t nb_sectors;
289
 
    uint32_t lba;
 
350
    uint64_t lba;
290
351
    uint32_t len;
291
352
    int cmdlen;
292
353
    int is_write;
308
369
    DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);
309
370
    switch (command >> 5) {
310
371
    case 0:
311
 
        lba = buf[3] | (buf[2] << 8) | ((buf[1] & 0x1f) << 16);
 
372
        lba = (uint64_t) buf[3] | ((uint64_t) buf[2] << 8) |
 
373
              (((uint64_t) buf[1] & 0x1f) << 16);
312
374
        len = buf[4];
313
375
        cmdlen = 6;
314
376
        break;
315
377
    case 1:
316
378
    case 2:
317
 
        lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 
379
        lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) |
 
380
              ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24);
318
381
        len = buf[8] | (buf[7] << 8);
319
382
        cmdlen = 10;
320
383
        break;
321
384
    case 4:
322
 
        lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 
385
        lba = (uint64_t) buf[9] | ((uint64_t) buf[8] << 8) |
 
386
              ((uint64_t) buf[7] << 16) | ((uint64_t) buf[6] << 24) |
 
387
              ((uint64_t) buf[5] << 32) | ((uint64_t) buf[4] << 40) |
 
388
              ((uint64_t) buf[3] << 48) | ((uint64_t) buf[2] << 56);
323
389
        len = buf[13] | (buf[12] << 8) | (buf[11] << 16) | (buf[10] << 24);
324
390
        cmdlen = 16;
325
391
        break;
326
392
    case 5:
327
 
        lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 
393
        lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) |
 
394
              ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24);
328
395
        len = buf[9] | (buf[8] << 8) | (buf[7] << 16) | (buf[6] << 24);
329
396
        cmdlen = 12;
330
397
        break;
344
411
    if (lun || buf[1] >> 5) {
345
412
        /* Only LUN 0 supported.  */
346
413
        DPRINTF("Unimplemented LUN %d\n", lun ? lun : buf[1] >> 5);
347
 
        goto fail;
 
414
        if (command != 0x03 && command != 0x12) /* REQUEST SENSE and INQUIRY */
 
415
            goto fail;
348
416
    }
349
417
    switch (command) {
350
418
    case 0x0:
362
430
        break;
363
431
    case 0x12:
364
432
        DPRINTF("Inquiry (len %d)\n", len);
365
 
        if (len < 36) {
366
 
            BADF("Inquiry buffer too small (%d)\n", len);
367
 
        }
368
 
        memset(outbuf, 0, 36);
369
 
        if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 
433
        if (buf[1] & 0x2) {
 
434
            /* Command support data - optional, not implemented */
 
435
            BADF("optional INQUIRY command support request not implemented\n");
 
436
            goto fail;
 
437
        }
 
438
        else if (buf[1] & 0x1) {
 
439
            /* Vital product data */
 
440
            uint8_t page_code = buf[2];
 
441
            if (len < 4) {
 
442
                BADF("Error: Inquiry (EVPD[%02X]) buffer size %d is "
 
443
                     "less than 4\n", page_code, len);
 
444
                goto fail;
 
445
            }
 
446
 
 
447
            switch (page_code) {
 
448
                case 0x00:
 
449
                    {
 
450
                        /* Supported page codes, mandatory */
 
451
                        DPRINTF("Inquiry EVPD[Supported pages] "
 
452
                                "buffer size %d\n", len);
 
453
 
 
454
                        r->buf_len = 0;
 
455
 
 
456
                        if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 
457
                            outbuf[r->buf_len++] = 5;
 
458
                        } else {
 
459
                            outbuf[r->buf_len++] = 0;
 
460
                        }
 
461
 
 
462
                        outbuf[r->buf_len++] = 0x00; // this page
 
463
                        outbuf[r->buf_len++] = 0x00;
 
464
                        outbuf[r->buf_len++] = 3;    // number of pages
 
465
                        outbuf[r->buf_len++] = 0x00; // list of supported pages (this page)
 
466
                        outbuf[r->buf_len++] = 0x80; // unit serial number
 
467
                        outbuf[r->buf_len++] = 0x83; // device identification
 
468
                    }
 
469
                    break;
 
470
                case 0x80:
 
471
                    {
 
472
                        int l;
 
473
 
 
474
                        /* Device serial number, optional */
 
475
                        if (len < 4) {
 
476
                            BADF("Error: EVPD[Serial number] Inquiry buffer "
 
477
                                 "size %d too small, %d needed\n", len, 4);
 
478
                            goto fail;
 
479
                        }
 
480
 
 
481
                        DPRINTF("Inquiry EVPD[Serial number] buffer size %d\n", len);
 
482
                        l = MIN(len, strlen(s->drive_serial_str));
 
483
 
 
484
                        r->buf_len = 0;
 
485
 
 
486
                        /* Supported page codes */
 
487
                        if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 
488
                            outbuf[r->buf_len++] = 5;
 
489
                        } else {
 
490
                            outbuf[r->buf_len++] = 0;
 
491
                        }
 
492
 
 
493
                        outbuf[r->buf_len++] = 0x80; // this page
 
494
                        outbuf[r->buf_len++] = 0x00;
 
495
                        outbuf[r->buf_len++] = l;
 
496
                        memcpy(&outbuf[r->buf_len], s->drive_serial_str, l);
 
497
                        r->buf_len += l;
 
498
                    }
 
499
 
 
500
                    break;
 
501
                case 0x83:
 
502
                    {
 
503
                        /* Device identification page, mandatory */
 
504
                        int max_len = 255 - 8;
 
505
                        int id_len = strlen(bdrv_get_device_name(s->bdrv));
 
506
                        if (id_len > max_len)
 
507
                            id_len = max_len;
 
508
 
 
509
                        DPRINTF("Inquiry EVPD[Device identification] "
 
510
                                "buffer size %d\n", len);
 
511
                        r->buf_len = 0;
 
512
                        if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 
513
                            outbuf[r->buf_len++] = 5;
 
514
                        } else {
 
515
                            outbuf[r->buf_len++] = 0;
 
516
                        }
 
517
 
 
518
                        outbuf[r->buf_len++] = 0x83; // this page
 
519
                        outbuf[r->buf_len++] = 0x00;
 
520
                        outbuf[r->buf_len++] = 3 + id_len;
 
521
 
 
522
                        outbuf[r->buf_len++] = 0x2; // ASCII
 
523
                        outbuf[r->buf_len++] = 0;   // not officially assigned
 
524
                        outbuf[r->buf_len++] = 0;   // reserved
 
525
                        outbuf[r->buf_len++] = id_len; // length of data following
 
526
 
 
527
                        memcpy(&outbuf[r->buf_len],
 
528
                               bdrv_get_device_name(s->bdrv), id_len);
 
529
                        r->buf_len += id_len;
 
530
                    }
 
531
                    break;
 
532
                default:
 
533
                    BADF("Error: unsupported Inquiry (EVPD[%02X]) "
 
534
                         "buffer size %d\n", page_code, len);
 
535
                    goto fail;
 
536
            }
 
537
            /* done with EVPD */
 
538
            break;
 
539
        }
 
540
        else {
 
541
            /* Standard INQUIRY data */
 
542
            if (buf[2] != 0) {
 
543
                BADF("Error: Inquiry (STANDARD) page or code "
 
544
                     "is non-zero [%02X]\n", buf[2]);
 
545
                goto fail;
 
546
            }
 
547
 
 
548
            /* PAGE CODE == 0 */
 
549
            if (len < 5) {
 
550
                BADF("Error: Inquiry (STANDARD) buffer size %d "
 
551
                     "is less than 5\n", len);
 
552
                goto fail;
 
553
            }
 
554
 
 
555
            if (len < 36) {
 
556
                BADF("Error: Inquiry (STANDARD) buffer size %d "
 
557
                     "is less than 36 (TODO: only 5 required)\n", len);
 
558
            }
 
559
        }
 
560
 
 
561
        if(len > SCSI_MAX_INQUIRY_LEN)
 
562
            len = SCSI_MAX_INQUIRY_LEN;
 
563
 
 
564
        memset(outbuf, 0, len);
 
565
 
 
566
        if (lun || buf[1] >> 5) {
 
567
            outbuf[0] = 0x7f;   /* LUN not supported */
 
568
        } else if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
370
569
            outbuf[0] = 5;
371
570
            outbuf[1] = 0x80;
372
571
            memcpy(&outbuf[16], "QEMU CD-ROM    ", 16);
380
579
           Some later commands are also implemented. */
381
580
        outbuf[2] = 3;
382
581
        outbuf[3] = 2; /* Format 2 */
383
 
        outbuf[4] = 31;
 
582
        outbuf[4] = len - 5; /* Additional Length = (Len - 1) - 4 */
384
583
        /* Sync data transfer and TCQ.  */
385
584
        outbuf[7] = 0x10 | (s->tcq ? 0x02 : 0);
386
 
        r->buf_len = 36;
 
585
        r->buf_len = len;
387
586
        break;
388
587
    case 0x16:
389
588
        DPRINTF("Reserve(6)\n");
411
610
                outbuf[2] = 0x80; /* Readonly.  */
412
611
            }
413
612
            p += 4;
414
 
            if ((page == 8 || page == 0x3f)) {
 
613
            if (page == 4) {
 
614
                int cylinders, heads, secs;
 
615
 
 
616
                /* Rigid disk device geometry page. */
 
617
                p[0] = 4;
 
618
                p[1] = 0x16;
 
619
                /* if a geometry hint is available, use it */
 
620
                bdrv_get_geometry_hint(s->bdrv, &cylinders, &heads, &secs);
 
621
                p[2] = (cylinders >> 16) & 0xff;
 
622
                p[3] = (cylinders >> 8) & 0xff;
 
623
                p[4] = cylinders & 0xff;
 
624
                p[5] = heads & 0xff;
 
625
                /* Write precomp start cylinder, disabled */
 
626
                p[6] = (cylinders >> 16) & 0xff;
 
627
                p[7] = (cylinders >> 8) & 0xff;
 
628
                p[8] = cylinders & 0xff;
 
629
                /* Reduced current start cylinder, disabled */
 
630
                p[9] = (cylinders >> 16) & 0xff;
 
631
                p[10] = (cylinders >> 8) & 0xff;
 
632
                p[11] = cylinders & 0xff;
 
633
                /* Device step rate [ns], 200ns */
 
634
                p[12] = 0;
 
635
                p[13] = 200;
 
636
                /* Landing zone cylinder */
 
637
                p[14] = 0xff;
 
638
                p[15] =  0xff;
 
639
                p[16] = 0xff;
 
640
                /* Medium rotation rate [rpm], 5400 rpm */
 
641
                p[20] = (5400 >> 8) & 0xff;
 
642
                p[21] = 5400 & 0xff;
 
643
                p += 0x16;
 
644
            } else if (page == 5) {
 
645
                int cylinders, heads, secs;
 
646
 
 
647
                /* Flexible disk device geometry page. */
 
648
                p[0] = 5;
 
649
                p[1] = 0x1e;
 
650
                /* Transfer rate [kbit/s], 5Mbit/s */
 
651
                p[2] = 5000 >> 8;
 
652
                p[3] = 5000 & 0xff;
 
653
                /* if a geometry hint is available, use it */
 
654
                bdrv_get_geometry_hint(s->bdrv, &cylinders, &heads, &secs);
 
655
                p[4] = heads & 0xff;
 
656
                p[5] = secs & 0xff;
 
657
                p[6] = s->cluster_size * 2;
 
658
                p[8] = (cylinders >> 8) & 0xff;
 
659
                p[9] = cylinders & 0xff;
 
660
                /* Write precomp start cylinder, disabled */
 
661
                p[10] = (cylinders >> 8) & 0xff;
 
662
                p[11] = cylinders & 0xff;
 
663
                /* Reduced current start cylinder, disabled */
 
664
                p[12] = (cylinders >> 8) & 0xff;
 
665
                p[13] = cylinders & 0xff;
 
666
                /* Device step rate [100us], 100us */
 
667
                p[14] = 0;
 
668
                p[15] = 1;
 
669
                /* Device step pulse width [us], 1us */
 
670
                p[16] = 1;
 
671
                /* Device head settle delay [100us], 100us */
 
672
                p[17] = 0;
 
673
                p[18] = 1;
 
674
                /* Motor on delay [0.1s], 0.1s */
 
675
                p[19] = 1;
 
676
                /* Motor off delay [0.1s], 0.1s */
 
677
                p[20] = 1;
 
678
                /* Medium rotation rate [rpm], 5400 rpm */
 
679
                p[28] = (5400 >> 8) & 0xff;
 
680
                p[29] = 5400 & 0xff;
 
681
                p += 0x1e;
 
682
            } else if ((page == 8 || page == 0x3f)) {
415
683
                /* Caching page.  */
416
684
                memset(p,0,20);
417
685
                p[0] = 8;
467
735
        /* The normal LEN field for this command is zero.  */
468
736
        memset(outbuf, 0, 8);
469
737
        bdrv_get_geometry(s->bdrv, &nb_sectors);
 
738
        nb_sectors /= s->cluster_size;
470
739
        /* Returned value is the address of the last sector.  */
471
740
        if (nb_sectors) {
472
741
            nb_sectors--;
 
742
            /* Remember the new size for read/write sanity checking. */
 
743
            s->max_lba = nb_sectors;
 
744
            /* Clip to 2TB, instead of returning capacity modulo 2TB. */
 
745
            if (nb_sectors > UINT32_MAX)
 
746
                nb_sectors = UINT32_MAX;
473
747
            outbuf[0] = (nb_sectors >> 24) & 0xff;
474
748
            outbuf[1] = (nb_sectors >> 16) & 0xff;
475
749
            outbuf[2] = (nb_sectors >> 8) & 0xff;
480
754
            outbuf[7] = 0;
481
755
            r->buf_len = 8;
482
756
        } else {
483
 
            scsi_command_complete(r, SENSE_NOT_READY);
 
757
            scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_NOT_READY);
484
758
            return 0;
485
759
        }
486
760
        break;
487
761
    case 0x08:
488
762
    case 0x28:
489
 
        DPRINTF("Read (sector %d, count %d)\n", lba, len);
 
763
    case 0x88:
 
764
        DPRINTF("Read (sector %lld, count %d)\n", lba, len);
 
765
        if (lba > s->max_lba)
 
766
            goto illegal_lba;
490
767
        r->sector = lba * s->cluster_size;
491
768
        r->sector_count = len * s->cluster_size;
492
769
        break;
493
770
    case 0x0a:
494
771
    case 0x2a:
495
 
        DPRINTF("Write (sector %d, count %d)\n", lba, len);
 
772
    case 0x8a:
 
773
        DPRINTF("Write (sector %lld, count %d)\n", lba, len);
 
774
        if (lba > s->max_lba)
 
775
            goto illegal_lba;
496
776
        r->sector = lba * s->cluster_size;
497
777
        r->sector_count = len * s->cluster_size;
498
778
        is_write = 1;
541
821
    case 0x46:
542
822
        DPRINTF("Get Configuration (rt %d, maxlen %d)\n", buf[1] & 3, len);
543
823
        memset(outbuf, 0, 8);
544
 
        /* ??? This shoud probably return much more information.  For now
 
824
        /* ??? This should probably return much more information.  For now
545
825
           just return the basic header indicating the CD-ROM profile.  */
546
826
        outbuf[7] = 8; // CD-ROM
547
827
        r->buf_len = 8;
556
836
        if (buf[1] & 3)
557
837
            goto fail;
558
838
        break;
 
839
    case 0x9e:
 
840
        /* Service Action In subcommands. */
 
841
        if ((buf[1] & 31) == 0x10) {
 
842
            DPRINTF("SAI READ CAPACITY(16)\n");
 
843
            memset(outbuf, 0, len);
 
844
            bdrv_get_geometry(s->bdrv, &nb_sectors);
 
845
            nb_sectors /= s->cluster_size;
 
846
            /* Returned value is the address of the last sector.  */
 
847
            if (nb_sectors) {
 
848
                nb_sectors--;
 
849
                /* Remember the new size for read/write sanity checking. */
 
850
                s->max_lba = nb_sectors;
 
851
                outbuf[0] = (nb_sectors >> 56) & 0xff;
 
852
                outbuf[1] = (nb_sectors >> 48) & 0xff;
 
853
                outbuf[2] = (nb_sectors >> 40) & 0xff;
 
854
                outbuf[3] = (nb_sectors >> 32) & 0xff;
 
855
                outbuf[4] = (nb_sectors >> 24) & 0xff;
 
856
                outbuf[5] = (nb_sectors >> 16) & 0xff;
 
857
                outbuf[6] = (nb_sectors >> 8) & 0xff;
 
858
                outbuf[7] = nb_sectors & 0xff;
 
859
                outbuf[8] = 0;
 
860
                outbuf[9] = 0;
 
861
                outbuf[10] = s->cluster_size * 2;
 
862
                outbuf[11] = 0;
 
863
                /* Protection, exponent and lowest lba field left blank. */
 
864
                r->buf_len = len;
 
865
            } else {
 
866
                scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_NOT_READY);
 
867
                return 0;
 
868
            }
 
869
            break;
 
870
        }
 
871
        DPRINTF("Unsupported Service Action In\n");
 
872
        goto fail;
559
873
    case 0xa0:
560
874
        DPRINTF("Report LUNs (len %d)\n", len);
561
875
        if (len < 16)
564
878
        outbuf[3] = 8;
565
879
        r->buf_len = 16;
566
880
        break;
 
881
    case 0x2f:
 
882
        DPRINTF("Verify (sector %d, count %d)\n", lba, len);
 
883
        break;
567
884
    default:
568
885
        DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);
569
886
    fail:
570
 
        scsi_command_complete(r, SENSE_ILLEGAL_REQUEST);
 
887
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_ILLEGAL_REQUEST);
571
888
        return 0;
 
889
    illegal_lba:
 
890
        scsi_command_complete(r, STATUS_CHECK_CONDITION, SENSE_HARDWARE_ERROR);
 
891
        return 0;
572
892
    }
573
893
    if (r->sector_count == 0 && r->buf_len == 0) {
574
 
        scsi_command_complete(r, SENSE_NO_SENSE);
 
894
        scsi_command_complete(r, STATUS_GOOD, SENSE_NO_SENSE);
575
895
    }
576
896
    len = r->sector_count * 512 + r->buf_len;
577
897
    if (is_write) {
594
914
{
595
915
    SCSIDevice *d;
596
916
    SCSIDeviceState *s;
 
917
    uint64_t nb_sectors;
597
918
 
598
919
    s = (SCSIDeviceState *)qemu_mallocz(sizeof(SCSIDeviceState));
599
920
    s->bdrv = bdrv;
605
926
    } else {
606
927
        s->cluster_size = 1;
607
928
    }
608
 
 
 
929
    bdrv_get_geometry(s->bdrv, &nb_sectors);
 
930
    nb_sectors /= s->cluster_size;
 
931
    if (nb_sectors)
 
932
        nb_sectors--;
 
933
    s->max_lba = nb_sectors;
 
934
    strncpy(s->drive_serial_str, drive_get_serial(s->bdrv),
 
935
            sizeof(s->drive_serial_str));
 
936
    if (strlen(s->drive_serial_str) == 0)
 
937
        pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), "0");
 
938
    qemu_add_vm_change_state_handler(scsi_dma_restart_cb, s);
609
939
    d = (SCSIDevice *)qemu_mallocz(sizeof(SCSIDevice));
610
940
    d->state = s;
611
941
    d->destroy = scsi_destroy;