AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-09 14:50:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Avoid cancellable I/O primitives in ld.so.

Browse Source 
Neither the <dlfcn.h> entry points, nor lazy symbol resolution, nor
initial shared library load-up, are cancellation points, so ld.so
should exclusively use I/O primitives that are not cancellable.  We
currently achieve this by having the cancellation hooks compile as
no-ops when IS_IN(rtld); this patch changes to using exclusively
_nocancel primitives in the source code instead, which makes the
intent clearer and significantly reduces the amount of code compiled
under IS_IN(rtld) as well as IS_IN(libc) -- in particular,
elf/Makefile no longer thinks we require a copy of unwind.c in
rtld-libc.a.  (The older mechanism is preserved as a backstop.)

The bulk of the change is splitting up the files that define the
_nocancel I/O functions, so they don't also define the variants that
*are* cancellation points; after which, the existing logic for picking
out the bits of libc that need to be recompiled as part of ld.so Just
Works.  I did this for all of the _nocancel functions, not just the
ones used by ld.so, for consistency.

fcntl was a little tricky because it's only a cancellation point for
certain opcodes (F_SETLKW(64), which can block), and the existing
__fcntl_nocancel wasn't applying the FCNTL_ADJUST_CMD hook, which
strikes me as asking for trouble, especially as the only nontrivial
definition of FCNTL_ADJUST_CMD (for powerpc64) changes F_*LK* opcodes.
To fix this, fcntl_common moves to fcntl_nocancel.c along with
__fcntl_nocancel, and changes its name to the extern (but hidden)
symbol __fcntl_nocancel_adjusted, so that regular fcntl can continue
calling it.  __fcntl_nocancel now applies FCNTL_ADJUST_CMD; so that
both both fcntl.c and fcntl_nocancel.c can see it, the only nontrivial
definition moves from sysdeps/u/s/l/powerpc/powerpc64/fcntl.c to
.../powerpc64/sysdep.h and becomes entirely a macro, instead of a macro
that calls an inline function.

The nptl version of libpthread also changes a little, because its
"compat-routines" formerly included files that defined all the
_nocancel functions it uses; instead of continuing to duplicate them,
I exported the relevant ones from libc.so as GLIBC_PRIVATE.  Since the
Linux fcntl.c calls a function defined by fcntl_nocancel.c, it can no
longer be used from libpthread.so; instead, introduce a custom
forwarder, pt-fcntl.c, and export __libc_fcntl from libc.so as
GLIBC_PRIVATE.  The nios2-linux ABI doesn't include a copy of vfork()
in libpthread, and it was handling that by manipulating
libpthread-routines in .../linux/nios2/Makefile; it is cleaner to do
what other such ports do, and have a pt-vfork.S that defines no symbols.

Right now, it appears that Hurd does not implement _nocancel I/O, so
sysdeps/generic/not-cancel.h will forward everything back to the
regular functions.  This changed the names of some of the functions
that sysdeps/mach/hurd/dl-sysdep.c needs to interpose.

	* elf/dl-load.c, elf/dl-misc.c, elf/dl-profile.c, elf/rtld.c
	* sysdeps/unix/sysv/linux/dl-sysdep.c
	Include not-cancel.h.  Use __close_nocancel instead of __close,
	__open64_nocancel instead of __open, __read_nocancel instead of
	__libc_read, and __write_nocancel instead of __libc_write.

	* csu/check_fds.c (check_one_fd)
	* sysdeps/posix/fdopendir.c (__fdopendir)
	* sysdeps/posix/opendir.c (__alloc_dir): Use __fcntl_nocancel
        instead of __fcntl and/or __libc_fcntl.

	* sysdeps/unix/sysv/linux/pthread_setname.c (pthread_setname_np)
	* sysdeps/unix/sysv/linux/pthread_getname.c (pthread_getname_np)
        * sysdeps/unix/sysv/linux/i386/smp.h (is_smp_system):
	Use __open64_nocancel instead of __open_nocancel.

	* sysdeps/unix/sysv/linux/not-cancel.h: Move all of the
	hidden_proto declarations to the end and issue them if either
	IS_IN(libc) or IS_IN(rtld).
	* sysdeps/unix/sysv/linux/Makefile [subdir=io] (sysdep_routines):
	Add close_nocancel, fcntl_nocancel, nanosleep_nocancel,
	open_nocancel, open64_nocancel, openat_nocancel, pause_nocancel,
	read_nocancel, waitpid_nocancel, write_nocancel.

        * io/Versions [GLIBC_PRIVATE]: Add __libc_fcntl,
        __fcntl_nocancel, __open64_nocancel, __write_nocancel.
        * posix/Versions: Add __nanosleep_nocancel, __pause_nocancel.

        * nptl/pt-fcntl.c: New file.
        * nptl/Makefile (pthread-compat-wrappers): Remove fcntl.
        (libpthread-routines): Add pt-fcntl.
        * include/fcntl.h (__fcntl_nocancel_adjusted): New function.
        (__libc_fcntl): Remove attribute_hidden.
	* sysdeps/unix/sysv/linux/fcntl.c (__libc_fcntl): Call
	__fcntl_nocancel_adjusted, not fcntl_common.
        (__fcntl_nocancel): Move to new file fcntl_nocancel.c.
	(fcntl_common): Rename to __fcntl_nocancel_adjusted; also move
	to fcntl_nocancel.c.
	* sysdeps/unix/sysv/linux/fcntl_nocancel.c: New file.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c: Remove file.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h:
	Define FCNTL_ADJUST_CMD here, as a self-contained macro.

	* sysdeps/unix/sysv/linux/close.c: Move __close_nocancel to...
	* sysdeps/unix/sysv/linux/close_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/nanosleep.c: Move __nanosleep_nocancel to...
	* sysdeps/unix/sysv/linux/nanosleep_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/open.c: Move __open_nocancel to...
	* sysdeps/unix/sysv/linux/open_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/open64.c: Move __open64_nocancel to...
	* sysdeps/unix/sysv/linux/open64_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/openat.c: Move __openat_nocancel to...
	* sysdeps/unix/sysv/linux/openat_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/openat64.c: Move __openat64_nocancel to...
	* sysdeps/unix/sysv/linux/openat64_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/pause.c: Move __pause_nocancel to...
	* sysdeps/unix/sysv/linux/pause_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/read.c: Move __read_nocancel to...
	* sysdeps/unix/sysv/linux/read_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/waitpid.c: Move __waitpid_nocancel to...
	* sysdeps/unix/sysv/linux/waitpid_nocancel.c: ...this new file.
	* sysdeps/unix/sysv/linux/write.c: Move __write_nocancel to...
	* sysdeps/unix/sysv/linux/write_nocancel.c: ...this new file.

        * sysdeps/unix/sysv/linux/nios2/Makefile: Don't override
        libpthread-routines.
        * sysdeps/unix/sysv/linux/nios2/pt-vfork.S: New file which
        defines nothing.

        * sysdeps/mach/hurd/dl-sysdep.c: Define __read instead of
        __libc_read, and __write instead of __libc_write.  Define
        __open64 in addition to __open.

(cherry picked from commit 329ea513b4)
This commit is contained in:
Zack Weinberg 2018-04-03 18:26:44 -04:00 committed by Pranav Kant
parent e00ff02338
commit 98f5e8eb96
44 changed files with 572 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
csu/check_fds.c
View File

@ -39,8 +39,7 @@
static void
check_one_fd (int fd, int mode)
{
/* Note that fcntl() with this parameter is not a cancellation point. */
if (__builtin_expect (__libc_fcntl (fd, F_GETFD), 0) == -1
if (__builtin_expect (__fcntl_nocancel (fd, F_GETFD), 0) == -1
&& errno == EBADF)
{
const char *name;

34
elf/dl-load.c
View File

@ -48,6 +48,7 @@
/* Code below to add offset to symbol names references itoa. */
#include <_itoa.h>
#include <not-cancel.h>
#include <endian.h>
#if BYTE_ORDER == BIG_ENDIAN
@ -786,7 +787,7 @@ lose (int code, int fd, const char *name, char *realname, struct link_map *l,
{
/* The file might already be closed. */
if (fd != -1)
(void) __close (fd);
(void) __close_nocancel (fd);
if (l != NULL && l->l_origin != (char *) -1l)
free ((char *) l->l_origin);
free (l);
@ -1016,7 +1017,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, off_t of
{
/* The object is already loaded.
Just bump its reference count and return it. */
__close (fd);
__close_nocancel (fd);
free (realname);
@ -1045,7 +1046,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, off_t of
/* No need to bump the refcount of the real object, ld.so will
never be unloaded. */
__close (fd);
__close_nocancel (fd);
/* Add the map for the mirrored object to the object list. */
_dl_add_to_namespace_list (l, nsid);
@ -1059,7 +1060,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, off_t of
/* We are not supposed to load the object unless it is already
loaded. So return now. */
free (realname);
__close (fd);
__close_nocancel (fd);
return NULL;
}
@ -1078,7 +1079,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, off_t of
if (_dl_zerofd == -1)
{
free (realname);
__close (fd);
__close_nocancel (fd);
_dl_signal_error (errno, NULL, NULL,
N_("cannot open zero fill device"));
}
@ -1165,7 +1166,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, off_t of
{
phdr = alloca (maplength);
__lseek (fd, header->e_phoff, SEEK_SET);
if ((size_t) __libc_read (fd, (void *) phdr, maplength) != maplength)
if ((size_t) __read_nocancel (fd, (void *) phdr, maplength) != maplength)
{
errstring = N_("cannot read file data");
goto call_lose_errno;
@ -1446,7 +1447,7 @@ cannot enable executable stack as shared object requires");
l->l_tls_initimage = (char *) l->l_tls_initimage + l->l_addr;
/* We are done mapping in the file. We no longer need the descriptor. */
if (__glibc_unlikely (__close (fd) != 0))
if (__glibc_unlikely (__close_nocancel (fd) != 0))
{
errstring = N_("cannot close file descriptor");
goto call_lose_errno;
@ -1660,7 +1661,7 @@ open_verify (const char *name, int fd, off_t offset,
{
/* An audit library changed what we're supposed to open,
so FD no longer matches it. */
__close (fd);
__close_nocancel (fd);
fd = -1;
}
}
@ -1668,7 +1669,7 @@ open_verify (const char *name, int fd, off_t offset,
if (fd == -1)
/* Open the file. We always open files read-only. */
fd = __open (name, O_RDONLY | O_CLOEXEC);
fd = __open64_nocancel (name, O_RDONLY | O_CLOEXEC);
if (fd != -1)
{
@ -1690,8 +1691,8 @@ open_verify (const char *name, int fd, off_t offset,
/* Read in the header. */
do
{
ssize_t retlen = __libc_read (fd, fbp->buf + fbp->len,
sizeof (fbp->buf) - fbp->len);
ssize_t retlen = __read_nocancel (fd, fbp->buf + fbp->len,
sizeof (fbp->buf) - fbp->len);
if (retlen <= 0)
break;
fbp->len += retlen;
@ -1814,7 +1815,8 @@ open_verify (const char *name, int fd, off_t offset,
{
phdr = alloca (maplength);
__lseek (fd, ehdr->e_phoff, SEEK_SET);
if ((size_t) __libc_read (fd, (void *) phdr, maplength) != maplength)
if ((size_t) __read_nocancel (fd, (void *) phdr, maplength)
!= maplength)
{
read_error:
errval = errno;
@ -1864,7 +1866,7 @@ open_verify (const char *name, int fd, off_t offset,
abi_note = abi_note_malloced;
}
__lseek (fd, ph->p_offset, SEEK_SET);
if (__libc_read (fd, (void *) abi_note, size) != size)
if (__read_nocancel (fd, (void *) abi_note, size) != size)
{
free (abi_note_malloced);
goto read_error;
@ -1896,7 +1898,7 @@ open_verify (const char *name, int fd, off_t offset,
|| (GLRO(dl_osversion) && GLRO(dl_osversion) < osversion))
{
close_and_out:
__close (fd);
__close_nocancel (fd);
__set_errno (ENOENT);
fd = -1;
}
@ -2013,7 +2015,7 @@ open_path (const char *name, size_t namelen, off_t offset, int mode,
/* The shared object cannot be tested for being SUID
or this bit is not set. In this case we must not
use this object. */
__close (fd);
__close_nocancel (fd);
fd = -1;
/* We simply ignore the file, signal this by setting
the error value which would have been set by `open'. */
@ -2034,7 +2036,7 @@ open_path (const char *name, size_t namelen, off_t offset, int mode,
{
/* No memory for the name, we certainly won't be able
to load and link it. */
__close (fd);
__close_nocancel (fd);
return -1;
}
}

6
elf/dl-misc.c
View File

@ -33,7 +33,7 @@
#include <sysdep.h>
#include <_itoa.h>
#include <dl-writev.h>
#include <not-cancel.h>
/* Read the whole contents of FILE into new mmap'd space with given
protections. *SIZEP gets the size of the file. On error MAP_FAILED
@ -44,7 +44,7 @@ _dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
{
void *result = MAP_FAILED;
struct stat64 st;
int fd = __open (file, O_RDONLY | O_CLOEXEC);
int fd = __open64_nocancel (file, O_RDONLY | O_CLOEXEC);
if (fd >= 0)
{
if (__fxstat64 (_STAT_VER, fd, &st) >= 0)
@ -65,7 +65,7 @@ _dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
#endif
, fd, 0);
}
__close (fd);
__close_nocancel (fd);
}
return result;
}

14
elf/dl-profile.c
View File

@ -35,6 +35,7 @@
#include <sys/param.h>
#include <sys/stat.h>
#include <atomic.h>
#include <not-cancel.h>
/* The LD_PROFILE feature has to be implemented different to the
normal profiling using the gmon/ functions. The problem is that an
@ -324,7 +325,7 @@ _dl_start_profile (void)
*cp++ = '/';
__stpcpy (__stpcpy (cp, GLRO(dl_profile)), ".profile");
fd = __open (filename, O_RDWR | O_CREAT | O_NOFOLLOW, DEFFILEMODE);
fd = __open64_nocancel (filename, O_RDWR|O_CREAT|O_NOFOLLOW, DEFFILEMODE);
if (fd == -1)
{
char buf[400];
@ -335,7 +336,7 @@ _dl_start_profile (void)
print_error:
errnum = errno;
if (fd != -1)
__close (fd);
__close_nocancel (fd);
_dl_error_printf (errstr, filename,
__strerror_r (errnum, buf, sizeof buf));
return;
@ -364,15 +365,14 @@ _dl_start_profile (void)
goto print_error;
}
if (TEMP_FAILURE_RETRY (__libc_write (fd, buf, (expected_size
& (GLRO(dl_pagesize)
- 1))))
if (TEMP_FAILURE_RETRY
(__write_nocancel (fd, buf, (expected_size & (GLRO(dl_pagesize) - 1))))
< 0)
goto cannot_create;
}
else if (st.st_size != expected_size)
{
__close (fd);
__close_nocancel (fd);
wrong_format:
if (addr != NULL)
@ -392,7 +392,7 @@ _dl_start_profile (void)
}
/* We don't need the file descriptor anymore. */
__close (fd);
__close_nocancel (fd);
/* Pointer to data after the header. */
hist = (char *) (addr + 1);

3
elf/rtld.c
View File

@ -41,6 +41,7 @@
#include <tls.h>
#include <stap-probe.h>
#include <stackinfo.h>
#include <not-cancel.h>
#include <assert.h>
@ -2756,7 +2757,7 @@ process_envvars (enum mode *modep)
*--startp = '.';
startp = memcpy (startp - name_len, debug_output, name_len);
GLRO(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
GLRO(dl_debug_fd) = __open64_nocancel (startp, flags, DEFFILEMODE);
if (GLRO(dl_debug_fd) == -1)
/* We use standard output if opening the file failed. */
GLRO(dl_debug_fd) = STDOUT_FILENO;

3
include/fcntl.h
View File

@ -8,8 +8,9 @@ libc_hidden_proto (__open64)
extern int __libc_open64 (const char *file, int oflag, ...);
extern int __libc_open (const char *file, int oflag, ...);
libc_hidden_proto (__libc_open)
extern int __libc_fcntl (int fd, int cmd, ...) attribute_hidden;
extern int __libc_fcntl (int fd, int cmd, ...);
libc_hidden_proto (__libc_fcntl)
extern int __fcntl_nocancel_adjusted (int fd, int cmd, void *arg) attribute_hidden;
extern int __open (const char *__file, int __oflag, ...);
libc_hidden_proto (__open)
extern int __fcntl (int __fd, int __cmd, ...);

6
io/Versions
View File

@ -128,4 +128,10 @@ libc {
GLIBC_2.27 {
copy_file_range;
}
GLIBC_PRIVATE {
__libc_fcntl;
__fcntl_nocancel;
__open64_nocancel;
__write_nocancel;
}
}

4
nptl/Makefile
View File

@ -36,7 +36,7 @@ shared-only-routines = forward
# We need to provide certain routines for compatibility with existing
# binaries.
pthread-compat-wrappers = \
write read close fcntl accept \
write read close accept \
connect recv recvfrom send \
sendto fsync lseek lseek64 \
msync nanosleep open open64 pause \
@ -120,7 +120,7 @@ libpthread-routines = nptl-init vars events version pt-interp \
cancellation \
lowlevellock \
lll_timedlock_wait lll_timedwait_tid \
pt-fork pt-vfork \
pt-fork pt-vfork pt-fcntl \
$(pthread-compat-wrappers) \
pt-raise pt-system \
flockfile ftrylockfile funlockfile \

1
posix/Versions
View File

@ -139,5 +139,6 @@ libc {
}
GLIBC_PRIVATE {
__libc_fork; __libc_pread; __libc_pwrite;
__nanosleep_nocancel; __pause_nocancel;
}
}

14
sysdeps/mach/hurd/dl-sysdep.c
View File

@ -353,6 +353,7 @@ open_file (const char *file_name, int flags,
}
check_no_hidden(__open);
check_no_hidden (__open64);
int weak_function
__open (const char *file_name, int mode, ...)
{
@ -363,6 +364,7 @@ __open (const char *file_name, int mode, ...)
else
return (int)port;
}
weak_alias (__open, __open64)
check_no_hidden(__close);
int weak_function
@ -373,9 +375,9 @@ __close (int fd)
return 0;
}
check_no_hidden(__libc_read);
check_no_hidden(__read);
__ssize_t weak_function
__libc_read (int fd, void *buf, size_t nbytes)
__read (int fd, void *buf, size_t nbytes)
{
error_t err;
char *data;
@ -395,11 +397,11 @@ __libc_read (int fd, void *buf, size_t nbytes)
return nread;
}
libc_hidden_weak (__libc_read)
libc_hidden_weak (__read)
check_no_hidden(__libc_write);
check_no_hidden(__write);
__ssize_t weak_function
__libc_write (int fd, const void *buf, size_t nbytes)
__write (int fd, const void *buf, size_t nbytes)
{
error_t err;
mach_msg_type_number_t nwrote;
@ -412,7 +414,7 @@ __libc_write (int fd, const void *buf, size_t nbytes)
return nwrote;
}
libc_hidden_weak (__libc_write)
libc_hidden_weak (__write)
/* This is only used for printing messages (see dl-misc.c). */
check_no_hidden(__writev);

2
sysdeps/posix/fdopendir.c
View File

@ -38,7 +38,7 @@ __fdopendir (int fd)
}
/* Make sure the descriptor allows for reading. */
int flags = __fcntl (fd, F_GETFL);
int flags = __fcntl_nocancel (fd, F_GETFL);
if (__glibc_unlikely (flags == -1))
return NULL;
if (__glibc_unlikely ((flags & O_ACCMODE) == O_WRONLY))

2
sysdeps/posix/opendir.c
View File

@ -197,7 +197,7 @@ __alloc_dir (int fd, bool close_fd, int flags, const struct stat64 *statp)
/* We have to set the close-on-exit flag if the user provided the
file descriptor. */
if (!close_fd
&& __builtin_expect (__fcntl (fd, F_SETFD, FD_CLOEXEC), 0) < 0)
&& __glibc_unlikely (__fcntl_nocancel (fd, F_SETFD, FD_CLOEXEC) < 0))
goto lose;
const size_t default_allocation = (4 * BUFSIZ < sizeof (struct dirent64)

49
sysdeps/unix/pt-fcntl.c Normal file
View File

@ -0,0 +1,49 @@
/* ABI compatibility for 'fcntl' symbol in libpthread ABI.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <stdarg.h>
#include <shlib-compat.h>
/* libpthread once had its own fcntl, though there was no apparent reason
for it. There is no use in having a separate symbol in libpthread, but
the historical ABI requires it. For static linking, there is no need to
provide anything here--the libc version will be linked in. For shared
library ABI compatibility, there must be __fcntl and fcntl symbols in
libpthread.so. */
#if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_28)
static int
fcntl_compat (int fd, int cmd, ...)
{
void *arg;
va_list ap;
va_start (ap, cmd);
arg = va_arg (ap, void *);
va_end (ap);
return __libc_fcntl (fd, cmd, arg);
}
weak_alias (fcntl_compat, fcntl_alias)
compat_symbol (libpthread, fcntl_alias, fcntl, GLIBC_2_0);
weak_alias (fcntl_compat, __fcntl_alias)
compat_symbol (libpthread, __fcntl_alias, __fcntl, GLIBC_2_0);
#endif

7
sysdeps/unix/sysv/linux/Makefile
View File

@ -167,7 +167,12 @@ endif
ifeq ($(subdir),io)
sysdep_routines += xstatconv internal_statvfs internal_statvfs64 \
sync_file_range fallocate fallocate64
sync_file_range fallocate fallocate64 \
close_nocancel fcntl_nocancel nanosleep_nocancel \
open_nocancel open64_nocancel \
openat_nocancel openat64_nocancel \
pause_nocancel read_nocancel waitpid_nocancel write_nocancel
sysdep_headers += bits/fcntl-linux.h
tests += tst-fallocate tst-fallocate64

11
sysdeps/unix/sysv/linux/close.c
View File

@ -29,14 +29,3 @@ __close (int fd)
libc_hidden_def (__close)
strong_alias (__close, __libc_close)
weak_alias (__close, close)
# if !IS_IN (rtld)
int
__close_nocancel (int fd)
{
return INLINE_SYSCALL_CALL (close, fd);
}
#else
strong_alias (__libc_close, __close_nocancel)
#endif
libc_hidden_def (__close_nocancel)

20
sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c → sysdeps/unix/sysv/linux/close_nocancel.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2000-2018 Free Software Foundation, Inc.
/* Linux close syscall implementation -- non-cancellable.
Copyright (C) 2018 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
@ -16,17 +17,12 @@
<http://www.gnu.org/licenses/>. */
#include <unistd.h>
#include <fcntl.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
static inline int
fcntl_adjust_cmd (int cmd)
int
__close_nocancel (int fd)
{
if (cmd >= F_GETLK64 && cmd <= F_SETLKW64)
cmd -= F_GETLK64 - F_GETLK;
return cmd;
return INLINE_SYSCALL_CALL (close, fd);
}
#define FCNTL_ADJUST_CMD(__cmd) \
fcntl_adjust_cmd (__cmd)
#include <sysdeps/unix/sysv/linux/fcntl.c>
libc_hidden_def (__close_nocancel)

7
sysdeps/unix/sysv/linux/dl-sysdep.c
View File

@ -26,6 +26,7 @@
#include <sys/param.h>
#include <sys/utsname.h>
#include <ldsodefs.h>
#include <not-cancel.h>
#ifdef SHARED
# define DL_SYSDEP_INIT frob_brk ()
@ -88,11 +89,11 @@ _dl_discover_osversion (void)
if (__uname (&uts))
{
/* This was not successful. Now try reading the /proc filesystem. */
int fd = __open ("/proc/sys/kernel/osrelease", O_RDONLY);
int fd = __open64_nocancel ("/proc/sys/kernel/osrelease", O_RDONLY);
if (fd < 0)
return -1;
ssize_t reslen = __read (fd, bufmem, sizeof (bufmem));
__close (fd);
ssize_t reslen = __read_nocancel (fd, bufmem, sizeof (bufmem));
__close_nocancel (fd);
if (reslen <= 0)
/* This also didn't work. We give up since we cannot
make sure the library can actually work. */

41
sysdeps/unix/sysv/linux/fcntl.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2000-2018 Free Software Foundation, Inc.
/* Linux fcntl syscall implementation.
Copyright (C) 2000-2018 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
@ -29,24 +30,6 @@
# define FCNTL_ADJUST_CMD(__cmd) __cmd
#endif
static int
fcntl_common (int fd, int cmd, void *arg)
{
if (cmd == F_GETOWN)
{
INTERNAL_SYSCALL_DECL (err);
struct f_owner_ex fex;
int res = INTERNAL_SYSCALL_CALL (fcntl64, err, fd, F_GETOWN_EX, &fex);
if (!INTERNAL_SYSCALL_ERROR_P (res, err))
return fex.type == F_OWNER_GID ? -fex.pid : fex.pid;
return INLINE_SYSCALL_ERROR_RETURN_VALUE (INTERNAL_SYSCALL_ERRNO (res,
err));
}
return INLINE_SYSCALL_CALL (fcntl64, fd, cmd, (void *) arg);
}
int
__libc_fcntl (int fd, int cmd, ...)
{
@ -62,28 +45,10 @@ __libc_fcntl (int fd, int cmd, ...)
if (cmd == F_SETLKW || cmd == F_SETLKW64)
return SYSCALL_CANCEL (fcntl64, fd, cmd, (void *) arg);
return fcntl_common (fd, cmd, arg);
return __fcntl_nocancel_adjusted (fd, cmd, arg);
}
libc_hidden_def (__libc_fcntl)
#if !IS_IN (rtld)
int
__fcntl_nocancel (int fd, int cmd, ...)
{
va_list ap;
void *arg;
va_start (ap, cmd);
arg = va_arg (ap, void *);
va_end (ap);
return fcntl_common (fd, cmd, arg);
}
#else
strong_alias (__libc_fcntl, __fcntl_nocancel)
#endif
libc_hidden_def (__fcntl_nocancel)
weak_alias (__libc_fcntl, __fcntl)
libc_hidden_weak (__fcntl)
weak_alias (__libc_fcntl, fcntl)

65
sysdeps/unix/sysv/linux/fcntl_nocancel.c Normal file
View File

@ -0,0 +1,65 @@
/* Linux fcntl syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <stdarg.h>
#include <errno.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifndef __NR_fcntl64
# define __NR_fcntl64 __NR_fcntl
#endif
#ifndef FCNTL_ADJUST_CMD
# define FCNTL_ADJUST_CMD(__cmd) __cmd
#endif
int
__fcntl_nocancel (int fd, int cmd, ...)
{
va_list ap;
void *arg;
va_start (ap, cmd);
arg = va_arg (ap, void *);
va_end (ap);
cmd = FCNTL_ADJUST_CMD (cmd);
return __fcntl_nocancel_adjusted (fd, cmd, arg);
}
hidden_def (__fcntl_nocancel)
int
__fcntl_nocancel_adjusted (int fd, int cmd, void *arg)
{
if (cmd == F_GETOWN)
{
INTERNAL_SYSCALL_DECL (err);
struct f_owner_ex fex;
int res = INTERNAL_SYSCALL_CALL (fcntl64, err, fd, F_GETOWN_EX, &fex);
if (!INTERNAL_SYSCALL_ERROR_P (res, err))
return fex.type == F_OWNER_GID ? -fex.pid : fex.pid;
return INLINE_SYSCALL_ERROR_RETURN_VALUE
(INTERNAL_SYSCALL_ERRNO (res, err));
}
return INLINE_SYSCALL_CALL (fcntl64, fd, cmd, (void *) arg);
}

2
sysdeps/unix/sysv/linux/i386/smp.h
View File

@ -41,7 +41,7 @@ is_smp_system (void)
else
{
/* This was not successful. Now try reading the /proc filesystem. */
int fd = __open_nocancel ("/proc/sys/kernel/version", O_RDONLY);
int fd = __open64_nocancel ("/proc/sys/kernel/version", O_RDONLY);
if (__builtin_expect (fd, 0) == -1
|| __read_nocancel (fd, u.buf, sizeof (u.buf)) <= 0)
/* This also didn't work. We give up and say it's a UP machine. */

10
sysdeps/unix/sysv/linux/nanosleep.c
View File

@ -1,4 +1,4 @@
/* Linux high resolution nanosleep implementation.
/* Linux nanosleep syscall implementation.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@ -29,11 +29,3 @@ __nanosleep (const struct timespec *requested_time,
}
hidden_def (__nanosleep)
weak_alias (__nanosleep, nanosleep)
int
__nanosleep_nocancel (const struct timespec *requested_time,
struct timespec *remaining)
{
return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining);
}
hidden_def (__nanosleep_nocancel)

29
sysdeps/unix/sysv/linux/nanosleep_nocancel.c Normal file
View File

@ -0,0 +1,29 @@
/* Linux nanosleep syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <time.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
int
__nanosleep_nocancel (const struct timespec *requested_time,
struct timespec *remaining)
{
return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining);
}
hidden_def (__nanosleep_nocancel)

4
sysdeps/unix/sysv/linux/nios2/Makefile
View File

@ -7,7 +7,3 @@ ifeq ($(subdir),misc)
sysdep_headers += sys/cachectl.h
sysdep_routines += cacheflush
endif
ifeq ($(subdir),nptl)
libpthread-routines := $(filter-out pt-vfork,$(libpthread-routines))
endif

1
sysdeps/unix/sysv/linux/nios2/pt-vfork.S Normal file
View File

@ -0,0 +1 @@
# Nios2 does not require a stub for vfork in libpthread.

25
sysdeps/unix/sysv/linux/not-cancel.h
View File

@ -30,31 +30,24 @@
/* Non cancellable open syscall. */
__typeof (open) __open_nocancel;
libc_hidden_proto (__open_nocancel)
/* Non cancellable open syscall (LFS version). */
__typeof (open64) __open64_nocancel;
libc_hidden_proto (__open64_nocancel)
/* Non cancellable openat syscall. */
__typeof (openat) __openat_nocancel;
libc_hidden_proto (__openat_nocancel)
/* Non cacellable openat syscall (LFS version). */
__typeof (openat64) __openat64_nocancel;
libc_hidden_proto (__openat64_nocancel)
/* Non cancellable read syscall. */
__typeof (__read) __read_nocancel;
libc_hidden_proto (__read_nocancel)
/* Uncancelable write. */
__typeof (__write) __write_nocancel;
libc_hidden_proto (__write_nocancel)
/* Uncancelable close. */
__typeof (__close) __close_nocancel;
libc_hidden_proto (__close_nocancel)
/* Non cancellable close syscall that does not also set errno in case of
failure. */
@ -75,18 +68,28 @@ __writev_nocancel_nostatus (int fd, const struct iovec *iov, int iovcnt)
/* Uncancelable waitpid. */
__typeof (waitpid) __waitpid_nocancel;
libc_hidden_proto (__waitpid_nocancel)
/* Uncancelable pause. */
__typeof (pause) __pause_nocancel;
libc_hidden_proto (__pause_nocancel)
/* Uncancelable nanosleep. */
__typeof (__nanosleep) __nanosleep_nocancel;
hidden_proto (__nanosleep_nocancel)
/* Uncancelable fcntl. */
__typeof (__fcntl) __fcntl_nocancel;
libc_hidden_proto (__fcntl_nocancel)
#if IS_IN (libc) || IS_IN (rtld)
hidden_proto (__open_nocancel)
hidden_proto (__open64_nocancel)
hidden_proto (__openat_nocancel)
hidden_proto (__openat64_nocancel)
hidden_proto (__read_nocancel)
hidden_proto (__write_nocancel)
hidden_proto (__close_nocancel)
hidden_proto (__waitpid_nocancel)
hidden_proto (__pause_nocancel)
hidden_proto (__nanosleep_nocancel)
hidden_proto (__fcntl_nocancel)
#endif
#endif /* NOT_CANCEL_H */

25
sysdeps/unix/sysv/linux/open.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2017-2018 Free Software Foundation, Inc.
/* Linux open syscall implementation, non-LFS.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Chris Metcalf <cmetcalf@tilera.com>, 2011.
@ -22,7 +23,6 @@
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifndef __OFF_T_MATCHES_OFF64_T
@ -48,25 +48,4 @@ libc_hidden_def (__libc_open)
weak_alias (__libc_open, __open)
libc_hidden_weak (__open)
weak_alias (__libc_open, open)
# if !IS_IN (rtld)
int
__open_nocancel (const char *file, int oflag, ...)
{
int mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, int);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, AT_FDCWD, file, oflag, mode);
}
# else
strong_alias (__libc_open, __open_nocancel)
# endif
libc_hidden_def (__open_nocancel)
#endif

30
sysdeps/unix/sysv/linux/open64.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
/* Linux open syscall implementation, LFS.
Copyright (C) 1991-2018 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
@ -21,7 +22,7 @@
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifdef __OFF_T_MATCHES_OFF64_T
# define EXTRA_OPEN_FLAGS 0
@ -52,34 +53,9 @@ strong_alias (__libc_open64, __open64)
libc_hidden_weak (__open64)
weak_alias (__libc_open64, open64)
# if !IS_IN (rtld)
int
__open64_nocancel (const char *file, int oflag, ...)
{
int mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, int);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, AT_FDCWD, file, oflag | EXTRA_OPEN_FLAGS,
mode);
}
#else
strong_alias (__libc_open64, __open64_nocancel)
#endif
libc_hidden_def (__open64_nocancel)
#ifdef __OFF_T_MATCHES_OFF64_T
strong_alias (__libc_open64, __libc_open)
strong_alias (__libc_open64, __open)
libc_hidden_weak (__open)
weak_alias (__libc_open64, open)
strong_alias (__open64_nocancel, __open_nocancel)
libc_hidden_weak (__open_nocancel)
#endif

54
sysdeps/unix/sysv/linux/open64_nocancel.c Normal file
View File

@ -0,0 +1,54 @@
/* Linux open syscall implementation, LFS, non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <not-cancel.h>
#ifdef __OFF_T_MATCHES_OFF64_T
# define EXTRA_OPEN_FLAGS 0
#else
# define EXTRA_OPEN_FLAGS O_LARGEFILE
#endif
int
__open64_nocancel (const char *file, int oflag, ...)
{
int mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, int);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, AT_FDCWD, file, oflag | EXTRA_OPEN_FLAGS,
mode);
}
hidden_def (__open64_nocancel)
#ifdef __OFF_T_MATCHES_OFF64_T
strong_alias (__open64_nocancel, __open_nocancel)
hidden_def (__open_nocancel)
#endif

46
sysdeps/unix/sysv/linux/open_nocancel.c Normal file
View File

@ -0,0 +1,46 @@
/* Linux open syscall implementation, non-LFS, non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifndef __OFF_T_MATCHES_OFF64_T
int
__open_nocancel (const char *file, int oflag, ...)
{
int mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, int);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, AT_FDCWD, file, oflag, mode);
}
hidden_def (__open_nocancel)
#endif

24
sysdeps/unix/sysv/linux/openat.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2005-2018 Free Software Foundation, Inc.
/* Linux openat syscall implementation, non-LFS.
Copyright (C) 2005-2018 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
@ -19,7 +20,6 @@
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifndef __OFF_T_MATCHES_OFF64_T
@ -43,24 +43,4 @@ __libc_openat (int fd, const char *file, int oflag, ...)
weak_alias (__libc_openat, __openat)
libc_hidden_weak (__openat)
weak_alias (__libc_openat, openat)
# if !IS_IN (rtld)
int
__openat_nocancel (int fd, const char *file, int oflag, ...)
{
mode_t mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, mode_t);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, fd, file, oflag, mode);
}
# else
strong_alias (__libc_openat, __openat_nocancel)
# endif
libc_hidden_weak (__openat_nocancel)
#endif

27
sysdeps/unix/sysv/linux/openat64.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 2007-2018 Free Software Foundation, Inc.
/* Linux openat syscall implementation, LFS.
Copyright (C) 2007-2018 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
@ -19,7 +20,6 @@
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifdef __OFF_T_MATCHES_OFF64_T
# define EXTRA_OPEN_FLAGS 0
@ -49,31 +49,8 @@ strong_alias (__libc_openat64, __openat64)
libc_hidden_weak (__openat64)
weak_alias (__libc_openat64, openat64)
#if !IS_IN (rtld)
int
__openat64_nocancel (int fd, const char *file, int oflag, ...)
{
mode_t mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, mode_t);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, fd, file, oflag | EXTRA_OPEN_FLAGS,
mode);
}
#else
strong_alias (__libc_openat64, __openat64_nocancel)
#endif
libc_hidden_def (__openat64_nocancel)
#ifdef __OFF_T_MATCHES_OFF64_T
strong_alias (__libc_openat64, __openat)
libc_hidden_weak (__openat)
weak_alias (__libc_openat64, openat)
strong_alias (__openat64_nocancel, __openat_nocancel)
#endif

51
sysdeps/unix/sysv/linux/openat64_nocancel.c Normal file
View File

@ -0,0 +1,51 @@
/* Linux openat syscall implementation, LFS, non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifdef __OFF_T_MATCHES_OFF64_T
# define EXTRA_OPEN_FLAGS 0
#else
# define EXTRA_OPEN_FLAGS O_LARGEFILE
#endif
int
__openat64_nocancel (int fd, const char *file, int oflag, ...)
{
mode_t mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, mode_t);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, fd, file, oflag | EXTRA_OPEN_FLAGS,
mode);
}
hidden_def (__openat64_nocancel)
#ifdef __OFF_T_MATCHES_OFF64_T
strong_alias (__openat64_nocancel, __openat_nocancel)
hidden_def (__openat_nocancel)
#endif

43
sysdeps/unix/sysv/linux/openat_nocancel.c Normal file
View File

@ -0,0 +1,43 @@
/* Linux openat syscall implementation, non-LFS, non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include <stdarg.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
#ifndef __OFF_T_MATCHES_OFF64_T
int
__openat_nocancel (int fd, const char *file, int oflag, ...)
{
mode_t mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, mode_t);
va_end (arg);
}
return INLINE_SYSCALL_CALL (openat, fd, file, oflag, mode);
}
hidden_def (__openat_nocancel)
#endif

12
sysdeps/unix/sysv/linux/pause.c
View File

@ -19,7 +19,6 @@
#include <signal.h>
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
/* Suspend the process until a signal arrives.
This always returns -1 and sets errno to EINTR. */
@ -33,14 +32,3 @@ __libc_pause (void)
#endif
}
weak_alias (__libc_pause, pause)
int
__pause_nocancel (void)
{
#ifdef __NR_pause
return INLINE_SYSCALL_CALL (pause);
#else
return INLINE_SYSCALL_CALL (ppoll, NULL, 0, NULL, NULL);
#endif
}
libc_hidden_def (__pause_nocancel)

33
sysdeps/unix/sysv/linux/pause_nocancel.c Normal file
View File

@ -0,0 +1,33 @@
/* Linux pause syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <signal.h>
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
int
__pause_nocancel (void)
{
#ifdef __NR_pause
return INLINE_SYSCALL_CALL (pause);
#else
return INLINE_SYSCALL_CALL (ppoll, NULL, 0, NULL, NULL);
#endif
}
hidden_def (__pause_nocancel)

9
sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h
View File

@ -236,4 +236,13 @@
# endif
#endif
/* In the PowerPC64 ABI, the unadorned F_GETLK* opcodes should be used
even by largefile64 code. */
#define FCNTL_ADJUST_CMD(__cmd) \
({ int cmd_ = (__cmd); \
if (cmd_ >= F_GETLK64 && cmd_ <= F_SETLKW64) \
cmd_ -= F_GETLK64 - F_GETLK; \
cmd_; })
#endif /* linux/powerpc/powerpc64/sysdep.h */

2
sysdeps/unix/sysv/linux/pthread_getname.c
View File

@ -45,7 +45,7 @@ pthread_getname_np (pthread_t th, char *buf, size_t len)
char fname[sizeof (FMT) + 8];
sprintf (fname, FMT, (unsigned int) pd->tid);
int fd = __open_nocancel (fname, O_RDONLY);
int fd = __open64_nocancel (fname, O_RDONLY);
if (fd == -1)
return errno;

2
sysdeps/unix/sysv/linux/pthread_setname.c
View File

@ -46,7 +46,7 @@ pthread_setname_np (pthread_t th, const char *name)
char fname[sizeof (FMT) + 8];
sprintf (fname, FMT, (unsigned int) pd->tid);
int fd = __open_nocancel (fname, O_RDWR);
int fd = __open64_nocancel (fname, O_RDWR);
if (fd == -1)
return errno;

12
sysdeps/unix/sysv/linux/read.c
View File

@ -18,7 +18,6 @@
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
/* Read NBYTES into BUF from FD. Return the number read or -1. */
ssize_t
@ -32,14 +31,3 @@ libc_hidden_def (__read)
weak_alias (__libc_read, __read)
libc_hidden_def (read)
weak_alias (__libc_read, read)
#if !IS_IN (rtld)
ssize_t
__read_nocancel (int fd, void *buf, size_t nbytes)
{
return INLINE_SYSCALL_CALL (read, fd, buf, nbytes);
}
#else
strong_alias (__libc_read, __read_nocancel)
#endif
libc_hidden_def (__read_nocancel)

28
sysdeps/unix/sysv/linux/read_nocancel.c Normal file
View File

@ -0,0 +1,28 @@
/* Linux read syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
ssize_t
__read_nocancel (int fd, void *buf, size_t nbytes)
{
return INLINE_SYSCALL_CALL (read, fd, buf, nbytes);
}
hidden_def (__read_nocancel)

15
sysdeps/unix/sysv/linux/waitpid.c
View File

@ -1,4 +1,5 @@
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
/* Linux waitpid syscall implementation.
Copyright (C) 1991-2018 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
@ -19,7 +20,6 @@
#include <sysdep-cancel.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <not-cancel.h>
__pid_t
__waitpid (__pid_t pid, int *stat_loc, int options)
@ -32,14 +32,3 @@ __waitpid (__pid_t pid, int *stat_loc, int options)
}
libc_hidden_def (__waitpid)
weak_alias (__waitpid, waitpid)
__pid_t
__waitpid_nocancel (__pid_t pid, int *stat_loc, int options)
{
#ifdef __NR_waitpid
return INLINE_SYSCALL_CALL (waitpid, pid, stat_loc, options);
#else
return INLINE_SYSCALL_CALL (wait4, pid, stat_loc, options, NULL);
#endif
}
libc_hidden_def (__waitpid_nocancel)

34
sysdeps/unix/sysv/linux/waitpid_nocancel.c Normal file
View File

@ -0,0 +1,34 @@
/* Linux waitpid syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <sysdep-cancel.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <not-cancel.h>
__pid_t
__waitpid_nocancel (__pid_t pid, int *stat_loc, int options)
{
#ifdef __NR_waitpid
return INLINE_SYSCALL_CALL (waitpid, pid, stat_loc, options);
#else
return INLINE_SYSCALL_CALL (wait4, pid, stat_loc, options, NULL);
#endif
}
libc_hidden_def (__waitpid_nocancel)

12
sysdeps/unix/sysv/linux/write.c
View File

@ -18,7 +18,6 @@
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
/* Write NBYTES of BUF to FD. Return the number written, or -1. */
ssize_t
@ -32,14 +31,3 @@ weak_alias (__libc_write, __write)
libc_hidden_weak (__write)
weak_alias (__libc_write, write)
libc_hidden_weak (write)
#if !IS_IN (rtld)
ssize_t
__write_nocancel (int fd, const void *buf, size_t nbytes)
{
return INLINE_SYSCALL_CALL (write, fd, buf, nbytes);
}
#else
strong_alias (__libc_write, __write_nocancel)
#endif
libc_hidden_def (__write_nocancel)

28
sysdeps/unix/sysv/linux/write_nocancel.c Normal file
View File

@ -0,0 +1,28 @@
/* Linux write syscall implementation -- non-cancellable.
Copyright (C) 2018 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, see
<http://www.gnu.org/licenses/>. */
#include <unistd.h>
#include <sysdep-cancel.h>
#include <not-cancel.h>
ssize_t
__write_nocancel (int fd, const void *buf, size_t nbytes)
{
return INLINE_SYSCALL_CALL (write, fd, buf, nbytes);
}
hidden_def (__write_nocancel)