Remove __ASSUME_GETDENTS64_SYSCALL.

This patch removes the __ASSUME_GETDENTS64_SYSCALL macro, as its
definition is constant given the new kernel version requirements (and
was constant anyway before those requirements except for MIPS n32).

Note that the "#ifdef __NR_getdents64" conditional *is* still needed,
because MIPS n64 only has the getdents syscall (being a 64-bit ABI,
that syscall is 64-bit; the difference between the two on 64-bit
architectures is where d_type goes).  If MIPS n64 were to gain the
getdents64 syscall and we wanted to use it conditionally on the kernel
version at runtime we'd have to revert this patch, but I think that's
unlikely (and in any case, we could follow the simpler approach of
undefining __NR_getdents64 if the syscall can't be assumed, just like
we do for accept4 / recvmmsg / sendmmsg syscalls on architectures
where socketcall support came first).

Most of the getdents.c changes are reindentation.

Tested for x86_64 and x86 that installed stripped shared libraries are
unchanged by the patch.

	* sysdeps/unix/sysv/linux/kernel-features.h
	(__ASSUME_GETDENTS64_SYSCALL): Remove macro.
	* sysdeps/unix/sysv/linux/getdents.c
	[!__ASSUME_GETDENTS64_SYSCALL]: Remove conditional code.
	[!have_no_getdents64_defined]: Likewise.
	(__GETDENTS): Remove __have_no_getdents64 conditional.

1 files changed, 81 insertions, 110 deletions

diff --git a/sysdeps/unix/sysv/linux/getdents.c b/sysdeps/unix/sysv/linux/getdents.c
index 1f2404e142..d438547be9 100644
--- a/sysdeps/unix/sysv/linux/getdents.c
+++ b/sysdeps/unix/sysv/linux/getdents.c
@@ -33,21 +33,6 @@
 
 #include <kernel-features.h>
 
-#ifdef __NR_getdents64
-# ifndef __ASSUME_GETDENTS64_SYSCALL
-#  ifndef __GETDENTS
-/* The variable is shared between all *getdents* calls.  */
-int __have_no_getdents64 attribute_hidden;
-#  else
-extern int __have_no_getdents64 attribute_hidden;
-#  endif
-#  define have_no_getdents64_defined 1
-# endif
-#endif
-#ifndef have_no_getdents64_defined
-# define __have_no_getdents64 0
-#endif
-
 /* For Linux we need a special version of this file since the
    definition of `struct dirent' is not the same for the kernel and
    the libc.  There is one additional field which might be introduced
@@ -137,108 +122,94 @@ __GETDENTS (int fd, char *buf, size_t nbytes)
   off64_t last_offset = -1;
 
 #ifdef __NR_getdents64
-  if (!__have_no_getdents64)
+  {
+    union
     {
-# ifndef __ASSUME_GETDENTS64_SYSCALL
-      int saved_errno = errno;
-# endif
-      union
+      struct kernel_dirent64 k;
+      DIRENT_TYPE u;
+      char b[1];
+    } *kbuf = (void *) buf, *outp, *inp;
+    size_t kbytes = nbytes;
+    if (offsetof (DIRENT_TYPE, d_name)
+	< offsetof (struct kernel_dirent64, d_name)
+	&& nbytes <= sizeof (DIRENT_TYPE))
       {
-	struct kernel_dirent64 k;
-	DIRENT_TYPE u;
-	char b[1];
-      } *kbuf = (void *) buf, *outp, *inp;
-      size_t kbytes = nbytes;
-      if (offsetof (DIRENT_TYPE, d_name)
-	  < offsetof (struct kernel_dirent64, d_name)
-	  && nbytes <= sizeof (DIRENT_TYPE))
-	{
-	  kbytes = nbytes + offsetof (struct kernel_dirent64, d_name)
-		   - offsetof (DIRENT_TYPE, d_name);
-	  kbuf = __alloca(kbytes);
-	}
-      retval = INLINE_SYSCALL (getdents64, 3, fd, kbuf, kbytes);
-# ifndef __ASSUME_GETDENTS64_SYSCALL
-      if (retval != -1 || (errno != EINVAL && errno != ENOSYS))
-# endif
-	{
-	  const size_t size_diff = (offsetof (struct kernel_dirent64, d_name)
-				    - offsetof (DIRENT_TYPE, d_name));
+	kbytes = (nbytes + offsetof (struct kernel_dirent64, d_name)
+		  - offsetof (DIRENT_TYPE, d_name));
+	kbuf = __alloca(kbytes);
+      }
+    retval = INLINE_SYSCALL (getdents64, 3, fd, kbuf, kbytes);
+    const size_t size_diff = (offsetof (struct kernel_dirent64, d_name)
+			      - offsetof (DIRENT_TYPE, d_name));
+
+    /* Return the error if encountered.  */
+    if (retval == -1)
+      return -1;
+
+    /* If the structure returned by the kernel is identical to what we
+       need, don't do any conversions.  */
+    if (offsetof (DIRENT_TYPE, d_name)
+	== offsetof (struct kernel_dirent64, d_name)
+	&& sizeof (outp->u.d_ino) == sizeof (inp->k.d_ino)
+	&& sizeof (outp->u.d_off) == sizeof (inp->k.d_off))
+      return retval;
+
+    /* These two pointers might alias the same memory buffer.
+       Standard C requires that we always use the same type for them,
+       so we must use the union type.  */
+    inp = kbuf;
+    outp = (void *) buf;
+
+    while (&inp->b < &kbuf->b + retval)
+      {
+	const size_t alignment = __alignof__ (DIRENT_TYPE);
+	/* Since inp->k.d_reclen is already aligned for the kernel
+	   structure this may compute a value that is bigger
+	   than necessary.  */
+	size_t old_reclen = inp->k.d_reclen;
+	size_t new_reclen = ((old_reclen - size_diff + alignment - 1)
+			     & ~(alignment - 1));
+
+	/* Copy the data out of the old structure into temporary space.
+	   Then copy the name, which may overlap if BUF == KBUF.  */
+	const uint64_t d_ino = inp->k.d_ino;
+	const int64_t d_off = inp->k.d_off;
+	const uint8_t d_type = inp->k.d_type;
 
-	  /* Return the error if encountered.  */
-	  if (retval == -1)
+	memmove (outp->u.d_name, inp->k.d_name,
+		 old_reclen - offsetof (struct kernel_dirent64, d_name));
+
+	/* Now we have copied the data from INP and access only OUTP.  */
+
+	DIRENT_SET_DP_INO (&outp->u, d_ino);
+	outp->u.d_off = d_off;
+	if ((sizeof (outp->u.d_ino) != sizeof (inp->k.d_ino)
+	     && outp->u.d_ino != d_ino)
+	    || (sizeof (outp->u.d_off) != sizeof (inp->k.d_off)
+		&& outp->u.d_off != d_off))
+	  {
+	    /* Overflow.  If there was at least one entry
+	       before this one, return them without error,
+	       otherwise signal overflow.  */
+	    if (last_offset != -1)
+	      {
+		__lseek64 (fd, last_offset, SEEK_SET);
+		return outp->b - buf;
+	      }
+	    __set_errno (EOVERFLOW);
 	    return -1;
+	  }
 
-	  /* If the structure returned by the kernel is identical to what we
-	     need, don't do any conversions.  */
-	  if (offsetof (DIRENT_TYPE, d_name)
-	      == offsetof (struct kernel_dirent64, d_name)
-	      && sizeof (outp->u.d_ino) == sizeof (inp->k.d_ino)
-	      && sizeof (outp->u.d_off) == sizeof (inp->k.d_off))
-	    return retval;
-
-	  /* These two pointers might alias the same memory buffer.
-	     Standard C requires that we always use the same type for them,
-	     so we must use the union type.  */
-	  inp = kbuf;
-	  outp = (void *) buf;
-
-	  while (&inp->b < &kbuf->b + retval)
-	    {
-	      const size_t alignment = __alignof__ (DIRENT_TYPE);
-	      /* Since inp->k.d_reclen is already aligned for the kernel
-		 structure this may compute a value that is bigger
-		 than necessary.  */
-	      size_t old_reclen = inp->k.d_reclen;
-	      size_t new_reclen = ((old_reclen - size_diff + alignment - 1)
-				  & ~(alignment - 1));
-
-	      /* Copy the data out of the old structure into temporary space.
-		 Then copy the name, which may overlap if BUF == KBUF.  */
-	      const uint64_t d_ino = inp->k.d_ino;
-	      const int64_t d_off = inp->k.d_off;
-	      const uint8_t d_type = inp->k.d_type;
-
-	      memmove (outp->u.d_name, inp->k.d_name,
-		       old_reclen - offsetof (struct kernel_dirent64, d_name));
-
-	      /* Now we have copied the data from INP and access only OUTP.  */
-
-	      DIRENT_SET_DP_INO (&outp->u, d_ino);
-	      outp->u.d_off = d_off;
-	      if ((sizeof (outp->u.d_ino) != sizeof (inp->k.d_ino)
-		   && outp->u.d_ino != d_ino)
-		  || (sizeof (outp->u.d_off) != sizeof (inp->k.d_off)
-		      && outp->u.d_off != d_off))
-		{
-		  /* Overflow.  If there was at least one entry
-		     before this one, return them without error,
-		     otherwise signal overflow.  */
-		  if (last_offset != -1)
-		    {
-		      __lseek64 (fd, last_offset, SEEK_SET);
-		      return outp->b - buf;
-		    }
-		  __set_errno (EOVERFLOW);
-		  return -1;
-		}
-
-	      last_offset = d_off;
-	      outp->u.d_reclen = new_reclen;
-	      outp->u.d_type = d_type;
-
-	      inp = (void *) inp + old_reclen;
-	      outp = (void *) outp + new_reclen;
-	    }
+	last_offset = d_off;
+	outp->u.d_reclen = new_reclen;
+	outp->u.d_type = d_type;
 
-	  return outp->b - buf;
-	}
+	inp = (void *) inp + old_reclen;
+	outp = (void *) outp + new_reclen;
+      }
 
-# ifndef __ASSUME_GETDENTS64_SYSCALL
-      __set_errno (saved_errno);
-      __have_no_getdents64 = 1;
-# endif
-    }
+    return outp->b - buf;
+  }
 #endif
   {
     size_t red_nbytes;