Author: baggins Date: Mon Aug 8 21:58:04 2005 GMT
Module: SOURCES Tag: HEAD
---- Log message:
- updates for util-vserver 0.30.208
---- Files affected:
SOURCES:
delta-0.30.208-shiny6.diff (NONE -> 1.1) (NEW),
delta-0.30.208-kheaders.diff (NONE -> 1.1) (NEW)
---- Diffs:
================================================================
Index: SOURCES/delta-0.30.208-shiny6.diff
diff -u /dev/null SOURCES/delta-0.30.208-shiny6.diff:1.1
--- /dev/null Mon Aug 8 23:58:04 2005
+++ SOURCES/delta-0.30.208-shiny6.diff Mon Aug 8 23:57:59 2005
@@ -0,0 +1,3122 @@
+diff -NurpP --minimal util-vserver-0.30.208/lib/syscall-alternative.h
util-vserver-0.30.208.x/lib/syscall-alternative.h
+--- util-vserver-0.30.208/lib/syscall-alternative.h 2005-07-04
19:58:28.000000000 +0200
++++ util-vserver-0.30.208.x/lib/syscall-alternative.h 2005-08-02
09:08:31.000000000 +0200
+@@ -1,2336 +1,1061 @@
++#ifndef __SYSCALL_NEW_H
++#define __SYSCALL_NEW_H
+
+-#ifndef __syscall_retval
+-#define __syscall_retval(v) do { } while(0)
+-#endif
++/* Copyright (C) 2005 Herbert Pötzl
+
+-#ifndef __syscall_error
+-#define __syscall_error(e) do { errno = (e); } while(0)
+-#endif
++ global config options
+
+-#define __check(pos, reg)
\
+- ".ifnc " pos ", " reg "\n\t" \
+- ".err\n\t" \
+- ".endif\n\t"
++ __sysc_setret ... set return value (default none)
++ __sysc_seterr ... set error value (default errno)
+
+-#ifndef __stringify0
+-#define __stringify0(val) #val
+-#endif
+
+-#ifndef __stringify
+-#define __stringify(val) __stringify0(val)
+-#endif
++ arch specific config
+
+-#define __comment(name)
\
+- "\t/* kernel sys_" #name "[" __stringify(__NR_##name) "] */"
++ __sysc_reg_cid ... the callid (if define), immediate otherwise
+
++ __sysc_reg(n) ... syscall argument registers
+
+-/* *****************************************
+- ALPHA ALPHA ALPHA ALPHA *
+- alpha kernel interface */
+-
+-#if defined(__alpha__)
++ __sysc_reg_res ... simple result register (either that or)
++ __sysc_reg_ret ... complex result register (and)
++ __sysc_reg_err ... complex error register
+
+-/* The Alpha calling convention doesn't use the stack until
+- after the first six arguments have been passed in registers.
+-
+- scnr: v0($0)
+- args: a0($16), a1($17), a2($18), a3($19), a4($20), a5($21)
+- sret: v0($0)
+- serr: a3($19) (!=0, err=sret)
+-*/
++ __sysc_cmd_pre ... preparation command(s) __sysc_pre(n)
++ __sysc_cmd_sys ... the syscall __sysc_cmd(n)
++ __sysc_cmd_fin ... syscall finalization __sysc_fin(n)
+
++ __sysc_clobber ... clobbered registers (default memory)
++ __sysc_max_err ... maximum error number (for simple result)
+
+-#define __syscall_return(type, ret, err) do { \
+- __syscall_retval(ret); \
+- if (err) { \
+- int __err = (ret); \
+- __syscall_error(__err); \
+- ret = -1; \
+- } \
+- return (type) ret; \
+-} while (0)
++ __sysc_errc(r,e) ... error condition (e cmplx)
++ __sysc_retv(t,r,e) ... syscall return value (e cmplx)
+
+-#define __syscall_regdef(name, reg) \
+- register long __sc_##name __asm__ (reg)
++ if gcc cannot be trusted
+
+-#define __syscall_regval(name, reg, val) \
+- register long __sc_##name __asm__ (reg) = (long)(val)
+-
+-#define __syscall_clobbers \
+- "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
+- "$22", "$23", "$24", "$25", "$27", "$28", "memory" \
++ __sysc_load(r,a) ... asm code for register load
++ __sysc_save(r,a) ... asm code to save result(s)
++ __sysc_limm(r,i) ... asm code to load immediate
++ __sysc_rcon(n) ... syscall register constraint
++ __sysc_regs ... list of input regs for clobber
++ __sysc_type ... register type
+
++ if all else fails
+
+-#define _syscall0(type, name) \
+-type name(void)
\
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regdef(a3, "$19"); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2", "$0$19$0") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0) \
+- : "$16", "$17", "$18", "$20", "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
++ __sc_asmload(n,N,...) ... asm code to prepare arguments
++ __sc_asmsysc(n,N) ... asm code to execute syscall
++ __sc_asmsave(n,r,e) ... asm code to store results
+
+-#define _syscall1(type, name, type1, arg1) \
+-type name(type1 arg1) \
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regdef(a3, "$19"); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3", "$0$19$0$16") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0) \
+- : "$17", "$18", "$20", "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
++*/
+
+-#define _syscall2(type, name, type1, arg1, type2, arg2)
\
+-type name(type1 arg1, type2 arg2) \
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regval(a1, "$17", arg2); \
+- __syscall_regdef(a3, "$19"); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3%4", "$0$19$0$16$17") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0), "r"(__sc_a1) \
+- : "$18", "$20", "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
+
+-#define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
+-type name(type1 arg1, type2 arg2, type3 arg3) \
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regval(a1, "$17", arg2); \
+- __syscall_regval(a2, "$18", arg3); \
+- __syscall_regdef(a3, "$19"); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3%4%5", "$0$19$0$16$17$18") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2) \
+- : "$20", "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
+
+-#define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
+- type4, arg4) \
+-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regval(a1, "$17", arg2); \
+- __syscall_regval(a2, "$18", arg3); \
+- __syscall_regval(a3, "$19", arg4); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3%4%5%6", "$0$19$0$16$17$18$19") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
+- "1"(__sc_a3) \
+- : "$20", "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
+
+-#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)
\
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regval(a1, "$17", arg2); \
+- __syscall_regval(a2, "$18", arg3); \
+- __syscall_regval(a3, "$19", arg4); \
+- __syscall_regval(a4, "$20", arg5); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3%4%5%6%7", "$0$19$0$16$17$18$19$20") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
+- "1"(__sc_a3), "r"(__sc_a4) \
+- : "$21", \
+- __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
++/* *****************************************
++ ALPHA ALPHA ALPHA ALPHA *
++ alpha kernel interface */
++
++#if defined(__alpha__)
+
+-#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) \
+-{ \
+- long __sc_ret, __sc_err; \
+- { \
+- __syscall_regval(v0, "$0", __NR_##name); \
+- __syscall_regval(a0, "$16", arg1); \
+- __syscall_regval(a1, "$17", arg2); \
+- __syscall_regval(a2, "$18", arg3); \
+- __syscall_regval(a3, "$19", arg4); \
+- __syscall_regval(a4, "$20", arg5); \
+- __syscall_regval(a5, "$21", arg6); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%1%2%3%4%5%6%7%8", \
+- "$0$19$0$16$17$18$19$20$21") \
+- "callsys" __comment(name) \
+- : "=r"(__sc_v0), "=r"(__sc_a3) \
+- : "0"(__sc_v0), \
+- "r"(__sc_a0), "r"(__sc_a1), "r"(__sc_a2), \
+- "1"(__sc_a3), "r"(__sc_a4), "r"(__sc_a5) \
+- : __syscall_clobbers \
+- ); \
+- __sc_ret = __sc_v0; \
+- __sc_err = __sc_a3; \
+- } \
+- __syscall_return(type, __sc_ret, __sc_err); \
+-}
++/* 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_reg_cid "$0"
++#define __sysc_reg_ret "$0"
++#define __sysc_reg_err "$19"
++#define __sysc_cmd_sys "callsys"
++
++#define __sysc_reg(n) __arg_##n\
++ ("$16", "$17", "$18", "$19", "$20", "$21")
++
++#define __sysc_clobber __sysc_regs,
\
++ "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
++ "$22", "$23", "$24", "$25", "$27", "$28", "memory" \
+
+
+
+ /* *****************************************
+- ARM ARM ARM ARM *
++ 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.
++/* 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), v1(r4), v2(r5),
+- sret: a1(r0)
+- serr: (err= sret > (unsigned)-EMAXERRNO)
++ args: a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5),
++ sret: r0(r0)
++ serr: (sret >= (unsigned)-EMAXERRNO)
++ call: swi
++ clob: memory
+ */
+
+-#ifndef EMAXERRNO
+-#define EMAXERRNO 125
+-#endif
++#define __sysc_max_err 125
++#define __sysc_reg_res "r0"
++#define __sysc_cmd_sys "swi %0"
+
+-#define __syscall_errcon(res) \
+- ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
++#define __sysc_reg(n) __arg_##n\
++ ("r0", "r1", "r2", "r3", "r4", "r5")
+
+-#define __syscall_return(type, res) do { \
+- __syscall_retval(res); \
+- if (__syscall_errcon(res)) { \
+- int __err = -(res); \
+- __syscall_error(__err); \
+- res = -1; \
+- } \
+- return (type) res; \
+-} while (0)
++#define __sysc_clobber __sysc_regs, "memory"
+
+-#define __syscall_regdef(name, reg) \
+- register int __sc_##name __asm__ (reg)
++#warning syscall arch arm not tested yet
+
+-#define __syscall_regval(name, reg, val) \
+- register int __sc_##name __asm__ (reg) = (int)(val)
+
+
+-#define _syscall0(type, name) \
+-type name(void)
\
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regdef(a1, "r0"); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0", "r0") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++/* *****************************************
++ CRIS CRIS CRIS CRIS *
++ cris v10 kernel interface */
+
+-#define _syscall1(type, name, type1, arg1) \
+-type name(type1 arg1) \
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2", "r0r0") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++#elif defined(__cris__)
+
+-#define _syscall2(type, name, type1, arg1, type2, arg2)
\
+-type name(type1 arg1, type2 arg2) \
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- __syscall_regval(a2, "r1", arg2); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2%3", "r0r0r1") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1), "r"(__sc_a2) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++/* The Cris calling convention uses stack args after four arguments
++ but the Linux kernel gets up to six arguments in registers.
++
++ scnr: id(r9)
++ args: a1(r10), a2(r11), a3(r12), a4(r13), a5(mof), a6(srp),
++ sret: r0(r10)
++ serr: (sret >= (unsigned)-EMAXERRNO)
++ call: break 13
++ clob: memory
++*/
+
+-#define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
+-type name(type1 arg1, type2 arg2, type3 arg3) \
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- __syscall_regval(a2, "r1", arg2); \
+- __syscall_regval(a3, "r2", arg3); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2%3%4", "r0r0r1r2") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++#define __sysc_max_err 125
++#define __sysc_reg_cid "r9"
++#define __sysc_reg_res "r0"
++#define __sysc_cmd_sys "break 13"
+
+-#define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
+- type4, arg4) \
+-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- __syscall_regval(a2, "r1", arg2); \
+- __syscall_regval(a3, "r2", arg3); \
+- __syscall_regval(a4, "r3", arg4); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2%3%4%5", "r0r0r1r2r3") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
+- "r"(__sc_a4) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++#define __sysc_regs "r10", "r11", "r12", "r13"
++#define __sysc_reg(n) __arg_##n\
++ ("r10", "r11", "r12", "r13", "r0", "srp")
+
+-#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)
\
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- __syscall_regval(a2, "r1", arg2); \
+- __syscall_regval(a3, "r2", arg3); \
+- __syscall_regval(a4, "r3", arg4); \
+- __syscall_regval(v1, "r4", arg5); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2%3%4%5%6", "r0r0r1r2r3r4") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
+- "r"(__sc_a4), "r"(__sc_v1) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
++#define __sysc_pre(n) __casm(n,5,0,"move r0,mof",)
++
++#define __sysc_clobber __sysc_regs, "memory"
++
++#warning syscall arch cris not tested yet
+
+-#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) \
+-{ \
+- long __sc_res; \
+- { \
+- __syscall_regval(a1, "r0", arg1); \
+- __syscall_regval(a2, "r1", arg2); \
+- __syscall_regval(a3, "r2", arg3); \
+- __syscall_regval(a4, "r3", arg4); \
+- __syscall_regval(v1, "r4", arg5); \
+- __syscall_regval(v2, "r5", arg6); \
+- \
+- __asm__ __volatile__ ( \
+- __check("%0%2%3%4%5%6%7", "r0r0r1r2r3r4r5") \
+- "swi %1" __comment(name) \
+- : "=r"(__sc_a1) \
+- : "i"(__NR_##name), \
+- "0"(__sc_a1), "r"(__sc_a2), "r"(__sc_a3), \
+- "r"(__sc_a4), "r"(__sc_v1), "r"(__sc_v2) \
+- : "memory" \
+- ); \
+- __sc_res = __sc_a1; \
+- } \
+- __syscall_return(type, __sc_res); \
+-}
+
+
+ /* *****************************************
+- CRIS CRIS CRIS CRIS *
+- cris v10 kernel interface */
++ FRV FRV FRV FRV *
++ frv kernel interface */
+
+-#elif defined(__cris__)
++#elif defined(__frv__)
+
+-/* The Cris calling convention uses stack args after four arguments
+- but the Linux kernel gets up to six arguments in registers.
++/* The C calling convention on FR-V uses the gr8-gr13 registers
++ for the first six arguments, the remainder is spilled onto the
++ stack. the linux kernel syscall interface does so too.
+
+- scnr: (r9)
+- args: (r10), (r11), (r12), (r13), (mof), (srp),
+- sret: (r10)
+- serr: (err= sret > (unsigned)-EMAXERRNO)
++ scnr: id(gr7)
++ args: a1(gr8), a2(gr9), a3(gr10), a4(gr11), a5(gr12), a6(gr13)
++ sret: r0(gr8)
++ serr: (sret >= (unsigned)-EMAXERRNO)
++ call: tra gr0,gr0
++ clob: memory
+ */
+
+-#ifndef EMAXERRNO
+-#define EMAXERRNO 125
+-#endif
++#define __sysc_max_err 125
++#define __sysc_reg_cid "gr7"
++#define __sysc_reg_res "gr8"
++#define __sysc_cmd_sys "tira gr0,#0"
+
+-#define __syscall_errcon(res) \
+- ((unsigned long)(res) >= (unsigned long)(-EMAXERRNO))
<<Diff was trimmed, longer than 597 lines>>
_______________________________________________
pld-cvs-commit mailing list
[email protected]
http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit
