diff mbox

[1/8] Use inline syscalls for non-cancellable versions

Message ID 5435AD71.4060506@linux.vnet.ibm.com
State Dropped
Headers show

Commit Message

Adhemerval Zanella Netto Oct. 8, 2014, 9:32 p.m. UTC
This patch uses inline calls (through INLINE_SYSCALL macro) to define
the non-cancellable functions macros to avoid use of the
syscall_nocancel entrypoints.

Checked on x86_64, ppc32, and ppc64.

--

	* sysdeps/unix/sysv/linux/not-cancel.h (open_not_cancel): Rewrite to
	be an inline implementation regardless of library is built within.
	(open_not_cancel_2): Likewise.
	(__read_nocancel): Likewise.
	(__write_nocancel): Likewise.
	(openat_not_cancel): Likewise.
	(openat_not_cancel_3): Likewise.
	(openat64_not_cancel): Likewise.
	(openat64_not_cancel_3): Likewise.
	(__close_nocancel): Likewise.
	(pause_not_cancel): Likewise.
	(nanosleep_not_cancel): Likewise.
	(sigsuspend_not_cancel): Likewise.

---

Comments

Roland McGrath Oct. 8, 2014, 9:50 p.m. UTC | #1
> +  ({ int __ret = INLINE_SYSCALL (open, 3, name, flags, mode); \
> +     __ret; })

What's the purpose of the statement expression and the result variable?
Why isn't the rhs just the INLINE_SYSCALL invocation directly, or with
an (int) cast if need be?

Same for several more instances below.

> +#define __read_nocancel(fd, buf, len) \
> +  ({ ssize_t __ret = INLINE_SYSCALL (read, 3, fd, buf, len); \
> +     __ret; })


What's the purpose of the extra __read_nocancel macro layer?
Why isn't this just the definition of read_not_cancel?

Same for write and close, below.

> +#define waitpid_nocancel(pid, stat_loc, options) \
>    INLINE_SYSCALL (wait4, 4, pid, stat_loc, options, NULL)
> +#define waitpid_not_cancel(pid, stat_loc, options) \
> +  waitpid_nocancel(pid, stat_loc, options)

Here without the __ prefix the extra macro layer looks even more insane.


Thanks,
Roland
diff mbox

Patch

diff --git a/sysdeps/unix/sysv/linux/not-cancel.h b/sysdeps/unix/sysv/linux/not-cancel.h
index 14f5e8b..1bef315 100644
--- a/sysdeps/unix/sysv/linux/not-cancel.h
+++ b/sysdeps/unix/sysv/linux/not-cancel.h
@@ -17,48 +17,50 @@ 
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
-#include <sysdep.h>
+#ifndef NOT_CANCEL_H
+# define NOT_CANCEL_H
 
-#if !defined NOT_IN_libc || defined IS_IN_libpthread || defined IS_IN_librt
-extern int __open_nocancel (const char *, int, ...) attribute_hidden;
-extern int __close_nocancel (int) attribute_hidden;
-extern int __read_nocancel (int, void *, size_t) attribute_hidden;
-extern int __write_nocancel (int, const void *, size_t) attribute_hidden;
-extern pid_t __waitpid_nocancel (pid_t, int *, int) attribute_hidden;
-extern int __openat_nocancel (int fd, const char *fname, int oflag,
-				mode_t mode) attribute_hidden;
-extern int __openat64_nocancel (int fd, const char *fname, int oflag,
-				  mode_t mode) attribute_hidden;
-#else
-# define __open_nocancel(name, ...) __open (name, __VA_ARGS__)
-# define __close_nocancel(fd) __close (fd)
-# define __read_nocancel(fd, buf, len) __read (fd, buf, len)
-# define __write_nocancel(fd, buf, len) __write (fd, buf, len)
-# define __waitpid_nocancel(pid, stat_loc, options) \
-  __waitpid (pid, stat_loc, options)
-# define __openat_nocancel(fd, fname, oflag, mode) \
-  openat (fd, fname, oflag, mode)
-# define __openat64_nocancel(fd, fname, oflag, mode) \
-  openat64 (fd, fname, oflag, mode)
-#endif
+#include <sysdep.h>
+#include <errno.h>
 
 /* Uncancelable open.  */
 #define open_not_cancel(name, flags, mode) \
-   __open_nocancel (name, flags, mode)
+  ({ int __ret = INLINE_SYSCALL (open, 3, name, flags, mode); \
+     __ret; })
 #define open_not_cancel_2(name, flags) \
-   __open_nocancel (name, flags)
+  ({ int __ret = INLINE_SYSCALL (open, 2, name, flags); \
+     __ret; })
+
+/* Uncancelable read.  */
+#define __read_nocancel(fd, buf, len) \
+  ({ ssize_t __ret = INLINE_SYSCALL (read, 3, fd, buf, len); \
+     __ret; })
+
+/* Uncancelable write.  */
+#define __write_nocancel(fd, buf, len) \
+  ({ ssize_t __ret = INLINE_SYSCALL (write, 3, fd, buf, len); \
+     __ret; })
 
 /* Uncancelable openat.  */
 #define openat_not_cancel(fd, fname, oflag, mode) \
-  __openat_nocancel (fd, fname, oflag, mode)
+  ({ int __ret = INLINE_SYSCALL (openat, 4, fd, fname, oflag, mode); \
+     __ret; })
 #define openat_not_cancel_3(fd, fname, oflag) \
-  __openat_nocancel (fd, fname, oflag, 0)
+  ({ int __ret = INLINE_SYSCALL (openat, 3, fd, fname, oflag); \
+     __ret; })
 #define openat64_not_cancel(fd, fname, oflag, mode) \
-  __openat64_nocancel (fd, fname, oflag, mode)
+  ({ int __ret = INLINE_SYSCALL (openat, 4, fd, fname, \
+				 oflag | O_LARGEFILE, mode); \
+     __ret; })
 #define openat64_not_cancel_3(fd, fname, oflag) \
-  __openat64_nocancel (fd, fname, oflag, 0)
+  ({ int __ret = INLINE_SYSCALL (openat, 3, fd, fname, \
+				 oflag | O_LARGEFILE); \
+     __ret; })
 
 /* Uncancelable close.  */
+#define __close_nocancel(fd) \
+ ({ int __ret = INLINE_SYSCALL (close, 1, fd); \
+    __ret; })
 #define close_not_cancel(fd) \
   __close_nocancel (fd)
 #define close_not_cancel_no_status(fd) \
@@ -83,17 +85,29 @@  extern int __openat64_nocancel (int fd, const char *fname, int oflag,
   __fcntl_nocancel (fd, cmd, val)
 
 /* Uncancelable waitpid.  */
-#define waitpid_not_cancel(pid, stat_loc, options) \
+#define waitpid_nocancel(pid, stat_loc, options) \
   INLINE_SYSCALL (wait4, 4, pid, stat_loc, options, NULL)
+#define waitpid_not_cancel(pid, stat_loc, options) \
+  waitpid_nocancel(pid, stat_loc, options)
 
 /* Uncancelable pause.  */
 #define pause_not_cancel() \
-  __pause_nocancel ()
+  ({ sigset_t set; 							     \
+     int __rc = INLINE_SYSCALL (rt_sigprocmask, 4, SIG_BLOCK, NULL, &set,    \
+				_NSIG / 8);				     \
+     if (__rc == 0)							     \
+       __rc = INLINE_SYSCALL (rt_sigsuspend, 2, &set, _NSIG / 8);	     \
+     __rc;								     \
+  })
 
 /* Uncancelable nanosleep.  */
 #define nanosleep_not_cancel(requested_time, remaining) \
-  __nanosleep_nocancel (requested_time, remaining)
+  ({ int __ret = INLINE_SYSCALL (nanosleep, 2, requested_time, remaining);   \
+     __ret; })
 
 /* Uncancelable sigsuspend.  */
 #define sigsuspend_not_cancel(set) \
-  __sigsuspend_nocancel (set)
+  ({ int __ret = INLINE_SYSCALL (rt_sigsuspend, 2, set, _NSIG / 8);	     \
+     __ret; })
+
+#endif /* NOT_CANCEL_H  */