← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to hw/pci/pci-hotplug.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/pci/pci-hotplug.c
1
 
/*
2
 
 * QEMU PCI hotplug support
3
 
 *
4
 
 * Copyright (c) 2004 Fabrice Bellard
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 "hw/hw.h"
26
 
#include "hw/boards.h"
27
 
#include "hw/pci/pci.h"
28
 
#include "net/net.h"
29
 
#include "hw/i386/pc.h"
30
 
#include "monitor/monitor.h"
31
 
#include "hw/scsi/scsi.h"
32
 
#include "hw/virtio/virtio-blk.h"
33
 
#include "qemu/config-file.h"
34
 
#include "sysemu/blockdev.h"
35
 
#include "qapi/error.h"
36
 
 
37
 
#if defined(TARGET_I386)
38
 
static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
39
 
                                       const char *devaddr,
40
 
                                       const char *opts_str)
41
 
{
42
 
    Error *local_err = NULL;
43
 
    QemuOpts *opts;
44
 
    PCIBus *bus;
45
 
    int ret, devfn;
46
 
 
47
 
    bus = pci_get_bus_devfn(&devfn, devaddr);
48
 
    if (!bus) {
49
 
        monitor_printf(mon, "Invalid PCI device address %s\n", devaddr);
50
 
        return NULL;
51
 
    }
52
 
    if (!((BusState*)bus)->allow_hotplug) {
53
 
        monitor_printf(mon, "PCI bus doesn't support hotplug\n");
54
 
        return NULL;
55
 
    }
56
 
 
57
 
    opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
58
 
    if (!opts) {
59
 
        return NULL;
60
 
    }
61
 
 
62
 
    qemu_opt_set(opts, "type", "nic");
63
 
 
64
 
    ret = net_client_init(opts, 0, &local_err);
65
 
    if (error_is_set(&local_err)) {
66
 
        qerror_report_err(local_err);
67
 
        error_free(local_err);
68
 
        return NULL;
69
 
    }
70
 
    if (nd_table[ret].devaddr) {
71
 
        monitor_printf(mon, "Parameter addr not supported\n");
72
 
        return NULL;
73
 
    }
74
 
    return pci_nic_init(&nd_table[ret], "rtl8139", devaddr);
75
 
}
76
 
 
77
 
static int scsi_hot_add(Monitor *mon, DeviceState *adapter,
78
 
                        DriveInfo *dinfo, int printinfo)
79
 
{
80
 
    SCSIBus *scsibus;
81
 
    SCSIDevice *scsidev;
82
 
 
83
 
    scsibus = (SCSIBus *)
84
 
        object_dynamic_cast(OBJECT(QLIST_FIRST(&adapter->child_bus)),
85
 
                            TYPE_SCSI_BUS);
86
 
    if (!scsibus) {
87
 
        error_report("Device is not a SCSI adapter");
88
 
        return -1;
89
 
    }
90
 
 
91
 
    /*
92
 
     * drive_init() tries to find a default for dinfo->unit.  Doesn't
93
 
     * work at all for hotplug though as we assign the device to a
94
 
     * specific bus instead of the first bus with spare scsi ids.
95
 
     *
96
 
     * Ditch the calculated value and reload from option string (if
97
 
     * specified).
98
 
     */
99
 
    dinfo->unit = qemu_opt_get_number(dinfo->opts, "unit", -1);
100
 
    dinfo->bus = scsibus->busnr;
101
 
    scsidev = scsi_bus_legacy_add_drive(scsibus, dinfo->bdrv, dinfo->unit,
102
 
                                        false, -1, NULL);
103
 
    if (!scsidev) {
104
 
        return -1;
105
 
    }
106
 
    dinfo->unit = scsidev->id;
107
 
 
108
 
    if (printinfo)
109
 
        monitor_printf(mon, "OK bus %d, unit %d\n",
110
 
                       scsibus->busnr, scsidev->id);
111
 
    return 0;
112
 
}
113
 
 
114
 
int pci_drive_hot_add(Monitor *mon, const QDict *qdict, DriveInfo *dinfo)
115
 
{
116
 
    int dom, pci_bus;
117
 
    unsigned slot;
118
 
    PCIDevice *dev;
119
 
    const char *pci_addr = qdict_get_str(qdict, "pci_addr");
120
 
 
121
 
    switch (dinfo->type) {
122
 
    case IF_SCSI:
123
 
        if (pci_read_devaddr(mon, pci_addr, &dom, &pci_bus, &slot)) {
124
 
            goto err;
125
 
        }
126
 
        dev = pci_find_device(pci_find_root_bus(dom), pci_bus,
127
 
                              PCI_DEVFN(slot, 0));
128
 
        if (!dev) {
129
 
            monitor_printf(mon, "no pci device with address %s\n", pci_addr);
130
 
            goto err;
131
 
        }
132
 
        if (scsi_hot_add(mon, &dev->qdev, dinfo, 1) != 0) {
133
 
            goto err;
134
 
        }
135
 
        break;
136
 
    default:
137
 
        monitor_printf(mon, "Can't hot-add drive to type %d\n", dinfo->type);
138
 
        goto err;
139
 
    }
140
 
 
141
 
    return 0;
142
 
err:
143
 
    return -1;
144
 
}
145
 
 
146
 
static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon,
147
 
                                           const char *devaddr,
148
 
                                           const char *opts)
149
 
{
150
 
    PCIDevice *dev;
151
 
    DriveInfo *dinfo = NULL;
152
 
    int type = -1;
153
 
    char buf[128];
154
 
    PCIBus *bus;
155
 
    int devfn;
156
 
 
157
 
    if (get_param_value(buf, sizeof(buf), "if", opts)) {
158
 
        if (!strcmp(buf, "scsi"))
159
 
            type = IF_SCSI;
160
 
        else if (!strcmp(buf, "virtio")) {
161
 
            type = IF_VIRTIO;
162
 
        } else {
163
 
            monitor_printf(mon, "type %s not a hotpluggable PCI device.\n", buf);
164
 
            return NULL;
165
 
        }
166
 
    } else {
167
 
        monitor_printf(mon, "no if= specified\n");
168
 
        return NULL;
169
 
    }
170
 
 
171
 
    if (get_param_value(buf, sizeof(buf), "file", opts)) {
172
 
        dinfo = add_init_drive(opts);
173
 
        if (!dinfo)
174
 
            return NULL;
175
 
        if (dinfo->devaddr) {
176
 
            monitor_printf(mon, "Parameter addr not supported\n");
177
 
            return NULL;
178
 
        }
179
 
    } else {
180
 
        dinfo = NULL;
181
 
    }
182
 
 
183
 
    bus = pci_get_bus_devfn(&devfn, devaddr);
184
 
    if (!bus) {
185
 
        monitor_printf(mon, "Invalid PCI device address %s\n", devaddr);
186
 
        return NULL;
187
 
    }
188
 
    if (!((BusState*)bus)->allow_hotplug) {
189
 
        monitor_printf(mon, "PCI bus doesn't support hotplug\n");
190
 
        return NULL;
191
 
    }
192
 
 
193
 
    switch (type) {
194
 
    case IF_SCSI:
195
 
        dev = pci_create(bus, devfn, "lsi53c895a");
196
 
        if (qdev_init(&dev->qdev) < 0)
197
 
            dev = NULL;
198
 
        if (dev && dinfo) {
199
 
            if (scsi_hot_add(mon, &dev->qdev, dinfo, 0) != 0) {
200
 
                qdev_unplug(&dev->qdev, NULL);
201
 
                dev = NULL;
202
 
            }
203
 
        }
204
 
        break;
205
 
    case IF_VIRTIO:
206
 
        if (!dinfo) {
207
 
            monitor_printf(mon, "virtio requires a backing file/device.\n");
208
 
            return NULL;
209
 
        }
210
 
        dev = pci_create(bus, devfn, "virtio-blk-pci");
211
 
        if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
212
 
            qdev_free(&dev->qdev);
213
 
            dev = NULL;
214
 
            break;
215
 
        }
216
 
        if (qdev_init(&dev->qdev) < 0)
217
 
            dev = NULL;
218
 
        break;
219
 
    default:
220
 
        dev = NULL;
221
 
    }
222
 
    return dev;
223
 
}
224
 
 
225
 
void pci_device_hot_add(Monitor *mon, const QDict *qdict)
226
 
{
227
 
    PCIDevice *dev = NULL;
228
 
    const char *pci_addr = qdict_get_str(qdict, "pci_addr");
229
 
    const char *type = qdict_get_str(qdict, "type");
230
 
    const char *opts = qdict_get_try_str(qdict, "opts");
231
 
 
232
 
    /* strip legacy tag */
233
 
    if (!strncmp(pci_addr, "pci_addr=", 9)) {
234
 
        pci_addr += 9;
235
 
    }
236
 
 
237
 
    if (!opts) {
238
 
        opts = "";
239
 
    }
240
 
 
241
 
    if (!strcmp(pci_addr, "auto"))
242
 
        pci_addr = NULL;
243
 
 
244
 
    if (strcmp(type, "nic") == 0) {
245
 
        dev = qemu_pci_hot_add_nic(mon, pci_addr, opts);
246
 
    } else if (strcmp(type, "storage") == 0) {
247
 
        dev = qemu_pci_hot_add_storage(mon, pci_addr, opts);
248
 
    } else {
249
 
        monitor_printf(mon, "invalid type: %s\n", type);
250
 
    }
251
 
 
252
 
    if (dev) {
253
 
        monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
254
 
                       pci_find_domain(dev->bus),
255
 
                       pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
256
 
                       PCI_FUNC(dev->devfn));
257
 
    } else
258
 
        monitor_printf(mon, "failed to add %s\n", opts);
259
 
}
260
 
#endif
261
 
 
262
 
static int pci_device_hot_remove(Monitor *mon, const char *pci_addr)
263
 
{
264
 
    PCIDevice *d;
265
 
    int dom, bus;
266
 
    unsigned slot;
267
 
    Error *local_err = NULL;
268
 
 
269
 
    if (pci_read_devaddr(mon, pci_addr, &dom, &bus, &slot)) {
270
 
        return -1;
271
 
    }
272
 
 
273
 
    d = pci_find_device(pci_find_root_bus(dom), bus, PCI_DEVFN(slot, 0));
274
 
    if (!d) {
275
 
        monitor_printf(mon, "slot %d empty\n", slot);
276
 
        return -1;
277
 
    }
278
 
 
279
 
    qdev_unplug(&d->qdev, &local_err);
280
 
    if (error_is_set(&local_err)) {
281
 
        monitor_printf(mon, "%s\n", error_get_pretty(local_err));
282
 
        error_free(local_err);
283
 
        return -1;
284
 
    }
285
 
 
286
 
    return 0;
287
 
}
288
 
 
289
 
void do_pci_device_hot_remove(Monitor *mon, const QDict *qdict)
290
 
{
291
 
    pci_device_hot_remove(mon, qdict_get_str(qdict, "pci_addr"));
292
 
}