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/virtio/virtio-access.h" 21 #include "qemu/iov.h" 22 23 static const struct V9fsTransport virtio_9p_transport; 24 25 static void virtio_9p_push_and_notify(V9fsPDU *pdu) 26 { 27 V9fsState *s = pdu->s; 28 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 29 VirtQueueElement *elem = v->elems[pdu->idx]; 30 31 /* push onto queue and notify */ 32 virtqueue_push(v->vq, elem, pdu->size); 33 g_free(elem); 34 v->elems[pdu->idx] = NULL; 35 36 /* FIXME: we should batch these completions */ 37 virtio_notify(VIRTIO_DEVICE(v), v->vq); 38 } 39 40 static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq) 41 { 42 V9fsVirtioState *v = (V9fsVirtioState *)vdev; 43 V9fsState *s = &v->state; 44 V9fsPDU *pdu; 45 ssize_t len; 46 VirtQueueElement *elem; 47 48 while ((pdu = pdu_alloc(s))) { 49 struct { 50 uint32_t size_le; 51 uint8_t id; 52 uint16_t tag_le; 53 } QEMU_PACKED out; 54 55 elem = virtqueue_pop(vq, sizeof(VirtQueueElement)); 56 if (!elem) { 57 goto out_free_pdu; 58 } 59 60 if (elem->in_num == 0) { 61 virtio_error(vdev, 62 "The guest sent a VirtFS request without space for " 63 "the reply"); 64 goto out_free_req; 65 } 66 QEMU_BUILD_BUG_ON(sizeof(out) != 7); 67 68 v->elems[pdu->idx] = elem; 69 len = iov_to_buf(elem->out_sg, elem->out_num, 0, 70 &out, sizeof(out)); 71 if (len != sizeof(out)) { 72 virtio_error(vdev, "The guest sent a malformed VirtFS request: " 73 "header size is %zd, should be 7", len); 74 goto out_free_req; 75 } 76 77 pdu->size = le32_to_cpu(out.size_le); 78 79 pdu->id = out.id; 80 pdu->tag = le16_to_cpu(out.tag_le); 81 82 qemu_co_queue_init(&pdu->complete); 83 pdu_submit(pdu); 84 } 85 86 return; 87 88 out_free_req: 89 virtqueue_detach_element(vq, elem, 0); 90 g_free(elem); 91 out_free_pdu: 92 pdu_free(pdu); 93 } 94 95 static uint64_t virtio_9p_get_features(VirtIODevice *vdev, uint64_t features, 96 Error **errp) 97 { 98 virtio_add_feature(&features, VIRTIO_9P_MOUNT_TAG); 99 return features; 100 } 101 102 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config) 103 { 104 int len; 105 struct virtio_9p_config *cfg; 106 V9fsVirtioState *v = VIRTIO_9P(vdev); 107 V9fsState *s = &v->state; 108 109 len = strlen(s->tag); 110 cfg = g_malloc0(sizeof(struct virtio_9p_config) + len); 111 virtio_stw_p(vdev, &cfg->tag_len, len); 112 /* We don't copy the terminating null to config space */ 113 memcpy(cfg->tag, s->tag, len); 114 memcpy(config, cfg, v->config_size); 115 g_free(cfg); 116 } 117 118 static void virtio_9p_device_realize(DeviceState *dev, Error **errp) 119 { 120 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 121 V9fsVirtioState *v = VIRTIO_9P(dev); 122 V9fsState *s = &v->state; 123 124 if (v9fs_device_realize_common(s, errp)) { 125 goto out; 126 } 127 128 v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); 129 virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); 130 v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); 131 v9fs_register_transport(s, &virtio_9p_transport); 132 133 out: 134 return; 135 } 136 137 static void virtio_9p_device_unrealize(DeviceState *dev, Error **errp) 138 { 139 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 140 V9fsVirtioState *v = VIRTIO_9P(dev); 141 V9fsState *s = &v->state; 142 143 virtio_cleanup(vdev); 144 v9fs_device_unrealize_common(s, errp); 145 } 146 147 static void virtio_9p_reset(VirtIODevice *vdev) 148 { 149 V9fsVirtioState *v = (V9fsVirtioState *)vdev; 150 151 v9fs_reset(&v->state); 152 } 153 154 static ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, 155 const char *fmt, va_list ap) 156 { 157 V9fsState *s = pdu->s; 158 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 159 VirtQueueElement *elem = v->elems[pdu->idx]; 160 161 return v9fs_iov_vmarshal(elem->in_sg, elem->in_num, offset, 1, fmt, ap); 162 } 163 164 static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, 165 const char *fmt, va_list ap) 166 { 167 V9fsState *s = pdu->s; 168 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 169 VirtQueueElement *elem = v->elems[pdu->idx]; 170 171 return v9fs_iov_vunmarshal(elem->out_sg, elem->out_num, offset, 1, fmt, ap); 172 } 173 174 /* The size parameter is used by other transports. Do not drop it. */ 175 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 176 unsigned int *pniov, size_t size) 177 { 178 V9fsState *s = pdu->s; 179 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 180 VirtQueueElement *elem = v->elems[pdu->idx]; 181 182 *piov = elem->in_sg; 183 *pniov = elem->in_num; 184 } 185 186 static void virtio_init_out_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 187 unsigned int *pniov) 188 { 189 V9fsState *s = pdu->s; 190 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 191 VirtQueueElement *elem = v->elems[pdu->idx]; 192 193 *piov = elem->out_sg; 194 *pniov = elem->out_num; 195 } 196 197 static const struct V9fsTransport virtio_9p_transport = { 198 .pdu_vmarshal = virtio_pdu_vmarshal, 199 .pdu_vunmarshal = virtio_pdu_vunmarshal, 200 .init_in_iov_from_pdu = virtio_init_in_iov_from_pdu, 201 .init_out_iov_from_pdu = virtio_init_out_iov_from_pdu, 202 .push_and_notify = virtio_9p_push_and_notify, 203 }; 204 205 /* virtio-9p device */ 206 207 static const VMStateDescription vmstate_virtio_9p = { 208 .name = "virtio-9p", 209 .minimum_version_id = 1, 210 .version_id = 1, 211 .fields = (VMStateField[]) { 212 VMSTATE_VIRTIO_DEVICE, 213 VMSTATE_END_OF_LIST() 214 }, 215 }; 216 217 static Property virtio_9p_properties[] = { 218 DEFINE_PROP_STRING("mount_tag", V9fsVirtioState, state.fsconf.tag), 219 DEFINE_PROP_STRING("fsdev", V9fsVirtioState, state.fsconf.fsdev_id), 220 DEFINE_PROP_END_OF_LIST(), 221 }; 222 223 static void virtio_9p_class_init(ObjectClass *klass, void *data) 224 { 225 DeviceClass *dc = DEVICE_CLASS(klass); 226 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 227 228 dc->props = virtio_9p_properties; 229 dc->vmsd = &vmstate_virtio_9p; 230 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 231 vdc->realize = virtio_9p_device_realize; 232 vdc->unrealize = virtio_9p_device_unrealize; 233 vdc->get_features = virtio_9p_get_features; 234 vdc->get_config = virtio_9p_get_config; 235 vdc->reset = virtio_9p_reset; 236 } 237 238 static const TypeInfo virtio_device_info = { 239 .name = TYPE_VIRTIO_9P, 240 .parent = TYPE_VIRTIO_DEVICE, 241 .instance_size = sizeof(V9fsVirtioState), 242 .class_init = virtio_9p_class_init, 243 }; 244 245 static void virtio_9p_register_types(void) 246 { 247 type_register_static(&virtio_device_info); 248 } 249 250 type_init(virtio_9p_register_types) 251