hypercall.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /******************************************************************************
    2  * hypercall.h
    3  * 
    4  * Linux-specific hypervisor handling.
    5  * 
    6  * Copyright (c) 2002-2004, K A Fraser
    7  * 
    8  * This file may be distributed separately from the Linux kernel, or
    9  * incorporated into other software packages, subject to the following license:
   10  * 
   11  * Permission is hereby granted, free of charge, to any person obtaining a copy
   12  * of this source file (the "Software"), to deal in the Software without
   13  * restriction, including without limitation the rights to use, copy, modify,
   14  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   15  * and to permit persons to whom the Software is furnished to do so, subject to
   16  * the following conditions:
   17  * 
   18  * The above copyright notice and this permission notice shall be included in
   19  * all copies or substantial portions of the Software.
   20  * 
   21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   26  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   27  * IN THE SOFTWARE.
   28  */
   29 
   30 #ifndef __HYPERCALL_H__
   31 #define __HYPERCALL_H__
   32 
   33 #include <sys/systm.h>
   34 #include <xen/interface/xen.h>
   35 #include <xen/interface/sched.h>
   36 
   37 #define __STR(x) #x
   38 #define STR(x) __STR(x)
   39 #define ENOXENSYS       38
   40 #define CONFIG_XEN_COMPAT       0x030002
   41 
   42 
   43 #if defined(XEN)
   44 #define HYPERCALL_STR(name)                                     \
   45         "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"
   46 #else
   47 #define HYPERCALL_STR(name)                                     \
   48         "mov hypercall_stubs,%%eax; "                           \
   49         "add $("STR(__HYPERVISOR_##name)" * 32),%%eax; "        \
   50         "call *%%eax"
   51 #endif
   52 
   53 #define _hypercall0(type, name)                 \
   54 ({                                              \
   55         long __res;                             \
   56         __asm__ volatile (                          \
   57                 HYPERCALL_STR(name)             \
   58                 : "=a" (__res)                  \
   59                 :                               \
   60                 : "memory" );                   \
   61         (type)__res;                            \
   62 })
   63 
   64 #define _hypercall1(type, name, a1)                             \
   65 ({                                                              \
   66         long __res, __ign1;                                     \
   67         __asm__ volatile (                                          \
   68                 HYPERCALL_STR(name)                             \
   69                 : "=a" (__res), "=b" (__ign1)                   \
   70                 : "1" ((long)(a1))                              \
   71                 : "memory" );                                   \
   72         (type)__res;                                            \
   73 })
   74 
   75 #define _hypercall2(type, name, a1, a2)                         \
   76 ({                                                              \
   77         long __res, __ign1, __ign2;                             \
   78         __asm__ volatile (                                          \
   79                 HYPERCALL_STR(name)                             \
   80                 : "=a" (__res), "=b" (__ign1), "=c" (__ign2)    \
   81                 : "1" ((long)(a1)), "2" ((long)(a2))            \
   82                 : "memory" );                                   \
   83         (type)__res;                                            \
   84 })
   85 
   86 #define _hypercall3(type, name, a1, a2, a3)                     \
   87 ({                                                              \
   88         long __res, __ign1, __ign2, __ign3;                     \
   89         __asm__ volatile (                                          \
   90                 HYPERCALL_STR(name)                             \
   91                 : "=a" (__res), "=b" (__ign1), "=c" (__ign2),   \
   92                 "=d" (__ign3)                                   \
   93                 : "1" ((long)(a1)), "2" ((long)(a2)),           \
   94                 "3" ((long)(a3))                                \
   95                 : "memory" );                                   \
   96         (type)__res;                                            \
   97 })
   98 
   99 #define _hypercall4(type, name, a1, a2, a3, a4)                 \
  100 ({                                                              \
  101         long __res, __ign1, __ign2, __ign3, __ign4;             \
  102         __asm__ volatile (                                          \
  103                 HYPERCALL_STR(name)                             \
  104                 : "=a" (__res), "=b" (__ign1), "=c" (__ign2),   \
  105                 "=d" (__ign3), "=S" (__ign4)                    \
  106                 : "1" ((long)(a1)), "2" ((long)(a2)),           \
  107                 "3" ((long)(a3)), "4" ((long)(a4))              \
  108                 : "memory" );                                   \
  109         (type)__res;                                            \
  110 })
  111 
  112 #define _hypercall5(type, name, a1, a2, a3, a4, a5)             \
  113 ({                                                              \
  114         long __res, __ign1, __ign2, __ign3, __ign4, __ign5;     \
  115         __asm__ volatile (                                          \
  116                 HYPERCALL_STR(name)                             \
  117                 : "=a" (__res), "=b" (__ign1), "=c" (__ign2),   \
  118                 "=d" (__ign3), "=S" (__ign4), "=D" (__ign5)     \
  119                 : "1" ((long)(a1)), "2" ((long)(a2)),           \
  120                 "3" ((long)(a3)), "4" ((long)(a4)),             \
  121                 "5" ((long)(a5))                                \
  122                 : "memory" );                                   \
  123         (type)__res;                                            \
  124 })                                                              
  125 
  126 static inline int
  127 HYPERVISOR_set_trap_table(
  128         trap_info_t *table)
  129 {
  130         return _hypercall1(int, set_trap_table, table);
  131 }
  132 
  133 static inline int
  134 HYPERVISOR_mmu_update(
  135         mmu_update_t *req, int count, int *success_count, domid_t domid)
  136 {
  137         return _hypercall4(int, mmu_update, req, count, success_count, domid);
  138 }
  139 
  140 static inline int
  141 HYPERVISOR_mmuext_op(
  142         mmuext_op_t *op, int count, int *success_count, domid_t domid)
  143 {
  144         return _hypercall4(int, mmuext_op, op, count, success_count, domid);
  145 }
  146 
  147 static inline int
  148 HYPERVISOR_set_gdt(
  149         unsigned long *frame_list, int entries)
  150 {
  151         return _hypercall2(int, set_gdt, frame_list, entries);
  152 }
  153 
  154 static inline int
  155 HYPERVISOR_stack_switch(
  156         unsigned long ss, unsigned long esp)
  157 {
  158         return _hypercall2(int, stack_switch, ss, esp);
  159 }
  160 
  161 static inline int
  162 HYPERVISOR_set_callbacks(
  163         unsigned long event_selector, unsigned long event_address,
  164         unsigned long failsafe_selector, unsigned long failsafe_address)
  165 {
  166         return _hypercall4(int, set_callbacks,
  167                            event_selector, event_address,
  168                            failsafe_selector, failsafe_address);
  169 }
  170 
  171 static inline int
  172 HYPERVISOR_fpu_taskswitch(
  173         int set)
  174 {
  175         return _hypercall1(int, fpu_taskswitch, set);
  176 }
  177 
  178 static inline int 
  179 HYPERVISOR_sched_op_compat(
  180         int cmd, unsigned long arg)
  181 {
  182         return _hypercall2(int, sched_op_compat, cmd, arg);
  183 }
  184 
  185 static inline int
  186 HYPERVISOR_sched_op(
  187         int cmd, void *arg)
  188 {
  189         return _hypercall2(int, sched_op, cmd, arg);
  190 }
  191 
  192 static inline long
  193 HYPERVISOR_set_timer_op(
  194         uint64_t timeout)
  195 {
  196         unsigned long timeout_hi = (unsigned long)(timeout>>32);
  197         unsigned long timeout_lo = (unsigned long)timeout;
  198         return _hypercall2(long, set_timer_op, timeout_lo, timeout_hi);
  199 }
  200 #if 0
  201 static inline int
  202 HYPERVISOR_platform_op(
  203         struct xen_platform_op *platform_op)
  204 {
  205         platform_op->interface_version = XENPF_INTERFACE_VERSION;
  206         return _hypercall1(int, platform_op, platform_op);
  207 }
  208 #endif
  209 static inline int
  210 HYPERVISOR_set_debugreg(
  211         int reg, unsigned long value)
  212 {
  213         return _hypercall2(int, set_debugreg, reg, value);
  214 }
  215 
  216 static inline unsigned long
  217 HYPERVISOR_get_debugreg(
  218         int reg)
  219 {
  220         return _hypercall1(unsigned long, get_debugreg, reg);
  221 }
  222 
  223 static inline int
  224 HYPERVISOR_update_descriptor(
  225         uint64_t ma, uint64_t desc)
  226 {
  227         return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32);
  228 }
  229 
  230 static inline int
  231 HYPERVISOR_memory_op(
  232         unsigned int cmd, void *arg)
  233 {
  234         return _hypercall2(int, memory_op, cmd, arg);
  235 }
  236 
  237 #if defined(XEN)
  238 int HYPERVISOR_multicall(multicall_entry_t *, int);
  239 static inline int
  240 _HYPERVISOR_multicall(
  241 #else /* XENHVM */
  242 static inline int
  243 HYPERVISOR_multicall(
  244 #endif
  245         void *call_list, int nr_calls)
  246 {
  247         return _hypercall2(int, multicall, call_list, nr_calls);
  248 }
  249 
  250 static inline int
  251 HYPERVISOR_update_va_mapping(
  252         unsigned long va, uint64_t new_val, unsigned long flags)
  253 {
  254         uint32_t hi, lo;
  255 
  256         lo = (uint32_t)(new_val & 0xffffffff);
  257         hi = (uint32_t)(new_val >> 32);
  258         
  259         return _hypercall4(int, update_va_mapping, va,
  260                            lo, hi, flags);
  261 }
  262 
  263 static inline int
  264 HYPERVISOR_event_channel_op(
  265         int cmd, void *arg)
  266 {
  267         int rc = _hypercall2(int, event_channel_op, cmd, arg);
  268 
  269 #if CONFIG_XEN_COMPAT <= 0x030002
  270         if (__predict_false(rc == -ENOXENSYS)) {
  271                 struct evtchn_op op;
  272                 op.cmd = cmd;
  273                 memcpy(&op.u, arg, sizeof(op.u));
  274                 rc = _hypercall1(int, event_channel_op_compat, &op);
  275                 memcpy(arg, &op.u, sizeof(op.u));
  276         }
  277 #endif
  278         return (rc);
  279 }
  280 
  281 static inline int
  282 HYPERVISOR_xen_version(
  283         int cmd, void *arg)
  284 {
  285         return _hypercall2(int, xen_version, cmd, arg);
  286 }
  287 
  288 static inline int
  289 HYPERVISOR_console_io(
  290         int cmd, int count, char *str)
  291 {
  292         return _hypercall3(int, console_io, cmd, count, str);
  293 }
  294 
  295 static inline int
  296 HYPERVISOR_physdev_op(
  297         int cmd, void *arg)
  298 {
  299         int rc = _hypercall2(int, physdev_op, cmd, arg);
  300 #if CONFIG_XEN_COMPAT <= 0x030002
  301         if (__predict_false(rc == -ENOXENSYS)) {
  302                 struct physdev_op op;
  303                 op.cmd = cmd;
  304                 memcpy(&op.u, arg, sizeof(op.u));
  305                 rc = _hypercall1(int, physdev_op_compat, &op);
  306                 memcpy(arg, &op.u, sizeof(op.u));
  307         }
  308 #endif
  309         return (rc);
  310 }
  311 
  312 static inline int
  313 HYPERVISOR_grant_table_op(
  314         unsigned int cmd, void *uop, unsigned int count)
  315 {
  316         return _hypercall3(int, grant_table_op, cmd, uop, count);
  317 }
  318 
  319 static inline int
  320 HYPERVISOR_update_va_mapping_otherdomain(
  321         unsigned long va, uint64_t new_val, unsigned long flags, domid_t domid)
  322 {
  323         uint32_t hi, lo;
  324         
  325         lo = (uint32_t)(new_val & 0xffffffff);
  326         hi = (uint32_t)(new_val >> 32);
  327         
  328         return _hypercall5(int, update_va_mapping_otherdomain, va,
  329                            lo, hi, flags, domid);
  330 }
  331 
  332 static inline int
  333 HYPERVISOR_vm_assist(
  334         unsigned int cmd, unsigned int type)
  335 {
  336         return _hypercall2(int, vm_assist, cmd, type);
  337 }
  338 
  339 static inline int
  340 HYPERVISOR_vcpu_op(
  341         int cmd, int vcpuid, void *extra_args)
  342 {
  343         return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
  344 }
  345 
  346 static inline int
  347 HYPERVISOR_suspend(
  348         unsigned long srec)
  349 {
  350         struct sched_shutdown sched_shutdown = {
  351                 .reason = SHUTDOWN_suspend
  352         };
  353         int rc = _hypercall3(int, sched_op, SCHEDOP_shutdown,
  354                            &sched_shutdown, srec);
  355 #if CONFIG_XEN_COMPAT <= 0x030002
  356         if (rc == -ENOXENSYS)
  357                 rc = _hypercall3(int, sched_op_compat, SCHEDOP_shutdown,
  358                                  SHUTDOWN_suspend, srec);
  359 #endif  
  360         return (rc);
  361 }
  362 
  363 #if CONFIG_XEN_COMPAT <= 0x030002
  364 static inline int
  365 HYPERVISOR_nmi_op(
  366         unsigned long op, void *arg)
  367 {
  368         return _hypercall2(int, nmi_op, op, arg);
  369 }
  370 #endif
  371 
  372 static inline int
  373 HYPERVISOR_callback_op(
  374         int cmd, void *arg)
  375 {
  376         return _hypercall2(int, callback_op, cmd, arg);
  377 }
  378 
  379 #ifndef CONFIG_XEN
  380 static inline unsigned long
  381 HYPERVISOR_hvm_op(
  382     int op, void *arg)
  383 {
  384     return _hypercall2(unsigned long, hvm_op, op, arg);
  385 }
  386 #endif
  387 
  388 static inline int
  389 HYPERVISOR_xenoprof_op(
  390         int op, void *arg)
  391 {
  392         return _hypercall2(int, xenoprof_op, op, arg);
  393 }
  394 
  395 static inline int
  396 HYPERVISOR_kexec_op(
  397         unsigned long op, void *args)
  398 {
  399         return _hypercall2(int, kexec_op, op, args);
  400 }
  401 #endif /* __HYPERCALL_H__ */
  402 
  403 /*
  404  * Local variables:
  405  *  c-file-style: "linux"
  406  *  indent-tabs-mode: t
  407  *  c-indent-level: 8
  408  *  c-basic-offset: 8
  409  *  tab-width: 8
  410  * End:
  411  */
Cache object: b1188eb7f6273b1957a1cbfb9aa7f4c7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/i386/include/xen/hypercall.h

FreeBSD/Linux Kernel Cross Reference
sys/i386/include/xen/hypercall.h
