picnoir/glibc
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

io: Consolidate lockf implementation

Browse source 
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).

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/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.
This commit is contained in:
Adhemerval Zanella 2018-11-21 11:41:05 +00:00
parent bc10e22c90
commit e442e40de5
14 changed files with 194 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
ChangeLog
View file

@ -1,3 +1,21 @@
2019-02-15 Adhemerval Zanella <adhemerval.zanella@linaro.org>
* 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/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.
2019-02-15 Florian Weimer <fweimer@redhat.com>
[BZ #24211]

2
io/Makefile
View file

@ -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.

54
io/lockf.c
View file

@ -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

65
io/lockf64.c
View file

@ -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

138
io/tst-lockf.c Normal file
View file

@ -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>

1
sysdeps/unix/sysv/linux/arm/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

70
sysdeps/unix/sysv/linux/i386/lockf64.c
View file

@ -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);
}

1
sysdeps/unix/sysv/linux/m68k/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/mips/mips32/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/mips/mips64/n32/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/powerpc/powerpc32/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/s390/s390-32/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/sh/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>

1
sysdeps/unix/sysv/linux/sparc/sparc32/lockf64.c
View file

@ -1 +0,0 @@
#include <sysdeps/unix/sysv/linux/i386/lockf64.c>