From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 50018 invoked by alias); 12 Jun 2018 02:13:04 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Received: (qmail 50006 invoked by uid 89); 12 Jun 2018 02:13:03 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=historical, forwarder X-HELO: mail-qk0-f194.google.com X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:openpgp:autocrypt :message-id:date:user-agent:mime-version:in-reply-to :content-language:content-transfer-encoding; bh=BsyLybTIArS0o/EGmTsbxYIywM268yYoe7+EfmmI8AA=; b=eFmE5oRigFbTiAkmj4r0Ck9rgZPFPiECmc60R1PQZfLnM+dvz+K/eu6DUo6UW/HXNw eQCWDfPwy9ptCGc44R812V8ZDhYiHE11KZelqFfgLqo4gkwSQVJ8GiB1887ZBetVlxlu kDqd11o2G8iu44Whel2bNlM+LENwrffUwyHdWOaatxpLk7iTHuOic6FRoNkfpB/hUe2x VNGsZfWs0JylMrEnLufCVh9DgLVLqcNhdl4AQTiN66G4GvjQxULXAr1Tz8OTI8z5CLr0 RUdWv39UP/VBbeKruAOcZojnEm2JC5wQVmBw5elrGTxyH7h3hNAWwrTaMZEzXc+scpJh W2Uw== X-Gm-Message-State: APt69E0w88vco+f6NZ/NEBL1KHVcmZq5TcbfCa1tF+w0qXYgRWKX6g5s PyRQL6cnvDn2T+2ABqT9GkztiA== X-Google-Smtp-Source: ADUXVKKf+qq2bgVut31T9CN4ITIrJNMzpObDV1Nh0TpgRLbuAVylyKkacZDC9rzlOxQijDRdVYlwHg== X-Received: by 2002:a37:7a46:: with SMTP id v67-v6mr1533093qkc.32.1528769572840; Mon, 11 Jun 2018 19:12:52 -0700 (PDT) Subject: Re: [PATCH v3?] Avoid cancellable I/O primitives in ld.so. To: Zack Weinberg , libc-alpha@sourceware.org Cc: schwab@suse.de, samuel.thibault@gnu.org References: <20180607140252.16562-1-zackw@panix.com> From: Adhemerval Zanella Openpgp: preference=signencrypt Message-ID: Date: Tue, 12 Jun 2018 02:13:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.8.0 MIME-Version: 1.0 In-Reply-To: <20180607140252.16562-1-zackw@panix.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit X-SW-Source: 2018-06/txt/msg00218.txt.bz2 On 07/06/2018 11:02, Zack Weinberg wrote: > Neither the 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; in > addition to streamlining low-level operations, this means elf/Makefile > does not think we require a copy of unwind.c in ld.so. > > 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. (Unlike the previous revision of this > patch, the body of the operation is not changed.) > > 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 now 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. I do not fully > understand how this works and I would appreciate specific review by > Hurd maintainers. I am getting test failures for cross compilation > to i686-gnu but I *think* this patch does not change the set of > failures. (Other than that, this patch shows no failures whatsoever > in a build-many-glibcs cycle.) > > * 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. LGTM, thanks. > --- > csu/check_fds.c | 3 +- > elf/dl-load.c | 35 +++++----- > elf/dl-misc.c | 6 +- > elf/dl-profile.c | 14 ++-- > elf/rtld.c | 3 +- > include/fcntl.h | 3 +- > io/Versions | 6 ++ > nptl/Makefile | 4 +- > posix/Versions | 1 + > sysdeps/mach/hurd/dl-sysdep.c | 14 ++-- > sysdeps/posix/fdopendir.c | 2 +- > sysdeps/posix/opendir.c | 2 +- > sysdeps/unix/pt-fcntl.c | 49 ++++++++++++++ > sysdeps/unix/sysv/linux/Makefile | 7 +- > sysdeps/unix/sysv/linux/close.c | 11 ---- > .../powerpc64/fcntl.c => close_nocancel.c} | 20 +++--- > sysdeps/unix/sysv/linux/dl-sysdep.c | 7 +- > sysdeps/unix/sysv/linux/fcntl.c | 41 +----------- > sysdeps/unix/sysv/linux/fcntl_nocancel.c | 65 +++++++++++++++++++ > sysdeps/unix/sysv/linux/i386/smp.h | 2 +- > sysdeps/unix/sysv/linux/nanosleep.c | 10 +-- > sysdeps/unix/sysv/linux/nanosleep_nocancel.c | 29 +++++++++ > sysdeps/unix/sysv/linux/nios2/Makefile | 4 -- > sysdeps/unix/sysv/linux/nios2/pt-vfork.S | 1 + > sysdeps/unix/sysv/linux/not-cancel.h | 25 +++---- > sysdeps/unix/sysv/linux/open.c | 25 +------ > sysdeps/unix/sysv/linux/open64.c | 30 +-------- > sysdeps/unix/sysv/linux/open64_nocancel.c | 54 +++++++++++++++ > sysdeps/unix/sysv/linux/open_nocancel.c | 46 +++++++++++++ > sysdeps/unix/sysv/linux/openat.c | 24 +------ > sysdeps/unix/sysv/linux/openat64.c | 27 +------- > sysdeps/unix/sysv/linux/openat64_nocancel.c | 51 +++++++++++++++ > sysdeps/unix/sysv/linux/openat_nocancel.c | 43 ++++++++++++ > sysdeps/unix/sysv/linux/pause.c | 12 ---- > sysdeps/unix/sysv/linux/pause_nocancel.c | 33 ++++++++++ > .../sysv/linux/powerpc/powerpc64/sysdep.h | 9 +++ > sysdeps/unix/sysv/linux/pthread_getname.c | 2 +- > sysdeps/unix/sysv/linux/pthread_setname.c | 2 +- > sysdeps/unix/sysv/linux/read.c | 12 ---- > sysdeps/unix/sysv/linux/read_nocancel.c | 28 ++++++++ > sysdeps/unix/sysv/linux/waitpid.c | 15 +---- > sysdeps/unix/sysv/linux/waitpid_nocancel.c | 34 ++++++++++ > sysdeps/unix/sysv/linux/write.c | 12 ---- > sysdeps/unix/sysv/linux/write_nocancel.c | 28 ++++++++ > 44 files changed, 572 insertions(+), 279 deletions(-) > create mode 100644 sysdeps/unix/pt-fcntl.c > rename sysdeps/unix/sysv/linux/{powerpc/powerpc64/fcntl.c => close_nocancel.c} (70%) > create mode 100644 sysdeps/unix/sysv/linux/fcntl_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/nanosleep_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/nios2/pt-vfork.S > create mode 100644 sysdeps/unix/sysv/linux/open64_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/open_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/openat64_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/openat_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/pause_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/read_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/waitpid_nocancel.c > create mode 100644 sysdeps/unix/sysv/linux/write_nocancel.c > > diff --git a/csu/check_fds.c b/csu/check_fds.c > index 2b181d44ab..605ee4f3f4 100644 > --- a/csu/check_fds.c > +++ b/csu/check_fds.c > @@ -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; > diff --git a/elf/dl-load.c b/elf/dl-load.c > index 431236920f..c52d011efd 100644 > --- a/elf/dl-load.c > +++ b/elf/dl-load.c > @@ -44,7 +44,7 @@ > #include > #include > #include > - > +#include > > #include > #if BYTE_ORDER == BIG_ENDIAN > @@ -776,7 +776,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); > @@ -835,7 +835,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, > { > /* The object is already loaded. > Just bump its reference count and return it. */ > - __close (fd); > + __close_nocancel (fd); > > /* If the name is not in the list of names for this object add > it. */ > @@ -863,7 +863,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, > > /* 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); > @@ -877,7 +877,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, > /* 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; > } > > @@ -896,7 +896,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, > if (_dl_zerofd == -1) > { > free (realname); > - __close (fd); > + __close_nocancel (fd); > _dl_signal_error (errno, NULL, NULL, > N_("cannot open zero fill device")); > } > @@ -962,7 +962,7 @@ _dl_map_object_from_fd (const char *name, const char *origname, int fd, > { > 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; > @@ -1232,7 +1232,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; > @@ -1447,7 +1447,7 @@ open_verify (const char *name, int fd, > { > /* An audit library changed what we're supposed to open, > so FD no longer matches it. */ > - __close (fd); > + __close_nocancel (fd); > fd = -1; > } > } > @@ -1455,7 +1455,7 @@ open_verify (const char *name, int fd, > > 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) > { > @@ -1474,8 +1474,8 @@ open_verify (const char *name, int fd, > /* 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; > @@ -1598,7 +1598,8 @@ open_verify (const char *name, int fd, > { > 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; > @@ -1648,7 +1649,7 @@ open_verify (const char *name, int fd, > 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; > @@ -1680,7 +1681,7 @@ open_verify (const char *name, int fd, > || (GLRO(dl_osversion) && GLRO(dl_osversion) < osversion)) > { > close_and_out: > - __close (fd); > + __close_nocancel (fd); > __set_errno (ENOENT); > fd = -1; > } > @@ -1797,7 +1798,7 @@ open_path (const char *name, size_t namelen, 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'. */ > @@ -1818,7 +1819,7 @@ open_path (const char *name, size_t namelen, 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; > } > } > diff --git a/elf/dl-misc.c b/elf/dl-misc.c > index b7174994cd..2eb81eeb02 100644 > --- a/elf/dl-misc.c > +++ b/elf/dl-misc.c > @@ -33,7 +33,7 @@ > #include > #include <_itoa.h> > #include > - > +#include > > /* 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; > } > diff --git a/elf/dl-profile.c b/elf/dl-profile.c > index 7f15352123..bac3718c11 100644 > --- a/elf/dl-profile.c > +++ b/elf/dl-profile.c > @@ -35,6 +35,7 @@ > #include > #include > #include > +#include > > /* 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); > diff --git a/elf/rtld.c b/elf/rtld.c > index e7681ebb1f..8c732adb68 100644 > --- a/elf/rtld.c > +++ b/elf/rtld.c > @@ -41,6 +41,7 @@ > #include > #include > #include > +#include > > #include > > @@ -2673,7 +2674,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; > diff --git a/include/fcntl.h b/include/fcntl.h > index 3d68c5ec67..966f797890 100644 > --- a/include/fcntl.h > +++ b/include/fcntl.h > @@ -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, ...); > diff --git a/io/Versions b/io/Versions > index 98898cb9d5..4448b7197c 100644 > --- a/io/Versions > +++ b/io/Versions > @@ -128,4 +128,10 @@ libc { > GLIBC_2.27 { > copy_file_range; > } > + GLIBC_PRIVATE { > + __libc_fcntl; > + __fcntl_nocancel; > + __open64_nocancel; > + __write_nocancel; > + } > } > diff --git a/nptl/Makefile b/nptl/Makefile > index 94be92c789..6cfc8c60ee 100644 > --- a/nptl/Makefile > +++ b/nptl/Makefile > @@ -36,7 +36,7 @@ static-only-routines = pthread_atfork > # 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 \ > diff --git a/posix/Versions b/posix/Versions > index 65e96870e1..cad4c23e8c 100644 > --- a/posix/Versions > +++ b/posix/Versions > @@ -139,5 +139,6 @@ libc { > } > GLIBC_PRIVATE { > __libc_fork; __libc_pread; __libc_pwrite; > + __nanosleep_nocancel; __pause_nocancel; > } > } > diff --git a/sysdeps/mach/hurd/dl-sysdep.c b/sysdeps/mach/hurd/dl-sysdep.c > index 547108805e..ec55c47f35 100644 > --- a/sysdeps/mach/hurd/dl-sysdep.c > +++ b/sysdeps/mach/hurd/dl-sysdep.c > @@ -339,6 +339,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, ...) > { > @@ -349,6 +350,7 @@ __open (const char *file_name, int mode, ...) > else > return (int)port; > } > +weak_alias (__open, __open64) > > check_no_hidden(__close); > int weak_function > @@ -359,9 +361,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; > @@ -381,11 +383,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; > @@ -398,7 +400,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); > diff --git a/sysdeps/posix/fdopendir.c b/sysdeps/posix/fdopendir.c > index ab4541f7fc..dafb5d20c1 100644 > --- a/sysdeps/posix/fdopendir.c > +++ b/sysdeps/posix/fdopendir.c > @@ -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)) > diff --git a/sysdeps/posix/opendir.c b/sysdeps/posix/opendir.c > index dea23b2ff5..0875385f65 100644 > --- a/sysdeps/posix/opendir.c > +++ b/sysdeps/posix/opendir.c > @@ -99,7 +99,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) > diff --git a/sysdeps/unix/pt-fcntl.c b/sysdeps/unix/pt-fcntl.c > new file mode 100644 > index 0000000000..8113d52b86 > --- /dev/null > +++ b/sysdeps/unix/pt-fcntl.c > @@ -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 > + . */ > + > +#include > +#include > +#include > + > +/* 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 > diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile > index cd6244f7ea..215fd5d136 100644 > --- a/sysdeps/unix/sysv/linux/Makefile > +++ b/sysdeps/unix/sysv/linux/Makefile > @@ -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 > diff --git a/sysdeps/unix/sysv/linux/close.c b/sysdeps/unix/sysv/linux/close.c > index c832d27a0f..fa0938bd89 100644 > --- a/sysdeps/unix/sysv/linux/close.c > +++ b/sysdeps/unix/sysv/linux/close.c > @@ -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) > diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c b/sysdeps/unix/sysv/linux/close_nocancel.c > similarity index 70% > rename from sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c > rename to sysdeps/unix/sysv/linux/close_nocancel.c > index 48198c1150..7d744f9096 100644 > --- a/sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c > +++ b/sysdeps/unix/sysv/linux/close_nocancel.c > @@ -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 @@ > . */ > > #include > -#include > +#include > +#include > > -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 > +libc_hidden_def (__close_nocancel) > diff --git a/sysdeps/unix/sysv/linux/dl-sysdep.c b/sysdeps/unix/sysv/linux/dl-sysdep.c > index b4cda3486a..0477e0e5fa 100644 > --- a/sysdeps/unix/sysv/linux/dl-sysdep.c > +++ b/sysdeps/unix/sysv/linux/dl-sysdep.c > @@ -25,6 +25,7 @@ > #include > #include > #include > +#include > > #ifdef SHARED > # define DL_SYSDEP_INIT frob_brk () > @@ -87,11 +88,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. */ > diff --git a/sysdeps/unix/sysv/linux/fcntl.c b/sysdeps/unix/sysv/linux/fcntl.c > index a3cb2aea10..e3992dc9d4 100644 > --- a/sysdeps/unix/sysv/linux/fcntl.c > +++ b/sysdeps/unix/sysv/linux/fcntl.c > @@ -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) > diff --git a/sysdeps/unix/sysv/linux/fcntl_nocancel.c b/sysdeps/unix/sysv/linux/fcntl_nocancel.c > new file mode 100644 > index 0000000000..f50e382c4a > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/fcntl_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > +#include > +#include > + > +#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); > +} > diff --git a/sysdeps/unix/sysv/linux/i386/smp.h b/sysdeps/unix/sysv/linux/i386/smp.h > index 01734b1779..5457bb27d3 100644 > --- a/sysdeps/unix/sysv/linux/i386/smp.h > +++ b/sysdeps/unix/sysv/linux/i386/smp.h > @@ -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. */ > diff --git a/sysdeps/unix/sysv/linux/nanosleep.c b/sysdeps/unix/sysv/linux/nanosleep.c > index 8945837407..56296046ca 100644 > --- a/sysdeps/unix/sysv/linux/nanosleep.c > +++ b/sysdeps/unix/sysv/linux/nanosleep.c > @@ -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) > diff --git a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c > new file mode 100644 > index 0000000000..66f3efd09e > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > + > +int > +__nanosleep_nocancel (const struct timespec *requested_time, > + struct timespec *remaining) > +{ > + return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining); > +} > +hidden_def (__nanosleep_nocancel) > diff --git a/sysdeps/unix/sysv/linux/nios2/Makefile b/sysdeps/unix/sysv/linux/nios2/Makefile > index 20910fa013..5688a16c38 100644 > --- a/sysdeps/unix/sysv/linux/nios2/Makefile > +++ b/sysdeps/unix/sysv/linux/nios2/Makefile > @@ -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 > diff --git a/sysdeps/unix/sysv/linux/nios2/pt-vfork.S b/sysdeps/unix/sysv/linux/nios2/pt-vfork.S > new file mode 100644 > index 0000000000..147427a42d > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/nios2/pt-vfork.S > @@ -0,0 +1 @@ > +# Nios2 does not require a stub for vfork in libpthread. > diff --git a/sysdeps/unix/sysv/linux/not-cancel.h b/sysdeps/unix/sysv/linux/not-cancel.h > index e6cdd144c2..0b5c955989 100644 > --- a/sysdeps/unix/sysv/linux/not-cancel.h > +++ b/sysdeps/unix/sysv/linux/not-cancel.h > @@ -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 */ > diff --git a/sysdeps/unix/sysv/linux/open.c b/sysdeps/unix/sysv/linux/open.c > index c189e285c9..7f12292b87 100644 > --- a/sysdeps/unix/sysv/linux/open.c > +++ b/sysdeps/unix/sysv/linux/open.c > @@ -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 , 2011. > > @@ -22,7 +23,6 @@ > #include > > #include > -#include > > #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 > diff --git a/sysdeps/unix/sysv/linux/open64.c b/sysdeps/unix/sysv/linux/open64.c > index 4af5ee2466..55ef658800 100644 > --- a/sysdeps/unix/sysv/linux/open64.c > +++ b/sysdeps/unix/sysv/linux/open64.c > @@ -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 > > #include > -#include > + > > #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 > diff --git a/sysdeps/unix/sysv/linux/open64_nocancel.c b/sysdeps/unix/sysv/linux/open64_nocancel.c > new file mode 100644 > index 0000000000..5d039eada6 > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/open64_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > +#include > + > +#include > + > +#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 > diff --git a/sysdeps/unix/sysv/linux/open_nocancel.c b/sysdeps/unix/sysv/linux/open_nocancel.c > new file mode 100644 > index 0000000000..2ee3e527cb > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/open_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#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 > diff --git a/sysdeps/unix/sysv/linux/openat.c b/sysdeps/unix/sysv/linux/openat.c > index 9601e617db..d0ad242271 100644 > --- a/sysdeps/unix/sysv/linux/openat.c > +++ b/sysdeps/unix/sysv/linux/openat.c > @@ -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 > > #include > -#include > > #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 > diff --git a/sysdeps/unix/sysv/linux/openat64.c b/sysdeps/unix/sysv/linux/openat64.c > index 6f14711df3..536f4f5aff 100644 > --- a/sysdeps/unix/sysv/linux/openat64.c > +++ b/sysdeps/unix/sysv/linux/openat64.c > @@ -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 > > #include > -#include > > #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 > diff --git a/sysdeps/unix/sysv/linux/openat64_nocancel.c b/sysdeps/unix/sysv/linux/openat64_nocancel.c > new file mode 100644 > index 0000000000..f3facc3b72 > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/openat64_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > + > +#include > +#include > + > +#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 > diff --git a/sysdeps/unix/sysv/linux/openat_nocancel.c b/sysdeps/unix/sysv/linux/openat_nocancel.c > new file mode 100644 > index 0000000000..ac98238cda > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/openat_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > + > +#include > +#include > + > +#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 > diff --git a/sysdeps/unix/sysv/linux/pause.c b/sysdeps/unix/sysv/linux/pause.c > index 7c8d9f4861..7b90365b98 100644 > --- a/sysdeps/unix/sysv/linux/pause.c > +++ b/sysdeps/unix/sysv/linux/pause.c > @@ -19,7 +19,6 @@ > #include > #include > #include > -#include > > /* 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) > diff --git a/sysdeps/unix/sysv/linux/pause_nocancel.c b/sysdeps/unix/sysv/linux/pause_nocancel.c > new file mode 100644 > index 0000000000..322908c8ea > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/pause_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > +#include > + > +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) > diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h b/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h > index 0fc179a9a1..0956cf04a7 100644 > --- a/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h > +++ b/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h > @@ -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 */ > diff --git a/sysdeps/unix/sysv/linux/pthread_getname.c b/sysdeps/unix/sysv/linux/pthread_getname.c > index 358682f436..726218b4df 100644 > --- a/sysdeps/unix/sysv/linux/pthread_getname.c > +++ b/sysdeps/unix/sysv/linux/pthread_getname.c > @@ -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; > > diff --git a/sysdeps/unix/sysv/linux/pthread_setname.c b/sysdeps/unix/sysv/linux/pthread_setname.c > index 5a8b500128..91b5273480 100644 > --- a/sysdeps/unix/sysv/linux/pthread_setname.c > +++ b/sysdeps/unix/sysv/linux/pthread_setname.c > @@ -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; > > diff --git a/sysdeps/unix/sysv/linux/read.c b/sysdeps/unix/sysv/linux/read.c > index 33ce38aaba..26d0bed404 100644 > --- a/sysdeps/unix/sysv/linux/read.c > +++ b/sysdeps/unix/sysv/linux/read.c > @@ -18,7 +18,6 @@ > > #include > #include > -#include > > /* 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) > diff --git a/sysdeps/unix/sysv/linux/read_nocancel.c b/sysdeps/unix/sysv/linux/read_nocancel.c > new file mode 100644 > index 0000000000..24699e3e21 > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/read_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > + > +ssize_t > +__read_nocancel (int fd, void *buf, size_t nbytes) > +{ > + return INLINE_SYSCALL_CALL (read, fd, buf, nbytes); > +} > +hidden_def (__read_nocancel) > diff --git a/sysdeps/unix/sysv/linux/waitpid.c b/sysdeps/unix/sysv/linux/waitpid.c > index d1d30fd431..8cf00e4efd 100644 > --- a/sysdeps/unix/sysv/linux/waitpid.c > +++ b/sysdeps/unix/sysv/linux/waitpid.c > @@ -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 > #include > #include > -#include > > __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) > diff --git a/sysdeps/unix/sysv/linux/waitpid_nocancel.c b/sysdeps/unix/sysv/linux/waitpid_nocancel.c > new file mode 100644 > index 0000000000..ff1ef3d241 > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/waitpid_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > +#include > +#include > + > +__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) > diff --git a/sysdeps/unix/sysv/linux/write.c b/sysdeps/unix/sysv/linux/write.c > index c96dc6f397..558639d471 100644 > --- a/sysdeps/unix/sysv/linux/write.c > +++ b/sysdeps/unix/sysv/linux/write.c > @@ -18,7 +18,6 @@ > > #include > #include > -#include > > /* 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) > diff --git a/sysdeps/unix/sysv/linux/write_nocancel.c b/sysdeps/unix/sysv/linux/write_nocancel.c > new file mode 100644 > index 0000000000..6fe1ea2aaa > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/write_nocancel.c > @@ -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 > + . */ > + > +#include > +#include > +#include > + > +ssize_t > +__write_nocancel (int fd, const void *buf, size_t nbytes) > +{ > + return INLINE_SYSCALL_CALL (write, fd, buf, nbytes); > +} > +hidden_def (__write_nocancel) >