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