From ce42435cab474eff0b7a8470d59bb484858a0863 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Thu, 4 Sep 2003 14:08:24 +0000 Subject: Update. * sysdeps/generic/utmp_file.c: Use not-cancelable syscalls all over the place. It would be allowed to have these fucntions as cancellation points but the cleanup would be ugly and a lot of work. * sysdeps/generic/not-cancel.h (fcntl_not_cancel): Define. * sysdeps/unix/sysv/linux/not-cancel.h (fcntl_not_cancel): Define. * include/fcntl.h (__fcntl_nocancel): Declare. * sysdeps/unix/sysv/linux/fcntl.c: New file. * sysdeps/unix/sysv/linux/i386/fcntl.c (__libc_fcntl): Only enable cancellation if absolutely needed. (__fcntl_nocancel): Define. * posix/unistd.h (gethostid): Remove __THROW. Clarify comment. * sysdeps/unix/sysv/linux/Makefile (CFLAGS-gethostid.c): Add -fexceptions. * sysdeps/unix/sysv/linux/gethostid.c (gethostid): Use extend_alloca. * resolv/res_init.c (__res_nclose): Use close_not_cancel_no_status instead of __close. --- sysdeps/generic/not-cancel.h | 2 + sysdeps/generic/utmp_file.c | 105 ++++++++++++++++++----------------- sysdeps/unix/sysv/linux/Makefile | 2 + sysdeps/unix/sysv/linux/fcntl.c | 60 ++++++++++++++++++++ sysdeps/unix/sysv/linux/gethostid.c | 7 +-- sysdeps/unix/sysv/linux/i386/fcntl.c | 18 +++--- sysdeps/unix/sysv/linux/not-cancel.h | 4 ++ 7 files changed, 135 insertions(+), 63 deletions(-) create mode 100644 sysdeps/unix/sysv/linux/fcntl.c (limited to 'sysdeps') diff --git a/sysdeps/generic/not-cancel.h b/sysdeps/generic/not-cancel.h index 2bea378b44..396e0421f9 100644 --- a/sysdeps/generic/not-cancel.h +++ b/sysdeps/generic/not-cancel.h @@ -33,5 +33,7 @@ __write (fd, buf, n) #define writev_not_cancel_no_status(fd, iov, n) \ (void) __writev (fd, iov, n) +#define fcntl_not_cancel(fd, cmd, val) \ + __fcntl (fd, cmd, val) # define waitpid_not_cancel(pid, stat_loc, options) \ __waitpid (pid, stat_loc, options) diff --git a/sysdeps/generic/utmp_file.c b/sysdeps/generic/utmp_file.c index 6502ac3524..dc31e64a4e 100644 --- a/sysdeps/generic/utmp_file.c +++ b/sysdeps/generic/utmp_file.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1996,97,98,99,2000,01,02 Free Software Foundation, Inc. +/* Copyright (C) 1996-2002, 2003 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper and Paul Janzen , 1996. @@ -26,6 +26,7 @@ #include #include #include +#include #include "utmp-private.h" #include "utmp-equal.h" @@ -57,47 +58,47 @@ static void timeout_handler (int signum) {}; LOCK_FILE. */ #define LOCK_FILE(fd, type) \ -{ \ - struct flock fl; \ - struct sigaction action, old_action; \ - unsigned int old_timeout; \ - \ - /* Cancel any existing alarm. */ \ - old_timeout = alarm (0); \ - \ - /* Establish signal handler. */ \ - action.sa_handler = timeout_handler; \ - __sigemptyset (&action.sa_mask); \ - action.sa_flags = 0; \ - __sigaction (SIGALRM, &action, &old_action); \ - \ - alarm (TIMEOUT); \ - \ - /* Try to get the lock. */ \ - memset (&fl, '\0', sizeof (struct flock)); \ - fl.l_type = (type); \ - fl.l_whence = SEEK_SET; \ - if (__fcntl ((fd), F_SETLKW, &fl) < 0) +{ \ + struct flock fl; \ + struct sigaction action, old_action; \ + unsigned int old_timeout; \ + \ + /* Cancel any existing alarm. */ \ + old_timeout = alarm (0); \ + \ + /* Establish signal handler. */ \ + action.sa_handler = timeout_handler; \ + __sigemptyset (&action.sa_mask); \ + action.sa_flags = 0; \ + __sigaction (SIGALRM, &action, &old_action); \ + \ + alarm (TIMEOUT); \ + \ + /* Try to get the lock. */ \ + memset (&fl, '\0', sizeof (struct flock)); \ + fl.l_type = (type); \ + fl.l_whence = SEEK_SET; \ + if (__fcntl_nocancel ((fd), F_SETLKW, &fl) < 0) #define LOCKING_FAILED() \ goto unalarm_return #define UNLOCK_FILE(fd) \ - /* Unlock the file. */ \ - fl.l_type = F_UNLCK; \ - __fcntl ((fd), F_SETLKW, &fl); \ - \ - unalarm_return: \ - /* Reset the signal handler and alarm. We must reset the alarm \ - before resetting the handler so our alarm does not generate a \ - spurious SIGALRM seen by the user. However, we cannot just set \ - the user's old alarm before restoring the handler, because then \ - it's possible our handler could catch the user alarm's SIGARLM \ - and then the user would never see the signal he expected. */ \ - alarm (0); \ - __sigaction (SIGALRM, &old_action, NULL); \ - if (old_timeout != 0) \ - alarm (old_timeout); \ + /* Unlock the file. */ \ + fl.l_type = F_UNLCK; \ + __fcntl_nocancel ((fd), F_SETLKW, &fl); \ + \ + unalarm_return: \ + /* Reset the signal handler and alarm. We must reset the alarm \ + before resetting the handler so our alarm does not generate a \ + spurious SIGALRM seen by the user. However, we cannot just set \ + the user's old alarm before restoring the handler, because then \ + it's possible our handler could catch the user alarm's SIGARLM \ + and then the user would never see the signal he expected. */ \ + alarm (0); \ + __sigaction (SIGALRM, &old_action, NULL); \ + if (old_timeout != 0) \ + alarm (old_timeout); \ } while (0) @@ -139,22 +140,22 @@ setutent_file (void) file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name); - file_fd = __open (file_name, O_RDWR); + file_fd = open_not_cancel_2 (file_name, O_RDWR); if (file_fd == -1) { /* Hhm, read-write access did not work. Try read-only. */ - file_fd = __open (file_name, O_RDONLY); + file_fd = open_not_cancel_2 (file_name, O_RDONLY); if (file_fd == -1) return 0; } /* We have to make sure the file is `closed on exec'. */ - result = __fcntl (file_fd, F_GETFD, 0); + result = __fcntl_nocancel (file_fd, F_GETFD, 0); if (result >= 0) - result = __fcntl (file_fd, F_SETFD, result | FD_CLOEXEC); + result = __fcntl_nocancel (file_fd, F_SETFD, result | FD_CLOEXEC); if (result == -1) { - __close (file_fd); + close_not_cancel_no_status (file_fd); return 0; } } @@ -197,7 +198,7 @@ getutent_r_file (struct utmp *buffer, struct utmp **result) } /* Read the next entry. */ - nbytes = __read (file_fd, &last_entry, sizeof (struct utmp)); + nbytes = read_not_cancel (file_fd, &last_entry, sizeof (struct utmp)); UNLOCK_FILE (file_fd); @@ -237,7 +238,7 @@ internal_getut_r (const struct utmp *id, struct utmp *buffer) while (1) { /* Read the next entry. */ - if (__read (file_fd, buffer, sizeof (struct utmp)) + if (read_not_cancel (file_fd, buffer, sizeof (struct utmp)) != sizeof (struct utmp)) { __set_errno (ESRCH); @@ -259,7 +260,7 @@ internal_getut_r (const struct utmp *id, struct utmp *buffer) while (1) { /* Read the next entry. */ - if (__read (file_fd, buffer, sizeof (struct utmp)) + if (read_not_cancel (file_fd, buffer, sizeof (struct utmp)) != sizeof (struct utmp)) { __set_errno (ESRCH); @@ -332,7 +333,7 @@ getutline_r_file (const struct utmp *line, struct utmp *buffer, while (1) { /* Read the next entry. */ - if (__read (file_fd, &last_entry, sizeof (struct utmp)) + if (read_not_cancel (file_fd, &last_entry, sizeof (struct utmp)) != sizeof (struct utmp)) { __set_errno (ESRCH); @@ -418,7 +419,8 @@ pututline_file (const struct utmp *data) } /* Write the new data. */ - if (__write (file_fd, data, sizeof (struct utmp)) != sizeof (struct utmp)) + if (write_not_cancel (file_fd, data, sizeof (struct utmp)) + != sizeof (struct utmp)) { /* If we appended a new record this is only partially written. Remove it. */ @@ -444,7 +446,7 @@ endutent_file (void) { assert (file_fd >= 0); - __close (file_fd); + close_not_cancel_no_status (file_fd); file_fd = -1; } @@ -457,7 +459,7 @@ updwtmp_file (const char *file, const struct utmp *utmp) int fd; /* Open WTMP file. */ - fd = __open (file, O_WRONLY); + fd = open_not_cancel_2 (file, O_WRONLY); if (fd < 0) return -1; @@ -478,7 +480,8 @@ updwtmp_file (const char *file, const struct utmp *utmp) /* Write the entry. If we can't write all the bytes, reset the file size back to the original size. That way, no partial entries will remain. */ - if (__write (fd, utmp, sizeof (struct utmp)) != sizeof (struct utmp)) + if (write_not_cancel (fd, utmp, sizeof (struct utmp)) + != sizeof (struct utmp)) { __ftruncate64 (fd, offset); goto unlock_return; @@ -490,7 +493,7 @@ unlock_return: UNLOCK_FILE (fd); /* Close WTMP file. */ - __close (fd); + close_not_cancel_no_status (fd); return result; } diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile index f292931fb9..2d781d2f74 100644 --- a/sysdeps/unix/sysv/linux/Makefile +++ b/sysdeps/unix/sysv/linux/Makefile @@ -15,6 +15,8 @@ ifeq ($(subdir),misc) sysdep_routines += sysctl clone llseek umount umount2 readahead \ setfsuid setfsgid +CFLAGS-gethostid.c = -fexceptions + sysdep_headers += sys/mount.h sys/acct.h sys/sysctl.h \ sys/klog.h sys/kdaemon.h \ sys/user.h sys/procfs.h sys/prctl.h \ diff --git a/sysdeps/unix/sysv/linux/fcntl.c b/sysdeps/unix/sysv/linux/fcntl.c new file mode 100644 index 0000000000..33651d3c10 --- /dev/null +++ b/sysdeps/unix/sysv/linux/fcntl.c @@ -0,0 +1,60 @@ +/* Copyright (C) 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 + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include +#include +#include +#include + +#include +#include + + +int +__fcntl_nocancel (int fd, int cmd, void *arg) +{ + return INLINE_SYSCALL (fcntl, 3, fd, cmd, arg); +} + + +int +__libc_fcntl (int fd, int cmd, ...) +{ + va_list ap; + void *arg; + + va_start (ap, cmd); + arg = va_arg (ap, void *); + va_end (ap); + + if (SINGLE_THREAD_P || cmd != F_SETLKW) + return __fcntl_nocancel (fd, cmd, arg); + + int oldtype = LIBC_CANCEL_ASYNC (); + + int result = __fcntl_nocancel (fd, cmd, arg); + + LIBC_CANCEL_RESET (oldtype); + + return result; +} +libc_hidden_def (__libc_fcntl) + +weak_alias (__libc_fcntl, __fcntl) +libc_hidden_weak (__fcntl) +weak_alias (__libc_fcntl, fcntl) diff --git a/sysdeps/unix/sysv/linux/gethostid.c b/sysdeps/unix/sysv/linux/gethostid.c index 5ef330b958..c7f894033d 100644 --- a/sysdeps/unix/sysv/linux/gethostid.c +++ b/sysdeps/unix/sysv/linux/gethostid.c @@ -101,11 +101,8 @@ gethostid () if (herr != NETDB_INTERNAL || errno != ERANGE) return 0; else - { - /* Enlarge buffer. */ - buflen *= 2; - buffer = __alloca (buflen); - } + /* Enlarge buffer. */ + buffer = extend_alloca (buffer, buflen, 2 * buflen); in.s_addr = 0; memcpy (&in, hp->h_addr, diff --git a/sysdeps/unix/sysv/linux/i386/fcntl.c b/sysdeps/unix/sysv/linux/i386/fcntl.c index 749288d92b..c0ca1257f1 100644 --- a/sysdeps/unix/sysv/linux/i386/fcntl.c +++ b/sysdeps/unix/sysv/linux/i386/fcntl.c @@ -28,11 +28,13 @@ #if __ASSUME_FCNTL64 == 0 /* This variable is shared with all files that check for fcntl64. */ int __have_no_fcntl64; +#endif -static int -do_fcntl (int fd, int cmd, void *arg) +int +__fcntl_nocancel (int fd, int cmd, void *arg) { +#if __ASSUME_FCNTL64 == 0 # ifdef __NR_fcntl64 if (! __have_no_fcntl64) { @@ -113,8 +115,10 @@ do_fcntl (int fd, int cmd, void *arg) return INLINE_SYSCALL (fcntl, 3, fd, cmd, arg); } return -1; +#else + return INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg); +#endif /* !__ASSUME_FCNTL64 */ } -#endif /* __ASSUME_FCNTL64 */ int @@ -128,19 +132,19 @@ __libc_fcntl (int fd, int cmd, ...) va_end (ap); #if __ASSUME_FCNTL64 > 0 - if (SINGLE_THREAD_P) + if (SINGLE_THREAD_P || (cmd != F_SETLKW && cmd != F_SETLKW64)) return INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg); int oldtype = LIBC_CANCEL_ASYNC (); int result = INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg); #else - if (SINGLE_THREAD_P) - return do_fcntl (fd, cmd, arg); + if (SINGLE_THREAD_P || (cmd != F_SETLKW && cmd != F_SETLKW64)) + return __fcntl_nocancel (fd, cmd, arg); int oldtype = LIBC_CANCEL_ASYNC (); - int result = do_fcntl (fd, cmd, arg); + int result = __fcntl_nocancel (fd, cmd, arg); #endif LIBC_CANCEL_RESET (oldtype); diff --git a/sysdeps/unix/sysv/linux/not-cancel.h b/sysdeps/unix/sysv/linux/not-cancel.h index c71641906d..9418417b45 100644 --- a/sysdeps/unix/sysv/linux/not-cancel.h +++ b/sysdeps/unix/sysv/linux/not-cancel.h @@ -46,6 +46,10 @@ (void) ({ INTERNAL_SYSCALL_DECL (err); \ INTERNAL_SYSCALL (writev, err, 3, (fd), (iov), (n)); }) +/* Uncancelable fcntl. */ +#define fcntl_not_cancel(fd, cmd, val) \ + __fcntl_nocancel (fd, cmd, val) + /* Uncancelable waitpid. */ #ifdef __NR_waitpid # define waitpid_not_cancel(pid, stat_loc, options) \ -- cgit 1.4.1