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 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 P9MsgHeader out; 50 51 elem = virtqueue_pop(vq, sizeof(VirtQueueElement)); 52 if (!elem) { 53 goto out_free_pdu; 54 } 55 56 if (iov_size(elem->in_sg, elem->in_num) < 7) { 57 virtio_error(vdev, 58 "The guest sent a VirtFS request without space for " 59 "the reply"); 60 goto out_free_req; 61 } 62 63 len = iov_to_buf(elem->out_sg, elem->out_num, 0, &out, 7); 64 if (len != 7) { 65 virtio_error(vdev, "The guest sent a malformed VirtFS request: " 66 "header size is %zd, should be 7", len); 67 goto out_free_req; 68 } 69 70 v->elems[pdu->idx] = elem; 71 72 pdu_submit(pdu, &out); 73 } 74 75 return; 76 77 out_free_req: 78 virtqueue_detach_element(vq, elem, 0); 79 g_free(elem); 80 out_free_pdu: 81 pdu_free(pdu); 82 } 83 84 static uint64_t virtio_9p_get_features(VirtIODevice *vdev, uint64_t features, 85 Error **errp) 86 { 87 virtio_add_feature(&features, VIRTIO_9P_MOUNT_TAG); 88 return features; 89 } 90 91 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config) 92 { 93 int len; 94 struct virtio_9p_config *cfg; 95 V9fsVirtioState *v = VIRTIO_9P(vdev); 96 V9fsState *s = &v->state; 97 98 len = strlen(s->tag); 99 cfg = g_malloc0(sizeof(struct virtio_9p_config) + len); 100 virtio_stw_p(vdev, &cfg->tag_len, len); 101 /* We don't copy the terminating null to config space */ 102 memcpy(cfg->tag, s->tag, len); 103 memcpy(config, cfg, v->config_size); 104 g_free(cfg); 105 } 106 107 static void virtio_9p_reset(VirtIODevice *vdev) 108 { 109 V9fsVirtioState *v = (V9fsVirtioState *)vdev; 110 111 v9fs_reset(&v->state); 112 } 113 114 static ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, 115 const char *fmt, va_list ap) 116 { 117 V9fsState *s = pdu->s; 118 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 119 VirtQueueElement *elem = v->elems[pdu->idx]; 120 ssize_t ret; 121 122 ret = v9fs_iov_vmarshal(elem->in_sg, elem->in_num, offset, 1, fmt, ap); 123 if (ret < 0) { 124 VirtIODevice *vdev = VIRTIO_DEVICE(v); 125 126 virtio_error(vdev, "Failed to encode VirtFS reply type %d", 127 pdu->id + 1); 128 } 129 return ret; 130 } 131 132 static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, 133 const char *fmt, va_list ap) 134 { 135 V9fsState *s = pdu->s; 136 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 137 VirtQueueElement *elem = v->elems[pdu->idx]; 138 ssize_t ret; 139 140 ret = v9fs_iov_vunmarshal(elem->out_sg, elem->out_num, offset, 1, fmt, ap); 141 if (ret < 0) { 142 VirtIODevice *vdev = VIRTIO_DEVICE(v); 143 144 virtio_error(vdev, "Failed to decode VirtFS request type %d", pdu->id); 145 } 146 return ret; 147 } 148 149 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 150 unsigned int *pniov, size_t *size) 151 { 152 V9fsState *s = pdu->s; 153 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 154 VirtQueueElement *elem = v->elems[pdu->idx]; 155 size_t buf_size = iov_size(elem->in_sg, elem->in_num); 156 157 if (buf_size < P9_IOHDRSZ) { 158 VirtIODevice *vdev = VIRTIO_DEVICE(v); 159 160 virtio_error(vdev, 161 "VirtFS reply type %d needs %zu bytes, buffer has %zu, less than minimum", 162 pdu->id + 1, *size, buf_size); 163 } 164 if (buf_size < *size) { 165 *size = buf_size; 166 } 167 168 *piov = elem->in_sg; 169 *pniov = elem->in_num; 170 } 171 172 static void virtio_init_out_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, 173 unsigned int *pniov, size_t size) 174 { 175 V9fsState *s = pdu->s; 176 V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); 177 VirtQueueElement *elem = v->elems[pdu->idx]; 178 size_t buf_size = iov_size(elem->out_sg, elem->out_num); 179 180 if (buf_size < size) { 181 VirtIODevice *vdev = VIRTIO_DEVICE(v); 182 183 virtio_error(vdev, 184 "VirtFS request type %d needs %zu bytes, buffer has %zu", 185 pdu->id, size, buf_size); 186 } 187 188 *piov = elem->out_sg; 189 *pniov = elem->out_num; 190 } 191 192 static const V9fsTransport virtio_9p_transport = { 193 .pdu_vmarshal = virtio_pdu_vmarshal, 194 .pdu_vunmarshal = virtio_pdu_vunmarshal, 195 .init_in_iov_from_pdu = virtio_init_in_iov_from_pdu, 196 .init_out_iov_from_pdu = virtio_init_out_iov_from_pdu, 197 .push_and_notify = virtio_9p_push_and_notify, 198 }; 199 200 static void virtio_9p_device_realize(DeviceState *dev, Error **errp) 201 { 202 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 203 V9fsVirtioState *v = VIRTIO_9P(dev); 204 V9fsState *s = &v->state; 205 206 if (v9fs_device_realize_common(s, &virtio_9p_transport, errp)) { 207 return; 208 } 209 210 v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); 211 virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); 212 v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); 213 } 214 215 static void virtio_9p_device_unrealize(DeviceState *dev, Error **errp) 216 { 217 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 218 V9fsVirtioState *v = VIRTIO_9P(dev); 219 V9fsState *s = &v->state; 220 221 virtio_delete_queue(v->vq); 222 virtio_cleanup(vdev); 223 v9fs_device_unrealize_common(s, errp); 224 } 225 226 /* virtio-9p device */ 227 228 static const VMStateDescription vmstate_virtio_9p = { 229 .name = "virtio-9p", 230 .minimum_version_id = 1, 231 .version_id = 1, 232 .fields = (VMStateField[]) { 233 VMSTATE_VIRTIO_DEVICE, 234 VMSTATE_END_OF_LIST() 235 }, 236 }; 237 238 static Property virtio_9p_properties[] = { 239 DEFINE_PROP_STRING("mount_tag", V9fsVirtioState, state.fsconf.tag), 240 DEFINE_PROP_STRING("fsdev", V9fsVirtioState, state.fsconf.fsdev_id), 241 DEFINE_PROP_END_OF_LIST(), 242 }; 243 244 static void virtio_9p_class_init(ObjectClass *klass, void *data) 245 { 246 DeviceClass *dc = DEVICE_CLASS(klass); 247 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 248 249 dc->props = virtio_9p_properties; 250 dc->vmsd = &vmstate_virtio_9p; 251 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 252 vdc->realize = virtio_9p_device_realize; 253 vdc->unrealize = virtio_9p_device_unrealize; 254 vdc->get_features = virtio_9p_get_features; 255 vdc->get_config = virtio_9p_get_config; 256 vdc->reset = virtio_9p_reset; 257 } 258 259 static const TypeInfo virtio_device_info = { 260 .name = TYPE_VIRTIO_9P, 261 .parent = TYPE_VIRTIO_DEVICE, 262 .instance_size = sizeof(V9fsVirtioState), 263 .class_init = virtio_9p_class_init, 264 }; 265 266 static void virtio_9p_register_types(void) 267 { 268 type_register_static(&virtio_device_info); 269 } 270 271 type_init(virtio_9p_register_types) 272