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 static inline int
  238 HYPERVISOR_multicall(
  239         void *call_list, int nr_calls)
  240 {
  241         return _hypercall2(int, multicall, call_list, nr_calls);
  242 }
  243 
  244 static inline int
  245 HYPERVISOR_update_va_mapping(
  246         unsigned long va, uint64_t new_val, unsigned long flags)
  247 {
  248         uint32_t hi, lo;
  249 
  250         lo = (uint32_t)(new_val & 0xffffffff);
  251         hi = (uint32_t)(new_val >> 32);
  252         
  253         return _hypercall4(int, update_va_mapping, va,
  254                            lo, hi, flags);
  255 }
  256 
  257 static inline int
  258 HYPERVISOR_event_channel_op(
  259         int cmd, void *arg)
  260 {
  261         int rc = _hypercall2(int, event_channel_op, cmd, arg);
  262 
  263 #if CONFIG_XEN_COMPAT <= 0x030002
  264         if (__predict_false(rc == -ENOXENSYS)) {
  265                 struct evtchn_op op;
  266                 op.cmd = cmd;
  267                 memcpy(&op.u, arg, sizeof(op.u));
  268                 rc = _hypercall1(int, event_channel_op_compat, &op);
  269                 memcpy(arg, &op.u, sizeof(op.u));
  270         }
  271 #endif
  272         return (rc);
  273 }
  274 
  275 static inline int
  276 HYPERVISOR_xen_version(
  277         int cmd, void *arg)
  278 {
  279         return _hypercall2(int, xen_version, cmd, arg);
  280 }
  281 
  282 static inline int
  283 HYPERVISOR_console_io(
  284         int cmd, int count, char *str)
  285 {
  286         return _hypercall3(int, console_io, cmd, count, str);
  287 }
  288 
  289 static inline int
  290 HYPERVISOR_physdev_op(
  291         int cmd, void *arg)
  292 {
  293         int rc = _hypercall2(int, physdev_op, cmd, arg);
  294 #if CONFIG_XEN_COMPAT <= 0x030002
  295         if (__predict_false(rc == -ENOXENSYS)) {
  296                 struct physdev_op op;
  297                 op.cmd = cmd;
  298                 memcpy(&op.u, arg, sizeof(op.u));
  299                 rc = _hypercall1(int, physdev_op_compat, &op);
  300                 memcpy(arg, &op.u, sizeof(op.u));
  301         }
  302 #endif
  303         return (rc);
  304 }
  305 
  306 static inline int
  307 HYPERVISOR_grant_table_op(
  308         unsigned int cmd, void *uop, unsigned int count)
  309 {
  310         return _hypercall3(int, grant_table_op, cmd, uop, count);
  311 }
  312 
  313 static inline int
  314 HYPERVISOR_update_va_mapping_otherdomain(
  315         unsigned long va, uint64_t new_val, unsigned long flags, domid_t domid)
  316 {
  317         uint32_t hi, lo;
  318         
  319         lo = (uint32_t)(new_val & 0xffffffff);
  320         hi = (uint32_t)(new_val >> 32);
  321         
  322         return _hypercall5(int, update_va_mapping_otherdomain, va,
  323                            lo, hi, flags, domid);
  324 }
  325 
  326 static inline int
  327 HYPERVISOR_vm_assist(
  328         unsigned int cmd, unsigned int type)
  329 {
  330         return _hypercall2(int, vm_assist, cmd, type);
  331 }
  332 
  333 static inline int
  334 HYPERVISOR_vcpu_op(
  335         int cmd, int vcpuid, void *extra_args)
  336 {
  337         return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
  338 }
  339 
  340 static inline int
  341 HYPERVISOR_suspend(
  342         unsigned long srec)
  343 {
  344         struct sched_shutdown sched_shutdown = {
  345                 .reason = SHUTDOWN_suspend
  346         };
  347         int rc = _hypercall3(int, sched_op, SCHEDOP_shutdown,
  348                            &sched_shutdown, srec);
  349 #if CONFIG_XEN_COMPAT <= 0x030002
  350         if (rc == -ENOXENSYS)
  351                 rc = _hypercall3(int, sched_op_compat, SCHEDOP_shutdown,
  352                                  SHUTDOWN_suspend, srec);
  353 #endif  
  354         return (rc);
  355 }
  356 
  357 #if CONFIG_XEN_COMPAT <= 0x030002
  358 static inline int
  359 HYPERVISOR_nmi_op(
  360         unsigned long op, void *arg)
  361 {
  362         return _hypercall2(int, nmi_op, op, arg);
  363 }
  364 #endif
  365 
  366 static inline int
  367 HYPERVISOR_callback_op(
  368         int cmd, void *arg)
  369 {
  370         return _hypercall2(int, callback_op, cmd, arg);
  371 }
  372 
  373 #ifndef CONFIG_XEN
  374 static inline unsigned long
  375 HYPERVISOR_hvm_op(
  376     int op, void *arg)
  377 {
  378     return _hypercall2(unsigned long, hvm_op, op, arg);
  379 }
  380 #endif
  381 
  382 static inline int
  383 HYPERVISOR_xenoprof_op(
  384         int op, void *arg)
  385 {
  386         return _hypercall2(int, xenoprof_op, op, arg);
  387 }
  388 
  389 static inline int
  390 HYPERVISOR_kexec_op(
  391         unsigned long op, void *args)
  392 {
  393         return _hypercall2(int, kexec_op, op, args);
  394 }
  395 #endif /* __HYPERCALL_H__ */
  396 
  397 /*
  398  * Local variables:
  399  *  c-file-style: "linux"
  400  *  indent-tabs-mode: t
  401  *  c-indent-level: 8
  402  *  c-basic-offset: 8
  403  *  tab-width: 8
  404  * End:
  405  */
Cache object: c7cc8cff5ce24c0bbac19c170a06ad64
[ 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
