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/mdev.h>
15 #include <linux/nospec.h>
16 #include <linux/slab.h>
17
18 #include "vfio_ccw_private.h"
19
20 static const struct vfio_device_ops vfio_ccw_dev_ops;
21
vfio_ccw_mdev_reset(struct vfio_ccw_private * private)22 static int vfio_ccw_mdev_reset(struct vfio_ccw_private *private)
23 {
24 struct subchannel *sch;
25 int ret;
26
27 sch = private->sch;
28 /*
29 * TODO:
30 * In the cureent stage, some things like "no I/O running" and "no
31 * interrupt pending" are clear, but we are not sure what other state
32 * we need to care about.
33 * There are still a lot more instructions need to be handled. We
34 * should come back here later.
35 */
36 ret = vfio_ccw_sch_quiesce(sch);
37 if (ret)
38 return ret;
39
40 ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
41 if (!ret)
42 private->state = VFIO_CCW_STATE_IDLE;
43
44 return ret;
45 }
46
vfio_ccw_mdev_notifier(struct notifier_block * nb,unsigned long action,void * data)47 static int vfio_ccw_mdev_notifier(struct notifier_block *nb,
48 unsigned long action,
49 void *data)
50 {
51 struct vfio_ccw_private *private =
52 container_of(nb, struct vfio_ccw_private, nb);
53
54 /*
55 * Vendor drivers MUST unpin pages in response to an
56 * invalidation.
57 */
58 if (action == VFIO_IOMMU_NOTIFY_DMA_UNMAP) {
59 struct vfio_iommu_type1_dma_unmap *unmap = data;
60
61 if (!cp_iova_pinned(&private->cp, unmap->iova))
62 return NOTIFY_OK;
63
64 if (vfio_ccw_mdev_reset(private))
65 return NOTIFY_BAD;
66
67 cp_free(&private->cp);
68 return NOTIFY_OK;
69 }
70
71 return NOTIFY_DONE;
72 }
73
name_show(struct mdev_type * mtype,struct mdev_type_attribute * attr,char * buf)74 static ssize_t name_show(struct mdev_type *mtype,
75 struct mdev_type_attribute *attr, char *buf)
76 {
77 return sprintf(buf, "I/O subchannel (Non-QDIO)\n");
78 }
79 static MDEV_TYPE_ATTR_RO(name);
80
device_api_show(struct mdev_type * mtype,struct mdev_type_attribute * attr,char * buf)81 static ssize_t device_api_show(struct mdev_type *mtype,
82 struct mdev_type_attribute *attr, char *buf)
83 {
84 return sprintf(buf, "%s\n", VFIO_DEVICE_API_CCW_STRING);
85 }
86 static MDEV_TYPE_ATTR_RO(device_api);
87
available_instances_show(struct mdev_type * mtype,struct mdev_type_attribute * attr,char * buf)88 static ssize_t available_instances_show(struct mdev_type *mtype,
89 struct mdev_type_attribute *attr,
90 char *buf)
91 {
92 struct vfio_ccw_private *private =
93 dev_get_drvdata(mtype_get_parent_dev(mtype));
94
95 return sprintf(buf, "%d\n", atomic_read(&private->avail));
96 }
97 static MDEV_TYPE_ATTR_RO(available_instances);
98
99 static struct attribute *mdev_types_attrs[] = {
100 &mdev_type_attr_name.attr,
101 &mdev_type_attr_device_api.attr,
102 &mdev_type_attr_available_instances.attr,
103 NULL,
104 };
105
106 static struct attribute_group mdev_type_group = {
107 .name = "io",
108 .attrs = mdev_types_attrs,
109 };
110
111 static struct attribute_group *mdev_type_groups[] = {
112 &mdev_type_group,
113 NULL,
114 };
115
vfio_ccw_mdev_probe(struct mdev_device * mdev)116 static int vfio_ccw_mdev_probe(struct mdev_device *mdev)
117 {
118 struct vfio_ccw_private *private = dev_get_drvdata(mdev->dev.parent);
119 int ret;
120
121 if (private->state == VFIO_CCW_STATE_NOT_OPER)
122 return -ENODEV;
123
124 if (atomic_dec_if_positive(&private->avail) < 0)
125 return -EPERM;
126
127 memset(&private->vdev, 0, sizeof(private->vdev));
128 vfio_init_group_dev(&private->vdev, &mdev->dev,
129 &vfio_ccw_dev_ops);
130
131 private->mdev = mdev;
132 private->state = VFIO_CCW_STATE_IDLE;
133
134 VFIO_CCW_MSG_EVENT(2, "mdev %pUl, sch %x.%x.%04x: create\n",
135 mdev_uuid(mdev), private->sch->schid.cssid,
136 private->sch->schid.ssid,
137 private->sch->schid.sch_no);
138
139 ret = vfio_register_emulated_iommu_dev(&private->vdev);
140 if (ret)
141 goto err_atomic;
142 dev_set_drvdata(&mdev->dev, private);
143 return 0;
144
145 err_atomic:
146 vfio_uninit_group_dev(&private->vdev);
147 atomic_inc(&private->avail);
148 private->mdev = NULL;
149 private->state = VFIO_CCW_STATE_IDLE;
150 return ret;
151 }
152
vfio_ccw_mdev_remove(struct mdev_device * mdev)153 static void vfio_ccw_mdev_remove(struct mdev_device *mdev)
154 {
155 struct vfio_ccw_private *private = dev_get_drvdata(mdev->dev.parent);
156
157 VFIO_CCW_MSG_EVENT(2, "mdev %pUl, sch %x.%x.%04x: remove\n",
158 mdev_uuid(mdev), private->sch->schid.cssid,
159 private->sch->schid.ssid,
160 private->sch->schid.sch_no);
161
162 vfio_unregister_group_dev(&private->vdev);
163
164 if ((private->state != VFIO_CCW_STATE_NOT_OPER) &&
165 (private->state != VFIO_CCW_STATE_STANDBY)) {
166 if (!vfio_ccw_sch_quiesce(private->sch))
167 private->state = VFIO_CCW_STATE_STANDBY;
168 /* The state will be NOT_OPER on error. */
169 }
170
171 vfio_uninit_group_dev(&private->vdev);
172 cp_free(&private->cp);
173 private->mdev = NULL;
174 atomic_inc(&private->avail);
175 }
176
vfio_ccw_mdev_open_device(struct vfio_device * vdev)177 static int vfio_ccw_mdev_open_device(struct vfio_device *vdev)
178 {
179 struct vfio_ccw_private *private =
180 container_of(vdev, struct vfio_ccw_private, vdev);
181 unsigned long events = VFIO_IOMMU_NOTIFY_DMA_UNMAP;
182 int ret;
183
184 private->nb.notifier_call = vfio_ccw_mdev_notifier;
185
186 ret = vfio_register_notifier(vdev->dev, VFIO_IOMMU_NOTIFY,
187 &events, &private->nb);
188 if (ret)
189 return ret;
190
191 ret = vfio_ccw_register_async_dev_regions(private);
192 if (ret)
193 goto out_unregister;
194
195 ret = vfio_ccw_register_schib_dev_regions(private);
196 if (ret)
197 goto out_unregister;
198
199 ret = vfio_ccw_register_crw_dev_regions(private);
200 if (ret)
201 goto out_unregister;
202
203 return ret;
204
205 out_unregister:
206 vfio_ccw_unregister_dev_regions(private);
207 vfio_unregister_notifier(vdev->dev, VFIO_IOMMU_NOTIFY,
208 &private->nb);
209 return ret;
210 }
211
vfio_ccw_mdev_close_device(struct vfio_device * vdev)212 static void vfio_ccw_mdev_close_device(struct vfio_device *vdev)
213 {
214 struct vfio_ccw_private *private =
215 container_of(vdev, struct vfio_ccw_private, vdev);
216
217 if ((private->state != VFIO_CCW_STATE_NOT_OPER) &&
218 (private->state != VFIO_CCW_STATE_STANDBY)) {
219 if (!vfio_ccw_mdev_reset(private))
220 private->state = VFIO_CCW_STATE_STANDBY;
221 /* The state will be NOT_OPER on error. */
222 }
223
224 cp_free(&private->cp);
225 vfio_ccw_unregister_dev_regions(private);
226 vfio_unregister_notifier(vdev->dev, VFIO_IOMMU_NOTIFY, &private->nb);
227 }
228
vfio_ccw_mdev_read_io_region(struct vfio_ccw_private * private,char __user * buf,size_t count,loff_t * ppos)229 static ssize_t vfio_ccw_mdev_read_io_region(struct vfio_ccw_private *private,
230 char __user *buf, size_t count,
231 loff_t *ppos)
232 {
233 loff_t pos = *ppos & VFIO_CCW_OFFSET_MASK;
234 struct ccw_io_region *region;
235 int ret;
236
237 if (pos + count > sizeof(*region))
238 return -EINVAL;
239
240 mutex_lock(&private->io_mutex);
241 region = private->io_region;
242 if (copy_to_user(buf, (void *)region + pos, count))
243 ret = -EFAULT;
244 else
245 ret = count;
246 mutex_unlock(&private->io_mutex);
247 return ret;
248 }
249
vfio_ccw_mdev_read(struct vfio_device * vdev,char __user * buf,size_t count,loff_t * ppos)250 static ssize_t vfio_ccw_mdev_read(struct vfio_device *vdev,
251 char __user *buf,
252 size_t count,
253 loff_t *ppos)
254 {
255 struct vfio_ccw_private *private =
256 container_of(vdev, struct vfio_ccw_private, vdev);
257 unsigned int index = VFIO_CCW_OFFSET_TO_INDEX(*ppos);
258
259 if (index >= VFIO_CCW_NUM_REGIONS + private->num_regions)
260 return -EINVAL;
261
262 switch (index) {
263 case VFIO_CCW_CONFIG_REGION_INDEX:
264 return vfio_ccw_mdev_read_io_region(private, buf, count, ppos);
265 default:
266 index -= VFIO_CCW_NUM_REGIONS;
267 return private->region[index].ops->read(private, buf, count,
268 ppos);
269 }
270
271 return -EINVAL;
272 }
273
vfio_ccw_mdev_write_io_region(struct vfio_ccw_private * private,const char __user * buf,size_t count,loff_t * ppos)274 static ssize_t vfio_ccw_mdev_write_io_region(struct vfio_ccw_private *private,
275 const char __user *buf,
276 size_t count, loff_t *ppos)
277 {
278 loff_t pos = *ppos & VFIO_CCW_OFFSET_MASK;
279 struct ccw_io_region *region;
280 int ret;
281
282 if (pos + count > sizeof(*region))
283 return -EINVAL;
284
285 if (!mutex_trylock(&private->io_mutex))
286 return -EAGAIN;
287
288 region = private->io_region;
289 if (copy_from_user((void *)region + pos, buf, count)) {
290 ret = -EFAULT;
291 goto out_unlock;
292 }
293
294 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_IO_REQ);
295 ret = (region->ret_code != 0) ? region->ret_code : count;
296
297 out_unlock:
298 mutex_unlock(&private->io_mutex);
299 return ret;
300 }
301
vfio_ccw_mdev_write(struct vfio_device * vdev,const char __user * buf,size_t count,loff_t * ppos)302 static ssize_t vfio_ccw_mdev_write(struct vfio_device *vdev,
303 const char __user *buf,
304 size_t count,
305 loff_t *ppos)
306 {
307 struct vfio_ccw_private *private =
308 container_of(vdev, struct vfio_ccw_private, vdev);
309 unsigned int index = VFIO_CCW_OFFSET_TO_INDEX(*ppos);
310
311 if (index >= VFIO_CCW_NUM_REGIONS + private->num_regions)
312 return -EINVAL;
313
314 switch (index) {
315 case VFIO_CCW_CONFIG_REGION_INDEX:
316 return vfio_ccw_mdev_write_io_region(private, buf, count, ppos);
317 default:
318 index -= VFIO_CCW_NUM_REGIONS;
319 return private->region[index].ops->write(private, buf, count,
320 ppos);
321 }
322
323 return -EINVAL;
324 }
325
vfio_ccw_mdev_get_device_info(struct vfio_ccw_private * private,struct vfio_device_info * info)326 static int vfio_ccw_mdev_get_device_info(struct vfio_ccw_private *private,
327 struct vfio_device_info *info)
328 {
329 info->flags = VFIO_DEVICE_FLAGS_CCW | VFIO_DEVICE_FLAGS_RESET;
330 info->num_regions = VFIO_CCW_NUM_REGIONS + private->num_regions;
331 info->num_irqs = VFIO_CCW_NUM_IRQS;
332
333 return 0;
334 }
335
vfio_ccw_mdev_get_region_info(struct vfio_ccw_private * private,struct vfio_region_info * info,unsigned long arg)336 static int vfio_ccw_mdev_get_region_info(struct vfio_ccw_private *private,
337 struct vfio_region_info *info,
338 unsigned long arg)
339 {
340 int i;
341
342 switch (info->index) {
343 case VFIO_CCW_CONFIG_REGION_INDEX:
344 info->offset = 0;
345 info->size = sizeof(struct ccw_io_region);
346 info->flags = VFIO_REGION_INFO_FLAG_READ
347 | VFIO_REGION_INFO_FLAG_WRITE;
348 return 0;
349 default: /* all other regions are handled via capability chain */
350 {
351 struct vfio_info_cap caps = { .buf = NULL, .size = 0 };
352 struct vfio_region_info_cap_type cap_type = {
353 .header.id = VFIO_REGION_INFO_CAP_TYPE,
354 .header.version = 1 };
355 int ret;
356
357 if (info->index >=
358 VFIO_CCW_NUM_REGIONS + private->num_regions)
359 return -EINVAL;
360
361 info->index = array_index_nospec(info->index,
362 VFIO_CCW_NUM_REGIONS +
363 private->num_regions);
364
365 i = info->index - VFIO_CCW_NUM_REGIONS;
366
367 info->offset = VFIO_CCW_INDEX_TO_OFFSET(info->index);
368 info->size = private->region[i].size;
369 info->flags = private->region[i].flags;
370
371 cap_type.type = private->region[i].type;
372 cap_type.subtype = private->region[i].subtype;
373
374 ret = vfio_info_add_capability(&caps, &cap_type.header,
375 sizeof(cap_type));
376 if (ret)
377 return ret;
378
379 info->flags |= VFIO_REGION_INFO_FLAG_CAPS;
380 if (info->argsz < sizeof(*info) + caps.size) {
381 info->argsz = sizeof(*info) + caps.size;
382 info->cap_offset = 0;
383 } else {
384 vfio_info_cap_shift(&caps, sizeof(*info));
385 if (copy_to_user((void __user *)arg + sizeof(*info),
386 caps.buf, caps.size)) {
387 kfree(caps.buf);
388 return -EFAULT;
389 }
390 info->cap_offset = sizeof(*info);
391 }
392
393 kfree(caps.buf);
394
395 }
396 }
397 return 0;
398 }
399
vfio_ccw_mdev_get_irq_info(struct vfio_irq_info * info)400 static int vfio_ccw_mdev_get_irq_info(struct vfio_irq_info *info)
401 {
402 switch (info->index) {
403 case VFIO_CCW_IO_IRQ_INDEX:
404 case VFIO_CCW_CRW_IRQ_INDEX:
405 case VFIO_CCW_REQ_IRQ_INDEX:
406 info->count = 1;
407 info->flags = VFIO_IRQ_INFO_EVENTFD;
408 break;
409 default:
410 return -EINVAL;
411 }
412
413 return 0;
414 }
415
vfio_ccw_mdev_set_irqs(struct vfio_ccw_private * private,uint32_t flags,uint32_t index,void __user * data)416 static int vfio_ccw_mdev_set_irqs(struct vfio_ccw_private *private,
417 uint32_t flags,
418 uint32_t index,
419 void __user *data)
420 {
421 struct eventfd_ctx **ctx;
422
423 if (!(flags & VFIO_IRQ_SET_ACTION_TRIGGER))
424 return -EINVAL;
425
426 switch (index) {
427 case VFIO_CCW_IO_IRQ_INDEX:
428 ctx = &private->io_trigger;
429 break;
430 case VFIO_CCW_CRW_IRQ_INDEX:
431 ctx = &private->crw_trigger;
432 break;
433 case VFIO_CCW_REQ_IRQ_INDEX:
434 ctx = &private->req_trigger;
435 break;
436 default:
437 return -EINVAL;
438 }
439
440 switch (flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
441 case VFIO_IRQ_SET_DATA_NONE:
442 {
443 if (*ctx)
444 eventfd_signal(*ctx, 1);
445 return 0;
446 }
447 case VFIO_IRQ_SET_DATA_BOOL:
448 {
449 uint8_t trigger;
450
451 if (get_user(trigger, (uint8_t __user *)data))
452 return -EFAULT;
453
454 if (trigger && *ctx)
455 eventfd_signal(*ctx, 1);
456 return 0;
457 }
458 case VFIO_IRQ_SET_DATA_EVENTFD:
459 {
460 int32_t fd;
461
462 if (get_user(fd, (int32_t __user *)data))
463 return -EFAULT;
464
465 if (fd == -1) {
466 if (*ctx)
467 eventfd_ctx_put(*ctx);
468 *ctx = NULL;
469 } else if (fd >= 0) {
470 struct eventfd_ctx *efdctx;
471
472 efdctx = eventfd_ctx_fdget(fd);
473 if (IS_ERR(efdctx))
474 return PTR_ERR(efdctx);
475
476 if (*ctx)
477 eventfd_ctx_put(*ctx);
478
479 *ctx = efdctx;
480 } else
481 return -EINVAL;
482
483 return 0;
484 }
485 default:
486 return -EINVAL;
487 }
488 }
489
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)490 int vfio_ccw_register_dev_region(struct vfio_ccw_private *private,
491 unsigned int subtype,
492 const struct vfio_ccw_regops *ops,
493 size_t size, u32 flags, void *data)
494 {
495 struct vfio_ccw_region *region;
496
497 region = krealloc(private->region,
498 (private->num_regions + 1) * sizeof(*region),
499 GFP_KERNEL);
500 if (!region)
501 return -ENOMEM;
502
503 private->region = region;
504 private->region[private->num_regions].type = VFIO_REGION_TYPE_CCW;
505 private->region[private->num_regions].subtype = subtype;
506 private->region[private->num_regions].ops = ops;
507 private->region[private->num_regions].size = size;
508 private->region[private->num_regions].flags = flags;
509 private->region[private->num_regions].data = data;
510
511 private->num_regions++;
512
513 return 0;
514 }
515
vfio_ccw_unregister_dev_regions(struct vfio_ccw_private * private)516 void vfio_ccw_unregister_dev_regions(struct vfio_ccw_private *private)
517 {
518 int i;
519
520 for (i = 0; i < private->num_regions; i++)
521 private->region[i].ops->release(private, &private->region[i]);
522 private->num_regions = 0;
523 kfree(private->region);
524 private->region = NULL;
525 }
526
vfio_ccw_mdev_ioctl(struct vfio_device * vdev,unsigned int cmd,unsigned long arg)527 static ssize_t vfio_ccw_mdev_ioctl(struct vfio_device *vdev,
528 unsigned int cmd,
529 unsigned long arg)
530 {
531 struct vfio_ccw_private *private =
532 container_of(vdev, struct vfio_ccw_private, vdev);
533 int ret = 0;
534 unsigned long minsz;
535
536 switch (cmd) {
537 case VFIO_DEVICE_GET_INFO:
538 {
539 struct vfio_device_info info;
540
541 minsz = offsetofend(struct vfio_device_info, num_irqs);
542
543 if (copy_from_user(&info, (void __user *)arg, minsz))
544 return -EFAULT;
545
546 if (info.argsz < minsz)
547 return -EINVAL;
548
549 ret = vfio_ccw_mdev_get_device_info(private, &info);
550 if (ret)
551 return ret;
552
553 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
554 }
555 case VFIO_DEVICE_GET_REGION_INFO:
556 {
557 struct vfio_region_info info;
558
559 minsz = offsetofend(struct vfio_region_info, offset);
560
561 if (copy_from_user(&info, (void __user *)arg, minsz))
562 return -EFAULT;
563
564 if (info.argsz < minsz)
565 return -EINVAL;
566
567 ret = vfio_ccw_mdev_get_region_info(private, &info, arg);
568 if (ret)
569 return ret;
570
571 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
572 }
573 case VFIO_DEVICE_GET_IRQ_INFO:
574 {
575 struct vfio_irq_info info;
576
577 minsz = offsetofend(struct vfio_irq_info, count);
578
579 if (copy_from_user(&info, (void __user *)arg, minsz))
580 return -EFAULT;
581
582 if (info.argsz < minsz || info.index >= VFIO_CCW_NUM_IRQS)
583 return -EINVAL;
584
585 ret = vfio_ccw_mdev_get_irq_info(&info);
586 if (ret)
587 return ret;
588
589 if (info.count == -1)
590 return -EINVAL;
591
592 return copy_to_user((void __user *)arg, &info, minsz) ? -EFAULT : 0;
593 }
594 case VFIO_DEVICE_SET_IRQS:
595 {
596 struct vfio_irq_set hdr;
597 size_t data_size;
598 void __user *data;
599
600 minsz = offsetofend(struct vfio_irq_set, count);
601
602 if (copy_from_user(&hdr, (void __user *)arg, minsz))
603 return -EFAULT;
604
605 ret = vfio_set_irqs_validate_and_prepare(&hdr, 1,
606 VFIO_CCW_NUM_IRQS,
607 &data_size);
608 if (ret)
609 return ret;
610
611 data = (void __user *)(arg + minsz);
612 return vfio_ccw_mdev_set_irqs(private, hdr.flags, hdr.index,
613 data);
614 }
615 case VFIO_DEVICE_RESET:
616 return vfio_ccw_mdev_reset(private);
617 default:
618 return -ENOTTY;
619 }
620 }
621
622 /* Request removal of the device*/
vfio_ccw_mdev_request(struct vfio_device * vdev,unsigned int count)623 static void vfio_ccw_mdev_request(struct vfio_device *vdev, unsigned int count)
624 {
625 struct vfio_ccw_private *private =
626 container_of(vdev, struct vfio_ccw_private, vdev);
627 struct device *dev = vdev->dev;
628
629 if (private->req_trigger) {
630 if (!(count % 10))
631 dev_notice_ratelimited(dev,
632 "Relaying device request to user (#%u)\n",
633 count);
634
635 eventfd_signal(private->req_trigger, 1);
636 } else if (count == 0) {
637 dev_notice(dev,
638 "No device request channel registered, blocked until released by user\n");
639 }
640 }
641
642 static const struct vfio_device_ops vfio_ccw_dev_ops = {
643 .open_device = vfio_ccw_mdev_open_device,
644 .close_device = vfio_ccw_mdev_close_device,
645 .read = vfio_ccw_mdev_read,
646 .write = vfio_ccw_mdev_write,
647 .ioctl = vfio_ccw_mdev_ioctl,
648 .request = vfio_ccw_mdev_request,
649 };
650
651 struct mdev_driver vfio_ccw_mdev_driver = {
652 .driver = {
653 .name = "vfio_ccw_mdev",
654 .owner = THIS_MODULE,
655 .mod_name = KBUILD_MODNAME,
656 },
657 .probe = vfio_ccw_mdev_probe,
658 .remove = vfio_ccw_mdev_remove,
659 };
660
661 static const struct mdev_parent_ops vfio_ccw_mdev_ops = {
662 .owner = THIS_MODULE,
663 .device_driver = &vfio_ccw_mdev_driver,
664 .supported_type_groups = mdev_type_groups,
665 };
666
vfio_ccw_mdev_reg(struct subchannel * sch)667 int vfio_ccw_mdev_reg(struct subchannel *sch)
668 {
669 return mdev_register_device(&sch->dev, &vfio_ccw_mdev_ops);
670 }
671
vfio_ccw_mdev_unreg(struct subchannel * sch)672 void vfio_ccw_mdev_unreg(struct subchannel *sch)
673 {
674 mdev_unregister_device(&sch->dev);
675 }
676