7cb282e9e58777aeb2ffd86b344d39a5189c5f84
[sfrench/cifs-2.6.git] / arch / x86 / include / asm / xen / hypercall.h
1 /******************************************************************************
2  * hypercall.h
3  *
4  * Linux-specific hypervisor handling.
5  *
6  * Copyright (c) 2002-2004, K A Fraser
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version 2
10  * as published by the Free Software Foundation; or, when distributed
11  * separately from the Linux kernel or incorporated into other
12  * software packages, subject to the following license:
13  *
14  * Permission is hereby granted, free of charge, to any person obtaining a copy
15  * of this source file (the "Software"), to deal in the Software without
16  * restriction, including without limitation the rights to use, copy, modify,
17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18  * and to permit persons to whom the Software is furnished to do so, subject to
19  * the following conditions:
20  *
21  * The above copyright notice and this permission notice shall be included in
22  * all copies or substantial portions of the Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
30  * IN THE SOFTWARE.
31  */
32
33 #ifndef _ASM_X86_XEN_HYPERCALL_H
34 #define _ASM_X86_XEN_HYPERCALL_H
35
36 #include <linux/kernel.h>
37 #include <linux/spinlock.h>
38 #include <linux/errno.h>
39 #include <linux/string.h>
40 #include <linux/types.h>
41
42 #include <trace/events/xen.h>
43
44 #include <asm/page.h>
45 #include <asm/pgtable.h>
46 #include <asm/smap.h>
47
48 #include <xen/interface/xen.h>
49 #include <xen/interface/sched.h>
50 #include <xen/interface/physdev.h>
51 #include <xen/interface/platform.h>
52 #include <xen/interface/xen-mca.h>
53
54 struct xen_dm_op_buf;
55
56 /*
57  * The hypercall asms have to meet several constraints:
58  * - Work on 32- and 64-bit.
59  *    The two architectures put their arguments in different sets of
60  *    registers.
61  *
62  * - Work around asm syntax quirks
63  *    It isn't possible to specify one of the rNN registers in a
64  *    constraint, so we use explicit register variables to get the
65  *    args into the right place.
66  *
67  * - Mark all registers as potentially clobbered
68  *    Even unused parameters can be clobbered by the hypervisor, so we
69  *    need to make sure gcc knows it.
70  *
71  * - Avoid compiler bugs.
72  *    This is the tricky part.  Because x86_32 has such a constrained
73  *    register set, gcc versions below 4.3 have trouble generating
74  *    code when all the arg registers and memory are trashed by the
75  *    asm.  There are syntactically simpler ways of achieving the
76  *    semantics below, but they cause the compiler to crash.
77  *
78  *    The only combination I found which works is:
79  *     - assign the __argX variables first
80  *     - list all actually used parameters as "+r" (__argX)
81  *     - clobber the rest
82  *
83  * The result certainly isn't pretty, and it really shows up cpp's
84  * weakness as as macro language.  Sorry.  (But let's just give thanks
85  * there aren't more than 5 arguments...)
86  */
87
88 extern struct { char _entry[32]; } hypercall_page[];
89
90 #define __HYPERCALL             "call hypercall_page+%c[offset]"
91 #define __HYPERCALL_ENTRY(x)                                            \
92         [offset] "i" (__HYPERVISOR_##x * sizeof(hypercall_page[0]))
93
94 #ifdef CONFIG_X86_32
95 #define __HYPERCALL_RETREG      "eax"
96 #define __HYPERCALL_ARG1REG     "ebx"
97 #define __HYPERCALL_ARG2REG     "ecx"
98 #define __HYPERCALL_ARG3REG     "edx"
99 #define __HYPERCALL_ARG4REG     "esi"
100 #define __HYPERCALL_ARG5REG     "edi"
101 #else
102 #define __HYPERCALL_RETREG      "rax"
103 #define __HYPERCALL_ARG1REG     "rdi"
104 #define __HYPERCALL_ARG2REG     "rsi"
105 #define __HYPERCALL_ARG3REG     "rdx"
106 #define __HYPERCALL_ARG4REG     "r10"
107 #define __HYPERCALL_ARG5REG     "r8"
108 #endif
109
110 #define __HYPERCALL_DECLS                                               \
111         register unsigned long __res  asm(__HYPERCALL_RETREG);          \
112         register unsigned long __arg1 asm(__HYPERCALL_ARG1REG) = __arg1; \
113         register unsigned long __arg2 asm(__HYPERCALL_ARG2REG) = __arg2; \
114         register unsigned long __arg3 asm(__HYPERCALL_ARG3REG) = __arg3; \
115         register unsigned long __arg4 asm(__HYPERCALL_ARG4REG) = __arg4; \
116         register unsigned long __arg5 asm(__HYPERCALL_ARG5REG) = __arg5;
117
118 #define __HYPERCALL_0PARAM      "=r" (__res), ASM_CALL_CONSTRAINT
119 #define __HYPERCALL_1PARAM      __HYPERCALL_0PARAM, "+r" (__arg1)
120 #define __HYPERCALL_2PARAM      __HYPERCALL_1PARAM, "+r" (__arg2)
121 #define __HYPERCALL_3PARAM      __HYPERCALL_2PARAM, "+r" (__arg3)
122 #define __HYPERCALL_4PARAM      __HYPERCALL_3PARAM, "+r" (__arg4)
123 #define __HYPERCALL_5PARAM      __HYPERCALL_4PARAM, "+r" (__arg5)
124
125 #define __HYPERCALL_0ARG()
126 #define __HYPERCALL_1ARG(a1)                                            \
127         __HYPERCALL_0ARG()              __arg1 = (unsigned long)(a1);
128 #define __HYPERCALL_2ARG(a1,a2)                                         \
129         __HYPERCALL_1ARG(a1)            __arg2 = (unsigned long)(a2);
130 #define __HYPERCALL_3ARG(a1,a2,a3)                                      \
131         __HYPERCALL_2ARG(a1,a2)         __arg3 = (unsigned long)(a3);
132 #define __HYPERCALL_4ARG(a1,a2,a3,a4)                                   \
133         __HYPERCALL_3ARG(a1,a2,a3)      __arg4 = (unsigned long)(a4);
134 #define __HYPERCALL_5ARG(a1,a2,a3,a4,a5)                                \
135         __HYPERCALL_4ARG(a1,a2,a3,a4)   __arg5 = (unsigned long)(a5);
136
137 #define __HYPERCALL_CLOBBER5    "memory"
138 #define __HYPERCALL_CLOBBER4    __HYPERCALL_CLOBBER5, __HYPERCALL_ARG5REG
139 #define __HYPERCALL_CLOBBER3    __HYPERCALL_CLOBBER4, __HYPERCALL_ARG4REG
140 #define __HYPERCALL_CLOBBER2    __HYPERCALL_CLOBBER3, __HYPERCALL_ARG3REG
141 #define __HYPERCALL_CLOBBER1    __HYPERCALL_CLOBBER2, __HYPERCALL_ARG2REG
142 #define __HYPERCALL_CLOBBER0    __HYPERCALL_CLOBBER1, __HYPERCALL_ARG1REG
143
144 #define _hypercall0(type, name)                                         \
145 ({                                                                      \
146         __HYPERCALL_DECLS;                                              \
147         __HYPERCALL_0ARG();                                             \
148         asm volatile (__HYPERCALL                                       \
149                       : __HYPERCALL_0PARAM                              \
150                       : __HYPERCALL_ENTRY(name)                         \
151                       : __HYPERCALL_CLOBBER0);                          \
152         (type)__res;                                                    \
153 })
154
155 #define _hypercall1(type, name, a1)                                     \
156 ({                                                                      \
157         __HYPERCALL_DECLS;                                              \
158         __HYPERCALL_1ARG(a1);                                           \
159         asm volatile (__HYPERCALL                                       \
160                       : __HYPERCALL_1PARAM                              \
161                       : __HYPERCALL_ENTRY(name)                         \
162                       : __HYPERCALL_CLOBBER1);                          \
163         (type)__res;                                                    \
164 })
165
166 #define _hypercall2(type, name, a1, a2)                                 \
167 ({                                                                      \
168         __HYPERCALL_DECLS;                                              \
169         __HYPERCALL_2ARG(a1, a2);                                       \
170         asm volatile (__HYPERCALL                                       \
171                       : __HYPERCALL_2PARAM                              \
172                       : __HYPERCALL_ENTRY(name)                         \
173                       : __HYPERCALL_CLOBBER2);                          \
174         (type)__res;                                                    \
175 })
176
177 #define _hypercall3(type, name, a1, a2, a3)                             \
178 ({                                                                      \
179         __HYPERCALL_DECLS;                                              \
180         __HYPERCALL_3ARG(a1, a2, a3);                                   \
181         asm volatile (__HYPERCALL                                       \
182                       : __HYPERCALL_3PARAM                              \
183                       : __HYPERCALL_ENTRY(name)                         \
184                       : __HYPERCALL_CLOBBER3);                          \
185         (type)__res;                                                    \
186 })
187
188 #define _hypercall4(type, name, a1, a2, a3, a4)                         \
189 ({                                                                      \
190         __HYPERCALL_DECLS;                                              \
191         __HYPERCALL_4ARG(a1, a2, a3, a4);                               \
192         asm volatile (__HYPERCALL                                       \
193                       : __HYPERCALL_4PARAM                              \
194                       : __HYPERCALL_ENTRY(name)                         \
195                       : __HYPERCALL_CLOBBER4);                          \
196         (type)__res;                                                    \
197 })
198
199 #define _hypercall5(type, name, a1, a2, a3, a4, a5)                     \
200 ({                                                                      \
201         __HYPERCALL_DECLS;                                              \
202         __HYPERCALL_5ARG(a1, a2, a3, a4, a5);                           \
203         asm volatile (__HYPERCALL                                       \
204                       : __HYPERCALL_5PARAM                              \
205                       : __HYPERCALL_ENTRY(name)                         \
206                       : __HYPERCALL_CLOBBER5);                          \
207         (type)__res;                                                    \
208 })
209
210 static inline long
211 privcmd_call(unsigned call,
212              unsigned long a1, unsigned long a2,
213              unsigned long a3, unsigned long a4,
214              unsigned long a5)
215 {
216         __HYPERCALL_DECLS;
217         __HYPERCALL_5ARG(a1, a2, a3, a4, a5);
218
219         stac();
220         asm volatile("call *%[call]"
221                      : __HYPERCALL_5PARAM
222                      : [call] "a" (&hypercall_page[call])
223                      : __HYPERCALL_CLOBBER5);
224         clac();
225
226         return (long)__res;
227 }
228
229 static inline int
230 HYPERVISOR_set_trap_table(struct trap_info *table)
231 {
232         return _hypercall1(int, set_trap_table, table);
233 }
234
235 static inline int
236 HYPERVISOR_mmu_update(struct mmu_update *req, int count,
237                       int *success_count, domid_t domid)
238 {
239         return _hypercall4(int, mmu_update, req, count, success_count, domid);
240 }
241
242 static inline int
243 HYPERVISOR_mmuext_op(struct mmuext_op *op, int count,
244                      int *success_count, domid_t domid)
245 {
246         return _hypercall4(int, mmuext_op, op, count, success_count, domid);
247 }
248
249 static inline int
250 HYPERVISOR_set_gdt(unsigned long *frame_list, int entries)
251 {
252         return _hypercall2(int, set_gdt, frame_list, entries);
253 }
254
255 static inline int
256 HYPERVISOR_stack_switch(unsigned long ss, unsigned long esp)
257 {
258         return _hypercall2(int, stack_switch, ss, esp);
259 }
260
261 #ifdef CONFIG_X86_32
262 static inline int
263 HYPERVISOR_set_callbacks(unsigned long event_selector,
264                          unsigned long event_address,
265                          unsigned long failsafe_selector,
266                          unsigned long failsafe_address)
267 {
268         return _hypercall4(int, set_callbacks,
269                            event_selector, event_address,
270                            failsafe_selector, failsafe_address);
271 }
272 #else  /* CONFIG_X86_64 */
273 static inline int
274 HYPERVISOR_set_callbacks(unsigned long event_address,
275                         unsigned long failsafe_address,
276                         unsigned long syscall_address)
277 {
278         return _hypercall3(int, set_callbacks,
279                            event_address, failsafe_address,
280                            syscall_address);
281 }
282 #endif  /* CONFIG_X86_{32,64} */
283
284 static inline int
285 HYPERVISOR_callback_op(int cmd, void *arg)
286 {
287         return _hypercall2(int, callback_op, cmd, arg);
288 }
289
290 static inline int
291 HYPERVISOR_fpu_taskswitch(int set)
292 {
293         return _hypercall1(int, fpu_taskswitch, set);
294 }
295
296 static inline int
297 HYPERVISOR_sched_op(int cmd, void *arg)
298 {
299         return _hypercall2(int, sched_op, cmd, arg);
300 }
301
302 static inline long
303 HYPERVISOR_set_timer_op(u64 timeout)
304 {
305         unsigned long timeout_hi = (unsigned long)(timeout>>32);
306         unsigned long timeout_lo = (unsigned long)timeout;
307         return _hypercall2(long, set_timer_op, timeout_lo, timeout_hi);
308 }
309
310 static inline int
311 HYPERVISOR_mca(struct xen_mc *mc_op)
312 {
313         mc_op->interface_version = XEN_MCA_INTERFACE_VERSION;
314         return _hypercall1(int, mca, mc_op);
315 }
316
317 static inline int
318 HYPERVISOR_platform_op(struct xen_platform_op *op)
319 {
320         op->interface_version = XENPF_INTERFACE_VERSION;
321         return _hypercall1(int, platform_op, op);
322 }
323
324 static inline int
325 HYPERVISOR_set_debugreg(int reg, unsigned long value)
326 {
327         return _hypercall2(int, set_debugreg, reg, value);
328 }
329
330 static inline unsigned long
331 HYPERVISOR_get_debugreg(int reg)
332 {
333         return _hypercall1(unsigned long, get_debugreg, reg);
334 }
335
336 static inline int
337 HYPERVISOR_update_descriptor(u64 ma, u64 desc)
338 {
339         if (sizeof(u64) == sizeof(long))
340                 return _hypercall2(int, update_descriptor, ma, desc);
341         return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32);
342 }
343
344 static inline long
345 HYPERVISOR_memory_op(unsigned int cmd, void *arg)
346 {
347         return _hypercall2(long, memory_op, cmd, arg);
348 }
349
350 static inline int
351 HYPERVISOR_multicall(void *call_list, uint32_t nr_calls)
352 {
353         return _hypercall2(int, multicall, call_list, nr_calls);
354 }
355
356 static inline int
357 HYPERVISOR_update_va_mapping(unsigned long va, pte_t new_val,
358                              unsigned long flags)
359 {
360         if (sizeof(new_val) == sizeof(long))
361                 return _hypercall3(int, update_va_mapping, va,
362                                    new_val.pte, flags);
363         else
364                 return _hypercall4(int, update_va_mapping, va,
365                                    new_val.pte, new_val.pte >> 32, flags);
366 }
367 extern int __must_check xen_event_channel_op_compat(int, void *);
368
369 static inline int
370 HYPERVISOR_event_channel_op(int cmd, void *arg)
371 {
372         int rc = _hypercall2(int, event_channel_op, cmd, arg);
373         if (unlikely(rc == -ENOSYS))
374                 rc = xen_event_channel_op_compat(cmd, arg);
375         return rc;
376 }
377
378 static inline int
379 HYPERVISOR_xen_version(int cmd, void *arg)
380 {
381         return _hypercall2(int, xen_version, cmd, arg);
382 }
383
384 static inline int
385 HYPERVISOR_console_io(int cmd, int count, char *str)
386 {
387         return _hypercall3(int, console_io, cmd, count, str);
388 }
389
390 extern int __must_check xen_physdev_op_compat(int, void *);
391
392 static inline int
393 HYPERVISOR_physdev_op(int cmd, void *arg)
394 {
395         int rc = _hypercall2(int, physdev_op, cmd, arg);
396         if (unlikely(rc == -ENOSYS))
397                 rc = xen_physdev_op_compat(cmd, arg);
398         return rc;
399 }
400
401 static inline int
402 HYPERVISOR_grant_table_op(unsigned int cmd, void *uop, unsigned int count)
403 {
404         return _hypercall3(int, grant_table_op, cmd, uop, count);
405 }
406
407 static inline int
408 HYPERVISOR_update_va_mapping_otherdomain(unsigned long va, pte_t new_val,
409                                          unsigned long flags, domid_t domid)
410 {
411         if (sizeof(new_val) == sizeof(long))
412                 return _hypercall4(int, update_va_mapping_otherdomain, va,
413                                    new_val.pte, flags, domid);
414         else
415                 return _hypercall5(int, update_va_mapping_otherdomain, va,
416                                    new_val.pte, new_val.pte >> 32,
417                                    flags, domid);
418 }
419
420 static inline int
421 HYPERVISOR_vm_assist(unsigned int cmd, unsigned int type)
422 {
423         return _hypercall2(int, vm_assist, cmd, type);
424 }
425
426 static inline int
427 HYPERVISOR_vcpu_op(int cmd, int vcpuid, void *extra_args)
428 {
429         return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
430 }
431
432 #ifdef CONFIG_X86_64
433 static inline int
434 HYPERVISOR_set_segment_base(int reg, unsigned long value)
435 {
436         return _hypercall2(int, set_segment_base, reg, value);
437 }
438 #endif
439
440 static inline int
441 HYPERVISOR_suspend(unsigned long start_info_mfn)
442 {
443         struct sched_shutdown r = { .reason = SHUTDOWN_suspend };
444
445         /*
446          * For a PV guest the tools require that the start_info mfn be
447          * present in rdx/edx when the hypercall is made. Per the
448          * hypercall calling convention this is the third hypercall
449          * argument, which is start_info_mfn here.
450          */
451         return _hypercall3(int, sched_op, SCHEDOP_shutdown, &r, start_info_mfn);
452 }
453
454 static inline int
455 HYPERVISOR_nmi_op(unsigned long op, unsigned long arg)
456 {
457         return _hypercall2(int, nmi_op, op, arg);
458 }
459
460 static inline unsigned long __must_check
461 HYPERVISOR_hvm_op(int op, void *arg)
462 {
463        return _hypercall2(unsigned long, hvm_op, op, arg);
464 }
465
466 static inline int
467 HYPERVISOR_tmem_op(
468         struct tmem_op *op)
469 {
470         return _hypercall1(int, tmem_op, op);
471 }
472
473 static inline int
474 HYPERVISOR_xenpmu_op(unsigned int op, void *arg)
475 {
476         return _hypercall2(int, xenpmu_op, op, arg);
477 }
478
479 static inline int
480 HYPERVISOR_dm_op(
481         domid_t dom, unsigned int nr_bufs, struct xen_dm_op_buf *bufs)
482 {
483         int ret;
484         stac();
485         ret = _hypercall3(int, dm_op, dom, nr_bufs, bufs);
486         clac();
487         return ret;
488 }
489
490 static inline void
491 MULTI_fpu_taskswitch(struct multicall_entry *mcl, int set)
492 {
493         mcl->op = __HYPERVISOR_fpu_taskswitch;
494         mcl->args[0] = set;
495
496         trace_xen_mc_entry(mcl, 1);
497 }
498
499 static inline void
500 MULTI_update_va_mapping(struct multicall_entry *mcl, unsigned long va,
501                         pte_t new_val, unsigned long flags)
502 {
503         mcl->op = __HYPERVISOR_update_va_mapping;
504         mcl->args[0] = va;
505         if (sizeof(new_val) == sizeof(long)) {
506                 mcl->args[1] = new_val.pte;
507                 mcl->args[2] = flags;
508         } else {
509                 mcl->args[1] = new_val.pte;
510                 mcl->args[2] = new_val.pte >> 32;
511                 mcl->args[3] = flags;
512         }
513
514         trace_xen_mc_entry(mcl, sizeof(new_val) == sizeof(long) ? 3 : 4);
515 }
516
517 static inline void
518 MULTI_grant_table_op(struct multicall_entry *mcl, unsigned int cmd,
519                      void *uop, unsigned int count)
520 {
521         mcl->op = __HYPERVISOR_grant_table_op;
522         mcl->args[0] = cmd;
523         mcl->args[1] = (unsigned long)uop;
524         mcl->args[2] = count;
525
526         trace_xen_mc_entry(mcl, 3);
527 }
528
529 static inline void
530 MULTI_update_va_mapping_otherdomain(struct multicall_entry *mcl, unsigned long va,
531                                     pte_t new_val, unsigned long flags,
532                                     domid_t domid)
533 {
534         mcl->op = __HYPERVISOR_update_va_mapping_otherdomain;
535         mcl->args[0] = va;
536         if (sizeof(new_val) == sizeof(long)) {
537                 mcl->args[1] = new_val.pte;
538                 mcl->args[2] = flags;
539                 mcl->args[3] = domid;
540         } else {
541                 mcl->args[1] = new_val.pte;
542                 mcl->args[2] = new_val.pte >> 32;
543                 mcl->args[3] = flags;
544                 mcl->args[4] = domid;
545         }
546
547         trace_xen_mc_entry(mcl, sizeof(new_val) == sizeof(long) ? 4 : 5);
548 }
549
550 static inline void
551 MULTI_update_descriptor(struct multicall_entry *mcl, u64 maddr,
552                         struct desc_struct desc)
553 {
554         mcl->op = __HYPERVISOR_update_descriptor;
555         if (sizeof(maddr) == sizeof(long)) {
556                 mcl->args[0] = maddr;
557                 mcl->args[1] = *(unsigned long *)&desc;
558         } else {
559                 u32 *p = (u32 *)&desc;
560
561                 mcl->args[0] = maddr;
562                 mcl->args[1] = maddr >> 32;
563                 mcl->args[2] = *p++;
564                 mcl->args[3] = *p;
565         }
566
567         trace_xen_mc_entry(mcl, sizeof(maddr) == sizeof(long) ? 2 : 4);
568 }
569
570 static inline void
571 MULTI_memory_op(struct multicall_entry *mcl, unsigned int cmd, void *arg)
572 {
573         mcl->op = __HYPERVISOR_memory_op;
574         mcl->args[0] = cmd;
575         mcl->args[1] = (unsigned long)arg;
576
577         trace_xen_mc_entry(mcl, 2);
578 }
579
580 static inline void
581 MULTI_mmu_update(struct multicall_entry *mcl, struct mmu_update *req,
582                  int count, int *success_count, domid_t domid)
583 {
584         mcl->op = __HYPERVISOR_mmu_update;
585         mcl->args[0] = (unsigned long)req;
586         mcl->args[1] = count;
587         mcl->args[2] = (unsigned long)success_count;
588         mcl->args[3] = domid;
589
590         trace_xen_mc_entry(mcl, 4);
591 }
592
593 static inline void
594 MULTI_mmuext_op(struct multicall_entry *mcl, struct mmuext_op *op, int count,
595                 int *success_count, domid_t domid)
596 {
597         mcl->op = __HYPERVISOR_mmuext_op;
598         mcl->args[0] = (unsigned long)op;
599         mcl->args[1] = count;
600         mcl->args[2] = (unsigned long)success_count;
601         mcl->args[3] = domid;
602
603         trace_xen_mc_entry(mcl, 4);
604 }
605
606 static inline void
607 MULTI_set_gdt(struct multicall_entry *mcl, unsigned long *frames, int entries)
608 {
609         mcl->op = __HYPERVISOR_set_gdt;
610         mcl->args[0] = (unsigned long)frames;
611         mcl->args[1] = entries;
612
613         trace_xen_mc_entry(mcl, 2);
614 }
615
616 static inline void
617 MULTI_stack_switch(struct multicall_entry *mcl,
618                    unsigned long ss, unsigned long esp)
619 {
620         mcl->op = __HYPERVISOR_stack_switch;
621         mcl->args[0] = ss;
622         mcl->args[1] = esp;
623
624         trace_xen_mc_entry(mcl, 2);
625 }
626
627 #endif /* _ASM_X86_XEN_HYPERCALL_H */