+2017-08-18 Adhemerval Zanella <adhemerval.zanella@linaro.org>
+
+ * sysdeps/generic/not-cancel.h (read_not_cancel): Remove macro.
+ (__read_nocancel): New macro.
+ * sysdeps/unix/sysv/linux/Versions (libc) [GLIBC_PRIVATE]: Add
+ __read_nocancel.
+ * sysdeps/unix/sysv/linux/not-cancel.h (__read_nocancel): Remove
+ macro.
+ (__read_nocancel): New prototype.
+ * sysdeps/unix/sysv/linux/read.c (__read_nocancel): New function.
+ * catgets/open_catalog.c (__open_catalog): Replace read_not_cancel
+ with __read_nocancel.
+ * intl/loadmsgcat.c (read): Likewise.
+ * libio/fileops.c (_IO_file_read): Likewise.
+ * locale/loadlocale.c (_nl_load_locale): Likewise.
+ * login/utmp_file.c (getutent_r_file): Likewise.
+ (internal_getut_r): Likewise.
+ (getutline_r_file): Likewise.
+ * sysdeps/unix/sysv/linux/fips-private.h (fips_enable_p): Likewise.
+ * sysdeps/unix/sysv/linux/gethostid.c (gethostid): Likewise.
+ * sysdeps/unix/sysv/linux/getloadavg.c (getloadavg): Likewise.
+ * sysdeps/unix/sysv/linux/getlogin_r.c (__getlogin_r_loginuid):
+ Likewise.
+ * sysdeps/unix/sysv/linux/getsysstats.c (next_line): Likewise.
+ * sysdeps/unix/sysv/linux/i386/smp.h (is_smp_system): Likewise.
+ * sysdeps/unix/sysv/linux/ia64/has_cpuclock.c (has_cpuclock):
+ Likewise.
+ * sysdeps/unix/sysv/linux/libc_fatal.c (backtrace_and_maps):
+ Likewise.
+ * sysdeps/unix/sysv/linux/malloc-sysdep.h (check_may_shrink_heap):
+ Likewise.
+ * sysdeps/unix/sysv/linux/pthread_getname.c (pthread_getname_np):
+ Likewise.
+ * sysdeps/unix/sysv/linux/sysconf.c (__sysconf): Likewise.
+
2017-08-18 H.J. Lu <hongjiu.lu@intel.com>
[BZ #21966]
/* Save read, handle partial reads. */
do
{
- size_t now = read_not_cancel (fd, (((char *) catalog->file_ptr)
+ size_t now = __read_nocancel (fd, (((char *) catalog->file_ptr)
+ (st.st_size - todo)), todo);
if (now == 0 || now == (size_t) -1)
{
file and the name space must not be polluted. */
# define open(name, flags) __open_nocancel (name, flags)
# define close(fd) close_not_cancel_no_status (fd)
-# define read(fd, buf, n) read_not_cancel (fd, buf, n)
+# define read(fd, buf, n) __read_nocancel (fd, buf, n)
# define mmap(addr, len, prot, flags, fd, offset) \
__mmap (addr, len, prot, flags, fd, offset)
# define munmap(addr, len) __munmap (addr, len)
_IO_file_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
{
return (__builtin_expect (fp->_flags2 & _IO_FLAGS2_NOTCANCEL, 0)
- ? read_not_cancel (fp->_fileno, buf, size)
+ ? __read_nocancel (fp->_fileno, buf, size)
: read (fp->_fileno, buf, size));
}
libc_hidden_def (_IO_file_read)
char *p = (char *) filedata;
while (to_read > 0)
{
- nread = read_not_cancel (fd, p, to_read);
+ nread = __read_nocancel (fd, p, to_read);
if (__builtin_expect (nread, 1) <= 0)
{
free (filedata);
}
/* Read the next entry. */
- nbytes = read_not_cancel (file_fd, &last_entry, sizeof (struct utmp));
+ nbytes = __read_nocancel (file_fd, &last_entry, sizeof (struct utmp));
UNLOCK_FILE (file_fd);
while (1)
{
/* Read the next entry. */
- if (read_not_cancel (file_fd, buffer, sizeof (struct utmp))
+ if (__read_nocancel (file_fd, buffer, sizeof (struct utmp))
!= sizeof (struct utmp))
{
__set_errno (ESRCH);
while (1)
{
/* Read the next entry. */
- if (read_not_cancel (file_fd, buffer, sizeof (struct utmp))
+ if (__read_nocancel (file_fd, buffer, sizeof (struct utmp))
!= sizeof (struct utmp))
{
__set_errno (ESRCH);
while (1)
{
/* Read the next entry. */
- if (read_not_cancel (file_fd, &last_entry, sizeof (struct utmp))
+ if (__read_nocancel (file_fd, &last_entry, sizeof (struct utmp))
!= sizeof (struct utmp))
{
__set_errno (ESRCH);
__close (fd)
#define close_not_cancel_no_status(fd) \
(void) __close (fd)
-#define read_not_cancel(fd, buf, n) \
+#define __read_nocancel(fd, buf, n) \
__read (fd, buf, n)
#define write_not_cancel(fd, buf, n) \
__write (fd, buf, n)
# functions used in other libraries
__syscall_rt_sigqueueinfo;
__open_nocancel;
+ __read_nocancel;
# functions used by nscd
__netlink_assert_response;
}
/* This is more than enough, the file contains a single integer. */
char buf[32];
ssize_t n;
- n = TEMP_FAILURE_RETRY (read_not_cancel (fd, buf, sizeof (buf) - 1));
+ n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, sizeof (buf) - 1));
close_not_cancel_no_status (fd);
if (n > 0)
fd = __open_nocancel (HOSTIDFILE, O_RDONLY|O_LARGEFILE, 0);
if (fd >= 0)
{
- ssize_t n = read_not_cancel (fd, &id, sizeof (id));
+ ssize_t n = __read_nocancel (fd, &id, sizeof (id));
close_not_cancel_no_status (fd);
ssize_t nread;
int i;
- nread = read_not_cancel (fd, buf, sizeof buf - 1);
+ nread = __read_nocancel (fd, buf, sizeof buf - 1);
close_not_cancel_no_status (fd);
if (nread <= 0)
return -1;
/* We are reading a 32-bit number. 12 bytes are enough for the text
representation. If not, something is wrong. */
char uidbuf[12];
- ssize_t n = TEMP_FAILURE_RETRY (read_not_cancel (fd, uidbuf,
+ ssize_t n = TEMP_FAILURE_RETRY (__read_nocancel (fd, uidbuf,
sizeof (uidbuf)));
close_not_cancel_no_status (fd);
*re = buffer + (*re - *cp);
*cp = buffer;
- ssize_t n = read_not_cancel (fd, *re, buffer_end - *re);
+ ssize_t n = __read_nocancel (fd, *re, buffer_end - *re);
if (n < 0)
return NULL;
{
/* Truncate too long lines. */
*re = buffer + 3 * (buffer_end - buffer) / 4;
- n = read_not_cancel (fd, *re, buffer_end - *re);
+ n = __read_nocancel (fd, *re, buffer_end - *re);
if (n < 0)
return NULL;
/* This was not successful. Now try reading the /proc filesystem. */
int fd = __open_nocancel ("/proc/sys/kernel/version", O_RDONLY);
if (__builtin_expect (fd, 0) == -1
- || read_not_cancel (fd, u.buf, sizeof (u.buf)) <= 0)
+ || __read_nocancel (fd, u.buf, sizeof (u.buf)) <= 0)
/* This also didn't work. We give up and say it's a UP machine. */
u.buf[0] = '\0';
/* We expect the file to contain a single digit followed by
a newline. If the format changes we better not rely on
the file content. */
- if (read_not_cancel (fd, buf, sizeof buf) != 2
+ if (__read_nocancel (fd, buf, sizeof buf) != 2
|| buf[0] != '0' || buf[1] != '\n')
newval = -1;
int fd2 = __open_nocancel ("/proc/self/maps", O_RDONLY);
char buf[1024];
ssize_t n2;
- while ((n2 = read_not_cancel (fd2, buf, sizeof (buf))) > 0)
+ while ((n2 = __read_nocancel (fd2, buf, sizeof (buf))) > 0)
if (write_not_cancel (fd, buf, n2) != n2)
break;
close_not_cancel_no_status (fd2);
if (fd >= 0)
{
char val;
- ssize_t n = read_not_cancel (fd, &val, 1);
+ ssize_t n = __read_nocancel (fd, &val, 1);
may_shrink_heap = n > 0 && val == '2';
close_not_cancel_no_status (fd);
}
__typeof (open64) __open64_nocancel;
libc_hidden_proto (__open64_nocancel)
-/* Uncancelable read. */
-#define __read_nocancel(fd, buf, len) \
- INLINE_SYSCALL (read, 3, fd, buf, len)
+/* Non cancellable read syscall. */
+__typeof (__read) __read_nocancel;
+libc_hidden_proto (__read_nocancel)
/* Uncancelable write. */
#define __write_nocancel(fd, buf, len) \
(void) ({ INTERNAL_SYSCALL_DECL (err); \
INTERNAL_SYSCALL (close, err, 1, (fd)); })
-/* Uncancelable read. */
-#define read_not_cancel(fd, buf, n) \
- __read_nocancel (fd, buf, n)
-
/* Uncancelable write. */
#define write_not_cancel(fd, buf, n) \
__write_nocancel (fd, buf, n)
return errno;
int res = 0;
- ssize_t n = TEMP_FAILURE_RETRY (read_not_cancel (fd, buf, len));
+ ssize_t n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, len));
if (n < 0)
res = errno;
else
#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
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)
/* This is more than enough, the file contains a single integer. */
char buf[32];
ssize_t n;
- n = TEMP_FAILURE_RETRY (read_not_cancel (fd, buf, sizeof (buf) - 1));
+ n = TEMP_FAILURE_RETRY (__read_nocancel (fd, buf, sizeof (buf) - 1));
close_not_cancel_no_status (fd);
if (n > 0)
projects / platform / upstream / glibc.git / commitdiff