Archipelago » qemu

int is_windows_drive(const char *filename);

#endif

#endif /* BLOCK_INT_H */

    ide_clear_hob(bus);

}

{

    int cylinders, heads, secs;

    uint64_t nb_sectors;

        }

        strncpy(s->drive_serial_str, drive_get_serial(s->bs),

                sizeof(s->drive_serial_str));

    }

    if (strlen(s->drive_serial_str) == 0)

        snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),

        s->sector_write_timer = qemu_new_timer(vm_clock,

                                               ide_sector_write_timer_cb, s);

        if (i == 0)

        if (i == 1)

    }

    bus->irq = irq;

}

 * non-internal declarations are in hw/ide.h

 */

#include <hw/ide.h>

/* debug IDE devices */

//#define DEBUG_IDE

    /* set for lba48 access */

    uint8_t lba48;

    BlockDriverState *bs;

    char version[9];

    /* ATAPI specific */

    uint8_t sense_key;

struct IDEDevice {

    DeviceState qdev;

    uint32_t unit;

    char *version;

};

void ide_data_writel(void *opaque, uint32_t addr, uint32_t val);

uint32_t ide_data_readl(void *opaque, uint32_t addr);

void ide_init2(IDEBus *bus, DriveInfo *hd0, DriveInfo *hd1,

               qemu_irq irq);

void ide_init_ioport(IDEBus *bus, int iobase, int iobase2);

    IDEDeviceInfo *info = DO_UPCAST(IDEDeviceInfo, qdev, base);

    IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus);

        fprintf(stderr, "%s: no drive specified\n", qdev->info->name);

        goto err;

    }

static int ide_drive_initfn(IDEDevice *dev)

{

    IDEBus *bus = DO_UPCAST(IDEBus, qbus, dev->qdev.parent_bus);

    return 0;

}

    .init       = ide_drive_initfn,

    .qdev.props = (Property[]) {

        DEFINE_PROP_UINT32("unit", IDEDrive, dev.unit, -1),

        DEFINE_PROP_STRING("ver",  IDEDrive, dev.version),

        DEFINE_PROP_END_OF_LIST(),

    }

{

    VirtIODevice *vdev;

    if (!vdev) {

        return -1;

    }

    .qdev.name = "virtio-blk-s390",

    .qdev.size = sizeof(VirtIOS390Device),

    .qdev.props = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

    ram_addr_t feat_offs;

    uint8_t feat_len;

    VirtIODevice *vdev;

    NICConf nic;

    uint32_t host_features;

    /* Max. number of ports we can have for a the virtio-serial device */

struct SCSIDiskState

{

    SCSIDevice qdev;

    /* The qemu block layer uses a fixed 512 byte sector size.

       This is the number of 512 byte blocks in a single scsi sector.  */

    int cluster_size;

    r->iov.iov_len = n * 512;

    qemu_iovec_init_external(&r->qiov, &r->iov, 1);

                              scsi_read_complete, r);

    if (r->req.aiocb == NULL)

        scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR);

static int scsi_handle_write_error(SCSIDiskReq *r, int error)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);

    if (action == BLOCK_ERR_IGNORE) {

        return 0;

    }

            || action == BLOCK_ERR_STOP_ANY) {

        r->status |= SCSI_REQ_STATUS_RETRY;

        vm_stop(0);

    } else {

        scsi_command_complete(r, CHECK_CONDITION,

                HARDWARE_ERROR);

    }

    return 1;

    n = r->iov.iov_len / 512;

    if (n) {

        qemu_iovec_init_external(&r->qiov, &r->iov, 1);

                                   scsi_write_complete, r);

        if (r->req.aiocb == NULL)

            scsi_command_complete(r, CHECK_CONDITION,

static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);

    int buflen = 0;

            return -1;

        }

            outbuf[buflen++] = 5;

        } else {

            outbuf[buflen++] = 0;

        case 0x80: /* Device serial number, optional */

        {

            int l = strlen(serial);

            if (l > req->cmd.xfer)

        case 0x83: /* Device identification page, mandatory */

        {

            int max_len = 255 - 8;

            if (id_len > max_len)

                id_len = max_len;

            outbuf[buflen++] = 0;   // reserved

            outbuf[buflen++] = id_len; // length of data following

            buflen += id_len;

            break;

        }

        return buflen;

    }

        outbuf[0] = 5;

        outbuf[1] = 0x80;

        memcpy(&outbuf[16], "QEMU CD-ROM     ", 16);

static int mode_sense_page(SCSIRequest *req, int page, uint8_t *p)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);

    int cylinders, heads, secs;

    switch (page) {

    case 8: /* Caching page.  */

        p[0] = 8;

        p[1] = 0x12;

            p[2] = 4; /* WCE */

        }

        return 20;

        p[5] = 0xff; /* CD DA, DA accurate, RW supported,

                        RW corrected, C2 errors, ISRC,

                        UPC, Bar code */

        /* Locking supported, jumper present, eject, tray */

        p[7] = 0; /* no volume & mute control, no

                     changer */

static int scsi_disk_emulate_mode_sense(SCSIRequest *req, uint8_t *outbuf)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);

    uint64_t nb_sectors;

    int page, dbd, buflen;

    uint8_t *p;

    p[1] = 0; /* Default media type.  */

    p[3] = 0; /* Block descriptor length.  */

        p[2] = 0x80; /* Readonly.  */

    }

    p += 4;

    if ((~dbd) & nb_sectors) {

        outbuf[3] = 8; /* Block descriptor length  */

        nb_sectors /= s->cluster_size;

static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);

    int start_track, format, msf, toclen;

    uint64_t nb_sectors;

    msf = req->cmd.buf[1] & 2;

    format = req->cmd.buf[2] & 0xf;

    start_track = req->cmd.buf[6];

    DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1);

    nb_sectors /= s->cluster_size;

    switch (format) {

static int scsi_disk_emulate_command(SCSIRequest *req, uint8_t *outbuf)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);

    uint64_t nb_sectors;

    int buflen = 0;

    switch (req->cmd.buf[0]) {

    case TEST_UNIT_READY:

            goto not_ready;

	break;

    case REQUEST_SENSE:

            goto illegal_request;

        break;

    case START_STOP:

            /* load/eject medium */

        }

	break;

    case ALLOW_MEDIUM_REMOVAL:

	break;

    case READ_CAPACITY:

        /* The normal LEN field for this command is zero.  */

	memset(outbuf, 0, 8);

        if (!nb_sectors)

            goto not_ready;

        nb_sectors /= s->cluster_size;

        buflen = 8;

	break;

    case SYNCHRONIZE_CACHE:

        break;

    case GET_CONFIGURATION:

        memset(outbuf, 0, 8);

        if ((req->cmd.buf[1] & 31) == 0x10) {

            DPRINTF("SAI READ CAPACITY(16)\n");

            memset(outbuf, 0, req->cmd.xfer);

            if (!nb_sectors)

                goto not_ready;

            nb_sectors /= s->cluster_size;

        r = DO_UPCAST(SCSIDiskReq, req, QTAILQ_FIRST(&s->qdev.requests));

        scsi_remove_request(r);

    }

}

static int scsi_disk_initfn(SCSIDevice *dev)

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);

    uint64_t nb_sectors;

        qemu_error("scsi-disk: drive property not set\n");

        return -1;

    }

        s->cluster_size = 4;

    } else {

        s->cluster_size = 1;

    }

    s->qdev.blocksize = 512 * s->cluster_size;

    s->qdev.type = TYPE_DISK;

    nb_sectors /= s->cluster_size;

    if (nb_sectors)

        nb_sectors--;

    .cancel_io    = scsi_cancel_io,

    .get_buf      = scsi_get_buf,

    .qdev.props   = (Property[]) {

        DEFINE_PROP_STRING("ver",  SCSIDiskState, version),

        DEFINE_PROP_END_OF_LIST(),

    },

struct SCSIGenericState

{

    SCSIDevice qdev;

    int lun;

    int driver_status;

    uint8_t sensebuf[SCSI_SENSE_BUF_SIZE];

        return;

    }

    if (ret == -1) {

        scsi_command_complete(r, -EINVAL);

        return;

        return 0;

    }

    if (ret == -1) {

        scsi_command_complete(r, -EINVAL);

        return 1;

            qemu_free(r->buf);

        r->buflen = 0;

        r->buf = NULL;

        if (ret == -1) {

            scsi_command_complete(r, -EINVAL);

            return 0;

        r = DO_UPCAST(SCSIGenericReq, req, QTAILQ_FIRST(&s->qdev.requests));

        scsi_remove_request(r);

    }

}

static int scsi_generic_initfn(SCSIDevice *dev)

    int sg_version;

    struct sg_scsi_id scsiid;

        qemu_error("scsi-generic: drive property not set\n");

        return -1;

    }

    /* check we are really using a /dev/sg* file */

        qemu_error("scsi-generic: not /dev/sg*\n");

        return -1;

    }

    /* check we are using a driver managing SG_IO (version 3 and after */

        sg_version < 30000) {

        qemu_error("scsi-generic: scsi generic interface too old\n");

        return -1;

    }

    /* get LUN of the /dev/sg? */

        qemu_error("scsi-generic: SG_GET_SCSI_ID ioctl failed\n");

        return -1;

    }

    s->qdev.type = scsiid.scsi_type;

    DPRINTF("device type %d\n", s->qdev.type);

    if (s->qdev.type == TYPE_TAPE) {

        if (s->qdev.blocksize == -1)

            s->qdev.blocksize = 0;

    } else {

        /* removable media returns 0 if not present */

        if (s->qdev.blocksize <= 0) {

            if (s->qdev.type == TYPE_ROM || s->qdev.type  == TYPE_WORM)

    .cancel_io    = scsi_cancel_io,

    .get_buf      = scsi_get_buf,

    .qdev.props   = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

#include "qdev.h"

#include "block.h"

#define SCSI_CMD_BUF_SIZE     16

{

    DeviceState qdev;

    uint32_t id;

    SCSIDeviceInfo *info;

    QTAILQ_HEAD(, SCSIRequest) requests;

    int blocksize;

    uint32_t residue;

    uint32_t tag;

    SCSIBus bus;

    SCSIDevice *scsi_dev;

    int result;

    /* For async completion.  */

{

    MSDState *s = DO_UPCAST(MSDState, dev, dev);

        qemu_error("usb-msd: drive property not set\n");

        return -1;

    }

    s->dev.speed = USB_SPEED_FULL;

    scsi_bus_new(&s->bus, &s->dev.qdev, 0, 1, usb_msd_command_complete);

    s->bus.qbus.allow_hotplug = 0;

    usb_msd_handle_reset(dev);

        if (s->dev.qdev.hotplugged) {

                                        usb_msd_password_cb, s);

            s->dev.auto_attach = 0;

        } else {

    .usbdevice_name = "disk",

    .usbdevice_init = usb_msd_init,

    .qdev.props     = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

    return 0;

}

{

    VirtIOBlock *s;

    int cylinders, heads, secs;

    s->vdev.get_config = virtio_blk_update_config;

    s->vdev.get_features = virtio_blk_get_features;

    s->vdev.reset = virtio_blk_reset;

    s->rq = NULL;

    bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);

    bdrv_set_geometry_hint(s->bs, cylinders, heads, secs);

#include "sysemu.h"

#include "msix.h"

#include "net.h"

#include "loader.h"

/* from Linux's linux/virtio_pci.h */

    uint32_t addr;

    uint32_t class_code;

    uint32_t nvectors;

    NICConf nic;

    uint32_t host_features;

    /* Max. number of ports we can have for a the virtio-serial device */

        proxy->class_code != PCI_CLASS_STORAGE_OTHER)

        proxy->class_code = PCI_CLASS_STORAGE_SCSI;

        qemu_error("virtio-blk-pci: drive property not set\n");

        return -1;

    }

    vdev->nvectors = proxy->nvectors;

    virtio_init_pci(proxy, vdev,

                    PCI_VENDOR_ID_REDHAT_QUMRANET,

{

    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);

    return virtio_exit_pci(pci_dev);

}

        .exit      = virtio_blk_exit_pci,

        .qdev.props = (Property[]) {

            DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),

            DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),

            DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),

            DEFINE_PROP_END_OF_LIST(),

#include "net.h"

#include "qdev.h"

#include "sysemu.h"

/* from Linux's linux/virtio_config.h */

                        void *opaque);

/* Base devices.  */

VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf);

VirtIODevice *virtio_serial_init(DeviceState *dev, uint32_t max_nr_ports);

VirtIODevice *virtio_balloon_init(DeviceState *dev);