| Message ID | 20190204194049.5828-1-adhemerval.zanella@linaro.org |
|---|---|
| State | Accepted |
| Commit | e442e40de5646e93bf31ace3e0c5159085a7259b |
| Headers | show |
| Series | [v2] io: Consolidate lockf implementation | expand |
If no one opposes it, I will commit this shortly. On 04/02/2019 17:40, Adhemerval Zanella wrote: > Changes from previous version [1]: > > * Remove hurd fixes since it was fixed upstream. > * Update test copyright year. > > -- > > With internal fcntl64 internal (commit 06ab719d), it is possible to > consolidate lockf implementation by using the LFS fcntl interface > instead of using arch and system-specific implementations. > > For Linux, the i386 implementation is used as generic implementation > by replacing the direct syscall with fcntl64 call. The LFS symbol > alias for default LFS ABI (__OFF_T_MATCHES_OFF64_T) is used to avoid > the duplicate symbol (instead of overriding the implementation with an > empty file). > > For Hurd lockf64 semantic is changed: previous generic lockf64 > implementation returned EOVERFLOW if LEN input is larger than 32-bit > off_t. However, Hurd fcntl64 implementation for F_GETLK64, F_SETLK64, > and F_SETLKW64 do accept off64_t inputs (__f_setlk accepts only off64_t > inputs). The consolidation thus uses the generic implementation on Hurd > as well and it also fixes a bug on Hurd fcntl for POSIX locks where it > tests for the wrong constant inside the F_GETLK64/F_SETLK64/F_SETLKW64 > case switch. > > Checked on i686-linux-gnu and x86_64-linux-gnu along with a i686-gnu > build. > > * io/Makefile (tests): Add tst-lockf. > * io/lockf.c (lockf): Use __fcntl and only define for > !__OFF_T_MATCHES_OFF64_T. > * io/lockf64.c (__lockf64): Call __fcntl64 and alias to lockf for > __OFF_T_MATCHES_OFF64_T case. > * io/tst-lockf.c: New file. > * sysdeps/mach/hurd/fcntl.c (__libc_fcntl): Fix internal check for > F_GETLK64, F_SETLKW64, and F_SETLK64. > * sysdeps/unix/sysv/linux/i386/lockf64.c: Remove file. > * sysdeps/unix/sysv/linux/arm/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/m68k/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/mips/mips32/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/sh/lockf64.c: Likewise. > * sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c: Likewise. > --- > ChangeLog | 20 +++ > io/Makefile | 2 +- > io/lockf.c | 54 ++----- > io/lockf64.c | 67 +++------ > io/tst-lockf.c | 138 ++++++++++++++++++ > sysdeps/unix/sysv/linux/arm/lockf64.c | 1 - > sysdeps/unix/sysv/linux/i386/lockf64.c | 70 --------- > sysdeps/unix/sysv/linux/m68k/lockf64.c | 1 - > sysdeps/unix/sysv/linux/mips/mips32/lockf64.c | 1 - > .../unix/sysv/linux/mips/mips64/n32/lockf64.c | 1 - > .../sysv/linux/powerpc/powerpc32/lockf64.c | 1 - > .../unix/sysv/linux/s390/s390-32/lockf64.c | 1 - > sysdeps/unix/sysv/linux/sh/lockf64.c | 1 - > .../unix/sysv/linux/sparc/sparc32/lockf64.c | 1 - > 14 files changed, 197 insertions(+), 162 deletions(-) > create mode 100644 io/tst-lockf.c > delete mode 100644 sysdeps/unix/sysv/linux/arm/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/i386/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/m68k/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/mips/mips32/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/sh/lockf64.c > delete mode 100644 sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c > > [1] https://sourceware.org/ml/libc-alpha/2018-11/msg00676.html > > diff --git a/io/Makefile b/io/Makefile > index cfae00bbfb..f2404db041 100644 > --- a/io/Makefile > +++ b/io/Makefile > @@ -71,7 +71,7 @@ tests := test-utime test-stat test-stat2 test-lfs tst-getcwd \ > tst-mknodat tst-mkfifoat tst-ttyname_r bug-ftw5 \ > tst-posix_fallocate tst-posix_fallocate64 \ > tst-fts tst-fts-lfs tst-open-tmpfile \ > - tst-copy_file_range tst-getcwd-abspath \ > + tst-copy_file_range tst-getcwd-abspath tst-lockf > > # This test includes the compat implementation of copy_file_range, > # which uses internal, unexported libc functions. > diff --git a/io/lockf.c b/io/lockf.c > index d07342962e..d40aa885c9 100644 > --- a/io/lockf.c > +++ b/io/lockf.c > @@ -15,34 +15,26 @@ > License along with the GNU C Library; if not, see > <http://www.gnu.org/licenses/>. */ > > -/* We need to avoid the header declaration of lockf64, because > - the types don't match lockf and then the compiler will > - complain about the mismatch when we do the alias below. */ > -#define lockf64 __renamed_lockf64 > +#ifndef __OFF_T_MATCHES_OFF64_T > > -#include <fcntl.h> > - > -#undef lockf64 > - > -#include <sys/types.h> > #include <unistd.h> > +#include <fcntl.h> > #include <errno.h> > -#include <string.h> > > /* lockf is a simplified interface to fcntl's locking facilities. */ > - > int > lockf (int fd, int cmd, off_t len) > { > - struct flock fl; > - > - 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; > + struct flock fl = { > + .l_type = F_WRLCK, > + .l_whence = SEEK_CUR, > + .l_len = len > + }; > > + /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is > + used. Therefore we don't have to care about cancellation here, > + the fcntl() function will take care of it. */ > switch (cmd) > { > case F_TEST: > @@ -55,31 +47,15 @@ lockf (int fd, int cmd, off_t len) > return 0; > __set_errno (EACCES); > return -1; > - > case F_ULOCK: > fl.l_type = F_UNLCK; > - cmd = F_SETLK; > - break; > + return __fcntl (fd, F_SETLK, &fl); > case F_LOCK: > - fl.l_type = F_WRLCK; > - cmd = F_SETLKW; > - break; > + return __fcntl (fd, F_SETLKW, &fl); > case F_TLOCK: > - fl.l_type = F_WRLCK; > - cmd = F_SETLK; > - break; > - > - default: > - __set_errno (EINVAL); > - return -1; > + return __fcntl (fd, F_SETLK, &fl); > } > - > - /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is > - used. Therefore we don't have to care about cancellation here, > - the fcntl() function will take care of it. */ > - return __fcntl (fd, cmd, &fl); > + __set_errno (EINVAL); > + return -1; > } > - > -#ifdef __OFF_T_MATCHES_OFF64_T > -weak_alias (lockf, lockf64) > #endif > diff --git a/io/lockf64.c b/io/lockf64.c > index 81b554e8f2..d520f776c1 100644 > --- a/io/lockf64.c > +++ b/io/lockf64.c > @@ -15,69 +15,48 @@ > License along with the GNU C Library; if not, see > <http://www.gnu.org/licenses/>. */ > > -#include <sys/types.h> > #include <unistd.h> > #include <fcntl.h> > #include <errno.h> > -#include <string.h> > - > -/* lockf.c defines lockf64 as an alias if __OFF_T_MATCHES_OFF64_T. */ > -#ifndef __OFF_T_MATCHES_OFF64_T > > /* lockf is a simplified interface to fcntl's locking facilities. */ > - > int > -lockf64 (int fd, int cmd, off64_t len64) > +__lockf64 (int fd, int cmd, off64_t len64) > { > - struct flock fl; > - off_t len = (off_t) len64; > - > - if (len64 != (off64_t) len) > - { > - /* We can't represent the length. */ > - __set_errno (EOVERFLOW); > - return -1; > - } > - > - 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; > - > + struct flock64 fl64 = { > + .l_type = F_WRLCK, > + .l_whence = SEEK_CUR, > + .l_len = len64, > + }; > + > + /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is > + used. Therefore we don't have to care about cancellation here, > + the fcntl() function will take care of it. */ > 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. */ > - fl.l_type = F_RDLCK; > - if (__fcntl (fd, F_GETLK, &fl) < 0) > + fl64.l_type = F_RDLCK; > + if (__fcntl (fd, F_GETLK64, &fl64) < 0) > return -1; > - if (fl.l_type == F_UNLCK || fl.l_pid == __getpid ()) > - return 0; > + if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ()) > + return 0; > __set_errno (EACCES); > return -1; > - > case F_ULOCK: > - fl.l_type = F_UNLCK; > - cmd = F_SETLK; > - break; > + fl64.l_type = F_UNLCK; > + return __fcntl64 (fd, F_SETLK64, &fl64); > case F_LOCK: > - fl.l_type = F_WRLCK; > - cmd = F_SETLKW; > - break; > + return __fcntl64 (fd, F_SETLKW64, &fl64); > case F_TLOCK: > - fl.l_type = F_WRLCK; > - cmd = F_SETLK; > - break; > - > - default: > - __set_errno (EINVAL); > - return -1; > + return __fcntl64 (fd, F_SETLK64, &fl64); > } > - > - return __fcntl (fd, cmd, &fl); > + __set_errno (EINVAL); > + return -1; > } > - > +weak_alias (__lockf64, lockf64) > +#ifdef __OFF_T_MATCHES_OFF64_T > +weak_alias (lockf64, lockf) > #endif > diff --git a/io/tst-lockf.c b/io/tst-lockf.c > new file mode 100644 > index 0000000000..05f8a6a797 > --- /dev/null > +++ b/io/tst-lockf.c > @@ -0,0 +1,138 @@ > +/* Test POSIX lock on an open file (lockf). > + Copyright (C) 2019 Free Software Foundation, Inc. > + > + This program is free software; you can redistribute it and/or > + modify it under the terms of the GNU General Public License > + as published by the Free Software Foundation; either version 2 > + of the License, or (at your option) any later version. > + > + This program 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 General Public License for more details. > + > + You should have received a copy of the GNU General Public License > + along with this program; if not, see <http://www.gnu.org/licenses/>. > +*/ > + > +#include <unistd.h> > +#include <stdint.h> > +#include <errno.h> > +#include <stdio.h> > + > +#include <support/temp_file.h> > +#include <support/capture_subprocess.h> > +#include <support/check.h> > + > +static char *temp_filename; > +static int temp_fd; > + > +static void > +do_prepare (int argc, char **argv) > +{ > + temp_fd = create_temp_file ("tst-lockfd.", &temp_filename); > + TEST_VERIFY_EXIT (temp_fd != -1); > +} > +#define PREPARE do_prepare > + > +static void > +do_test_child_lockf (void *closure) > +{ > + /* Check if parent has [0, 1024) locked. */ > + TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0); > + TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), -1); > + TEST_COMPARE (errno, EAGAIN); > + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1); > + TEST_COMPARE (errno, EACCES); > + /* Also Check if parent has last 1024 bytes locked. */ > + TEST_COMPARE (lseek (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024); > + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1); > + > + /* And try to lock [1024, 2048). */ > + TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024); > + TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0); > + > + /* Check if non-LFS interface cap access to 32-bif off_t. */ > + TEST_COMPARE (lseek64 (temp_fd, (off64_t)INT32_MAX, SEEK_SET), > + (off64_t)INT32_MAX); > + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0); > +} > + > +static void > +do_test_child_lockf64 (void *closure) > +{ > + /* Check if parent has [0, 1024) locked. */ > + TEST_COMPARE (lseek64 (temp_fd, 0, SEEK_SET), 0); > + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1); > + TEST_COMPARE (errno, EAGAIN); > + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); > + TEST_COMPARE (errno, EACCES); > + /* Also Check if parent has last 1024 bytes locked. */ > + TEST_COMPARE (lseek64 (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024); > + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); > + > + /* And try to lock [1024, 2048). */ > + TEST_COMPARE (lseek64 (temp_fd, 1024, SEEK_SET), 1024); > + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); > + > + /* And also [INT32_MAX, INT32_MAX+1024). */ > + { > + off64_t off = (off64_t)INT32_MAX; > + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); > + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); > + } > + > + /* Check if [INT32_MAX+1024, INT64_MAX) is locked. */ > + { > + off64_t off = (off64_t)INT32_MAX+1024; > + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); > + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1); > + TEST_COMPARE (errno, EAGAIN); > + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); > + TEST_COMPARE (errno, EACCES); > + } > +} > + > +static int > +do_test (void) > +{ > + /* Basic tests to check if a lock can be obtained and checked. */ > + TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0); > + TEST_COMPARE (lockf (temp_fd, F_LOCK, INT32_MAX), 0); > + TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), 0); > + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), 0); > + TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024); > + TEST_COMPARE (lockf (temp_fd, F_ULOCK, 1024), 0); > + /* Parent process should have ([0, 1024), [2048, INT32_MAX)) ranges locked. */ > + > + { > + struct support_capture_subprocess result; > + result = support_capture_subprocess (do_test_child_lockf, NULL); > + support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none); > + } > + > + if (sizeof (off_t) != sizeof (off64_t)) > + { > + /* Check if previously locked regions with LFS symbol. */ > + TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0); > + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); > + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), 0); > + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0); > + /* Lock region [INT32_MAX+1024, INT64_MAX). */ > + off64_t off = (off64_t)INT32_MAX + 1024; > + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); > + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); > + /* Parent process should have ([0, 1024), [2048, INT32_MAX), > + [INT32_MAX+1024, INT64_MAX)) ranges locked. */ > + > + { > + struct support_capture_subprocess result; > + result = support_capture_subprocess (do_test_child_lockf64, NULL); > + support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none); > + } > + } > + > + return 0; > +} > + > +#include <support/test-driver.c> > diff --git a/sysdeps/unix/sysv/linux/arm/lockf64.c b/sysdeps/unix/sysv/linux/arm/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/arm/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/i386/lockf64.c b/sysdeps/unix/sysv/linux/i386/lockf64.c > deleted file mode 100644 > index 7c8631112f..0000000000 > --- a/sysdeps/unix/sysv/linux/i386/lockf64.c > +++ /dev/null > @@ -1,70 +0,0 @@ > -/* Copyright (C) 1994-2019 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 Lesser General Public > - License as published by the Free Software Foundation; either > - version 2.1 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 > - Lesser General Public License for more details. > - > - You should have received a copy of the GNU Lesser General Public > - License along with the GNU C Library; if not, see > - <http://www.gnu.org/licenses/>. */ > - > -#include <sys/types.h> > -#include <unistd.h> > -#include <fcntl.h> > -#include <errno.h> > -#include <string.h> > -#include <sysdep.h> > - > -/* lockf is a simplified interface to fcntl's locking facilities. */ > - > -int > -lockf64 (int fd, int cmd, off64_t len64) > -{ > - struct flock64 fl64; > - int cmd64; > - int result; > - > - memset ((char *) &fl64, '\0', sizeof (fl64)); > - fl64.l_whence = SEEK_CUR; > - fl64.l_start = 0; > - fl64.l_len = len64; > - > - 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. */ > - fl64.l_type = F_RDLCK; > - INTERNAL_SYSCALL_DECL (err); > - result = INTERNAL_SYSCALL (fcntl64, err, 3, fd, F_GETLK64, &fl64); > - if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err))) > - return INLINE_SYSCALL_ERROR_RETURN_VALUE (INTERNAL_SYSCALL_ERRNO (result, > - err)); > - if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ()) > - return 0; > - return INLINE_SYSCALL_ERROR_RETURN_VALUE (EACCES); > - case F_ULOCK: > - fl64.l_type = F_UNLCK; > - cmd64 = F_SETLK64; > - break; > - case F_LOCK: > - fl64.l_type = F_WRLCK; > - cmd64 = F_SETLKW64; > - break; > - case F_TLOCK: > - fl64.l_type = F_WRLCK; > - cmd64 = F_SETLK64; > - break; > - > - default: > - return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL); > - } > - return INLINE_SYSCALL (fcntl64, 3, fd, cmd64, &fl64); > -} > diff --git a/sysdeps/unix/sysv/linux/m68k/lockf64.c b/sysdeps/unix/sysv/linux/m68k/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/m68k/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c b/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c b/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c b/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c b/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/sh/lockf64.c b/sysdeps/unix/sysv/linux/sh/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/sh/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> > diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c b/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c > deleted file mode 100644 > index a88f5a784a..0000000000 > --- a/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c > +++ /dev/null > @@ -1 +0,0 @@ > -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> >
diff --git a/io/Makefile b/io/Makefile index cfae00bbfb..f2404db041 100644 --- a/io/Makefile +++ b/io/Makefile @@ -71,7 +71,7 @@ tests := test-utime test-stat test-stat2 test-lfs tst-getcwd \ tst-mknodat tst-mkfifoat tst-ttyname_r bug-ftw5 \ tst-posix_fallocate tst-posix_fallocate64 \ tst-fts tst-fts-lfs tst-open-tmpfile \ - tst-copy_file_range tst-getcwd-abspath \ + tst-copy_file_range tst-getcwd-abspath tst-lockf # This test includes the compat implementation of copy_file_range, # which uses internal, unexported libc functions. diff --git a/io/lockf.c b/io/lockf.c index d07342962e..d40aa885c9 100644 --- a/io/lockf.c +++ b/io/lockf.c @@ -15,34 +15,26 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -/* We need to avoid the header declaration of lockf64, because - the types don't match lockf and then the compiler will - complain about the mismatch when we do the alias below. */ -#define lockf64 __renamed_lockf64 +#ifndef __OFF_T_MATCHES_OFF64_T -#include <fcntl.h> - -#undef lockf64 - -#include <sys/types.h> #include <unistd.h> +#include <fcntl.h> #include <errno.h> -#include <string.h> /* lockf is a simplified interface to fcntl's locking facilities. */ - int lockf (int fd, int cmd, off_t len) { - struct flock fl; - - 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; + struct flock fl = { + .l_type = F_WRLCK, + .l_whence = SEEK_CUR, + .l_len = len + }; + /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is + used. Therefore we don't have to care about cancellation here, + the fcntl() function will take care of it. */ switch (cmd) { case F_TEST: @@ -55,31 +47,15 @@ lockf (int fd, int cmd, off_t len) return 0; __set_errno (EACCES); return -1; - case F_ULOCK: fl.l_type = F_UNLCK; - cmd = F_SETLK; - break; + return __fcntl (fd, F_SETLK, &fl); case F_LOCK: - fl.l_type = F_WRLCK; - cmd = F_SETLKW; - break; + return __fcntl (fd, F_SETLKW, &fl); case F_TLOCK: - fl.l_type = F_WRLCK; - cmd = F_SETLK; - break; - - default: - __set_errno (EINVAL); - return -1; + return __fcntl (fd, F_SETLK, &fl); } - - /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is - used. Therefore we don't have to care about cancellation here, - the fcntl() function will take care of it. */ - return __fcntl (fd, cmd, &fl); + __set_errno (EINVAL); + return -1; } - -#ifdef __OFF_T_MATCHES_OFF64_T -weak_alias (lockf, lockf64) #endif diff --git a/io/lockf64.c b/io/lockf64.c index 81b554e8f2..d520f776c1 100644 --- a/io/lockf64.c +++ b/io/lockf64.c @@ -15,69 +15,48 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#include <sys/types.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> -#include <string.h> - -/* lockf.c defines lockf64 as an alias if __OFF_T_MATCHES_OFF64_T. */ -#ifndef __OFF_T_MATCHES_OFF64_T /* lockf is a simplified interface to fcntl's locking facilities. */ - int -lockf64 (int fd, int cmd, off64_t len64) +__lockf64 (int fd, int cmd, off64_t len64) { - struct flock fl; - off_t len = (off_t) len64; - - if (len64 != (off64_t) len) - { - /* We can't represent the length. */ - __set_errno (EOVERFLOW); - return -1; - } - - 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; - + struct flock64 fl64 = { + .l_type = F_WRLCK, + .l_whence = SEEK_CUR, + .l_len = len64, + }; + + /* lockf() is a cancellation point but so is fcntl() if F_SETLKW is + used. Therefore we don't have to care about cancellation here, + the fcntl() function will take care of it. */ 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. */ - fl.l_type = F_RDLCK; - if (__fcntl (fd, F_GETLK, &fl) < 0) + fl64.l_type = F_RDLCK; + if (__fcntl (fd, F_GETLK64, &fl64) < 0) return -1; - if (fl.l_type == F_UNLCK || fl.l_pid == __getpid ()) - return 0; + if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ()) + return 0; __set_errno (EACCES); return -1; - case F_ULOCK: - fl.l_type = F_UNLCK; - cmd = F_SETLK; - break; + fl64.l_type = F_UNLCK; + return __fcntl64 (fd, F_SETLK64, &fl64); case F_LOCK: - fl.l_type = F_WRLCK; - cmd = F_SETLKW; - break; + return __fcntl64 (fd, F_SETLKW64, &fl64); case F_TLOCK: - fl.l_type = F_WRLCK; - cmd = F_SETLK; - break; - - default: - __set_errno (EINVAL); - return -1; + return __fcntl64 (fd, F_SETLK64, &fl64); } - - return __fcntl (fd, cmd, &fl); + __set_errno (EINVAL); + return -1; } - +weak_alias (__lockf64, lockf64) +#ifdef __OFF_T_MATCHES_OFF64_T +weak_alias (lockf64, lockf) #endif diff --git a/io/tst-lockf.c b/io/tst-lockf.c new file mode 100644 index 0000000000..05f8a6a797 --- /dev/null +++ b/io/tst-lockf.c @@ -0,0 +1,138 @@ +/* Test POSIX lock on an open file (lockf). + Copyright (C) 2019 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, see <http://www.gnu.org/licenses/>. +*/ + +#include <unistd.h> +#include <stdint.h> +#include <errno.h> +#include <stdio.h> + +#include <support/temp_file.h> +#include <support/capture_subprocess.h> +#include <support/check.h> + +static char *temp_filename; +static int temp_fd; + +static void +do_prepare (int argc, char **argv) +{ + temp_fd = create_temp_file ("tst-lockfd.", &temp_filename); + TEST_VERIFY_EXIT (temp_fd != -1); +} +#define PREPARE do_prepare + +static void +do_test_child_lockf (void *closure) +{ + /* Check if parent has [0, 1024) locked. */ + TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0); + TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), -1); + TEST_COMPARE (errno, EAGAIN); + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1); + TEST_COMPARE (errno, EACCES); + /* Also Check if parent has last 1024 bytes locked. */ + TEST_COMPARE (lseek (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024); + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1); + + /* And try to lock [1024, 2048). */ + TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024); + TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0); + + /* Check if non-LFS interface cap access to 32-bif off_t. */ + TEST_COMPARE (lseek64 (temp_fd, (off64_t)INT32_MAX, SEEK_SET), + (off64_t)INT32_MAX); + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0); +} + +static void +do_test_child_lockf64 (void *closure) +{ + /* Check if parent has [0, 1024) locked. */ + TEST_COMPARE (lseek64 (temp_fd, 0, SEEK_SET), 0); + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1); + TEST_COMPARE (errno, EAGAIN); + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); + TEST_COMPARE (errno, EACCES); + /* Also Check if parent has last 1024 bytes locked. */ + TEST_COMPARE (lseek64 (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024); + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); + + /* And try to lock [1024, 2048). */ + TEST_COMPARE (lseek64 (temp_fd, 1024, SEEK_SET), 1024); + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); + + /* And also [INT32_MAX, INT32_MAX+1024). */ + { + off64_t off = (off64_t)INT32_MAX; + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); + } + + /* Check if [INT32_MAX+1024, INT64_MAX) is locked. */ + { + off64_t off = (off64_t)INT32_MAX+1024; + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1); + TEST_COMPARE (errno, EAGAIN); + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1); + TEST_COMPARE (errno, EACCES); + } +} + +static int +do_test (void) +{ + /* Basic tests to check if a lock can be obtained and checked. */ + TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0); + TEST_COMPARE (lockf (temp_fd, F_LOCK, INT32_MAX), 0); + TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), 0); + TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), 0); + TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024); + TEST_COMPARE (lockf (temp_fd, F_ULOCK, 1024), 0); + /* Parent process should have ([0, 1024), [2048, INT32_MAX)) ranges locked. */ + + { + struct support_capture_subprocess result; + result = support_capture_subprocess (do_test_child_lockf, NULL); + support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none); + } + + if (sizeof (off_t) != sizeof (off64_t)) + { + /* Check if previously locked regions with LFS symbol. */ + TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0); + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); + TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), 0); + TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0); + /* Lock region [INT32_MAX+1024, INT64_MAX). */ + off64_t off = (off64_t)INT32_MAX + 1024; + TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off); + TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0); + /* Parent process should have ([0, 1024), [2048, INT32_MAX), + [INT32_MAX+1024, INT64_MAX)) ranges locked. */ + + { + struct support_capture_subprocess result; + result = support_capture_subprocess (do_test_child_lockf64, NULL); + support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none); + } + } + + return 0; +} + +#include <support/test-driver.c> diff --git a/sysdeps/unix/sysv/linux/arm/lockf64.c b/sysdeps/unix/sysv/linux/arm/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/arm/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/i386/lockf64.c b/sysdeps/unix/sysv/linux/i386/lockf64.c deleted file mode 100644 index 7c8631112f..0000000000 --- a/sysdeps/unix/sysv/linux/i386/lockf64.c +++ /dev/null @@ -1,70 +0,0 @@ -/* Copyright (C) 1994-2019 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 Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <http://www.gnu.org/licenses/>. */ - -#include <sys/types.h> -#include <unistd.h> -#include <fcntl.h> -#include <errno.h> -#include <string.h> -#include <sysdep.h> - -/* lockf is a simplified interface to fcntl's locking facilities. */ - -int -lockf64 (int fd, int cmd, off64_t len64) -{ - struct flock64 fl64; - int cmd64; - int result; - - memset ((char *) &fl64, '\0', sizeof (fl64)); - fl64.l_whence = SEEK_CUR; - fl64.l_start = 0; - fl64.l_len = len64; - - 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. */ - fl64.l_type = F_RDLCK; - INTERNAL_SYSCALL_DECL (err); - result = INTERNAL_SYSCALL (fcntl64, err, 3, fd, F_GETLK64, &fl64); - if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err))) - return INLINE_SYSCALL_ERROR_RETURN_VALUE (INTERNAL_SYSCALL_ERRNO (result, - err)); - if (fl64.l_type == F_UNLCK || fl64.l_pid == __getpid ()) - return 0; - return INLINE_SYSCALL_ERROR_RETURN_VALUE (EACCES); - case F_ULOCK: - fl64.l_type = F_UNLCK; - cmd64 = F_SETLK64; - break; - case F_LOCK: - fl64.l_type = F_WRLCK; - cmd64 = F_SETLKW64; - break; - case F_TLOCK: - fl64.l_type = F_WRLCK; - cmd64 = F_SETLK64; - break; - - default: - return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL); - } - return INLINE_SYSCALL (fcntl64, 3, fd, cmd64, &fl64); -} diff --git a/sysdeps/unix/sysv/linux/m68k/lockf64.c b/sysdeps/unix/sysv/linux/m68k/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/m68k/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c b/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/mips/mips32/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c b/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c b/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c b/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/sh/lockf64.c b/sysdeps/unix/sysv/linux/sh/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/sh/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c> diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c b/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c deleted file mode 100644 index a88f5a784a..0000000000 --- a/sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c +++ /dev/null @@ -1 +0,0 @@ -#include <sysdeps/unix/sysv/linux/i386/lockf64.c>