1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Physical device callbacks for vfio_ccw
4 *
5 * Copyright IBM Corp. 2017
6 * Copyright Red Hat, Inc. 2019
7 *
8 * Author(s): Dong Jia Shi <bjsdjshi@linux.vnet.ibm.com>
9 * Xiao Feng Ren <renxiaof@linux.vnet.ibm.com>
10 * Cornelia Huck <cohuck@redhat.com>
11 */
12
13 #include <linux/vfio.h>
14 #include <linux/nospec.h>
15 #include <linux/slab.h>
16
17 #include "vfio_ccw_private.h"
18
19 static const struct vfio_device_ops vfio_ccw_dev_ops;
20
vfio_ccw_mdev_reset(struct vfio_ccw_private * private)21 static int vfio_ccw_mdev_reset(struct vfio_ccw_private *private)
22 {
23 /*
24 * If the FSM state is seen as Not Operational after closing
25 * and re-opening the mdev, return an error.
26 */
27 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_CLOSE);
28 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_OPEN);
29 if (private->state == VFIO_CCW_STATE_NOT_OPER)
30 return -EINVAL;
31
32 return 0;
33 }
34
vfio_ccw_dma_unmap(struct vfio_device * vdev,u64 iova,u64 length)35 static void vfio_ccw_dma_unmap(struct vfio_device *vdev, u64 iova, u64 length)
36 {
37 struct vfio_ccw_private *private =
38 container_of(vdev, struct vfio_ccw_private, vdev);
39
40 /* Drivers MUST unpin pages in response to an invalidation. */
41 if (!cp_iova_pinned(&private->cp, iova, length))
42 return;
43
44 vfio_ccw_mdev_reset(private);
45 }
46
vfio_ccw_mdev_init_dev(struct vfio_device * vdev)47 static int vfio_ccw_mdev_init_dev(struct vfio_device *vdev)
48 {
49 struct vfio_ccw_private *private =
50 container_of(vdev, struct vfio_ccw_private, vdev);
51
52 init_completion(&private->release_comp);
53 return 0;
54 }
55
vfio_ccw_mdev_probe(struct mdev_device * mdev)56 static int vfio_ccw_mdev_probe(struct mdev_device *mdev)
57 {
58 struct vfio_ccw_private *private = dev_get_drvdata(mdev->dev.parent);
59 int ret;
60
61 if (private->state == VFIO_CCW_STATE_NOT_OPER)
62 return -ENODEV;
63
64 ret = vfio_init_device(&private->vdev, &mdev->dev, &vfio_ccw_dev_ops);
65 if (ret)
66 return ret;
67
68 VFIO_CCW_MSG_EVENT(2, "sch %x.%x.%04x: create\n",
69 private->sch->schid.cssid,
70 private->sch->schid.ssid,
71 private->sch->schid.sch_no);
72
73 ret = vfio_register_emulated_iommu_dev(&private->vdev);
74 if (ret)
75 goto err_put_vdev;
76 dev_set_drvdata(&mdev->dev, private);
77 return 0;
78
79 err_put_vdev:
80 vfio_put_device(&private->vdev);
81 return ret;
82 }
83
vfio_ccw_mdev_release_dev(struct vfio_device * vdev)84 static void vfio_ccw_mdev_release_dev(struct vfio_device *vdev)
85 {
86 struct vfio_ccw_private *private =
87 container_of(vdev, struct vfio_ccw_private, vdev);
88
89 /*
90 * We cannot free vfio_ccw_private here because it includes
91 * parent info which must be free'ed by css driver.
92 *
93 * Use a workaround by memset'ing the core device part and
94 * then notifying the remove path that all active references
95 * to this device have been released.
96 */
97 memset(vdev, 0, sizeof(*vdev));
98 complete(&private->release_comp);
99 }
100
vfio_ccw_mdev_remove(struct mdev_device * mdev)101 static void vfio_ccw_mdev_remove(struct mdev_device *mdev)
102 {
103 struct vfio_ccw_private *private = dev_get_drvdata(mdev->dev.parent);
104
105 VFIO_CCW_MSG_EVENT(2, "sch %x.%x.%04x: remove\n",
106 private->sch->schid.cssid,
107 private->sch->schid.ssid,
108 private->sch->schid.sch_no);
109
110 vfio_unregister_group_dev(&private->vdev);
111
112 vfio_put_device(&private->vdev);
113 /*
114 * Wait for all active references on mdev are released so it
115 * is safe to defer kfree() to a later point.
116 *
117 * TODO: the clean fix is to split parent/mdev info from ccw
118 * private structure so each can be managed in its own life
119 * cycle.
120 */
121 wait_for_completion(&private->release_comp);
122 }
123
vfio_ccw_mdev_open_device(struct vfio_device * vdev)124 static int vfio_ccw_mdev_open_device(struct vfio_device *vdev)
125 {
126 struct vfio_ccw_private *private =
127 container_of(vdev, struct vfio_ccw_private, vdev);
128 int ret;
129
130 /* Device cannot simply be opened again from this state */
131 if (private->state == VFIO_CCW_STATE_NOT_OPER)
132 return -EINVAL;
133
134 ret = vfio_ccw_register_async_dev_regions(private);
135 if (ret)
136 return ret;
137
138 ret = vfio_ccw_register_schib_dev_regions(private);
139 if (ret)
140 goto out_unregister;
141
142 ret = vfio_ccw_register_crw_dev_regions(private);
143 if (ret)
144 goto out_unregister;
145
146 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_OPEN);
147 if (private->state == VFIO_CCW_STATE_NOT_OPER) {
148 ret = -EINVAL;
149 goto out_unregister;
150 }
151
152 return ret;
153
154 out_unregister:
155 vfio_ccw_unregister_dev_regions(private);
156 return ret;
157 }
158
vfio_ccw_mdev_close_device(struct vfio_device * vdev)159 static void vfio_ccw_mdev_close_device(struct vfio_device *vdev)
160 {
161 struct vfio_ccw_private *private =
162 container_of(vdev, struct vfio_ccw_private, vdev);
163
164 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_CLOSE);
165 vfio_ccw_unregister_dev_regions(private);
166 }
167
vfio_ccw_mdev_read_io_region(struct vfio_ccw_private * private,char __user * buf,size_t count,loff_t * ppos)168 static ssize_t vfio_ccw_mdev_read_io_region(struct vfio_ccw_private *private,
169 char __user *buf, size_t count,
170 loff_t *ppos)
171 {
172 loff_t pos = *ppos & VFIO_CCW_OFFSET_MASK;
173 struct ccw_io_region *region;
174 int ret;
175
176 if (pos + count > sizeof(*region))
177 return -EINVAL;
178
179 mutex_lock(&private->io_mutex);
180 region = private->io_region;
181 if (copy_to_user(buf, (void *)region + pos, count))
182 ret = -EFAULT;
183 else
184 ret = count;
185 mutex_unlock(&private->io_mutex);
186 return ret;
187 }
188
vfio_ccw_mdev_read(struct vfio_device * vdev,char __user * buf,size_t count,loff_t * ppos)189 static ssize_t vfio_ccw_mdev_read(struct vfio_device *vdev,
190 char __user *buf,
191 size_t count,
192 loff_t *ppos)
193 {
194 struct vfio_ccw_private *private =
195 container_of(vdev, struct vfio_ccw_private, vdev);
196 unsigned int index = VFIO_CCW_OFFSET_TO_INDEX(*ppos);
197
198 if (index >= VFIO_CCW_NUM_REGIONS + private->num_regions)
199 return -EINVAL;
200
201 switch (index) {
202 case VFIO_CCW_CONFIG_REGION_INDEX:
203 return vfio_ccw_mdev_read_io_region(private, buf, count, ppos);
204 default:
205 index -= VFIO_CCW_NUM_REGIONS;
206 return private->region[index].ops->read(private, buf, count,
207 ppos);
208 }
209
210 return -EINVAL;
211 }
212
vfio_ccw_mdev_write_io_region(struct vfio_ccw_private * private,const char __user * buf,size_t count,loff_t * ppos)213 static ssize_t vfio_ccw_mdev_write_io_region(struct vfio_ccw_private *private,
214 const char __user *buf,
215 size_t count, loff_t *ppos)
216 {
217 loff_t pos = *ppos & VFIO_CCW_OFFSET_MASK;
218 struct ccw_io_region *region;
219 int ret;
220
221 if (pos + count > sizeof(*region))
222 return -EINVAL;
223
224 if (!mutex_trylock(&private->io_mutex))
225 return -EAGAIN;
226
227 region = private->io_region;
228 if (copy_from_user((void *)region + pos, buf, count)) {
229 ret = -EFAULT;
230 goto out_unlock;
231 }
232
233 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_IO_REQ);
234 ret = (region->ret_code != 0) ? region->ret_code : count;
235
236 out_unlock:
237 mutex_unlock(&private->io_mutex);
238 return ret;
239 }
240
vfio_ccw_mdev_write(struct vfio_device * vdev,const char __user * buf,size_t count,loff_t * ppos)241 static ssize_t vfio_ccw_mdev_write(struct vfio_device *vdev,
242 const char __user *buf,
243 size_t count,
244 loff_t *ppos)
245 {
246 struct vfio_ccw_private *private =
247 container_of(vdev, struct vfio_ccw_private, vdev);
248 unsigned int index = VFIO_CCW_OFFSET_TO_INDEX(*ppos);
249
250 if (index >= VFIO_CCW_NUM_REGIONS + private->num_regions)
251 return -EINVAL;
252
253 switch (index) {
254 case VFIO_CCW_CONFIG_REGION_INDEX:
255 return vfio_ccw_mdev_write_io_region(private, buf, count, ppos);
256 default:
257 index -= VFIO_CCW_NUM_REGIONS;
258 return private->region[index].ops->write(private, buf, count,
259 ppos);
260 }
261
262 return -EINVAL;
263 }
264
vfio_ccw_mdev_get_device_info(struct vfio_ccw_private * private,struct vfio_device_info * info)265 static int vfio_ccw_mdev_get_device_info(struct vfio_ccw_private *private,
266 struct vfio_device_info *info)
267 {
268 info->flags = VFIO_DEVICE_FLAGS_CCW | VFIO_DEVICE_FLAGS_RESET;
269 info->num_regions = VFIO_CCW_NUM_REGIONS + private->num_regions;
270 info->num_irqs = VFIO_CCW_NUM_IRQS;
271
272 return 0;
273 }
274
vfio_ccw_mdev_get_region_info(struct vfio_ccw_private * private,struct vfio_region_info * info,unsigned long arg)275 static int vfio_ccw_mdev_get_region_info(struct vfio_ccw_private *private,
276 struct vfio_region_info *info,
277 unsigned long arg)
278 {
279 int i;
280
281 switch (info->index) {
282 case VFIO_CCW_CONFIG_REGION_INDEX:
283 info->offset = 0;
284 info->size = sizeof(struct ccw_io_region);
285 info->flags = VFIO_REGION_INFO_FLAG_READ
286 | VFIO_REGION_INFO_FLAG_WRITE;
287 return 0;
288 default: /* all other regions are handled via capability chain */
289 {
290 struct vfio_info_cap caps = { .buf = NULL, .size = 0 };
291 struct vfio_region_info_cap_type cap_type = {
292 .header.id = VFIO_REGION_INFO_CAP_TYPE,
293 .header.version = 1 };
294 int ret;
295
296 if (info->index >=
297 VFIO_CCW_NUM_REGIONS + private->num_regions)
298 return -EINVAL;
299
300 info->index = array_index_nospec(info->index,
301 VFIO_CCW_NUM_REGIONS +
302 private->num_regions);
303
304 i = info->index - VFIO_CCW_NUM_REGIONS;
305
306 info->offset = VFIO_CCW_INDEX_TO_OFFSET(info->index);
307 info->size = private->region[i].size;
308 info->flags = private->region[i].flags;
309
310 cap_type.type = private->region[i].type;
311 cap_type.subtype = private->region[i].subtype;
312
313 ret = vfio_info_add_capability(&caps, &cap_type.header,
314 sizeof(cap_type));
315 if (ret)
316 return ret;
317
318 info->flags |= VFIO_REGION_INFO_FLAG_CAPS;
319 if (info->argsz < sizeof(*info) + caps.size) {
320 info->argsz = sizeof(*info) + caps.size;
321 info->cap_offset = 0;
322 } else {
323 vfio_info_cap_shift(&caps, sizeof(*info));
324 if (copy_to_user((void __user *)arg + sizeof(*info),
325 caps.buf, caps.size)) {
326 kfree(caps.buf);
327 return -EFAULT;
328 }
329 info->cap_offset = sizeof(*info);
330 }
331
332 kfree(caps.buf);
333
334 }
335 }
336 return 0;
337 }
338
vfio_ccw_mdev_get_irq_info(struct vfio_irq_info * info)339 static int vfio_ccw_mdev_get_irq_info(struct vfio_irq_info *info)
340 {
341 switch (info->index) {
342 case VFIO_CCW_IO_IRQ_INDEX:
343 case VFIO_CCW_CRW_IRQ_INDEX:
344 case VFIO_CCW_REQ_IRQ_INDEX:
345 info->count = 1;
346 info->flags = VFIO_IRQ_INFO_EVENTFD;
347 break;
348 default:
349 return -EINVAL;
350 }
351
352 return 0;
353 }
354
vfio_ccw_mdev_set_irqs(struct vfio_ccw_private * private,uint32_t flags,uint32_t index,void __user * data)355 static int vfio_ccw_mdev_set_irqs(struct vfio_ccw_private *private,
356 uint32_t flags,
357 uint32_t index,
358 void __user *data)
359 {
360 struct eventfd_ctx **ctx;
361
362 if (!(flags & VFIO_IRQ_SET_ACTION_TRIGGER))
363 return -EINVAL;
364
365 switch (index) {
366 case VFIO_CCW_IO_IRQ_INDEX:
367 ctx = &private->io_trigger;
368 break;
369 case VFIO_CCW_CRW_IRQ_INDEX:
370 ctx = &private->crw_trigger;
371 break;
372 case VFIO_CCW_REQ_IRQ_INDEX:
373 ctx = &private->req_trigger;
374 break;
375 default:
376 return -EINVAL;
377 }
378
379 switch (flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
380 case VFIO_IRQ_SET_DATA_NONE:
381 {
382 if (*ctx)
383 eventfd_signal(*ctx, 1);
384 return 0;
385 }
386 case VFIO_IRQ_SET_DATA_BOOL:
387 {
388 uint8_t trigger;
389
390 if (get_user(trigger, (uint8_t __user *)data))
391 return -EFAULT;
392
393 if (trigger && *ctx)
394 eventfd_signal(*ctx, 1);
395 return 0;
396 }
397 case VFIO_IRQ_SET_DATA_EVENTFD:
398 {
399 int32_t fd;
400
401 if (get_user(fd, (int32_t __user *)data))
402 return -EFAULT;
403
404 if (fd == -1) {
405 if (*ctx)
406 eventfd_ctx_put(*ctx);
407 *ctx = NULL;
408 } else if (fd >= 0) {
409 struct eventfd_ctx *efdctx;
410
411 efdctx = eventfd_ctx_fdget(fd);
412 if (IS_ERR(efdctx))
413 return PTR_ERR(efdctx);
414
415 if (*ctx)
416 eventfd_ctx_put(*ctx);
417
418 *ctx = efdctx;
419 } else
420 return -EINVAL;
421
422 return 0;
423 }
424 default:
425 return -EINVAL;
426 }
427 }
428
vfio_ccw_register_dev_region(struct vfio_ccw_private * private,unsigned int subtype,const struct vfio_ccw_regops * ops,size_t size,u32 flags,void * data)429 int vfio_ccw_register_dev_region(struct vfio_ccw_private *private,
430 unsigned int subtype,
431 const struct vfio_ccw_regops *ops,
432 size_t size, u32 flags, void *data)
433 {
434 struct vfio_ccw_region *region;
435
436 region = krealloc(private->region,
437 (private->num_regions + 1) * sizeof(*region),
438 GFP_KERNEL);
439 if (!region)
440 return -ENOMEM;
441
442 private->region = region;
443 private->region[private->num_regions].type = VFIO_REGION_TYPE_CCW;
444 private->region[private->num_regions].subtype = subtype;
445 private->region[private->num_regions].ops = ops;
446 private->region[private->num_regions].size = size;
447 private->region[private->num_regions].flags = flags;
448 private->region[private->num_regions].data = data;
449
450 private->num_regions++;
451
452 return 0;
453 }
454
vfio_ccw_unregister_dev_regions(struct vfio_ccw_private * private)455 void vfio_ccw_unregister_dev_regions(struct vfio_ccw_private *private)
456 {
457 int i;
458
459 for (i = 0; i < private->num_regions; i++)
460 private->region[i].ops->release(private, &private->region[i]);
461 private->num_regions = 0;
462 kfree(private->region);
463 private->region = NULL;
464 }
465
vfio_ccw_mdev_ioctl(struct vfio_device * vdev,unsigned int cmd,unsigned long arg)466 static ssize_t vfio_ccw_mdev_ioctl(struct vfio_device *vdev,
467 unsigned int cmd,
468 unsigned long arg)
469 {
470 struct vfio_ccw_private *private =
471 container_of(vdev, struct vfio_ccw_private, vdev);
472 int ret = 0;
473 unsigned long minsz;
474
475 switch (cmd) {
476 case VFIO_DEVICE_GET_INFO:
477 {
478 struct vfio_device_info info;
479
480 minsz = offsetofend(struct vfio_device_info, num_irqs);
481
482 if (copy_from_user(&info, (void __user *)arg, minsz))
483 return -EFAULT;
484
485 if (info.argsz < minsz)
486 return -EINVAL;
487
488 ret = vfio_ccw_mdev_get_device_info(private, &info);
489 if (ret)
490 return ret;
491
492 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
493 }
494 case VFIO_DEVICE_GET_REGION_INFO:
495 {
496 struct vfio_region_info info;
497
498 minsz = offsetofend(struct vfio_region_info, offset);
499
500 if (copy_from_user(&info, (void __user *)arg, minsz))
501 return -EFAULT;
502
503 if (info.argsz < minsz)
504 return -EINVAL;
505
506 ret = vfio_ccw_mdev_get_region_info(private, &info, arg);
507 if (ret)
508 return ret;
509
510 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
511 }
512 case VFIO_DEVICE_GET_IRQ_INFO:
513 {
514 struct vfio_irq_info info;
515
516 minsz = offsetofend(struct vfio_irq_info, count);
517
518 if (copy_from_user(&info, (void __user *)arg, minsz))
519 return -EFAULT;
520
521 if (info.argsz < minsz || info.index >= VFIO_CCW_NUM_IRQS)
522 return -EINVAL;
523
524 ret = vfio_ccw_mdev_get_irq_info(&info);
525 if (ret)
526 return ret;
527
528 if (info.count == -1)
529 return -EINVAL;
530
531 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
532 }
533 case VFIO_DEVICE_SET_IRQS:
534 {
535 struct vfio_irq_set hdr;
536 size_t data_size;
537 void __user *data;
538
539 minsz = offsetofend(struct vfio_irq_set, count);
540
541 if (copy_from_user(&hdr, (void __user *)arg, minsz))
542 return -EFAULT;
543
544 ret = vfio_set_irqs_validate_and_prepare(&hdr, 1,
545 VFIO_CCW_NUM_IRQS,
546 &data_size);
547 if (ret)
548 return ret;
549
550 data = (void __user *)(arg + minsz);
551 return vfio_ccw_mdev_set_irqs(private, hdr.flags, hdr.index,
552 data);
553 }
554 case VFIO_DEVICE_RESET:
555 return vfio_ccw_mdev_reset(private);
556 default:
557 return -ENOTTY;
558 }
559 }
560
561 /* Request removal of the device*/
vfio_ccw_mdev_request(struct vfio_device * vdev,unsigned int count)562 static void vfio_ccw_mdev_request(struct vfio_device *vdev, unsigned int count)
563 {
564 struct vfio_ccw_private *private =
565 container_of(vdev, struct vfio_ccw_private, vdev);
566 struct device *dev = vdev->dev;
567
568 if (private->req_trigger) {
569 if (!(count % 10))
570 dev_notice_ratelimited(dev,
571 "Relaying device request to user (#%u)\n",
572 count);
573
574 eventfd_signal(private->req_trigger, 1);
575 } else if (count == 0) {
576 dev_notice(dev,
577 "No device request channel registered, blocked until released by user\n");
578 }
579 }
580
581 static const struct vfio_device_ops vfio_ccw_dev_ops = {
582 .init = vfio_ccw_mdev_init_dev,
583 .release = vfio_ccw_mdev_release_dev,
584 .open_device = vfio_ccw_mdev_open_device,
585 .close_device = vfio_ccw_mdev_close_device,
586 .read = vfio_ccw_mdev_read,
587 .write = vfio_ccw_mdev_write,
588 .ioctl = vfio_ccw_mdev_ioctl,
589 .request = vfio_ccw_mdev_request,
590 .dma_unmap = vfio_ccw_dma_unmap,
591 };
592
593 struct mdev_driver vfio_ccw_mdev_driver = {
594 .device_api = VFIO_DEVICE_API_CCW_STRING,
595 .max_instances = 1,
596 .driver = {
597 .name = "vfio_ccw_mdev",
598 .owner = THIS_MODULE,
599 .mod_name = KBUILD_MODNAME,
600 },
601 .probe = vfio_ccw_mdev_probe,
602 .remove = vfio_ccw_mdev_remove,
603 };
604
