27 files changed, 543 insertions, 179 deletions

diff --git a/ChangeLog b/ChangeLog
index 80b617c381..bdbbf4b114 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,31 @@
 2003-07-14  Ulrich Drepper  <drepper@redhat.com>
 
+	More cancellation handling fixups.
+	* sysdeps/unix/sysv/linux/not-cancel.h: Add waitpid_not_cancel.
+	* sysdeps/generic/not-cancel.h: Likewise.
+	* catgets/open_catalog.c: Use not-cancelable syscalls.
+	* time/Makefile (CFLAGS-getdate.c): Add -fexceptions.
+	* sysdeps/unix/sysv/linux/llseek.c: Must not be cancelable.
+	* sysdeps/unix/syscalls.list: Don't mark lseek as cancelable.
+	* dlfcn/dlfcn.h: Mark dlopen with __THROW again.
+	* io/fcntl.h: Don't mark posix_fallocate with __THROW.
+	* libio/fileops.c: Use not-cancelable syscalls for fclose.
+	* libio/iopopen.c: Use no-cancelable syscalls.
+	* libio/stdio.h: Mark popen and pclose with __THROW again.
+	* misc/Makefile (CFLAGS-syslog.c): Add -fexceptions.
+	* misc/syslog.c: Fix locking and cancellation cleanup handling.
+	* posix/unistd.h: Mark ttyname and ttyname_r again with __THROW.
+	* stdio-common/Makefile (CFLAGS-tmpfile.c, CFLAGS-tmpfile64.c,
+	CFLAGS-tempname.c): Add -fexceptions.
+	* stdlib/Makefile (CFLAGS-mkstemp.c): Add -fexceptions.
+	* string/string.h: Mark strerror and strerror_r with _THROW again.
+	* sysdeps/generic/unwind.inc: New file.  Copied from gcc.
+	* sysdeps/generic/unwind-dw2.c: Update from gcc version.  Remove
+	#ifs since we now need all the code compiled.
+	* sysdeps/posix/spawni.c: Use close_not_cancel instead of close.
+	* sysdeps/unix/closedir.c: Use not-cancelable syscalls.
+	* sysdeps/unix/opendir.c: Likewise.
+
 	* iconvdata/Makefile (modules): Add CP932 and EUC-JP-MS.
 	Add rule for EUC-JP-MS dependency.
 	* iconvdata/cp932.c: New file.
diff --git a/catgets/open_catalog.c b/catgets/open_catalog.c
index 674a0c1bf0..8c563b2e26 100644
--- a/catgets/open_catalog.c
+++ b/catgets/open_catalog.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996-2000, 2001, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2000, 2001, 2002, 2003 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper, <drepper@gnu.org>.
 
@@ -30,6 +30,7 @@
 #include <sys/stat.h>
 
 #include "catgetsinfo.h"
+#include <not-cancel.h>
 
 
 #define SWAPU32(w) bswap_32 (w)
@@ -49,7 +50,7 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
   int result = -1;
 
   if (strchr (cat_name, '/') != NULL || nlspath == NULL)
-    fd = __open (cat_name, O_RDONLY);
+    fd = open_not_cancel_2 (cat_name, O_RDONLY);
   else
     {
       const char *run_nlspath = nlspath;
@@ -177,7 +178,7 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
 
 	  if (bufact != 0)
 	    {
-	      fd = __open (buf, O_RDONLY);
+	      fd = open_not_cancel_2 (buf, O_RDONLY);
 	      if (fd >= 0)
 		break;
 	    }
@@ -233,8 +234,8 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
       /* Save read, handle partial reads.  */
       do
 	{
-	  size_t now = __read (fd, (((char *) catalog->file_ptr)
-				    + (st.st_size - todo)), todo);
+	  size_t now = read_not_cancel (fd, (((char *) catalog->file_ptr)
+					     + (st.st_size - todo)), todo);
 	  if (now == 0 || now == (size_t) -1)
 	    {
 #ifdef EINTR
@@ -324,7 +325,7 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
 
   /* Release the lock again.  */
  close_unlock_return:
-  __close (fd);
+  close_not_cancel_no_status (fd);
 
   return result;
 }
diff --git a/dlfcn/dlfcn.h b/dlfcn/dlfcn.h
index ad51bb9233..9d8ee0d6d1 100644
--- a/dlfcn/dlfcn.h
+++ b/dlfcn/dlfcn.h
@@ -45,11 +45,8 @@
 __BEGIN_DECLS
 
 /* Open the shared object FILE and map it in; return a handle that can be
-   passed to `dlsym' to get symbol values from it.
-
-   This function is a possible cancellation point and therefore not
-   marked with __THROW.  */
-extern void *dlopen (__const char *__file, int __mode);
+   passed to `dlsym' to get symbol values from it.  */
+extern void *dlopen (__const char *__file, int __mode) __THROW;
 
 /* Unmap and close a shared object opened by `dlopen'.
    The handle cannot be used again after calling `dlclose'.  */
diff --git a/io/fcntl.h b/io/fcntl.h
index 8131c24d88..5dbde77bf4 100644
--- a/io/fcntl.h
+++ b/io/fcntl.h
@@ -151,21 +151,23 @@ extern int posix_fadvise64 (int __fd, __off64_t __offset, size_t __len,
 # endif
 
 
-/* Reserve storage for the data of the file associated with FD.  */
+/* Reserve storage for the data of the file associated with FD.
+
+   This function is a possible cancellation points and therefore not
+   marked with __THROW.  */
 # ifndef __USE_FILE_OFFSET64
-extern int posix_fallocate (int __fd, __off_t __offset, size_t __len) __THROW;
+extern int posix_fallocate (int __fd, __off_t __offset, size_t __len);
 # else
 # ifdef __REDIRECT
 extern int __REDIRECT (posix_fallocate, (int __fd, __off64_t __offset,
-					 size_t __len) __THROW,
+					 size_t __len),
 		       posix_fallocate64);
 # else
 #  define posix_fallocate posix_fallocate64
 # endif
 # endif
 # ifdef __USE_LARGEFILE64
-extern int posix_fallocate64 (int __fd, __off64_t __offset, size_t __len)
-     __THROW;
+extern int posix_fallocate64 (int __fd, __off64_t __offset, size_t __len);
 # endif
 #endif
 
diff --git a/libio/fileops.c b/libio/fileops.c
index aae02f001c..0faf01f09f 100644
--- a/libio/fileops.c
+++ b/libio/fileops.c
@@ -47,6 +47,7 @@
 # include "../iconv/gconv_charset.h"
 # include "../iconv/gconv_int.h"
 # include <shlib-compat.h>
+# include <not-cancel.h>
 #endif
 #ifndef errno
 extern int errno;
@@ -1240,14 +1241,18 @@ _IO_file_close_mmap (fp)
   /* In addition to closing the file descriptor we have to unmap the file.  */
   (void) __munmap (fp->_IO_buf_base, fp->_IO_buf_end - fp->_IO_buf_base);
   fp->_IO_buf_base = fp->_IO_buf_end = NULL;
-  return close (fp->_fileno);
+  /* Cancelling close should be avoided if possible since it leaves an
+     unrecoverable state behind.  */
+  return close_not_cancel (fp->_fileno);
 }
 
 int
 _IO_file_close (fp)
      _IO_FILE *fp;
 {
-  return close (fp->_fileno);
+  /* Cancelling close should be avoided if possible since it leaves an
+     unrecoverable state behind.  */
+  return close_not_cancel (fp->_fileno);
 }
 INTDEF(_IO_file_close)
 
diff --git a/libio/iopopen.c b/libio/iopopen.c
index 80a97f1b64..63094389d7 100644
--- a/libio/iopopen.c
+++ b/libio/iopopen.c
@@ -39,6 +39,7 @@
 #ifdef _LIBC
 # include <unistd.h>
 # include <shlib-compat.h>
+# include <not-cancel.h>
 #endif
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -74,7 +75,7 @@ extern int _IO_dup2 __P ((int fd, int fd2));
 
 #ifndef _IO_waitpid
 #ifdef _LIBC
-#define _IO_waitpid __waitpid
+#define _IO_waitpid waitpid_not_cancel
 #else
 #define _IO_waitpid waitpid
 #endif
@@ -89,7 +90,7 @@ extern int _IO_dup2 __P ((int fd, int fd2));
 
 #ifndef _IO_close
 #ifdef _LIBC
-#define _IO_close __close
+#define _IO_close close_not_cancel
 #else
 #define _IO_close close
 #endif
diff --git a/libio/stdio.h b/libio/stdio.h
index f98d38ff32..88ef61b029 100644
--- a/libio/stdio.h
+++ b/libio/stdio.h
@@ -757,17 +757,11 @@ extern int fileno_unlocked (FILE *__stream) __THROW;
 
 #if (defined __USE_POSIX2 || defined __USE_SVID  || defined __USE_BSD || \
      defined __USE_MISC)
-/* Create a new stream connected to a pipe running the given command.
+/* Create a new stream connected to a pipe running the given command.  */
+extern FILE *popen (__const char *__command, __const char *__modes) __THROW;
 
-   This function is a possible cancellation point and therefore not
-   marked with __THROW.  */
-extern FILE *popen (__const char *__command, __const char *__modes);
-
-/* Close a stream opened by popen and return the status of its child.
-
-   This function is a possible cancellation point and therefore not
-   marked with __THROW.  */
-extern int pclose (FILE *__stream);
+/* Close a stream opened by popen and return the status of its child.  */
+extern int pclose (FILE *__stream) __THROW;
 #endif
 
 
diff --git a/misc/Makefile b/misc/Makefile
index 2685e908ee..e8828109a7 100644
--- a/misc/Makefile
+++ b/misc/Makefile
@@ -81,6 +81,7 @@ CFLAGS-pselect.c = -fexceptions
 CFLAGS-readv.c = -fexceptions -fasynchronous-unwind-tables
 CFLAGS-writev.c = -fexceptions -fasynchronous-unwind-tables
 CFLAGS-usleep.c = -fexceptions
+CFLAGS-syslog.c = -fexceptions
 
 include ../Rules
 
diff --git a/misc/syslog.c b/misc/syslog.c
index c1fdf5b6b9..d84cbbf47f 100644
--- a/misc/syslog.c
+++ b/misc/syslog.c
@@ -41,6 +41,7 @@ static char sccsid[] = "@(#)syslog.c	8.4 (Berkeley) 3/18/94";
 #include <fcntl.h>
 #include <paths.h>
 #include <stdio.h>
+#include <stdio_ext.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
@@ -74,9 +75,27 @@ __libc_lock_define_initialized (static, syslog_lock)
 static void openlog_internal(const char *, int, int) internal_function;
 static void closelog_internal(void);
 static void sigpipe_handler (int);
-#ifdef _LIBC_REENTRANT
-static void cancel_handler (void *);
-#endif
+
+
+struct cleanup_arg
+{
+  void *buf;
+  struct sigaction *oldaction;
+};
+
+static void
+cancel_handler (void *ptr)
+{
+  /* Restore the old signal handler.  */
+  struct cleanup_arg *clarg = (struct cleanup_arg *) ptr;
+
+  if (clarg != NULL && clarg->oldaction != NULL)
+    __sigaction (SIGPIPE, clarg->oldaction, NULL);
+
+  /* Free the lock.  */
+  __libc_lock_unlock (syslog_lock);
+}
+
 
 /*
  * syslog, vsyslog --
@@ -118,7 +137,6 @@ vsyslog(pri, fmt, ap)
 	size_t bufsize = 0;
 	size_t prioff, msgoff;
  	struct sigaction action, oldaction;
-	struct sigaction *oldaction_ptr = NULL;
  	int sigpipe;
 	int saved_errno = errno;
 	char failbuf[3 * sizeof (pid_t) + sizeof "out of memory []"];
@@ -165,6 +183,7 @@ vsyslog(pri, fmt, ap)
 	  }
 	else
 	  {
+	    __fsetlocking (f, FSETLOCKING_BYCALLER);
 	    prioff = fprintf (f, "<%d>", pri);
 	    (void) time (&now);
 #ifdef USE_IN_LIBIO
@@ -182,9 +201,12 @@ vsyslog(pri, fmt, ap)
 	    if (LogTag != NULL)
 	      fputs_unlocked (LogTag, f);
 	    if (LogStat & LOG_PID)
-	      fprintf (f, "[%d]", __getpid ());
+	      fprintf (f, "[%d]", (int) __getpid ());
 	    if (LogTag != NULL)
-	      putc_unlocked (':', f), putc_unlocked (' ', f);
+	      {
+		putc_unlocked (':', f);
+		putc_unlocked (' ', f);
+	      }
 
 	    /* Restore errno for %m format.  */
 	    __set_errno (saved_errno);
@@ -212,16 +234,22 @@ vsyslog(pri, fmt, ap)
 		    v->iov_base = (char *) "\n";
 		    v->iov_len = 1;
 		  }
+
+		__libc_cleanup_push (free, buf);
+
+		/* writev is a cancellation point.  */
 		(void)__writev(STDERR_FILENO, iov, v - iov + 1);
+
+		__libc_cleanup_pop (0);
 	}
 
-#ifdef _LIBC_REENTRANT
 	/* Prepare for multiple users.  We have to take care: open and
 	   write are cancellation points.  */
-	__libc_cleanup_region_start (1, (void (*) (void *)) cancel_handler,
-				     &oldaction_ptr);
+	struct cleanup_arg clarg;
+	clarg.buf = buf;
+	clarg.oldaction = NULL;
+	__libc_cleanup_push (cancel_handler, &clarg);
 	__libc_lock_lock (syslog_lock);
-#endif
 
 	/* Prepare for a broken connection.  */
  	memset (&action, 0, sizeof (action));
@@ -229,7 +257,7 @@ vsyslog(pri, fmt, ap)
  	sigemptyset (&action.sa_mask);
  	sigpipe = __sigaction (SIGPIPE, &action, &oldaction);
 	if (sigpipe == 0)
-	  oldaction_ptr = &oldaction;
+	  clarg.oldaction = &oldaction;
 
 	/* Get connected, output the message to the local logger. */
 	if (!connected)
@@ -271,11 +299,9 @@ vsyslog(pri, fmt, ap)
 	if (sigpipe == 0)
 		__sigaction (SIGPIPE, &oldaction, (struct sigaction *) NULL);
 
-#ifdef _LIBC_REENTRANT
 	/* End of critical section.  */
-	__libc_cleanup_region_end (0);
+	__libc_cleanup_pop (0);
 	__libc_lock_unlock (syslog_lock);
-#endif
 
 	free (buf);
 }
@@ -283,6 +309,7 @@ libc_hidden_def (vsyslog)
 
 static struct sockaddr SyslogAddr;	/* AF_UNIX address of local logger */
 
+
 static void
 internal_function
 openlog_internal(const char *ident, int logstat, int logfac)
@@ -312,8 +339,9 @@ openlog_internal(const char *ident, int logstat, int logfac)
 			    == -1)
 			{
 				int saved_errno = errno;
-				(void)__close(LogFile);
+				int fd = LogFile;
 				LogFile = -1;
+				(void)__close(fd);
 				if (LogType == SOCK_DGRAM
 				    && saved_errno == EPROTOTYPE)
 				{
@@ -329,28 +357,16 @@ openlog_internal(const char *ident, int logstat, int logfac)
 	}
 }
 
-
-static void
-log_cleanup (void *arg)
-{
-  __libc_lock_unlock (syslog_lock);
-}
-
 void
 openlog (const char *ident, int logstat, int logfac)
 {
-#ifdef _LIBC_REENTRANT
-  /* Protect against multiple users.  */
-  __libc_cleanup_region_start (1, log_cleanup, NULL);
+  /* Protect against multiple users and cancellation.  */
+  __libc_cleanup_push (cancel_handler, NULL);
   __libc_lock_lock (syslog_lock);
-#endif
 
   openlog_internal (ident, logstat, logfac);
 
-#ifdef _LIBC_REENTRANT
-  /* Free the lock.  */
-  __libc_cleanup_region_end (1);
-#endif
+  __libc_cleanup_pop (1);
 }
 
 static void
@@ -373,36 +389,17 @@ closelog_internal()
 void
 closelog ()
 {
-#ifdef _LIBC_REENTRANT
-  /* Protect against multiple users.  */
-  __libc_cleanup_region_start (1, log_cleanup, NULL);
+  /* Protect against multiple users and cancellation.  */
+  __libc_cleanup_push (cancel_handler, NULL);
   __libc_lock_lock (syslog_lock);
-#endif
 
   closelog_internal ();
   LogTag = NULL;
   LogType = SOCK_DGRAM; /* this is the default */
 
-#ifdef _LIBC_REENTRANT
-  /* Free the lock.  */
-  __libc_cleanup_region_end (1);
-#endif
-}
-
-#ifdef _LIBC_REENTRANT
-static void
-cancel_handler (void *ptr)
-{
-  /* Restore the old signal handler.  */
-  struct sigaction *oldaction = *((struct sigaction **) ptr);
-
-  if (oldaction != (struct sigaction *) NULL)
-    __sigaction (SIGPIPE, oldaction, (struct sigaction *) NULL);
-
   /* Free the lock.  */
-  __libc_lock_unlock (syslog_lock);
+  __libc_cleanup_pop (1);
 }
-#endif
 
 /* setlogmask -- set the log mask level */
 int
diff --git a/nptl/Banner b/nptl/Banner
index 80e09ac5a5..fe38739940 100644
--- a/nptl/Banner
+++ b/nptl/Banner
@@ -1 +1 @@
-NPTL 0.52 by Ulrich Drepper
+NPTL 0.53 by Ulrich Drepper
diff --git a/nptl/ChangeLog b/nptl/ChangeLog
index 7594e5fdf3..804968a8c5 100644
--- a/nptl/ChangeLog
+++ b/nptl/ChangeLog
@@ -1,3 +1,7 @@
+2003-07-15  Ulrich Drepper  <drepper@redhat.com>
+
+	* tst-tcancel-wrappers.sh: lseek and llseek are not cancelation points.
+
 2003-07-14  Ulrich Drepper  <drepper@redhat.com>
 
 	* sysdeps/pthread/configure.in: Require CFI directives also for
diff --git a/nptl/sysdeps/pthread/configure b/nptl/sysdeps/pthread/configure
index 00a58843cc..d10b23dee8 100755
--- a/nptl/sysdeps/pthread/configure
+++ b/nptl/sysdeps/pthread/configure
@@ -6,7 +6,7 @@ echo "$as_me: error: compiler support for __thread is required" >&2;}
    { (exit 1); exit 1; }; }
 fi
 
-if test "sx$libc_cv_asm_cfi_directives" != xyes; then
+if test "x$libc_cv_asm_cfi_directives" != xyes; then
     case "$base_machine" in
     i386 | x86_64 | powerpc | s390)
       { { echo "$as_me:$LINENO: error: CFI directive support in assembler is required" >&5
diff --git a/posix/unistd.h b/posix/unistd.h
index 6fdfa0d937..1e28ba26a0 100644
--- a/posix/unistd.h
+++ b/posix/unistd.h
@@ -699,18 +699,12 @@ extern __pid_t vfork (void) __THROW;
 
 
 /* Return the pathname of the terminal FD is open on, or NULL on errors.
-   The returned storage is good only until the next call to this function.
-
-   This function is a possible cancellation points and therefore not
-   marked with __THROW.  */
-extern char *ttyname (int __fd);
+   The returned storage is good only until the next call to this function.  */
+extern char *ttyname (int __fd) __THROW;
 
 /* Store at most BUFLEN characters of the pathname of the terminal FD is
-   open on in BUF.  Return 0 on success, otherwise an error number.
-
-   This function is a possible cancellation points and therefore not
-   marked with __THROW.  */
-extern int ttyname_r (int __fd, char *__buf, size_t __buflen);
+   open on in BUF.  Return 0 on success, otherwise an error number.  */
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen) __THROW;
 
 /* Return 1 if FD is a valid descriptor associated
    with a terminal, zero if not.  */
diff --git a/stdio-common/Makefile b/stdio-common/Makefile
index f5ef190850..ecc6865d11 100644
--- a/stdio-common/Makefile
+++ b/stdio-common/Makefile
@@ -81,6 +81,10 @@ CFLAGS-scanf4.c = -Wno-format
 CFLAGS-scanf7.c = -Wno-format
 CFLAGS-tst-printfsz.c = -Wno-format
 
+CFLAGS-tmpfile.c = -fexceptions
+CFLAGS-tmpfile64.c = -fexceptions
+CFLAGS-tempname.c = -fexceptions
+
 tst-sscanf-ENV = LOCPATH=$(common-objpfx)localedata
 tst-swprintf-ENV = LOCPATH=$(common-objpfx)localedata
 test-vfprintf-ENV = LOCPATH=$(common-objpfx)localedata
diff --git a/stdlib/Makefile b/stdlib/Makefile
index 8c3f501f32..7b4df2ea6f 100644
--- a/stdlib/Makefile
+++ b/stdlib/Makefile
@@ -83,6 +83,7 @@ CFLAGS-bsearch.c = $(exceptions)
 CFLAGS-msort.c = $(exceptions)
 CFLAGS-qsort.c = $(exceptions)
 CFLAGS-system.c = -fexceptions
+CFLAGS-mkstemp.c = -fexceptions
 
 include ../Makeconfig
 
diff --git a/string/string.h b/string/string.h
index ecfc4c7060..108d54da4e 100644
--- a/string/string.h
+++ b/string/string.h
@@ -239,19 +239,13 @@ extern size_t strnlen (__const char *__string, size_t __maxlen)
 
 
 __BEGIN_NAMESPACE_STD
-/* Return a string describing the meaning of the `errno' code in ERRNUM.
-
-   This function is a possible cancellation points and therefore not
-   marked with __THROW.  */
-extern char *strerror (int __errnum);
+/* Return a string describing the meaning of the `errno' code in ERRNUM.  */
+extern char *strerror (int __errnum) __THROW;
 __END_NAMESPACE_STD
 #if defined __USE_XOPEN2K || defined __USE_MISC
 /* Reentrant version of `strerror'.  If a temporary buffer is required, at
-   most BUFLEN bytes of BUF will be used.
-
-   This function is a possible cancellation points and therefore not
-   marked with __THROW.  */
-extern char *strerror_r (int __errnum, char *__buf, size_t __buflen);
+   most BUFLEN bytes of BUF will be used.  */
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) __THROW;
 #endif
 
 /* We define this function always since `bzero' is sometimes needed when
diff --git a/sysdeps/generic/not-cancel.h b/sysdeps/generic/not-cancel.h
index b87c16034b..2bea378b44 100644
--- a/sysdeps/generic/not-cancel.h
+++ b/sysdeps/generic/not-cancel.h
@@ -19,8 +19,12 @@
    02111-1307 USA.  */
 
 /* By default we have none.  Map the name to the normal functions.  */
-#define open_not_cancel(name, flags, mode...) \
-  __libc_open (name, flags, ##mode)
+#define open_not_cancel(name, flags, mode) \
+  __libc_open (name, flags, mode)
+#define open_not_cancel_2(name, flags) \
+  __libc_open (name, flags)
+#define close_not_cancel(fd) \
+  __close (fd)
 #define close_not_cancel_no_status(fd) \
   (void) __close (fd)
 #define read_not_cancel(fd, buf, n) \
@@ -29,3 +33,5 @@
   __write (fd, buf, n)
 #define writev_not_cancel_no_status(fd, iov, n) \
   (void) __writev (fd, iov, n)
+# define waitpid_not_cancel(pid, stat_loc, options) \
+  __waitpid (pid, stat_loc, options)
diff --git a/sysdeps/generic/unwind-dw2.c b/sysdeps/generic/unwind-dw2.c
index 8e175466ab..89f9d59f23 100644
--- a/sysdeps/generic/unwind-dw2.c
+++ b/sysdeps/generic/unwind-dw2.c
@@ -72,10 +72,8 @@ struct _Unwind_Context
   _Unwind_Word args_size;
 };
 
-#ifndef _LIBC
 /* Byte size of every register managed by these routines.  */
 static unsigned char dwarf_reg_size_table[DWARF_FRAME_REGISTERS];
-#endif
 
 
 /* The result of interpreting the frame unwind info for a frame.
@@ -184,7 +182,7 @@ _Unwind_GetGR (struct _Unwind_Context *context, int index)
 _Unwind_Word
 _Unwind_GetCFA (struct _Unwind_Context *context)
 {
-  return (_Unwind_Word) context->cfa;
+  return (_Unwind_Ptr) context->cfa;
 }
 
 /* Overwrite the saved value for register REG in CONTEXT with VAL.  */
@@ -323,7 +321,7 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
   return ret ? ret : p;
 }
 
-#ifndef _LIBC
+
 /* Decode a DW_OP stack program.  Return the top of stack.  Push INITIAL
    onto the stack to start.  */
 
@@ -713,7 +711,7 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
       /* Most things push a result value.  */
       if ((size_t) stack_elt >= sizeof(stack)/sizeof(*stack))
 	abort ();
-      stack[++stack_elt] = result;
+      stack[stack_elt++] = result;
     no_push:;
     }
 
@@ -723,7 +721,7 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
     abort ();
   return stack[stack_elt];
 }
-#endif
+
 
 /* Decode DWARF 2 call frame information. Takes pointers the
    instruction sequence to decode, current register information and
@@ -863,17 +861,17 @@ execute_cfa_program (const unsigned char *insn_ptr,
 	  break;
 
 	case DW_CFA_def_cfa_expression:
-	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
 	  fs->cfa_exp = insn_ptr;
 	  fs->cfa_how = CFA_EXP;
+	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
 	  insn_ptr += utmp;
 	  break;
 
 	case DW_CFA_expression:
 	  insn_ptr = read_uleb128 (insn_ptr, &reg);
-	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
 	  fs->regs.reg[reg].how = REG_SAVED_EXP;
 	  fs->regs.reg[reg].loc.exp = insn_ptr;
+	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
 	  insn_ptr += utmp;
 	  break;
 
@@ -1061,8 +1059,6 @@ __frame_state_for (void *pc_target, struct frame_state *state_in)
   return state_in;
 }
 
-#ifndef _LIBC
-
 static void
 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
 {
@@ -1070,34 +1066,48 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
   void *cfa;
   long i;
 
+#ifdef EH_RETURN_STACKADJ_RTX
+  /* Special handling here: Many machines do not use a frame pointer,
+     and track the CFA only through offsets from the stack pointer from
+     one frame to the next.  In this case, the stack pointer is never
+     stored, so it has no saved address in the context.  What we do
+     have is the CFA from the previous stack frame.
+
+     In very special situations (such as unwind info for signal return),
+     there may be location expressions that use the stack pointer as well.
+
+     Do this conditionally for one frame.  This allows the unwind info
+     for one frame to save a copy of the stack pointer from the previous
+     frame, and be able to use much easier CFA mechanisms to do it.
+     Always zap the saved stack pointer value for the next frame; carrying
+     the value over from one frame to another doesn't make sense.  */
+
+  _Unwind_Word tmp_sp;
+
+  if (!orig_context.reg[__builtin_dwarf_sp_column ()])
+    {
+      tmp_sp = (_Unwind_Ptr) context->cfa;
+      orig_context.reg[__builtin_dwarf_sp_column ()] = &tmp_sp;
+    }
+  context->reg[__builtin_dwarf_sp_column ()] = NULL;
+#endif
+
   /* Compute this frame's CFA.  */
   switch (fs->cfa_how)
     {
     case CFA_REG_OFFSET:
-      /* Special handling here: Many machines do not use a frame pointer,
-	 and track the CFA only through offsets from the stack pointer from
-	 one frame to the next.  In this case, the stack pointer is never
-	 stored, so it has no saved address in the context.  What we do
-	 have is the CFA from the previous stack frame.  */
-      if (context->reg[fs->cfa_reg] == NULL)
-	cfa = context->cfa;
-      else
-	cfa = (void *) (_Unwind_Ptr) _Unwind_GetGR (context, fs->cfa_reg);
+      cfa = (void *) (_Unwind_Ptr) _Unwind_GetGR (&orig_context, fs->cfa_reg);
       cfa += fs->cfa_offset;
       break;
 
     case CFA_EXP:
-      /* ??? No way of knowing what register number is the stack pointer
-	 to do the same sort of handling as above.  Assume that if the
-	 CFA calculation is so complicated as to require a stack program
-	 that this will not be a problem.  */
       {
 	const unsigned char *exp = fs->cfa_exp;
 	_Unwind_Word len;
 
 	exp = read_uleb128 (exp, &len);
 	cfa = (void *) (_Unwind_Ptr)
-	  execute_stack_op (exp, exp + len, context, 0);
+	  execute_stack_op (exp, exp + len, &orig_context, 0);
 	break;
       }
 
@@ -1112,12 +1122,15 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
       {
       case REG_UNSAVED:
 	break;
+
       case REG_SAVED_OFFSET:
 	context->reg[i] = cfa + fs->regs.reg[i].loc.offset;
 	break;
+
       case REG_SAVED_REG:
 	context->reg[i] = orig_context.reg[fs->regs.reg[i].loc.reg];
 	break;
+
       case REG_SAVED_EXP:
 	{
 	  const unsigned char *exp = fs->regs.reg[i].loc.exp;
@@ -1169,6 +1182,7 @@ uw_init_context_1 (struct _Unwind_Context *context,
 {
   void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
   _Unwind_FrameState fs;
+  _Unwind_Word sp_slot;
 
   memset (context, 0, sizeof (struct _Unwind_Context));
   context->ra = ra;
@@ -1177,9 +1191,10 @@ uw_init_context_1 (struct _Unwind_Context *context,
     abort ();
 
   /* Force the frame state to use the known cfa value.  */
-  context->cfa = outer_cfa;
+  sp_slot = (_Unwind_Ptr) outer_cfa;
+  context->reg[__builtin_dwarf_sp_column ()] = &sp_slot;
   fs.cfa_how = CFA_REG_OFFSET;
-  fs.cfa_reg = 0;
+  fs.cfa_reg = __builtin_dwarf_sp_column ();
   fs.cfa_offset = 0;
 
   uw_update_context_1 (context, &fs);
@@ -1236,11 +1251,26 @@ uw_install_context_1 (struct _Unwind_Context *current,
 	memcpy (c, t, dwarf_reg_size_table[i]);
     }
 
-  /* We adjust SP by the difference between CURRENT and TARGET's CFA.  */
-  if (STACK_GROWS_DOWNWARD)
-    return target->cfa - current->cfa + target->args_size;
-  else
-    return current->cfa - target->cfa - target->args_size;
+#ifdef EH_RETURN_STACKADJ_RTX
+  {
+    void *target_cfa;
+
+    /* If the last frame records a saved stack pointer, use it.  */
+    if (target->reg[__builtin_dwarf_sp_column ()])
+      target_cfa = (void *)(_Unwind_Ptr)
+        _Unwind_GetGR (target, __builtin_dwarf_sp_column ());
+    else
+      target_cfa = target->cfa;
+
+    /* We adjust SP by the difference between CURRENT and TARGET's CFA.  */
+    if (STACK_GROWS_DOWNWARD)
+      return target_cfa - current->cfa + target->args_size;
+    else
+      return current->cfa - target_cfa - target->args_size;
+  }
+#else
+  return 0;
+#endif
 }
 
 static inline _Unwind_Ptr
@@ -1252,5 +1282,4 @@ uw_identify_context (struct _Unwind_Context *context)
 
 #include "unwind.inc"
 
-#endif /* _LIBC */
 #endif /* !USING_SJLJ_EXCEPTIONS */
diff --git a/sysdeps/generic/unwind.inc b/sysdeps/generic/unwind.inc
new file mode 100644
index 0000000000..7ec65e903b
--- /dev/null
+++ b/sysdeps/generic/unwind.inc
@@ -0,0 +1,309 @@
+/* Exception handling and frame unwind runtime interface routines. -*- C -*-
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   GCC is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+   License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+/* This is derived from the C++ ABI for IA-64.  Where we diverge
+   for cross-architecture compatibility are noted with "@@@".
+   This file is included from unwind-dw2.c or unwind-ia64.c.  */
+
+/* Subroutine of _Unwind_RaiseException also invoked from _Unwind_Resume.
+
+   Unwind the stack calling the personality routine to find both the
+   exception handler and intermediary cleanup code.  We'll only locate
+   the first such frame here.  Cleanup code will call back into
+   _Unwind_Resume and we'll continue Phase 2 there.  */
+
+static _Unwind_Reason_Code
+_Unwind_RaiseException_Phase2(struct _Unwind_Exception *exc,
+			      struct _Unwind_Context *context)
+{
+  _Unwind_Reason_Code code;
+
+  while (1)
+    {
+      _Unwind_FrameState fs;
+      int match_handler;
+
+      code = uw_frame_state_for (context, &fs);
+
+      /* Identify when we've reached the designated handler context.  */
+      match_handler = (uw_identify_context (context) == exc->private_2
+		       ? _UA_HANDLER_FRAME : 0);
+
+      if (code != _URC_NO_REASON)
+	/* Some error encountered.  Usually the unwinder doesn't
+	   diagnose these and merely crashes.  */
+	return _URC_FATAL_PHASE2_ERROR;
+
+      /* Unwind successful.  Run the personality routine, if any.  */
+      if (fs.personality)
+	{
+	  code = (*fs.personality) (1, _UA_CLEANUP_PHASE | match_handler,
+				    exc->exception_class, exc, context);
+	  if (code == _URC_INSTALL_CONTEXT)
+	    break;
+	  if (code != _URC_CONTINUE_UNWIND)
+	    return _URC_FATAL_PHASE2_ERROR;
+	}
+
+      /* Don't let us unwind past the handler context.  */
+      if (match_handler)
+	abort ();
+
+      uw_update_context (context, &fs);
+    }
+
+  return code;
+}
+
+/* Raise an exception, passing along the given exception object.  */
+#ifndef _LIBC
+_Unwind_Reason_Code
+_Unwind_RaiseException(struct _Unwind_Exception *exc)
+{
+  struct _Unwind_Context this_context, cur_context;
+  _Unwind_Reason_Code code;
+
+  /* Set up this_context to describe the current stack frame.  */
+  uw_init_context (&this_context);
+  cur_context = this_context;
+
+  /* Phase 1: Search.  Unwind the stack, calling the personality routine
+     with the _UA_SEARCH_PHASE flag set.  Do not modify the stack yet.  */
+  while (1)
+    {
+      _Unwind_FrameState fs;
+
+      /* Set up fs to describe the FDE for the caller of cur_context.  The
+	 first time through the loop, that means __cxa_throw.  */
+      code = uw_frame_state_for (&cur_context, &fs);
+
+      if (code == _URC_END_OF_STACK)
+	/* Hit end of stack with no handler found.  */
+	return _URC_END_OF_STACK;
+
+      if (code != _URC_NO_REASON)
+	/* Some error encountered.  Ususally the unwinder doesn't
+	   diagnose these and merely crashes.  */
+	return _URC_FATAL_PHASE1_ERROR;
+
+      /* Unwind successful.  Run the personality routine, if any.  */
+      if (fs.personality)
+	{
+	  code = (*fs.personality) (1, _UA_SEARCH_PHASE, exc->exception_class,
+				    exc, &cur_context);
+	  if (code == _URC_HANDLER_FOUND)
+	    break;
+	  else if (code != _URC_CONTINUE_UNWIND)
+	    return _URC_FATAL_PHASE1_ERROR;
+	}
+
+      /* Update cur_context to describe the same frame as fs.  */
+      uw_update_context (&cur_context, &fs);
+    }
+
+  /* Indicate to _Unwind_Resume and associated subroutines that this
+     is not a forced unwind.  Further, note where we found a handler.  */
+  exc->private_1 = 0;
+  exc->private_2 = uw_identify_context (&cur_context);
+
+  cur_context = this_context;
+  code = _Unwind_RaiseException_Phase2 (exc, &cur_context);
+  if (code != _URC_INSTALL_CONTEXT)
+    return code;
+
+  uw_install_context (&this_context, &cur_context);
+}
+#endif
+
+
+/* Subroutine of _Unwind_ForcedUnwind also invoked from _Unwind_Resume.  */
+
+static _Unwind_Reason_Code
+_Unwind_ForcedUnwind_Phase2(struct _Unwind_Exception *exc,
+			    struct _Unwind_Context *context)
+{
+  _Unwind_Stop_Fn stop = (_Unwind_Stop_Fn) (_Unwind_Ptr) exc->private_1;
+  void *stop_argument = (void *) (_Unwind_Ptr) exc->private_2;
+  _Unwind_Reason_Code code, stop_code;
+
+  while (1)
+    {
+      _Unwind_FrameState fs;
+      int action;
+
+      /* Set up fs to describe the FDE for the caller of cur_context.  */
+      code = uw_frame_state_for (context, &fs);
+      if (code != _URC_NO_REASON && code != _URC_END_OF_STACK)
+	return _URC_FATAL_PHASE2_ERROR;
+
+      /* Unwind successful.  */
+      action = _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE;
+      if (code == _URC_END_OF_STACK)
+	action |= _UA_END_OF_STACK;
+      stop_code = (*stop) (1, action, exc->exception_class, exc,
+			   context, stop_argument);
+      if (stop_code != _URC_NO_REASON)
+	return _URC_FATAL_PHASE2_ERROR;
+
+      /* Stop didn't want to do anything.  Invoke the personality
+	 handler, if applicable, to run cleanups.  */
+      if (code == _URC_END_OF_STACK)
+	break;
+
+      if (fs.personality)
+	{
+	  code = (*fs.personality) (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE,
+				    exc->exception_class, exc, context);
+	  if (code == _URC_INSTALL_CONTEXT)
+	    break;
+	  if (code != _URC_CONTINUE_UNWIND)
+	    return _URC_FATAL_PHASE2_ERROR;
+	}
+
+      /* Update cur_context to describe the same frame as fs.  */
+      uw_update_context (context, &fs);
+    }
+
+  return code;
+}
+
+
+/* Raise an exception for forced unwinding.  */
+#ifndef _LIBC
+_Unwind_Reason_Code
+_Unwind_ForcedUnwind (struct _Unwind_Exception *exc,
+		      _Unwind_Stop_Fn stop, void * stop_argument)
+{
+  struct _Unwind_Context this_context, cur_context;
+  _Unwind_Reason_Code code;
+
+  uw_init_context (&this_context);
+  cur_context = this_context;
+
+  exc->private_1 = (_Unwind_Ptr) stop;
+  exc->private_2 = (_Unwind_Ptr) stop_argument;
+
+  code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context);
+  if (code != _URC_INSTALL_CONTEXT)
+    return code;
+
+  uw_install_context (&this_context, &cur_context);
+}
+#endif
+
+
+/* Resume propagation of an existing exception.  This is used after
+   e.g. executing cleanup code, and not to implement rethrowing.  */
+
+void
+_Unwind_Resume (struct _Unwind_Exception *exc)
+{
+  struct _Unwind_Context this_context, cur_context;
+  _Unwind_Reason_Code code;
+
+  uw_init_context (&this_context);
+  cur_context = this_context;
+
+  /* Choose between continuing to process _Unwind_RaiseException
+     or _Unwind_ForcedUnwind.  */
+  if (exc->private_1 == 0)
+    code = _Unwind_RaiseException_Phase2 (exc, &cur_context);
+  else
+    code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context);
+
+  if (code != _URC_INSTALL_CONTEXT)
+    abort ();
+
+  uw_install_context (&this_context, &cur_context);
+}
+
+
+/* Resume propagation of an FORCE_UNWIND exception, or to rethrow
+   a normal exception that was handled.  */
+#ifndef _LIBC
+_Unwind_Reason_Code
+_Unwind_Resume_or_Rethrow (struct _Unwind_Exception *exc)
+{
+  struct _Unwind_Context this_context, cur_context;
+  _Unwind_Reason_Code code;
+
+  /* Choose between continuing to process _Unwind_RaiseException
+     or _Unwind_ForcedUnwind.  */
+  if (exc->private_1 == 0)
+    return _Unwind_RaiseException (exc);
+
+  uw_init_context (&this_context);
+  cur_context = this_context;
+
+  code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context);
+
+  if (code != _URC_INSTALL_CONTEXT)
+    abort ();
+
+  uw_install_context (&this_context, &cur_context);
+}
+#endif
+
+
+/* A convenience function that calls the exception_cleanup field.  */
+#ifndef _LIBC
+void
+_Unwind_DeleteException (struct _Unwind_Exception *exc)
+{
+  if (exc->exception_cleanup)
+    (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
+}
+#endif
+
+
+/* Perform stack backtrace through unwind data.  */
+#ifndef _LIBC
+_Unwind_Reason_Code
+_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument)
+{
+  struct _Unwind_Context context;
+  _Unwind_Reason_Code code;
+
+  uw_init_context (&context);
+
+  while (1)
+    {
+      _Unwind_FrameState fs;
+
+      /* Set up fs to describe the FDE for the caller of context.  */
+      code = uw_frame_state_for (&context, &fs);
+      if (code != _URC_NO_REASON && code != _URC_END_OF_STACK)
+	return _URC_FATAL_PHASE1_ERROR;
+
+      /* Call trace function.  */
+      if ((*trace) (&context, trace_argument) != _URC_NO_REASON)
+	return _URC_FATAL_PHASE1_ERROR;
+
+      /* We're done at end of stack.  */
+      if (code == _URC_END_OF_STACK)
+	break;
+
+      /* Update context to describe the same frame as fs.  */
+      uw_update_context (&context, &fs);
+    }
+
+  return code;
+}
+#endif
diff --git a/sysdeps/posix/spawni.c b/sysdeps/posix/spawni.c
index a072ab77b0..f65a0957a7 100644
--- a/sysdeps/posix/spawni.c
+++ b/sysdeps/posix/spawni.c
@@ -1,5 +1,5 @@
 /* Guts of POSIX spawn interface.  Generic POSIX.1 version.
-   Copyright (C) 2000,01,02 Free Software Foundation, Inc.
+   Copyright (C) 2000,01,02, 2003 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -25,6 +25,7 @@
 #include <string.h>
 #include <unistd.h>
 #include "spawn_int.h"
+#include <not-cancel.h>
 
 
 /* The Unix standard contains a long explanation of the way to signal
@@ -158,7 +159,7 @@ __spawni (pid_t *pid, const char *file,
 	  switch (action->tag)
 	    {
 	    case spawn_do_close:
-	      if (__close (action->action.close_action.fd) != 0)
+	      if (close_not_cancel (action->action.close_action.fd) != 0)
 		/* Signal the error.  */
 		_exit (SPAWN_ERROR);
 	      break;
diff --git a/sysdeps/unix/closedir.c b/sysdeps/unix/closedir.c
index c2fcbe549a..09deee7e85 100644
--- a/sysdeps/unix/closedir.c
+++ b/sysdeps/unix/closedir.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 1991,1993,1995,1996,1998,2002 Free Software Foundation, Inc.
+/* Copyright (C) 1991,1993,1995,1996,1998,2002,2003
+   Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -22,6 +23,8 @@
 #include <dirent.h>
 #include <unistd.h>
 #include <dirstream.h>
+#include <not-cancel.h>
+
 
 /* Close the directory stream DIRP.
    Return 0 if successful, -1 if not.  */
@@ -46,6 +49,6 @@ __closedir (DIR *dirp)
 
   free ((void *) dirp);
 
-  return __close (fd);
+  return close_not_cancel (fd);
 }
 weak_alias (__closedir, closedir)
diff --git a/sysdeps/unix/opendir.c b/sysdeps/unix/opendir.c
index dac1db5e55..5e7c6e54a6 100644
--- a/sysdeps/unix/opendir.c
+++ b/sysdeps/unix/opendir.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-1996,98,2000-2002 Free Software Foundation, Inc.
+/* Copyright (C) 1991-1996,98,2000-2002, 2003 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -28,6 +28,8 @@
 #include <stdio.h>
 
 #include <dirstream.h>
+#include <not-cancel.h>
+
 
 /* opendir() must not accidentally open something other than a directory.
    Some OS's have kernel support for that, some don't.  In the worst
@@ -50,11 +52,11 @@ static void
 tryopen_o_directory (void)
 {
   int serrno = errno;
-  int x = __open ("/dev/null", O_RDONLY|O_NDELAY|O_DIRECTORY);
+  int x = open_not_cancel_2 ("/dev/null", O_RDONLY|O_NDELAY|O_DIRECTORY);
 
   if (x >= 0)
     {
-      __close (x);
+      close_not_cancel_no_status (x);
       o_directory_works = -1;
     }
   else if (errno != ENOTDIR)
@@ -110,7 +112,7 @@ __opendir (const char *name)
 	 }
     }
 
-  fd = __open64 (name, O_RDONLY|O_NDELAY|EXTRA_FLAGS);
+  fd = open_not_cancel_2 (name, O_RDONLY|O_NDELAY|EXTRA_FLAGS|O_LARGEFILE);
   if (__builtin_expect (fd, 0) < 0)
     return NULL;
 
@@ -148,7 +150,7 @@ __opendir (const char *name)
   lose:
     {
       save_errno = errno;
-      (void) __close (fd);
+      close_not_cancel_no_status (fd);
       __set_errno (save_errno);
       return NULL;
     }
diff --git a/sysdeps/unix/syscalls.list b/sysdeps/unix/syscalls.list
index db83cee376..b6e178b727 100644
--- a/sysdeps/unix/syscalls.list
+++ b/sysdeps/unix/syscalls.list
@@ -24,7 +24,7 @@ getuid		-	getuid		Ei:	__getuid	getuid
 ioctl		-	ioctl		i:iiI	__ioctl		ioctl
 kill		-	kill		i:ii	__kill		kill
 link		-	link		i:ss	__link		link
-lseek		-	lseek		Ci:iii	__libc_lseek	__lseek lseek
+lseek		-	lseek		i:iii	__libc_lseek	__lseek lseek
 mkdir		-	mkdir		i:si	__mkdir		mkdir
 open		-	open		Ci:siv	__libc_open __open open
 profil		-	profil		i:piii	__profil	profil
diff --git a/sysdeps/unix/sysv/linux/kernel-features.h b/sysdeps/unix/sysv/linux/kernel-features.h
index e78c959529..f2e86305ab 100644
--- a/sysdeps/unix/sysv/linux/kernel-features.h
+++ b/sysdeps/unix/sysv/linux/kernel-features.h
@@ -351,7 +351,7 @@
    it was introduced in 2.6.0-test1 which unfortunately cannot be
    distinguished from 2.6.0.  */
 #if (__LINUX_KERNEL_VERSION >= 132427 && defined __i386__) \
-    || (__LINUX_KERNEL_VERSION >= 132609 && defined __alpha__) \
+    || (__LINUX_KERNEL_VERSION >= 132609 && defined __alpha__)
 # define __ASSUME_TGKILL	1
 #endif
 
diff --git a/sysdeps/unix/sysv/linux/llseek.c b/sysdeps/unix/sysv/linux/llseek.c
index 9ee340d476..dcfd9dde9a 100644
--- a/sysdeps/unix/sysv/linux/llseek.c
+++ b/sysdeps/unix/sysv/linux/llseek.c
@@ -1,5 +1,5 @@
 /* Long-long seek operation.
-   Copyright (C) 1996,1997,1998,1999,2000,2002 Free Software Foundation, Inc.
+   Copyright (C) 1996-2000,2002,2003 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -20,7 +20,7 @@
 #include <errno.h>
 #include <sys/types.h>
 
-#include <sysdep-cancel.h>
+#include <sysdep.h>
 #include <sys/syscall.h>
 
 extern int __syscall__llseek (int fd, off_t offset_hi, off_t offset_lo,
@@ -34,20 +34,9 @@ __llseek (int fd, loff_t offset, int whence)
 {
   loff_t retval;
 
-  if (SINGLE_THREAD_P)
-    return (loff_t) (INLINE_SYSCALL (_llseek, 5, fd, (off_t) (offset >> 32),
-				     (off_t) (offset & 0xffffffff),
-				     __ptrvalue (&retval), whence) ?: retval);
-
-  int oldtype = LIBC_CANCEL_ASYNC ();
-
-  int result = (loff_t) INLINE_SYSCALL (_llseek, 5, fd, (off_t) (offset >> 32),
-					(off_t) (offset & 0xffffffff),
-					__ptrvalue (&retval), whence);
-
-  LIBC_CANCEL_RESET (oldtype);
-
-  return (loff_t) result ?: retval;
+  return (loff_t) (INLINE_SYSCALL (_llseek, 5, fd, (off_t) (offset >> 32),
+				   (off_t) (offset & 0xffffffff),
+				   __ptrvalue (&retval), whence) ?: retval);
 }
 weak_alias (__llseek, llseek)
 strong_alias (__llseek, __libc_lseek64)
diff --git a/sysdeps/unix/sysv/linux/not-cancel.h b/sysdeps/unix/sysv/linux/not-cancel.h
index fcd0187a5a..c71641906d 100644
--- a/sysdeps/unix/sysv/linux/not-cancel.h
+++ b/sysdeps/unix/sysv/linux/not-cancel.h
@@ -21,33 +21,36 @@
 #include <sysdep.h>
 
 /* Uncancelable open.  */
-#ifdef INLINE_SYSCALL
-# define open_not_cancel(name, flags, mode) \
+#define open_not_cancel(name, flags, mode) \
    INLINE_SYSCALL (open, 3, (const char *) (name), (flags), (mode))
-#endif
+#define open_not_cancel_2(name, flags) \
+   INLINE_SYSCALL (open, 2, (const char *) (name), (flags))
 
 /* Uncancelable close.  */
-#ifdef INLINE_SYSCALL
-# define close_not_cancel_no_status(fd) \
+#define close_not_cancel(fd) \
+  INLINE_SYSCALL (close, 1, fd)
+#define close_not_cancel_no_status(fd) \
   (void) ({ INTERNAL_SYSCALL_DECL (err);				      \
 	    INTERNAL_SYSCALL (close, err, 1, (fd)); })
-#endif
 
 /* Uncancelable read.  */
-#ifdef INLINE_SYSCALL
-# define read_not_cancel(fd, buf, n) \
+#define read_not_cancel(fd, buf, n) \
   INLINE_SYSCALL (read, 3, (fd), (buf), (n))
-#endif
 
 /* Uncancelable write.  */
-#ifdef INLINE_SYSCALL
-# define write_not_cancel(fd, buf, n) \
+#define write_not_cancel(fd, buf, n) \
   INLINE_SYSCALL (write, 3, (fd), (buf), (n))
-#endif
 
 /* Uncancelable writev.  */
-#ifdef INLINE_SYSCALL
-# define writev_not_cancel_no_status(fd, iov, n) \
+#define writev_not_cancel_no_status(fd, iov, n) \
   (void) ({ INTERNAL_SYSCALL_DECL (err);				      \
 	    INTERNAL_SYSCALL (writev, err, 3, (fd), (iov), (n)); })
+
+/* Uncancelable waitpid.  */
+#ifdef __NR_waitpid
+# define waitpid_not_cancel(pid, stat_loc, options) \
+  INLINE_SYSCALL (waitpid, 3, pid, stat_loc, options)
+#else
+# define waitpid_not_cancel(pid, stat_loc, options) \
+  INLINE_SYSCALL (wait4, 4, pid, stat_loc, options, NULL)
 #endif
diff --git a/time/Makefile b/time/Makefile
index a7fe2f91c5..acd82d855e 100644
--- a/time/Makefile
+++ b/time/Makefile
@@ -44,6 +44,7 @@ tz-cflags = -DTZDIR='"$(zonedir)"' \
 
 CFLAGS-tzfile.c = $(tz-cflags)
 CFLAGS-tzset.c = $(tz-cflags)
+CFLAGS-getdate.c = -fexceptions
 
 # Don't warn about Y2k problem in strftime format string.
 CFLAGS-test_time.c = -Wno-format