added vwait
[util-vserver.git] / util-vserver / lib / syscall-alternative.h
1
2 #ifndef __syscall_retval
3 #define __syscall_retval(v)     do { } while(0)
4 #endif
5
6 #ifndef __syscall_error
7 #define __syscall_error(e)      do { errno = (e); } while(0)
8 #endif
9
10 #define __check(pos, reg)                                               \
11         ".ifnc " pos ", " reg "\n\t"                                    \
12         ".err\n\t"                                                      \
13         ".endif\n\t"
14
15 #ifndef __stringify0
16 #define __stringify0(val)       #val
17 #endif
18
19 #ifndef __stringify
20 #define __stringify(val)        __stringify0(val)
21 #endif
22
23 #define __comment(name)                                                 \
24         "\t/* kernel sys_" #name "[" __stringify(__NR_##name) "] */"
25
26
27 /*      *****************************************
28         ALPHA   ALPHA   ALPHA   ALPHA           *
29         alpha kernel interface                  */
30         
31 #if     defined(__alpha__)
32
33 /*      The Alpha calling convention doesn't use the stack until 
34         after the first six arguments have been passed in registers.
35         
36         scnr:   v0($0)
37         args:   a0($16), a1($17), a2($18), a3($19), a4($20), a5($21)
38         sret:   v0($0)
39         serr:   a3($19) (!=0, err=sret)
40 */
41
42
43 #define __syscall_return(type, ret, err) do {                           \
44         __syscall_retval(ret);                                          \
45         if (err) {                                                      \
46                 int __err = (ret);                                      \
47                 __syscall_error(__err);                                 \
48                 ret = -1;                                               \
49         }                                                               \
50         return (type) ret;                                              \
51 } while (0)                             
52
53 #define __syscall_regdef(name, reg)                                     \
54         register long __sc_##name __asm__ (reg)
55
56 #define __syscall_regval(name, reg, val)                                \
57         register long __sc_##name __asm__ (reg) = (long)(val)
58         
59 #define __syscall_clobbers                                              \
60         "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",                 \
61         "$22", "$23", "$24", "$25", "$27", "$28", "memory"              \
62
63
64 #define _syscall0(type, name)                                           \
65 type name(void)                                                         \
66 {                                                                       \
67         long __sc_ret, __sc_err;                                        \
68         {                                                               \
69                 __syscall_regval(v0, "$0", __NR_##name);                \
70                 __syscall_regdef(a3, "$19");                            \
71                                                                         \
72                 __asm__ __volatile__ (                                  \
73                 __check("%0%1%2", "$0$19$0")                            \
74                         "callsys" __comment(name)                       \
75                       : "=r"(__sc_v0), "=r"(__sc_a3)                    \
76                       : "0"(__sc_v0)                                    \
77                       : "$16", "$17", "$18", "$20", "$21",              \
78                         __syscall_clobbers                              \
79                 );                                                      \
80                 __sc_ret = __sc_v0;                                     \
81                 __sc_err = __sc_a3;                                     \
82         }                                                               \
83         __syscall_return(type, __sc_ret, __sc_err);                     \
84 }
85
86 #define _syscall1(type, name, type1, arg1)                              \
87 type name(type1 arg1)                                                   \
88 {                                                                       \
89         long __sc_ret, __sc_err;                                        \
90         {                                                               \
91                 __syscall_regval(v0, "$0", __NR_##name);                \
92                 __syscall_regval(a0, "$16", arg1);                      \
93                 __syscall_regdef(a3, "$19");                            \
94                                                                         \
95                 __asm__ __volatile__ (                                  \
96                 __check("%0%1%2%3", "$0$19$0$16")                       \
97                         "callsys" __comment(name)                       \
98                       : "=r"(__sc_v0), "=r"(__sc_a3)                    \
99                       : "0"(__sc_v0),                                   \
100                         "r"(__sc_a0)                                    \
101                       : "$17", "$18", "$20", "$21",                     \
102                         __syscall_clobbers                              \
103                 );                                                      \
104                 __sc_ret = __sc_v0;                                     \
105                 __sc_err = __sc_a3;                                     \
106         }                                                               \
107         __syscall_return(type, __sc_ret, __sc_err);                     \
108 }
109
110 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
111 type name(type1 arg1, type2 arg2)                                       \
112 {                                                                       \
113         long __sc_ret, __sc_err;                                        \
114         {                                                               \
115                 __syscall_regval(v0, "$0", __NR_##name);                \
116                 __syscall_regval(a0, "$16", arg1);                      \
117                 __syscall_regval(a1, "$17", arg2);                      \
118                 __syscall_regdef(a3, "$19");                            \
119                                                                         \
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)                    \
124                       : "0"(__sc_v0),                                   \
125                         "r"(__sc_a0), "r"(__sc_a1)                      \
126                       : "$18", "$20", "$21",                            \
127                         __syscall_clobbers                              \
128                 );                                                      \
129                 __sc_ret = __sc_v0;                                     \
130                 __sc_err = __sc_a3;                                     \
131         }                                                               \
132         __syscall_return(type, __sc_ret, __sc_err);                     \
133 }
134
135 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
136 type name(type1 arg1, type2 arg2, type3 arg3)                           \
137 {                                                                       \
138         long __sc_ret, __sc_err;                                        \
139         {                                                               \
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");                            \
145                                                                         \
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)                    \
150                       : "0"(__sc_v0),                                   \
151                         "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2)        \
152                       : "$20", "$21",                                   \
153                         __syscall_clobbers                              \
154                 );                                                      \
155                 __sc_ret = __sc_v0;                                     \
156                 __sc_err = __sc_a3;                                     \
157         }                                                               \
158         __syscall_return(type, __sc_ret, __sc_err);                     \
159 }
160
161 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
162                               type4, arg4)                              \
163 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)              \
164 {                                                                       \
165         long __sc_ret, __sc_err;                                        \
166         {                                                               \
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);                      \
172                                                                         \
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)                    \
177                       : "0"(__sc_v0),                                   \
178                         "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2),       \
179                         "1"(__sc_a3)                                    \
180                       : "$20", "$21",                                   \
181                         __syscall_clobbers                              \
182                 );                                                      \
183                 __sc_ret = __sc_v0;                                     \
184                 __sc_err = __sc_a3;                                     \
185         }                                                               \
186         __syscall_return(type, __sc_ret, __sc_err);                     \
187
188
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)  \
192 {                                                                       \
193         long __sc_ret, __sc_err;                                        \
194         {                                                               \
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);                      \
201                                                                         \
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)                    \
206                       : "0"(__sc_v0),                                   \
207                         "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2),       \
208                         "1"(__sc_a3), "r"(__sc_a4)                      \
209                       : "$21",                                          \
210                         __syscall_clobbers                              \
211                 );                                                      \
212                 __sc_ret = __sc_v0;                                     \
213                 __sc_err = __sc_a3;                                     \
214         }                                                               \
215         __syscall_return(type, __sc_ret, __sc_err);                     \
216 }
217
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)                          \
222 {                                                                       \
223         long __sc_ret, __sc_err;                                        \
224         {                                                               \
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);                      \
232                                                                         \
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)                    \
238                       : "0"(__sc_v0),                                   \
239                         "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2),       \
240                         "1"(__sc_a3), "r"(__sc_a4), "r"(__sc_a5)        \
241                       : __syscall_clobbers                              \
242                 );                                                      \
243                 __sc_ret = __sc_v0;                                     \
244                 __sc_err = __sc_a3;                                     \
245         }                                                               \
246         __syscall_return(type, __sc_ret, __sc_err);                     \
247 }
248
249
250
251 /*      *****************************************
252         ARM     ARM     ARM     ARM             *
253         arm kernel interface                    */
254
255 #elif   defined(__arm__)
256
257 /*      The Arm calling convention uses stack args after four arguments
258         but the Linux kernel gets up to seven arguments in registers.
259         
260         scnr:   imm
261         args:   a1(r0), a2(r1), a3(r2), a4(r3), v1(r4), v2(r5), 
262         sret:   a1(r0)
263         serr:   (err= sret > (unsigned)-EMAXERRNO)
264 */
265
266 #ifndef EMAXERRNO
267 #define EMAXERRNO   125
268 #endif
269
270 #define __syscall_errcon(res)                                           \
271         ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
272
273 #define __syscall_return(type, res) do {                                \
274         __syscall_retval(res);                                          \
275         if (__syscall_errcon(res)) {                                    \
276                 int __err = -(res);                                     \
277                 __syscall_error(__err);                                 \
278                 res = -1;                                               \
279         }                                                               \
280         return (type) res;                                              \
281 } while (0)                             
282
283 #define __syscall_regdef(name, reg)                                     \
284         register int __sc_##name __asm__ (reg)
285
286 #define __syscall_regval(name, reg, val)                                \
287         register int __sc_##name __asm__ (reg) = (int)(val)
288
289
290 #define _syscall0(type, name)                                           \
291 type name(void)                                                         \
292 {                                                                       \
293         long __sc_res;                                                  \
294         {                                                               \
295                 __syscall_regdef(a1, "r0");                             \
296                                                                         \
297                 __asm__ __volatile__ (                                  \
298                 __check("%0", "r0")                                     \
299                         "swi %1" __comment(name)                        \
300                       : "=r"(__sc_a1)                                   \
301                       : "i"(__NR_##name)                                \
302                       : "memory"                                        \
303                 );                                                      \
304                 __sc_res = __sc_a1;                                     \
305         }                                                               \
306         __syscall_return(type, __sc_res);                               \
307 }
308
309 #define _syscall1(type, name, type1, arg1)                              \
310 type name(type1 arg1)                                                   \
311 {                                                                       \
312         long __sc_res;                                                  \
313         {                                                               \
314                 __syscall_regval(a1, "r0", arg1);                       \
315                                                                         \
316                 __asm__ __volatile__ (                                  \
317                 __check("%0%2", "r0r0")                                 \
318                         "swi %1" __comment(name)                        \
319                       : "=r"(__sc_a1)                                   \
320                       : "i"(__NR_##name),                               \
321                         "0"(__sc_a1)                                    \
322                       : "memory"                                        \
323                 );                                                      \
324                 __sc_res = __sc_a1;                                     \
325         }                                                               \
326         __syscall_return(type, __sc_res);                               \
327 }
328
329 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
330 type name(type1 arg1, type2 arg2)                                       \
331 {                                                                       \
332         long __sc_res;                                                  \
333         {                                                               \
334                 __syscall_regval(a1, "r0", arg1);                       \
335                 __syscall_regval(a2, "r1", arg2);                       \
336                                                                         \
337                 __asm__ __volatile__ (                                  \
338                 __check("%0%2%3", "r0r0r1")                             \
339                         "swi %1" __comment(name)                        \
340                       : "=r"(__sc_a1)                                   \
341                       : "i"(__NR_##name),                               \
342                         "0"(__sc_a1), "r"(__sc_a2)                      \
343                       : "memory"                                        \
344                 );                                                      \
345                 __sc_res = __sc_a1;                                     \
346         }                                                               \
347         __syscall_return(type, __sc_res);                               \
348 }
349
350 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
351 type name(type1 arg1, type2 arg2, type3 arg3)                           \
352 {                                                                       \
353         long __sc_res;                                                  \
354         {                                                               \
355                 __syscall_regval(a1, "r0", arg1);                       \
356                 __syscall_regval(a2, "r1", arg2);                       \
357                 __syscall_regval(a3, "r2", arg3);                       \
358                                                                         \
359                 __asm__ __volatile__ (                                  \
360                 __check("%0%2%3%4", "r0r0r1r2")                         \
361                         "swi %1" __comment(name)                        \
362                       : "=r"(__sc_a1)                                   \
363                       : "i"(__NR_##name),                               \
364                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3)        \
365                       : "memory"                                        \
366                 );                                                      \
367                 __sc_res = __sc_a1;                                     \
368         }                                                               \
369         __syscall_return(type, __sc_res);                               \
370 }
371
372 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
373                               type4, arg4)                              \
374 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)              \
375 {                                                                       \
376         long __sc_res;                                                  \
377         {                                                               \
378                 __syscall_regval(a1, "r0", arg1);                       \
379                 __syscall_regval(a2, "r1", arg2);                       \
380                 __syscall_regval(a3, "r2", arg3);                       \
381                 __syscall_regval(a4, "r3", arg4);                       \
382                                                                         \
383                 __asm__ __volatile__ (                                  \
384                 __check("%0%2%3%4%5", "r0r0r1r2r3")                     \
385                         "swi %1" __comment(name)                        \
386                       : "=r"(__sc_a1)                                   \
387                       : "i"(__NR_##name),                               \
388                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
389                         "r"(__sc_a4)                                    \
390                       : "memory"                                        \
391                 );                                                      \
392                 __sc_res = __sc_a1;                                     \
393         }                                                               \
394         __syscall_return(type, __sc_res);                               \
395
396
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)  \
400 {                                                                       \
401         long __sc_res;                                                  \
402         {                                                               \
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);                       \
408                                                                         \
409                 __asm__ __volatile__ (                                  \
410                 __check("%0%2%3%4%5%6", "r0r0r1r2r3r4")                 \
411                         "swi %1" __comment(name)                        \
412                       : "=r"(__sc_a1)                                   \
413                       : "i"(__NR_##name),                               \
414                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
415                         "r"(__sc_a4), "r"(__sc_v1)                      \
416                       : "memory"                                        \
417                 );                                                      \
418                 __sc_res = __sc_a1;                                     \
419         }                                                               \
420         __syscall_return(type, __sc_res);                               \
421 }
422
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)                          \
427 {                                                                       \
428         long __sc_res;                                                  \
429         {                                                               \
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);                       \
436                                                                         \
437                 __asm__ __volatile__ (                                  \
438                 __check("%0%2%3%4%5%6%7", "r0r0r1r2r3r4r5")             \
439                         "swi %1" __comment(name)                        \
440                       : "=r"(__sc_a1)                                   \
441                       : "i"(__NR_##name),                               \
442                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
443                         "r"(__sc_a4), "r"(__sc_v1), "r"(__sc_v2)        \
444                       : "memory"                                        \
445                 );                                                      \
446                 __sc_res = __sc_a1;                                     \
447         }                                                               \
448         __syscall_return(type, __sc_res);                               \
449 }
450
451
452 /*      *****************************************
453         CRIS    CRIS    CRIS    CRIS            *
454         cris v10 kernel interface               */
455
456 #elif   defined(__cris__)
457
458 /*      The Cris calling convention uses stack args after four arguments
459         but the Linux kernel gets up to six arguments in registers.
460         
461         scnr:   (r9)
462         args:   (r10), (r11), (r12), (r13), (mof), (srp), 
463         sret:   (r10)
464         serr:   (err= sret > (unsigned)-EMAXERRNO)
465 */
466
467 #ifndef EMAXERRNO
468 #define EMAXERRNO   125
469 #endif
470
471 #define __syscall_errcon(res)                                           \
472         ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
473
474 #define __syscall_return(type, res) do {                                \
475         __syscall_retval(res);                                          \
476         if (__syscall_errcon(res)) {                                    \
477                 int __err = -(res);                                     \
478                 __syscall_error(__err);                                 \
479                 res = -1;                                               \
480         }                                                               \
481         return (type) res;                                              \
482 } while (0)                             
483
484 #define __syscall_regdef(name, reg)                                     \
485         register long __sc_##name __asm__ (reg)
486
487 #define __syscall_regval(name, reg, val)                                \
488         register long __sc_##name __asm__ (reg) = (long)(val)
489
490 #define _syscall0(type, name)                                           \
491 type name(void)                                                         \
492 {                                                                       \
493         long __sc_res;                                                  \
494         {                                                               \
495                 __syscall_regval(a0, "r9", __NR_##name);                \
496                 __syscall_regdef(a1, "r10");                            \
497                                                                         \
498                 __asm__ __volatile__ (                                  \
499                 __check("%0%1", "$r10$r9")                              \
500                         "break 13" __comment(name)                      \
501                       : "=r"(__sc_a1)                                   \
502                       : "r"(__sc_a0)                                    \
503                       : "memory", "srp", "r13", "r12", "r11"            \
504                 );                                                      \
505                 __sc_res = __sc_a1;                                     \
506         }                                                               \
507         __syscall_return(type, __sc_res);                               \
508 }
509
510 #define _syscall1(type, name, type1, arg1)                              \
511 type name(type1 arg1)                                                   \
512 {                                                                       \
513         long __sc_res;                                                  \
514         {                                                               \
515                 __syscall_regval(a0, "r9", __NR_##name);                \
516                 __syscall_regval(a1, "r10", arg1);                      \
517                                                                         \
518                 __asm__ __volatile__ (                                  \
519                 __check("%0%1%2", "$r10$r9$r10")                        \
520                         "break 13" __comment(name)                      \
521                       : "=r"(__sc_a1)                                   \
522                       : "r"(__sc_a0),                                   \
523                         "0"(__sc_a1)                                    \
524                       : "memory", "srp", "r13", "r12", "r11"            \
525                 );                                                      \
526                 __sc_res = __sc_a1;                                     \
527         }                                                               \
528         __syscall_return(type, __sc_res);                               \
529 }
530
531 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
532 type name(type1 arg1, type2 arg2)                                       \
533 {                                                                       \
534         long __sc_res;                                                  \
535         {                                                               \
536                 __syscall_regval(a0, "r9", __NR_##name);                \
537                 __syscall_regval(a1, "r10", arg1);                      \
538                 __syscall_regval(a2, "r11", arg2);                      \
539                                                                         \
540                 __asm__ __volatile__ (                                  \
541                 __check("%0%1%2%3", "$r10$r9$r10$r11")                  \
542                         "break 13" __comment(name)                      \
543                       : "=r"(__sc_a1)                                   \
544                       : "r"(__sc_a0),                                   \
545                         "0"(__sc_a1), "r"(__sc_a2)                      \
546                       : "memory", "srp", "r13", "r12"                   \
547                 );                                                      \
548                 __sc_res = __sc_a1;                                     \
549         }                                                               \
550         __syscall_return(type, __sc_res);                               \
551 }
552
553 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
554 type name(type1 arg1, type2 arg2, type3 arg3)                           \
555 {                                                                       \
556         long __sc_res;                                                  \
557         {                                                               \
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);                      \
562                                                                         \
563                 __asm__ __volatile__ (                                  \
564                 __check("%0%1%2%3%4", "$r10$r9$r10$r11$r12")            \
565                         "break 13" __comment(name)                      \
566                       : "=r"(__sc_a1)                                   \
567                       : "r"(__sc_a0),                                   \
568                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3)        \
569                       : "memory", "srp", "r13"                          \
570                 );                                                      \
571                 __sc_res = __sc_a1;                                     \
572         }                                                               \
573         __syscall_return(type, __sc_res);                               \
574 }
575
576 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
577                               type4, arg4)                              \
578 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)              \
579 {                                                                       \
580         long __sc_res;                                                  \
581         {                                                               \
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);                      \
587                                                                         \
588                 __asm__ __volatile__ (                                  \
589                 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13")      \
590                         "break 13" __comment(name)                      \
591                       : "=r"(__sc_a1)                                   \
592                       : "r"(__sc_a0),                                   \
593                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
594                         "r"(__sc_a4)                                    \
595                       : "memory", "srp"                                 \
596                 );                                                      \
597                 __sc_res = __sc_a1;                                     \
598         }                                                               \
599         __syscall_return(type, __sc_res);                               \
600
601
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)  \
605 {                                                                       \
606         long __sc_res;                                                  \
607         {                                                               \
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);                      \
613                                                                         \
614                 __asm__ __volatile__ (                                  \
615                 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13")      \
616                         "move %6,$mof\n\t"                              \
617                         "break 13" __comment(name)                      \
618                       : "=r"(__sc_a1)                                   \
619                       : "r"(__sc_a0),                                   \
620                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
621                         "r"(__sc_a4),                                   \
622                         "g"((long)arg5)                                 \
623                       : "memory", "srp"                                 \
624                 );                                                      \
625                 __sc_res = __sc_a1;                                     \
626         }                                                               \
627         __syscall_return(type, __sc_res);                               \
628 }
629
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)                          \
634 {                                                                       \
635         long __sc_res;                                                  \
636         {                                                               \
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);                      \
642                                                                         \
643                 __asm__ __volatile__ (                                  \
644                 __check("%0%1%2%3%4%5", "$r10$r9$r10$r11$r12$r13")      \
645                         "move %6,$mof\n\t"                              \
646                         "move %7,$srp\n\t"                              \
647                         "break 13" __comment(name)                      \
648                       : "=r"(__sc_a1)                                   \
649                       : "r"(__sc_a0),                                   \
650                         "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3),       \
651                         "r"(__sc_a4),                                   \
652                         "g"((long)arg5), "g"((long)arg6)                \
653                       : "memory"                                        \
654                 );                                                      \
655                 __sc_res = __sc_a1;                                     \
656         }                                                               \
657         __syscall_return(type, __sc_res);                               \
658 }
659
660
661 /*      *****************************************
662         FRV     FRV     FRV     FRV             *
663         frv kernel interface            */
664
665 #elif   defined(__frv__)
666
667 #warning syscall arch frv not implemented yet
668
669
670 /*      *****************************************
671         H8300   H8300   H8300   H8300           *
672         h8/300 kernel interface                 */
673
674 #elif   defined(__h8300__)
675
676 #warning syscall arch h8300 not implemented yet
677
678
679 /*      *****************************************
680         I386    I386    I386    I386            *
681         i386 kernel interface                   */
682
683 #elif   defined(__i386__)
684
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.
688         
689         scnr:   a0(eax)
690         args:   a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp) 
691         sret:   a0(eax)
692         serr:   (err= sret > (unsigned)-EMAXERRNO)
693 */
694
695 #ifndef EMAXERRNO
696 #define EMAXERRNO   129
697 #endif
698
699 #define __syscall_errcon(res)                                           \
700         ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
701
702 #define __syscall_return(type, res) do {                                \
703         __syscall_retval(res);                                          \
704         if (__syscall_errcon(res)) {                                    \
705                 int __err = -(res);                                     \
706                 __syscall_error(__err);                                 \
707                 res = -1;                                               \
708         }                                                               \
709         return (type) res;                                              \
710 } while (0)                             
711
712 #define __syscall_regdef(name, reg)                                     \
713         register long __sc_##name __asm__ (reg)
714
715 #define __syscall_regval(name, reg, val)                                \
716         register long __sc_##name __asm__ (reg) = (long)(val)
717
718
719 #define _syscall0(type, name)                                           \
720 type name(void)                                                         \
721 {                                                                       \
722         long __sc_res;                                                  \
723         {                                                               \
724                 __syscall_regval(a0, "eax", __NR_##name);               \
725                                                                         \
726                 __asm__ volatile (                                      \
727                 __check("%0%1", "%%eax%%eax")                           \
728                         "int $0x80" __comment(name)                     \
729                       : "=a"(__sc_a0)                                   \
730                       : "0"(__sc_a0)                                    \
731                       : "memory"                                        \
732                 );                                                      \
733                 __sc_res = __sc_a0;                                     \
734         }                                                               \
735         __syscall_return(type, __sc_res);                               \
736 }
737
738 #define _syscall1(type, name, type1, arg1)                              \
739 type name(type1 arg1)                                                   \
740 {                                                                       \
741         long __sc_res;                                                  \
742         {                                                               \
743                 __syscall_regval(a0, "eax", __NR_##name);               \
744                 __syscall_regval(a1, "ebx", arg1);                      \
745                                                                         \
746                 __asm__ volatile (                                      \
747                 __check("%0%1%2", "%%eax%%eax%%ebx")                    \
748                         "int $0x80" __comment(name)                     \
749                       : "=a"(__sc_a0)                                   \
750                       : "0"(__sc_a0),                                   \
751                         "r" (__sc_a1)                                   \
752                       : "memory"                                        \
753                 );                                                      \
754                 __sc_res = __sc_a0;                                     \
755         }                                                               \
756         __syscall_return(type, __sc_res);                               \
757 }
758
759 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
760 type name(type1 arg1, type2 arg2)                                       \
761 {                                                                       \
762         long __sc_res;                                                  \
763         {                                                               \
764                 __syscall_regval(a0, "eax", __NR_##name);               \
765                 __syscall_regval(a1, "ebx", arg1);                      \
766                 __syscall_regval(a2, "ecx", arg2);                      \
767                                                                         \
768                 __asm__ volatile (                                      \
769                 __check("%0%1%2%3", "%%eax%%eax%%ebx%%ecx")             \
770                         "int $0x80" __comment(name)                     \
771                       : "=a"(__sc_a0)                                   \
772                       : "0"(__sc_a0),                                   \
773                         "r" (__sc_a1), "r"(__sc_a2)                     \
774                       : "memory"                                        \
775                 );                                                      \
776                 __sc_res = __sc_a0;                                     \
777         }                                                               \
778         __syscall_return(type, __sc_res);                               \
779 }
780
781 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
782 type name(type1 arg1, type2 arg2, type3 arg3)                           \
783 {                                                                       \
784         long __sc_res;                                                  \
785         {                                                               \
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);                      \
790                                                                         \
791                 __asm__ volatile (                                      \
792                 __check("%0%1%2%3%4", "%%eax%%eax%%ebx%%ecx%%edx")      \
793                         "int $0x80" __comment(name)                     \
794                       : "=a"(__sc_a0)                                   \
795                       : "0"(__sc_a0),                                   \
796                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3)      \
797                       : "memory"                                        \
798                 );                                                      \
799                 __sc_res = __sc_a0;                                     \
800         }                                                               \
801         __syscall_return(type, __sc_res);                               \
802
803
804
805 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
806                               type4, arg4)                              \
807 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)              \
808 {                                                                       \
809         long __sc_res;                                                  \
810         {                                                               \
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);                      \
816                                                                         \
817                 __asm__ volatile (                                      \
818                 __check("%0%1%2%3%4%5",                                 \
819                         "%%eax%%eax%%ebx%%ecx%%edx%%esi")               \
820                         "int $0x80" __comment(name)                     \
821                       : "=a"(__sc_a0)                                   \
822                       : "0"(__sc_a0),                                   \
823                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
824                         "r" (__sc_a4)                                   \
825                       : "memory"                                        \
826                 );                                                      \
827                 __sc_res = __sc_a0;                                     \
828         }                                                               \
829         __syscall_return(type, __sc_res);                               \
830
831
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)  \
835 {                                                                       \
836         long __sc_res;                                                  \
837         {                                                               \
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);                      \
844                                                                         \
845                 __asm__ volatile (                                      \
846                 __check("%0%1%2%3%4%5%6",                               \
847                         "%%eax%%eax%%ebx%%ecx%%edx%%esi%%edi")          \
848                         "int $0x80" __comment(name)                     \
849                       : "=a"(__sc_a0)                                   \
850                       : "0"(__sc_a0),                                   \
851                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
852                         "r" (__sc_a4), "r"(__sc_a5)                     \
853                       : "memory"                                        \
854                 );                                                      \
855                 __sc_res = __sc_a0;                                     \
856         }                                                               \
857         __syscall_return(type, __sc_res);                               \
858 }
859
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)                          \
864 {                                                                       \
865         long __sc_res;                                                  \
866         {                                                               \
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);                      \
874                                                                         \
875                 __asm__ volatile (                                      \
876                 __check("%0%1%2%3%4%5%6%7",                             \
877                         "%%eax%%eax%%ebx%%ecx%%edx%%esi%%edi%%ebp")     \
878                         "int $0x80" __comment(name)                     \
879                       : "=a"(__sc_a0)                                   \
880                       : "0"(__sc_a0),                                   \
881                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
882                         "r" (__sc_a4), "r"(__sc_a5), "r" (__sc_a6)      \
883                       : "memory"                                        \
884                 );                                                      \
885                 __sc_res = __sc_a0;                                     \
886         }                                                               \
887         __syscall_return(type, __sc_res);                               \
888 }
889
890
891 /*      *****************************************
892         IA64    IA64    IA64    IA64            *
893         ia64 kernel interface                   */
894
895 #elif   defined(__ia64__)
896
897 #warning syscall arch ia64 not implemented yet
898
899
900 /*      *****************************************
901         M32R    IM32R   M32R    M32R            *
902         m32r kernel interface                   */
903
904 #elif   defined(__m32r__)
905
906 #warning syscall arch m32r not implemented yet
907
908
909 /*      *****************************************
910         M68K    M68K    M68K    M68K            *
911         m68k kernel interface                   */
912
913 #elif   defined(__mc68000__)
914
915 #warning syscall arch m68k not implemented yet
916
917
918 /*      *****************************************
919         MIPS    MIPS    MIPS    MIPS            *
920         mips kernel interface                   */
921
922 #elif   defined(__mips__)
923
924 #warning syscall arch mips not implemented yet
925
926
927 /*      *****************************************
928         HPPA    HPPA    HPPA    HPPA            *
929         hppa kernel interface                   */
930
931 #elif   defined(__hppa__)
932
933 #warning syscall arch hppa not implemented yet
934
935
936 /*      *****************************************
937         PPC64   PPC64   PPC64   PPC64           *
938         ppc64 kernel interface                  */
939
940 #elif   defined(__powerpc64__)
941
942 #warning syscall arch ppc64 not implemented yet
943
944
945 /*      *****************************************
946         PPC     PPC     PPC     PPC             *
947         ppc kernel interface                    */
948
949 #elif   defined(__powerpc__)
950
951 #warning syscall arch ppc not implemented yet
952
953
954 /*      *****************************************
955         S390X   S390X   S390X   S390X           *
956         s390x kernel interface                  */
957
958 #elif   defined(__s390x__)
959
960 #warning syscall arch s390x not implemented yet
961
962
963 /*      *****************************************
964         S390    S390    S390    S390            *
965         s390 kernel interface                   */
966
967 #elif   defined(__s390__)
968
969 #warning syscall arch s390 not implemented yet
970
971
972 /*      *****************************************
973         SH      SH      SH      SH              *
974         sh kernel interface                     */
975
976 #elif   defined(__sh__) && !defined(__SH5__)
977
978 #warning syscall arch sh not implemented yet
979
980
981 /*      *****************************************
982         SH64    SH64    SH64    SH64            *
983         sh64 kernel interface                   */
984
985 #elif   defined(__sh__) && defined(__SH5__)
986
987 #warning syscall arch sh64 not implemented yet
988
989
990 /*      *****************************************
991         SPARC64 SPARC64 SPARC64 SPARC64         *
992         sparc64 kernel interface                */
993
994 #elif   defined(__sparc__) && defined(__sparc_v9__)
995
996 #warning syscall arch sparc64 not implemented yet
997
998
999 /*      *****************************************
1000         SPARC   SPARC   SPARC   SPARC           *
1001         sparc kernel interface                  */
1002
1003 #elif   defined(__sparc__)
1004
1005 #warning syscall arch sparc not implemented yet
1006
1007
1008 /*      *****************************************
1009         V850    V850    V850    V850            *
1010         v850 kernel interface                   */
1011
1012 #elif   defined(__v850__)
1013
1014 #warning syscall arch v850 not implemented yet
1015
1016
1017 /*      *****************************************
1018         X86_64  X86_64  X86_64  X86_64          *
1019         x86_64 kernel interface                 */
1020
1021 #elif   defined(__x86_64__)
1022
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.
1025         
1026         scnr:   a0(rax)
1027         args:   a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9) 
1028         sret:   a0(rax)
1029         serr:   (err= sret > (unsigned)-EMAXERRNO)
1030         call:   syscall
1031         clob:   rcx, r11
1032 */
1033
1034 #ifndef EMAXERRNO
1035 #define EMAXERRNO   4095
1036 #endif
1037
1038 #define __syscall_errcon(res)                                           \
1039         ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
1040
1041 #define __syscall_return(type, res) do {                                \
1042         __syscall_retval(res);                                          \
1043         if (__syscall_errcon(res)) {                                    \
1044                 int __err = -(res);                                     \
1045                 __syscall_error(__err);                                 \
1046                 res = -1;                                               \
1047         }                                                               \
1048         return (type) res;                                              \
1049 } while (0)                             
1050
1051 #define __syscall_clobbers                                              \
1052         "cc", "r11", "rcx", "memory" 
1053
1054 #define __syscall_regdef(name, reg)                                     \
1055         register long __sc_##name __asm__ (reg)
1056
1057 #define __syscall_regval(name, reg, val)                                \
1058         register long __sc_##name __asm__ (reg) = (long)(val)
1059
1060
1061 #define _syscall0(type, name)                                           \
1062 type name(void)                                                         \
1063 {                                                                       \
1064         long __sc_res;                                                  \
1065         {                                                               \
1066                 __syscall_regval(a0, "rax", __NR_##name);               \
1067                                                                         \
1068                 __asm__ volatile (                                      \
1069                 __check("%0%1", "%%rax%%rax")                           \
1070                         "syscall" __comment(name)                       \
1071                       : "=a"(__sc_a0)                                   \
1072                       : "0"(__sc_a0)                                    \
1073                       : __syscall_clobbers                              \
1074                 );                                                      \
1075                 __sc_res = __sc_a0;                                     \
1076         }                                                               \
1077         __syscall_return(type, __sc_res);                               \
1078 }
1079
1080 #define _syscall1(type, name, type1, arg1)                              \
1081 type name(type1 arg1)                                                   \
1082 {                                                                       \
1083         long __sc_res;                                                  \
1084         {                                                               \
1085                 __syscall_regval(a0, "rax", __NR_##name);               \
1086                 __syscall_regval(a1, "rdi", arg1);                      \
1087                                                                         \
1088                 __asm__ volatile (                                      \
1089                 __check("%0%1%2", "%%rax%%rax%%rdi")                    \
1090                         "syscall" __comment(name)                       \
1091                       : "=a"(__sc_a0)                                   \
1092                       : "0"(__sc_a0),                                   \
1093                         "r" (__sc_a1)                                   \
1094                       : __syscall_clobbers                              \
1095                 );                                                      \
1096                 __sc_res = __sc_a0;                                     \
1097         }                                                               \
1098         __syscall_return(type, __sc_res);                               \
1099 }
1100
1101 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
1102 type name(type1 arg1, type2 arg2)                                       \
1103 {                                                                       \
1104         long __sc_res;                                                  \
1105         {                                                               \
1106                 __syscall_regval(a0, "rax", __NR_##name);               \
1107                 __syscall_regval(a1, "rdi", arg1);                      \
1108                 __syscall_regval(a2, "rsi", arg2);                      \
1109                                                                         \
1110                 __asm__ volatile (                                      \
1111                 __check("%0%1%2%3", "%%rax%%rax%%rdi%%rsi")             \
1112                         "syscall" __comment(name)                       \
1113                       : "=a"(__sc_a0)                                   \
1114                       : "0"(__sc_a0),                                   \
1115                         "r" (__sc_a1), "r"(__sc_a2)                     \
1116                       : __syscall_clobbers                              \
1117                 );                                                      \
1118                 __sc_res = __sc_a0;                                     \
1119         }                                                               \
1120         __syscall_return(type, __sc_res);                               \
1121 }
1122
1123 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
1124 type name(type1 arg1, type2 arg2, type3 arg3)                           \
1125 {                                                                       \
1126         long __sc_res;                                                  \
1127         {                                                               \
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);                      \
1132                                                                         \
1133                 __asm__ volatile (                                      \
1134                 __check("%0%1%2%3%4", "%%rax%%rax%%rdi%%rsi%%rdx")      \
1135                         "syscall" __comment(name)                       \
1136                       : "=a"(__sc_a0)                                   \
1137                       : "0"(__sc_a0),                                   \
1138                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3)      \
1139                       : __syscall_clobbers                              \
1140                 );                                                      \
1141                 __sc_res = __sc_a0;                                     \
1142         }                                                               \
1143         __syscall_return(type, __sc_res);                               \
1144
1145
1146
1147 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
1148                               type4, arg4)                              \
1149 type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4)              \
1150 {                                                                       \
1151         long __sc_res;                                                  \
1152         {                                                               \
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);                      \
1158                                                                         \
1159                 __asm__ volatile (                                      \
1160                 __check("%0%1%2%3%4%5",                                 \
1161                         "%%rax%%rax%%rdi%%rsi%%rdx%%r10")               \
1162                         "syscall" __comment(name)                       \
1163                       : "=a"(__sc_a0)                                   \
1164                       : "0"(__sc_a0),                                   \
1165                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
1166                         "r" (__sc_a4)                                   \
1167                       : __syscall_clobbers                              \
1168                 );                                                      \
1169                 __sc_res = __sc_a0;                                     \
1170         }                                                               \
1171         __syscall_return(type, __sc_res);                               \
1172
1173
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)  \
1177 {                                                                       \
1178         long __sc_res;                                                  \
1179         {                                                               \
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);                       \
1186                                                                         \
1187                 __asm__ volatile (                                      \
1188                 __check("%0%1%2%3%4%5%6",                               \
1189                         "%%rax%%rax%%rdi%%rsi%%rdx%%r10%%r8")           \
1190                         "syscall" __comment(name)                       \
1191                       : "=a"(__sc_a0)                                   \
1192                       : "0"(__sc_a0),                                   \
1193                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
1194                         "r" (__sc_a4), "r"(__sc_a5)                     \
1195                       : __syscall_clobbers                              \
1196                 );                                                      \
1197                 __sc_res = __sc_a0;                                     \
1198         }                                                               \
1199         __syscall_return(type, __sc_res);                               \
1200 }
1201
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)                          \
1206 {                                                                       \
1207         long __sc_res;                                                  \
1208         {                                                               \
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);                       \
1216                                                                         \
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)                       \
1221                       : "=a"(__sc_a0)                                   \
1222                       : "0"(__sc_a0),                                   \
1223                         "r" (__sc_a1), "r"(__sc_a2), "r" (__sc_a3),     \
1224                         "r" (__sc_a4), "r"(__sc_a5), "r" (__sc_a6)      \
1225                       : __syscall_clobbers                              \
1226                 );                                                      \
1227                 __sc_res = __sc_a0;                                     \
1228         }                                                               \
1229         __syscall_return(type, __sc_res);                               \
1230 }
1231
1232
1233 #endif
1234