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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Provides basic C wrappers around hypervisor invocation. 29 * 30 * i386: eax = vector: ebx, ecx, edx, esi, edi = args 1-5 31 * eax = return value 32 * (argument registers may be clobbered on return) 33 * 34 * amd64:rax = vector: rdi, rsi, rdx, r10, r8, r9 = args 1-6 35 * rax = return value 36 * (arguments registers not clobbered on return; rcx, r11 are) 37 */ 38 39 #include <sys/types.h> 40 #ifndef __xpv 41 #include <sys/xpv_support.h> 42 #else 43 #include <sys/xpv_user.h> 44 #endif 45 46 #include <sys/hypervisor.h> 47 #include <xen/public/sched.h> 48 #include <sys/debug.h> 49 #include <sys/archsystm.h> 50 51 long 52 HYPERVISOR_set_trap_table(trap_info_t *table) 53 { 54 return (__hypercall1(__HYPERVISOR_set_trap_table, (ulong_t)table)); 55 } 56 57 int 58 HYPERVISOR_mmu_update(mmu_update_t *req, int count, int *success_count, 59 domid_t domain_id) 60 { 61 return (__hypercall4_int(__HYPERVISOR_mmu_update, 62 (ulong_t)req, (long)count, (ulong_t)success_count, 63 (ulong_t)domain_id)); 64 } 65 66 long 67 HYPERVISOR_set_gdt(ulong_t *frame_list, int entries) 68 { 69 return (__hypercall2( 70 __HYPERVISOR_set_gdt, (ulong_t)frame_list, (long)entries)); 71 } 72 73 /* 74 * XXPV Seems like "sp" would be a better name for both amd64 and i386? 75 * For now stay consistent with xen project source. 76 */ 77 long 78 HYPERVISOR_stack_switch(ulong_t ss, ulong_t esp) 79 { 80 return (__hypercall2(__HYPERVISOR_stack_switch, ss, esp)); 81 } 82 83 #if defined(__amd64) 84 85 long 86 HYPERVISOR_set_callbacks(ulong_t event_address, ulong_t failsafe_address, 87 ulong_t syscall_address) 88 { 89 return (__hypercall3(__HYPERVISOR_set_callbacks, 90 event_address, failsafe_address, syscall_address)); 91 } 92 93 #elif defined(__i386) 94 95 long 96 HYPERVISOR_set_callbacks( 97 ulong_t event_selector, ulong_t event_address, 98 ulong_t failsafe_selector, ulong_t failsafe_address) 99 { 100 return (__hypercall4(__HYPERVISOR_set_callbacks, 101 event_selector, event_address, 102 failsafe_selector, failsafe_address)); 103 } 104 105 #endif /* __amd64 */ 106 107 long 108 HYPERVISOR_fpu_taskswitch(int set) 109 { 110 return (__hypercall1(__HYPERVISOR_fpu_taskswitch, (long)set)); 111 } 112 113 /* *** __HYPERVISOR_sched_op_compat *** OBSOLETED */ 114 115 long 116 HYPERVISOR_platform_op(xen_platform_op_t *platform_op) 117 { 118 return (__hypercall1(__HYPERVISOR_platform_op, (ulong_t)platform_op)); 119 } 120 121 /* *** __HYPERVISOR_set_debugreg *** NOT IMPLEMENTED */ 122 123 /* *** __HYPERVISOR_get_debugreg *** NOT IMPLEMENTED */ 124 125 long 126 HYPERVISOR_update_descriptor(maddr_t ma, uint64_t desc) 127 { 128 #if defined(__amd64) 129 130 return (__hypercall2(__HYPERVISOR_update_descriptor, ma, desc)); 131 132 #elif defined(__i386) 133 134 return (__hypercall4(__HYPERVISOR_update_descriptor, 135 (ulong_t)ma, (ulong_t)(ma >>32), 136 (ulong_t)desc, (ulong_t)(desc >> 32))); 137 138 #endif 139 } 140 141 long 142 HYPERVISOR_memory_op(int cmd, void *arg) 143 { 144 return (__hypercall2(__HYPERVISOR_memory_op, (long)cmd, 145 (ulong_t)arg)); 146 } 147 148 long 149 HYPERVISOR_multicall(void *call_list, uint_t nr_calls) 150 { 151 return (__hypercall2(__HYPERVISOR_multicall, 152 (ulong_t)call_list, (ulong_t)nr_calls)); 153 } 154 155 int 156 HYPERVISOR_update_va_mapping(ulong_t va, uint64_t new_pte, ulong_t flags) 157 { 158 #if !defined(_BOOT) 159 if (IN_XPV_PANIC()) 160 return (0); 161 #endif 162 #if defined(__amd64) 163 164 return (__hypercall3_int(__HYPERVISOR_update_va_mapping, va, 165 new_pte, flags)); 166 167 #elif defined(__i386) 168 169 return (__hypercall4_int(__HYPERVISOR_update_va_mapping, va, 170 (ulong_t)new_pte, (ulong_t)(new_pte >> 32), flags)); 171 172 #endif /* __i386 */ 173 } 174 175 /* 176 * Note: this timeout must be the Xen system time not hrtime (see 177 * xpv_timestamp.c). 178 */ 179 long 180 HYPERVISOR_set_timer_op(uint64_t timeout) 181 { 182 #if defined(__amd64) 183 184 return (__hypercall1(__HYPERVISOR_set_timer_op, timeout)); 185 186 #elif defined(__i386) 187 188 uint32_t timeout_hi = (uint32_t)(timeout >> 32); 189 uint32_t timeout_lo = (uint32_t)timeout; 190 return (__hypercall2(__HYPERVISOR_set_timer_op, 191 (ulong_t)timeout_lo, (ulong_t)timeout_hi)); 192 193 #endif /* __i386 */ 194 } 195 196 /* *** __HYPERVISOR_event_channel_op_compat *** OBSOLETED */ 197 198 long 199 HYPERVISOR_xen_version(int cmd, void *arg) 200 { 201 return (__hypercall2(__HYPERVISOR_xen_version, (long)cmd, 202 (ulong_t)arg)); 203 } 204 205 long 206 HYPERVISOR_console_io(int cmd, int count, char *str) 207 { 208 return (__hypercall3(__HYPERVISOR_console_io, (long)cmd, (long)count, 209 (ulong_t)str)); 210 } 211 212 /* *** __HYPERVISOR_physdev_op_compat *** OBSOLETED */ 213 214 /* 215 * **** 216 * NOTE: this hypercall should not be called directly for a 217 * GNTTABOP_map_grant_ref. Instead xen_map_gref() should be called. 218 * **** 219 */ 220 long 221 HYPERVISOR_grant_table_op(uint_t cmd, void *uop, uint_t count) 222 { 223 int ret_val; 224 ret_val = __hypercall3(__HYPERVISOR_grant_table_op, 225 (long)cmd, (ulong_t)uop, (ulong_t)count); 226 return (ret_val); 227 } 228 229 long 230 HYPERVISOR_vm_assist(uint_t cmd, uint_t type) 231 { 232 return (__hypercall2(__HYPERVISOR_vm_assist, 233 (ulong_t)cmd, (ulong_t)type)); 234 } 235 236 int 237 HYPERVISOR_update_va_mapping_otherdomain(ulong_t va, 238 uint64_t new_pte, ulong_t flags, domid_t domain_id) 239 { 240 #if defined(__amd64) 241 242 return (__hypercall4_int(__HYPERVISOR_update_va_mapping_otherdomain, 243 va, new_pte, flags, (ulong_t)domain_id)); 244 245 #elif defined(__i386) 246 247 return (__hypercall5_int(__HYPERVISOR_update_va_mapping_otherdomain, 248 va, (ulong_t)new_pte, (ulong_t)(new_pte >> 32), flags, 249 (ulong_t)domain_id)); 250 251 #endif /* __i386 */ 252 } 253 254 /* 255 * *** __HYPERVISOR_iret *** 256 * see HYPERVISOR_IRET() macro in i86xpv/sys/machprivregs.h 257 */ 258 259 long 260 HYPERVISOR_vcpu_op(int cmd, int vcpuid, void *extra_args) 261 { 262 return (__hypercall3(__HYPERVISOR_vcpu_op, (long)cmd, (long)vcpuid, 263 (ulong_t)extra_args)); 264 } 265 266 #if defined(__amd64) 267 268 long 269 HYPERVISOR_set_segment_base(int reg, ulong_t value) 270 { 271 return (__hypercall2(__HYPERVISOR_set_segment_base, (long)reg, value)); 272 } 273 274 #endif /* __amd64 */ 275 276 int 277 HYPERVISOR_mmuext_op(struct mmuext_op *req, int count, uint_t *success_count, 278 domid_t domain_id) 279 { 280 return (__hypercall4_int(__HYPERVISOR_mmuext_op, 281 (ulong_t)req, (long)count, (ulong_t)success_count, 282 (ulong_t)domain_id)); 283 } 284 285 long 286 HYPERVISOR_nmi_op(int cmd, void *arg) 287 { 288 return (__hypercall2(__HYPERVISOR_nmi_op, (long)cmd, (ulong_t)arg)); 289 } 290 291 long 292 HYPERVISOR_sched_op(int cmd, void *arg) 293 { 294 return (__hypercall2(__HYPERVISOR_sched_op, 295 (ulong_t)cmd, (ulong_t)arg)); 296 } 297 298 long 299 HYPERVISOR_callback_op(int cmd, void *arg) 300 { 301 return (__hypercall2(__HYPERVISOR_callback_op, 302 (ulong_t)cmd, (ulong_t)arg)); 303 } 304 305 /* *** __HYPERVISOR_xenoprof_op *** NOT IMPLEMENTED */ 306 307 long 308 HYPERVISOR_event_channel_op(int cmd, void *arg) 309 { 310 return (__hypercall2(__HYPERVISOR_event_channel_op, (long)cmd, 311 (ulong_t)arg)); 312 } 313 314 long 315 HYPERVISOR_physdev_op(int cmd, void *arg) 316 { 317 return (__hypercall2(__HYPERVISOR_physdev_op, (long)cmd, 318 (ulong_t)arg)); 319 } 320 321 long 322 HYPERVISOR_hvm_op(int cmd, void *arg) 323 { 324 return (__hypercall2(__HYPERVISOR_hvm_op, (long)cmd, (ulong_t)arg)); 325 } 326 327 #if defined(__xpv) 328 long 329 HYPERVISOR_xsm_op(struct xen_acmctl *arg) 330 { 331 return (__hypercall1(__HYPERVISOR_xsm_op, (ulong_t)arg)); 332 } 333 334 long 335 HYPERVISOR_sysctl(xen_sysctl_t *sysctl) 336 { 337 return (__hypercall1(__HYPERVISOR_sysctl, (ulong_t)sysctl)); 338 } 339 340 long 341 HYPERVISOR_domctl(xen_domctl_t *domctl) 342 { 343 return (__hypercall1(__HYPERVISOR_domctl, (ulong_t)domctl)); 344 } 345 #endif /* __xpv */ 346 347 /* *** __HYPERVISOR_kexec_op *** NOT IMPLEMENTED */ 348 349 /* 350 * 351 * HYPERCALL HELPER ROUTINES 352 * These don't have there own unique hypercalls. 353 * 354 */ 355 356 long 357 HYPERVISOR_yield(void) 358 { 359 return (HYPERVISOR_sched_op(SCHEDOP_yield, NULL)); 360 } 361 362 long 363 HYPERVISOR_block(void) 364 { 365 return (HYPERVISOR_sched_op(SCHEDOP_block, NULL)); 366 } 367 368 long 369 HYPERVISOR_shutdown(uint_t reason) 370 { 371 struct sched_shutdown sched_shutdown; 372 373 sched_shutdown.reason = reason; 374 375 return (HYPERVISOR_sched_op(SCHEDOP_shutdown, &sched_shutdown)); 376 } 377 378 /* 379 * Poll one or more event-channel ports, and return when pending. 380 * An optional timeout (in nanoseconds, absolute time since boot) may be 381 * specified. Note: this timeout must be the Xen system time not hrtime (see 382 * xpv_timestamp.c). 383 */ 384 long 385 HYPERVISOR_poll(evtchn_port_t *ports, uint_t nr_ports, uint64_t timeout) 386 { 387 struct sched_poll sched_poll; 388 389 /*LINTED: constant in conditional context*/ 390 set_xen_guest_handle(sched_poll.ports, ports); 391 sched_poll.nr_ports = nr_ports; 392 sched_poll.timeout = timeout; 393 394 return (HYPERVISOR_sched_op(SCHEDOP_poll, &sched_poll)); 395 } 396 397 long 398 HYPERVISOR_suspend(ulong_t start_info_mfn) 399 { 400 struct sched_shutdown sched_shutdown; 401 402 sched_shutdown.reason = SHUTDOWN_suspend; 403 404 return (__hypercall3(__HYPERVISOR_sched_op, SCHEDOP_shutdown, 405 (ulong_t)&sched_shutdown, start_info_mfn)); 406 } 407 408 long 409 HYPERVISOR_mca(uint32_t cmd, xen_mc_t *xmcp) 410 { 411 long rv; 412 413 switch (cmd) { 414 case XEN_MC_fetch: 415 case XEN_MC_physcpuinfo: 416 case XEN_MC_msrinject: 417 case XEN_MC_mceinject: 418 break; 419 420 case XEN_MC_notifydomain: 421 return (ENOTSUP); 422 423 default: 424 return (EINVAL); 425 } 426 427 xmcp->interface_version = XEN_MCA_INTERFACE_VERSION; 428 xmcp->cmd = cmd; 429 430 rv = __hypercall1(__HYPERVISOR_mca, (ulong_t)xmcp); 431 432 return (rv); 433 } 434