1 /* SPDX-License-Identifier: (GPL-2.0 OR CDDL-1.0) */ 2 /* 3 * vboxguest vmm-req and hgcm-call code, VBoxGuestR0LibHGCMInternal.cpp, 4 * VBoxGuestR0LibGenericRequest.cpp and RTErrConvertToErrno.cpp in vbox svn. 5 * 6 * Copyright (C) 2006-2016 Oracle Corporation 7 */ 8 9 #include <linux/errno.h> 10 #include <linux/kernel.h> 11 #include <linux/mm.h> 12 #include <linux/module.h> 13 #include <linux/sizes.h> 14 #include <linux/slab.h> 15 #include <linux/uaccess.h> 16 #include <linux/vmalloc.h> 17 #include <linux/vbox_err.h> 18 #include <linux/vbox_utils.h> 19 #include "vboxguest_core.h" 20 21 /* Get the pointer to the first parameter of a HGCM call request. */ 22 #define VMMDEV_HGCM_CALL_PARMS(a) \ 23 ((struct vmmdev_hgcm_function_parameter *)( \ 24 (u8 *)(a) + sizeof(struct vmmdev_hgcm_call))) 25 26 /* The max parameter buffer size for a user request. */ 27 #define VBG_MAX_HGCM_USER_PARM (24 * SZ_1M) 28 /* The max parameter buffer size for a kernel request. */ 29 #define VBG_MAX_HGCM_KERNEL_PARM (16 * SZ_1M) 30 31 #define VBG_DEBUG_PORT 0x504 32 33 /* This protects vbg_log_buf and serializes VBG_DEBUG_PORT accesses */ 34 static DEFINE_SPINLOCK(vbg_log_lock); 35 static char vbg_log_buf[128]; 36 37 #define VBG_LOG(name, pr_func) \ 38 void name(const char *fmt, ...) \ 39 { \ 40 unsigned long flags; \ 41 va_list args; \ 42 int i, count; \ 43 \ 44 va_start(args, fmt); \ 45 spin_lock_irqsave(&vbg_log_lock, flags); \ 46 \ 47 count = vscnprintf(vbg_log_buf, sizeof(vbg_log_buf), fmt, args);\ 48 for (i = 0; i < count; i++) \ 49 outb(vbg_log_buf[i], VBG_DEBUG_PORT); \ 50 \ 51 pr_func("%s", vbg_log_buf); \ 52 \ 53 spin_unlock_irqrestore(&vbg_log_lock, flags); \ 54 va_end(args); \ 55 } \ 56 EXPORT_SYMBOL(name) 57 58 VBG_LOG(vbg_info, pr_info); 59 VBG_LOG(vbg_warn, pr_warn); 60 VBG_LOG(vbg_err, pr_err); 61 #if defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG) 62 VBG_LOG(vbg_debug, pr_debug); 63 #endif 64 65 void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type) 66 { 67 struct vmmdev_request_header *req; 68 int order = get_order(PAGE_ALIGN(len)); 69 70 req = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); 71 if (!req) 72 return NULL; 73 74 memset(req, 0xaa, len); 75 76 req->size = len; 77 req->version = VMMDEV_REQUEST_HEADER_VERSION; 78 req->request_type = req_type; 79 req->rc = VERR_GENERAL_FAILURE; 80 req->reserved1 = 0; 81 req->reserved2 = 0; 82 83 return req; 84 } 85 86 void vbg_req_free(void *req, size_t len) 87 { 88 if (!req) 89 return; 90 91 free_pages((unsigned long)req, get_order(PAGE_ALIGN(len))); 92 } 93 94 /* Note this function returns a VBox status code, not a negative errno!! */ 95 int vbg_req_perform(struct vbg_dev *gdev, void *req) 96 { 97 unsigned long phys_req = virt_to_phys(req); 98 99 outl(phys_req, gdev->io_port + VMMDEV_PORT_OFF_REQUEST); 100 /* 101 * The host changes the request as a result of the outl, make sure 102 * the outl and any reads of the req happen in the correct order. 103 */ 104 mb(); 105 106 return ((struct vmmdev_request_header *)req)->rc; 107 } 108 109 static bool hgcm_req_done(struct vbg_dev *gdev, 110 struct vmmdev_hgcmreq_header *header) 111 { 112 unsigned long flags; 113 bool done; 114 115 spin_lock_irqsave(&gdev->event_spinlock, flags); 116 done = header->flags & VMMDEV_HGCM_REQ_DONE; 117 spin_unlock_irqrestore(&gdev->event_spinlock, flags); 118 119 return done; 120 } 121 122 int vbg_hgcm_connect(struct vbg_dev *gdev, 123 struct vmmdev_hgcm_service_location *loc, 124 u32 *client_id, int *vbox_status) 125 { 126 struct vmmdev_hgcm_connect *hgcm_connect = NULL; 127 int rc; 128 129 hgcm_connect = vbg_req_alloc(sizeof(*hgcm_connect), 130 VMMDEVREQ_HGCM_CONNECT); 131 if (!hgcm_connect) 132 return -ENOMEM; 133 134 hgcm_connect->header.flags = 0; 135 memcpy(&hgcm_connect->loc, loc, sizeof(*loc)); 136 hgcm_connect->client_id = 0; 137 138 rc = vbg_req_perform(gdev, hgcm_connect); 139 140 if (rc == VINF_HGCM_ASYNC_EXECUTE) 141 wait_event(gdev->hgcm_wq, 142 hgcm_req_done(gdev, &hgcm_connect->header)); 143 144 if (rc >= 0) { 145 *client_id = hgcm_connect->client_id; 146 rc = hgcm_connect->header.result; 147 } 148 149 vbg_req_free(hgcm_connect, sizeof(*hgcm_connect)); 150 151 *vbox_status = rc; 152 return 0; 153 } 154 EXPORT_SYMBOL(vbg_hgcm_connect); 155 156 int vbg_hgcm_disconnect(struct vbg_dev *gdev, u32 client_id, int *vbox_status) 157 { 158 struct vmmdev_hgcm_disconnect *hgcm_disconnect = NULL; 159 int rc; 160 161 hgcm_disconnect = vbg_req_alloc(sizeof(*hgcm_disconnect), 162 VMMDEVREQ_HGCM_DISCONNECT); 163 if (!hgcm_disconnect) 164 return -ENOMEM; 165 166 hgcm_disconnect->header.flags = 0; 167 hgcm_disconnect->client_id = client_id; 168 169 rc = vbg_req_perform(gdev, hgcm_disconnect); 170 171 if (rc == VINF_HGCM_ASYNC_EXECUTE) 172 wait_event(gdev->hgcm_wq, 173 hgcm_req_done(gdev, &hgcm_disconnect->header)); 174 175 if (rc >= 0) 176 rc = hgcm_disconnect->header.result; 177 178 vbg_req_free(hgcm_disconnect, sizeof(*hgcm_disconnect)); 179 180 *vbox_status = rc; 181 return 0; 182 } 183 EXPORT_SYMBOL(vbg_hgcm_disconnect); 184 185 static u32 hgcm_call_buf_size_in_pages(void *buf, u32 len) 186 { 187 u32 size = PAGE_ALIGN(len + ((unsigned long)buf & ~PAGE_MASK)); 188 189 return size >> PAGE_SHIFT; 190 } 191 192 static void hgcm_call_add_pagelist_size(void *buf, u32 len, size_t *extra) 193 { 194 u32 page_count; 195 196 page_count = hgcm_call_buf_size_in_pages(buf, len); 197 *extra += offsetof(struct vmmdev_hgcm_pagelist, pages[page_count]); 198 } 199 200 static int hgcm_call_preprocess_linaddr( 201 const struct vmmdev_hgcm_function_parameter *src_parm, 202 void **bounce_buf_ret, size_t *extra) 203 { 204 void *buf, *bounce_buf; 205 bool copy_in; 206 u32 len; 207 int ret; 208 209 buf = (void *)src_parm->u.pointer.u.linear_addr; 210 len = src_parm->u.pointer.size; 211 copy_in = src_parm->type != VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT; 212 213 if (len > VBG_MAX_HGCM_USER_PARM) 214 return -E2BIG; 215 216 bounce_buf = kvmalloc(len, GFP_KERNEL); 217 if (!bounce_buf) 218 return -ENOMEM; 219 220 if (copy_in) { 221 ret = copy_from_user(bounce_buf, (void __user *)buf, len); 222 if (ret) 223 return -EFAULT; 224 } else { 225 memset(bounce_buf, 0, len); 226 } 227 228 *bounce_buf_ret = bounce_buf; 229 hgcm_call_add_pagelist_size(bounce_buf, len, extra); 230 return 0; 231 } 232 233 /** 234 * Preprocesses the HGCM call, validate parameters, alloc bounce buffers and 235 * figure out how much extra storage we need for page lists. 236 * Return: 0 or negative errno value. 237 * @src_parm: Pointer to source function call parameters 238 * @parm_count: Number of function call parameters. 239 * @bounce_bufs_ret: Where to return the allocated bouncebuffer array 240 * @extra: Where to return the extra request space needed for 241 * physical page lists. 242 */ 243 static int hgcm_call_preprocess( 244 const struct vmmdev_hgcm_function_parameter *src_parm, 245 u32 parm_count, void ***bounce_bufs_ret, size_t *extra) 246 { 247 void *buf, **bounce_bufs = NULL; 248 u32 i, len; 249 int ret; 250 251 for (i = 0; i < parm_count; i++, src_parm++) { 252 switch (src_parm->type) { 253 case VMMDEV_HGCM_PARM_TYPE_32BIT: 254 case VMMDEV_HGCM_PARM_TYPE_64BIT: 255 break; 256 257 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 258 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 259 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 260 if (!bounce_bufs) { 261 bounce_bufs = kcalloc(parm_count, 262 sizeof(void *), 263 GFP_KERNEL); 264 if (!bounce_bufs) 265 return -ENOMEM; 266 267 *bounce_bufs_ret = bounce_bufs; 268 } 269 270 ret = hgcm_call_preprocess_linaddr(src_parm, 271 &bounce_bufs[i], 272 extra); 273 if (ret) 274 return ret; 275 276 break; 277 278 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: 279 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: 280 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: 281 buf = (void *)src_parm->u.pointer.u.linear_addr; 282 len = src_parm->u.pointer.size; 283 if (WARN_ON(len > VBG_MAX_HGCM_KERNEL_PARM)) 284 return -E2BIG; 285 286 hgcm_call_add_pagelist_size(buf, len, extra); 287 break; 288 289 default: 290 return -EINVAL; 291 } 292 } 293 294 return 0; 295 } 296 297 /** 298 * Translates linear address types to page list direction flags. 299 * 300 * Return: page list flags. 301 * @type: The type. 302 */ 303 static u32 hgcm_call_linear_addr_type_to_pagelist_flags( 304 enum vmmdev_hgcm_function_parameter_type type) 305 { 306 switch (type) { 307 default: 308 WARN_ON(1); 309 /* Fall through */ 310 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 311 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: 312 return VMMDEV_HGCM_F_PARM_DIRECTION_BOTH; 313 314 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 315 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: 316 return VMMDEV_HGCM_F_PARM_DIRECTION_TO_HOST; 317 318 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 319 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: 320 return VMMDEV_HGCM_F_PARM_DIRECTION_FROM_HOST; 321 } 322 } 323 324 static void hgcm_call_init_linaddr(struct vmmdev_hgcm_call *call, 325 struct vmmdev_hgcm_function_parameter *dst_parm, void *buf, u32 len, 326 enum vmmdev_hgcm_function_parameter_type type, u32 *off_extra) 327 { 328 struct vmmdev_hgcm_pagelist *dst_pg_lst; 329 struct page *page; 330 bool is_vmalloc; 331 u32 i, page_count; 332 333 dst_parm->type = type; 334 335 if (len == 0) { 336 dst_parm->u.pointer.size = 0; 337 dst_parm->u.pointer.u.linear_addr = 0; 338 return; 339 } 340 341 dst_pg_lst = (void *)call + *off_extra; 342 page_count = hgcm_call_buf_size_in_pages(buf, len); 343 is_vmalloc = is_vmalloc_addr(buf); 344 345 dst_parm->type = VMMDEV_HGCM_PARM_TYPE_PAGELIST; 346 dst_parm->u.page_list.size = len; 347 dst_parm->u.page_list.offset = *off_extra; 348 dst_pg_lst->flags = hgcm_call_linear_addr_type_to_pagelist_flags(type); 349 dst_pg_lst->offset_first_page = (unsigned long)buf & ~PAGE_MASK; 350 dst_pg_lst->page_count = page_count; 351 352 for (i = 0; i < page_count; i++) { 353 if (is_vmalloc) 354 page = vmalloc_to_page(buf); 355 else 356 page = virt_to_page(buf); 357 358 dst_pg_lst->pages[i] = page_to_phys(page); 359 buf += PAGE_SIZE; 360 } 361 362 *off_extra += offsetof(struct vmmdev_hgcm_pagelist, pages[page_count]); 363 } 364 365 /** 366 * Initializes the call request that we're sending to the host. 367 * @call: The call to initialize. 368 * @client_id: The client ID of the caller. 369 * @function: The function number of the function to call. 370 * @src_parm: Pointer to source function call parameters. 371 * @parm_count: Number of function call parameters. 372 * @bounce_bufs: The bouncebuffer array. 373 */ 374 static void hgcm_call_init_call( 375 struct vmmdev_hgcm_call *call, u32 client_id, u32 function, 376 const struct vmmdev_hgcm_function_parameter *src_parm, 377 u32 parm_count, void **bounce_bufs) 378 { 379 struct vmmdev_hgcm_function_parameter *dst_parm = 380 VMMDEV_HGCM_CALL_PARMS(call); 381 u32 i, off_extra = (uintptr_t)(dst_parm + parm_count) - (uintptr_t)call; 382 void *buf; 383 384 call->header.flags = 0; 385 call->header.result = VINF_SUCCESS; 386 call->client_id = client_id; 387 call->function = function; 388 call->parm_count = parm_count; 389 390 for (i = 0; i < parm_count; i++, src_parm++, dst_parm++) { 391 switch (src_parm->type) { 392 case VMMDEV_HGCM_PARM_TYPE_32BIT: 393 case VMMDEV_HGCM_PARM_TYPE_64BIT: 394 *dst_parm = *src_parm; 395 break; 396 397 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 398 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 399 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 400 hgcm_call_init_linaddr(call, dst_parm, bounce_bufs[i], 401 src_parm->u.pointer.size, 402 src_parm->type, &off_extra); 403 break; 404 405 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: 406 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: 407 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: 408 buf = (void *)src_parm->u.pointer.u.linear_addr; 409 hgcm_call_init_linaddr(call, dst_parm, buf, 410 src_parm->u.pointer.size, 411 src_parm->type, &off_extra); 412 break; 413 414 default: 415 WARN_ON(1); 416 dst_parm->type = VMMDEV_HGCM_PARM_TYPE_INVALID; 417 } 418 } 419 } 420 421 /** 422 * Tries to cancel a pending HGCM call. 423 * 424 * Return: VBox status code 425 */ 426 static int hgcm_cancel_call(struct vbg_dev *gdev, struct vmmdev_hgcm_call *call) 427 { 428 int rc; 429 430 /* 431 * We use a pre-allocated request for cancellations, which is 432 * protected by cancel_req_mutex. This means that all cancellations 433 * get serialized, this should be fine since they should be rare. 434 */ 435 mutex_lock(&gdev->cancel_req_mutex); 436 gdev->cancel_req->phys_req_to_cancel = virt_to_phys(call); 437 rc = vbg_req_perform(gdev, gdev->cancel_req); 438 mutex_unlock(&gdev->cancel_req_mutex); 439 440 if (rc == VERR_NOT_IMPLEMENTED) { 441 call->header.flags |= VMMDEV_HGCM_REQ_CANCELLED; 442 call->header.header.request_type = VMMDEVREQ_HGCM_CANCEL; 443 444 rc = vbg_req_perform(gdev, call); 445 if (rc == VERR_INVALID_PARAMETER) 446 rc = VERR_NOT_FOUND; 447 } 448 449 if (rc >= 0) 450 call->header.flags |= VMMDEV_HGCM_REQ_CANCELLED; 451 452 return rc; 453 } 454 455 /** 456 * Performs the call and completion wait. 457 * Return: 0 or negative errno value. 458 * @gdev: The VBoxGuest device extension. 459 * @call: The call to execute. 460 * @timeout_ms: Timeout in ms. 461 * @leak_it: Where to return the leak it / free it, indicator. 462 * Cancellation fun. 463 */ 464 static int vbg_hgcm_do_call(struct vbg_dev *gdev, struct vmmdev_hgcm_call *call, 465 u32 timeout_ms, bool *leak_it) 466 { 467 int rc, cancel_rc, ret; 468 long timeout; 469 470 *leak_it = false; 471 472 rc = vbg_req_perform(gdev, call); 473 474 /* 475 * If the call failed, then pretend success. Upper layers will 476 * interpret the result code in the packet. 477 */ 478 if (rc < 0) { 479 call->header.result = rc; 480 return 0; 481 } 482 483 if (rc != VINF_HGCM_ASYNC_EXECUTE) 484 return 0; 485 486 /* Host decided to process the request asynchronously, wait for it */ 487 if (timeout_ms == U32_MAX) 488 timeout = MAX_SCHEDULE_TIMEOUT; 489 else 490 timeout = msecs_to_jiffies(timeout_ms); 491 492 timeout = wait_event_interruptible_timeout( 493 gdev->hgcm_wq, 494 hgcm_req_done(gdev, &call->header), 495 timeout); 496 497 /* timeout > 0 means hgcm_req_done has returned true, so success */ 498 if (timeout > 0) 499 return 0; 500 501 if (timeout == 0) 502 ret = -ETIMEDOUT; 503 else 504 ret = -EINTR; 505 506 /* Cancel the request */ 507 cancel_rc = hgcm_cancel_call(gdev, call); 508 if (cancel_rc >= 0) 509 return ret; 510 511 /* 512 * Failed to cancel, this should mean that the cancel has lost the 513 * race with normal completion, wait while the host completes it. 514 */ 515 if (cancel_rc == VERR_NOT_FOUND || cancel_rc == VERR_SEM_DESTROYED) 516 timeout = msecs_to_jiffies(500); 517 else 518 timeout = msecs_to_jiffies(2000); 519 520 timeout = wait_event_timeout(gdev->hgcm_wq, 521 hgcm_req_done(gdev, &call->header), 522 timeout); 523 524 if (WARN_ON(timeout == 0)) { 525 /* We really should never get here */ 526 vbg_err("%s: Call timedout and cancellation failed, leaking the request\n", 527 __func__); 528 *leak_it = true; 529 return ret; 530 } 531 532 /* The call has completed normally after all */ 533 return 0; 534 } 535 536 /** 537 * Copies the result of the call back to the caller info structure and user 538 * buffers. 539 * Return: 0 or negative errno value. 540 * @call: HGCM call request. 541 * @dst_parm: Pointer to function call parameters destination. 542 * @parm_count: Number of function call parameters. 543 * @bounce_bufs: The bouncebuffer array. 544 */ 545 static int hgcm_call_copy_back_result( 546 const struct vmmdev_hgcm_call *call, 547 struct vmmdev_hgcm_function_parameter *dst_parm, 548 u32 parm_count, void **bounce_bufs) 549 { 550 const struct vmmdev_hgcm_function_parameter *src_parm = 551 VMMDEV_HGCM_CALL_PARMS(call); 552 void __user *p; 553 int ret; 554 u32 i; 555 556 /* Copy back parameters. */ 557 for (i = 0; i < parm_count; i++, src_parm++, dst_parm++) { 558 switch (dst_parm->type) { 559 case VMMDEV_HGCM_PARM_TYPE_32BIT: 560 case VMMDEV_HGCM_PARM_TYPE_64BIT: 561 *dst_parm = *src_parm; 562 break; 563 564 case VMMDEV_HGCM_PARM_TYPE_PAGELIST: 565 dst_parm->u.page_list.size = src_parm->u.page_list.size; 566 break; 567 568 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 569 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL: 570 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_IN: 571 case VMMDEV_HGCM_PARM_TYPE_LINADDR_KERNEL_OUT: 572 dst_parm->u.pointer.size = src_parm->u.pointer.size; 573 break; 574 575 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 576 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 577 dst_parm->u.pointer.size = src_parm->u.pointer.size; 578 579 p = (void __user *)dst_parm->u.pointer.u.linear_addr; 580 ret = copy_to_user(p, bounce_bufs[i], 581 min(src_parm->u.pointer.size, 582 dst_parm->u.pointer.size)); 583 if (ret) 584 return -EFAULT; 585 break; 586 587 default: 588 WARN_ON(1); 589 return -EINVAL; 590 } 591 } 592 593 return 0; 594 } 595 596 int vbg_hgcm_call(struct vbg_dev *gdev, u32 client_id, u32 function, 597 u32 timeout_ms, struct vmmdev_hgcm_function_parameter *parms, 598 u32 parm_count, int *vbox_status) 599 { 600 struct vmmdev_hgcm_call *call; 601 void **bounce_bufs = NULL; 602 bool leak_it; 603 size_t size; 604 int i, ret; 605 606 size = sizeof(struct vmmdev_hgcm_call) + 607 parm_count * sizeof(struct vmmdev_hgcm_function_parameter); 608 /* 609 * Validate and buffer the parameters for the call. This also increases 610 * call_size with the amount of extra space needed for page lists. 611 */ 612 ret = hgcm_call_preprocess(parms, parm_count, &bounce_bufs, &size); 613 if (ret) { 614 /* Even on error bounce bufs may still have been allocated */ 615 goto free_bounce_bufs; 616 } 617 618 call = vbg_req_alloc(size, VMMDEVREQ_HGCM_CALL); 619 if (!call) { 620 ret = -ENOMEM; 621 goto free_bounce_bufs; 622 } 623 624 hgcm_call_init_call(call, client_id, function, parms, parm_count, 625 bounce_bufs); 626 627 ret = vbg_hgcm_do_call(gdev, call, timeout_ms, &leak_it); 628 if (ret == 0) { 629 *vbox_status = call->header.result; 630 ret = hgcm_call_copy_back_result(call, parms, parm_count, 631 bounce_bufs); 632 } 633 634 if (!leak_it) 635 vbg_req_free(call, size); 636 637 free_bounce_bufs: 638 if (bounce_bufs) { 639 for (i = 0; i < parm_count; i++) 640 kvfree(bounce_bufs[i]); 641 kfree(bounce_bufs); 642 } 643 644 return ret; 645 } 646 EXPORT_SYMBOL(vbg_hgcm_call); 647 648 #ifdef CONFIG_COMPAT 649 int vbg_hgcm_call32( 650 struct vbg_dev *gdev, u32 client_id, u32 function, u32 timeout_ms, 651 struct vmmdev_hgcm_function_parameter32 *parm32, u32 parm_count, 652 int *vbox_status) 653 { 654 struct vmmdev_hgcm_function_parameter *parm64 = NULL; 655 u32 i, size; 656 int ret = 0; 657 658 /* KISS allocate a temporary request and convert the parameters. */ 659 size = parm_count * sizeof(struct vmmdev_hgcm_function_parameter); 660 parm64 = kzalloc(size, GFP_KERNEL); 661 if (!parm64) 662 return -ENOMEM; 663 664 for (i = 0; i < parm_count; i++) { 665 switch (parm32[i].type) { 666 case VMMDEV_HGCM_PARM_TYPE_32BIT: 667 parm64[i].type = VMMDEV_HGCM_PARM_TYPE_32BIT; 668 parm64[i].u.value32 = parm32[i].u.value32; 669 break; 670 671 case VMMDEV_HGCM_PARM_TYPE_64BIT: 672 parm64[i].type = VMMDEV_HGCM_PARM_TYPE_64BIT; 673 parm64[i].u.value64 = parm32[i].u.value64; 674 break; 675 676 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 677 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 678 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 679 parm64[i].type = parm32[i].type; 680 parm64[i].u.pointer.size = parm32[i].u.pointer.size; 681 parm64[i].u.pointer.u.linear_addr = 682 parm32[i].u.pointer.u.linear_addr; 683 break; 684 685 default: 686 ret = -EINVAL; 687 } 688 if (ret < 0) 689 goto out_free; 690 } 691 692 ret = vbg_hgcm_call(gdev, client_id, function, timeout_ms, 693 parm64, parm_count, vbox_status); 694 if (ret < 0) 695 goto out_free; 696 697 /* Copy back. */ 698 for (i = 0; i < parm_count; i++, parm32++, parm64++) { 699 switch (parm64[i].type) { 700 case VMMDEV_HGCM_PARM_TYPE_32BIT: 701 parm32[i].u.value32 = parm64[i].u.value32; 702 break; 703 704 case VMMDEV_HGCM_PARM_TYPE_64BIT: 705 parm32[i].u.value64 = parm64[i].u.value64; 706 break; 707 708 case VMMDEV_HGCM_PARM_TYPE_LINADDR_OUT: 709 case VMMDEV_HGCM_PARM_TYPE_LINADDR: 710 case VMMDEV_HGCM_PARM_TYPE_LINADDR_IN: 711 parm32[i].u.pointer.size = parm64[i].u.pointer.size; 712 break; 713 714 default: 715 WARN_ON(1); 716 ret = -EINVAL; 717 } 718 } 719 720 out_free: 721 kfree(parm64); 722 return ret; 723 } 724 #endif 725 726 static const int vbg_status_code_to_errno_table[] = { 727 [-VERR_ACCESS_DENIED] = -EPERM, 728 [-VERR_FILE_NOT_FOUND] = -ENOENT, 729 [-VERR_PROCESS_NOT_FOUND] = -ESRCH, 730 [-VERR_INTERRUPTED] = -EINTR, 731 [-VERR_DEV_IO_ERROR] = -EIO, 732 [-VERR_TOO_MUCH_DATA] = -E2BIG, 733 [-VERR_BAD_EXE_FORMAT] = -ENOEXEC, 734 [-VERR_INVALID_HANDLE] = -EBADF, 735 [-VERR_TRY_AGAIN] = -EAGAIN, 736 [-VERR_NO_MEMORY] = -ENOMEM, 737 [-VERR_INVALID_POINTER] = -EFAULT, 738 [-VERR_RESOURCE_BUSY] = -EBUSY, 739 [-VERR_ALREADY_EXISTS] = -EEXIST, 740 [-VERR_NOT_SAME_DEVICE] = -EXDEV, 741 [-VERR_NOT_A_DIRECTORY] = -ENOTDIR, 742 [-VERR_PATH_NOT_FOUND] = -ENOTDIR, 743 [-VERR_INVALID_NAME] = -ENOENT, 744 [-VERR_IS_A_DIRECTORY] = -EISDIR, 745 [-VERR_INVALID_PARAMETER] = -EINVAL, 746 [-VERR_TOO_MANY_OPEN_FILES] = -ENFILE, 747 [-VERR_INVALID_FUNCTION] = -ENOTTY, 748 [-VERR_SHARING_VIOLATION] = -ETXTBSY, 749 [-VERR_FILE_TOO_BIG] = -EFBIG, 750 [-VERR_DISK_FULL] = -ENOSPC, 751 [-VERR_SEEK_ON_DEVICE] = -ESPIPE, 752 [-VERR_WRITE_PROTECT] = -EROFS, 753 [-VERR_BROKEN_PIPE] = -EPIPE, 754 [-VERR_DEADLOCK] = -EDEADLK, 755 [-VERR_FILENAME_TOO_LONG] = -ENAMETOOLONG, 756 [-VERR_FILE_LOCK_FAILED] = -ENOLCK, 757 [-VERR_NOT_IMPLEMENTED] = -ENOSYS, 758 [-VERR_NOT_SUPPORTED] = -ENOSYS, 759 [-VERR_DIR_NOT_EMPTY] = -ENOTEMPTY, 760 [-VERR_TOO_MANY_SYMLINKS] = -ELOOP, 761 [-VERR_NO_MORE_FILES] = -ENODATA, 762 [-VERR_NO_DATA] = -ENODATA, 763 [-VERR_NET_NO_NETWORK] = -ENONET, 764 [-VERR_NET_NOT_UNIQUE_NAME] = -ENOTUNIQ, 765 [-VERR_NO_TRANSLATION] = -EILSEQ, 766 [-VERR_NET_NOT_SOCKET] = -ENOTSOCK, 767 [-VERR_NET_DEST_ADDRESS_REQUIRED] = -EDESTADDRREQ, 768 [-VERR_NET_MSG_SIZE] = -EMSGSIZE, 769 [-VERR_NET_PROTOCOL_TYPE] = -EPROTOTYPE, 770 [-VERR_NET_PROTOCOL_NOT_AVAILABLE] = -ENOPROTOOPT, 771 [-VERR_NET_PROTOCOL_NOT_SUPPORTED] = -EPROTONOSUPPORT, 772 [-VERR_NET_SOCKET_TYPE_NOT_SUPPORTED] = -ESOCKTNOSUPPORT, 773 [-VERR_NET_OPERATION_NOT_SUPPORTED] = -EOPNOTSUPP, 774 [-VERR_NET_PROTOCOL_FAMILY_NOT_SUPPORTED] = -EPFNOSUPPORT, 775 [-VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED] = -EAFNOSUPPORT, 776 [-VERR_NET_ADDRESS_IN_USE] = -EADDRINUSE, 777 [-VERR_NET_ADDRESS_NOT_AVAILABLE] = -EADDRNOTAVAIL, 778 [-VERR_NET_DOWN] = -ENETDOWN, 779 [-VERR_NET_UNREACHABLE] = -ENETUNREACH, 780 [-VERR_NET_CONNECTION_RESET] = -ENETRESET, 781 [-VERR_NET_CONNECTION_ABORTED] = -ECONNABORTED, 782 [-VERR_NET_CONNECTION_RESET_BY_PEER] = -ECONNRESET, 783 [-VERR_NET_NO_BUFFER_SPACE] = -ENOBUFS, 784 [-VERR_NET_ALREADY_CONNECTED] = -EISCONN, 785 [-VERR_NET_NOT_CONNECTED] = -ENOTCONN, 786 [-VERR_NET_SHUTDOWN] = -ESHUTDOWN, 787 [-VERR_NET_TOO_MANY_REFERENCES] = -ETOOMANYREFS, 788 [-VERR_TIMEOUT] = -ETIMEDOUT, 789 [-VERR_NET_CONNECTION_REFUSED] = -ECONNREFUSED, 790 [-VERR_NET_HOST_DOWN] = -EHOSTDOWN, 791 [-VERR_NET_HOST_UNREACHABLE] = -EHOSTUNREACH, 792 [-VERR_NET_ALREADY_IN_PROGRESS] = -EALREADY, 793 [-VERR_NET_IN_PROGRESS] = -EINPROGRESS, 794 [-VERR_MEDIA_NOT_PRESENT] = -ENOMEDIUM, 795 [-VERR_MEDIA_NOT_RECOGNIZED] = -EMEDIUMTYPE, 796 }; 797 798 int vbg_status_code_to_errno(int rc) 799 { 800 if (rc >= 0) 801 return 0; 802 803 rc = -rc; 804 if (rc >= ARRAY_SIZE(vbg_status_code_to_errno_table) || 805 vbg_status_code_to_errno_table[rc] == 0) { 806 vbg_warn("%s: Unhandled err %d\n", __func__, -rc); 807 return -EPROTO; 808 } 809 810 return vbg_status_code_to_errno_table[rc]; 811 } 812 EXPORT_SYMBOL(vbg_status_code_to_errno); 813