xref: /titanic_51/usr/src/uts/i86xpv/io/privcmd_hcall.c (revision bb1fad37c75defa7a6ae25f00c1d4b356713b734)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/xpv_user.h>
27 
28 #include <sys/types.h>
29 #include <sys/file.h>
30 #include <sys/errno.h>
31 #include <sys/open.h>
32 #include <sys/cred.h>
33 #include <sys/conf.h>
34 #include <sys/stat.h>
35 #include <sys/modctl.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 #include <sys/vmsystm.h>
39 #include <sys/hypervisor.h>
40 #include <sys/xen_errno.h>
41 #include <sys/sysmacros.h>
42 #include <sys/sdt.h>
43 
44 #include <xen/sys/privcmd.h>
45 #include <sys/privcmd_impl.h>
46 
47 typedef struct import_export {
48 	void *			ie_uaddr;
49 	void *			ie_kaddr;
50 	size_t			ie_size;
51 	uint32_t		ie_flags;
52 } import_export_t;
53 
54 static import_export_t null_ie = {NULL, NULL, 0, 0};
55 
56 #define	IE_IMPORT	0x0001		/* Data needs to be copied in */
57 #define	IE_EXPORT	0x0002		/* Data needs to be copied out */
58 #define	IE_FREE		0x0004
59 #define	IE_IMPEXP	(IE_IMPORT | IE_EXPORT)
60 
61 static void *
62 uaddr_from_handle(void *field)
63 {
64 	struct { void *p; } *hdl = field;
65 	void *ptr;
66 
67 	/*LINTED: constant in conditional context*/
68 	get_xen_guest_handle(ptr, (*hdl));
69 	return (ptr);
70 }
71 
72 
73 /*
74  * Import a buffer from user-space.  If the caller provides a kernel
75  * address, we import to that address.  If not, we kmem_alloc() the space
76  * ourselves.
77  */
78 static int
79 import_buffer(import_export_t *iep, void *uaddr, void *kaddr, size_t size,
80     uint32_t flags)
81 {
82 	iep->ie_uaddr = uaddr;
83 	iep->ie_size = size;
84 	iep->ie_flags = flags & IE_EXPORT;
85 
86 	if (size == 0 || uaddr == NULL) {
87 		*iep = null_ie;
88 		return (0);
89 	}
90 
91 	if (kaddr == NULL) {
92 		iep->ie_kaddr = kmem_alloc(size, KM_SLEEP);
93 		iep->ie_flags |= IE_FREE;
94 	} else {
95 		iep->ie_kaddr = kaddr;
96 		iep->ie_flags &= ~IE_FREE;
97 	}
98 
99 	if ((flags & IE_IMPORT) &&
100 	    (ddi_copyin(uaddr, iep->ie_kaddr, size, 0) != 0)) {
101 		if (iep->ie_flags & IE_FREE) {
102 			kmem_free(iep->ie_kaddr, iep->ie_size);
103 			iep->ie_kaddr = NULL;
104 			iep->ie_flags = 0;
105 		}
106 		return (-X_EFAULT);
107 	}
108 
109 	return (0);
110 }
111 
112 static void
113 export_buffer(import_export_t *iep, int *error)
114 {
115 	int copy_err = 0;
116 
117 	if (iep->ie_size == 0 || iep->ie_uaddr == NULL)
118 		return;
119 
120 	/*
121 	 * If the buffer was marked for export initially, and if the
122 	 * hypercall completed successfully, resync the user-space buffer
123 	 * with our in-kernel buffer.
124 	 */
125 	if ((iep->ie_flags & IE_EXPORT) && (*error >= 0) &&
126 	    (ddi_copyout(iep->ie_kaddr, iep->ie_uaddr, iep->ie_size, 0) != 0))
127 		copy_err = -X_EFAULT;
128 	if (iep->ie_flags & IE_FREE) {
129 		kmem_free(iep->ie_kaddr, iep->ie_size);
130 		iep->ie_kaddr = NULL;
131 		iep->ie_flags = 0;
132 	}
133 
134 	if (copy_err != 0 && *error >= 0)
135 		*error = copy_err;
136 }
137 
138 /*
139  * Xen 'op' structures often include pointers disguised as 'handles', which
140  * refer to addresses in user space.  This routine copies a buffer
141  * associated with an embedded pointer into kernel space, and replaces the
142  * pointer to userspace with a pointer to the new kernel buffer.
143  *
144  * Note: if Xen ever redefines the structure of a 'handle', this routine
145  * (specifically the definition of 'hdl') will need to be updated.
146  */
147 static int
148 import_handle(import_export_t *iep, void *field, size_t size, int flags)
149 {
150 	struct { void *p; } *hdl = field;
151 	void *ptr;
152 	int err;
153 
154 	ptr = uaddr_from_handle(field);
155 	err = import_buffer(iep, ptr, NULL, size, (flags));
156 	if (err == 0) {
157 		/*LINTED: constant in conditional context*/
158 		set_xen_guest_handle((*hdl), (void *)((iep)->ie_kaddr));
159 	}
160 	return (err);
161 }
162 
163 static int
164 privcmd_HYPERVISOR_mmu_update(mmu_update_t *ureq, int count, int *scount,
165     domid_t domid)
166 {
167 	mmu_update_t *kreq, single_kreq;
168 	import_export_t cnt_ie, req_ie;
169 	int error, kscount, bytes;
170 
171 	bytes = count * sizeof (*kreq);
172 	kreq = (count == 1) ? &single_kreq : kmem_alloc(bytes, KM_SLEEP);
173 
174 	error = import_buffer(&cnt_ie, scount, &kscount, sizeof (kscount),
175 	    IE_IMPEXP);
176 	if (error != 0)
177 		req_ie = null_ie;
178 	else
179 		error = import_buffer(&req_ie, ureq, kreq, bytes, IE_IMPEXP);
180 
181 	DTRACE_XPV3(mmu__update__start, int, domid, int, count, mmu_update_t *,
182 	    ((error == -X_EFAULT) ? ureq : kreq));
183 
184 	if (error == 0)
185 		error = HYPERVISOR_mmu_update(kreq, count, &kscount, domid);
186 	export_buffer(&cnt_ie, &error);
187 	export_buffer(&req_ie, &error);
188 	if (count != 1)
189 		kmem_free(kreq, bytes);
190 
191 	DTRACE_XPV1(mmu__update__end, int, error);
192 	return (error);
193 }
194 
195 static int
196 privcmd_HYPERVISOR_domctl(xen_domctl_t *opp)
197 {
198 	xen_domctl_t op;
199 	import_export_t op_ie, sub_ie;
200 	int error = 0;
201 
202 	if ((error = import_buffer(&op_ie, opp, &op, sizeof (op),
203 	    IE_IMPEXP)) != 0)
204 		return (error);
205 
206 	sub_ie = null_ie;
207 
208 	/*
209 	 * Check this first because our wrapper will forcibly overwrite it.
210 	 */
211 	if (op.interface_version != XEN_DOMCTL_INTERFACE_VERSION) {
212 #ifdef DEBUG
213 		printf("domctl vers mismatch (cmd %d, found 0x%x, need 0x%x\n",
214 		    op.cmd, op.interface_version, XEN_DOMCTL_INTERFACE_VERSION);
215 #endif
216 		error = -X_EACCES;
217 		export_buffer(&op_ie, &error);
218 		return (error);
219 	}
220 
221 	/*
222 	 * Now handle any domctl ops with embedded pointers elsewhere
223 	 * in the user address space that also need to be tacked down
224 	 * while the hypervisor futzes with them.
225 	 */
226 	switch (op.cmd) {
227 	case XEN_DOMCTL_createdomain:
228 		DTRACE_XPV1(dom__create__start, xen_domctl_t *,
229 		    &op.u.createdomain);
230 		break;
231 
232 	case XEN_DOMCTL_destroydomain:
233 		DTRACE_XPV1(dom__destroy__start, domid_t, op.domain);
234 		break;
235 
236 	case XEN_DOMCTL_pausedomain:
237 		DTRACE_XPV1(dom__pause__start, domid_t, op.domain);
238 		break;
239 
240 	case XEN_DOMCTL_unpausedomain:
241 		DTRACE_XPV1(dom__unpause__start, domid_t, op.domain);
242 		break;
243 
244 	case XEN_DOMCTL_getmemlist: {
245 		error = import_handle(&sub_ie, &op.u.getmemlist.buffer,
246 		    op.u.getmemlist.max_pfns * sizeof (xen_pfn_t), IE_EXPORT);
247 		break;
248 	}
249 
250 	case XEN_DOMCTL_getpageframeinfo2: {
251 		error = import_handle(&sub_ie, &op.u.getpageframeinfo2.array,
252 		    op.u.getpageframeinfo2.num * sizeof (ulong_t), IE_IMPEXP);
253 		break;
254 	}
255 
256 	case XEN_DOMCTL_shadow_op: {
257 		size_t size;
258 
259 		size = roundup(howmany(op.u.shadow_op.pages, NBBY),
260 		    sizeof (ulong_t));
261 		error = import_handle(&sub_ie,
262 		    &op.u.shadow_op.dirty_bitmap, size, IE_IMPEXP);
263 		break;
264 	}
265 
266 	case XEN_DOMCTL_setvcpucontext: {
267 		vcpu_guest_context_t *taddr;
268 		error = import_handle(&sub_ie, &op.u.vcpucontext.ctxt,
269 		    sizeof (vcpu_guest_context_t), IE_IMPORT);
270 		if (error == -X_EFAULT)
271 			/*LINTED: constant in conditional context*/
272 			get_xen_guest_handle_u(taddr, op.u.vcpucontext.ctxt);
273 		else
274 			taddr = sub_ie.ie_kaddr;
275 		DTRACE_XPV2(setvcpucontext__start, domid_t, op.domain,
276 		    vcpu_guest_context_t *, taddr);
277 		break;
278 	}
279 
280 	case XEN_DOMCTL_getvcpucontext: {
281 		error = import_handle(&sub_ie, &op.u.vcpucontext.ctxt,
282 		    sizeof (vcpu_guest_context_t), IE_EXPORT);
283 		break;
284 	}
285 
286 
287 	case XEN_DOMCTL_sethvmcontext: {
288 		error = import_handle(&sub_ie, &op.u.hvmcontext.buffer,
289 		    op.u.hvmcontext.size, IE_IMPORT);
290 		break;
291 	}
292 
293 	case XEN_DOMCTL_gethvmcontext: {
294 #if !defined(__GNUC__) && defined(__i386__)
295 		if (op.u.hvmcontext.buffer.u.p != NULL)
296 #else
297 		if (op.u.hvmcontext.buffer.p != NULL)
298 #endif
299 			error = import_handle(&sub_ie, &op.u.hvmcontext.buffer,
300 			    op.u.hvmcontext.size, IE_EXPORT);
301 		break;
302 	}
303 
304 	case XEN_DOMCTL_getdomaininfo:
305 	case XEN_DOMCTL_getpageframeinfo:
306 	case XEN_DOMCTL_max_mem:
307 	case XEN_DOMCTL_resumedomain:
308 	case XEN_DOMCTL_getvcpuinfo:
309 	case XEN_DOMCTL_setvcpuaffinity:
310 	case XEN_DOMCTL_getvcpuaffinity:
311 	case XEN_DOMCTL_max_vcpus:
312 	case XEN_DOMCTL_scheduler_op:
313 	case XEN_DOMCTL_setdomainhandle:
314 	case XEN_DOMCTL_setdebugging:
315 	case XEN_DOMCTL_irq_permission:
316 	case XEN_DOMCTL_iomem_permission:
317 	case XEN_DOMCTL_ioport_permission:
318 	case XEN_DOMCTL_hypercall_init:
319 	case XEN_DOMCTL_arch_setup:
320 	case XEN_DOMCTL_settimeoffset:
321 	case XEN_DOMCTL_real_mode_area:
322 	case XEN_DOMCTL_sendtrigger:
323 	case XEN_DOMCTL_assign_device:
324 	case XEN_DOMCTL_bind_pt_irq:
325 	case XEN_DOMCTL_get_address_size:
326 	case XEN_DOMCTL_set_address_size:
327 	case XEN_DOMCTL_get_ext_vcpucontext:
328 	case XEN_DOMCTL_set_ext_vcpucontext:
329 	case XEN_DOMCTL_set_opt_feature:
330 	case XEN_DOMCTL_memory_mapping:
331 	case XEN_DOMCTL_ioport_mapping:
332 	case XEN_DOMCTL_pin_mem_cacheattr:
333 	case XEN_DOMCTL_test_assign_device:
334 	case XEN_DOMCTL_set_target:
335 	case XEN_DOMCTL_deassign_device:
336 	case XEN_DOMCTL_set_cpuid:
337 	case XEN_DOMCTL_get_device_group:
338 	case XEN_DOMCTL_get_machine_address_size:
339 	case XEN_DOMCTL_set_machine_address_size:
340 	case XEN_DOMCTL_suppress_spurious_page_faults:
341 		break;
342 
343 	default:
344 #ifdef DEBUG
345 		printf("unrecognized HYPERVISOR_domctl %d\n", op.cmd);
346 #endif
347 		error = -X_EINVAL;
348 	}
349 
350 	if (error == 0)
351 		error = HYPERVISOR_domctl(&op);
352 
353 	export_buffer(&op_ie, &error);
354 	export_buffer(&sub_ie, &error);
355 
356 	switch (op.cmd) {
357 	case XEN_DOMCTL_createdomain:
358 		DTRACE_XPV1(dom__create__end, int, error);
359 		break;
360 	case XEN_DOMCTL_destroydomain:
361 		DTRACE_XPV1(dom__destroy__end, int, error);
362 		break;
363 	case XEN_DOMCTL_pausedomain:
364 		DTRACE_XPV1(dom__pause__end, int, error);
365 		break;
366 	case XEN_DOMCTL_unpausedomain:
367 		DTRACE_XPV1(dom__unpause__end, int, error);
368 		break;
369 	case XEN_DOMCTL_setvcpucontext:
370 		DTRACE_XPV1(setvcpucontext__end, int, error);
371 		break;
372 	default:
373 		;
374 	}
375 
376 	return (error);
377 }
378 
379 static int
380 privcmd_HYPERVISOR_sysctl(xen_sysctl_t *opp)
381 {
382 	xen_sysctl_t op, dop;
383 	import_export_t op_ie, sub_ie, sub2_ie;
384 	int error = 0;
385 
386 	if (import_buffer(&op_ie, opp, &op, sizeof (op), IE_IMPEXP) != 0)
387 		return (-X_EFAULT);
388 
389 	sub_ie = null_ie;
390 	sub2_ie = null_ie;
391 
392 	/*
393 	 * Check this first because our wrapper will forcibly overwrite it.
394 	 */
395 	if (op.interface_version != XEN_SYSCTL_INTERFACE_VERSION) {
396 		error = -X_EACCES;
397 		export_buffer(&op_ie, &error);
398 		return (error);
399 	}
400 
401 	switch (op.cmd) {
402 	case XEN_SYSCTL_readconsole: {
403 		error = import_handle(&sub_ie, &op.u.readconsole.buffer,
404 		    op.u.readconsole.count, IE_EXPORT);
405 		break;
406 	}
407 
408 	case XEN_SYSCTL_debug_keys: {
409 		error = import_handle(&sub_ie, &op.u.debug_keys.keys,
410 		    op.u.debug_keys.nr_keys, IE_IMPORT);
411 		break;
412 	}
413 
414 	case XEN_SYSCTL_tbuf_op:
415 	case XEN_SYSCTL_physinfo: {
416 		if (uaddr_from_handle(&op.u.physinfo.cpu_to_node) != NULL &&
417 		    op.u.physinfo.max_cpu_id != 0) {
418 			error = import_handle(&sub_ie,
419 			    &op.u.physinfo.cpu_to_node,
420 			    op.u.physinfo.max_cpu_id * sizeof (uint32_t),
421 			    IE_EXPORT);
422 		}
423 		break;
424 	}
425 	case XEN_SYSCTL_sched_id:
426 	case XEN_SYSCTL_availheap:
427 	case XEN_SYSCTL_cpu_hotplug:
428 		break;
429 	case XEN_SYSCTL_get_pmstat: {
430 		unsigned int maxs;
431 
432 		switch (op.u.get_pmstat.type) {
433 		case PMSTAT_get_pxstat:
434 			/*
435 			 * This interface is broken. Xen always copies out
436 			 * all the state information, and the interface
437 			 * does not specify how much space the caller has
438 			 * reserved. So, the only thing to do is just mirror
439 			 * the hypervisor and libxc behavior, and use the
440 			 * maximum amount of data.
441 			 */
442 			dop.cmd = XEN_SYSCTL_get_pmstat;
443 			dop.interface_version = XEN_SYSCTL_INTERFACE_VERSION;
444 			dop.u.get_pmstat.cpuid = op.u.get_pmstat.cpuid;
445 			dop.u.get_pmstat.type = PMSTAT_get_max_px;
446 			error = HYPERVISOR_sysctl(&dop);
447 			if (error != 0)
448 				break;
449 
450 			maxs = dop.u.get_pmstat.u.getpx.total;
451 			if (maxs == 0) {
452 				error = -X_EINVAL;
453 				break;
454 			}
455 
456 			error = import_handle(&sub_ie,
457 			    &op.u.get_pmstat.u.getpx.trans_pt,
458 			    maxs * maxs * sizeof (uint64_t), IE_EXPORT);
459 			if (error != 0)
460 				break;
461 
462 			error = import_handle(&sub2_ie,
463 			    &op.u.get_pmstat.u.getpx.pt,
464 			    maxs * sizeof (pm_px_val_t), IE_EXPORT);
465 			break;
466 		case PMSTAT_get_cxstat:
467 			/* See above */
468 			dop.cmd = XEN_SYSCTL_get_pmstat;
469 			dop.interface_version = XEN_SYSCTL_INTERFACE_VERSION;
470 			dop.u.get_pmstat.cpuid = op.u.get_pmstat.cpuid;
471 			dop.u.get_pmstat.type = PMSTAT_get_max_cx;
472 			error = HYPERVISOR_sysctl(&dop);
473 			if (error != 0)
474 				break;
475 
476 			maxs = dop.u.get_pmstat.u.getcx.nr;
477 			if (maxs == 0) {
478 				error = -X_EINVAL;
479 				break;
480 			}
481 
482 			error = import_handle(&sub_ie,
483 			    &op.u.get_pmstat.u.getcx.triggers,
484 			    maxs * sizeof (uint64_t), IE_EXPORT);
485 			if (error != 0)
486 				break;
487 			error = import_handle(&sub2_ie,
488 			    &op.u.get_pmstat.u.getcx.residencies,
489 			    maxs * sizeof (uint64_t), IE_EXPORT);
490 			break;
491 
492 		case PMSTAT_get_max_px:
493 		case PMSTAT_reset_pxstat:
494 		case PMSTAT_get_max_cx:
495 		case PMSTAT_reset_cxstat:
496 			break;
497 		default:
498 			error = -X_EINVAL;
499 			break;
500 		}
501 		break;
502 	}
503 
504 	case XEN_SYSCTL_perfc_op: {
505 		xen_sysctl_perfc_desc_t *scdp;
506 		/*
507 		 * If 'desc' is NULL, then the caller is asking for
508 		 * the number of counters.  If 'desc' is non-NULL,
509 		 * then we need to know how many counters there are
510 		 * before wiring down the output buffer appropriately.
511 		 */
512 		/*LINTED: constant in conditional context*/
513 		get_xen_guest_handle_u(scdp, op.u.perfc_op.desc);
514 		if (scdp != NULL) {
515 			static int numcounters = -1;
516 			static int numvals = -1;
517 
518 			if (numcounters == -1) {
519 				dop.cmd = XEN_SYSCTL_perfc_op;
520 				dop.interface_version =
521 				    XEN_SYSCTL_INTERFACE_VERSION;
522 				dop.u.perfc_op.cmd = XEN_SYSCTL_PERFCOP_query;
523 				/*LINTED: constant in conditional context*/
524 				set_xen_guest_handle_u(dop.u.perfc_op.desc,
525 				    NULL);
526 				/*LINTED: constant in conditional context*/
527 				set_xen_guest_handle_u(dop.u.perfc_op.val,
528 				    NULL);
529 
530 				error = HYPERVISOR_sysctl(&dop);
531 				if (error != 0)
532 					break;
533 				numcounters = dop.u.perfc_op.nr_counters;
534 				numvals = dop.u.perfc_op.nr_vals;
535 			}
536 			ASSERT(numcounters != -1);
537 			ASSERT(numvals != -1);
538 			error = import_handle(&sub_ie, &op.u.perfc_op.desc,
539 			    (sizeof (xen_sysctl_perfc_desc_t) * numcounters),
540 			    IE_EXPORT);
541 			error = import_handle(&sub2_ie, &op.u.perfc_op.val,
542 			    (sizeof (xen_sysctl_perfc_val_t) * numvals),
543 			    IE_EXPORT);
544 		}
545 		break;
546 	}
547 
548 	case XEN_SYSCTL_getdomaininfolist: {
549 		error = import_handle(&sub_ie, &op.u.getdomaininfolist.buffer,
550 		    (op.u.getdomaininfolist.max_domains *
551 		    sizeof (xen_domctl_getdomaininfo_t)), IE_EXPORT);
552 		break;
553 	}
554 
555 	case XEN_SYSCTL_getcpuinfo:
556 		error = import_handle(&sub_ie, &op.u.getcpuinfo.info,
557 		    op.u.getcpuinfo.max_cpus *
558 		    sizeof (xen_sysctl_cpuinfo_t), IE_EXPORT);
559 		break;
560 	default:
561 #ifdef DEBUG
562 		printf("unrecognized HYPERVISOR_sysctl %d\n", op.cmd);
563 #endif
564 		error = -X_EINVAL;
565 	}
566 
567 	if (error == 0)
568 		error = HYPERVISOR_sysctl(&op);
569 
570 	export_buffer(&op_ie, &error);
571 	export_buffer(&sub_ie, &error);
572 	export_buffer(&sub2_ie, &error);
573 
574 	return (error);
575 }
576 
577 static int
578 privcmd_HYPERVISOR_platform_op(xen_platform_op_t *opp)
579 {
580 	import_export_t op_ie, sub_ie, sub2_ie;
581 	xen_platform_op_t op;
582 	int error;
583 
584 	if (import_buffer(&op_ie, opp, &op, sizeof (op), IE_IMPEXP) != 0)
585 		return (-X_EFAULT);
586 
587 	sub_ie = null_ie;
588 	sub2_ie = null_ie;
589 
590 	/*
591 	 * Check this first because our wrapper will forcibly overwrite it.
592 	 */
593 	if (op.interface_version != XENPF_INTERFACE_VERSION) {
594 		error = -X_EACCES;
595 		export_buffer(&op_ie, &error);
596 		return (error);
597 	}
598 
599 	/*
600 	 * Now handle any platform ops with embedded pointers elsewhere
601 	 * in the user address space that also need to be tacked down
602 	 * while the hypervisor futzes with them.
603 	 */
604 	switch (op.cmd) {
605 	case XENPF_settime:
606 	case XENPF_add_memtype:
607 	case XENPF_del_memtype:
608 	case XENPF_read_memtype:
609 	case XENPF_platform_quirk:
610 	case XENPF_enter_acpi_sleep:
611 	case XENPF_change_freq:
612 	case XENPF_panic_init:
613 		break;
614 
615 	case XENPF_microcode_update:
616 		error = import_handle(&sub_ie, &op.u.microcode.data,
617 		    op.u.microcode.length, IE_IMPORT);
618 		break;
619 	case XENPF_getidletime:
620 		error = import_handle(&sub_ie, &op.u.getidletime.cpumap_bitmap,
621 		    op.u.getidletime.cpumap_nr_cpus, IE_IMPEXP);
622 		if (error != 0)
623 			break;
624 
625 		error = import_handle(&sub2_ie, &op.u.getidletime.idletime,
626 		    op.u.getidletime.cpumap_nr_cpus * sizeof (uint64_t),
627 		    IE_EXPORT);
628 		break;
629 
630 	case XENPF_set_processor_pminfo: {
631 		size_t s;
632 
633 		switch (op.u.set_pminfo.type) {
634 		case XEN_PM_PX:
635 			s = op.u.set_pminfo.u.perf.state_count *
636 			    sizeof (xen_processor_px_t);
637 			if (op.u.set_pminfo.u.perf.flags & XEN_PX_PSS) {
638 				error = import_handle(&sub_ie,
639 				    &op.u.set_pminfo.u.perf.states, s,
640 				    IE_IMPORT);
641 			}
642 			break;
643 		case XEN_PM_CX:
644 			s = op.u.set_pminfo.u.power.count *
645 			    sizeof (xen_processor_cx_t);
646 			error = import_handle(&sub_ie,
647 			    &op.u.set_pminfo.u.power.states, s, IE_IMPORT);
648 			break;
649 		case XEN_PM_TX:
650 			break;
651 		default:
652 			error = -X_EINVAL;
653 			break;
654 		}
655 		break;
656 	}
657 	case XENPF_firmware_info: {
658 		uint16_t len;
659 		void *uaddr;
660 
661 		switch (op.u.firmware_info.type) {
662 		case XEN_FW_DISK_INFO:
663 			/*
664 			 * Ugh.. another hokey interface. The first 16 bits
665 			 * of the buffer are also used as the (input) length.
666 			 */
667 			uaddr = uaddr_from_handle(
668 			    &op.u.firmware_info.u.disk_info.edd_params);
669 			error = ddi_copyin(uaddr, &len, sizeof (len), 0);
670 			if (error != 0)
671 				break;
672 			error = import_handle(&sub_ie,
673 			    &op.u.firmware_info.u.disk_info.edd_params, len,
674 			    IE_IMPEXP);
675 			break;
676 		case XEN_FW_VBEDDC_INFO:
677 			error = import_handle(&sub_ie,
678 			    &op.u.firmware_info.u.vbeddc_info.edid, 128,
679 			    IE_EXPORT);
680 			break;
681 		case XEN_FW_DISK_MBR_SIGNATURE:
682 		default:
683 			break;
684 		}
685 		break;
686 	}
687 	default:
688 		/* FIXME: see this with non-existed ID 38 ???? */
689 #ifdef DEBUG
690 		printf("unrecognized HYPERVISOR_platform_op %d pid %d\n",
691 		    op.cmd, curthread->t_procp->p_pid);
692 #endif
693 		return (-X_EINVAL);
694 	}
695 
696 	if (error == 0)
697 		error = HYPERVISOR_platform_op(&op);
698 
699 	export_buffer(&op_ie, &error);
700 	export_buffer(&sub_ie, &error);
701 	export_buffer(&sub2_ie, &error);
702 
703 	return (error);
704 }
705 
706 static int
707 privcmd_HYPERVISOR_memory_op(int cmd, void *arg)
708 {
709 	int error = 0;
710 	import_export_t op_ie, sub_ie, gpfn_ie, mfn_ie;
711 	union {
712 		domid_t domid;
713 		struct xen_memory_reservation resv;
714 		struct xen_machphys_mfn_list xmml;
715 		struct xen_add_to_physmap xatp;
716 		struct xen_memory_map mm;
717 		struct xen_foreign_memory_map fmm;
718 		struct xen_pod_target pd;
719 	} op_arg;
720 
721 	op_ie = sub_ie = gpfn_ie = mfn_ie = null_ie;
722 
723 	switch (cmd) {
724 	case XENMEM_increase_reservation:
725 	case XENMEM_decrease_reservation:
726 	case XENMEM_populate_physmap: {
727 		ulong_t *taddr;
728 
729 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.resv),
730 		    IE_IMPEXP) != 0)
731 			return (-X_EFAULT);
732 
733 		error = import_handle(&sub_ie, &op_arg.resv.extent_start,
734 		    (op_arg.resv.nr_extents * sizeof (ulong_t)), IE_IMPEXP);
735 
736 		if (error == -X_EFAULT)
737 			/*LINTED: constant in conditional context*/
738 			get_xen_guest_handle(taddr, op_arg.resv.extent_start);
739 		else
740 			taddr = sub_ie.ie_kaddr;
741 
742 		switch (cmd) {
743 		case XENMEM_increase_reservation:
744 			DTRACE_XPV4(increase__reservation__start,
745 			    domid_t, op_arg.resv.domid,
746 			    ulong_t, op_arg.resv.nr_extents,
747 			    uint_t, op_arg.resv.extent_order,
748 			    ulong_t *, taddr);
749 			break;
750 		case XENMEM_decrease_reservation:
751 			DTRACE_XPV4(decrease__reservation__start,
752 			    domid_t, op_arg.resv.domid,
753 			    ulong_t, op_arg.resv.nr_extents,
754 			    uint_t, op_arg.resv.extent_order,
755 			    ulong_t *, taddr);
756 			break;
757 		case XENMEM_populate_physmap:
758 			DTRACE_XPV3(populate__physmap__start,
759 			    domid_t, op_arg.resv.domid,
760 			    ulong_t, op_arg.resv.nr_extents,
761 			    ulong_t *, taddr);
762 			break;
763 		}
764 
765 		break;
766 	}
767 
768 	case XENMEM_maximum_ram_page:
769 		break;
770 
771 	case XENMEM_current_reservation:
772 	case XENMEM_maximum_reservation:
773 	case XENMEM_maximum_gpfn:
774 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.domid),
775 		    IE_IMPEXP) != 0)
776 			return (-X_EFAULT);
777 		break;
778 
779 	case XENMEM_machphys_mfn_list: {
780 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.xmml),
781 		    IE_IMPEXP) != 0)
782 			return (-X_EFAULT);
783 
784 		error = import_handle(&sub_ie, &op_arg.xmml.extent_start,
785 		    (op_arg.xmml.max_extents * sizeof (ulong_t)), IE_IMPEXP);
786 		break;
787 	}
788 
789 	case XENMEM_add_to_physmap:
790 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.xatp),
791 		    IE_IMPEXP) != 0)
792 			return (-X_EFAULT);
793 		DTRACE_XPV4(add__to__physmap__start, domid_t,
794 		    op_arg.xatp.domid, uint_t, op_arg.xatp.space, ulong_t,
795 		    op_arg.xatp.idx, ulong_t, op_arg.xatp.gpfn);
796 		break;
797 
798 	case XENMEM_memory_map:
799 	case XENMEM_machine_memory_map: {
800 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.mm),
801 		    IE_EXPORT) != 0)
802 			return (-X_EFAULT);
803 
804 		/*
805 		 * XXPV: ugh. e820entry is packed, but not in the kernel, since
806 		 * we remove all attributes; seems like this is a nice way to
807 		 * break mysteriously.
808 		 */
809 		error = import_handle(&sub_ie, &op_arg.mm.buffer,
810 		    (op_arg.mm.nr_entries * 20), IE_IMPEXP);
811 		break;
812 	}
813 
814 	case XENMEM_set_memory_map: {
815 		struct xen_memory_map *taddr;
816 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.fmm),
817 		    IE_IMPORT) != 0)
818 			return (-X_EFAULT);
819 
820 		/*
821 		 * As above.
822 		 */
823 		error = import_handle(&sub_ie, &op_arg.fmm.map.buffer,
824 		    (op_arg.fmm.map.nr_entries * 20), IE_IMPEXP);
825 
826 		if (error == -X_EFAULT)
827 			/*LINTED: constant in conditional context*/
828 			get_xen_guest_handle(taddr, op_arg.fmm.map.buffer);
829 		else
830 			taddr = sub_ie.ie_kaddr;
831 		DTRACE_XPV3(set__memory__map__start, domid_t,
832 		    op_arg.fmm.domid, int, op_arg.fmm.map.nr_entries,
833 		    struct xen_memory_map *, taddr);
834 		break;
835 	}
836 
837 	case XENMEM_set_pod_target:
838 	case XENMEM_get_pod_target:
839 		if (import_buffer(&op_ie, arg, &op_arg, sizeof (op_arg.pd),
840 		    IE_IMPEXP) != 0)
841 			return (-X_EFAULT);
842 		break;
843 
844 	default:
845 #ifdef DEBUG
846 		printf("unrecognized HYPERVISOR_memory_op %d\n", cmd);
847 #endif
848 		return (-X_EINVAL);
849 	}
850 
851 	if (error == 0)
852 		error = HYPERVISOR_memory_op(cmd,
853 		    (arg == NULL) ? NULL: &op_arg);
854 
855 	export_buffer(&op_ie, &error);
856 	export_buffer(&sub_ie, &error);
857 	export_buffer(&gpfn_ie, &error);
858 	export_buffer(&mfn_ie, &error);
859 
860 	switch (cmd) {
861 	case XENMEM_increase_reservation:
862 		DTRACE_XPV1(increase__reservation__end, int, error);
863 		break;
864 	case XENMEM_decrease_reservation:
865 		DTRACE_XPV1(decrease__reservation__end, int, error);
866 		break;
867 	case XENMEM_populate_physmap:
868 		DTRACE_XPV1(populate__physmap__end, int, error);
869 		break;
870 	case XENMEM_add_to_physmap:
871 		DTRACE_XPV1(add__to__physmap__end, int, error);
872 		break;
873 	case XENMEM_set_memory_map:
874 		DTRACE_XPV1(set__memory__map__end, int, error);
875 		break;
876 	}
877 	return (error);
878 }
879 
880 static int
881 privcmd_HYPERVISOR_event_channel_op(int cmd, void *arg)
882 {
883 	int error;
884 	size_t size;
885 	import_export_t op_ie;
886 	uint32_t flags;
887 
888 	switch (cmd) {
889 	case EVTCHNOP_alloc_unbound:
890 		size = sizeof (evtchn_alloc_unbound_t);
891 		flags = IE_IMPEXP;
892 		break;
893 	case EVTCHNOP_bind_interdomain:
894 		size = sizeof (evtchn_bind_interdomain_t);
895 		flags = IE_IMPEXP;
896 		break;
897 	case EVTCHNOP_bind_virq:
898 		size = sizeof (evtchn_bind_virq_t);
899 		flags = IE_IMPEXP;
900 		break;
901 	case EVTCHNOP_bind_pirq:
902 		size = sizeof (evtchn_bind_pirq_t);
903 		flags = IE_IMPEXP;
904 		break;
905 	case EVTCHNOP_bind_ipi:
906 		size = sizeof (evtchn_bind_ipi_t);
907 		flags = IE_IMPEXP;
908 		break;
909 	case EVTCHNOP_close:
910 		size = sizeof (evtchn_close_t);
911 		flags = IE_IMPORT;
912 		break;
913 	case EVTCHNOP_send:
914 		size = sizeof (evtchn_send_t);
915 		flags = IE_IMPORT;
916 		break;
917 	case EVTCHNOP_status:
918 		size = sizeof (evtchn_status_t);
919 		flags = IE_IMPEXP;
920 		break;
921 	case EVTCHNOP_bind_vcpu:
922 		size = sizeof (evtchn_bind_vcpu_t);
923 		flags = IE_IMPORT;
924 		break;
925 	case EVTCHNOP_unmask:
926 		size = sizeof (evtchn_unmask_t);
927 		flags = IE_IMPORT;
928 		break;
929 	case EVTCHNOP_reset:
930 		size = sizeof (evtchn_reset_t);
931 		flags = IE_IMPORT;
932 		break;
933 
934 	default:
935 #ifdef DEBUG
936 		printf("unrecognized HYPERVISOR_event_channel op %d\n", cmd);
937 #endif
938 		return (-X_EINVAL);
939 	}
940 
941 	error = import_buffer(&op_ie, arg, NULL, size, flags);
942 
943 	/*
944 	 * If there is sufficient demand, we can replace this void * with
945 	 * the proper op structure pointer.
946 	 */
947 	DTRACE_XPV2(evtchn__op__start, int, cmd, void *,
948 	    ((error == -X_EFAULT) ? arg : op_ie.ie_kaddr));
949 
950 	if (error == 0)
951 		error = HYPERVISOR_event_channel_op(cmd, op_ie.ie_kaddr);
952 	export_buffer(&op_ie, &error);
953 
954 	DTRACE_XPV1(evtchn__op__end, int, error);
955 
956 	return (error);
957 }
958 
959 static int
960 privcmd_HYPERVISOR_xen_version(int cmd, void *arg)
961 {
962 	int error;
963 	int size = 0;
964 	import_export_t op_ie;
965 	uint32_t flags = IE_EXPORT;
966 
967 	switch (cmd) {
968 	case XENVER_version:
969 		break;
970 	case XENVER_extraversion:
971 		size = sizeof (xen_extraversion_t);
972 		break;
973 	case XENVER_compile_info:
974 		size = sizeof (xen_compile_info_t);
975 		break;
976 	case XENVER_capabilities:
977 		size = sizeof (xen_capabilities_info_t);
978 		break;
979 	case XENVER_changeset:
980 		size = sizeof (xen_changeset_info_t);
981 		break;
982 	case XENVER_platform_parameters:
983 		size = sizeof (xen_platform_parameters_t);
984 		break;
985 	case XENVER_get_features:
986 		flags = IE_IMPEXP;
987 		size = sizeof (xen_feature_info_t);
988 		break;
989 	case XENVER_pagesize:
990 		break;
991 	case XENVER_guest_handle:
992 		size = sizeof (xen_domain_handle_t);
993 		break;
994 
995 	default:
996 #ifdef DEBUG
997 		printf("unrecognized HYPERVISOR_xen_version op %d\n", cmd);
998 #endif
999 		return (-X_EINVAL);
1000 	}
1001 
1002 	error = import_buffer(&op_ie, arg, NULL, size, flags);
1003 	if (error == 0)
1004 		error = HYPERVISOR_xen_version(cmd, op_ie.ie_kaddr);
1005 	export_buffer(&op_ie, &error);
1006 
1007 	return (error);
1008 }
1009 
1010 static int
1011 privcmd_HYPERVISOR_xsm_op(void *uacmctl)
1012 {
1013 	int error;
1014 	struct xen_acmctl *acmctl;
1015 	import_export_t op_ie;
1016 
1017 	error = import_buffer(&op_ie, uacmctl, NULL, sizeof (*acmctl),
1018 	    IE_IMPEXP);
1019 	if (error != 0)
1020 		return (error);
1021 
1022 	acmctl = op_ie.ie_kaddr;
1023 
1024 	if (acmctl->interface_version != ACM_INTERFACE_VERSION) {
1025 #ifdef DEBUG
1026 		printf("acm vers mismatch (cmd %d, found 0x%x, need 0x%x\n",
1027 		    acmctl->cmd, acmctl->interface_version,
1028 		    ACM_INTERFACE_VERSION);
1029 #endif
1030 		error = -X_EACCES;
1031 		export_buffer(&op_ie, &error);
1032 		return (error);
1033 	}
1034 
1035 	/* FIXME: flask ops??? */
1036 
1037 	switch (acmctl->cmd) {
1038 	case ACMOP_setpolicy:
1039 	case ACMOP_getpolicy:
1040 	case ACMOP_dumpstats:
1041 	case ACMOP_getssid:
1042 	case ACMOP_getdecision:
1043 	case ACMOP_chgpolicy:
1044 	case ACMOP_relabeldoms:
1045 		/* flags = IE_IMPEXP; */
1046 		break;
1047 	default:
1048 #ifdef DEBUG
1049 		printf("unrecognized HYPERVISOR_xsm_op op %d\n", acmctl->cmd);
1050 #endif
1051 		return (-X_EINVAL);
1052 	}
1053 
1054 	if (error == 0)
1055 		error = HYPERVISOR_xsm_op(acmctl);
1056 	export_buffer(&op_ie, &error);
1057 
1058 	return (error);
1059 }
1060 
1061 static int
1062 privcmd_HYPERVISOR_mmuext_op(struct mmuext_op *op, int count, uint_t *scount,
1063     domid_t domid)
1064 {
1065 	int error, bytes;
1066 	uint_t kscount;
1067 	struct mmuext_op *kop, single_kop;
1068 	import_export_t op_ie, scnt_ie;
1069 
1070 	op_ie = scnt_ie = null_ie;
1071 	error = 0;
1072 
1073 	if (count >= 1) {
1074 		bytes = count * sizeof (*kop);
1075 		kop = (count == 1) ? &single_kop : kmem_alloc(bytes, KM_SLEEP);
1076 		error = import_buffer(&op_ie, op, kop, bytes, IE_IMPORT);
1077 	}
1078 
1079 	DTRACE_XPV2(mmu__ext__op__start, int, count, struct mmuext_op *,
1080 	    ((error == -X_EFAULT) ? op : kop));
1081 
1082 	if (scount != NULL && error == 0)
1083 		error = import_buffer(&scnt_ie, scount, &kscount,
1084 		    sizeof (kscount), IE_EXPORT);
1085 
1086 	if (error == 0)
1087 		error = HYPERVISOR_mmuext_op(kop, count, &kscount, domid);
1088 	export_buffer(&op_ie, &error);
1089 	export_buffer(&scnt_ie, &error);
1090 
1091 	DTRACE_XPV1(mmu__ext__op__end, int, error);
1092 
1093 	if (count > 1)
1094 		kmem_free(kop, bytes);
1095 	return (error);
1096 }
1097 
1098 static int
1099 privcmd_HYPERVISOR_hvm_op(int cmd, void *arg)
1100 {
1101 	int error;
1102 	int size = 0;
1103 	import_export_t arg_ie;
1104 	uint32_t flags = IE_IMPORT;
1105 
1106 	switch (cmd) {
1107 	case HVMOP_set_param:
1108 	case HVMOP_get_param:
1109 		size = sizeof (struct xen_hvm_param);
1110 		flags = IE_IMPEXP;
1111 		break;
1112 	case HVMOP_set_pci_intx_level:
1113 		size = sizeof (struct xen_hvm_set_pci_intx_level);
1114 		break;
1115 	case HVMOP_set_isa_irq_level:
1116 		size = sizeof (struct xen_hvm_set_isa_irq_level);
1117 		break;
1118 	case HVMOP_set_pci_link_route:
1119 		size = sizeof (struct xen_hvm_set_pci_link_route);
1120 		break;
1121 	case HVMOP_track_dirty_vram:
1122 		size = sizeof (struct xen_hvm_track_dirty_vram);
1123 		break;
1124 	case HVMOP_modified_memory:
1125 		size = sizeof (struct xen_hvm_modified_memory);
1126 		break;
1127 	case HVMOP_set_mem_type:
1128 		size = sizeof (struct xen_hvm_set_mem_type);
1129 		break;
1130 
1131 	default:
1132 #ifdef DEBUG
1133 		printf("unrecognized HVM op 0x%x\n", cmd);
1134 #endif
1135 		return (-X_EINVAL);
1136 	}
1137 
1138 	error = import_buffer(&arg_ie, arg, NULL, size, flags);
1139 	if (error == 0)
1140 		error = HYPERVISOR_hvm_op(cmd, arg_ie.ie_kaddr);
1141 	export_buffer(&arg_ie, &error);
1142 
1143 	return (error);
1144 }
1145 
1146 static int
1147 privcmd_HYPERVISOR_sched_op(int cmd, void *arg)
1148 {
1149 	int error;
1150 	int size = 0;
1151 	import_export_t op_ie;
1152 	struct sched_remote_shutdown op;
1153 
1154 	switch (cmd) {
1155 	case SCHEDOP_remote_shutdown:
1156 		size = sizeof (struct sched_remote_shutdown);
1157 		break;
1158 	default:
1159 #ifdef DEBUG
1160 		printf("unrecognized sched op 0x%x\n", cmd);
1161 #endif
1162 		return (-X_EINVAL);
1163 	}
1164 
1165 	error = import_buffer(&op_ie, arg, &op, size, IE_IMPORT);
1166 	if (error == 0)
1167 		error = HYPERVISOR_sched_op(cmd, (arg == NULL) ? NULL : &op);
1168 	export_buffer(&op_ie, &error);
1169 
1170 	return (error);
1171 }
1172 
1173 int allow_all_hypercalls = 0;
1174 int privcmd_efault_debug = 0;
1175 
1176 /*ARGSUSED*/
1177 int
1178 do_privcmd_hypercall(void *uarg, int mode, cred_t *cr, int *rval)
1179 {
1180 	privcmd_hypercall_t __hc, *hc = &__hc;
1181 	int error;
1182 
1183 	if (ddi_copyin(uarg, hc, sizeof (*hc), mode))
1184 		return (EFAULT);
1185 
1186 	switch (hc->op) {
1187 	case __HYPERVISOR_mmu_update:
1188 		error = privcmd_HYPERVISOR_mmu_update(
1189 		    (mmu_update_t *)hc->arg[0], (int)hc->arg[1],
1190 		    (int *)hc->arg[2], (domid_t)hc->arg[3]);
1191 		break;
1192 	case __HYPERVISOR_domctl:
1193 		error = privcmd_HYPERVISOR_domctl(
1194 		    (xen_domctl_t *)hc->arg[0]);
1195 		break;
1196 	case __HYPERVISOR_sysctl:
1197 		error = privcmd_HYPERVISOR_sysctl(
1198 		    (xen_sysctl_t *)hc->arg[0]);
1199 		break;
1200 	case __HYPERVISOR_platform_op:
1201 		error = privcmd_HYPERVISOR_platform_op(
1202 		    (xen_platform_op_t *)hc->arg[0]);
1203 		break;
1204 	case __HYPERVISOR_memory_op:
1205 		error = privcmd_HYPERVISOR_memory_op(
1206 		    (int)hc->arg[0], (void *)hc->arg[1]);
1207 		break;
1208 	case __HYPERVISOR_event_channel_op:
1209 		error = privcmd_HYPERVISOR_event_channel_op(
1210 		    (int)hc->arg[0], (void *)hc->arg[1]);
1211 		break;
1212 	case __HYPERVISOR_xen_version:
1213 		error = privcmd_HYPERVISOR_xen_version(
1214 		    (int)hc->arg[0], (void *)hc->arg[1]);
1215 		break;
1216 	case __HYPERVISOR_mmuext_op:
1217 		error = privcmd_HYPERVISOR_mmuext_op(
1218 		    (struct mmuext_op *)hc->arg[0], (int)hc->arg[1],
1219 		    (uint_t *)hc->arg[2], (domid_t)hc->arg[3]);
1220 		break;
1221 	case __HYPERVISOR_xsm_op:
1222 		error = privcmd_HYPERVISOR_xsm_op((void *)hc->arg[0]);
1223 		break;
1224 	case __HYPERVISOR_hvm_op:
1225 		error = privcmd_HYPERVISOR_hvm_op(
1226 		    (int)hc->arg[0], (void *)hc->arg[1]);
1227 		break;
1228 	case __HYPERVISOR_sched_op:
1229 		error = privcmd_HYPERVISOR_sched_op(
1230 		    (int)hc->arg[0], (void *)hc->arg[1]);
1231 		break;
1232 	default:
1233 		if (allow_all_hypercalls)
1234 			error = __hypercall5(hc->op, hc->arg[0], hc->arg[1],
1235 			    hc->arg[2], hc->arg[3], hc->arg[4]);
1236 		else {
1237 #ifdef DEBUG
1238 			printf("unrecognized hypercall %ld\n", hc->op);
1239 #endif
1240 			error = -X_EPERM;
1241 		}
1242 		break;
1243 	}
1244 
1245 	if (error > 0) {
1246 		*rval = error;
1247 		error = 0;
1248 	} else if (error != 0)
1249 		error = xen_xlate_errcode(error);
1250 
1251 	return (error);
1252 }
1253