diff options
Diffstat (limited to 'fedora/tzdata-update.c')
| -rw-r--r-- | fedora/tzdata-update.c | 589 |
1 files changed, 589 insertions, 0 deletions
diff --git a/fedora/tzdata-update.c b/fedora/tzdata-update.c new file mode 100644 index 0000000000..f94f9a2609 --- /dev/null +++ b/fedora/tzdata-update.c @@ -0,0 +1,589 @@ +#ifdef __sparc__ +register void *__thread_self __asm ("g7"); +#endif +#define _GNU_SOURCE 1 +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <syscall.h> +#include <unistd.h> + +#if defined __i386__ +# define INTERNAL_SYSCALL_DECL(err) do { } while (0) +# define INTERNAL_SYSCALL(name, err, nr, args...) \ + ({ \ + register unsigned int resultvar; \ + asm volatile ( \ + "movl %1, %%eax\n\t" \ + "int $0x80\n\t" \ + : "=a" (resultvar) \ + : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc"); \ + (int) resultvar; }) +# define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((unsigned int) (val) >= 0xfffff001u) +# define ASMFMT_0() +# define ASMFMT_1(arg1) \ + , "b" (arg1) +# define ASMFMT_2(arg1, arg2) \ + , "b" (arg1), "c" (arg2) +# define ASMFMT_3(arg1, arg2, arg3) \ + , "b" (arg1), "c" (arg2), "d" (arg3) +#elif defined __x86_64__ +# define INTERNAL_SYSCALL_DECL(err) do { } while (0) +# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \ + ({ \ + unsigned long resultvar; \ + LOAD_ARGS_##nr (args) \ + LOAD_REGS_##nr \ + asm volatile ( \ + "syscall\n\t" \ + : "=a" (resultvar) \ + : "0" (name) ASM_ARGS_##nr : "memory", "cc", "r11", "cx"); \ + (long) resultvar; }) +# define INTERNAL_SYSCALL(name, err, nr, args...) \ + INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args) +# define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((unsigned long) (val) >= -4095L) +# define LOAD_ARGS_0() +# define LOAD_REGS_0 +# define ASM_ARGS_0 +# define LOAD_ARGS_1(a1) \ + long int __arg1 = (long) (a1); \ + LOAD_ARGS_0 () +# define LOAD_REGS_1 \ + register long int _a1 asm ("rdi") = __arg1; \ + LOAD_REGS_0 +# define ASM_ARGS_1 ASM_ARGS_0, "r" (_a1) +# define LOAD_ARGS_2(a1, a2) \ + long int __arg2 = (long) (a2); \ + LOAD_ARGS_1 (a1) +# define LOAD_REGS_2 \ + register long int _a2 asm ("rsi") = __arg2; \ + LOAD_REGS_1 +# define ASM_ARGS_2 ASM_ARGS_1, "r" (_a2) +# define LOAD_ARGS_3(a1, a2, a3) \ + long int __arg3 = (long) (a3); \ + LOAD_ARGS_2 (a1, a2) +# define LOAD_REGS_3 \ + register long int _a3 asm ("rdx") = __arg3; \ + LOAD_REGS_2 +# define ASM_ARGS_3 ASM_ARGS_2, "r" (_a3) +#elif defined __powerpc__ +# define INTERNAL_SYSCALL_DECL(err) long int err +# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \ + ({ \ + register long int r0 __asm__ ("r0"); \ + register long int r3 __asm__ ("r3"); \ + register long int r4 __asm__ ("r4"); \ + register long int r5 __asm__ ("r5"); \ + register long int r6 __asm__ ("r6"); \ + register long int r7 __asm__ ("r7"); \ + register long int r8 __asm__ ("r8"); \ + LOADARGS_##nr(name, args); \ + __asm__ __volatile__ \ + ("sc\n\t" \ + "mfcr %0\n\t" \ + : "=&r" (r0), \ + "=&r" (r3), "=&r" (r4), "=&r" (r5), \ + "=&r" (r6), "=&r" (r7), "=&r" (r8) \ + : ASM_INPUT_##nr \ + : "r9", "r10", "r11", "r12", \ + "cr0", "ctr", "memory"); \ + err = r0; \ + (int) r3; \ + }) +# define INTERNAL_SYSCALL(name, err, nr, args...) \ + INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args) +# define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((void) (val), __builtin_expect ((err) & (1 << 28), 0)) +# define LOADARGS_0(name, dummy) \ + r0 = name +# define LOADARGS_1(name, __arg1) \ + long int arg1 = (long int) (__arg1); \ + LOADARGS_0(name, 0); \ + r3 = arg1 +# define LOADARGS_2(name, __arg1, __arg2) \ + long int arg2 = (long int) (__arg2); \ + LOADARGS_1(name, __arg1); \ + r4 = arg2 +# define LOADARGS_3(name, __arg1, __arg2, __arg3) \ + long int arg3 = (long int) (__arg3); \ + LOADARGS_2(name, __arg1, __arg2); \ + r5 = arg3 +# define ASM_INPUT_0 "0" (r0) +# define ASM_INPUT_1 ASM_INPUT_0, "1" (r3) +# define ASM_INPUT_2 ASM_INPUT_1, "2" (r4) +# define ASM_INPUT_3 ASM_INPUT_2, "3" (r5) +#elif defined __ia64__ +# define DO_INLINE_SYSCALL_NCS(name, nr, args...) \ + LOAD_ARGS_##nr (args) \ + register long _r8 asm ("r8"); \ + register long _r10 asm ("r10"); \ + register long _r15 asm ("r15") = name; \ + long _retval; \ + LOAD_REGS_##nr \ + __asm __volatile ("break 0x100000;;" \ + : "=r" (_r8), "=r" (_r10), "=r" (_r15) \ + ASM_OUTARGS_##nr \ + : "2" (_r15) ASM_ARGS_##nr \ + : "memory" ASM_CLOBBERS_##nr); \ + _retval = _r8; +# define INTERNAL_SYSCALL_DECL(err) long int err +# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \ + ({ \ + DO_INLINE_SYSCALL_NCS (name, nr, args) \ + err = _r10; \ + _retval; }) +# define INTERNAL_SYSCALL(name, err, nr, args...) \ + INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args) +# define INTERNAL_SYSCALL_ERROR_P(val, err) (err == -1) +# define LOAD_ARGS_0() +# define LOAD_REGS_0 +# define LOAD_ARGS_1(a1) \ + long _arg1 = (long) (a1); \ + LOAD_ARGS_0 () +# define LOAD_REGS_1 \ + register long _out0 asm ("out0") = _arg1; \ + LOAD_REGS_0 +# define LOAD_ARGS_2(a1, a2) \ + long _arg2 = (long) (a2); \ + LOAD_ARGS_1 (a1) +# define LOAD_REGS_2 \ + register long _out1 asm ("out1") = _arg2; \ + LOAD_REGS_1 +# define LOAD_ARGS_3(a1, a2, a3) \ + long _arg3 = (long) (a3); \ + LOAD_ARGS_2 (a1, a2) +# define LOAD_REGS_3 \ + register long _out2 asm ("out2") = _arg3; \ + LOAD_REGS_2 +# define ASM_OUTARGS_0 +# define ASM_OUTARGS_1 ASM_OUTARGS_0, "=r" (_out0) +# define ASM_OUTARGS_2 ASM_OUTARGS_1, "=r" (_out1) +# define ASM_OUTARGS_3 ASM_OUTARGS_2, "=r" (_out2) +# define ASM_ARGS_0 +# define ASM_ARGS_1 ASM_ARGS_0, "3" (_out0) +# define ASM_ARGS_2 ASM_ARGS_1, "4" (_out1) +# define ASM_ARGS_3 ASM_ARGS_2, "5" (_out2) +# define ASM_CLOBBERS_0 ASM_CLOBBERS_1, "out0" +# define ASM_CLOBBERS_1 ASM_CLOBBERS_2, "out1" +# define ASM_CLOBBERS_2 ASM_CLOBBERS_3, "out2" +# define ASM_CLOBBERS_3 ASM_CLOBBERS_4, "out3" +# define ASM_CLOBBERS_4 ASM_CLOBBERS_5, "out4" +# define ASM_CLOBBERS_5 ASM_CLOBBERS_6, "out5" +# define ASM_CLOBBERS_6_COMMON , "out6", "out7", \ + /* Non-stacked integer registers, minus r8, r10, r15. */ \ + "r2", "r3", "r9", "r11", "r12", "r13", "r14", "r16", "r17", "r18", \ + "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", \ + "r28", "r29", "r30", "r31", \ + /* Predicate registers. */ \ + "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", \ + /* Non-rotating fp registers. */ \ + "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + /* Branch registers. */ \ + "b6" +# define ASM_CLOBBERS_6 ASM_CLOBBERS_6_COMMON , "b7" +#elif defined __s390__ +# define INTERNAL_SYSCALL_DECL(err) do { } while (0) +# define INTERNAL_SYSCALL_DIRECT(name, err, nr, args...) \ + ({ \ + DECLARGS_##nr(args) \ + register long _ret asm("2"); \ + asm volatile ( \ + "svc %b1\n\t" \ + : "=d" (_ret) \ + : "i" (__NR_##name) ASMFMT_##nr \ + : "memory" ); \ + _ret; }) +# define INTERNAL_SYSCALL_SVC0(name, err, nr, args...) \ + ({ \ + DECLARGS_##nr(args) \ + register unsigned long _nr asm("1") = (unsigned long)(__NR_##name); \ + register long _ret asm("2"); \ + asm volatile ( \ + "svc 0\n\t" \ + : "=d" (_ret) \ + : "d" (_nr) ASMFMT_##nr \ + : "memory" ); \ + _ret; }) +# define INTERNAL_SYSCALL(name, err, nr, args...) \ + (((__NR_##name) < 256) ? \ + INTERNAL_SYSCALL_DIRECT(name, err, nr, args) : \ + INTERNAL_SYSCALL_SVC0(name, err,nr, args)) +# define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((unsigned long) (val) >= -4095UL) +# define DECLARGS_0() +# define DECLARGS_1(arg1) \ + register unsigned long gpr2 asm ("2") = (unsigned long)(arg1); +# define DECLARGS_2(arg1, arg2) \ + DECLARGS_1(arg1) \ + register unsigned long gpr3 asm ("3") = (unsigned long)(arg2); +# define DECLARGS_3(arg1, arg2, arg3) \ + DECLARGS_2(arg1, arg2) \ + register unsigned long gpr4 asm ("4") = (unsigned long)(arg3); +# define ASMFMT_0 +# define ASMFMT_1 , "0" (gpr2) +# define ASMFMT_2 , "0" (gpr2), "d" (gpr3) +# define ASMFMT_3 , "0" (gpr2), "d" (gpr3), "d" (gpr4) +#elif defined __sparc__ +# ifndef __arch64__ +# define __INTERNAL_SYSCALL_STRING \ + "ta 0x10;" \ + "bcs,a 1f;" \ + " sub %%g0, %%o0, %%o0;" \ + "1:" +# define __SYSCALL_CLOBBERS "g2", "g3", "g4", "g5", "g6", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \ + "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \ + "cc", "memory" +# else +# define __INTERNAL_SYSCALL_STRING \ + "ta 0x6d;" \ + "bcs,a,pt %%xcc, 1f;" \ + " sub %%g0, %%o0, %%o0;" \ + "1:" +# define __SYSCALL_CLOBBERS "g2", "g3", "g4", "g5", "g6", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \ + "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \ + "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \ + "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62", \ + "cc", "memory" +# endif +#define INTERNAL_SYSCALL_DECL(err) do { } while (0) +#define INTERNAL_SYSCALL(name, err, nr, args...) \ + inline_syscall##nr(__INTERNAL_SYSCALL_STRING, __NR_##name, args) +#define INTERNAL_SYSCALL_ERROR_P(val, err) \ + ((unsigned long) (val) >= -515L) +# define inline_syscall0(string,name,dummy...) \ +({ \ + register long __o0 __asm__ ("o0"); \ + register long __g1 __asm__ ("g1") = name; \ + __asm __volatile (string : "=r" (__g1), "=r" (__o0) : \ + "0" (__g1) : \ + __SYSCALL_CLOBBERS); \ + __o0; \ +}) +# define inline_syscall1(string,name,arg1) \ +({ \ + register long __o0 __asm__ ("o0") = (long)(arg1); \ + register long __g1 __asm__ ("g1") = name; \ + __asm __volatile (string : "=r" (__g1), "=r" (__o0) : \ + "0" (__g1), "1" (__o0) : \ + __SYSCALL_CLOBBERS); \ + __o0; \ +}) +# define inline_syscall2(string,name,arg1,arg2) \ +({ \ + register long __o0 __asm__ ("o0") = (long)(arg1); \ + register long __o1 __asm__ ("o1") = (long)(arg2); \ + register long __g1 __asm__ ("g1") = name; \ + __asm __volatile (string : "=r" (__g1), "=r" (__o0) : \ + "0" (__g1), "1" (__o0), "r" (__o1) : \ + __SYSCALL_CLOBBERS); \ + __o0; \ +}) +# define inline_syscall3(string,name,arg1,arg2,arg3) \ +({ \ + register long __o0 __asm__ ("o0") = (long)(arg1); \ + register long __o1 __asm__ ("o1") = (long)(arg2); \ + register long __o2 __asm__ ("o2") = (long)(arg3); \ + register long __g1 __asm__ ("g1") = name; \ + __asm __volatile (string : "=r" (__g1), "=r" (__o0) : \ + "0" (__g1), "1" (__o0), "r" (__o1), \ + "r" (__o2) : \ + __SYSCALL_CLOBBERS); \ + __o0; \ +}) +#elif defined __alpha__ +# define INTERNAL_SYSCALL(name, err_out, nr, args...) \ + INTERNAL_SYSCALL1(name, err_out, nr, args) +# define INTERNAL_SYSCALL1(name, err_out, nr, args...) \ + INTERNAL_SYSCALL_NCS(__NR_##name, err_out, nr, args) +# define INTERNAL_SYSCALL_NCS(name, err_out, nr, args...) \ +({ \ + long _sc_ret, _sc_err; \ + inline_syscall##nr(name, args); \ + err_out = _sc_err; \ + _sc_ret; \ +}) +# define INTERNAL_SYSCALL_DECL(err) long int err +# define INTERNAL_SYSCALL_ERROR_P(val, err) err +# define inline_syscall_clobbers \ + "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \ + "$22", "$23", "$24", "$25", "$27", "$28", "memory" +# define inline_syscall_r0_asm +# define inline_syscall_r0_out_constraint "=v" +# define inline_syscall0(name, args...) \ +{ \ + register long _sc_0 inline_syscall_r0_asm; \ + register long _sc_19 __asm__("$19"); \ + \ + _sc_0 = name; \ + __asm__ __volatile__ \ + ("callsys # %0 %1 <= %2" \ + : inline_syscall_r0_out_constraint (_sc_0), \ + "=r"(_sc_19) \ + : "0"(_sc_0) \ + : inline_syscall_clobbers, \ + "$16", "$17", "$18", "$20", "$21"); \ + _sc_ret = _sc_0, _sc_err = _sc_19; \ +} +# define inline_syscall1(name,arg1) \ +{ \ + register long _sc_0 inline_syscall_r0_asm; \ + register long _sc_16 __asm__("$16"); \ + register long _sc_19 __asm__("$19"); \ + \ + _sc_0 = name; \ + _sc_16 = (long) (arg1); \ + __asm__ __volatile__ \ + ("callsys # %0 %1 <= %2 %3" \ + : inline_syscall_r0_out_constraint (_sc_0), \ + "=r"(_sc_19), "=r"(_sc_16) \ + : "0"(_sc_0), "2"(_sc_16) \ + : inline_syscall_clobbers, \ + "$17", "$18", "$20", "$21"); \ + _sc_ret = _sc_0, _sc_err = _sc_19; \ +} +# define inline_syscall2(name,arg1,arg2) \ +{ \ + register long _sc_0 inline_syscall_r0_asm; \ + register long _sc_16 __asm__("$16"); \ + register long _sc_17 __asm__("$17"); \ + register long _sc_19 __asm__("$19"); \ + \ + _sc_0 = name; \ + _sc_16 = (long) (arg1); \ + _sc_17 = (long) (arg2); \ + __asm__ __volatile__ \ + ("callsys # %0 %1 <= %2 %3 %4" \ + : inline_syscall_r0_out_constraint (_sc_0), \ + "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17) \ + : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17) \ + : inline_syscall_clobbers, \ + "$18", "$20", "$21"); \ + _sc_ret = _sc_0, _sc_err = _sc_19; \ +} +# define inline_syscall3(name,arg1,arg2,arg3) \ +{ \ + register long _sc_0 inline_syscall_r0_asm; \ + register long _sc_16 __asm__("$16"); \ + register long _sc_17 __asm__("$17"); \ + register long _sc_18 __asm__("$18"); \ + register long _sc_19 __asm__("$19"); \ + \ + _sc_0 = name; \ + _sc_16 = (long) (arg1); \ + _sc_17 = (long) (arg2); \ + _sc_18 = (long) (arg3); \ + __asm__ __volatile__ \ + ("callsys # %0 %1 <= %2 %3 %4 %5" \ + : inline_syscall_r0_out_constraint (_sc_0), \ + "=r"(_sc_19), "=r"(_sc_16), "=r"(_sc_17), \ + "=r"(_sc_18) \ + : "0"(_sc_0), "2"(_sc_16), "3"(_sc_17), \ + "4"(_sc_18) \ + : inline_syscall_clobbers, "$20", "$21"); \ + _sc_ret = _sc_0, _sc_err = _sc_19; \ +} +#endif + +char buffer[32768], data[32768]; +size_t datasize; +char zonename[1024]; + +ssize_t +readall (int fd, void *buf, size_t len) +{ + INTERNAL_SYSCALL_DECL (err); + size_t n = len; + ssize_t ret; + do + { + ret = INTERNAL_SYSCALL (read, err, 3, fd, buf, n); + if (INTERNAL_SYSCALL_ERROR_P (ret, err)) + { + ret = -1; + break; + } + else if (ret == 0) + break; + buf = (char *) buf + ret; + n -= ret; + } + while (n > 0); + return ret < 0 ? ret : (ssize_t) (len - n); +} + +ssize_t +writeall (int fd, const void *buf, size_t len) +{ + INTERNAL_SYSCALL_DECL (err); + size_t n = len; + ssize_t ret; + do + { + ret = INTERNAL_SYSCALL (write, err, 3, fd, buf, n); + if (INTERNAL_SYSCALL_ERROR_P (ret, err)) + { + ret = -1; + break; + } + else if (ret == 0) + break; + buf = (const char *) buf + ret; + n -= ret; + } + while (n > 0); + return ret < 0 ? ret : (ssize_t) (len - n); +} + +void +update (const char *filename) +{ + INTERNAL_SYSCALL_DECL (err); + long int fd = INTERNAL_SYSCALL (open, err, 2, filename, O_RDONLY); + if (INTERNAL_SYSCALL_ERROR_P (fd, err)) + return; + ssize_t ret = readall (fd, buffer, sizeof (buffer)); + INTERNAL_SYSCALL (close, err, 1, fd); + if (ret <= 0 || (size_t) ret == sizeof (buffer)) + return; + /* Don't update the file unnecessarily. */ + if ((size_t) ret == datasize && memcmp (buffer, data, datasize) == 0) + return; + size_t len = strlen (filename); + char tempfilename[len + sizeof (".tzupdate")]; + memcpy (tempfilename, filename, len); + memcpy (tempfilename + len, ".tzupdate", sizeof (".tzupdate")); + + fd = INTERNAL_SYSCALL (open, err, 3, tempfilename, O_WRONLY | O_CREAT | O_EXCL, 0600); + if (INTERNAL_SYSCALL_ERROR_P (fd, err)) + return; + if (writeall (fd, data, datasize) != datasize) + { +clean_up: + INTERNAL_SYSCALL (unlink, err, 1, tempfilename); + INTERNAL_SYSCALL (close, err, 1, fd); + return; + } + long int sret; + sret = INTERNAL_SYSCALL (fchmod, err, 2, fd, 0644); + if (INTERNAL_SYSCALL_ERROR_P (sret, err)) + goto clean_up; + INTERNAL_SYSCALL (close, err, 1, fd); + + sret = INTERNAL_SYSCALL (rename, err, 2, tempfilename, filename); + if (INTERNAL_SYSCALL_ERROR_P (sret, err)) + INTERNAL_SYSCALL (unlink, err, 1, tempfilename); +} + +int +main (int argc, char **argv) +{ + INTERNAL_SYSCALL_DECL (err); + long int fd = INTERNAL_SYSCALL (open, err, 2, "/etc/sysconfig/clock", O_RDONLY); + if (INTERNAL_SYSCALL_ERROR_P (fd, err)) + return 0; + ssize_t ret = readall (fd, buffer, sizeof (buffer) - 1); + INTERNAL_SYSCALL (close, err, 1, fd); + if (ret <= 0 || (size_t) ret == sizeof (buffer) - 1) + return 0; + char *p = buffer; + while (p != NULL) + { + while (*p == ' ' || *p == '\t') p++; + if (memcmp (p, "ZONE", 4) == 0) + { + p += 4; + while (*p == ' ' || *p == '\t') p++; + if (*p == '=') + { + p++; + while (*p == ' ' || *p == '\t') p++; + if (*p == '"') p++; + char *q = p; + while (strchr (" \t\n\"", *p) == NULL) p++; + const char path[] = "/usr/share/zoneinfo/"; + if (p - q >= sizeof (zonename) - sizeof (path)) + return 0; + memcpy (zonename, path, sizeof (path) - 1); + memcpy (zonename + sizeof (path) - 1, q, p - q); + break; + } + } + p = strchr (p, '\n'); + if (p) p++; + } + if (*zonename == '\0') + return 0; + fd = INTERNAL_SYSCALL (open, err, 2, zonename, O_RDONLY); + if (INTERNAL_SYSCALL_ERROR_P (fd, err)) + return 0; + ret = readall (fd, data, sizeof (data)); + INTERNAL_SYSCALL (close, err, 1, fd); + if (ret <= 0 || (size_t) ret == sizeof (data)) + return 0; + datasize = (size_t) ret; + update ("/etc/localtime"); + update ("/var/spool/postfix/etc/localtime"); + return 0; +} + +int __libc_multiple_threads __attribute__((nocommon)); +int __libc_enable_asynccancel (void) { return 0; } +void __libc_disable_asynccancel (int x) { } +void __libc_csu_init (void) { } +void __libc_csu_fini (void) { } +pid_t __fork (void) { return -1; } +char thr_buf[65536]; + +#ifndef __powerpc__ +int __libc_start_main (int (*main) (int argc, char **argv), + int argc, char **argv, + void (*init) (void), void (*fini) (void), + void (*rtld_fini) (void), void * stack_end) +#else +struct startup_info +{ + void *sda_base; + int (*main) (int, char **, char **, void *); + int (*init) (int, char **, char **, void *); + void (*fini) (void); +}; + +int __libc_start_main (int argc, char **argv, char **ev, + void *auxvec, void (*rtld_fini) (void), + struct startup_info *stinfo, + char **stack_on_entry) +#endif +{ +#if defined __ia64__ || defined __powerpc64__ + register void *r13 __asm ("r13") = thr_buf + 32768; + __asm ("" : : "r" (r13)); +#elif defined __sparc__ + register void *g6 __asm ("g6") = thr_buf + 32768; + __thread_self = thr_buf + 32768; + __asm ("" : : "r" (g6), "r" (__thread_self)); +#elif defined __s390__ && !defined __s390x__ + __asm ("sar %%a0,%0" : : "d" (thr_buf + 32768)); +#elif defined __s390x__ + __asm ("sar %%a1,%0; srlg 0,%0,32; sar %%a0,0" : : "d" (thr_buf + 32768) : "0"); +#elif defined __powerpc__ && !defined __powerpc64__ + register void *r2 __asm ("r2") = thr_buf + 32768; + __asm ("" : : "r" (r2)); +#endif +#ifdef __powerpc__ + argc = (long)*stack_on_entry; + argv = stack_on_entry + 1; +#endif + long ret = main (argc, argv); + INTERNAL_SYSCALL_DECL (err); + INTERNAL_SYSCALL (exit, err, 1, ret); + return 110; +} |