mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
825 lines
24 KiB
825 lines
24 KiB
/* SPDX-License-Identifier: (GPL-2.0 OR CDDL-1.0) */ |
|
/* |
|
* vboxguest vmm-req and hgcm-call code, VBoxGuestR0LibHGCMInternal.cpp, |
|
* VBoxGuestR0LibGenericRequest.cpp and RTErrConvertToErrno.cpp in vbox svn. |
|
* |
|
* Copyright (C) 2006-2016 Oracle Corporation |
|
*/ |
|
|
|
#include <linux/errno.h> |
|
#include <linux/io.h> |
|
#include <linux/kernel.h> |
|
#include <linux/mm.h> |
|
#include <linux/module.h> |
|
#include <linux/sizes.h> |
|
#include <linux/slab.h> |
|
#include <linux/uaccess.h> |
|
#include <linux/vmalloc.h> |
|
#include <linux/vbox_err.h> |
|
#include <linux/vbox_utils.h> |
|
#include "vboxguest_core.h" |
|
|
|
/* Get the pointer to the first parameter of a HGCM call request. */ |
|
#define VMMDEV_HGCM_CALL_PARMS(a) \ |
|
((struct vmmdev_hgcm_function_parameter *)( \ |
|
(u8 *)(a) + sizeof(struct vmmdev_hgcm_call))) |
|
|
|
/* The max parameter buffer size for a user request. */ |
|
#define VBG_MAX_HGCM_USER_PARM (24 * SZ_1M) |
|
/* The max parameter buffer size for a kernel request. */ |
|
#define VBG_MAX_HGCM_KERNEL_PARM (16 * SZ_1M) |
|
|
|
#define VBG_DEBUG_PORT 0x504 |
|
|
|
/* This protects vbg_log_buf and serializes VBG_DEBUG_PORT accesses */ |
|
static DEFINE_SPINLOCK(vbg_log_lock); |
|
static char vbg_log_buf[128]; |
|
|
|
#define VBG_LOG(name, pr_func) \ |
|
void name(const char *fmt, ...) \ |
|
{ \ |
|
unsigned long flags; \ |
|
va_list args; \ |
|
int i, count; \ |
|
\ |
|
va_start(args, fmt); \ |
|
spin_lock_irqsave(&vbg_log_lock, flags); \ |
|
\ |
|
count = vscnprintf(vbg_log_buf, sizeof(vbg_log_buf), fmt, args);\ |
|
for (i = 0; i < count; i++) \ |
|
outb(vbg_log_buf[i], VBG_DEBUG_PORT); \ |
|
\ |
|
pr_func("%s", vbg_log_buf); \ |
|
\ |
|
spin_unlock_irqrestore(&vbg_log_lock, flags); \ |
|
va_end(args); \ |
|
} \ |
|
EXPORT_SYMBOL(name) |
|
|
|
VBG_LOG(vbg_info, pr_info); |
|
VBG_LOG(vbg_warn, pr_warn); |
|
VBG_LOG(vbg_err, pr_err); |
|
VBG_LOG(vbg_err_ratelimited, pr_err_ratelimited); |
|
#if defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG) |
|
VBG_LOG(vbg_debug, pr_debug); |
|
#endif |
|
|
|
void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type, |
|
u32 requestor) |
|
{ |
|
struct vmmdev_request_header *req; |
|
int order = get_order(PAGE_ALIGN(len)); |
|
|
|
req = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); |
|
if (!req) |
|
return NULL; |
|
|
|
memset(req, 0xaa, len); |
|
|
|
req->size = len; |
|
req->version = VMMDEV_REQUEST_HEADER_VERSION; |
|
req->request_type = req_type; |
|
req->rc = VERR_GENERAL_FAILURE; |
|
req->reserved1 = 0; |
|
req->requestor = requestor; |
|
|
|
return req; |
|
} |
|
|
|
void vbg_req_free(void *req, size_t len) |
|
{ |
|
if (!req) |
|
return; |
|
|
|
free_pages((unsigned long)req, get_order(PAGE_ALIGN(len))); |
|
} |
|
|
|
/* Note this function returns a VBox status code, not a negative errno!! */ |
|
int vbg_req_perform(struct vbg_dev *gdev, void *req) |
|
{ |
|
unsigned long phys_req = virt_to_phys(req); |
|
|
|
outl(phys_req, gdev->io_port + VMMDEV_PORT_OFF_REQUEST); |
|
/* |
|
* The host changes the request as a result of the outl, make sure |
|
* the outl and any reads of the req happen in the correct order. |
|
*/ |
|
mb(); |
|
|
|
return ((struct vmmdev_request_header *)req)->rc; |
|
} |
|
|
|
static bool hgcm_req_done(struct vbg_dev *gdev, |
|
struct vmmdev_hgcmreq_header *header) |
|
{ |
|
unsigned long flags; |
|
bool done; |
|
|
|
spin_lock_irqsave(&gdev->event_spinlock, flags); |
|
done = header->flags & VMMDEV_HGCM_REQ_DONE; |
|
spin_unlock_irqrestore(&gdev->event_spinlock, flags); |
|
|
|
return done; |
|
} |
|
|
|
int vbg_hgcm_connect(struct vbg_dev *gdev, u32 requestor, |
|
struct vmmdev_hgcm_service_location *loc, |
|
u32 *client_id, int *vbox_status) |
|
{ |
|
struct vmmdev_hgcm_connect *hgcm_connect = NULL; |
|
int rc; |
|
|
|
hgcm_connect = vbg_req_alloc(sizeof(*hgcm_connect), |
|
VMMDEVREQ_HGCM_CONNECT, requestor); |
|
if (!hgcm_connect) |
|
return -ENOMEM; |
|
|
|
hgcm_connect->header.flags = 0; |
|
memcpy(&hgcm_connect->loc, loc, sizeof(*loc)); |
|
hgcm_connect->client_id = 0; |
|
|
|
rc = vbg_req_perform(gdev, hgcm_connect); |
|
|
|
if (rc == VINF_HGCM_ASYNC_EXECUTE) |
|
wait_event(gdev->hgcm_wq, |
|
hgcm_req_done(gdev, &hgcm_connect->header)); |
|
|
|
if (rc >= 0) { |
|
*client_id = hgcm_connect->client_id; |
|
rc = hgcm_connect->header.result; |
|
} |
|
|
|
vbg_req_free(hgcm_connect, sizeof(*hgcm_connect)); |
|
|
|
*vbox_status = rc; |
|
return 0; |
|
} |
|
EXPORT_SYMBOL(vbg_hgcm_connect); |
|
|
|
int vbg_hgcm_disconnect(struct vbg_dev *gdev, u32 requestor, |
|
u32 client_id, int *vbox_status) |
|
{ |
|
struct vmmdev_hgcm_disconnect *hgcm_disconnect = NULL; |
|
int rc; |
|
|
|
hgcm_disconnect = vbg_req_alloc(sizeof(*hgcm_disconnect), |
|
VMMDEVREQ_HGCM_DISCONNECT, |
|
requestor); |
|
if (!hgcm_disconnect) |
|
return -ENOMEM; |
|
|
|
hgcm_disconnect->header.flags = 0; |
|
hgcm_disconnect->client_id = client_id; |
|
|
|
rc = vbg_req_perform(gdev, hgcm_disconnect); |
|
|
|
if (rc == VINF_HGCM_ASYNC_EXECUTE) |
|
wait_event(gdev->hgcm_wq, |
|
hgcm_req_done(gdev, &hgcm_disconnect->header)); |
|
|
|
if (rc >= 0) |
|
rc = hgcm_disconnect->header.result; |
|
|
|
vbg_req_free(hgcm_disconnect, sizeof(*hgcm_disconnect)); |
|
|
|
*vbox_status = rc; |
|
return 0; |
|
} |
|
EXPORT_SYMBOL(vbg_hgcm_disconnect); |
|
|
|
static u32 hgcm_call_buf_size_in_pages(void *buf, u32 len) |
|
{ |
|
u32 size = PAGE_ALIGN(len + ((unsigned long)buf & ~PAGE_MASK)); |
|
|
|
return size >> PAGE_SHIFT; |
|
} |
|
|
|
static void hgcm_call_add_pagelist_size(void *buf, u32 len, size_t *extra) |
|
{ |
|
u32 page_count; |
|
|
|
page_count = hgcm_call_buf_size_in_pages(buf, len); |
|
*extra += offsetof(struct vmmdev_hgcm_pagelist, pages[page_count]); |
|
} |
|
|
|
static int hgcm_call_preprocess_linaddr( |
|
const struct vmmdev_hgcm_function_parameter *src_parm, |
|
void **bounce_buf_ret, size_t *extra) |
|
{ |
|
void *buf, *bounce_buf; |
|
bool copy_in; |
|
u32 len; |
|
int ret; |
|
|
|
buf = (void *)src_parm->u.pointer.u.linear_addr; |
|
len = src_parm->u.pointer.size; |
|
copy_in = src_parm->type != VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT; |
|
|
|
if (len > VBG_MAX_HGCM_USER_PARM) |
|
return -E2BIG; |
|
|
|
bounce_buf = kvmalloc(len, GFP_KERNEL); |
|
if (!bounce_buf) |
|
return -ENOMEM; |
|
|
|
*bounce_buf_ret = bounce_buf; |
|
|
|
if (copy_in) { |
|
ret = copy_from_user(bounce_buf, (void __user *)buf, len); |
|
if (ret) |
|
return -EFAULT; |
|
} else { |
|
memset(bounce_buf, 0, len); |
|
} |
|
|
|
hgcm_call_add_pagelist_size(bounce_buf, len, extra); |
|
return 0; |
|
} |
|
|
|
/** |
|
* Preprocesses the HGCM call, validate parameters, alloc bounce buffers and |
|
* figure out how much extra storage we need for page lists. |
|
* Return: 0 or negative errno value. |
|
* @src_parm: Pointer to source function call parameters |
|
* @parm_count: Number of function call parameters. |
|
* @bounce_bufs_ret: Where to return the allocated bouncebuffer array |
|
* @extra: Where to return the extra request space needed for |
|
* physical page lists. |
|
*/ |
|
static int hgcm_call_preprocess( |
|
const struct vmmdev_hgcm_function_parameter *src_parm, |
|
u32 parm_count, void ***bounce_bufs_ret, size_t *extra) |
|
{ |
|
void *buf, **bounce_bufs = NULL; |
|
u32 i, len; |
|
int ret; |
|
|
|
for (i = 0; i < parm_count; i++, src_parm++) { |
|
switch (src_parm->type) { |
|
case VMMDEV_HGCM_PARM_TYPE_32BIT: |
|
case VMMDEV_HGCM_PARM_TYPE_64BIT: |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
if (!bounce_bufs) { |
|
bounce_bufs = kcalloc(parm_count, |
|
sizeof(void *), |
|
GFP_KERNEL); |
|
if (!bounce_bufs) |
|
return -ENOMEM; |
|
|
|
*bounce_bufs_ret = bounce_bufs; |
|
} |
|
|
|
ret = hgcm_call_preprocess_linaddr(src_parm, |
|
&bounce_bufs[i], |
|
extra); |
|
if (ret) |
|
return ret; |
|
|
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: |
|
buf = (void *)src_parm->u.pointer.u.linear_addr; |
|
len = src_parm->u.pointer.size; |
|
if (WARN_ON(len > VBG_MAX_HGCM_KERNEL_PARM)) |
|
return -E2BIG; |
|
|
|
hgcm_call_add_pagelist_size(buf, len, extra); |
|
break; |
|
|
|
default: |
|
return -EINVAL; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* Translates linear address types to page list direction flags. |
|
* |
|
* Return: page list flags. |
|
* @type: The type. |
|
*/ |
|
static u32 hgcm_call_linear_addr_type_to_pagelist_flags( |
|
enum vmmdev_hgcm_function_parameter_type type) |
|
{ |
|
switch (type) { |
|
default: |
|
WARN_ON(1); |
|
fallthrough; |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: |
|
return VMMDEV_HGCM_F_PARM_DIRECTION_BOTH; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: |
|
return VMMDEV_HGCM_F_PARM_DIRECTION_TO_HOST; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: |
|
return VMMDEV_HGCM_F_PARM_DIRECTION_FROM_HOST; |
|
} |
|
} |
|
|
|
static void hgcm_call_init_linaddr(struct vmmdev_hgcm_call *call, |
|
struct vmmdev_hgcm_function_parameter *dst_parm, void *buf, u32 len, |
|
enum vmmdev_hgcm_function_parameter_type type, u32 *off_extra) |
|
{ |
|
struct vmmdev_hgcm_pagelist *dst_pg_lst; |
|
struct page *page; |
|
bool is_vmalloc; |
|
u32 i, page_count; |
|
|
|
dst_parm->type = type; |
|
|
|
if (len == 0) { |
|
dst_parm->u.pointer.size = 0; |
|
dst_parm->u.pointer.u.linear_addr = 0; |
|
return; |
|
} |
|
|
|
dst_pg_lst = (void *)call + *off_extra; |
|
page_count = hgcm_call_buf_size_in_pages(buf, len); |
|
is_vmalloc = is_vmalloc_addr(buf); |
|
|
|
dst_parm->type = VMMDEV_HGCM_PARM_TYPE_PAGELIST; |
|
dst_parm->u.page_list.size = len; |
|
dst_parm->u.page_list.offset = *off_extra; |
|
dst_pg_lst->flags = hgcm_call_linear_addr_type_to_pagelist_flags(type); |
|
dst_pg_lst->offset_first_page = (unsigned long)buf & ~PAGE_MASK; |
|
dst_pg_lst->page_count = page_count; |
|
|
|
for (i = 0; i < page_count; i++) { |
|
if (is_vmalloc) |
|
page = vmalloc_to_page(buf); |
|
else |
|
page = virt_to_page(buf); |
|
|
|
dst_pg_lst->pages[i] = page_to_phys(page); |
|
buf += PAGE_SIZE; |
|
} |
|
|
|
*off_extra += offsetof(struct vmmdev_hgcm_pagelist, pages[page_count]); |
|
} |
|
|
|
/** |
|
* Initializes the call request that we're sending to the host. |
|
* @call: The call to initialize. |
|
* @client_id: The client ID of the caller. |
|
* @function: The function number of the function to call. |
|
* @src_parm: Pointer to source function call parameters. |
|
* @parm_count: Number of function call parameters. |
|
* @bounce_bufs: The bouncebuffer array. |
|
*/ |
|
static void hgcm_call_init_call( |
|
struct vmmdev_hgcm_call *call, u32 client_id, u32 function, |
|
const struct vmmdev_hgcm_function_parameter *src_parm, |
|
u32 parm_count, void **bounce_bufs) |
|
{ |
|
struct vmmdev_hgcm_function_parameter *dst_parm = |
|
VMMDEV_HGCM_CALL_PARMS(call); |
|
u32 i, off_extra = (uintptr_t)(dst_parm + parm_count) - (uintptr_t)call; |
|
void *buf; |
|
|
|
call->header.flags = 0; |
|
call->header.result = VINF_SUCCESS; |
|
call->client_id = client_id; |
|
call->function = function; |
|
call->parm_count = parm_count; |
|
|
|
for (i = 0; i < parm_count; i++, src_parm++, dst_parm++) { |
|
switch (src_parm->type) { |
|
case VMMDEV_HGCM_PARM_TYPE_32BIT: |
|
case VMMDEV_HGCM_PARM_TYPE_64BIT: |
|
*dst_parm = *src_parm; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
hgcm_call_init_linaddr(call, dst_parm, bounce_bufs[i], |
|
src_parm->u.pointer.size, |
|
src_parm->type, &off_extra); |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: |
|
buf = (void *)src_parm->u.pointer.u.linear_addr; |
|
hgcm_call_init_linaddr(call, dst_parm, buf, |
|
src_parm->u.pointer.size, |
|
src_parm->type, &off_extra); |
|
break; |
|
|
|
default: |
|
WARN_ON(1); |
|
dst_parm->type = VMMDEV_HGCM_PARM_TYPE_INVALID; |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Tries to cancel a pending HGCM call. |
|
* |
|
* Return: VBox status code |
|
*/ |
|
static int hgcm_cancel_call(struct vbg_dev *gdev, struct vmmdev_hgcm_call *call) |
|
{ |
|
int rc; |
|
|
|
/* |
|
* We use a pre-allocated request for cancellations, which is |
|
* protected by cancel_req_mutex. This means that all cancellations |
|
* get serialized, this should be fine since they should be rare. |
|
*/ |
|
mutex_lock(&gdev->cancel_req_mutex); |
|
gdev->cancel_req->phys_req_to_cancel = virt_to_phys(call); |
|
rc = vbg_req_perform(gdev, gdev->cancel_req); |
|
mutex_unlock(&gdev->cancel_req_mutex); |
|
|
|
if (rc == VERR_NOT_IMPLEMENTED) { |
|
call->header.flags |= VMMDEV_HGCM_REQ_CANCELLED; |
|
call->header.header.request_type = VMMDEVREQ_HGCM_CANCEL; |
|
|
|
rc = vbg_req_perform(gdev, call); |
|
if (rc == VERR_INVALID_PARAMETER) |
|
rc = VERR_NOT_FOUND; |
|
} |
|
|
|
if (rc >= 0) |
|
call->header.flags |= VMMDEV_HGCM_REQ_CANCELLED; |
|
|
|
return rc; |
|
} |
|
|
|
/** |
|
* Performs the call and completion wait. |
|
* Return: 0 or negative errno value. |
|
* @gdev: The VBoxGuest device extension. |
|
* @call: The call to execute. |
|
* @timeout_ms: Timeout in ms. |
|
* @leak_it: Where to return the leak it / free it, indicator. |
|
* Cancellation fun. |
|
*/ |
|
static int vbg_hgcm_do_call(struct vbg_dev *gdev, struct vmmdev_hgcm_call *call, |
|
u32 timeout_ms, bool interruptible, bool *leak_it) |
|
{ |
|
int rc, cancel_rc, ret; |
|
long timeout; |
|
|
|
*leak_it = false; |
|
|
|
rc = vbg_req_perform(gdev, call); |
|
|
|
/* |
|
* If the call failed, then pretend success. Upper layers will |
|
* interpret the result code in the packet. |
|
*/ |
|
if (rc < 0) { |
|
call->header.result = rc; |
|
return 0; |
|
} |
|
|
|
if (rc != VINF_HGCM_ASYNC_EXECUTE) |
|
return 0; |
|
|
|
/* Host decided to process the request asynchronously, wait for it */ |
|
if (timeout_ms == U32_MAX) |
|
timeout = MAX_SCHEDULE_TIMEOUT; |
|
else |
|
timeout = msecs_to_jiffies(timeout_ms); |
|
|
|
if (interruptible) { |
|
timeout = wait_event_interruptible_timeout(gdev->hgcm_wq, |
|
hgcm_req_done(gdev, &call->header), |
|
timeout); |
|
} else { |
|
timeout = wait_event_timeout(gdev->hgcm_wq, |
|
hgcm_req_done(gdev, &call->header), |
|
timeout); |
|
} |
|
|
|
/* timeout > 0 means hgcm_req_done has returned true, so success */ |
|
if (timeout > 0) |
|
return 0; |
|
|
|
if (timeout == 0) |
|
ret = -ETIMEDOUT; |
|
else |
|
ret = -EINTR; |
|
|
|
/* Cancel the request */ |
|
cancel_rc = hgcm_cancel_call(gdev, call); |
|
if (cancel_rc >= 0) |
|
return ret; |
|
|
|
/* |
|
* Failed to cancel, this should mean that the cancel has lost the |
|
* race with normal completion, wait while the host completes it. |
|
*/ |
|
if (cancel_rc == VERR_NOT_FOUND || cancel_rc == VERR_SEM_DESTROYED) |
|
timeout = msecs_to_jiffies(500); |
|
else |
|
timeout = msecs_to_jiffies(2000); |
|
|
|
timeout = wait_event_timeout(gdev->hgcm_wq, |
|
hgcm_req_done(gdev, &call->header), |
|
timeout); |
|
|
|
if (WARN_ON(timeout == 0)) { |
|
/* We really should never get here */ |
|
vbg_err("%s: Call timedout and cancellation failed, leaking the request\n", |
|
__func__); |
|
*leak_it = true; |
|
return ret; |
|
} |
|
|
|
/* The call has completed normally after all */ |
|
return 0; |
|
} |
|
|
|
/** |
|
* Copies the result of the call back to the caller info structure and user |
|
* buffers. |
|
* Return: 0 or negative errno value. |
|
* @call: HGCM call request. |
|
* @dst_parm: Pointer to function call parameters destination. |
|
* @parm_count: Number of function call parameters. |
|
* @bounce_bufs: The bouncebuffer array. |
|
*/ |
|
static int hgcm_call_copy_back_result( |
|
const struct vmmdev_hgcm_call *call, |
|
struct vmmdev_hgcm_function_parameter *dst_parm, |
|
u32 parm_count, void **bounce_bufs) |
|
{ |
|
const struct vmmdev_hgcm_function_parameter *src_parm = |
|
VMMDEV_HGCM_CALL_PARMS(call); |
|
void __user *p; |
|
int ret; |
|
u32 i; |
|
|
|
/* Copy back parameters. */ |
|
for (i = 0; i < parm_count; i++, src_parm++, dst_parm++) { |
|
switch (dst_parm->type) { |
|
case VMMDEV_HGCM_PARM_TYPE_32BIT: |
|
case VMMDEV_HGCM_PARM_TYPE_64BIT: |
|
*dst_parm = *src_parm; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_PAGELIST: |
|
dst_parm->u.page_list.size = src_parm->u.page_list.size; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: |
|
dst_parm->u.pointer.size = src_parm->u.pointer.size; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
dst_parm->u.pointer.size = src_parm->u.pointer.size; |
|
|
|
p = (void __user *)dst_parm->u.pointer.u.linear_addr; |
|
ret = copy_to_user(p, bounce_bufs[i], |
|
min(src_parm->u.pointer.size, |
|
dst_parm->u.pointer.size)); |
|
if (ret) |
|
return -EFAULT; |
|
break; |
|
|
|
default: |
|
WARN_ON(1); |
|
return -EINVAL; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int vbg_hgcm_call(struct vbg_dev *gdev, u32 requestor, u32 client_id, |
|
u32 function, u32 timeout_ms, |
|
struct vmmdev_hgcm_function_parameter *parms, u32 parm_count, |
|
int *vbox_status) |
|
{ |
|
struct vmmdev_hgcm_call *call; |
|
void **bounce_bufs = NULL; |
|
bool leak_it; |
|
size_t size; |
|
int i, ret; |
|
|
|
size = sizeof(struct vmmdev_hgcm_call) + |
|
parm_count * sizeof(struct vmmdev_hgcm_function_parameter); |
|
/* |
|
* Validate and buffer the parameters for the call. This also increases |
|
* call_size with the amount of extra space needed for page lists. |
|
*/ |
|
ret = hgcm_call_preprocess(parms, parm_count, &bounce_bufs, &size); |
|
if (ret) { |
|
/* Even on error bounce bufs may still have been allocated */ |
|
goto free_bounce_bufs; |
|
} |
|
|
|
call = vbg_req_alloc(size, VMMDEVREQ_HGCM_CALL, requestor); |
|
if (!call) { |
|
ret = -ENOMEM; |
|
goto free_bounce_bufs; |
|
} |
|
|
|
hgcm_call_init_call(call, client_id, function, parms, parm_count, |
|
bounce_bufs); |
|
|
|
ret = vbg_hgcm_do_call(gdev, call, timeout_ms, |
|
requestor & VMMDEV_REQUESTOR_USERMODE, &leak_it); |
|
if (ret == 0) { |
|
*vbox_status = call->header.result; |
|
ret = hgcm_call_copy_back_result(call, parms, parm_count, |
|
bounce_bufs); |
|
} |
|
|
|
if (!leak_it) |
|
vbg_req_free(call, size); |
|
|
|
free_bounce_bufs: |
|
if (bounce_bufs) { |
|
for (i = 0; i < parm_count; i++) |
|
kvfree(bounce_bufs[i]); |
|
kfree(bounce_bufs); |
|
} |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL(vbg_hgcm_call); |
|
|
|
#ifdef CONFIG_COMPAT |
|
int vbg_hgcm_call32( |
|
struct vbg_dev *gdev, u32 requestor, u32 client_id, u32 function, |
|
u32 timeout_ms, struct vmmdev_hgcm_function_parameter32 *parm32, |
|
u32 parm_count, int *vbox_status) |
|
{ |
|
struct vmmdev_hgcm_function_parameter *parm64 = NULL; |
|
u32 i, size; |
|
int ret = 0; |
|
|
|
/* KISS allocate a temporary request and convert the parameters. */ |
|
size = parm_count * sizeof(struct vmmdev_hgcm_function_parameter); |
|
parm64 = kzalloc(size, GFP_KERNEL); |
|
if (!parm64) |
|
return -ENOMEM; |
|
|
|
for (i = 0; i < parm_count; i++) { |
|
switch (parm32[i].type) { |
|
case VMMDEV_HGCM_PARM_TYPE_32BIT: |
|
parm64[i].type = VMMDEV_HGCM_PARM_TYPE_32BIT; |
|
parm64[i].u.value32 = parm32[i].u.value32; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_64BIT: |
|
parm64[i].type = VMMDEV_HGCM_PARM_TYPE_64BIT; |
|
parm64[i].u.value64 = parm32[i].u.value64; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
parm64[i].type = parm32[i].type; |
|
parm64[i].u.pointer.size = parm32[i].u.pointer.size; |
|
parm64[i].u.pointer.u.linear_addr = |
|
parm32[i].u.pointer.u.linear_addr; |
|
break; |
|
|
|
default: |
|
ret = -EINVAL; |
|
} |
|
if (ret < 0) |
|
goto out_free; |
|
} |
|
|
|
ret = vbg_hgcm_call(gdev, requestor, client_id, function, timeout_ms, |
|
parm64, parm_count, vbox_status); |
|
if (ret < 0) |
|
goto out_free; |
|
|
|
/* Copy back. */ |
|
for (i = 0; i < parm_count; i++, parm32++, parm64++) { |
|
switch (parm64[i].type) { |
|
case VMMDEV_HGCM_PARM_TYPE_32BIT: |
|
parm32[i].u.value32 = parm64[i].u.value32; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_64BIT: |
|
parm32[i].u.value64 = parm64[i].u.value64; |
|
break; |
|
|
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR: |
|
case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: |
|
parm32[i].u.pointer.size = parm64[i].u.pointer.size; |
|
break; |
|
|
|
default: |
|
WARN_ON(1); |
|
ret = -EINVAL; |
|
} |
|
} |
|
|
|
out_free: |
|
kfree(parm64); |
|
return ret; |
|
} |
|
#endif |
|
|
|
static const int vbg_status_code_to_errno_table[] = { |
|
[-VERR_ACCESS_DENIED] = -EPERM, |
|
[-VERR_FILE_NOT_FOUND] = -ENOENT, |
|
[-VERR_PROCESS_NOT_FOUND] = -ESRCH, |
|
[-VERR_INTERRUPTED] = -EINTR, |
|
[-VERR_DEV_IO_ERROR] = -EIO, |
|
[-VERR_TOO_MUCH_DATA] = -E2BIG, |
|
[-VERR_BAD_EXE_FORMAT] = -ENOEXEC, |
|
[-VERR_INVALID_HANDLE] = -EBADF, |
|
[-VERR_TRY_AGAIN] = -EAGAIN, |
|
[-VERR_NO_MEMORY] = -ENOMEM, |
|
[-VERR_INVALID_POINTER] = -EFAULT, |
|
[-VERR_RESOURCE_BUSY] = -EBUSY, |
|
[-VERR_ALREADY_EXISTS] = -EEXIST, |
|
[-VERR_NOT_SAME_DEVICE] = -EXDEV, |
|
[-VERR_NOT_A_DIRECTORY] = -ENOTDIR, |
|
[-VERR_PATH_NOT_FOUND] = -ENOTDIR, |
|
[-VERR_INVALID_NAME] = -ENOENT, |
|
[-VERR_IS_A_DIRECTORY] = -EISDIR, |
|
[-VERR_INVALID_PARAMETER] = -EINVAL, |
|
[-VERR_TOO_MANY_OPEN_FILES] = -ENFILE, |
|
[-VERR_INVALID_FUNCTION] = -ENOTTY, |
|
[-VERR_SHARING_VIOLATION] = -ETXTBSY, |
|
[-VERR_FILE_TOO_BIG] = -EFBIG, |
|
[-VERR_DISK_FULL] = -ENOSPC, |
|
[-VERR_SEEK_ON_DEVICE] = -ESPIPE, |
|
[-VERR_WRITE_PROTECT] = -EROFS, |
|
[-VERR_BROKEN_PIPE] = -EPIPE, |
|
[-VERR_DEADLOCK] = -EDEADLK, |
|
[-VERR_FILENAME_TOO_LONG] = -ENAMETOOLONG, |
|
[-VERR_FILE_LOCK_FAILED] = -ENOLCK, |
|
[-VERR_NOT_IMPLEMENTED] = -ENOSYS, |
|
[-VERR_NOT_SUPPORTED] = -ENOSYS, |
|
[-VERR_DIR_NOT_EMPTY] = -ENOTEMPTY, |
|
[-VERR_TOO_MANY_SYMLINKS] = -ELOOP, |
|
[-VERR_NO_MORE_FILES] = -ENODATA, |
|
[-VERR_NO_DATA] = -ENODATA, |
|
[-VERR_NET_NO_NETWORK] = -ENONET, |
|
[-VERR_NET_NOT_UNIQUE_NAME] = -ENOTUNIQ, |
|
[-VERR_NO_TRANSLATION] = -EILSEQ, |
|
[-VERR_NET_NOT_SOCKET] = -ENOTSOCK, |
|
[-VERR_NET_DEST_ADDRESS_REQUIRED] = -EDESTADDRREQ, |
|
[-VERR_NET_MSG_SIZE] = -EMSGSIZE, |
|
[-VERR_NET_PROTOCOL_TYPE] = -EPROTOTYPE, |
|
[-VERR_NET_PROTOCOL_NOT_AVAILABLE] = -ENOPROTOOPT, |
|
[-VERR_NET_PROTOCOL_NOT_SUPPORTED] = -EPROTONOSUPPORT, |
|
[-VERR_NET_SOCKET_TYPE_NOT_SUPPORTED] = -ESOCKTNOSUPPORT, |
|
[-VERR_NET_OPERATION_NOT_SUPPORTED] = -EOPNOTSUPP, |
|
[-VERR_NET_PROTOCOL_FAMILY_NOT_SUPPORTED] = -EPFNOSUPPORT, |
|
[-VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED] = -EAFNOSUPPORT, |
|
[-VERR_NET_ADDRESS_IN_USE] = -EADDRINUSE, |
|
[-VERR_NET_ADDRESS_NOT_AVAILABLE] = -EADDRNOTAVAIL, |
|
[-VERR_NET_DOWN] = -ENETDOWN, |
|
[-VERR_NET_UNREACHABLE] = -ENETUNREACH, |
|
[-VERR_NET_CONNECTION_RESET] = -ENETRESET, |
|
[-VERR_NET_CONNECTION_ABORTED] = -ECONNABORTED, |
|
[-VERR_NET_CONNECTION_RESET_BY_PEER] = -ECONNRESET, |
|
[-VERR_NET_NO_BUFFER_SPACE] = -ENOBUFS, |
|
[-VERR_NET_ALREADY_CONNECTED] = -EISCONN, |
|
[-VERR_NET_NOT_CONNECTED] = -ENOTCONN, |
|
[-VERR_NET_SHUTDOWN] = -ESHUTDOWN, |
|
[-VERR_NET_TOO_MANY_REFERENCES] = -ETOOMANYREFS, |
|
[-VERR_TIMEOUT] = -ETIMEDOUT, |
|
[-VERR_NET_CONNECTION_REFUSED] = -ECONNREFUSED, |
|
[-VERR_NET_HOST_DOWN] = -EHOSTDOWN, |
|
[-VERR_NET_HOST_UNREACHABLE] = -EHOSTUNREACH, |
|
[-VERR_NET_ALREADY_IN_PROGRESS] = -EALREADY, |
|
[-VERR_NET_IN_PROGRESS] = -EINPROGRESS, |
|
[-VERR_MEDIA_NOT_PRESENT] = -ENOMEDIUM, |
|
[-VERR_MEDIA_NOT_RECOGNIZED] = -EMEDIUMTYPE, |
|
}; |
|
|
|
int vbg_status_code_to_errno(int rc) |
|
{ |
|
if (rc >= 0) |
|
return 0; |
|
|
|
rc = -rc; |
|
if (rc >= ARRAY_SIZE(vbg_status_code_to_errno_table) || |
|
vbg_status_code_to_errno_table[rc] == 0) { |
|
vbg_warn("%s: Unhandled err %d\n", __func__, -rc); |
|
return -EPROTO; |
|
} |
|
|
|
return vbg_status_code_to_errno_table[rc]; |
|
} |
|
EXPORT_SYMBOL(vbg_status_code_to_errno);
|
|
|