2003-09-04 Ulrich Drepper <drepper@redhat.com>
+ * 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.
+
* nss/getXXbyYY.c (FUNCTION_NAME): Add a few casts. Remove
unnecessary errno handling.
libc_hidden_proto (__libc_open)
extern int __libc_creat (const char *file, mode_t mode);
extern int __libc_fcntl (int fd, int cmd, ...);
+extern int __fcntl_nocancel (int fd, int cmd, ...) attribute_hidden;
libc_hidden_proto (__libc_fcntl)
extern int __open (__const char *__file, int __oflag, ...);
libc_hidden_proto (__open)
(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) \
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
-/* Return the current machine's Internet number. */
-extern long int gethostid (void) __THROW;
+/* Return identifier for the current host. */
+extern long int gethostid (void);
/* Make all changes done to all files actually appear on disk. */
extern void sync (void) __THROW;
#include <string.h>
#include <unistd.h>
+#include <not-cancel.h>
+
/* Options. Should all be left alone. */
#define RESOLVSORT
#define RFC1535
int ns;
if (statp->_vcsock >= 0) {
- (void) __close(statp->_vcsock);
+ close_not_cancel_no_status(statp->_vcsock);
statp->_vcsock = -1;
statp->_flags &= ~(RES_F_VC | RES_F_CONN);
}
#endif
if (statp->_u._ext.nsaddrs[ns]
&& statp->_u._ext.nssocks[ns] != -1) {
- (void) __close(statp->_u._ext.nssocks[ns]);
+ close_not_cancel_no_status(statp->_u._ext.nssocks[ns]);
statp->_u._ext.nssocks[ns] = -1;
}
statp->_u._ext.nsinit = 0;
__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)
-/* 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 <drepper@cygnus.com>
and Paul Janzen <pcj@primenet.com>, 1996.
#include <string.h>
#include <unistd.h>
#include <utmp.h>
+#include <not-cancel.h>
#include "utmp-private.h"
#include "utmp-equal.h"
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)
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;
}
}
}
/* 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);
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);
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);
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);
}
/* 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. */
{
assert (file_fd >= 0);
- __close (file_fd);
+ close_not_cancel_no_status (file_fd);
file_fd = -1;
}
int fd;
/* Open WTMP file. */
- fd = __open (file, O_WRONLY);
+ fd = open_not_cancel_2 (file, O_WRONLY);
if (fd < 0)
return -1;
/* 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;
UNLOCK_FILE (fd);
/* Close WTMP file. */
- __close (fd);
+ close_not_cancel_no_status (fd);
return result;
}
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 \
--- /dev/null
+/* 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 <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+
+#include <sysdep-cancel.h>
+#include <sys/syscall.h>
+
+
+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)
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,
#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)
{
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
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);
(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) \
projects / platform / upstream / glibc.git / commitdiff