cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

bus.c (20513B)

      1#include "qemu/osdep.h"
      2#include "hw/qdev-properties.h"
      3#include "hw/usb.h"
      4#include "qapi/error.h"
      5#include "qemu/error-report.h"
      6#include "qemu/module.h"
      7#include "sysemu/sysemu.h"
      8#include "migration/vmstate.h"
      9#include "monitor/monitor.h"
     10#include "trace.h"
     11#include "qemu/cutils.h"
     12
     13static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
     14
     15static char *usb_get_dev_path(DeviceState *dev);
     16static char *usb_get_fw_dev_path(DeviceState *qdev);
     17static void usb_qdev_unrealize(DeviceState *qdev);
     18
     19static Property usb_props[] = {
     20    DEFINE_PROP_STRING("port", USBDevice, port_path),
     21    DEFINE_PROP_STRING("serial", USBDevice, serial),
     22    DEFINE_PROP_BIT("msos-desc", USBDevice, flags,
     23                    USB_DEV_FLAG_MSOS_DESC_ENABLE, true),
     24    DEFINE_PROP_STRING("pcap", USBDevice, pcap_filename),
     25    DEFINE_PROP_END_OF_LIST()
     26};
     27
     28static void usb_bus_class_init(ObjectClass *klass, void *data)
     29{
     30    BusClass *k = BUS_CLASS(klass);
     31    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
     32
     33    k->print_dev = usb_bus_dev_print;
     34    k->get_dev_path = usb_get_dev_path;
     35    k->get_fw_dev_path = usb_get_fw_dev_path;
     36    hc->unplug = qdev_simple_device_unplug_cb;
     37}
     38
     39static const TypeInfo usb_bus_info = {
     40    .name = TYPE_USB_BUS,
     41    .parent = TYPE_BUS,
     42    .instance_size = sizeof(USBBus),
     43    .class_init = usb_bus_class_init,
     44    .interfaces = (InterfaceInfo[]) {
     45        { TYPE_HOTPLUG_HANDLER },
     46        { }
     47    }
     48};
     49
     50static int next_usb_bus = 0;
     51static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
     52
     53static int usb_device_post_load(void *opaque, int version_id)
     54{
     55    USBDevice *dev = opaque;
     56
     57    if (dev->state == USB_STATE_NOTATTACHED) {
     58        dev->attached = false;
     59    } else {
     60        dev->attached = true;
     61    }
     62    return 0;
     63}
     64
     65const VMStateDescription vmstate_usb_device = {
     66    .name = "USBDevice",
     67    .version_id = 1,
     68    .minimum_version_id = 1,
     69    .post_load = usb_device_post_load,
     70    .fields = (VMStateField[]) {
     71        VMSTATE_UINT8(addr, USBDevice),
     72        VMSTATE_INT32(state, USBDevice),
     73        VMSTATE_INT32(remote_wakeup, USBDevice),
     74        VMSTATE_INT32(setup_state, USBDevice),
     75        VMSTATE_INT32(setup_len, USBDevice),
     76        VMSTATE_INT32(setup_index, USBDevice),
     77        VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
     78        VMSTATE_END_OF_LIST(),
     79    }
     80};
     81
     82void usb_bus_new(USBBus *bus, size_t bus_size,
     83                 USBBusOps *ops, DeviceState *host)
     84{
     85    qbus_init(bus, bus_size, TYPE_USB_BUS, host, NULL);
     86    qbus_set_bus_hotplug_handler(BUS(bus));
     87    bus->ops = ops;
     88    bus->busnr = next_usb_bus++;
     89    QTAILQ_INIT(&bus->free);
     90    QTAILQ_INIT(&bus->used);
     91    QTAILQ_INSERT_TAIL(&busses, bus, next);
     92}
     93
     94void usb_bus_release(USBBus *bus)
     95{
     96    assert(next_usb_bus > 0);
     97
     98    QTAILQ_REMOVE(&busses, bus, next);
     99}
    100
    101USBBus *usb_bus_find(int busnr)
    102{
    103    USBBus *bus;
    104
    105    if (-1 == busnr)
    106        return QTAILQ_FIRST(&busses);
    107    QTAILQ_FOREACH(bus, &busses, next) {
    108        if (bus->busnr == busnr)
    109            return bus;
    110    }
    111    return NULL;
    112}
    113
    114static void usb_device_realize(USBDevice *dev, Error **errp)
    115{
    116    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    117
    118    if (klass->realize) {
    119        klass->realize(dev, errp);
    120    }
    121}
    122
    123USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
    124{
    125    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    126    if (klass->find_device) {
    127        return klass->find_device(dev, addr);
    128    }
    129    return NULL;
    130}
    131
    132static void usb_device_unrealize(USBDevice *dev)
    133{
    134    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    135
    136    if (klass->unrealize) {
    137        klass->unrealize(dev);
    138    }
    139}
    140
    141void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
    142{
    143    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    144    if (klass->cancel_packet) {
    145        klass->cancel_packet(dev, p);
    146    }
    147}
    148
    149void usb_device_handle_attach(USBDevice *dev)
    150{
    151    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    152    if (klass->handle_attach) {
    153        klass->handle_attach(dev);
    154    }
    155}
    156
    157void usb_device_handle_reset(USBDevice *dev)
    158{
    159    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    160    if (klass->handle_reset) {
    161        klass->handle_reset(dev);
    162    }
    163}
    164
    165void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
    166                               int value, int index, int length, uint8_t *data)
    167{
    168    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    169    if (klass->handle_control) {
    170        klass->handle_control(dev, p, request, value, index, length, data);
    171    }
    172}
    173
    174void usb_device_handle_data(USBDevice *dev, USBPacket *p)
    175{
    176    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    177    if (klass->handle_data) {
    178        klass->handle_data(dev, p);
    179    }
    180}
    181
    182const char *usb_device_get_product_desc(USBDevice *dev)
    183{
    184    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    185    return klass->product_desc;
    186}
    187
    188const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
    189{
    190    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    191    if (dev->usb_desc) {
    192        return dev->usb_desc;
    193    }
    194    return klass->usb_desc;
    195}
    196
    197void usb_device_set_interface(USBDevice *dev, int interface,
    198                              int alt_old, int alt_new)
    199{
    200    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    201    if (klass->set_interface) {
    202        klass->set_interface(dev, interface, alt_old, alt_new);
    203    }
    204}
    205
    206void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
    207{
    208    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    209    if (klass->flush_ep_queue) {
    210        klass->flush_ep_queue(dev, ep);
    211    }
    212}
    213
    214void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
    215{
    216    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    217    if (klass->ep_stopped) {
    218        klass->ep_stopped(dev, ep);
    219    }
    220}
    221
    222int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
    223                             int streams)
    224{
    225    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    226    if (klass->alloc_streams) {
    227        return klass->alloc_streams(dev, eps, nr_eps, streams);
    228    }
    229    return 0;
    230}
    231
    232void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
    233{
    234    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    235    if (klass->free_streams) {
    236        klass->free_streams(dev, eps, nr_eps);
    237    }
    238}
    239
    240static void usb_qdev_realize(DeviceState *qdev, Error **errp)
    241{
    242    USBDevice *dev = USB_DEVICE(qdev);
    243    Error *local_err = NULL;
    244
    245    pstrcpy(dev->product_desc, sizeof(dev->product_desc),
    246            usb_device_get_product_desc(dev));
    247    dev->auto_attach = 1;
    248    QLIST_INIT(&dev->strings);
    249    usb_ep_init(dev);
    250
    251    usb_claim_port(dev, &local_err);
    252    if (local_err) {
    253        error_propagate(errp, local_err);
    254        return;
    255    }
    256
    257    usb_device_realize(dev, &local_err);
    258    if (local_err) {
    259        usb_release_port(dev);
    260        error_propagate(errp, local_err);
    261        return;
    262    }
    263
    264    if (dev->auto_attach) {
    265        usb_device_attach(dev, &local_err);
    266        if (local_err) {
    267            usb_qdev_unrealize(qdev);
    268            error_propagate(errp, local_err);
    269            return;
    270        }
    271    }
    272
    273    if (dev->pcap_filename) {
    274        int fd = qemu_open_old(dev->pcap_filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
    275        if (fd < 0) {
    276            error_setg(errp, "open %s failed", dev->pcap_filename);
    277            usb_qdev_unrealize(qdev);
    278            return;
    279        }
    280        dev->pcap = fdopen(fd, "w");
    281        usb_pcap_init(dev->pcap);
    282    }
    283}
    284
    285static void usb_qdev_unrealize(DeviceState *qdev)
    286{
    287    USBDevice *dev = USB_DEVICE(qdev);
    288    USBDescString *s, *next;
    289
    290    QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
    291        QLIST_REMOVE(s, next);
    292        g_free(s->str);
    293        g_free(s);
    294    }
    295
    296    if (dev->pcap) {
    297        fclose(dev->pcap);
    298    }
    299
    300    if (dev->attached) {
    301        usb_device_detach(dev);
    302    }
    303    usb_device_unrealize(dev);
    304    if (dev->port) {
    305        usb_release_port(dev);
    306    }
    307}
    308
    309typedef struct LegacyUSBFactory
    310{
    311    const char *name;
    312    const char *usbdevice_name;
    313    USBDevice *(*usbdevice_init)(void);
    314} LegacyUSBFactory;
    315
    316static GSList *legacy_usb_factory;
    317
    318void usb_legacy_register(const char *typename, const char *usbdevice_name,
    319                         USBDevice *(*usbdevice_init)(void))
    320{
    321    if (usbdevice_name) {
    322        LegacyUSBFactory *f = g_malloc0(sizeof(*f));
    323        f->name = typename;
    324        f->usbdevice_name = usbdevice_name;
    325        f->usbdevice_init = usbdevice_init;
    326        legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
    327    }
    328}
    329
    330USBDevice *usb_new(const char *name)
    331{
    332    return USB_DEVICE(qdev_new(name));
    333}
    334
    335static USBDevice *usb_try_new(const char *name)
    336{
    337    return USB_DEVICE(qdev_try_new(name));
    338}
    339
    340bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
    341{
    342    return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
    343}
    344
    345USBDevice *usb_create_simple(USBBus *bus, const char *name)
    346{
    347    USBDevice *dev = usb_new(name);
    348
    349    usb_realize_and_unref(dev, bus, &error_abort);
    350    return dev;
    351}
    352
    353static void usb_fill_port(USBPort *port, void *opaque, int index,
    354                          USBPortOps *ops, int speedmask)
    355{
    356    port->opaque = opaque;
    357    port->index = index;
    358    port->ops = ops;
    359    port->speedmask = speedmask;
    360    usb_port_location(port, NULL, index + 1);
    361}
    362
    363void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
    364                       USBPortOps *ops, int speedmask)
    365{
    366    usb_fill_port(port, opaque, index, ops, speedmask);
    367    QTAILQ_INSERT_TAIL(&bus->free, port, next);
    368    bus->nfree++;
    369}
    370
    371void usb_register_companion(const char *masterbus, USBPort *ports[],
    372                            uint32_t portcount, uint32_t firstport,
    373                            void *opaque, USBPortOps *ops, int speedmask,
    374                            Error **errp)
    375{
    376    USBBus *bus;
    377    int i;
    378
    379    QTAILQ_FOREACH(bus, &busses, next) {
    380        if (strcmp(bus->qbus.name, masterbus) == 0) {
    381            break;
    382        }
    383    }
    384
    385    if (!bus) {
    386        error_setg(errp, "USB bus '%s' not found", masterbus);
    387        return;
    388    }
    389    if (!bus->ops->register_companion) {
    390        error_setg(errp, "Can't use USB bus '%s' as masterbus,"
    391                   " it doesn't support companion controllers",
    392                   masterbus);
    393        return;
    394    }
    395
    396    for (i = 0; i < portcount; i++) {
    397        usb_fill_port(ports[i], opaque, i, ops, speedmask);
    398    }
    399
    400    bus->ops->register_companion(bus, ports, portcount, firstport, errp);
    401}
    402
    403void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
    404{
    405    if (upstream) {
    406        int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
    407                         upstream->path, portnr);
    408        /* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
    409        assert(l < sizeof(downstream->path));
    410        downstream->hubcount = upstream->hubcount + 1;
    411    } else {
    412        snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
    413        downstream->hubcount = 0;
    414    }
    415}
    416
    417void usb_unregister_port(USBBus *bus, USBPort *port)
    418{
    419    if (port->dev) {
    420        object_unparent(OBJECT(port->dev));
    421    }
    422    QTAILQ_REMOVE(&bus->free, port, next);
    423    bus->nfree--;
    424}
    425
    426void usb_claim_port(USBDevice *dev, Error **errp)
    427{
    428    USBBus *bus = usb_bus_from_device(dev);
    429    USBPort *port;
    430    USBDevice *hub;
    431
    432    assert(dev->port == NULL);
    433
    434    if (dev->port_path) {
    435        QTAILQ_FOREACH(port, &bus->free, next) {
    436            if (strcmp(port->path, dev->port_path) == 0) {
    437                break;
    438            }
    439        }
    440        if (port == NULL) {
    441            error_setg(errp, "usb port %s (bus %s) not found (in use?)",
    442                       dev->port_path, bus->qbus.name);
    443            return;
    444        }
    445    } else {
    446        if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
    447            /* Create a new hub and chain it on */
    448            hub = usb_try_new("usb-hub");
    449            if (hub) {
    450                usb_realize_and_unref(hub, bus, NULL);
    451            }
    452        }
    453        if (bus->nfree == 0) {
    454            error_setg(errp, "tried to attach usb device %s to a bus "
    455                       "with no free ports", dev->product_desc);
    456            return;
    457        }
    458        port = QTAILQ_FIRST(&bus->free);
    459    }
    460    trace_usb_port_claim(bus->busnr, port->path);
    461
    462    QTAILQ_REMOVE(&bus->free, port, next);
    463    bus->nfree--;
    464
    465    dev->port = port;
    466    port->dev = dev;
    467
    468    QTAILQ_INSERT_TAIL(&bus->used, port, next);
    469    bus->nused++;
    470}
    471
    472void usb_release_port(USBDevice *dev)
    473{
    474    USBBus *bus = usb_bus_from_device(dev);
    475    USBPort *port = dev->port;
    476
    477    assert(port != NULL);
    478    trace_usb_port_release(bus->busnr, port->path);
    479
    480    QTAILQ_REMOVE(&bus->used, port, next);
    481    bus->nused--;
    482
    483    dev->port = NULL;
    484    port->dev = NULL;
    485
    486    QTAILQ_INSERT_TAIL(&bus->free, port, next);
    487    bus->nfree++;
    488}
    489
    490static void usb_mask_to_str(char *dest, size_t size,
    491                            unsigned int speedmask)
    492{
    493    static const struct {
    494        unsigned int mask;
    495        const char *name;
    496    } speeds[] = {
    497        { .mask = USB_SPEED_MASK_FULL,  .name = "full"  },
    498        { .mask = USB_SPEED_MASK_HIGH,  .name = "high"  },
    499        { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
    500    };
    501    int i, pos = 0;
    502
    503    for (i = 0; i < ARRAY_SIZE(speeds); i++) {
    504        if (speeds[i].mask & speedmask) {
    505            pos += snprintf(dest + pos, size - pos, "%s%s",
    506                            pos ? "+" : "",
    507                            speeds[i].name);
    508        }
    509    }
    510
    511    if (pos == 0) {
    512        snprintf(dest, size, "unknown");
    513    }
    514}
    515
    516void usb_check_attach(USBDevice *dev, Error **errp)
    517{
    518    USBBus *bus = usb_bus_from_device(dev);
    519    USBPort *port = dev->port;
    520    char devspeed[32], portspeed[32];
    521
    522    assert(port != NULL);
    523    assert(!dev->attached);
    524    usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
    525    usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
    526    trace_usb_port_attach(bus->busnr, port->path,
    527                          devspeed, portspeed);
    528
    529    if (!(port->speedmask & dev->speedmask)) {
    530        error_setg(errp, "Warning: speed mismatch trying to attach"
    531                   " usb device \"%s\" (%s speed)"
    532                   " to bus \"%s\", port \"%s\" (%s speed)",
    533                   dev->product_desc, devspeed,
    534                   bus->qbus.name, port->path, portspeed);
    535        return;
    536    }
    537}
    538
    539void usb_device_attach(USBDevice *dev, Error **errp)
    540{
    541    USBPort *port = dev->port;
    542    Error *local_err = NULL;
    543
    544    usb_check_attach(dev, &local_err);
    545    if (local_err) {
    546        error_propagate(errp, local_err);
    547        return;
    548    }
    549
    550    dev->attached = true;
    551    usb_attach(port);
    552}
    553
    554int usb_device_detach(USBDevice *dev)
    555{
    556    USBBus *bus = usb_bus_from_device(dev);
    557    USBPort *port = dev->port;
    558
    559    assert(port != NULL);
    560    assert(dev->attached);
    561    trace_usb_port_detach(bus->busnr, port->path);
    562
    563    usb_detach(port);
    564    dev->attached = false;
    565    return 0;
    566}
    567
    568static const char *usb_speed(unsigned int speed)
    569{
    570    static const char *txt[] = {
    571        [ USB_SPEED_LOW  ] = "1.5",
    572        [ USB_SPEED_FULL ] = "12",
    573        [ USB_SPEED_HIGH ] = "480",
    574        [ USB_SPEED_SUPER ] = "5000",
    575    };
    576    if (speed >= ARRAY_SIZE(txt))
    577        return "?";
    578    return txt[speed];
    579}
    580
    581static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
    582{
    583    USBDevice *dev = USB_DEVICE(qdev);
    584    USBBus *bus = usb_bus_from_device(dev);
    585
    586    monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
    587                   indent, "", bus->busnr, dev->addr,
    588                   dev->port ? dev->port->path : "-",
    589                   usb_speed(dev->speed), dev->product_desc,
    590                   dev->attached ? ", attached" : "");
    591}
    592
    593static char *usb_get_dev_path(DeviceState *qdev)
    594{
    595    USBDevice *dev = USB_DEVICE(qdev);
    596    DeviceState *hcd = qdev->parent_bus->parent;
    597    char *id = qdev_get_dev_path(hcd);
    598
    599    if (id) {
    600        char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
    601        g_free(id);
    602        return ret;
    603    } else {
    604        return g_strdup(dev->port->path);
    605    }
    606}
    607
    608static char *usb_get_fw_dev_path(DeviceState *qdev)
    609{
    610    USBDevice *dev = USB_DEVICE(qdev);
    611    char *fw_path, *in;
    612    ssize_t pos = 0, fw_len;
    613    long nr;
    614
    615    fw_len = 32 + strlen(dev->port->path) * 6;
    616    fw_path = g_malloc(fw_len);
    617    in = dev->port->path;
    618    while (fw_len - pos > 0) {
    619        nr = strtol(in, &in, 10);
    620        if (in[0] == '.') {
    621            /* some hub between root port and device */
    622            pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
    623            in++;
    624        } else {
    625            /* the device itself */
    626            snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
    627                     qdev_fw_name(qdev), nr);
    628            break;
    629        }
    630    }
    631    return fw_path;
    632}
    633
    634void hmp_info_usb(Monitor *mon, const QDict *qdict)
    635{
    636    USBBus *bus;
    637    USBDevice *dev;
    638    USBPort *port;
    639
    640    if (QTAILQ_EMPTY(&busses)) {
    641        monitor_printf(mon, "USB support not enabled\n");
    642        return;
    643    }
    644
    645    QTAILQ_FOREACH(bus, &busses, next) {
    646        QTAILQ_FOREACH(port, &bus->used, next) {
    647            dev = port->dev;
    648            if (!dev)
    649                continue;
    650            monitor_printf(mon, "  Device %d.%d, Port %s, Speed %s Mb/s, "
    651                           "Product %s%s%s\n",
    652                           bus->busnr, dev->addr, port->path,
    653                           usb_speed(dev->speed), dev->product_desc,
    654                           dev->qdev.id ? ", ID: " : "",
    655                           dev->qdev.id ?: "");
    656        }
    657    }
    658}
    659
    660/* handle legacy -usbdevice cmd line option */
    661USBDevice *usbdevice_create(const char *driver)
    662{
    663    USBBus *bus = usb_bus_find(-1 /* any */);
    664    LegacyUSBFactory *f = NULL;
    665    Error *err = NULL;
    666    GSList *i;
    667    USBDevice *dev;
    668
    669    if (strchr(driver, ':')) {
    670        error_report("usbdevice parameters are not supported anymore");
    671        return NULL;
    672    }
    673
    674    for (i = legacy_usb_factory; i; i = i->next) {
    675        f = i->data;
    676        if (strcmp(f->usbdevice_name, driver) == 0) {
    677            break;
    678        }
    679    }
    680    if (i == NULL) {
    681#if 0
    682        /* no error because some drivers are not converted (yet) */
    683        error_report("usbdevice %s not found", driver);
    684#endif
    685        return NULL;
    686    }
    687
    688    if (!bus) {
    689        error_report("Error: no usb bus to attach usbdevice %s, "
    690                     "please try -machine usb=on and check that "
    691                     "the machine model supports USB", driver);
    692        return NULL;
    693    }
    694
    695    dev = f->usbdevice_init ? f->usbdevice_init() : usb_new(f->name);
    696    if (!dev) {
    697        error_report("Failed to create USB device '%s'", f->name);
    698        return NULL;
    699    }
    700    if (!usb_realize_and_unref(dev, bus, &err)) {
    701        error_reportf_err(err, "Failed to initialize USB device '%s': ",
    702                          f->name);
    703        object_unparent(OBJECT(dev));
    704        return NULL;
    705    }
    706    return dev;
    707}
    708
    709static bool usb_get_attached(Object *obj, Error **errp)
    710{
    711    USBDevice *dev = USB_DEVICE(obj);
    712
    713    return dev->attached;
    714}
    715
    716static void usb_set_attached(Object *obj, bool value, Error **errp)
    717{
    718    USBDevice *dev = USB_DEVICE(obj);
    719
    720    if (dev->attached == value) {
    721        return;
    722    }
    723
    724    if (value) {
    725        usb_device_attach(dev, errp);
    726    } else {
    727        usb_device_detach(dev);
    728    }
    729}
    730
    731static void usb_device_instance_init(Object *obj)
    732{
    733    USBDevice *dev = USB_DEVICE(obj);
    734    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
    735
    736    if (klass->attached_settable) {
    737        object_property_add_bool(obj, "attached",
    738                                 usb_get_attached, usb_set_attached);
    739    } else {
    740        object_property_add_bool(obj, "attached",
    741                                 usb_get_attached, NULL);
    742    }
    743}
    744
    745static void usb_device_class_init(ObjectClass *klass, void *data)
    746{
    747    DeviceClass *k = DEVICE_CLASS(klass);
    748    k->bus_type = TYPE_USB_BUS;
    749    k->realize  = usb_qdev_realize;
    750    k->unrealize = usb_qdev_unrealize;
    751    device_class_set_props(k, usb_props);
    752}
    753
    754static const TypeInfo usb_device_type_info = {
    755    .name = TYPE_USB_DEVICE,
    756    .parent = TYPE_DEVICE,
    757    .instance_size = sizeof(USBDevice),
    758    .instance_init = usb_device_instance_init,
    759    .abstract = true,
    760    .class_size = sizeof(USBDeviceClass),
    761    .class_init = usb_device_class_init,
    762};
    763
    764static void usb_register_types(void)
    765{
    766    type_register_static(&usb_bus_info);
    767    type_register_static(&usb_device_type_info);
    768}
    769
    770type_init(usb_register_types)