Update.

2000-08-12  Andreas Jaeger  <aj@suse.de>

	* sysdeps/unix/sysv/linux/i386/fcntl.c (__libc_fcntl): Try fcntl
	if fnctl64 is not available for F_*LK*64.

	* sysdeps/unix/sysv/linux/i386/lockf64.c: New file.

3 files changed, 282 insertions, 17 deletions

diff --git a/ChangeLog b/ChangeLog
index 98e39de919..2a44be92dd 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2000-08-12  Andreas Jaeger  <aj@suse.de>
+
+	* sysdeps/unix/sysv/linux/i386/fcntl.c (__libc_fcntl): Try fcntl
+	if fnctl64 is not available for F_*LK*64.
+
+	* sysdeps/unix/sysv/linux/i386/lockf64.c: New file.
+
 2000-08-12  Ulrich Drepper  <drepper@redhat.com>
 
 	* sysdeps/unix/sysv/linux/kernel-features.h (__ASSUME_FCNTL64):
diff --git a/sysdeps/unix/sysv/linux/i386/fcntl.c b/sysdeps/unix/sysv/linux/i386/fcntl.c
index 457ec2e60b..05708bf42d 100644
--- a/sysdeps/unix/sysv/linux/i386/fcntl.c
+++ b/sysdeps/unix/sysv/linux/i386/fcntl.c
@@ -25,37 +25,104 @@
 #include "../kernel-features.h"
 
 
+# if __ASSUME_FCNTL64 == 0
+/* This variable is shared with all files that check for fcntl64.  */
+int __have_no_fcntl64;
+# endif
+#endif
+
 int
 __libc_fcntl (int fd, int cmd, ...)
 {
   va_list ap;
-#if __NR_fcntl64
-  int result;
-#endif
   void *arg;
 
   va_start (ap, cmd);
   arg = va_arg (ap, void *);
   va_end (ap);
 
-#if __NR_fcntl64
-  result = INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg);
+#if __ASSUME_FCNTL64 > 0
+  return INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg);
+#else
+# ifdef __NR_fcntl64
+  if (! __have_no_fcntl64)
+    {
+      int result = INLINE_SYSCALL (fcntl64, 3, fd, cmd, arg);
+      if (result >= 0 || errno != ENOSYS)
+	return result;
 
-# if __ASSUME_FCNTL64 == 0
-  if (result != -1 || errno != ENOSYS)
+      __have_no_fcntl64 = 1;
+    }
 # endif
-    return result;
-#endif
-
-#if __ASSUME_FCNTL64 == 0
-  if (cmd == F_GETLK64 || cmd == F_SETLK64 || cmd == F_SETLKW64)
+  switch (cmd)
     {
-      __set_errno (EINVAL);
-      return -1;
-    }
+    case F_GETLK64:
+      /* Convert arg from flock64 to flock and back.  */
+      {
+	struct flock fl;
+	struct flock64 *fl64 = arg;
+	int res;
 
-  return INLINE_SYSCALL (fcntl, 3, fd, cmd, arg);
-#endif
+	fl.l_start = (off_t)fl64->l_start;
+	/* Check if we can represent the values with the smaller type.  */
+	if ((off64_t)fl.l_start != fl64->l_start)
+	  {
+	    __set_errno (EOVERFLOW);
+	    return -1;
+	  }
+	fl.l_len = (off_t)fl64->l_len;
+	/* Check if we can represent the values with the smaller type.  */
+	if ((off64_t)fl.l_len != fl64->l_len)
+	  {
+	    __set_errno (EOVERFLOW);
+	    return -1;
+	  }
+	fl.l_type = fl64->l_type;
+	fl.l_whence = fl64->l_whence;
+	fl.l_pid = fl64->l_pid;
+
+	res = INLINE_SYSCALL (fcntl, 3, fd, cmd, &fl);
+	if (res  != 0)
+	  return res;
+	/* Everything ok, convert back.  */
+	fl64->l_type = fl.l_type;
+	fl64->l_whence = fl.l_whence;
+	fl64->l_start = fl.l_start;
+	fl64->l_len = fl.l_len;
+	fl64->l_pid = fl.l_pid;
+
+	return 0;
+      }
+    case F_SETLK64:
+    case F_SETLKW64:
+      /* Try to convert arg from flock64 to flock.  */
+      {
+	struct flock fl;
+	struct flock64 *fl64 = arg;
+	fl.l_start = (off_t)fl64->l_start;
+	/* Check if we can represent the values with the smaller type.  */
+	if ((off64_t)fl.l_start != fl64->l_start)
+	  {
+	    __set_errno (EOVERFLOW);
+	    return -1;
+	  }
+	fl.l_len = (off_t)fl64->l_len;
+	/* Check if we can represent the values with the smaller type.  */
+	if ((off64_t)fl.l_len != fl64->l_len)
+	  {
+	    __set_errno (EOVERFLOW);
+	    return -1;
+	  }
+	fl.l_type = fl64->l_type;
+	fl.l_whence = fl64->l_whence;
+	fl.l_pid = fl64->l_pid;
+	return INLINE_SYSCALL (fcntl, 3, fd, cmd, &fl);
+      }
+    default:
+      return INLINE_SYSCALL (fcntl, 3, fd, cmd, arg);
+    }
+  return -1;
+#endif  /* __ASSUME_FCNTL64  */
 }
 
 weak_alias (__libc_fcntl, __fcntl)
diff --git a/sysdeps/unix/sysv/linux/i386/lockf64.c b/sysdeps/unix/sysv/linux/i386/lockf64.c
new file mode 100644
index 0000000000..f4603cfee2
--- /dev/null
+++ b/sysdeps/unix/sysv/linux/i386/lockf64.c
@@ -0,0 +1,191 @@
+/* Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 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 Library General Public License as
+   published by the Free Software Foundation; either version 2 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <sysdep.h>
+
+#include "kernel-features.h"
+
+/* lockf is a simplified interface to fcntl's locking facilities.  */
+
+#ifdef __NR_fcntl64
+extern int __syscall_fcntl64 (int __fd, int __cmd, ...);
+
+# if __ASSUME_FCNTL64 == 0
+/* This variable is shared with all files that check for fcntl64. The
+   declaration is in fcntl.c.  */
+extern int __have_no_fcntl64;
+# endif
+#endif
+
+int
+lockf64 (int fd, int cmd, off64_t len64)
+{
+#if __ASSUME_FCNTL64 == 0
+  struct flock fl;
+  off_t len = (off_t) len64;
+#endif
+#ifdef __NR_fcntl64
+  struct flock64 fl64;
+  int cmd64;
+#endif
+
+#if __ASSUME_FCNTL64 == 0
+  memset ((char *) &fl, '\0', sizeof (fl));
+
+  /* lockf is always relative to the current file position.  */
+  fl.l_whence = SEEK_CUR;
+  fl.l_start = 0;
+  fl.l_len = len;
+#endif
+#ifdef __NR_fcntl64
+# if __ASSUME_FCNTL64 == 0
+  if (!__have_no_fcntl64)
+    {
+# endif
+      memset ((char *) &fl64, '\0', sizeof (fl64));
+      fl64.l_whence = SEEK_CUR;
+      fl64.l_start = 0;
+      fl64.l_len = len64;
+# if __ASSUME_FCNTL64 == 0
+    }
+# endif
+#endif
+
+#if __ASSUME_FCNTL64 == 0 && !defined __NR_fcntl64
+  if (len64 != (off64_t) len)
+    {
+      /* We can't represent the length.  */
+      __set_errno (EOVERFLOW);
+      return -1;
+    }
+#endif
+  switch (cmd)
+    {
+    case F_TEST:
+      /* Test the lock: return 0 if FD is unlocked or locked by this process;
+	 return -1, set errno to EACCES, if another process holds the lock.  */
+#if __ASSUME_FCNTL64 > 0
+      if (INLINE_SYSCALL (fcntl64, 3, fd, F_GETLK64, &fl64) < 0)
+        return -1;
+      if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ())
+        return 0;
+      __set_errno (EACCES);
+      return -1;
+#else
+# ifdef __NR_fcntl64
+      if (!__have_no_fcntl64)
+	{
+	  int res = INLINE_SYSCALL (fcntl64, 3, fd, F_GETLK64, &fl64);
+
+	  /* If errno == ENOSYS try the 32bit interface if len64 can
+             be represented with 32 bits.  */
+
+	  if (res == 0)
+	    {
+	      if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ())
+		return 0;
+	      __set_errno (EACCES);
+	      return -1;
+	    }
+	  else if (errno == ENOSYS)
+	    __have_no_fcntl64 = 1;
+	  else
+	    /* res < 0 && errno != ENOSYS.  */
+	    return -1;
+	  if (len64 != (off64_t) len)
+	    {
+	      /* We can't represent the length.  */
+	      __set_errno (EOVERFLOW);
+	      return -1;
+	    }
+	}
+# endif
+      if (__fcntl (fd, F_GETLK, &fl) < 0)
+	return -1;
+      if (fl.l_type == F_UNLCK || fl.l_pid == __getpid ())
+	return 0;
+      __set_errno (EACCES);
+      return -1;
+#endif
+    case F_ULOCK:
+#if __ASSUME_FCNTL64 == 0
+      fl.l_type = F_UNLCK;
+      cmd = F_SETLK;
+#endif
+#ifdef __NR_fcntl64
+      fl64.l_type = F_UNLCK;
+      cmd64 = F_SETLK64;
+#endif
+      break;
+    case F_LOCK:
+#if __ASSUME_FCNTL64 == 0
+      fl.l_type = F_WRLCK;
+      cmd = F_SETLKW;
+#endif
+#ifdef __NR_fcntl64
+      fl64.l_type = F_WRLCK;
+      cmd64 = F_SETLKW64;
+#endif
+      break;
+    case F_TLOCK:
+#if __ASSUME_FCNTL64 == 0
+      fl.l_type = F_WRLCK;
+      cmd = F_SETLK;
+#endif
+#ifdef __NR_fcntl64
+      fl64.l_type = F_WRLCK;
+      cmd64 = F_SETLK64;
+#endif
+      break;
+
+    default:
+      __set_errno (EINVAL);
+      return -1;
+    }
+#if __ASSUME_FCNTL64 > 0
+  return INLINE_SYSCALL (fcntl64, 3, fd, cmd64, &fl64);
+#else
+# ifdef __NR_fcntl64
+
+  if (!__have_no_fcntl64)
+    {
+      int res = INLINE_SYSCALL (fcntl64, 3, fd, cmd64, &fl64);
+
+      /* If errno == ENOSYS try the 32bit interface if len64 can
+	 be represented with 32 bits.  */
+      if (res == 0 || errno != ENOSYS)
+	return res;
+
+      __have_no_fcntl64 = 1;
+
+      if (len64 != (off64_t) len)
+	{
+	  /* We can't represent the length.  */
+	  __set_errno (EOVERFLOW);
+	  return -1;
+	}
+    }
+# endif
+  return __fcntl (fd, cmd, &fl);
+#endif
+}