2 #ifndef __syscall_retval
3 #define __syscall_retval(v) do { } while(0)
6 #ifndef __syscall_error
7 #define __syscall_error(e) do { errno = (e); } while(0)
10 #define __check(pos, reg) \
11 ".ifnc " pos ", " reg "\n\t" \
16 #define __stringify0(val) #val
20 #define __stringify(val) __stringify0(val)
23 #define __comment(name) \
24 "\t/* kernel sys_" #name "[" __stringify(__NR_##name) "] */"
27 /* *****************************************
28 ALPHA ALPHA ALPHA ALPHA *
29 alpha kernel interface */
31 #if defined(__alpha__)
33 /* The Alpha calling convention doesn't use the stack until
34 after the first six arguments have been passed in registers.
37 args: a0($16), a1($17), a2($18), a3($19), a4($20), a5($21)
39 serr: a3($19) (!=0, err=sret)
43 #define __syscall_return(type, ret, err) do { \
44 __syscall_retval(ret); \
47 __syscall_error(__err); \
53 #define __syscall_regdef(name, reg) \
54 register long __sc_##name __asm__ (reg)
56 #define __syscall_regval(name, reg, val) \
57 register long __sc_##name __asm__ (reg) = (long)(val)
59 #define __syscall_clobbers \
60 "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
61 "$22", "$23", "$24", "$25", "$27", "$28", "memory" \
64 #define _syscall0(type, name) \
67 long __sc_ret, __sc_err; \
69 __syscall_regval(v0, "$0", __NR_##name); \
70 __syscall_regdef(a3, "$19"); \
72 __asm__ __volatile__ ( \
73 __check("%0%1%2", "$0$19$0") \
74 "callsys" __comment(name) \
75 : "=r"(__sc_v0), "=r"(__sc_a3) \
77 : "$16", "$17", "$18", "$20", "$21", \
83 __syscall_return(type, __sc_ret, __sc_err); \
86 #define _syscall1(type, name, type1, arg1) \
87 type name(type1 arg1) \
89 long __sc_ret, __sc_err; \
91 __syscall_regval(v0, "$0", __NR_##name); \
92 __syscall_regval(a0, "$16", arg1); \
93 __syscall_regdef(a3, "$19"); \
95 __asm__ __volatile__ ( \
96 __check("%0%1%2%3", "$0$19$0$16") \
97 "callsys" __comment(name) \
98 : "=r"(__sc_v0), "=r"(__sc_a3) \
101 : "$17", "$18", "$20", "$21", \
104 __sc_ret = __sc_v0; \
105 __sc_err = __sc_a3; \
107 __syscall_return(type, __sc_ret, __sc_err); \
110 #define _syscall2(type, name, type1, arg1, type2, arg2) \
111 type name(type1 arg1, type2 arg2) \
113 long __sc_ret, __sc_err; \
115 __syscall_regval(v0, "$0", __NR_##name); \
116 __syscall_regval(a0, "$16", arg1); \
117 __syscall_regval(a1, "$17", arg2); \
118 __syscall_regdef(a3, "$19"); \
120 __asm__ __volatile__ ( \
121 __check("%0%1%2%3%4", "$0$19$0$16$17") \
122 "callsys" __comment(name) \
123 : "=r"(__sc_v0), "=r"(__sc_a3) \
125 "r"(__sc_a0), "r"(__sc_a1) \
126 : "$18", "$20", "$21", \
129 __sc_ret = __sc_v0; \
130 __sc_err = __sc_a3; \
132 __syscall_return(type, __sc_ret, __sc_err); \
135 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
136 type name(type1 arg1, type2 arg2, type3 arg3) \
138 long __sc_ret, __sc_err; \
140 __syscall_regval(v0, "$0", __NR_##name); \
141 __syscall_regval(a0, "$16", arg1); \
142 __syscall_regval(a1, "$17", arg2); \
143 __syscall_regval(a2, "$18", arg3); \
144 __syscall_regdef(a3, "$19"); \
146 __asm__ __volatile__ ( \
147 __check("%0%1%2%3%4%5", "$0$19$0$16$17$18") \
148 "callsys" __comment(name) \
149 : "=r"(__sc_v0), "=r"(__sc_a3) \
151 "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2) \
155 __sc_ret = __sc_v0; \
156 __sc_err = __sc_a3; \
158 __syscall_return(type, __sc_ret, __sc_err); \
161 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
163 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
165 long __sc_ret, __sc_err; \
167 __syscall_regval(v0, "$0", __NR_##name); \
168 __syscall_regval(a0, "$16", arg1); \
169 __syscall_regval(a1, "$17", arg2); \
170 __syscall_regval(a2, "$18", arg3); \
171 __syscall_regval(a3, "$19", arg4); \
173 __asm__ __volatile__ ( \
174 __check("%0%1%2%3%4%5%6", "$0$19$0$16$17$18$19") \
175 "callsys" __comment(name) \
176 : "=r"(__sc_v0), "=r"(__sc_a3) \
178 "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
183 __sc_ret = __sc_v0; \
184 __sc_err = __sc_a3; \
186 __syscall_return(type, __sc_ret, __sc_err); \
189 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
190 type4, arg4, type5, arg5) \
191 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
193 long __sc_ret, __sc_err; \
195 __syscall_regval(v0, "$0", __NR_##name); \
196 __syscall_regval(a0, "$16", arg1); \
197 __syscall_regval(a1, "$17", arg2); \
198 __syscall_regval(a2, "$18", arg3); \
199 __syscall_regval(a3, "$19", arg4); \
200 __syscall_regval(a4, "$20", arg5); \
202 __asm__ __volatile__ ( \
203 __check("%0%1%2%3%4%5%6%7", "$0$19$0$16$17$18$19$20") \
204 "callsys" __comment(name) \
205 : "=r"(__sc_v0), "=r"(__sc_a3) \
207 "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
208 "1"(__sc_a3), "r"(__sc_a4) \
212 __sc_ret = __sc_v0; \
213 __sc_err = __sc_a3; \
215 __syscall_return(type, __sc_ret, __sc_err); \
218 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
219 type4, arg4, type5, arg5, type6, arg6) \
220 type name (type1 arg1, type2 arg2, type3 arg3, \
221 type4 arg4, type5 arg5, type6 arg6) \
223 long __sc_ret, __sc_err; \
225 __syscall_regval(v0, "$0", __NR_##name); \
226 __syscall_regval(a0, "$16", arg1); \
227 __syscall_regval(a1, "$17", arg2); \
228 __syscall_regval(a2, "$18", arg3); \
229 __syscall_regval(a3, "$19", arg4); \
230 __syscall_regval(a4, "$20", arg5); \
231 __syscall_regval(a5, "$21", arg6); \
233 __asm__ __volatile__ ( \
234 __check("%0%1%2%3%4%5%6%7%8", \
235 "$0$19$0$16$17$18$19$20$21") \
236 "callsys" __comment(name) \
237 : "=r"(__sc_v0), "=r"(__sc_a3) \
239 "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
240 "1"(__sc_a3), "r"(__sc_a4), "r"(__sc_a5) \
241 : __syscall_clobbers \
243 __sc_ret = __sc_v0; \
244 __sc_err = __sc_a3; \
246 __syscall_return(type, __sc_ret, __sc_err); \
251 /* *****************************************
253 arm kernel interface */
255 #elif defined(__arm__)
257 /* The Arm calling convention uses stack args after four arguments
258 but the Linux kernel gets up to seven arguments in registers.
261 args: a1(r0), a2(r1), a3(r2), a4(r3), v1(r4), v2(r5),
263 serr: (err= sret > (unsigned)-EMAXERRNO)
267 #define EMAXERRNO 125
270 #define __syscall_errcon(res) \
271 ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
273 #define __syscall_return(type, res) do { \
274 __syscall_retval(res); \
275 if (__syscall_errcon(res)) { \
276 int __err = -(res); \
277 __syscall_error(__err); \
283 #define __syscall_regdef(name, reg) \
284 register int __sc_##name __asm__ (reg)
286 #define __syscall_regval(name, reg, val) \
287 register int __sc_##name __asm__ (reg) = (int)(val)
290 #define _syscall0(type, name) \
295 __syscall_regdef(a1, "r0"); \
297 __asm__ __volatile__ ( \
298 __check("%0", "r0") \
299 "swi %1" __comment(name) \
304 __sc_res = __sc_a1; \
306 __syscall_return(type, __sc_res); \
309 #define _syscall1(type, name, type1, arg1) \
310 type name(type1 arg1) \
314 __syscall_regval(a1, "r0", arg1); \
316 __asm__ __volatile__ ( \
317 __check("%0%2", "r0r0") \
318 "swi %1" __comment(name) \
320 : "i"(__NR_##name), \
324 __sc_res = __sc_a1; \
326 __syscall_return(type, __sc_res); \
329 #define _syscall2(type, name, type1, arg1, type2, arg2) \
330 type name(type1 arg1, type2 arg2) \
334 __syscall_regval(a1, "r0", arg1); \
335 __syscall_regval(a2, "r1", arg2); \
337 __asm__ __volatile__ ( \
338 __check("%0%2%3", "r0r0r1") \
339 "swi %1" __comment(name) \
341 : "i"(__NR_##name), \
342 "0"(__sc_a1), "r"(__sc_a2) \
345 __sc_res = __sc_a1; \
347 __syscall_return(type, __sc_res); \
350 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
351 type name(type1 arg1, type2 arg2, type3 arg3) \
355 __syscall_regval(a1, "r0", arg1); \
356 __syscall_regval(a2, "r1", arg2); \
357 __syscall_regval(a3, "r2", arg3); \
359 __asm__ __volatile__ ( \
360 __check("%0%2%3%4", "r0r0r1r2") \
361 "swi %1" __comment(name) \
363 : "i"(__NR_##name), \
364 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3) \
367 __sc_res = __sc_a1; \
369 __syscall_return(type, __sc_res); \
372 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
374 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
378 __syscall_regval(a1, "r0", arg1); \
379 __syscall_regval(a2, "r1", arg2); \
380 __syscall_regval(a3, "r2", arg3); \
381 __syscall_regval(a4, "r3", arg4); \
383 __asm__ __volatile__ ( \
384 __check("%0%2%3%4%5", "r0r0r1r2r3") \
385 "swi %1" __comment(name) \
387 : "i"(__NR_##name), \
388 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
392 __sc_res = __sc_a1; \
394 __syscall_return(type, __sc_res); \
397 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
398 type4, arg4, type5, arg5) \
399 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
403 __syscall_regval(a1, "r0", arg1); \
404 __syscall_regval(a2, "r1", arg2); \
405 __syscall_regval(a3, "r2", arg3); \
406 __syscall_regval(a4, "r3", arg4); \
407 __syscall_regval(v1, "r4", arg5); \
409 __asm__ __volatile__ ( \
410 __check("%0%2%3%4%5%6", "r0r0r1r2r3r4") \
411 "swi %1" __comment(name) \
413 : "i"(__NR_##name), \
414 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
415 "r"(__sc_a4), "r"(__sc_v1) \
418 __sc_res = __sc_a1; \
420 __syscall_return(type, __sc_res); \
423 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
424 type4, arg4, type5, arg5, type6, arg6) \
425 type name (type1 arg1, type2 arg2, type3 arg3, \
426 type4 arg4, type5 arg5, type6 arg6) \
430 __syscall_regval(a1, "r0", arg1); \
431 __syscall_regval(a2, "r1", arg2); \
432 __syscall_regval(a3, "r2", arg3); \
433 __syscall_regval(a4, "r3", arg4); \
434 __syscall_regval(v1, "r4", arg5); \
435 __syscall_regval(v2, "r5", arg6); \
437 __asm__ __volatile__ ( \
438 __check("%0%2%3%4%5%6%7", "r0r0r1r2r3r4r5") \
439 "swi %1" __comment(name) \
441 : "i"(__NR_##name), \
442 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
443 "r"(__sc_a4), "r"(__sc_v1), "r"(__sc_v2) \
446 __sc_res = __sc_a1; \
448 __syscall_return(type, __sc_res); \
452 /* *****************************************
453 CRIS CRIS CRIS CRIS *
454 cris v10 kernel interface */
456 #elif defined(__cris__)
458 /* The Cris calling convention uses stack args after four arguments
459 but the Linux kernel gets up to six arguments in registers.
462 args: (r10), (r11), (r12), (r13), (mof), (srp),
464 serr: (err= sret > (unsigned)-EMAXERRNO)
468 #define EMAXERRNO 125
471 #define __syscall_errcon(res) \
472 ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
474 #define __syscall_return(type, res) do { \
475 __syscall_retval(res); \
476 if (__syscall_errcon(res)) { \
477 int __err = -(res); \
478 __syscall_error(__err); \
484 #define __syscall_regdef(name, reg) \
485 register long __sc_##name __asm__ (reg)
487 #define __syscall_regval(name, reg, val) \
488 register long __sc_##name __asm__ (reg) = (long)(val)
490 #define _syscall0(type, name) \
495 __syscall_regval(a0, "r9", __NR_##name); \
496 __syscall_regdef(a1, "r10"); \
498 __asm__ __volatile__ ( \
499 __check("%0%1", "$r10$r9") \
500 "break 13" __comment(name) \
503 : "memory", "srp", "r13", "r12", "r11" \
505 __sc_res = __sc_a1; \
507 __syscall_return(type, __sc_res); \
510 #define _syscall1(type, name, type1, arg1) \
511 type name(type1 arg1) \
515 __syscall_regval(a0, "r9", __NR_##name); \
516 __syscall_regval(a1, "r10", arg1); \
518 __asm__ __volatile__ ( \
519 __check("%0%1%2", "$r10$r9$r10") \
520 "break 13" __comment(name) \
524 : "memory", "srp", "r13", "r12", "r11" \
526 __sc_res = __sc_a1; \
528 __syscall_return(type, __sc_res); \
531 #define _syscall2(type, name, type1, arg1, type2, arg2) \
532 type name(type1 arg1, type2 arg2) \
536 __syscall_regval(a0, "r9", __NR_##name); \
537 __syscall_regval(a1, "r10", arg1); \
538 __syscall_regval(a2, "r11", arg2); \
540 __asm__ __volatile__ ( \
541 __check("%0%1%2%3", "$r10$r9$r10$r11") \
542 "break 13" __comment(name) \
545 "0"(__sc_a1), "r"(__sc_a2) \
546 : "memory", "srp", "r13", "r12" \
548 __sc_res = __sc_a1; \
550 __syscall_return(type, __sc_res); \
553 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
554 type name(type1 arg1, type2 arg2, type3 arg3) \
558 __syscall_regval(a0, "r9", __NR_##name); \
559 __syscall_regval(a1, "r10", arg1); \
560 __syscall_regval(a2, "r11", arg2); \
561 __syscall_regval(a3, "r12", arg3); \
563 __asm__ __volatile__ ( \
564 __check("%0%1%2%3%4", "$r10$r9$r10$r11$r12") \
565 "break 13" __comment(name) \
568 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3) \
569 : "memory", "srp", "r13" \
571 __sc_res = __sc_a1; \
573 __syscall_return(type, __sc_res); \
576 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
578 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
582 __syscall_regval(a0, "r9", __NR_##name); \
583 __syscall_regval(a1, "r10", arg1); \
584 __syscall_regval(a2, "r11", arg2); \
585 __syscall_regval(a3, "r12", arg3); \
586 __syscall_regval(a4, "r13", arg4); \
588 __asm__ __volatile__ ( \
589 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13") \
590 "break 13" __comment(name) \
593 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
597 __sc_res = __sc_a1; \
599 __syscall_return(type, __sc_res); \
602 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
603 type4, arg4, type5, arg5) \
604 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
608 __syscall_regval(a0, "r9", __NR_##name); \
609 __syscall_regval(a1, "r10", arg1); \
610 __syscall_regval(a2, "r11", arg2); \
611 __syscall_regval(a3, "r12", arg3); \
612 __syscall_regval(a4, "r13", arg4); \
614 __asm__ __volatile__ ( \
615 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13") \
617 "break 13" __comment(name) \
620 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
625 __sc_res = __sc_a1; \
627 __syscall_return(type, __sc_res); \
630 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
631 type4, arg4, type5, arg5, type6, arg6) \
632 type name (type1 arg1, type2 arg2, type3 arg3, \
633 type4 arg4, type5 arg5, type6 arg6) \
637 __syscall_regval(a0, "r9", __NR_##name); \
638 __syscall_regval(a1, "r10", arg1); \
639 __syscall_regval(a2, "r11", arg2); \
640 __syscall_regval(a3, "r12", arg3); \
641 __syscall_regval(a4, "r13", arg4); \
643 __asm__ __volatile__ ( \
644 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13") \
647 "break 13" __comment(name) \
650 "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
652 "g"((long)arg5), "g"((long)arg6) \
655 __sc_res = __sc_a1; \
657 __syscall_return(type, __sc_res); \
661 /* *****************************************
663 frv kernel interface */
665 #elif defined(__frv__)
667 #warning syscall arch frv not implemented yet
670 /* *****************************************
671 H8300 H8300 H8300 H8300 *
672 h8/300 kernel interface */
674 #elif defined(__h8300__)
676 #warning syscall arch h8300 not implemented yet
679 /* *****************************************
680 I386 I386 I386 I386 *
681 i386 kernel interface */
683 #elif defined(__i386__)
685 /* The x86 calling convention uses stack args for all arguments,
686 but the Linux kernel passes the first six arguments in the
687 following registers: ebx, ecx, edx, esi, edi, ebp.
690 args: a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp)
692 serr: (err= sret > (unsigned)-EMAXERRNO)
696 #define EMAXERRNO 129
699 #define __syscall_errcon(res) \
700 ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
702 #define __syscall_return(type, res) do { \
703 __syscall_retval(res); \
704 if (__syscall_errcon(res)) { \
705 int __err = -(res); \
706 __syscall_error(__err); \
712 #define __syscall_regdef(name, reg) \
713 register long __sc_##name __asm__ (reg)
715 #define __syscall_regval(name, reg, val) \
716 register long __sc_##name __asm__ (reg) = (long)(val)
719 #define _syscall0(type, name) \
724 __syscall_regval(a0, "eax", __NR_##name); \
727 __check("%0%1", "%%eax%%eax") \
728 "int $0x80" __comment(name) \
733 __sc_res = __sc_a0; \
735 __syscall_return(type, __sc_res); \
738 #define _syscall1(type, name, type1, arg1) \
739 type name(type1 arg1) \
743 __syscall_regval(a0, "eax", __NR_##name); \
744 __syscall_regval(a1, "ebx", arg1); \
747 __check("%0%1%2", "%%eax%%eax%%ebx") \
748 "int $0x80" __comment(name) \
754 __sc_res = __sc_a0; \
756 __syscall_return(type, __sc_res); \
759 #define _syscall2(type, name, type1, arg1, type2, arg2) \
760 type name(type1 arg1, type2 arg2) \
764 __syscall_regval(a0, "eax", __NR_##name); \
765 __syscall_regval(a1, "ebx", arg1); \
766 __syscall_regval(a2, "ecx", arg2); \
769 __check("%0%1%2%3", "%%eax%%eax%%ebx%%ecx") \
770 "int $0x80" __comment(name) \
773 "r" (__sc_a1), "r"(__sc_a2) \
776 __sc_res = __sc_a0; \
778 __syscall_return(type, __sc_res); \
781 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
782 type name(type1 arg1, type2 arg2, type3 arg3) \
786 __syscall_regval(a0, "eax", __NR_##name); \
787 __syscall_regval(a1, "ebx", arg1); \
788 __syscall_regval(a2, "ecx", arg2); \
789 __syscall_regval(a3, "edx", arg3); \
792 __check("%0%1%2%3%4", "%%eax%%eax%%ebx%%ecx%%edx") \
793 "int $0x80" __comment(name) \
796 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3) \
799 __sc_res = __sc_a0; \
801 __syscall_return(type, __sc_res); \
805 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
807 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
811 __syscall_regval(a0, "eax", __NR_##name); \
812 __syscall_regval(a1, "ebx", arg1); \
813 __syscall_regval(a2, "ecx", arg2); \
814 __syscall_regval(a3, "edx", arg3); \
815 __syscall_regval(a4, "esi", arg4); \
818 __check("%0%1%2%3%4%5", \
819 "%%eax%%eax%%ebx%%ecx%%edx%%esi") \
820 "int $0x80" __comment(name) \
823 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
827 __sc_res = __sc_a0; \
829 __syscall_return(type, __sc_res); \
832 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
833 type4, arg4, type5, arg5) \
834 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
838 __syscall_regval(a0, "eax", __NR_##name); \
839 __syscall_regval(a1, "ebx", arg1); \
840 __syscall_regval(a2, "ecx", arg2); \
841 __syscall_regval(a3, "edx", arg3); \
842 __syscall_regval(a4, "esi", arg4); \
843 __syscall_regval(a5, "edi", arg5); \
846 __check("%0%1%2%3%4%5%6", \
847 "%%eax%%eax%%ebx%%ecx%%edx%%esi%%edi") \
848 "int $0x80" __comment(name) \
851 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
852 "r" (__sc_a4), "r"(__sc_a5) \
855 __sc_res = __sc_a0; \
857 __syscall_return(type, __sc_res); \
860 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
861 type4, arg4, type5, arg5, type6, arg6) \
862 type name (type1 arg1, type2 arg2, type3 arg3, \
863 type4 arg4, type5 arg5, type6 arg6) \
867 __syscall_regval(a0, "eax", __NR_##name); \
868 __syscall_regval(a1, "ebx", arg1); \
869 __syscall_regval(a2, "ecx", arg2); \
870 __syscall_regval(a3, "edx", arg3); \
871 __syscall_regval(a4, "esi", arg4); \
872 __syscall_regval(a5, "edi", arg5); \
873 __syscall_regval(a6, "ebp", arg6); \
876 __check("%0%1%2%3%4%5%6%7", \
877 "%%eax%%eax%%ebx%%ecx%%edx%%esi%%edi%%ebp") \
878 "int $0x80" __comment(name) \
881 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
882 "r" (__sc_a4), "r"(__sc_a5), "r" (__sc_a6) \
885 __sc_res = __sc_a0; \
887 __syscall_return(type, __sc_res); \
891 /* *****************************************
892 IA64 IA64 IA64 IA64 *
893 ia64 kernel interface */
895 #elif defined(__ia64__)
897 #warning syscall arch ia64 not implemented yet
900 /* *****************************************
901 M32R IM32R M32R M32R *
902 m32r kernel interface */
904 #elif defined(__m32r__)
906 #warning syscall arch m32r not implemented yet
909 /* *****************************************
910 M68K M68K M68K M68K *
911 m68k kernel interface */
913 #elif defined(__mc68000__)
915 #warning syscall arch m68k not implemented yet
918 /* *****************************************
919 MIPS MIPS MIPS MIPS *
920 mips kernel interface */
922 #elif defined(__mips__)
924 #warning syscall arch mips not implemented yet
927 /* *****************************************
928 HPPA HPPA HPPA HPPA *
929 hppa kernel interface */
931 #elif defined(__hppa__)
933 #warning syscall arch hppa not implemented yet
936 /* *****************************************
937 PPC64 PPC64 PPC64 PPC64 *
938 ppc64 kernel interface */
940 #elif defined(__powerpc64__)
942 #warning syscall arch ppc64 not implemented yet
945 /* *****************************************
947 ppc kernel interface */
949 #elif defined(__powerpc__)
951 #warning syscall arch ppc not implemented yet
954 /* *****************************************
955 S390X S390X S390X S390X *
956 s390x kernel interface */
958 #elif defined(__s390x__)
960 #warning syscall arch s390x not implemented yet
963 /* *****************************************
964 S390 S390 S390 S390 *
965 s390 kernel interface */
967 #elif defined(__s390__)
969 #warning syscall arch s390 not implemented yet
972 /* *****************************************
974 sh kernel interface */
976 #elif defined(__sh__) && !defined(__SH5__)
978 #warning syscall arch sh not implemented yet
981 /* *****************************************
982 SH64 SH64 SH64 SH64 *
983 sh64 kernel interface */
985 #elif defined(__sh__) && defined(__SH5__)
987 #warning syscall arch sh64 not implemented yet
990 /* *****************************************
991 SPARC64 SPARC64 SPARC64 SPARC64 *
992 sparc64 kernel interface */
994 #elif defined(__sparc__) && defined(__sparc_v9__)
996 #warning syscall arch sparc64 not implemented yet
999 /* *****************************************
1000 SPARC SPARC SPARC SPARC *
1001 sparc kernel interface */
1003 #elif defined(__sparc__)
1005 #warning syscall arch sparc not implemented yet
1008 /* *****************************************
1009 V850 V850 V850 V850 *
1010 v850 kernel interface */
1012 #elif defined(__v850__)
1014 #warning syscall arch v850 not implemented yet
1017 /* *****************************************
1018 X86_64 X86_64 X86_64 X86_64 *
1019 x86_64 kernel interface */
1021 #elif defined(__x86_64__)
1023 /* The x86_64 calling convention uses rdi, rsi, rdx, rcx, r8, r9
1024 but the Linux kernel interface uses rdi, rsi, rdx, r10, r8, r9.
1027 args: a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9)
1029 serr: (err= sret > (unsigned)-EMAXERRNO)
1035 #define EMAXERRNO 4095
1038 #define __syscall_errcon(res) \
1039 ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
1041 #define __syscall_return(type, res) do { \
1042 __syscall_retval(res); \
1043 if (__syscall_errcon(res)) { \
1044 int __err = -(res); \
1045 __syscall_error(__err); \
1048 return (type) res; \
1051 #define __syscall_clobbers \
1052 "cc", "r11", "rcx", "memory"
1054 #define __syscall_regdef(name, reg) \
1055 register long __sc_##name __asm__ (reg)
1057 #define __syscall_regval(name, reg, val) \
1058 register long __sc_##name __asm__ (reg) = (long)(val)
1061 #define _syscall0(type, name) \
1066 __syscall_regval(a0, "rax", __NR_##name); \
1068 __asm__ volatile ( \
1069 __check("%0%1", "%%rax%%rax") \
1070 "syscall" __comment(name) \
1073 : __syscall_clobbers \
1075 __sc_res = __sc_a0; \
1077 __syscall_return(type, __sc_res); \
1080 #define _syscall1(type, name, type1, arg1) \
1081 type name(type1 arg1) \
1085 __syscall_regval(a0, "rax", __NR_##name); \
1086 __syscall_regval(a1, "rdi", arg1); \
1088 __asm__ volatile ( \
1089 __check("%0%1%2", "%%rax%%rax%%rdi") \
1090 "syscall" __comment(name) \
1094 : __syscall_clobbers \
1096 __sc_res = __sc_a0; \
1098 __syscall_return(type, __sc_res); \
1101 #define _syscall2(type, name, type1, arg1, type2, arg2) \
1102 type name(type1 arg1, type2 arg2) \
1106 __syscall_regval(a0, "rax", __NR_##name); \
1107 __syscall_regval(a1, "rdi", arg1); \
1108 __syscall_regval(a2, "rsi", arg2); \
1110 __asm__ volatile ( \
1111 __check("%0%1%2%3", "%%rax%%rax%%rdi%%rsi") \
1112 "syscall" __comment(name) \
1115 "r" (__sc_a1), "r"(__sc_a2) \
1116 : __syscall_clobbers \
1118 __sc_res = __sc_a0; \
1120 __syscall_return(type, __sc_res); \
1123 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
1124 type name(type1 arg1, type2 arg2, type3 arg3) \
1128 __syscall_regval(a0, "rax", __NR_##name); \
1129 __syscall_regval(a1, "rdi", arg1); \
1130 __syscall_regval(a2, "rsi", arg2); \
1131 __syscall_regval(a3, "rdx", arg3); \
1133 __asm__ volatile ( \
1134 __check("%0%1%2%3%4", "%%rax%%rax%%rdi%%rsi%%rdx") \
1135 "syscall" __comment(name) \
1138 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3) \
1139 : __syscall_clobbers \
1141 __sc_res = __sc_a0; \
1143 __syscall_return(type, __sc_res); \
1147 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
1149 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
1153 __syscall_regval(a0, "rax", __NR_##name); \
1154 __syscall_regval(a1, "rdi", arg1); \
1155 __syscall_regval(a2, "rsi", arg2); \
1156 __syscall_regval(a3, "rdx", arg3); \
1157 __syscall_regval(a4, "r10", arg4); \
1159 __asm__ volatile ( \
1160 __check("%0%1%2%3%4%5", \
1161 "%%rax%%rax%%rdi%%rsi%%rdx%%r10") \
1162 "syscall" __comment(name) \
1165 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
1167 : __syscall_clobbers \
1169 __sc_res = __sc_a0; \
1171 __syscall_return(type, __sc_res); \
1174 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
1175 type4, arg4, type5, arg5) \
1176 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
1180 __syscall_regval(a0, "rax", __NR_##name); \
1181 __syscall_regval(a1, "rdi", arg1); \
1182 __syscall_regval(a2, "rsi", arg2); \
1183 __syscall_regval(a3, "rdx", arg3); \
1184 __syscall_regval(a4, "r10", arg4); \
1185 __syscall_regval(a5, "r8", arg5); \
1187 __asm__ volatile ( \
1188 __check("%0%1%2%3%4%5%6", \
1189 "%%rax%%rax%%rdi%%rsi%%rdx%%r10%%r8") \
1190 "syscall" __comment(name) \
1193 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
1194 "r" (__sc_a4), "r"(__sc_a5) \
1195 : __syscall_clobbers \
1197 __sc_res = __sc_a0; \
1199 __syscall_return(type, __sc_res); \
1202 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1203 type4, arg4, type5, arg5, type6, arg6) \
1204 type name (type1 arg1, type2 arg2, type3 arg3, \
1205 type4 arg4, type5 arg5, type6 arg6) \
1209 __syscall_regval(a0, "rax", __NR_##name); \
1210 __syscall_regval(a1, "rdi", arg1); \
1211 __syscall_regval(a2, "rsi", arg2); \
1212 __syscall_regval(a3, "rdx", arg3); \
1213 __syscall_regval(a4, "r10", arg4); \
1214 __syscall_regval(a5, "r8", arg5); \
1215 __syscall_regval(a6, "r9", arg6); \
1217 __asm__ volatile ( \
1218 __check("%0%1%2%3%4%5%6%7", \
1219 "%%rax%%rax%%rdi%%rsi%%rdx%%r10%%r8%%r9") \
1220 "syscall" __comment(name) \
1223 "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3), \
1224 "r" (__sc_a4), "r"(__sc_a5), "r" (__sc_a6) \
1225 : __syscall_clobbers \
1227 __sc_res = __sc_a0; \
1229 __syscall_return(type, __sc_res); \