skip duplicate util-vserver dir
[util-vserver.git] / lib / syscall-alternative.h
1   // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny7.h
2
3 #ifndef __SYSCALL_NEW_H
4 #define __SYSCALL_NEW_H
5
6 /*      Copyright (C) 2005 Herbert Pƶtzl
7
8                 global config options
9
10         __sysc_setret   ... set return value (default none)
11         __sysc_seterr   ... set error value (default errno)
12
13
14                 arch specific config
15
16         __sysc_reg_cid  ... the callid (if define), immediate otherwise
17
18         __sysc_reg(n)   ... syscall argument registers
19
20         __sysc_reg_res  ... simple result register (either that or)
21         __sysc_reg_ret  ... complex result register (and)
22         __sysc_reg_err  ... complex error register
23
24         __sysc_cmd_pre  ... preparation command(s)      __sysc_pre(n)
25         __sysc_cmd_sys  ... the syscall                 __sysc_cmd(n)
26         __sysc_cmd_fin  ... syscall finalization        __sysc_fin(n)
27
28         __sysc_clobber  ... clobbered registers (default memory)
29         __sysc_max_err  ... maximum error number (for simple result)
30
31         __sysc_errc(r,e)        ... error condition (e cmplx)
32         __sysc_retv(t,r,e)      ... syscall return value (e cmplx)
33
34                 if gcc cannot be trusted
35
36         __sysc_load(r,a)        ... asm code for register load
37         __sysc_save(r,a)        ... asm code to save result(s)
38         __sysc_limm(r,i)        ... asm code to load immediate
39         __sysc_rcon(n)          ... syscall register constraint
40         __sysc_regs             ... list of input regs for clobber
41         __sysc_type             ... register type
42
43                 if all else fails
44
45         __sc_asmload(n,N,...)   ... asm code to prepare arguments
46         __sc_asmsysc(n,N)       ... asm code to execute syscall
47         __sc_asmsave(n,r,e)     ... asm code to store results
48
49 */
50
51
52
53
54 /*      *****************************************
55         ALPHA   ALPHA   ALPHA   ALPHA           *
56         alpha kernel interface                  */
57
58 #if     defined(__alpha__)
59
60 /*      The Alpha calling convention doesn't use the stack until
61         after the first six arguments have been passed in registers.
62
63         scnr:   v0($0)
64         args:   a1($16), a2($17), a3($18), a4($19), a5($20), a6($21)
65         sret:   r0($0)
66         serr:   e0($19) (!=0, err=sret)
67         call:   callsys
68         clob:   memory
69 */
70
71 #define __sysc_reg_cid  "$0"
72 #define __sysc_reg_ret  "$0"
73 #define __sysc_reg_err  "$19"
74 #define __sysc_cmd_sys  "callsys"
75
76 #define __sysc_reg(n)   __arg_##n\
77         ("$16", "$17", "$18", "$19", "$20", "$21")
78
79 #define __sysc_clobber  __sysc_regs,                                    \
80         "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",                 \
81         "$22", "$23", "$24", "$25", "$27", "$28", "memory"              \
82
83
84
85 /*      *****************************************
86         ARM     ARM     ARM     ARM             *
87         arm kernel interface                    */
88
89 #elif   defined(__arm__)
90
91 /*      The Arm calling convention uses stack args after four arguments
92         but the Linux kernel gets up to seven arguments in registers.
93         
94         scnr:   imm
95         args:   a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5),
96         sret:   r0(r0)
97         serr:   (sret >= (unsigned)-EMAXERRNO)
98         call:   swi
99         clob:   memory
100 */
101
102 #define __sysc_max_err  125
103 #define __sysc_reg_res  "r0"
104 #define __sysc_cmd_sys  "swi    %0"
105
106 #define __sysc_reg(n)   __arg_##n\
107         ("r0", "r1", "r2", "r3", "r4", "r5")
108
109 #define __sysc_clobber  __sysc_regs, "memory"
110
111 #warning syscall arch arm not tested yet
112
113
114
115 /*      *****************************************
116         CRIS    CRIS    CRIS    CRIS            *
117         cris v10 kernel interface               */
118
119 #elif   defined(__cris__)
120
121 /*      The Cris calling convention uses stack args after four arguments
122         but the Linux kernel gets up to six arguments in registers.
123
124         scnr:   id(r9)
125         args:   a1(r10), a2(r11), a3(r12), a4(r13), a5(mof), a6(srp),
126         sret:   r0(r10)
127         serr:   (sret >= (unsigned)-EMAXERRNO)
128         call:   break 13
129         clob:   memory
130 */
131
132 #define __sysc_max_err  125
133 #define __sysc_reg_cid  "r9"
134 #define __sysc_reg_res  "r0"
135 #define __sysc_cmd_sys  "break 13"
136
137 #define __sysc_regs     "r10", "r11", "r12", "r13"
138 #define __sysc_reg(n)   __arg_##n\
139         ("r10", "r11", "r12", "r13", "r0", "srp")
140
141 #define __sysc_pre(n)   __casm(n,5,0,"move r0,mof",)
142
143 #define __sysc_clobber  __sysc_regs, "memory"
144
145 #warning syscall arch cris not tested yet
146
147
148
149 /*      *****************************************
150         FRV     FRV     FRV     FRV             *
151         frv kernel interface            */
152
153 #elif   defined(__frv__)
154
155 /*      The C calling convention on FR-V uses the gr8-gr13 registers
156         for the first six arguments, the remainder is spilled onto the
157         stack. the linux kernel syscall interface does so too.
158         
159         scnr:   id(gr7)
160         args:   a1(gr8), a2(gr9), a3(gr10), a4(gr11), a5(gr12), a6(gr13)
161         sret:   r0(gr8)
162         serr:   (sret >= (unsigned)-EMAXERRNO)
163         call:   tra gr0,gr0
164         clob:   memory
165 */
166
167 #define __sysc_max_err  125
168 #define __sysc_reg_cid  "gr7"
169 #define __sysc_reg_res  "gr8"
170 #define __sysc_cmd_sys  "tira   gr0,#0"
171
172 #define __sysc_reg(n)   __arg_##n\
173         ("gr8", "gr9", "gr10", "gr11", "gr12", "gr13")
174
175 #define __sysc_clobber  __sysc_regs, "memory"
176
177 #warning syscall arch frv not tested yet
178
179
180
181 /*      *****************************************
182         H8300   H8300   H8300   H8300           *
183         h8/300 kernel interface                 */
184
185 #elif   defined(__H8300__)
186
187 /*      The H8/300 C calling convention passes the first three
188         arguments in registers. However the linux kernel calling
189         convention passes the first six arguments in registers
190         er1-er6
191
192         scnr:   id(er0)
193         args:   a1(er1), a2(er2), a3(er3), a4(er4), a5(er5), a6(er6)
194         sret:   r0(er0)
195         serr:   (sret >= (unsigned)-EMAXERRNO)
196         call:   trapa #0
197         clob:   memory
198 */
199
200 #define __sysc_max_err  125
201 #define __sysc_reg_res  "er0"
202
203 #define __sysc_reg(n)   __arg_##n\
204         ("er1", "er2", "er3", "er4", "er5", "er6")
205
206 #define __sysc_clobber  "memory"
207
208 #define __sc_asmload(n,N,...)   __sc_asm        (                       \
209         __casm(n,1,1,   "mov.l  %0,er1"         ,                       )\
210         __casm(n,2,1,   "mov.l  %1,er2"         ,                       )\
211         __casm(n,3,1,   "mov.l  %2,er3"         ,                       )\
212         __casm(n,4,1,   "mov.l  %3,er4"         ,                       )\
213         __casm(n,5,1,   "mov.l  %4,er5"         ,                       )\
214         __casm(n,6,1,   "mov.l  er6,@-sp"       ,                       )\
215         __casm(n,6,1,   "mov.l  %5,er6"         ,                       )\
216         ""::__sc_iregs(n,__VA_ARGS__):__sysc_regs)
217
218 #define __sysc_cmd_pre  "mov.l  %0,er0"
219 #define __sysc_cmd_sys  "trapa  #0"
220 #define __sysc_fin(n)   __casm(n,6,0,"mov.l     @sp+,er6",)
221
222 #warning syscall arch h8300 not tested yet
223
224
225
226 /*      *****************************************
227         HPPA    HPPA    HPPA    HPPA            *
228         hppa/64 kernel interface                */
229
230 #elif   defined(__hppa__)
231
232 /*      The hppa calling convention uses r26-r23 for the first 4
233         arguments, the rest is spilled onto the stack. However the
234         Linux kernel passes the first six arguments in the registers
235         r26-r21.
236
237         The system call number MUST ALWAYS be loaded in the delay
238         slot of the ble instruction, or restarting system calls
239         WILL NOT WORK.
240
241         scnr:   id(r20)
242         args:   a1(r26), a2(r25), a3(r24), a4(r23), a5(r22), a6(r21)
243         sret:   r0(r28)
244         serr:   (sret >= (unsigned)-EMAXERRNO)
245         call:   ble  0x100(%%sr2, %%r0)
246         clob:   r1, r2, r4, r20, r29, r31, memory
247 */
248
249 #define __sysc_max_err  4095
250 #define __sysc_reg_res  "r28"
251
252 #define __sysc_reg(n)   __arg_##n\
253         ("r26", "r25", "r24", "r23", "r22", "r21")
254
255 #define __sysc_cmd_sys  "ble 0x100(%%sr2,%%r0)"
256 #define __sysc_cmd_fin  "ldi %0,%%r20"
257
258 #define __sysc_clobber  __sysc_regs,                                    \
259         "r1", "r2", "r4", "r20", "r29", "r31", "memory"
260
261 #warning syscall arch hppa not tested yet
262
263
264
265 /*      *****************************************
266         I386    I386    I386    I386            *
267         i386 kernel interface                   */
268
269 #elif   defined(__i386__)
270
271 /*      The x86 calling convention uses stack args for all arguments,
272         but the Linux kernel passes the first six arguments in the
273         following registers: ebx, ecx, edx, esi, edi, ebp.
274         
275         scnr:   id(eax)
276         args:   a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp) 
277         sret:   r0(eax)
278         serr:   (sret >= (unsigned)-EMAXERRNO)
279         call:   int 0x80
280         clob:   memory
281 */
282
283 #define __sysc_max_err  129
284 #define __sysc_reg_res  "eax"
285 #define __sysc_cmd_sys  "int    $0x80"
286
287 #ifndef __PIC__
288 #define __sysc_regs     "ebx", "ecx", "edx", "esi", "edi"
289 #else
290 #define __sysc_regs     "ecx", "edx", "esi", "edi"
291 #endif
292
293 #define __sc_asmload(n,N,...)   __sc_asm        (                       \
294         __casm(n,6,1,   "movl   %5,%%eax"       ,                       )\
295         __casm(n,5,1,   "movl   %4,%%edi"       ,                       )\
296         __casm(n,4,1,   "movl   %3,%%esi"       ,                       )\
297         __casm(n,3,1,   "movl   %2,%%edx"       ,                       )\
298         __casm(n,2,1,   "movl   %1,%%ecx"       ,                       )\
299         __pasm(n,1,1,   "pushl  %%ebx"          ,                       )\
300         __casm(n,1,1,   "movl   %0,%%ebx"       ,                       )\
301         __casm(n,6,1,   "pushl  %%ebp"          ,                       )\
302         ""::__sc_iregs(n,__VA_ARGS__):__sysc_clobber)
303
304 #define __sysc_pre(n)                                                   \
305         __casm(n,6,1,   "movl   %%eax,%%ebp"    ,                       )\
306         __casm(n,0,1,   "movl   %0,%%eax"       ,                       )\
307
308 #define __sysc_fin(n)                                                   \
309         __casm(n,6,1,   "popl   %%ebp"          ,                       )\
310         __pasm(n,1,1,   "popl   %%ebx"          ,                       )\
311
312 #define __sysc_clobber  __sysc_regs, "eax", "memory"
313
314
315 /*      *****************************************
316         IA64    IA64    IA64    IA64            *
317         ia64 kernel interface                   */
318
319 #elif   defined(__ia64__)
320
321 /*      The ia64 calling convention uses out0-out7 to pass the first
322         eight arguments (mapped via register windows).
323
324         scnr:   id(r15)
325         args:   a1(out0), a2(out1), ... a5(out4), a6(out5)
326         sret:   r0(r8)
327         serr:   e0(r10)
328         call:   break 0x100000
329         clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
330 */
331
332
333 #define __sysc_reg_ret  "r8"
334 #define __sysc_reg_err  "r10"
335 #define __sysc_reg_cid  "r15"
336 #define __sysc_cmd_sys  "break.i        0x100000"
337
338 #define __sysc_errc(r,e)        ((e) == -1)
339
340 #define __sysc_reg(n)   __arg_##n\
341         ("out0", "out1", "out2", "out3", "out4", "out5")
342
343 #define __sysc_clobber  __sysc_regs,                                    \
344         "out6", "out7", "r2", "r3", "r9", "r11", "r12", "r13",          \
345         "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22",         \
346         "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30",         \
347         "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13",      \
348         "p14", "p15", "f6", "f7", "f8", "f9", "f10", "f11", "f12",      \
349         "f13", "f14", "f15", "f16", "b6", "b7", "cc", "memory"
350
351 #warning syscall arch ia64 not tested yet
352
353
354
355 /*      *****************************************
356         M32R    M32R    M32R    M32R            *
357         m32r kernel interface                   */
358
359 #elif   defined(__M32R__)
360
361 /*      The m32r calling convention uses r0-r7 to pass the first
362         eight arguments (mapped via register windows).
363
364         scnr:   id(r0)
365         args:   a1(r1), a2(r2), a3(r3), a4(r4), a5(r5), a6(r6)
366         sret:   r0(r0)
367         serr:   (sret >= (unsigned)-EMAXERRNO)
368         call:   trap #2
369         clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
370 */
371
372 #define __sysc_max_err  125
373 #define __sysc_reg_cid  "r7"
374 #define __sysc_reg_res  "r0"
375 #define __sysc_cmd_sys  "trap #2"
376
377 #define __sysc_reg(n)   __arg_##n\
378         ("r0", "r1", "r2", "r3", "r4", "r5")
379
380 #define __sysc_clobber  __sysc_regs, "memory"
381
382 #warning syscall arch m32r not tested yet
383
384
385
386 /*      *****************************************
387         M68K    M68K    M68K    M68K            *
388         m68k kernel interface                   */
389
390 #elif   defined(__m68000__)
391
392 #error syscall arch m68k not implemented yet
393
394
395
396 /*      *****************************************
397         MIPS    MIPS    MIPS    MIPS            *
398         mips kernel interface                   */
399
400 #elif   defined(__mips__)
401
402 #error syscall arch mips not implemented yet
403
404
405
406 /*      *****************************************
407         PPC     PPC     PPC     PPC             *
408         ppc/64 kernel interface                 */
409
410 #elif   defined(__powerpc__)
411
412 /*      The powerpc calling convention uses r3-r10 to pass the first
413         eight arguments, the remainder is spilled onto the stack.
414         
415         scnr:   id(r0)
416         args:   a1(r3), a2(r4), a3(r5), a4(r6), a5(r7), a6(r8)
417         sret:   r0(r3)
418         serr:   (carry)
419         call:   sc
420         clob:   cr0, ctr
421 */
422
423
424 #define __sysc_reg_cid  "r0"
425 #define __sysc_reg_ret  "r3"
426 #define __sysc_reg_err  "r0"
427
428 #define __sysc_errc(r,e)        ((e) & 0x10000000)
429
430 #define __sysc_reg(n)   __arg_##n\
431         ("r3", "r4", "r5", "r6", "r7", "r8")
432
433 #define __sysc_cmd_sys  "sc"
434 #define __sysc_cmd_fin  "mfcr 0"
435
436 #define __sysc_clobber  __sysc_regs,                                    \
437         "r9", "r10", "r11", "r12", "cr0", "ctr", "memory"
438
439
440
441 /*      *****************************************
442         S390    S390    S390    S390            *
443         s390/x kernel interface                 */
444
445 #elif   defined(__s390__)
446
447 /*      The s390x calling convention passes the first five arguments
448         in r2-r6, the remainder is spilled onto the stack. However
449         the Linux kernel passes the first six arguments in r2-r7.
450         
451         scnr:   imm, id(r1)
452         args:   a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
453         sret:   r0(r2)
454         serr:   (sret >= (unsigned)-EMAXERRNO)
455         call:   svc
456         clob:   memory
457 */
458
459 #define __sysc_max_err  4095
460 #define __sysc_reg_cid  "r1"
461 #define __sysc_reg_res  "r2"
462 #define __sysc_cmd_sys  "svc    0"
463
464 #define __sysc_regtyp   unsigned long
465
466 #define __sysc_reg(n)   __arg_##n\
467         ("r2", "r3", "r4", "r5", "r6", "r7")
468
469 #define __sysc_clobber  __sysc_regs, "memory"
470
471
472
473 /*      *****************************************
474         SH      SH      SH      SH              *
475         sh kernel interface                     */
476
477 #elif   defined(__sh__) && !defined(__SH5__)
478
479 /*      The SuperH calling convention passes the first four arguments
480         in r4-r7, the remainder is spilled onto the stack. However
481         the Linux kernel passes the remainder in r0-r2.
482
483         scnr:   id(r3)
484         args:   a1(r4), a2(r5), a3(r6), a4(r7), a5(r0), a6(r1)
485         sret:   r0(r0)
486         serr:   (sret >= (unsigned)-EMAXERRNO)
487         call:   trapa #0x1x (x=#args)
488         clob:   memory
489 */
490
491 #define __sysc_max_err  4095
492 #define __sysc_reg_cid  "r3"
493 #define __sysc_reg_res  "r0"
494
495 #define __sysc_reg(n)   __arg_##n\
496         ("r4", "r5", "r6", "r7", "r0", "r1")
497
498 #define __sysc_cmd(n)   "trapa  #0x1" __stringify(n)
499
500 #define __rep_6(x)      x x x x x x
501 #define __sysc_cmd_fin  __rep_6("or     r0,r0\n\t")
502
503 #define __sysc_clobber  __sysc_regs, "memory"
504
505 #warning syscall arch sh not tested yet
506
507
508
509 /*      *****************************************
510         SH64    SH64    SH64    SH64            *
511         sh64 kernel interface                   */
512
513 #elif defined(__sh__) && defined(__SH5__)
514
515 /*      The SuperH-5 calling convention passes the first eight
516         arguments in r2-r9
517
518         scnr:   id(r9)
519         args:   a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
520         sret:   r0(r9)
521         serr:   (sret >= (unsigned)-EMAXERRNO)
522         call:   trapa #0x1x (x=#args)
523         clob:   memory
524 */
525
526 #define __sysc_max_err  4095
527 #define __sysc_reg_res  "r9"
528 #define __sysc_cmd_sys  "trapa  r9"
529
530 #define __sysc_reg(n)   __arg_##n\
531         ("r2", "r3", "r4", "r5", "r6", "r7")
532
533 #define __sc_asmsysc(n,N)       __sc_asm_vol    (                       \
534         __casm(n,0,1,   "movi %0,r9"            ,                       )\
535         __casm(n,0,1,   __sc_cmds(n,N)          ,                       )\
536         ""::"i"(__sc_id(N) | 0x1##n << 16) : __sysc_clobber)
537
538 #define __sysc_clobber  __sysc_regs, "memory"
539
540 #warning syscall arch sh64 not tested yet
541
542
543
544 /*      *****************************************
545         SPARC64 SPARC64 SPARC64 SPARC64         *
546         sparc64 kernel interface                */
547
548 #elif   defined(__sparc__)
549
550 /*      The sparc/64 calling convention uses o0-o5 to pass the first
551         six arguments (mapped via register windows).
552
553         scnr:   id(g1)
554         args:   a1(o0), a2(o1), a3(o2), a4(o3), a5(o4), a6(o5)
555         sret:   r0(o0)
556         serr:   (carry)
557         call:   ta 0x6d, t 0x10
558         clob:   g1-g6, g7?, o7?, f0-f31, cc
559 */
560
561 #define __sysc_max_err  515
562 #define __sysc_reg_cid  "g1"
563 #define __sysc_reg_ret  "o0"
564 #define __sysc_reg_err  "l1"
565
566 #define __sysc_reg(n)   __arg_##n\
567         ("o0", "o1", "o2", "o3", "o4", "o5")
568
569 #ifdef  __arch64__
570 #define __sysc_cmd_sys  "ta     0x6d"
571 #else
572 #define __sysc_cmd_sys  "t      0x10"
573 #endif
574
575 #define __sysc_cmd_fin  "addx   %%g0,%%g0,%%l1"
576
577
578 #define __sysc_clobber  __sysc_regs,                                    \
579         "g2", "g3", "g4", "g5", "g6",                                   \
580         "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8",           \
581         "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16",          \
582         "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24",         \
583         "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32",         \
584         "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48",         \
585         "f50", "f52", "f54", "f56", "f58", "f60", "f62",                \
586         "cc", "memory"
587
588 #warning syscall arch sparc not tested yet
589
590
591
592 /*      *****************************************
593         V850    V850    V850    V850            *
594         v850 kernel interface                   */
595
596 #elif   defined(__v850__)
597
598 /*      The V850 calling convention passes the first four arguments
599         in registers r6-r9, the rest is spilled onto the stack.
600         but the Linux kernel interface uses r6-r9 and r13/14.
601
602         scnr:   id(r12)
603         args:   a1(r6), a2(r7), a3(r8), a4(r9), a5(r13), a6(r14)
604         sret:   r0(r10)
605         serr:   (sret >= (unsigned)-EMAXERRNO)
606         call:   trap 0, trap 1
607         clob:   r1, r5, r11, r15-r19
608 */
609
610 #define __sysc_max_err  515
611 #define __sysc_reg_cid  "r12"
612 #define __sysc_reg_res  "r10"
613
614 #define __sysc_reg(n)   __arg_##n\
615         ("r6", "r7", "r8", "r9", "r13", "r14")
616
617 #define __sysc_cmd(n)   __casm(n,4,0,"trap 1","trap 0")
618
619 #define __sysc_clobber  __sysc_regs,                                    \
620         "r1", "r5", "r11", "r15", "r16", "r17", "r18", "r19", "memory"
621
622 #warning syscall arch v850 not tested yet
623
624
625
626 /*      *****************************************
627         X86_64  X86_64  X86_64  X86_64          *
628         x86_64 kernel interface                 */
629
630 #elif   defined(__x86_64__)
631
632 /*      The x86_64 calling convention uses rdi, rsi, rdx, rcx, r8, r9
633         but the Linux kernel interface uses rdi, rsi, rdx, r10, r8, r9.
634         
635         scnr:   id(rax)
636         args:   a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9)
637         sret:   r0(rax)
638         serr:   (err= sret > (unsigned)-EMAXERRNO)
639         call:   syscall
640         clob:   rcx, r11
641 */
642
643 #define __sysc_max_err  4095
644 #define __sysc_reg_cid  "rax"
645 #define __sysc_reg_res  "rax"
646 #define __sysc_cmd_sys  "syscall"
647
648 #define __sysc_reg(n)   __arg_##n\
649         ("rdi", "rsi", "rdx", "r10", "r8", "r9")
650
651 #define __sysc_clobber  __sysc_regs,                                    \
652         "cc", "r11", "rcx", "memory"
653
654
655 #else
656 #error unknown kernel arch
657 #endif
658
659
660
661
662
663         /* argument list */
664
665 #define __lst_6(x,a1,a2,a3,a4,a5,a6)    __lst_5(x,a1,a2,a3,a4,a5),x(6,a6)
666 #define __lst_5(x,a1,a2,a3,a4,a5)       __lst_4(x,a1,a2,a3,a4),x(5,a5)
667 #define __lst_4(x,a1,a2,a3,a4)          __lst_3(x,a1,a2,a3),x(4,a4)
668 #define __lst_3(x,a1,a2,a3)             __lst_2(x,a1,a2),x(3,a3)
669 #define __lst_2(x,a1,a2)                __lst_1(x,a1),x(2,a2)
670 #define __lst_1(x,a1)                   __lst_0(x,*)x(1,a1)
671 #define __lst_0(x,a0)
672
673         /* argument concat */
674
675 #define __con_6(x,a1,a2,a3,a4,a5,a6)    __con_5(x,a1,a2,a3,a4,a5)x(6,a6)
676 #define __con_5(x,a1,a2,a3,a4,a5)       __con_4(x,a1,a2,a3,a4)x(5,a5)
677 #define __con_4(x,a1,a2,a3,a4)          __con_3(x,a1,a2,a3)x(4,a4)
678 #define __con_3(x,a1,a2,a3)             __con_2(x,a1,a2)x(3,a3)
679 #define __con_2(x,a1,a2)                __con_1(x,a1)x(2,a2)
680 #define __con_1(x,a1)                   __con_0(x,*)x(1,a1)
681 #define __con_0(x,a0)
682
683         /* argument selection */
684
685 #define __arg_0(...)
686 #define __arg_1(a1,...)                 a1
687 #define __arg_2(a1,a2,...)              a2
688 #define __arg_3(a1,a2,a3,...)           a3
689 #define __arg_4(a1,a2,a3,a4,...)        a4
690 #define __arg_5(a1,a2,a3,a4,a5,...)     a5
691 #define __arg_6(a1,a2,a3,a4,a5,a6)      a6
692
693
694
695 #ifdef  __PIC__
696 #define __pic(v)                v
697 #define __nopic(v)
698 #else
699 #define __pic(v)
700 #define __nopic(v)              v
701 #endif
702
703 #define __casm_nl(v)            v "\n\t"
704
705 #define __casm(n,a,r,v,w)       __casm_##n##a(v,w,r)
706
707 #define __pasm(n,a,r,v,w)       __pic(__casm(n,a,r,v,w))
708 #define __Pasm(n,a,r,v,w)       __nopic(__casm(n,a,r,v,w))
709
710 #define __casm_use(q,r,v)       v __casm_use_##q##r(__casm_nl(""))
711
712 #define __casm_use_10(v)
713 #define __casm_use_11(v)        v
714 #define __casm_use_12(v)
715 #define __casm_use_13(v)        v
716
717 #define __casm_use_20(v)
718 #define __casm_use_21(v)
719 #define __casm_use_22(v)        v
720 #define __casm_use_23(v)        v
721
722
723 #define __casm_00(v,w,r)        __casm_use(1,r,v)
724 #define __casm_01(v,w,r)        __casm_use(2,r,w)
725 #define __casm_02(v,w,r)        __casm_use(2,r,w)
726 #define __casm_03(v,w,r)        __casm_use(2,r,w)
727 #define __casm_04(v,w,r)        __casm_use(2,r,w)
728 #define __casm_05(v,w,r)        __casm_use(2,r,w)
729 #define __casm_06(v,w,r)        __casm_use(2,r,w)
730
731 #define __casm_10(v,w,r)        __casm_use(1,r,v)
732 #define __casm_11(v,w,r)        __casm_use(1,r,v)
733 #define __casm_12(v,w,r)        __casm_use(2,r,w)
734 #define __casm_13(v,w,r)        __casm_use(2,r,w)
735 #define __casm_14(v,w,r)        __casm_use(2,r,w)
736 #define __casm_15(v,w,r)        __casm_use(2,r,w)
737 #define __casm_16(v,w,r)        __casm_use(2,r,w)
738
739 #define __casm_20(v,w,r)        __casm_use(1,r,v)
740 #define __casm_21(v,w,r)        __casm_use(1,r,v)
741 #define __casm_22(v,w,r)        __casm_use(1,r,v)
742 #define __casm_23(v,w,r)        __casm_use(2,r,w)
743 #define __casm_24(v,w,r)        __casm_use(2,r,w)
744 #define __casm_25(v,w,r)        __casm_use(2,r,w)
745 #define __casm_26(v,w,r)        __casm_use(2,r,w)
746
747 #define __casm_30(v,w,r)        __casm_use(1,r,v)
748 #define __casm_31(v,w,r)        __casm_use(1,r,v)
749 #define __casm_32(v,w,r)        __casm_use(1,r,v)
750 #define __casm_33(v,w,r)        __casm_use(1,r,v)
751 #define __casm_34(v,w,r)        __casm_use(2,r,w)
752 #define __casm_35(v,w,r)        __casm_use(2,r,w)
753 #define __casm_36(v,w,r)        __casm_use(2,r,w)
754
755 #define __casm_40(v,w,r)        __casm_use(1,r,v)
756 #define __casm_41(v,w,r)        __casm_use(1,r,v)
757 #define __casm_42(v,w,r)        __casm_use(1,r,v)
758 #define __casm_43(v,w,r)        __casm_use(1,r,v)
759 #define __casm_44(v,w,r)        __casm_use(1,r,v)
760 #define __casm_45(v,w,r)        __casm_use(2,r,w)
761 #define __casm_46(v,w,r)        __casm_use(2,r,w)
762
763 #define __casm_50(v,w,r)        __casm_use(1,r,v)
764 #define __casm_51(v,w,r)        __casm_use(1,r,v)
765 #define __casm_52(v,w,r)        __casm_use(1,r,v)
766 #define __casm_53(v,w,r)        __casm_use(1,r,v)
767 #define __casm_54(v,w,r)        __casm_use(1,r,v)
768 #define __casm_55(v,w,r)        __casm_use(1,r,v)
769 #define __casm_56(v,w,r)        __casm_use(2,r,w)
770
771 #define __casm_60(v,w,r)        __casm_use(1,r,v)
772 #define __casm_61(v,w,r)        __casm_use(1,r,v)
773 #define __casm_62(v,w,r)        __casm_use(1,r,v)
774 #define __casm_63(v,w,r)        __casm_use(1,r,v)
775 #define __casm_64(v,w,r)        __casm_use(1,r,v)
776 #define __casm_65(v,w,r)        __casm_use(1,r,v)
777 #define __casm_66(v,w,r)        __casm_use(1,r,v)
778
779 #define __casm_cn_0
780 #define __casm_cn_1             ,
781 #define __casm_cn_2             ,
782 #define __casm_cn_3             ,
783 #define __casm_cn_4             ,
784 #define __casm_cn_5             ,
785 #define __casm_cn_6             ,
786
787
788
789 #define __sc_asm                __asm__
790 #define __sc_asm_vol            __asm__ __volatile__
791
792 #ifndef __sysc_setret
793 #define __sysc_setret(v)        do { } while(0)
794 #endif
795
796 #ifndef __sysc_seterr
797 #define __sysc_seterr(e)        do { errno = (e); } while(0)
798 #endif
799
800 #ifndef __stringify0
801 #define __stringify0(val)       #val
802 #endif
803
804 #ifndef __stringify
805 #define __stringify(val)        __stringify0(val)
806 #endif
807
808
809 #if     !defined(__sysc_load) && !defined(__sysc_save)
810 #if     !defined(__sysc_limm) && !defined(__sc_asmload)
811 #define __sc_trust
812 #endif
813 #endif
814
815 #if     defined(__sysc_reg_ret) && defined(__sysc_reg_err)
816 #define __sc_complex
817 #endif
818
819
820 #ifndef __sysc_type
821 #define __sysc_type             long
822 #endif
823
824 #define __sc_cast(v)            (__sysc_type)(v)
825
826
827 #define __sc_reg(n)             register __sysc_type n
828 #define __sc_asm_reg(n,r)       register __sysc_type n __sc_asm (r)
829 #define __sc_asm_val(n,r,v)     __sc_asm_reg(n,r) = __sc_cast(v)
830
831 #ifndef __sysc_load
832 #define __sc_inp_def(n,v)       __sc_asm_val(__sc_a##n, __sysc_reg(n), v);
833 #else
834 #define __sc_inp_def(n,value)
835 #endif
836
837 #ifndef __sysc_save
838 #define __sc_res_def(n,r)       __sc_asm_reg(n, r);
839 #else
840 #define __sc_res_def(n,r)       __sc_reg(n);
841 #endif
842
843
844 #define __sc_rreg(n,v)          "r"(__sc_a##n)
845 #define __sc_creg(n,v)          __sysc_rcon(n)(__sc_cast(v))
846
847 #ifdef  __sc_trust
848 #define __sc_iregs(n,...)       __lst_##n(__sc_rreg,__VA_ARGS__)
849 #define __sc_input(n,...)       __con_##n(__sc_inp_def,__VA_ARGS__)
850 #else
851 #define __sc_iregs(n,...)       __lst_##n(__sc_creg,__VA_ARGS__)
852 #define __sc_input(n,...)
853 #endif
854
855
856
857 #define __sc_list(x)            x(1), x(2), x(3), x(4), x(5), x(6)
858
859 #ifndef __sysc_regs
860 #define __sysc_regs             __sc_list(__sysc_reg)
861 #endif
862
863 #ifndef __sysc_rcon
864 #define __sysc_rcon(n)          "g"
865 #endif
866
867
868
869 #ifdef  __sc_complex    /* complex result */
870
871 #ifndef __sysc_errc
872 #define __sysc_errc(ret, err) (err)
873 #endif
874
875 #ifndef __sysc_retv
876 #define __sysc_retv(type, ret, err)                                     \
877         __sysc_setret(ret);                                             \
878         if (__sysc_errc(ret, err)) {                                    \
879                 int __err = (ret);                                      \
880                 __sysc_seterr(__err);                                   \
881                 ret = -1;                                               \
882         }                                                               \
883         return (type)(ret)
884 #endif
885
886 #define __sc_results                                                    \
887         __sc_res_def(__err, __sysc_reg_err)                             \
888         __sc_res_def(__ret, __sysc_reg_ret)
889
890 #define __sc_oregs      "=r"(__ret), "=r"(__err)
891
892 #if     defined(__sc_trust) || !defined(__sysc_save)
893 #define __sc_saveres    __sc_dummy_save(1)
894 #else
895 #define __sc_saveres                                                    \
896         __casm_nl(__sysc_save(__sysc_reg_ret,"%0"))                     \
897         __casm_nl(__sysc_save(__sysc_reg_err,"%1"))
898 #endif
899
900 #define __sc_return(t)  __sysc_retv(t, __ret, __err)
901
902 #else                   /* simple result  */
903
904 #ifndef __sysc_errc
905 #define __sysc_errc(res)                                                \
906         ((unsigned __sysc_type)(res) >=                                 \
907                 (unsigned __sysc_type)(-(__sysc_max_err)))
908 #endif
909
910 #ifndef __sysc_retv
911 #define __sysc_retv(type, res)                                          \
912         __sysc_setret(res);                                             \
913         if (__sysc_errc(res)) {                                         \
914                 int __err = -(res);                                     \
915                 __sysc_seterr(__err);                                   \
916                 res = -1;                                               \
917         }                                                               \
918         return (type)(res)
919 #endif
920
921 #define __sc_results                                                    \
922         __sc_res_def(__res, __sysc_reg_res)
923
924 #define __sc_oregs      "=r"(__res)
925
926 #if     defined(__sc_trust) || !defined(__sysc_save)
927 #define __sc_saveres    __sc_dummy_save(0)
928 #else
929 #define __sc_saveres    __casm_nl(__sysc_save(__sysc_reg_res,"%0"))
930 #endif
931
932 #define __sc_return(t)  __sysc_retv(t, __res)
933
934 #endif                  /* simple/complex */
935
936
937 #define __sc_dummy_load(n)      "/* gcc dummy load "                    \
938         __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) __casm(n,2,0,"%2 ",)  \
939         __casm(n,3,0,"%3 ",) __casm(n,4,0,"%4 ",) __casm(n,5,0,"%5 ",)  \
940         __casm(n,6,0,"%6 ",) "*/"
941
942 #define __sc_dummy_save(n)      "/* gcc dummy save "                    \
943         __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) "*/"
944
945 #define __comment(name)         "\t/* kernel sys_"                      \
946         #name "[" __stringify(__sc_id(name)) "] */"
947
948
949 #define __sc_id(N)              __NR_##N
950
951 #ifndef __sysc_reg_cid
952 #define __sc_cid(N)             "i"(__sc_id(N))
953 #define __sc_load_cid           ""
954 #define __sc_callid(N)
955 #else
956 #define __sc_cid(N)             "r"(__cid)
957 #define __sc_load_cid           __sysc_limm(__sysc_reg_cid,"%0")
958 #define __sc_callid(N)                                                  \
959         __sc_asm_val(__cid, __sysc_reg_cid, __sc_id(N));
960 #endif
961
962 #ifndef __sysc_cmd_pre
963 #define __sc_cmd_pre            ""
964 #else
965 #define __sc_cmd_pre            __casm_nl(__sysc_cmd_pre)
966 #endif
967
968 #ifndef __sysc_cmd_fin
969 #define __sc_cmd_fin            ""
970 #else
971 #define __sc_cmd_fin            __sysc_cmd_fin
972 #endif
973
974 #ifndef __sysc_pre
975 #define __sysc_pre(n)           __sc_cmd_pre
976 #endif
977
978 #ifndef __sysc_cmd
979 #define __sysc_cmd(n)           __sysc_cmd_sys
980 #endif
981
982 #ifndef __sysc_fin
983 #define __sysc_fin(n)           __sc_cmd_fin
984 #endif
985
986 #define __sc_cmds(n,name)                                               \
987         __sysc_pre(n)                                                   \
988         __casm_nl(__sysc_cmd(n) __comment(name))                        \
989         __sysc_fin(n)
990
991 #ifndef __sc_asmload
992 #ifdef  __sc_trust
993 #define __sc_asmload(n,N,...)   __sc_asm(                               \
994         __sc_dummy_load(n)                                              \
995         ::__sc_cid(N) __casm_cn_##n __sc_iregs(n,__VA_ARGS__))
996 #else
997 #define __sc_asmload(n,N,...)   __sc_asm(                               \
998         __casm(n,1,1,   __sysc_load(__sysc_reg(1),"%1"),                )\
999         __casm(n,2,1,   __sysc_load(__sysc_reg(2),"%2"),                )\
1000         __casm(n,3,1,   __sysc_load(__sysc_reg(3),"%3"),                )\
1001         __casm(n,4,1,   __sysc_load(__sysc_reg(4),"%4"),                )\
1002         __casm(n,5,1,   __sysc_load(__sysc_reg(5),"%5"),                )\
1003         __casm(n,6,1,   __sysc_load(__sysc_reg(6),"%6"),                )\
1004         __sc_load_cid   ::__sc_cid(N) __casm_cn_##n                     \
1005         __sc_iregs(n,__VA_ARGS__):__sysc_regs)
1006 #endif
1007 #endif
1008
1009 #ifndef __sc_asmsysc
1010 #define __sc_asmsysc(n,N)       __sc_asm_vol(                           \
1011         __casm(n,0,0,   __sc_cmds(n,N)          ,                       )\
1012         ::"i"(__sc_id(N)) : __sysc_clobber)
1013 #endif
1014
1015 #ifndef __sc_asmsave
1016 #define __sc_asmsave(n)         __sc_asm(                               \
1017         __sc_saveres            :__sc_oregs)
1018 #endif
1019
1020
1021
1022
1023 #define __sc_body(n, type, name, ...)                                   \
1024 {                                                                       \
1025         __sc_results __sc_callid(name) __sc_input(n, __VA_ARGS__)       \
1026         __sc_asmload(n, name, __VA_ARGS__);                             \
1027         __sc_asmsysc(n, name);                                          \
1028         __sc_asmsave(n);                                                \
1029         __sc_return(type);                                              \
1030 }
1031
1032
1033
1034 #define _syscall0(type, name)                                           \
1035 type name(void)                                                         \
1036 __sc_body(0, type, name, *)
1037
1038 #define _syscall1(type, name, type1, arg1)                              \
1039 type name(type1 arg1)                                                   \
1040 __sc_body(1, type, name, arg1)
1041
1042 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
1043 type name(type1 arg1, type2 arg2)                                       \
1044 __sc_body(2, type, name, arg1, arg2)
1045
1046 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)    \
1047 type name(type1 arg1, type2 arg2, type3 arg3)                           \
1048 __sc_body(3, type, name, arg1, arg2, arg3)
1049
1050 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
1051                               type4, arg4)                              \
1052 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4)               \
1053 __sc_body(4, type, name, arg1, arg2, arg3, arg4)
1054
1055 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3,    \
1056                               type4, arg4, type5, arg5)                 \
1057 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)   \
1058 __sc_body(5, type, name, arg1, arg2, arg3, arg4, arg5)
1059
1060 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3,    \
1061                         type4, arg4, type5, arg5, type6, arg6)          \
1062 type name(type1 arg1, type2 arg2, type3 arg3,                           \
1063           type4 arg4, type5 arg5, type6 arg6)                           \
1064 __sc_body(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6)
1065
1066
1067 #endif  /* __SYSCALL_NEW_H */