posix: Fix and simplify default p{read,write}v implementation

Currently all architectures but microblaze use wire-up syscall for
p{readv,write}v.  Microblaze still uses the syscall emulation using
sysdep/posix/p{readv,writev}.c and it was reported in some ocasions
[1] [2] that it might have some issues with some linux specific
usage (mainly with O_DIRECT and the alignment requirement).

Although it is not an issue for virtually all the system, this
patch refactors the sysdeps/posix p{read,write}v syscall to avoid
such issue (by using posix_memalign on the buffer used on
p{read,write} call) and by refactoring it common files to avoid
the need check on defines to correct set the alias and internal
symbols.

Checked on microblaze-linux-gnu check with run-built-tests=no and
by using the sysdeps/posix implementation on x86_64-linux-gnu (just
for sanity test where it shown no regression).

	* sysdeps/posix/preadv.c: Use sysdeps/posix/preadv_common.c.
	* sysdeps/posix/preadv64.c: Likewise.
	* sysdeps/unix/sysv/linux/preadv.c: Likewise.
	* sysdeps/unix/sysv/linux/preadv64.c: Likewise.
	* sysdeps/posix/pwritev.c: Use sysdeps/posix/pwritev_common.c.
	* sysdeps/posix/pwritev64.c: Likewise.
	* sysdeps/unix/sysv/linux/pwritev.c: Likewise.
	* sysdeps/unix/sysv/linux/pwritev64.c: Likewise.
	* sysdeps/posix/preadv_common.c: New file.
	* sysdeps/posix/pwritev_common.c: Likewise.

[1] http://www.mail-archive.com/qemu-devel@nongnu.org/msg25282.html
[2] https://bugzilla.redhat.com/show_bug.cgi?id=563103#c8

1 files changed, 7 insertions, 84 deletions

diff --git a/sysdeps/posix/preadv.c b/sysdeps/posix/preadv.c
index 7539bf8..7819a93 100644
--- a/sysdeps/posix/preadv.c
+++ b/sysdeps/posix/preadv.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 2009-2017 Free Software Foundation, Inc.
+/* Read data into multiple buffers.  Generic version.
+   Copyright (C) 2009-2017 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
@@ -15,93 +16,15 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <sys/param.h>
-#if __WORDSIZE == 64 && !defined PREADV
-/* Hide the preadv64 declaration.  */
-# define preadv64 __redirect_preadv64
-#endif
-#include <sys/uio.h>
-#include <bits/wordsize.h>
+#include <sys/types.h>
+
+#ifndef __OFF_T_MATCHES_OFF64_T
 
-#ifndef PREADV
 # define PREADV preadv
 # define PREAD __pread
 # define OFF_T off_t
-#endif
-
-
-static void
-ifree (char **ptrp)
-{
-  free (*ptrp);
-}
-
-
-/* Read data from file descriptor FD at the given position OFFSET
-   without change the file pointer, and put the result in the buffers
-   described by VECTOR, which is a vector of COUNT 'struct iovec's.
-   The buffers are filled in the order specified.  Operates just like
-   'pread' (see <unistd.h>) except that data are put in VECTOR instead
-   of a contiguous buffer.  */
-ssize_t
-PREADV (int fd, const struct iovec *vector, int count, OFF_T offset)
-{
-  /* Find the total number of bytes to be read.  */
-  size_t bytes = 0;
-  for (int i = 0; i < count; ++i)
-    {
-      /* Check for ssize_t overflow.  */
-      if (SSIZE_MAX - bytes < vector[i].iov_len)
-	{
-	  __set_errno (EINVAL);
-	  return -1;
-	}
-      bytes += vector[i].iov_len;
-    }
-
-  /* Allocate a temporary buffer to hold the data.  We should normally
-     use alloca since it's faster and does not require synchronization
-     with other threads.  But we cannot if the amount of memory
-     required is too large.  */
-  char *buffer;
-  char *malloced_buffer __attribute__ ((__cleanup__ (ifree))) = NULL;
-  if (__libc_use_alloca (bytes))
-    buffer = (char *) __alloca (bytes);
-  else
-    {
-      malloced_buffer = buffer = (char *) malloc (bytes);
-      if (buffer == NULL)
-	return -1;
-    }
-
-  /* Read the data.  */
-  ssize_t bytes_read = PREAD (fd, buffer, bytes, offset);
-  if (bytes_read < 0)
-    return -1;
-
-  /* Copy the data from BUFFER into the memory specified by VECTOR.  */
-  bytes = bytes_read;
-  for (int i = 0; i < count; ++i)
-    {
-      size_t copy = MIN (vector[i].iov_len, bytes);
-
-      (void) memcpy ((void *) vector[i].iov_base, (void *) buffer, copy);
+# include <sysdeps/posix/preadv_common.c>
 
-      buffer += copy;
-      bytes -= copy;
-      if (bytes == 0)
-	break;
-    }
+libc_hidden_def (preadv)
 
-  return bytes_read;
-}
-#if __WORDSIZE == 64 && defined preadv64
-# undef preadv64
-strong_alias (preadv, preadv64)
 #endif