1 /* 2 * Virtio 9p backend 3 * 4 * Copyright IBM, Corp. 2010 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2. See 10 * the COPYING file in the top-level directory. 11 * 12 */ 13 14 #include "qemu/osdep.h" 15 #include "hw/virtio/virtio.h" 16 #include "qemu/sockets.h" 17 #include "virtio-9p.h" 18 #include "fsdev/qemu-fsdev.h" 19 #include "coth.h" 20 #include "hw/qdev-properties.h" 21 #include "hw/virtio/virtio-access.h" 22 #include "qemu/iov.h" 23 #include "qemu/module.h" 24 #include "sysemu/qtest.h" 25 26 static void virtio_9p_push_and_notify(V9fsPDU *pdu) 27 { 28 V9fsState *s = pdu->s; 29 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 30 VirtQueueElement *elem = v->elems[pdu->idx]; 31 32 /* push onto queue and notify */ 33 virtqueue_push(v->vq, elem, pdu->size); 34 g_free(elem); 35 v->elems[pdu->idx] = NULL; 36 37 /* FIXME: we should batch these completions */ 38 virtio_notify(VIRTIO_DEVICE(v), v->vq); 39 } 40 41 static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq) 42 { 43 V9fsVirtioState *v = (V9fsVirtioState *)vdev; 44 V9fsState *s = &v->state; 45 V9fsPDU *pdu; 46 ssize_t len; 47 VirtQueueElement *elem; 48 49 while ((pdu = pdu_alloc(s))) { 50 P9MsgHeader out; 51 52 elem = virtqueue_pop(vq, sizeof(VirtQueueElement)); 53 if (!elem) { 54 goto out_free_pdu; 55 } 56 57 if (iov_size(elem->in_sg, elem->in_num) < 7) { 58 virtio_error(vdev, 59 "The guest sent a VirtFS request without space for " 60 "the reply"); 61 goto out_free_req; 62 } 63 64 len = iov_to_buf(elem->out_sg, elem->out_num, 0, &out, 7); 65 if (len != 7) { 66 virtio_error(vdev, "The guest sent a malformed VirtFS request: " 67 "header size is %zd, should be 7", len); 68 goto out_free_req; 69 } 70 71 v->elems[pdu->idx] = elem; 72 73 pdu_submit(pdu, &out); 74 } 75 76 return; 77 78 out_free_req: 79 virtqueue_detach_element(vq, elem, 0); 80 g_free(elem); 81 out_free_pdu: 82 pdu_free(pdu); 83 } 84 85 static uint64_t virtio_9p_get_features(VirtIODevice *vdev, uint64_t features, 86 Error **errp) 87 { 88 virtio_add_feature(&features, VIRTIO_9P_MOUNT_TAG); 89 return features; 90 } 91 92 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config) 93 { 94 int len; 95 struct virtio_9p_config *cfg; 96 V9fsVirtioState *v = VIRTIO_9P(vdev); 97 V9fsState *s = &v->state; 98 99 len = strlen(s->tag); 100 cfg = g_malloc0(sizeof(struct virtio_9p_config) + len); 101 virtio_stw_p(vdev, &cfg->tag_len, len); 102 /* We don't copy the terminating null to config space */ 103 memcpy(cfg->tag, s->tag, len); 104 memcpy(config, cfg, v->config_size); 105 g_free(cfg); 106 } 107 108 static void virtio_9p_reset(VirtIODevice *vdev) 109 { 110 V9fsVirtioState *v = (V9fsVirtioState *)vdev; 111 112 v9fs_reset(&v->state); 113 } 114 115 static ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, 116 const char *fmt, va_list ap) 117 { 118 V9fsState *s = pdu->s; 119 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 120 VirtQueueElement *elem = v->elems[pdu->idx]; 121 ssize_t ret; 122 123 ret = v9fs_iov_vmarshal(elem->in_sg, elem->in_num, offset, 1, fmt, ap); 124 if (ret < 0) { 125 VirtIODevice *vdev = VIRTIO_DEVICE(v); 126 127 virtio_error(vdev, "Failed to encode VirtFS reply type %d", 128 pdu->id + 1); 129 } 130 return ret; 131 } 132 133 static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, 134 const char *fmt, va_list ap) 135 { 136 V9fsState *s = pdu->s; 137 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 138 VirtQueueElement *elem = v->elems[pdu->idx]; 139 ssize_t ret; 140 141 ret = v9fs_iov_vunmarshal(elem->out_sg, elem->out_num, offset, 1, fmt, ap); 142 if (ret < 0) { 143 VirtIODevice *vdev = VIRTIO_DEVICE(v); 144 145 virtio_error(vdev, "Failed to decode VirtFS request type %d", pdu->id); 146 } 147 return ret; 148 } 149 150 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 151 unsigned int *pniov, size_t size) 152 { 153 V9fsState *s = pdu->s; 154 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 155 VirtQueueElement *elem = v->elems[pdu->idx]; 156 size_t buf_size = iov_size(elem->in_sg, elem->in_num); 157 158 if (buf_size < size) { 159 VirtIODevice *vdev = VIRTIO_DEVICE(v); 160 161 virtio_error(vdev, 162 "VirtFS reply type %d needs %zu bytes, buffer has %zu", 163 pdu->id + 1, size, buf_size); 164 } 165 166 *piov = elem->in_sg; 167 *pniov = elem->in_num; 168 } 169 170 static void virtio_init_out_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 171 unsigned int *pniov, size_t size) 172 { 173 V9fsState *s = pdu->s; 174 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 175 VirtQueueElement *elem = v->elems[pdu->idx]; 176 size_t buf_size = iov_size(elem->out_sg, elem->out_num); 177 178 if (buf_size < size) { 179 VirtIODevice *vdev = VIRTIO_DEVICE(v); 180 181 virtio_error(vdev, 182 "VirtFS request type %d needs %zu bytes, buffer has %zu", 183 pdu->id, size, buf_size); 184 } 185 186 *piov = elem->out_sg; 187 *pniov = elem->out_num; 188 } 189 190 static const V9fsTransport virtio_9p_transport = { 191 .pdu_vmarshal = virtio_pdu_vmarshal, 192 .pdu_vunmarshal = virtio_pdu_vunmarshal, 193 .init_in_iov_from_pdu = virtio_init_in_iov_from_pdu, 194 .init_out_iov_from_pdu = virtio_init_out_iov_from_pdu, 195 .push_and_notify = virtio_9p_push_and_notify, 196 }; 197 198 static void virtio_9p_device_realize(DeviceState *dev, Error **errp) 199 { 200 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 201 V9fsVirtioState *v = VIRTIO_9P(dev); 202 V9fsState *s = &v->state; 203 FsDriverEntry *fse = get_fsdev_fsentry(s->fsconf.fsdev_id); 204 205 if (qtest_enabled() && fse) { 206 fse->export_flags |= V9FS_NO_PERF_WARN; 207 } 208 209 if (v9fs_device_realize_common(s, &virtio_9p_transport, errp)) { 210 return; 211 } 212 213 v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); 214 virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); 215 v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); 216 } 217 218 static void virtio_9p_device_unrealize(DeviceState *dev) 219 { 220 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 221 V9fsVirtioState *v = VIRTIO_9P(dev); 222 V9fsState *s = &v->state; 223 224 virtio_delete_queue(v->vq); 225 virtio_cleanup(vdev); 226 v9fs_device_unrealize_common(s); 227 } 228 229 /* virtio-9p device */ 230 231 static const VMStateDescription vmstate_virtio_9p = { 232 .name = "virtio-9p", 233 .minimum_version_id = 1, 234 .version_id = 1, 235 .fields = (VMStateField[]) { 236 VMSTATE_VIRTIO_DEVICE, 237 VMSTATE_END_OF_LIST() 238 }, 239 }; 240 241 static Property virtio_9p_properties[] = { 242 DEFINE_PROP_STRING("mount_tag", V9fsVirtioState, state.fsconf.tag), 243 DEFINE_PROP_STRING("fsdev", V9fsVirtioState, state.fsconf.fsdev_id), 244 DEFINE_PROP_END_OF_LIST(), 245 }; 246 247 static void virtio_9p_class_init(ObjectClass *klass, void *data) 248 { 249 DeviceClass *dc = DEVICE_CLASS(klass); 250 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 251 252 device_class_set_props(dc, virtio_9p_properties); 253 dc->vmsd = &vmstate_virtio_9p; 254 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 255 vdc->realize = virtio_9p_device_realize; 256 vdc->unrealize = virtio_9p_device_unrealize; 257 vdc->get_features = virtio_9p_get_features; 258 vdc->get_config = virtio_9p_get_config; 259 vdc->reset = virtio_9p_reset; 260 } 261 262 static const TypeInfo virtio_device_info = { 263 .name = TYPE_VIRTIO_9P, 264 .parent = TYPE_VIRTIO_DEVICE, 265 .instance_size = sizeof(V9fsVirtioState), 266 .class_init = virtio_9p_class_init, 267 }; 268 269 static void virtio_9p_register_types(void) 270 { 271 type_register_static(&virtio_device_info); 272 } 273 274 type_init(virtio_9p_register_types) 275