#ifndef __SYSCALL_NEW_H #define __SYSCALL_NEW_H /* Copyright (C) 2005-2007 Herbert Pötzl global config options __sysc_setret ... set return value (def: none) __sysc_seterr ... set error value (def: errno) __sysc_cid(N) ... syscall 'name' id (def: __NR_) arch specific config __sysc_clbrs ... the clobbered syscall registers __sysc_regs ... the syscall registers (asm load) __sysc_cidr ... the syscall id register (asm load) __sysc_cmd(n) ... the syscall __sysc_clobber ... clobbered registers (def: memory) __sysc_max_err ... maximum error number (def: separate) __sysc_acon(n) ... argument constraint (def: "r") __sysc_rcon ... return value contraint (def: "=r") __sysc_icon ... syscall id constraint (def: "i") __sysc_type ... type of syscall arguments (def: long) */ /* some fallback defaults */ #ifndef __sysc_setret #define __sysc_setret(v) do { } while(0) #endif #ifndef __sysc_seterr #define __sysc_seterr(e) do { errno = (e); } while(0) #endif #ifndef __sysc_cid #define __sysc_cid(N) __NR_##N #else #define __sc_cidvar(N) __sc_scid(__cid, __sysc_cid(N)) #endif /* ***************************************** ALPHA ALPHA ALPHA ALPHA * alpha kernel interface */ #if defined(__alpha__) /* The Alpha calling convention doesn't use the stack until after the first six arguments have been passed in registers. scnr: v0($0) args: a1($16), a2($17), a3($18), a4($19), a5($20), a6($21) sret: r0($0) serr: e0($19) (!=0, err=sret) call: callsys clob: memory */ #define __sysc_cmd(n) \ __casm(n,0,1, "callsys" ,)\ __casm(n,0,1, "mov %0,$0" ,)\ __casm(n,0,1, "mov %1,$19" ,) #define __sysc_regs "$16", "$17", "$18", "$19", "$20", "$21" #define __sysc_cidr "$0" #define __sysc_clobber \ "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \ "$22", "$23", "$24", "$25", "$27", "$28", "memory" \ /* ***************************************** ARM ARM ARM ARM * arm kernel interface */ #elif defined(__arm__) /* The Arm calling convention uses stack args after four arguments but the Linux kernel gets up to seven arguments in registers. scnr: imm args: a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5), sret: r0(r0) serr: (sret >= (unsigned)-EMAXERRNO) call: swi clob: memory */ #define __sysc_max_err 125 #define __sysc_cmd(n) \ __casm(n,0,1, "swi %1" ,)\ __casm(n,0,1, "mov %0, r0" ,) #define __sysc_regs "r0", "r1", "r2", "r3", "r4", "r5" #warning syscall arch arm not tested yet /* ***************************************** I386 I386 I386 I386 * i386 kernel interface */ #elif defined(__i386__) /* The x86 calling convention uses stack args for all arguments, but the Linux kernel passes the first six arguments in the following registers: ebx, ecx, edx, esi, edi, ebp. scnr: id(eax) args: a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp) sret: r0(eax) serr: (sret >= (unsigned)-EMAXERRNO) call: int 0x80 picr: pr(ebx) clob: memory */ #define __sysc_max_err 129 #ifndef __PIC__ #define __sysc_clbrs "eax", "ebx", "ecx", "edx", "esi", "edi" #else #define __sysc_clbrs "eax", "memory", "ecx", "edx", "esi", "edi" #endif #define __sysc_cmd(n) \ __casm(n,6,1, "movl %7, %%eax" ,)\ __casm(n,5,1, "movl %6, %%edi" ,)\ __casm(n,4,1, "movl %5, %%esi" ,)\ __casm(n,3,1, "movl %4, %%edx" ,)\ __casm(n,2,1, "movl %3, %%ecx" ,)\ __pasm(n,1,1, "pushl %%ebx" ,)\ __casm(n,1,1, "movl %2, %%ebx" ,)\ __casm(n,6,1, "pushl %%ebp" ,)\ __casm(n,6,1, "movl %%eax, %%ebp" ,)\ __casm(n,0,1, "movl %1, %%eax" ,)\ __casm(n,0,1, "int $0x80" ,)\ __casm(n,6,1, "popl %%ebp" ,)\ __pasm(n,1,1, "popl %%ebx" ,)\ __casm(n,0,1, "movl %%eax, %0" ,) #define __sysc_acon(n) "g" #define __sysc_rcon "=g" /* ***************************************** X86_64 X86_64 X86_64 X86_64 * x86_64 kernel interface */ #elif defined(__x86_64__) /* The x86_64 calling convention uses rdi, rsi, rdx, rcx, r8, r9 but the Linux kernel interface uses rdi, rsi, rdx, r10, r8, r9. scnr: id(rax) args: a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9) sret: r0(rax) serr: (err= sret > (unsigned)-EMAXERRNO) call: syscall clob: rcx, r11 */ #define __sysc_max_err 4095 #define __sysc_cmd(n) \ __casm(n,0,1, "syscall" ,)\ __casm(n,0,1, "mov %%rax, %0" ,) #define __sysc_regs "rdi", "rsi", "rdx", "r10", "r8", "r9" #define __sysc_cidr "rax" #define __sysc_clobber "cc", "r11", "rcx", "memory" #else #error unknown kernel arch #endif /* implementation defaults */ #ifndef __sysc_clobber #define __sysc_clobber "memory" #endif #ifndef __sysc_acon #define __sysc_acon(n) "r" #endif #ifndef __sysc_rcon #define __sysc_rcon "=r" #endif #ifndef __sysc_icon #define __sysc_icon "i" #endif #ifndef __sysc_type #define __sysc_type long #endif #ifdef __sysc_regs #define __sysc_rega(n,...) __arg_##n(__VA_ARGS__) #ifndef __sysc_reg #define __sysc_reg(n) __sysc_rega(n,__sysc_regs) #endif #endif /* argument list */ #define __lst_6(x,a1,a2,a3,a4,a5,a6) __lst_5(x,a1,a2,a3,a4,a5),x(6,a6) #define __lst_5(x,a1,a2,a3,a4,a5) __lst_4(x,a1,a2,a3,a4),x(5,a5) #define __lst_4(x,a1,a2,a3,a4) __lst_3(x,a1,a2,a3),x(4,a4) #define __lst_3(x,a1,a2,a3) __lst_2(x,a1,a2),x(3,a3) #define __lst_2(x,a1,a2) __lst_1(x,a1),x(2,a2) #define __lst_1(x,a1) __lst_0(x,*),x(1,a1) #define __lst_0(x,a0) /* argument selection */ #define __arg_0(...) #define __arg_1(a1,...) a1 #define __arg_2(a1,a2,...) a2 #define __arg_3(a1,a2,a3,...) a3 #define __arg_4(a1,a2,a3,a4,...) a4 #define __arg_5(a1,a2,a3,a4,a5,...) a5 #define __arg_6(a1,a2,a3,a4,a5,a6) a6 /* argument concatenation */ #define __con_6(x,a1,a2,a3,a4,a5,a6) __con_5(x,a1,a2,a3,a4,a5)x(6,a6) #define __con_5(x,a1,a2,a3,a4,a5) __con_4(x,a1,a2,a3,a4)x(5,a5) #define __con_4(x,a1,a2,a3,a4) __con_3(x,a1,a2,a3)x(4,a4) #define __con_3(x,a1,a2,a3) __con_2(x,a1,a2)x(3,a3) #define __con_2(x,a1,a2) __con_1(x,a1)x(2,a2) #define __con_1(x,a1) __con_0(x,*)x(1,a1) #define __con_0(x,a0) /* list reduction */ #define __red_0(...) #define __red_1(a1,...) ,a1 #define __red_2(a1,a2,...) ,a1,a2 #define __red_3(a1,a2,a3,...) ,a1,a2,a3 #define __red_4(a1,a2,a3,a4,...) ,a1,a2,a3,a4 #define __red_5(a1,a2,a3,a4,a5,...) ,a1,a2,a3,a4,a5 #define __red_6(a1,a2,a3,a4,a5,a6) ,a1,a2,a3,a4,a5,a6 /* conditional asm */ #define __casm_use(q,r,v) v __casm_use_##q##r(__casm_nl("")) #define __casm_use_10(v) #define __casm_use_11(v) v #define __casm_use_12(v) #define __casm_use_13(v) v #define __casm_use_20(v) #define __casm_use_21(v) #define __casm_use_22(v) v #define __casm_use_23(v) v #define __casm_00(v,w,r) __casm_use(1,r,v) #define __casm_01(v,w,r) __casm_use(2,r,w) #define __casm_02(v,w,r) __casm_use(2,r,w) #define __casm_03(v,w,r) __casm_use(2,r,w) #define __casm_04(v,w,r) __casm_use(2,r,w) #define __casm_05(v,w,r) __casm_use(2,r,w) #define __casm_06(v,w,r) __casm_use(2,r,w) #define __casm_10(v,w,r) __casm_use(1,r,v) #define __casm_11(v,w,r) __casm_use(1,r,v) #define __casm_12(v,w,r) __casm_use(2,r,w) #define __casm_13(v,w,r) __casm_use(2,r,w) #define __casm_14(v,w,r) __casm_use(2,r,w) #define __casm_15(v,w,r) __casm_use(2,r,w) #define __casm_16(v,w,r) __casm_use(2,r,w) #define __casm_20(v,w,r) __casm_use(1,r,v) #define __casm_21(v,w,r) __casm_use(1,r,v) #define __casm_22(v,w,r) __casm_use(1,r,v) #define __casm_23(v,w,r) __casm_use(2,r,w) #define __casm_24(v,w,r) __casm_use(2,r,w) #define __casm_25(v,w,r) __casm_use(2,r,w) #define __casm_26(v,w,r) __casm_use(2,r,w) #define __casm_30(v,w,r) __casm_use(1,r,v) #define __casm_31(v,w,r) __casm_use(1,r,v) #define __casm_32(v,w,r) __casm_use(1,r,v) #define __casm_33(v,w,r) __casm_use(1,r,v) #define __casm_34(v,w,r) __casm_use(2,r,w) #define __casm_35(v,w,r) __casm_use(2,r,w) #define __casm_36(v,w,r) __casm_use(2,r,w) #define __casm_40(v,w,r) __casm_use(1,r,v) #define __casm_41(v,w,r) __casm_use(1,r,v) #define __casm_42(v,w,r) __casm_use(1,r,v) #define __casm_43(v,w,r) __casm_use(1,r,v) #define __casm_44(v,w,r) __casm_use(1,r,v) #define __casm_45(v,w,r) __casm_use(2,r,w) #define __casm_46(v,w,r) __casm_use(2,r,w) #define __casm_50(v,w,r) __casm_use(1,r,v) #define __casm_51(v,w,r) __casm_use(1,r,v) #define __casm_52(v,w,r) __casm_use(1,r,v) #define __casm_53(v,w,r) __casm_use(1,r,v) #define __casm_54(v,w,r) __casm_use(1,r,v) #define __casm_55(v,w,r) __casm_use(1,r,v) #define __casm_56(v,w,r) __casm_use(2,r,w) #define __casm_60(v,w,r) __casm_use(1,r,v) #define __casm_61(v,w,r) __casm_use(1,r,v) #define __casm_62(v,w,r) __casm_use(1,r,v) #define __casm_63(v,w,r) __casm_use(1,r,v) #define __casm_64(v,w,r) __casm_use(1,r,v) #define __casm_65(v,w,r) __casm_use(1,r,v) #define __casm_66(v,w,r) __casm_use(1,r,v) /* special PIC handling */ #ifdef __PIC__ #define __pic(v) v #define __nopic(v) #else #define __pic(v) #define __nopic(v) v #endif #define __casm_nl(v) v "\n\t" #define __casm(n,a,r,v,w) __casm_##n##a(v,w,r) #define __pasm(n,a,r,v,w) __pic(__casm(n,a,r,v,w)) #define __nasm(n,a,r,v,w) __nopic(__casm(n,a,r,v,w)) #define __sc_cast(v) (__sysc_type)(v) #define __sc_ldef(N) __sysc_type N #define __sc_rdef(N,R) register __sc_ldef(N) __sc_asm (R) #define __sc_scid(N,v) __sc_ldef(N) = (v) #define __sc_areg(N,R,v) __sc_rdef(N,R) = (v) #define __sc_rval(n,v) "r"(__sc_a##n) #define __sc_ival(n,v) __sysc_acon(n)(__sc_cast(v)) #define __sc_idef(n,v) __sc_areg(__sc_a##n, __sysc_reg(n), v); #ifdef __sysc_regs #define __sc_input(n,...) __con_##n(__sc_idef,__VA_ARGS__) #define __sc_ivals(n,...) __lst_##n(__sc_rval,__VA_ARGS__) #define __sc_cregs(n,...) #ifdef __sysc_cidr #define __sc_cidvar(N) __sc_areg(__sc_cid,__sysc_cidr,__sysc_cid(N)) #define __sc_cidval(N) "r"(__sc_cid) #endif #else #define __sc_input(n,...) #define __sc_ivals(n,...) __lst_##n(__sc_ival,__VA_ARGS__) #define __sc_cregs(n,...) __red_##n(__VA_ARGS__) #endif #ifndef __sc_cidval #define __sc_cidval(N) __sysc_icon(__sysc_cid(N)) #endif #ifndef __sc_cidvar #define __sc_cidvar(N) #endif #ifndef __sysc_max_err #define __sc_complex #endif #ifdef __sc_complex /* complex result */ #define __sc_results __sc_ldef(__ret); __sc_ldef(__err) #ifndef __sysc_errc #define __sysc_errc(ret, err) (err) #endif #ifndef __sysc_retv #define __sysc_retv(type, ret, err) \ __sysc_setret(ret); \ if (__sysc_errc(ret, err)) { \ __sysc_seterr(ret); \ ret = -1; \ } \ return (type)(ret) #endif #define __sc_oregs __sysc_rcon (__ret), __sysc_rcon (__err) #define __sc_return(t) __sysc_retv(t, __ret, __err) #else /* simple result */ #define __sc_results __sc_ldef(__res) #ifndef __sysc_errc #define __sysc_errc(res) \ ((unsigned __sysc_type)(res) >= \ (unsigned __sysc_type)(-(__sysc_max_err))) #endif #ifndef __sysc_retv #define __sysc_retv(type, res) \ __sysc_setret(res); \ if (__sysc_errc(res)) { \ __sysc_seterr(-res); \ res = -1; \ } \ return (type)(res) #endif #define __sc_oregs __sysc_rcon (__res) #define __sc_return(t) __sysc_retv(t, __res) #endif /* simple/complex */ /* the inline syscall */ #define __sc_asm __asm__ #define __sc_asm_vol __asm__ __volatile__ #define __sc_syscall(n,N,...) \ __sc_asm (__sysc_cmd(n) \ : __sc_oregs \ : __sc_cidval(N) __sc_ivals(n,__VA_ARGS__) \ : __sysc_clobber __sc_cregs(n,__sysc_clbrs) ) #define __sc_body(n, type, name, ...) \ { \ __sc_results;__sc_cidvar(name); \ __sc_input(n,__VA_ARGS__); \ __sc_syscall(n,name,__VA_ARGS__); \ __sc_return(type); \ } #define _syscall0(type, name) \ type name(void) \ __sc_body(0, type, name, *) #define _syscall1(type, name, type1, arg1) \ type name(type1 arg1) \ __sc_body(1, type, name, arg1) #define _syscall2(type, name, type1, arg1, type2, arg2) \ type name(type1 arg1, type2 arg2) \ __sc_body(2, type, name, arg1, arg2) #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ type name(type1 arg1, type2 arg2, type3 arg3) \ __sc_body(3, type, name, arg1, arg2, arg3) #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \ type4, arg4) \ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \ __sc_body(4, type, name, arg1, arg2, arg3, arg4) #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \ type4, arg4, type5, arg5) \ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \ __sc_body(5, type, name, arg1, arg2, arg3, arg4, arg5) #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \ type4, arg4, type5, arg5, type6, arg6) \ type name(type1 arg1, type2 arg2, type3 arg3, \ type4 arg4, type5 arg5, type6 arg6) \ __sc_body(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6) #endif /* __SYSCALL_NEW_H */