AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-08 14:20:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

io: Fix record locking contants on 32 bit arch with 64 bit default time_t (BZ#30477)

Browse Source 
For architecture with default 64 bit time_t support, the kernel
does not provide LFS and non-LFS values for F_GETLK, F_GETLK, and
F_GETLK (the default value used for 64 bit architecture are used).

This is might be considered an ABI break, but the currenct exported
values is bogus anyway.

The POSIX lockf is not affected since it is aliased to lockf64,
which already uses the LFS values.

Checked on i686-linux-gnu and the new tests on a riscv32.

Reviewed-by: Carlos O'Donell <carlos@redhat.com>
This commit is contained in:
Adhemerval Zanella 2023-05-24 16:24:19 -03:00
parent 1512599694
commit 4d0fe291ae
4 changed files with 133 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
io/Makefile
View File

@ -175,6 +175,7 @@ tests := \
tst-fchmodat \
tst-fchownat \
tst-fcntl \
tst-fcntl-lock \
tst-fstatat \
tst-fts \
tst-fts-lfs \

97
io/tst-fcntl-lock.c Normal file
View File

@ -0,0 +1,97 @@
/* Test for advisory record locking.
Copyright (C) 2023 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 <https://www.gnu.org/licenses/>.
*/
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
/* This is essentially the POSIX lockf. */
static int
fcntl_lockf (int fd, int cmd, off_t len)
{
struct flock fl = {
.l_type = F_WRLCK,
.l_whence = SEEK_CUR,
.l_len = len
};
switch (cmd)
{
case F_TEST:
fl.l_type = F_RDLCK;
if (fcntl (fd, F_GETLK, &fl) < 0)
return -1;
if (fl.l_type == F_UNLCK || fl.l_pid == getpid ())
return 0;
errno = EACCES;
return -1;
case F_ULOCK:
fl.l_type = F_UNLCK;
return fcntl (fd, F_SETLK, &fl);
case F_LOCK:
return fcntl (fd, F_SETLKW, &fl);
case F_TLOCK:
return fcntl (fd, F_SETLK, &fl);
}
errno = EINVAL;
return -1;
}
static int
fcntl64_lockf (int fd, int cmd, off64_t len64)
{
struct flock64 fl64 = {
.l_type = F_WRLCK,
.l_whence = SEEK_CUR,
.l_len = len64
};
switch (cmd)
{
case F_TEST:
fl64.l_type = F_RDLCK;
if (fcntl64 (fd, F_GETLK64, &fl64) < 0)
return -1;
if (fl64.l_type == F_UNLCK || fl64.l_pid == getpid ())
return 0;
errno = EACCES;
return -1;
case F_ULOCK:
fl64.l_type = F_UNLCK;
return fcntl64 (fd, F_SETLK64, &fl64);
case F_LOCK:
return fcntl64 (fd, F_SETLKW64, &fl64);
case F_TLOCK:
return fcntl64 (fd, F_SETLK64, &fl64);
}
errno = EINVAL;
return -1;
}
#define TST_LOCKFD "tst-fcntl-lock."
#define LOCKF fcntl_lockf
#define LOCKF64 fcntl64_lockf
#include "tst-lockf.c"

58
io/tst-lockf.c
View File

@ -24,13 +24,23 @@
#include <support/capture_subprocess.h>
#include <support/check.h>
#ifndef TST_LOCKFD
# define TST_LOCKFD "tst-lockfd."
#endif
#ifndef LOCKF
# define LOCKF lockf
#endif
#ifndef LOCKF64
# define LOCKF64 lockf64
#endif
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);
temp_fd = create_temp_file (TST_LOCKFD, &temp_filename);
TEST_VERIFY_EXIT (temp_fd != -1);
}
#define PREPARE do_prepare
@ -40,22 +50,22 @@ 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 (LOCKF (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1);
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);
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);
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);
TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), 0);
}
static void
@ -63,32 +73,32 @@ 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 (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1);
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);
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);
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);
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 (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1);
TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
TEST_COMPARE (errno, EACCES);
}
}
@ -97,38 +107,38 @@ 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 (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);
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);
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);
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);
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);
support_capture_subprocess_check (&result, "LOCKF", 0, sc_allow_none);
}
}

2
sysdeps/unix/sysv/linux/bits/fcntl-linux.h
View File

@ -101,7 +101,7 @@
#endif
#ifndef F_GETLK
# ifndef __USE_FILE_OFFSET64
# if !defined __USE_FILE_OFFSET64 && __TIMESIZE != 64
# define F_GETLK 5 /* Get record locking info. */
# define F_SETLK 6 /* Set record locking info (non-blocking). */
# define F_SETLKW 7 /* Set record locking info (blocking). */