]>
Commit | Line | Data |
---|---|---|
5e9be92d NB |
1 | /* |
2 | * vhost_scsi host device | |
3 | * | |
4 | * Copyright IBM, Corp. 2011 | |
5 | * | |
6 | * Authors: | |
7 | * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> | |
8 | * | |
9 | * Changes for QEMU mainline + tcm_vhost kernel upstream: | |
10 | * Nicholas Bellinger <nab@risingtidesystems.com> | |
11 | * | |
12 | * This work is licensed under the terms of the GNU LGPL, version 2 or later. | |
13 | * See the COPYING.LIB file in the top-level directory. | |
14 | * | |
15 | */ | |
16 | ||
a4ab4792 | 17 | #include "qemu/osdep.h" |
a9c94277 | 18 | #include <linux/vhost.h> |
5e9be92d | 19 | #include <sys/ioctl.h> |
a9c94277 | 20 | #include "qapi/error.h" |
d49b6836 | 21 | #include "qemu/error-report.h" |
0b8fa32f | 22 | #include "qemu/module.h" |
5e9be92d | 23 | #include "monitor/monitor.h" |
795c40b8 | 24 | #include "migration/blocker.h" |
5e9be92d NB |
25 | #include "hw/virtio/vhost-scsi.h" |
26 | #include "hw/virtio/vhost.h" | |
27 | #include "hw/virtio/virtio-scsi.h" | |
1c819449 | 28 | #include "hw/virtio/virtio-bus.h" |
7ce04255 | 29 | #include "hw/virtio/virtio-access.h" |
1956cf6f | 30 | #include "hw/fw-path-provider.h" |
a27bd6c7 | 31 | #include "hw/qdev-properties.h" |
f348b6d1 | 32 | #include "qemu/cutils.h" |
2f780b6a | 33 | #include "sysemu/sysemu.h" |
5e9be92d | 34 | |
2e6d46d7 NN |
35 | /* Features supported by host kernel. */ |
36 | static const int kernel_feature_bits[] = { | |
37 | VIRTIO_F_NOTIFY_ON_EMPTY, | |
38 | VIRTIO_RING_F_INDIRECT_DESC, | |
39 | VIRTIO_RING_F_EVENT_IDX, | |
40 | VIRTIO_SCSI_F_HOTPLUG, | |
41 | VHOST_INVALID_FEATURE_BIT | |
42 | }; | |
43 | ||
5e9be92d NB |
44 | static int vhost_scsi_set_endpoint(VHostSCSI *s) |
45 | { | |
46 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); | |
95615ce5 FF |
47 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(s); |
48 | const VhostOps *vhost_ops = vsc->dev.vhost_ops; | |
5e9be92d NB |
49 | struct vhost_scsi_target backend; |
50 | int ret; | |
51 | ||
52 | memset(&backend, 0, sizeof(backend)); | |
53 | pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn); | |
95615ce5 | 54 | ret = vhost_ops->vhost_scsi_set_endpoint(&vsc->dev, &backend); |
5e9be92d NB |
55 | if (ret < 0) { |
56 | return -errno; | |
57 | } | |
58 | return 0; | |
59 | } | |
60 | ||
61 | static void vhost_scsi_clear_endpoint(VHostSCSI *s) | |
62 | { | |
63 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); | |
95615ce5 | 64 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(s); |
5e9be92d | 65 | struct vhost_scsi_target backend; |
95615ce5 | 66 | const VhostOps *vhost_ops = vsc->dev.vhost_ops; |
5e9be92d NB |
67 | |
68 | memset(&backend, 0, sizeof(backend)); | |
69 | pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn); | |
95615ce5 | 70 | vhost_ops->vhost_scsi_clear_endpoint(&vsc->dev, &backend); |
5e9be92d NB |
71 | } |
72 | ||
73 | static int vhost_scsi_start(VHostSCSI *s) | |
74 | { | |
95615ce5 FF |
75 | int ret, abi_version; |
76 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(s); | |
77 | const VhostOps *vhost_ops = vsc->dev.vhost_ops; | |
5e9be92d | 78 | |
95615ce5 | 79 | ret = vhost_ops->vhost_scsi_get_abi_version(&vsc->dev, &abi_version); |
5e9be92d NB |
80 | if (ret < 0) { |
81 | return -errno; | |
82 | } | |
83 | if (abi_version > VHOST_SCSI_ABI_VERSION) { | |
84 | error_report("vhost-scsi: The running tcm_vhost kernel abi_version:" | |
95615ce5 FF |
85 | " %d is greater than vhost_scsi userspace supports: %d," |
86 | " please upgrade your version of QEMU", abi_version, | |
5e9be92d NB |
87 | VHOST_SCSI_ABI_VERSION); |
88 | return -ENOSYS; | |
89 | } | |
90 | ||
95615ce5 | 91 | ret = vhost_scsi_common_start(vsc); |
5e9be92d NB |
92 | if (ret < 0) { |
93 | return ret; | |
94 | } | |
95 | ||
5e9be92d NB |
96 | ret = vhost_scsi_set_endpoint(s); |
97 | if (ret < 0) { | |
95615ce5 FF |
98 | error_report("Error setting vhost-scsi endpoint"); |
99 | vhost_scsi_common_stop(vsc); | |
5e9be92d NB |
100 | } |
101 | ||
102 | return ret; | |
5e9be92d NB |
103 | } |
104 | ||
105 | static void vhost_scsi_stop(VHostSCSI *s) | |
106 | { | |
95615ce5 | 107 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(s); |
5e9be92d NB |
108 | |
109 | vhost_scsi_clear_endpoint(s); | |
95615ce5 | 110 | vhost_scsi_common_stop(vsc); |
5e9be92d NB |
111 | } |
112 | ||
113 | static void vhost_scsi_set_status(VirtIODevice *vdev, uint8_t val) | |
114 | { | |
95615ce5 FF |
115 | VHostSCSI *s = VHOST_SCSI(vdev); |
116 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(s); | |
5e9be92d NB |
117 | bool start = (val & VIRTIO_CONFIG_S_DRIVER_OK); |
118 | ||
c6d369fd NW |
119 | if (!vdev->vm_running) { |
120 | start = false; | |
121 | } | |
122 | ||
95615ce5 | 123 | if (vsc->dev.started == start) { |
5e9be92d NB |
124 | return; |
125 | } | |
126 | ||
127 | if (start) { | |
128 | int ret; | |
129 | ||
130 | ret = vhost_scsi_start(s); | |
131 | if (ret < 0) { | |
95615ce5 | 132 | error_report("unable to start vhost-scsi: %s", strerror(-ret)); |
5e9be92d NB |
133 | exit(1); |
134 | } | |
135 | } else { | |
136 | vhost_scsi_stop(s); | |
137 | } | |
138 | } | |
139 | ||
91d670fb ML |
140 | static void vhost_dummy_handle_output(VirtIODevice *vdev, VirtQueue *vq) |
141 | { | |
142 | } | |
143 | ||
4ea57425 NW |
144 | static int vhost_scsi_pre_save(void *opaque) |
145 | { | |
146 | VHostSCSICommon *vsc = opaque; | |
147 | ||
148 | /* At this point, backend must be stopped, otherwise | |
149 | * it might keep writing to memory. */ | |
150 | assert(!vsc->dev.started); | |
151 | ||
152 | return 0; | |
153 | } | |
154 | ||
155 | static const VMStateDescription vmstate_virtio_vhost_scsi = { | |
156 | .name = "virtio-vhost_scsi", | |
157 | .minimum_version_id = 1, | |
158 | .version_id = 1, | |
159 | .fields = (VMStateField[]) { | |
160 | VMSTATE_VIRTIO_DEVICE, | |
161 | VMSTATE_END_OF_LIST() | |
162 | }, | |
163 | .pre_save = vhost_scsi_pre_save, | |
164 | }; | |
165 | ||
71a6520b | 166 | static void vhost_scsi_realize(DeviceState *dev, Error **errp) |
5e9be92d | 167 | { |
71a6520b | 168 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev); |
95615ce5 | 169 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(dev); |
71a6520b | 170 | Error *err = NULL; |
5e9be92d NB |
171 | int vhostfd = -1; |
172 | int ret; | |
173 | ||
174 | if (!vs->conf.wwpn) { | |
71a6520b AF |
175 | error_setg(errp, "vhost-scsi: missing wwpn"); |
176 | return; | |
5e9be92d NB |
177 | } |
178 | ||
179 | if (vs->conf.vhostfd) { | |
e43bfd9c | 180 | vhostfd = monitor_fd_param(cur_mon, vs->conf.vhostfd, errp); |
5e9be92d | 181 | if (vhostfd == -1) { |
e43bfd9c | 182 | error_prepend(errp, "vhost-scsi: unable to parse vhostfd: "); |
71a6520b | 183 | return; |
5e9be92d | 184 | } |
81647a65 NN |
185 | } else { |
186 | vhostfd = open("/dev/vhost-scsi", O_RDWR); | |
187 | if (vhostfd < 0) { | |
188 | error_setg(errp, "vhost-scsi: open vhost char device failed: %s", | |
189 | strerror(errno)); | |
190 | return; | |
191 | } | |
5e9be92d NB |
192 | } |
193 | ||
bf46e67d | 194 | virtio_scsi_common_realize(dev, |
91d670fb | 195 | vhost_dummy_handle_output, |
bf46e67d FZ |
196 | vhost_dummy_handle_output, |
197 | vhost_dummy_handle_output, | |
198 | &err); | |
71a6520b AF |
199 | if (err != NULL) { |
200 | error_propagate(errp, err); | |
fe44dc91 AA |
201 | goto close_fd; |
202 | } | |
203 | ||
b3e89c94 LA |
204 | if (!vsc->migratable) { |
205 | error_setg(&vsc->migration_blocker, | |
206 | "vhost-scsi does not support migration in all cases. " | |
207 | "When external environment supports it (Orchestrator migrates " | |
208 | "target SCSI device state or use shared storage over network), " | |
209 | "set 'migratable' property to true to enable migration."); | |
210 | migrate_add_blocker(vsc->migration_blocker, &err); | |
211 | if (err) { | |
212 | error_propagate(errp, err); | |
213 | error_free(vsc->migration_blocker); | |
934443c3 | 214 | goto free_virtio; |
b3e89c94 | 215 | } |
5e9be92d NB |
216 | } |
217 | ||
95615ce5 | 218 | vsc->dev.nvqs = VHOST_SCSI_VQ_NUM_FIXED + vs->conf.num_queues; |
e6cc11d6 | 219 | vsc->dev.vqs = g_new0(struct vhost_virtqueue, vsc->dev.nvqs); |
95615ce5 FF |
220 | vsc->dev.vq_index = 0; |
221 | vsc->dev.backend_features = 0; | |
5e9be92d | 222 | |
95615ce5 | 223 | ret = vhost_dev_init(&vsc->dev, (void *)(uintptr_t)vhostfd, |
69e87b32 | 224 | VHOST_BACKEND_TYPE_KERNEL, 0); |
5e9be92d | 225 | if (ret < 0) { |
71a6520b AF |
226 | error_setg(errp, "vhost-scsi: vhost initialization failed: %s", |
227 | strerror(-ret)); | |
fe44dc91 | 228 | goto free_vqs; |
5e9be92d | 229 | } |
5e9be92d | 230 | |
444c7e0d | 231 | /* At present, channel and lun both are 0 for bootable vhost-scsi disk */ |
95615ce5 FF |
232 | vsc->channel = 0; |
233 | vsc->lun = 0; | |
444c7e0d | 234 | /* Note: we can also get the minimum tpgt from kernel */ |
95615ce5 | 235 | vsc->target = vs->conf.boot_tpgt; |
444c7e0d | 236 | |
fe44dc91 AA |
237 | return; |
238 | ||
239 | free_vqs: | |
b3e89c94 LA |
240 | if (!vsc->migratable) { |
241 | migrate_del_blocker(vsc->migration_blocker); | |
242 | } | |
95615ce5 | 243 | g_free(vsc->dev.vqs); |
934443c3 XY |
244 | free_virtio: |
245 | virtio_scsi_common_unrealize(dev); | |
fe44dc91 AA |
246 | close_fd: |
247 | close(vhostfd); | |
248 | return; | |
5e9be92d NB |
249 | } |
250 | ||
306ec6c3 | 251 | static void vhost_scsi_unrealize(DeviceState *dev, Error **errp) |
5e9be92d | 252 | { |
306ec6c3 | 253 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
95615ce5 | 254 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(dev); |
a5390d93 | 255 | struct vhost_virtqueue *vqs = vsc->dev.vqs; |
5e9be92d | 256 | |
b3e89c94 LA |
257 | if (!vsc->migratable) { |
258 | migrate_del_blocker(vsc->migration_blocker); | |
259 | error_free(vsc->migration_blocker); | |
260 | } | |
5e9be92d NB |
261 | |
262 | /* This will stop vhost backend. */ | |
263 | vhost_scsi_set_status(vdev, 0); | |
264 | ||
95615ce5 | 265 | vhost_dev_cleanup(&vsc->dev); |
a5390d93 | 266 | g_free(vqs); |
306ec6c3 | 267 | |
12e1dc49 | 268 | virtio_scsi_common_unrealize(dev); |
5e9be92d NB |
269 | } |
270 | ||
271 | static Property vhost_scsi_properties[] = { | |
95615ce5 FF |
272 | DEFINE_PROP_STRING("vhostfd", VirtIOSCSICommon, conf.vhostfd), |
273 | DEFINE_PROP_STRING("wwpn", VirtIOSCSICommon, conf.wwpn), | |
274 | DEFINE_PROP_UINT32("boot_tpgt", VirtIOSCSICommon, conf.boot_tpgt, 0), | |
275 | DEFINE_PROP_UINT32("num_queues", VirtIOSCSICommon, conf.num_queues, 1), | |
2994cb2e EF |
276 | DEFINE_PROP_UINT32("virtqueue_size", VirtIOSCSICommon, conf.virtqueue_size, |
277 | 128), | |
95615ce5 FF |
278 | DEFINE_PROP_UINT32("max_sectors", VirtIOSCSICommon, conf.max_sectors, |
279 | 0xFFFF), | |
280 | DEFINE_PROP_UINT32("cmd_per_lun", VirtIOSCSICommon, conf.cmd_per_lun, 128), | |
f287fdd9 GE |
281 | DEFINE_PROP_BIT64("t10_pi", VHostSCSICommon, host_features, |
282 | VIRTIO_SCSI_F_T10_PI, | |
283 | false), | |
b3e89c94 | 284 | DEFINE_PROP_BOOL("migratable", VHostSCSICommon, migratable, false), |
5e9be92d NB |
285 | DEFINE_PROP_END_OF_LIST(), |
286 | }; | |
287 | ||
288 | static void vhost_scsi_class_init(ObjectClass *klass, void *data) | |
289 | { | |
290 | DeviceClass *dc = DEVICE_CLASS(klass); | |
291 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); | |
1956cf6f | 292 | FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(klass); |
71a6520b | 293 | |
5e9be92d | 294 | dc->props = vhost_scsi_properties; |
4ea57425 | 295 | dc->vmsd = &vmstate_virtio_vhost_scsi; |
125ee0ed | 296 | set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); |
71a6520b | 297 | vdc->realize = vhost_scsi_realize; |
306ec6c3 | 298 | vdc->unrealize = vhost_scsi_unrealize; |
95615ce5 FF |
299 | vdc->get_features = vhost_scsi_common_get_features; |
300 | vdc->set_config = vhost_scsi_common_set_config; | |
5e9be92d | 301 | vdc->set_status = vhost_scsi_set_status; |
95615ce5 | 302 | fwc->get_dev_path = vhost_scsi_common_get_fw_dev_path; |
5e9be92d NB |
303 | } |
304 | ||
d4433f32 GA |
305 | static void vhost_scsi_instance_init(Object *obj) |
306 | { | |
95615ce5 FF |
307 | VHostSCSICommon *vsc = VHOST_SCSI_COMMON(obj); |
308 | ||
309 | vsc->feature_bits = kernel_feature_bits; | |
d4433f32 | 310 | |
95615ce5 FF |
311 | device_add_bootindex_property(obj, &vsc->bootindex, "bootindex", NULL, |
312 | DEVICE(vsc), NULL); | |
d4433f32 GA |
313 | } |
314 | ||
5e9be92d NB |
315 | static const TypeInfo vhost_scsi_info = { |
316 | .name = TYPE_VHOST_SCSI, | |
95615ce5 | 317 | .parent = TYPE_VHOST_SCSI_COMMON, |
5e9be92d NB |
318 | .instance_size = sizeof(VHostSCSI), |
319 | .class_init = vhost_scsi_class_init, | |
d4433f32 | 320 | .instance_init = vhost_scsi_instance_init, |
1956cf6f GA |
321 | .interfaces = (InterfaceInfo[]) { |
322 | { TYPE_FW_PATH_PROVIDER }, | |
323 | { } | |
324 | }, | |
5e9be92d NB |
325 | }; |
326 | ||
327 | static void virtio_register_types(void) | |
328 | { | |
329 | type_register_static(&vhost_scsi_info); | |
330 | } | |
331 | ||
332 | type_init(virtio_register_types) |