2.3.90-12

4 files changed, 610 insertions, 16 deletions

diff --git a/fedora/build-locale-archive.c b/fedora/build-locale-archive.c
index bc89863c14..a35171736e 100644
--- a/fedora/build-locale-archive.c
+++ b/fedora/build-locale-archive.c
@@ -156,5 +156,7 @@ int main ()
     }
   closedir (dirp);
   add_locales_to_archive (cnt, list, 0);
+  char *argv[] = { "/usr/sbin/tzdata-update", NULL };
+  execve (argv[0], (char *const *)argv, (char *const *)&argv[1]);
   exit (0);
 }
diff --git a/fedora/glibc.spec.in b/fedora/glibc.spec.in
index e9a8faecd3..03d50aebc2 100644
--- a/fedora/glibc.spec.in
+++ b/fedora/glibc.spec.in
@@ -1,4 +1,4 @@
-%define glibcrelease 11
+%define glibcrelease 12
 %define auxarches i586 i686 athlon sparcv9 alphaev6
 %define prelinkarches noarch
 %define xenarches i686 athlon
@@ -600,6 +600,8 @@ echo 'include ld.so.conf.d/*.conf' > $RPM_BUILD_ROOT/etc/ld.so.conf
 touch $RPM_BUILD_ROOT/etc/ld.so.cache
 chmod 644 $RPM_BUILD_ROOT/etc/ld.so.conf
 mkdir -p $RPM_BUILD_ROOT/etc/ld.so.conf.d
+mkdir -p $RPM_BUILD_ROOT/etc/sysconfig
+touch $RPM_BUILD_ROOT/etc/sysconfig/nscd
 
 # Include %{_prefix}/%{_lib}/gconv/gconv-modules.cache
 > $RPM_BUILD_ROOT%{_prefix}/%{_lib}/gconv/gconv-modules.cache
@@ -722,6 +724,7 @@ grep -v '/%{_lib}/%{nosegneg_subdir}' < rpm.filelist.full > rpm.filelist
 %endif
 
 echo '%{_prefix}/sbin/build-locale-archive' >> common.filelist
+echo '%{_prefix}/sbin/tzdata-update' >> common.filelist
 echo '%{_prefix}/sbin/nscd' > nscd.filelist
 
 cat > utils.filelist <<EOF
@@ -748,6 +751,9 @@ $GCC -Os -static -o build-locale-archive build-locale-archive.c \
   -DDATADIR=\"%{_datadir}\" -DPREFIX=\"%{_prefix}\" \
   -L../build-%{nptl_target_cpu}-linuxnptl
 install -m 700 build-locale-archive $RPM_BUILD_ROOT/usr/sbin/build-locale-archive
+$GCC -Os -static -o tzdata-update tzdata-update.c \
+  -L../build-%{nptl_target_cpu}-linuxnptl
+install -m 700 tzdata-update $RPM_BUILD_ROOT/usr/sbin/tzdata-update
 cd ..
 
 # the last bit: more documentation
@@ -937,6 +943,8 @@ touch $RPM_BUILD_ROOT/%{_prefix}/lib/locale/locale-archive
 
 %post common -p /usr/sbin/build-locale-archive
 
+%triggerin common -p /usr/sbin/tzdata-update -- tzdata
+
 %post devel
 /sbin/install-info %{_infodir}/libc.info.gz %{_infodir}/dir
 
@@ -1051,6 +1059,7 @@ rm -f *.filelist*
 %attr(0600,root,root) %verify(not md5 size mtime) %ghost %config(missingok,noreplace) /var/db/nscd/passwd
 %attr(0600,root,root) %verify(not md5 size mtime) %ghost %config(missingok,noreplace) /var/db/nscd/group
 %attr(0600,root,root) %verify(not md5 size mtime) %ghost %config(missingok,noreplace) /var/db/nscd/hosts
+%ghost %config(missingok,noreplace) /etc/sysconfig/nscd
 %endif
 
 %if "%{_enable_debug_packages}" == "1"
@@ -1074,6 +1083,23 @@ rm -f *.filelist*
 %endif
 
 %changelog
+* Mon Sep 12 2005 Jakub Jelinek <jakub@redhat.com> 2.3.90-12
+- update from CVS
+  - netgrp handling fixes (#167728)
+  - fix memory leak in setlocale (BZ#1318)
+  - fix hwcaps computation
+  - several regex portability improvements (#167019)
+  - hypotf fix
+  - fix *printf return code if underlying write fails (BZ#1146)
+  - PPC64 dl{,v}sym fixes for new ABI .opd symbols
+- fix calloc with MALLOC_PERTURB_ in environment on 64-bit architectures
+  (#166719)
+- source /etc/sysconfig/nscd (if it exists) in /etc/rc.d/init.d/nscd
+  (#167083)
+- add %%triggerin for tzdata to glibc-common, so that tzdata updates
+  update /etc/localtime and /var/spool/postfix/etc/localtime if they
+  exist (#167787)
+
 * Mon Aug 29 2005 Jakub Jelinek <jakub@redhat.com> 2.3.90-11
 - FUTEX_WAKE_OP support to speed up pthread_cond_signal
 
diff --git a/fedora/tzdata-update.c b/fedora/tzdata-update.c
new file mode 100644
index 0000000000..38539817d3
--- /dev/null
+++ b/fedora/tzdata-update.c
@@ -0,0 +1,577 @@
+#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)
+{
+  size_t n = len;
+  ssize_t ret;
+  do
+    {
+      ret = INTERNAL_SYSCALL (read, err, 3, fd, buf, n);
+      if (ret <= 0)
+	break;
+      buf = (char *) buf + ret;
+      n -= ret;
+    }
+  while (n > 0);
+  return ret < 0 ? ret : len - n;
+}
+
+ssize_t
+writeall (int fd, const void *buf, size_t len)
+{
+  size_t n = len;
+  ssize_t ret;
+  do
+    {
+      ret = INTERNAL_SYSCALL (write, err, 3, fd, buf, n);
+      if (ret <= 0)
+	break;
+      buf = (const char *) buf + ret;
+      n -= ret;
+    }
+  while (n > 0);
+  return ret < 0 ? ret : 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 (void)
+{
+  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;
+}
diff --git a/nscd/nscd.init b/nscd/nscd.init
index a0074b99e5..1fba72f5c3 100644
--- a/nscd/nscd.init
+++ b/nscd/nscd.init
@@ -9,6 +9,7 @@
 #		slow naming services like NIS, NIS+, LDAP, or hesiod.
 # processname: /usr/sbin/nscd
 # config: /etc/nscd.conf
+# config: /etc/sysconfig/nscd
 #
 ### BEGIN INIT INFO
 # Provides: nscd
@@ -28,20 +29,8 @@
 # Source function library.
 . /etc/init.d/functions
 
-# nscd does not run on any kernel lower than 2.2.0 because of threading
-# problems, so we require that in first place.
-case $(uname -r) in
-    2.[2-9].*)
-	# this is okay
-	;;
-    [3-9]*)
-	# these are of course also okay
-	;;
-    *)
-	#this is not
-	exit 1
-	;;
-esac
+# Source an auxiliary options file if we have one, and pick up NSCD_OPTIONS.
+[ -r /etc/sysconfig/nscd ] && . /etc/sysconfig/nscd
 
 RETVAL=0
 prog=nscd
@@ -57,7 +46,7 @@ start () {
 #   	fi
 #   done
     echo -n $"Starting $prog: "
-    daemon /usr/sbin/nscd $secure
+    daemon /usr/sbin/nscd $secure $NSCD_OPTIONS
     RETVAL=$?
     echo
     [ $RETVAL -eq 0 ] && touch /var/lock/subsys/nscd