This is the mail archive of the
libc-alpha@sourceware.org
mailing list for the glibc project.
Re: [PATCH] RFC: avoid cancellable I/O primitives in ld.so
- From: Adhemerval Zanella <adhemerval dot zanella at linaro dot org>
- To: libc-alpha at sourceware dot org
- Date: Thu, 5 Apr 2018 09:32:17 -0300
- Subject: Re: [PATCH] RFC: avoid cancellable I/O primitives in ld.so
- Autocrypt: addr=adhemerval dot zanella at linaro dot org; prefer-encrypt=mutual; keydata= xsFNBFcVGkoBEADiQU2x/cBBmAVf5C2d1xgz6zCnlCefbqaflUBw4hB/bEME40QsrVzWZ5Nq 8kxkEczZzAOKkkvv4pRVLlLn/zDtFXhlcvQRJ3yFMGqzBjofucOrmdYkOGo0uCaoJKPT186L NWp53SACXguFJpnw4ODI64ziInzXQs/rUJqrFoVIlrPDmNv/LUv1OVPKz20ETjgfpg8MNwG6 iMizMefCl+RbtXbIEZ3TE/IaDT/jcOirjv96lBKrc/pAL0h/O71Kwbbp43fimW80GhjiaN2y WGByepnkAVP7FyNarhdDpJhoDmUk9yfwNuIuESaCQtfd3vgKKuo6grcKZ8bHy7IXX1XJj2X/ BgRVhVgMHAnDPFIkXtP+SiarkUaLjGzCz7XkUn4XAGDskBNfbizFqYUQCaL2FdbW3DeZqNIa nSzKAZK7Dm9+0VVSRZXP89w71Y7JUV56xL/PlOE+YKKFdEw+gQjQi0e+DZILAtFjJLoCrkEX w4LluMhYX/X8XP6/C3xW0yOZhvHYyn72sV4yJ1uyc/qz3OY32CRy+bwPzAMAkhdwcORA3JPb kPTlimhQqVgvca8m+MQ/JFZ6D+K7QPyvEv7bQ7M+IzFmTkOCwCJ3xqOD6GjX3aphk8Sr0dq3 4Awlf5xFDAG8dn8Uuutb7naGBd/fEv6t8dfkNyzj6yvc4jpVxwARAQABzUlBZGhlbWVydmFs IFphbmVsbGEgTmV0dG8gKExpbmFybyBWUE4gS2V5KSA8YWRoZW1lcnZhbC56YW5lbGxhQGxp bmFyby5vcmc+wsF3BBMBCAAhBQJXFRpKAhsDBQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJ EKqx7BSnlIjv0e8P/1YOYoNkvJ+AJcNUaM5a2SA9oAKjSJ/M/EN4Id5Ow41ZJS4lUA0apSXW NjQg3VeVc2RiHab2LIB4MxdJhaWTuzfLkYnBeoy4u6njYcaoSwf3g9dSsvsl3mhtuzm6aXFH /Qsauav77enJh99tI4T+58rp0EuLhDsQbnBic/ukYNv7sQV8dy9KxA54yLnYUFqH6pfH8Lly sTVAMyi5Fg5O5/hVV+Z0Kpr+ZocC1YFJkTsNLAW5EIYSP9ftniqaVsim7MNmodv/zqK0IyDB GLLH1kjhvb5+6ySGlWbMTomt/or/uvMgulz0bRS+LUyOmlfXDdT+t38VPKBBVwFMarNuREU2 69M3a3jdTfScboDd2ck1u7l+QbaGoHZQ8ZNUrzgObltjohiIsazqkgYDQzXIMrD9H19E+8fw kCNUlXxjEgH/Kg8DlpoYJXSJCX0fjMWfXywL6ZXc2xyG/hbl5hvsLNmqDpLpc1CfKcA0BkK+ k8R57fr91mTCppSwwKJYO9T+8J+o4ho/CJnK/jBy1pWKMYJPvvrpdBCWq3MfzVpXYdahRKHI ypk8m4QlRlbOXWJ3TDd/SKNfSSrWgwRSg7XCjSlR7PNzNFXTULLB34sZhjrN6Q8NQZsZnMNs TX8nlGOVrKolnQPjKCLwCyu8PhllU8OwbSMKskcD1PSkG6h3r0AqzsFNBFcVGkoBEACgAdbR Ck+fsfOVwT8zowMiL3l9a2DP3Eeak23ifdZG+8Avb/SImpv0UMSbRfnw/N81IWwlbjkjbGTu oT37iZHLRwYUFmA8fZX0wNDNKQUUTjN6XalJmvhdz9l71H3WnE0wneEM5ahu5V1L1utUWTyh VUwzX1lwJeV3vyrNgI1kYOaeuNVvq7npNR6t6XxEpqPsNc6O77I12XELic2+36YibyqlTJIQ V1SZEbIy26AbC2zH9WqaKyGyQnr/IPbTJ2Lv0dM3RaXoVf+CeK7gB2B+w1hZummD21c1Laua +VIMPCUQ+EM8W9EtX+0iJXxI+wsztLT6vltQcm+5Q7tY+HFUucizJkAOAz98YFucwKefbkTp eKvCfCwiM1bGatZEFFKIlvJ2QNMQNiUrqJBlW9nZp/k7pbG3oStOjvawD9ZbP9e0fnlWJIsj 6c7pX354Yi7kxIk/6gREidHLLqEb/otuwt1aoMPg97iUgDV5mlNef77lWE8vxmlY0FBWIXuZ yv0XYxf1WF6dRizwFFbxvUZzIJp3spAao7jLsQj1DbD2s5+S1BW09A0mI/1DjB6EhNN+4bDB SJCOv/ReK3tFJXuj/HbyDrOdoMt8aIFbe7YFLEExHpSk+HgN05Lg5TyTro8oW7TSMTk+8a5M kzaH4UGXTTBDP/g5cfL3RFPl79ubXwARAQABwsFfBBgBCAAJBQJXFRpKAhsMAAoJEKqx7BSn lIjvI/8P/jg0jl4Tbvg3B5kT6PxJOXHYu9OoyaHLcay6Cd+ZrOd1VQQCbOcgLFbf4Yr+rE9l mYsY67AUgq2QKmVVbn9pjvGsEaz8UmfDnz5epUhDxC6yRRvY4hreMXZhPZ1pbMa6A0a/WOSt AgFj5V6Z4dXGTM/lNManr0HjXxbUYv2WfbNt3/07Db9T+GZkpUotC6iknsTA4rJi6u2ls0W9 1UIvW4o01vb4nZRCj4rni0g6eWoQCGoVDk/xFfy7ZliR5B+3Z3EWRJcQskip/QAHjbLa3pml xAZ484fVxgeESOoaeC9TiBIp0NfH8akWOI0HpBCiBD5xaCTvR7ujUWMvhsX2n881r/hNlR9g fcE6q00qHSPAEgGr1bnFv74/1vbKtjeXLCcRKk3Ulw0bY1OoDxWQr86T2fZGJ/HIZuVVBf3+ gaYJF92GXFynHnea14nFFuFgOni0Mi1zDxYH/8yGGBXvo14KWd8JOW0NJPaCDFJkdS5hu0VY 7vJwKcyHJGxsCLU+Et0mryX8qZwqibJIzu7kUJQdQDljbRPDFd/xmGUFCQiQAncSilYOcxNU EMVCXPAQTteqkvA+gNqSaK1NM9tY0eQ4iJpo+aoX8HAcn4sZzt2pfUB9vQMTBJ2d4+m/qO6+ cFTAceXmIoFsN8+gFN3i8Is3u12u8xGudcBPvpoy4OoG
- Openpgp: preference=signencrypt
- References: <20180404014319.7339-1-zackw@panix.com>
On 03/04/2018 22:43, Zack Weinberg wrote:
> 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; in
> addition to streamlining low-level operations, this means we do not
> require a copy of nptl/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), so there's a chunk of
> code to share between fcntl and __fcntl_nocancel. The only nontrivial
> definition of FCNTL_ADJUST_CMD needed to move from
> sysdeps/unix/sysv/linux/powerpc/powerpc64/fcntl.c to .../sysdep.h so
> that both fcntl.c and fcntl_nocancel.c could see it, and I also
> changed it from a clever arithmetic expression to a chain of ternaries
> to make it more obviously idempotent.
>
> 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.
>
> I attempted to make sure this stays fixed by making libc-cancellation.c
> issue an #error if IS_IN(rtld), but I'm not sure that part works.
>
> (Yes, this is still in the chain of yaks needing to be shaved in order
> to finish the C99-scanf patches. Don't ask.)
I agree that splitting not-cancel implementation in their own files is a
good refactor for the same reasons (explict stating the desired semantic,
ld will pull only the specific implementation and less preprocessor
tikering on default implementations).
>
> zw
>
> * 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,
> __open_nocancel instead of __open, __read_nocancel instead of
> __libc_read, and __write_nocancel instead of __libc_write.
> * csu/check_fds/c (check_one_fd): Use __fcntl_nocancel.
> * sysdeps/posix/fdopendir.c (__fdopendir): Likewise.
> * sysdeps/posix/opendir.c (__alloc_dir): Likewise.
>
> * 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.
>
> * sysdeps/unix/sysv/linux/fcntl.c (__libc_fcntl): Call
> __fcntl_nocancel, not fcntl_common.
> (fcntl_common, __fcntl_nocancel): Combine and move to ...
> * sysdeps/unix/sysv/linux/fcntl_nocancel.c: ...this 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.
>
> * 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.
> ---
> csu/check_fds.c | 6 ++-
> elf/dl-load.c | 35 ++++++-------
> elf/dl-misc.c | 6 +--
> elf/dl-profile.c | 14 +++---
> elf/rtld.c | 3 +-
> nptl/libc-cancellation.c | 3 ++
> sysdeps/posix/fdopendir.c | 7 ++-
> sysdeps/posix/opendir.c | 7 ++-
> 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 | 38 +-------------
> sysdeps/unix/sysv/linux/fcntl_nocancel.c | 58 ++++++++++++++++++++++
> sysdeps/unix/sysv/linux/nanosleep.c | 8 ---
> sysdeps/unix/sysv/linux/nanosleep_nocancel.c | 29 +++++++++++
> sysdeps/unix/sysv/linux/not-cancel.h | 25 ++++++----
> sysdeps/unix/sysv/linux/open.c | 22 --------
> sysdeps/unix/sysv/linux/open64.c | 27 +---------
> sysdeps/unix/sysv/linux/open64_nocancel.c | 53 ++++++++++++++++++++
> sysdeps/unix/sysv/linux/open_nocancel.c | 46 +++++++++++++++++
> sysdeps/unix/sysv/linux/openat.c | 21 --------
> sysdeps/unix/sysv/linux/openat64.c | 24 ---------
> sysdeps/unix/sysv/linux/openat64_nocancel.c | 50 +++++++++++++++++++
> sysdeps/unix/sysv/linux/openat_nocancel.c | 42 ++++++++++++++++
> sysdeps/unix/sysv/linux/pause.c | 12 -----
> sysdeps/unix/sysv/linux/pause_nocancel.c | 33 ++++++++++++
> sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h | 9 ++++
> sysdeps/unix/sysv/linux/read.c | 12 -----
> sysdeps/unix/sysv/linux/read_nocancel.c | 28 +++++++++++
> sysdeps/unix/sysv/linux/waitpid.c | 12 -----
> sysdeps/unix/sysv/linux/waitpid_nocancel.c | 33 ++++++++++++
> sysdeps/unix/sysv/linux/write.c | 12 -----
> sysdeps/unix/sysv/linux/write_nocancel.c | 28 +++++++++++
> 34 files changed, 490 insertions(+), 258 deletions(-)
> 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/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..108f6d5137 100644
> --- a/csu/check_fds.c
> +++ b/csu/check_fds.c
> @@ -39,8 +39,10 @@
> 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
> + /* fcntl(F_GETFD) is not a cancellation point, but we still use
> + __fcntl_nocancel so that it is *statically* not a cancellation
> + point, which matters to the code that constructs ld.so. */
> + if (__builtin_expect (__fcntl_nocancel (fd, F_GETFD), 0) == -1
> && errno == EBADF)
> {
> const char *name;
I think we could just omit the comment, the function name is explicit enough.
> diff --git a/elf/dl-load.c b/elf/dl-load.c
> index a5e3a25462..0f257f51bd 100644
> --- a/elf/dl-load.c
> +++ b/elf/dl-load.c
> @@ -44,7 +44,7 @@
> #include <dl-unmap-segments.h>
> #include <dl-machine-reject-phdr.h>
> #include <dl-sysdep-open.h>
> -
> +#include <not-cancel.h>
>
> #include <endian.h>
> #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 = __open_nocancel (name, O_RDONLY | O_CLOEXEC);
I think there is no reason to continue using non-LFS interface on loader, so
change to __open64_nocancel (so eventually we can get rid of non-LFS no cancel
implementations).
>
> if (fd != -1)
> {
> @@ -1473,8 +1473,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;
> @@ -1597,7 +1597,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;
> @@ -1635,7 +1636,7 @@ open_verify (const char *name, int fd,
> {
> abi_note = alloca (size);
> __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)
> goto read_error;
> }
>
> @@ -1664,7 +1665,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;
> }
> @@ -1780,7 +1781,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'. */
> @@ -1801,7 +1802,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;
> }
> }
Ok.
> diff --git a/elf/dl-misc.c b/elf/dl-misc.c
> index b7174994cd..c46281cb0c 100644
> --- a/elf/dl-misc.c
> +++ b/elf/dl-misc.c
> @@ -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 = __open_nocancel (file, O_RDONLY | O_CLOEXEC);
Same comment for non-LFS usage.
> 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;
> }
Ok.
> diff --git a/elf/dl-profile.c b/elf/dl-profile.c
> index 7f15352123..cf9ec2297f 100644
> --- a/elf/dl-profile.c
> +++ b/elf/dl-profile.c
> @@ -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 = __open_nocancel (filename, O_RDWR | O_CREAT | O_NOFOLLOW, DEFFILEMODE);
Same comment for non-LFS usage.
> 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);
Ok.
> diff --git a/elf/rtld.c b/elf/rtld.c
> index f8d9597cdd..bb6fb0fa4c 100644
> --- a/elf/rtld.c
> +++ b/elf/rtld.c
> @@ -41,6 +41,7 @@
> #include <tls.h>
> #include <stap-probe.h>
> #include <stackinfo.h>
> +#include <not-cancel.h>
>
> #include <assert.h>
>
> @@ -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) = __open_nocancel (startp, flags, DEFFILEMODE);
Same comment for non-LFS usage.
> if (GLRO(dl_debug_fd) == -1)
> /* We use standard output if opening the file failed. */
> GLRO(dl_debug_fd) = STDOUT_FILENO;
> diff --git a/nptl/libc-cancellation.c b/nptl/libc-cancellation.c
> index aef5b5d321..076c9015b5 100644
> --- a/nptl/libc-cancellation.c
> +++ b/nptl/libc-cancellation.c
> @@ -18,6 +18,9 @@
>
> #include "pthreadP.h"
>
> +#if IS_IN (rtld)
> +# error "Cancellation should not occur within rtld"
> +#endif
>
> #define __pthread_enable_asynccancel __libc_enable_asynccancel
> #define __pthread_disable_asynccancel __libc_disable_asynccancel
Not sure if this check is really required, since cancellation hooks for
enable/disable will be empty definitions for loader.
> diff --git a/sysdeps/posix/fdopendir.c b/sysdeps/posix/fdopendir.c
> index ab4541f7fc..6e235223e5 100644
> --- a/sysdeps/posix/fdopendir.c
> +++ b/sysdeps/posix/fdopendir.c
> @@ -37,8 +37,11 @@ __fdopendir (int fd)
> return NULL;
> }
>
> - /* Make sure the descriptor allows for reading. */
> - int flags = __fcntl (fd, F_GETFL);
> + /* Make sure the descriptor allows for reading. fcntl(F_GETFL) is
> + not a cancellation point, but we still use __fcntl_nocancel so
> + that it is *statically* not a cancellation point, which matters
> + to the code constructing ld.so. */
> + int flags = __fcntl_nocancel (fd, F_GETFL);
> if (__glibc_unlikely (flags == -1))
> return NULL;
> if (__glibc_unlikely ((flags & O_ACCMODE) == O_WRONLY))
Ok (although I think the symbols name is explicit enough to define the
expected semantic).
> diff --git a/sysdeps/posix/opendir.c b/sysdeps/posix/opendir.c
> index dea23b2ff5..bc6a9c94a1 100644
> --- a/sysdeps/posix/opendir.c
> +++ b/sysdeps/posix/opendir.c
> @@ -97,9 +97,12 @@ DIR *
> __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. */
> + file descriptor. fcntl(F_SETFD) is not a cancellation point,
> + but we still use __fcntl_nocancel so that it is *statically*
> + not a cancellation point, which matters to the code that
> + constructs ld.so. */
> if (!close_fd
> - && __builtin_expect (__fcntl (fd, F_SETFD, FD_CLOEXEC), 0) < 0)
> + && __builtin_expect (__fcntl_nocancel (fd, F_SETFD, FD_CLOEXEC), 0) < 0)
> goto lose;
>
> const size_t default_allocation = (4 * BUFSIZ < sizeof (struct dirent64)
Use __glibc_likely.
> diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile
> index 8f19e0efc3..5f99a1c54c 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
Ok.
> 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)
Ok.
> 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..21f8b6203c 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.
I think it is worth to add it has no cancellable semantic.
> + Copyright (C) 2017-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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/dl-sysdep.c b/sysdeps/unix/sysv/linux/dl-sysdep.c
> index b4cda3486a..40eae0d87f 100644
> --- a/sysdeps/unix/sysv/linux/dl-sysdep.c
> +++ b/sysdeps/unix/sysv/linux/dl-sysdep.c
> @@ -25,6 +25,7 @@
> #include <sys/param.h>
> #include <sys/utsname.h>
> #include <ldsodefs.h>
> +#include <not-cancel.h>
>
> #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 = __open_nocancel ("/proc/sys/kernel/osrelease", O_RDONLY);
Same comment for non-LFS usage.
> 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..b5bd045a1b 100644
> --- a/sysdeps/unix/sysv/linux/fcntl.c
> +++ b/sysdeps/unix/sysv/linux/fcntl.c
> @@ -29,24 +29,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 +44,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 (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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/fcntl_nocancel.c b/sysdeps/unix/sysv/linux/fcntl_nocancel.c
> new file mode 100644
> index 0000000000..49f00cb79f
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/fcntl_nocancel.c
> @@ -0,0 +1,58 @@
> +/* Copyright (C) 2000-2018 Free Software Foundation, Inc.
Copyright date and one line comment.
> + 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);
> +
> + 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);
> +}
> +hidden_def (__fcntl_nocancel)
> diff --git a/sysdeps/unix/sysv/linux/nanosleep.c b/sysdeps/unix/sysv/linux/nanosleep.c
> index 8945837407..3cc13a87f9 100644
> --- a/sysdeps/unix/sysv/linux/nanosleep.c
> +++ b/sysdeps/unix/sysv/linux/nanosleep.c
> @@ -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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c
> new file mode 100644
> index 0000000000..1d8bb551b8
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c
> @@ -0,0 +1,29 @@
> +/* Linux high resolution nanosleep implementation.
I think it is worth to add it has no cancellable semantic.
> + Copyright (C) 2017-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)
> 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 */
Ok.
> diff --git a/sysdeps/unix/sysv/linux/open.c b/sysdeps/unix/sysv/linux/open.c
> index c189e285c9..6984b272ac 100644
> --- a/sysdeps/unix/sysv/linux/open.c
> +++ b/sysdeps/unix/sysv/linux/open.c
> @@ -22,7 +22,6 @@
> #include <stdarg.h>
>
> #include <sysdep-cancel.h>
> -#include <not-cancel.h>
>
> #ifndef __OFF_T_MATCHES_OFF64_T
>
> @@ -48,25 +47,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
Ok.
> diff --git a/sysdeps/unix/sysv/linux/open64.c b/sysdeps/unix/sysv/linux/open64.c
> index 4af5ee2466..b7dbfa91d6 100644
> --- a/sysdeps/unix/sysv/linux/open64.c
> +++ b/sysdeps/unix/sysv/linux/open64.c
> @@ -21,7 +21,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 +52,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
Ok, although it will incur in a slight code increase due __open_nocancel and
__open64_nocancel not being alias anymore for __OFF_T_MATCHES_OFF64_T
architectures (same applies for openat64).
> diff --git a/sysdeps/unix/sysv/linux/open64_nocancel.c b/sysdeps/unix/sysv/linux/open64_nocancel.c
> new file mode 100644
> index 0000000000..ce2229bcf3
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/open64_nocancel.c
> @@ -0,0 +1,53 @@
> +/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
Copyright date and one line comment.
> + 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
> diff --git a/sysdeps/unix/sysv/linux/open_nocancel.c b/sysdeps/unix/sysv/linux/open_nocancel.c
> new file mode 100644
> index 0000000000..64dcb0e536
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/open_nocancel.c
> @@ -0,0 +1,46 @@
> +/* 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.
Copyright date, one line comment, and I think we can omit the 'Contributed by'
now (it quite different than the original generic implementation).
> +
> + 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
Ok.
> diff --git a/sysdeps/unix/sysv/linux/openat.c b/sysdeps/unix/sysv/linux/openat.c
> index 9601e617db..181cdc6105 100644
> --- a/sysdeps/unix/sysv/linux/openat.c
> +++ b/sysdeps/unix/sysv/linux/openat.c
> @@ -19,7 +19,6 @@
> #include <stdarg.h>
>
> #include <sysdep-cancel.h>
> -#include <not-cancel.h>
>
> #ifndef __OFF_T_MATCHES_OFF64_T
>
> @@ -43,24 +42,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
Ok.
> diff --git a/sysdeps/unix/sysv/linux/openat64.c b/sysdeps/unix/sysv/linux/openat64.c
> index 6f14711df3..818ddc51f0 100644
> --- a/sysdeps/unix/sysv/linux/openat64.c
> +++ b/sysdeps/unix/sysv/linux/openat64.c
> @@ -19,7 +19,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 +48,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
Ok.
> diff --git a/sysdeps/unix/sysv/linux/openat64_nocancel.c b/sysdeps/unix/sysv/linux/openat64_nocancel.c
> new file mode 100644
> index 0000000000..ce342dfc0d
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/openat64_nocancel.c
> @@ -0,0 +1,50 @@
> +/* Copyright (C) 2007-2018 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
Copyright date and one line comment.
> +
> + 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
Ok.
> diff --git a/sysdeps/unix/sysv/linux/openat_nocancel.c b/sysdeps/unix/sysv/linux/openat_nocancel.c
> new file mode 100644
> index 0000000000..0cfc94565c
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/openat_nocancel.c
> @@ -0,0 +1,42 @@
> +/* Copyright (C) 2005-2018 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
Copyright date and one line comment.
> +
> + 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
Ok.
> 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 <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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/pause_nocancel.c b/sysdeps/unix/sysv/linux/pause_nocancel.c
> new file mode 100644
> index 0000000000..58e0445679
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/pause_nocancel.c
> @@ -0,0 +1,33 @@
> +/* Linux pause syscall implementation.
I think it is worth to add it has no cancellable semantic.
> + Copyright (C) 2017-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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h b/sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h
> index 0fc179a9a1..ba500e5f84 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); \
> + cmd_ == F_GETLK64 ? F_GETLK : \
> + cmd_ == F_SETLK64 ? F_SETLK : \
> + cmd_ == F_SETLKW64 ? F_SETLKW : cmd_ })
> +
> +
I am getting a:
error: expected ‘;’ before ‘}’ token
cmd_ == F_SETLKW64 ? F_SETLKW : cmd_ })
with this snippet and I am not sure it is worth to change this code on this patch.
Also, I think a better option would to place it on kernel-features.h (since it
usually the place to define architecture kernel abi idiossiacrassies).
> #endif /* linux/powerpc/powerpc64/sysdep.h */
> 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 <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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/read_nocancel.c b/sysdeps/unix/sysv/linux/read_nocancel.c
> new file mode 100644
> index 0000000000..fe3a716639
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/read_nocancel.c
> @@ -0,0 +1,28 @@
> +/* Linux read syscall implementation.
I think it is worth to add it has no cancellable semantic.
> + Copyright (C) 2017-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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/waitpid.c b/sysdeps/unix/sysv/linux/waitpid.c
> index d1d30fd431..a05d908c7b 100644
> --- a/sysdeps/unix/sysv/linux/waitpid.c
> +++ b/sysdeps/unix/sysv/linux/waitpid.c
> @@ -19,7 +19,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 +31,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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/waitpid_nocancel.c b/sysdeps/unix/sysv/linux/waitpid_nocancel.c
> new file mode 100644
> index 0000000000..f8f3231f32
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/waitpid_nocancel.c
> @@ -0,0 +1,33 @@
> +/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
Copyright date and one line comment.
> +
> + 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)
Ok.
> 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 <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)
Ok.
> diff --git a/sysdeps/unix/sysv/linux/write_nocancel.c b/sysdeps/unix/sysv/linux/write_nocancel.c
> new file mode 100644
> index 0000000000..696f40beec
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/write_nocancel.c
> @@ -0,0 +1,28 @@
> +/* Linux write syscall implementation.
I think it is worth to add it has no cancellable semantic.
> + Copyright (C) 2017-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)
>
Ok.