From patchwork Tue May 30 13:15:36 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 1787515 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=sourceware.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=libc-alpha-bounces+incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.a=rsa-sha256 header.s=default header.b=y6frh2Hi; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4QVtFY5KsZz20Pc for ; Tue, 30 May 2023 23:16:17 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A8C453856DD6 for ; Tue, 30 May 2023 13:16:15 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A8C453856DD6 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1685452575; bh=lUAGd5+c7JCFnFR45gVit5t8ccYARPJELrcwAIZSJUI=; h=To:Cc:Subject:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=y6frh2Hi4H/pRXcte9oY6kL6r66xfsTek3kUaDNLZg0cUUFiGatkCIzUbYT+VRXNN yDR+izR1F+iIiln36/fMHYNAM8sNCr20jkGROQ6b5txHLAIzPJzcGqbR9pgWAgkkgt MT/aAdXHp2u5YQAUwcBa/4nZLTM56IFlf79Z/gqU= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-ot1-x32e.google.com (mail-ot1-x32e.google.com [IPv6:2607:f8b0:4864:20::32e]) by sourceware.org (Postfix) with ESMTPS id C4D363856600 for ; Tue, 30 May 2023 13:15:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C4D363856600 Received: by mail-ot1-x32e.google.com with SMTP id 46e09a7af769-6af6f49e41cso3362738a34.2 for ; Tue, 30 May 2023 06:15:52 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1685452551; x=1688044551; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=lUAGd5+c7JCFnFR45gVit5t8ccYARPJELrcwAIZSJUI=; b=ezG83nNGZYApMNAIZ5GgP5HAi6u8KKWK8tNYtqccNatzohEJEQenL3TFj8apokR7F9 TIN2Yt6YBUzymJYgJKYPjoIJ/hrD1/FTbCZHvnxZEwImQWU4UbWKxgOSdbGeLd8+94hZ 5JOzaxLcZA/kuVW0RlMDOkduDXxrdnsClagdc7jGZhH1vNM8gqPPIyAnQoLwpzgINFoo mYbA86ADB5SeNCnFnBLCbFEva/OwDdw9zf/TIVAUp4dIZtBftiylhaZH6r8vRX6XHW6R 5fPX3D0Az/krrJAAPHHlTHdIYHNEPpwx1J5Z0P1nXnPs88y8+gUflfhO0dZGvyJkptnl G/hw== X-Gm-Message-State: AC+VfDwTVUAbqgYWNDiuaEk2Q5a8OAvDFyDWQuEE2bOYWbEoA1iGSjGa 7Jk64TNFp6uMQOaSbmlbJDOoaogvql7AZ5bBHUgKkg== X-Google-Smtp-Source: ACHHUZ4txVtiQAoY/UMuCm3S8kKIZ3FMdCXmqN6fIw5eFu2sQuJnKBrw7uYMEZ19wF+YfIdEzrEtBw== X-Received: by 2002:a05:6830:1e84:b0:6a6:5a48:1f9b with SMTP id n4-20020a0568301e8400b006a65a481f9bmr1172554otr.8.1685452551361; Tue, 30 May 2023 06:15:51 -0700 (PDT) Received: from mandiga.. ([2804:1b3:a7c1:4dd5:946a:2241:9066:6bf3]) by smtp.gmail.com with ESMTPSA id r14-20020a056830134e00b006a3bd777dfdsm5528060otq.12.2023.05.30.06.15.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 30 May 2023 06:15:50 -0700 (PDT) To: libc-alpha@sourceware.org Cc: Carlos O'Donell Subject: [COMMITTED 2.35] io: Fix record locking contants on 32 bit arch with 64 bit default time_t (BZ#30477) Date: Tue, 30 May 2023 10:15:36 -0300 Message-Id: <20230530131536.652923-1-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 X-Spam-Status: No, score=-12.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Adhemerval Zanella via Libc-alpha From: Adhemerval Zanella Netto Reply-To: Adhemerval Zanella Errors-To: libc-alpha-bounces+incoming=patchwork.ozlabs.org@sourceware.org Sender: "Libc-alpha" 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 (cherry picked from commit 4d0fe291aed3a476a3b59c4ecfae9d35ac0f15e8) --- NEWS | 1 + io/Makefile | 3 +- io/tst-fcntl-lock.c | 97 ++++++++++++++++++++++ io/tst-lockf.c | 58 +++++++------ sysdeps/unix/sysv/linux/bits/fcntl-linux.h | 2 +- 5 files changed, 135 insertions(+), 26 deletions(-) create mode 100644 io/tst-fcntl-lock.c diff --git a/NEWS b/NEWS index b2d98f442d..8e08b22a8b 100644 --- a/NEWS +++ b/NEWS @@ -80,6 +80,7 @@ The following bugs are resolved with this release: [30151] gshadow: Matching sgetsgent, sgetsgent_r ERANGE handling [30163] posix: Fix system blocks SIGCHLD erroneously [30305] x86_64: Fix asm constraints in feraiseexcept + [30477] libc: [RISCV]: time64 does not work on riscv32 Version 2.35 diff --git a/io/Makefile b/io/Makefile index b1710407d0..fb363c612c 100644 --- a/io/Makefile +++ b/io/Makefile @@ -80,7 +80,8 @@ tests := test-utime test-stat test-stat2 test-lfs tst-getcwd \ tst-utimensat \ tst-closefrom \ tst-close_range \ - tst-ftw-bz28126 + tst-ftw-bz28126 \ + tst-fcntl-lock tests-time64 := \ tst-fcntl-time64 \ diff --git a/io/tst-fcntl-lock.c b/io/tst-fcntl-lock.c new file mode 100644 index 0000000000..357c4b7b56 --- /dev/null +++ b/io/tst-fcntl-lock.c @@ -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 . +*/ + +#include +#include +#include + +/* 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" diff --git a/io/tst-lockf.c b/io/tst-lockf.c index be92f33fd1..5e41dc19df 100644 --- a/io/tst-lockf.c +++ b/io/tst-lockf.c @@ -24,13 +24,23 @@ #include #include +#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); } } diff --git a/sysdeps/unix/sysv/linux/bits/fcntl-linux.h b/sysdeps/unix/sysv/linux/bits/fcntl-linux.h index 33ff88ce59..bfc674235d 100644 --- a/sysdeps/unix/sysv/linux/bits/fcntl-linux.h +++ b/sysdeps/unix/sysv/linux/bits/fcntl-linux.h @@ -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). */