tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'char-misc-4.17-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc

Pull char/misc driver fixes from Greg KH:
"Here are some small char and misc driver fixes for 4.17-rc3

A variety of small things that have fallen out after 4.17-rc1 was out.
Some vboxguest fixes for systems with lots of memory, amba bus fixes,
some MAINTAINERS updates, uio_hv_generic driver fixes, and a few other
minor things that resolve problems that people reported.

The amba bus fixes took twice to get right, the first time I messed up
applying the patches in the wrong order, hence the revert and later
addition again with the correct fix, sorry about that.

All of these have been in linux-next with no reported issues"

* tag 'char-misc-4.17-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc:
ARM: amba: Fix race condition with driver_override
ARM: amba: Make driver_override output consistent with other buses
Revert "ARM: amba: Fix race condition with driver_override"
ARM: amba: Don't read past the end of sysfs "driver_override" buffer
ARM: amba: Fix race condition with driver_override
virt: vbox: Log an error when we fail to get the host version
virt: vbox: Use __get_free_pages instead of kmalloc for DMA32 memory
virt: vbox: Add vbg_req_free() helper function
virt: vbox: Move declarations of vboxguest private functions to private header
slimbus: Fix out-of-bounds access in slim_slicesize()
MAINTAINERS: add dri-devel&linaro-mm for Android ION
fpga-manager: altera-ps-spi: preserve nCONFIG state
MAINTAINERS: update my email address
uio_hv_generic: fix subchannel ring mmap
uio_hv_generic: use correct channel in isr
uio_hv_generic: make ring buffer attribute for primary channel
uio_hv_generic: set size of ring buffer attribute
ANDROID: binder: prevent transactions into own process.

Linus Torvalds d8a33273 ee3748be

+124 -121
+4 -2
MAINTAINERS
··· 905 905 M: Laura Abbott <labbott@redhat.com> 906 906 M: Sumit Semwal <sumit.semwal@linaro.org> 907 907 L: devel@driverdev.osuosl.org 908 + L: dri-devel@lists.freedesktop.org 909 + L: linaro-mm-sig@lists.linaro.org (moderated for non-subscribers) 908 910 S: Supported 909 911 F: drivers/staging/android/ion 910 912 F: drivers/staging/android/uapi/ion.h ··· 13955 13953 M: Andreas Noever <andreas.noever@gmail.com> 13956 13954 M: Michael Jamet <michael.jamet@intel.com> 13957 13955 M: Mika Westerberg <mika.westerberg@linux.intel.com> 13958 - M: Yehezkel Bernat <yehezkel.bernat@intel.com> 13956 + M: Yehezkel Bernat <YehezkelShB@gmail.com> 13959 13957 T: git git://git.kernel.org/pub/scm/linux/kernel/git/westeri/thunderbolt.git 13960 13958 S: Maintained 13961 13959 F: Documentation/admin-guide/thunderbolt.rst ··· 13965 13963 THUNDERBOLT NETWORK DRIVER 13966 13964 M: Michael Jamet <michael.jamet@intel.com> 13967 13965 M: Mika Westerberg <mika.westerberg@linux.intel.com> 13968 - M: Yehezkel Bernat <yehezkel.bernat@intel.com> 13966 + M: Yehezkel Bernat <YehezkelShB@gmail.com> 13969 13967 L: netdev@vger.kernel.org 13970 13968 S: Maintained 13971 13969 F: drivers/net/thunderbolt.c
+11 -6
drivers/amba/bus.c
··· 69 69 struct device_attribute *attr, char *buf) 70 70 { 71 71 struct amba_device *dev = to_amba_device(_dev); 72 + ssize_t len; 72 73 73 - if (!dev->driver_override) 74 - return 0; 75 - 76 - return sprintf(buf, "%s\n", dev->driver_override); 74 + device_lock(_dev); 75 + len = sprintf(buf, "%s\n", dev->driver_override); 76 + device_unlock(_dev); 77 + return len; 77 78 } 78 79 79 80 static ssize_t driver_override_store(struct device *_dev, ··· 82 81 const char *buf, size_t count) 83 82 { 84 83 struct amba_device *dev = to_amba_device(_dev); 85 - char *driver_override, *old = dev->driver_override, *cp; 84 + char *driver_override, *old, *cp; 86 85 87 - if (count > PATH_MAX) 86 + /* We need to keep extra room for a newline */ 87 + if (count >= (PAGE_SIZE - 1)) 88 88 return -EINVAL; 89 89 90 90 driver_override = kstrndup(buf, count, GFP_KERNEL); ··· 96 94 if (cp) 97 95 *cp = '\0'; 98 96 97 + device_lock(_dev); 98 + old = dev->driver_override; 99 99 if (strlen(driver_override)) { 100 100 dev->driver_override = driver_override; 101 101 } else { 102 102 kfree(driver_override); 103 103 dev->driver_override = NULL; 104 104 } 105 + device_unlock(_dev); 105 106 106 107 kfree(old); 107 108
+8
drivers/android/binder.c
··· 2839 2839 else 2840 2840 return_error = BR_DEAD_REPLY; 2841 2841 mutex_unlock(&context->context_mgr_node_lock); 2842 + if (target_node && target_proc == proc) { 2843 + binder_user_error("%d:%d got transaction to context manager from process owning it\n", 2844 + proc->pid, thread->pid); 2845 + return_error = BR_FAILED_REPLY; 2846 + return_error_param = -EINVAL; 2847 + return_error_line = __LINE__; 2848 + goto err_invalid_target_handle; 2849 + } 2842 2850 } 2843 2851 if (!target_node) { 2844 2852 /*
+1 -1
drivers/fpga/altera-ps-spi.c
··· 249 249 250 250 conf->data = of_id->data; 251 251 conf->spi = spi; 252 - conf->config = devm_gpiod_get(&spi->dev, "nconfig", GPIOD_OUT_HIGH); 252 + conf->config = devm_gpiod_get(&spi->dev, "nconfig", GPIOD_OUT_LOW); 253 253 if (IS_ERR(conf->config)) { 254 254 dev_err(&spi->dev, "Failed to get config gpio: %ld\n", 255 255 PTR_ERR(conf->config));
+1 -1
drivers/slimbus/messaging.c
··· 183 183 0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7 184 184 }; 185 185 186 - clamp(code, 1, (int)ARRAY_SIZE(sizetocode)); 186 + code = clamp(code, 1, (int)ARRAY_SIZE(sizetocode)); 187 187 188 188 return sizetocode[code - 1]; 189 189 }
+23 -49
drivers/uio/uio_hv_generic.c
··· 19 19 * # echo -n "ed963694-e847-4b2a-85af-bc9cfc11d6f3" \ 20 20 * > /sys/bus/vmbus/drivers/uio_hv_generic/bind 21 21 */ 22 - 22 + #define DEBUG 1 23 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 24 25 25 #include <linux/device.h> ··· 94 94 */ 95 95 static void hv_uio_channel_cb(void *context) 96 96 { 97 - struct hv_uio_private_data *pdata = context; 98 - struct hv_device *dev = pdata->device; 97 + struct vmbus_channel *chan = context; 98 + struct hv_device *hv_dev = chan->device_obj; 99 + struct hv_uio_private_data *pdata = hv_get_drvdata(hv_dev); 99 100 100 - dev->channel->inbound.ring_buffer->interrupt_mask = 1; 101 + chan->inbound.ring_buffer->interrupt_mask = 1; 101 102 virt_mb(); 102 103 103 104 uio_event_notify(&pdata->info); ··· 122 121 uio_event_notify(&pdata->info); 123 122 } 124 123 125 - /* 126 - * Handle fault when looking for sub channel ring buffer 127 - * Subchannel ring buffer is same as resource 0 which is main ring buffer 128 - * This is derived from uio_vma_fault 124 + /* Sysfs API to allow mmap of the ring buffers 125 + * The ring buffer is allocated as contiguous memory by vmbus_open 129 126 */ 130 - static int hv_uio_vma_fault(struct vm_fault *vmf) 131 - { 132 - struct vm_area_struct *vma = vmf->vma; 133 - void *ring_buffer = vma->vm_private_data; 134 - struct page *page; 135 - void *addr; 136 - 137 - addr = ring_buffer + (vmf->pgoff << PAGE_SHIFT); 138 - page = virt_to_page(addr); 139 - get_page(page); 140 - vmf->page = page; 141 - return 0; 142 - } 143 - 144 - static const struct vm_operations_struct hv_uio_vm_ops = { 145 - .fault = hv_uio_vma_fault, 146 - }; 147 - 148 - /* Sysfs API to allow mmap of the ring buffers */ 149 127 static int hv_uio_ring_mmap(struct file *filp, struct kobject *kobj, 150 128 struct bin_attribute *attr, 151 129 struct vm_area_struct *vma) 152 130 { 153 131 struct vmbus_channel *channel 154 132 = container_of(kobj, struct vmbus_channel, kobj); 155 - unsigned long requested_pages, actual_pages; 133 + struct hv_device *dev = channel->primary_channel->device_obj; 134 + u16 q_idx = channel->offermsg.offer.sub_channel_index; 156 135 157 - if (vma->vm_end < vma->vm_start) 158 - return -EINVAL; 136 + dev_dbg(&dev->device, "mmap channel %u pages %#lx at %#lx\n", 137 + q_idx, vma_pages(vma), vma->vm_pgoff); 159 138 160 - /* only allow 0 for now */ 161 - if (vma->vm_pgoff > 0) 162 - return -EINVAL; 163 - 164 - requested_pages = vma_pages(vma); 165 - actual_pages = 2 * HV_RING_SIZE; 166 - if (requested_pages > actual_pages) 167 - return -EINVAL; 168 - 169 - vma->vm_private_data = channel->ringbuffer_pages; 170 - vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 171 - vma->vm_ops = &hv_uio_vm_ops; 172 - return 0; 139 + return vm_iomap_memory(vma, virt_to_phys(channel->ringbuffer_pages), 140 + channel->ringbuffer_pagecount << PAGE_SHIFT); 173 141 } 174 142 175 - static struct bin_attribute ring_buffer_bin_attr __ro_after_init = { 143 + static const struct bin_attribute ring_buffer_bin_attr = { 176 144 .attr = { 177 145 .name = "ring", 178 146 .mode = 0600, 179 - /* size is set at init time */ 180 147 }, 148 + .size = 2 * HV_RING_SIZE * PAGE_SIZE, 181 149 .mmap = hv_uio_ring_mmap, 182 150 }; 183 151 184 - /* Callback from VMBUS subystem when new channel created. */ 152 + /* Callback from VMBUS subsystem when new channel created. */ 185 153 static void 186 154 hv_uio_new_channel(struct vmbus_channel *new_sc) 187 155 { 188 156 struct hv_device *hv_dev = new_sc->primary_channel->device_obj; 189 157 struct device *device = &hv_dev->device; 190 - struct hv_uio_private_data *pdata = hv_get_drvdata(hv_dev); 191 158 const size_t ring_bytes = HV_RING_SIZE * PAGE_SIZE; 192 159 int ret; 193 160 194 161 /* Create host communication ring */ 195 162 ret = vmbus_open(new_sc, ring_bytes, ring_bytes, NULL, 0, 196 - hv_uio_channel_cb, pdata); 163 + hv_uio_channel_cb, new_sc); 197 164 if (ret) { 198 165 dev_err(device, "vmbus_open subchannel failed: %d\n", ret); 199 166 return; ··· 203 234 204 235 ret = vmbus_open(dev->channel, HV_RING_SIZE * PAGE_SIZE, 205 236 HV_RING_SIZE * PAGE_SIZE, NULL, 0, 206 - hv_uio_channel_cb, pdata); 237 + hv_uio_channel_cb, dev->channel); 207 238 if (ret) 208 239 goto fail; 209 240 ··· 294 325 295 326 vmbus_set_chn_rescind_callback(dev->channel, hv_uio_rescind); 296 327 vmbus_set_sc_create_callback(dev->channel, hv_uio_new_channel); 328 + 329 + ret = sysfs_create_bin_file(&dev->channel->kobj, &ring_buffer_bin_attr); 330 + if (ret) 331 + dev_notice(&dev->device, 332 + "sysfs create ring bin file failed; %d\n", ret); 297 333 298 334 hv_set_drvdata(dev, pdata); 299 335
+38 -32
drivers/virt/vboxguest/vboxguest_core.c
··· 114 114 } 115 115 116 116 out: 117 - kfree(req); 117 + vbg_req_free(req, sizeof(*req)); 118 118 kfree(pages); 119 119 } 120 120 ··· 144 144 145 145 rc = vbg_req_perform(gdev, req); 146 146 147 - kfree(req); 147 + vbg_req_free(req, sizeof(*req)); 148 148 149 149 if (rc < 0) { 150 150 vbg_err("%s error: %d\n", __func__, rc); ··· 214 214 ret = vbg_status_code_to_errno(rc); 215 215 216 216 out_free: 217 - kfree(req2); 218 - kfree(req1); 217 + vbg_req_free(req2, sizeof(*req2)); 218 + vbg_req_free(req1, sizeof(*req1)); 219 219 return ret; 220 220 } 221 221 ··· 245 245 if (rc == VERR_NOT_IMPLEMENTED) /* Compatibility with older hosts. */ 246 246 rc = VINF_SUCCESS; 247 247 248 - kfree(req); 248 + vbg_req_free(req, sizeof(*req)); 249 249 250 250 return vbg_status_code_to_errno(rc); 251 251 } ··· 431 431 rc = vbg_req_perform(gdev, req); 432 432 do_div(req->interval_ns, 1000000); /* ns -> ms */ 433 433 gdev->heartbeat_interval_ms = req->interval_ns; 434 - kfree(req); 434 + vbg_req_free(req, sizeof(*req)); 435 435 436 436 return vbg_status_code_to_errno(rc); 437 437 } ··· 454 454 if (ret < 0) 455 455 return ret; 456 456 457 - /* 458 - * Preallocate the request to use it from the timer callback because: 459 - * 1) on Windows vbg_req_alloc must be called at IRQL <= APC_LEVEL 460 - * and the timer callback runs at DISPATCH_LEVEL; 461 - * 2) avoid repeated allocations. 462 - */ 463 457 gdev->guest_heartbeat_req = vbg_req_alloc( 464 458 sizeof(*gdev->guest_heartbeat_req), 465 459 VMMDEVREQ_GUEST_HEARTBEAT); ··· 475 481 { 476 482 del_timer_sync(&gdev->heartbeat_timer); 477 483 vbg_heartbeat_host_config(gdev, false); 478 - kfree(gdev->guest_heartbeat_req); 479 - 484 + vbg_req_free(gdev->guest_heartbeat_req, 485 + sizeof(*gdev->guest_heartbeat_req)); 480 486 } 481 487 482 488 /** ··· 537 543 if (rc < 0) 538 544 vbg_err("%s error, rc: %d\n", __func__, rc); 539 545 540 - kfree(req); 546 + vbg_req_free(req, sizeof(*req)); 541 547 return vbg_status_code_to_errno(rc); 542 548 } 543 549 ··· 611 617 612 618 out: 613 619 mutex_unlock(&gdev->session_mutex); 614 - kfree(req); 620 + vbg_req_free(req, sizeof(*req)); 615 621 616 622 return ret; 617 623 } ··· 636 642 if (rc < 0) 637 643 vbg_err("%s error, rc: %d\n", __func__, rc); 638 644 639 - kfree(req); 645 + vbg_req_free(req, sizeof(*req)); 640 646 return vbg_status_code_to_errno(rc); 641 647 } 642 648 ··· 706 712 707 713 out: 708 714 mutex_unlock(&gdev->session_mutex); 709 - kfree(req); 715 + vbg_req_free(req, sizeof(*req)); 710 716 711 717 return ret; 712 718 } ··· 727 733 728 734 rc = vbg_req_perform(gdev, req); 729 735 ret = vbg_status_code_to_errno(rc); 730 - if (ret) 736 + if (ret) { 737 + vbg_err("%s error: %d\n", __func__, rc); 731 738 goto out; 739 + } 732 740 733 741 snprintf(gdev->host_version, sizeof(gdev->host_version), "%u.%u.%ur%u", 734 742 req->major, req->minor, req->build, req->revision); ··· 745 749 } 746 750 747 751 out: 748 - kfree(req); 752 + vbg_req_free(req, sizeof(*req)); 749 753 return ret; 750 754 } 751 755 ··· 843 847 return 0; 844 848 845 849 err_free_reqs: 846 - kfree(gdev->mouse_status_req); 847 - kfree(gdev->ack_events_req); 848 - kfree(gdev->cancel_req); 849 - kfree(gdev->mem_balloon.change_req); 850 - kfree(gdev->mem_balloon.get_req); 850 + vbg_req_free(gdev->mouse_status_req, 851 + sizeof(*gdev->mouse_status_req)); 852 + vbg_req_free(gdev->ack_events_req, 853 + sizeof(*gdev->ack_events_req)); 854 + vbg_req_free(gdev->cancel_req, 855 + sizeof(*gdev->cancel_req)); 856 + vbg_req_free(gdev->mem_balloon.change_req, 857 + sizeof(*gdev->mem_balloon.change_req)); 858 + vbg_req_free(gdev->mem_balloon.get_req, 859 + sizeof(*gdev->mem_balloon.get_req)); 851 860 return ret; 852 861 } 853 862 ··· 873 872 vbg_reset_host_capabilities(gdev); 874 873 vbg_core_set_mouse_status(gdev, 0); 875 874 876 - kfree(gdev->mouse_status_req); 877 - kfree(gdev->ack_events_req); 878 - kfree(gdev->cancel_req); 879 - kfree(gdev->mem_balloon.change_req); 880 - kfree(gdev->mem_balloon.get_req); 875 + vbg_req_free(gdev->mouse_status_req, 876 + sizeof(*gdev->mouse_status_req)); 877 + vbg_req_free(gdev->ack_events_req, 878 + sizeof(*gdev->ack_events_req)); 879 + vbg_req_free(gdev->cancel_req, 880 + sizeof(*gdev->cancel_req)); 881 + vbg_req_free(gdev->mem_balloon.change_req, 882 + sizeof(*gdev->mem_balloon.change_req)); 883 + vbg_req_free(gdev->mem_balloon.get_req, 884 + sizeof(*gdev->mem_balloon.get_req)); 881 885 } 882 886 883 887 /** ··· 1421 1415 req->flags = dump->u.in.flags; 1422 1416 dump->hdr.rc = vbg_req_perform(gdev, req); 1423 1417 1424 - kfree(req); 1418 + vbg_req_free(req, sizeof(*req)); 1425 1419 return 0; 1426 1420 } 1427 1421 ··· 1519 1513 if (rc < 0) 1520 1514 vbg_err("%s error, rc: %d\n", __func__, rc); 1521 1515 1522 - kfree(req); 1516 + vbg_req_free(req, sizeof(*req)); 1523 1517 return vbg_status_code_to_errno(rc); 1524 1518 } 1525 1519
+9
drivers/virt/vboxguest/vboxguest_core.h
··· 171 171 172 172 void vbg_linux_mouse_event(struct vbg_dev *gdev); 173 173 174 + /* Private (non exported) functions form vboxguest_utils.c */ 175 + void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type); 176 + void vbg_req_free(void *req, size_t len); 177 + int vbg_req_perform(struct vbg_dev *gdev, void *req); 178 + int vbg_hgcm_call32( 179 + struct vbg_dev *gdev, u32 client_id, u32 function, u32 timeout_ms, 180 + struct vmmdev_hgcm_function_parameter32 *parm32, u32 parm_count, 181 + int *vbox_status); 182 + 174 183 #endif
+16 -3
drivers/virt/vboxguest/vboxguest_linux.c
··· 87 87 struct vbg_session *session = filp->private_data; 88 88 size_t returned_size, size; 89 89 struct vbg_ioctl_hdr hdr; 90 + bool is_vmmdev_req; 90 91 int ret = 0; 91 92 void *buf; 92 93 ··· 107 106 if (size > SZ_16M) 108 107 return -E2BIG; 109 108 110 - /* __GFP_DMA32 because IOCTL_VMMDEV_REQUEST passes this to the host */ 111 - buf = kmalloc(size, GFP_KERNEL | __GFP_DMA32); 109 + /* 110 + * IOCTL_VMMDEV_REQUEST needs the buffer to be below 4G to avoid 111 + * the need for a bounce-buffer and another copy later on. 112 + */ 113 + is_vmmdev_req = (req & ~IOCSIZE_MASK) == VBG_IOCTL_VMMDEV_REQUEST(0) || 114 + req == VBG_IOCTL_VMMDEV_REQUEST_BIG; 115 + 116 + if (is_vmmdev_req) 117 + buf = vbg_req_alloc(size, VBG_IOCTL_HDR_TYPE_DEFAULT); 118 + else 119 + buf = kmalloc(size, GFP_KERNEL); 112 120 if (!buf) 113 121 return -ENOMEM; 114 122 ··· 142 132 ret = -EFAULT; 143 133 144 134 out: 145 - kfree(buf); 135 + if (is_vmmdev_req) 136 + vbg_req_free(buf, size); 137 + else 138 + kfree(buf); 146 139 147 140 return ret; 148 141 }
+13 -4
drivers/virt/vboxguest/vboxguest_utils.c
··· 65 65 void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type) 66 66 { 67 67 struct vmmdev_request_header *req; 68 + int order = get_order(PAGE_ALIGN(len)); 68 69 69 - req = kmalloc(len, GFP_KERNEL | __GFP_DMA32); 70 + req = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); 70 71 if (!req) 71 72 return NULL; 72 73 ··· 81 80 req->reserved2 = 0; 82 81 83 82 return req; 83 + } 84 + 85 + void vbg_req_free(void *req, size_t len) 86 + { 87 + if (!req) 88 + return; 89 + 90 + free_pages((unsigned long)req, get_order(PAGE_ALIGN(len))); 84 91 } 85 92 86 93 /* Note this function returns a VBox status code, not a negative errno!! */ ··· 146 137 rc = hgcm_connect->header.result; 147 138 } 148 139 149 - kfree(hgcm_connect); 140 + vbg_req_free(hgcm_connect, sizeof(*hgcm_connect)); 150 141 151 142 *vbox_status = rc; 152 143 return 0; ··· 175 166 if (rc >= 0) 176 167 rc = hgcm_disconnect->header.result; 177 168 178 - kfree(hgcm_disconnect); 169 + vbg_req_free(hgcm_disconnect, sizeof(*hgcm_disconnect)); 179 170 180 171 *vbox_status = rc; 181 172 return 0; ··· 632 623 } 633 624 634 625 if (!leak_it) 635 - kfree(call); 626 + vbg_req_free(call, size); 636 627 637 628 free_bounce_bufs: 638 629 if (bounce_bufs) {
-23
include/linux/vbox_utils.h
··· 24 24 #define vbg_debug pr_debug 25 25 #endif 26 26 27 - /** 28 - * Allocate memory for generic request and initialize the request header. 29 - * 30 - * Return: the allocated memory 31 - * @len: Size of memory block required for the request. 32 - * @req_type: The generic request type. 33 - */ 34 - void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type); 35 - 36 - /** 37 - * Perform a generic request. 38 - * 39 - * Return: VBox status code 40 - * @gdev: The Guest extension device. 41 - * @req: Pointer to the request structure. 42 - */ 43 - int vbg_req_perform(struct vbg_dev *gdev, void *req); 44 - 45 27 int vbg_hgcm_connect(struct vbg_dev *gdev, 46 28 struct vmmdev_hgcm_service_location *loc, 47 29 u32 *client_id, int *vbox_status); ··· 33 51 int vbg_hgcm_call(struct vbg_dev *gdev, u32 client_id, u32 function, 34 52 u32 timeout_ms, struct vmmdev_hgcm_function_parameter *parms, 35 53 u32 parm_count, int *vbox_status); 36 - 37 - int vbg_hgcm_call32( 38 - struct vbg_dev *gdev, u32 client_id, u32 function, u32 timeout_ms, 39 - struct vmmdev_hgcm_function_parameter32 *parm32, u32 parm_count, 40 - int *vbox_status); 41 54 42 55 /** 43 56 * Convert a VirtualBox status code to a standard Linux kernel return value.