io/tst-lockf.c

   1 /* Test POSIX lock on an open file (lockf).
   2    Copyright (C) 2019-2023 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License
   6    as published by the Free Software Foundation; either version 2
   7    of the License, or (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, see <https://www.gnu.org/licenses/>.
  16 */
  17
  18 #include <unistd.h>
  19 #include <stdint.h>
  20 #include <errno.h>
  21 #include <stdio.h>
  22
  23 #include <support/temp_file.h>
  24 #include <support/capture_subprocess.h>
  25 #include <support/check.h>
  26
  27 #ifndef TST_LOCKFD
  28 # define TST_LOCKFD "tst-lockfd."
  29 #endif
  30 #ifndef LOCKF
  31 # define LOCKF lockf
  32 #endif
  33 #ifndef LOCKF64
  34 # define LOCKF64 lockf64
  35 #endif
  36
  37 static char *temp_filename;
  38 static int temp_fd;
  39
  40 static void
  41 do_prepare (int argc, char **argv)
  42 {
  43   temp_fd = create_temp_file (TST_LOCKFD, &temp_filename);
  44   TEST_VERIFY_EXIT (temp_fd != -1);
  45 }
  46 #define PREPARE do_prepare
  47
  48 static void
  49 do_test_child_lockf (void *closure)
  50 {
  51   /* Check if parent has [0, 1024) locked.  */
  52   TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0);
  53   TEST_COMPARE (LOCKF (temp_fd, F_TLOCK, 1024), -1);
  54   TEST_COMPARE (errno, EAGAIN);
  55   TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), -1);
  56   TEST_COMPARE (errno, EACCES);
  57   /* Also Check if parent has last 1024 bytes locked.  */
  58   TEST_COMPARE (lseek (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024);
  59   TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), -1);
  60
  61   /* And try to lock [1024, 2048).  */
  62   TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024);
  63   TEST_COMPARE (LOCKF (temp_fd, F_LOCK, 1024), 0);
  64
  65   /* Check if non-LFS interface cap access to 32-bif off_t.  */
  66   TEST_COMPARE (lseek64 (temp_fd, (off64_t)INT32_MAX, SEEK_SET),
  67                 (off64_t)INT32_MAX);
  68   TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), 0);
  69 }
  70
  71 static void
  72 do_test_child_lockf64 (void *closure)
  73 {
  74   /* Check if parent has [0, 1024) locked.  */
  75   TEST_COMPARE (lseek64 (temp_fd, 0, SEEK_SET), 0);
  76   TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
  77   TEST_COMPARE (errno, EAGAIN);
  78   TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
  79   TEST_COMPARE (errno, EACCES);
  80   /* Also Check if parent has last 1024 bytes locked.  */
  81   TEST_COMPARE (lseek64 (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024);
  82   TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
  83
  84   /* And try to lock [1024, 2048).  */
  85   TEST_COMPARE (lseek64 (temp_fd, 1024, SEEK_SET), 1024);
  86   TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
  87
  88   /* And also [INT32_MAX, INT32_MAX+1024).  */
  89   {
  90     off64_t off = (off64_t)INT32_MAX;
  91     TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
  92     TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
  93   }
  94
  95   /* Check if [INT32_MAX+1024, INT64_MAX) is locked.  */
  96   {
  97     off64_t off = (off64_t)INT32_MAX+1024;
  98     TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
  99     TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
 100     TEST_COMPARE (errno, EAGAIN);
 101     TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
 102     TEST_COMPARE (errno, EACCES);
 103   }
 104 }
 105
 106 static int
 107 do_test (void)
 108 {
 109   /* Basic tests to check if a lock can be obtained and checked.  */
 110   TEST_COMPARE (LOCKF (temp_fd, F_LOCK, 1024), 0);
 111   TEST_COMPARE (LOCKF (temp_fd, F_LOCK, INT32_MAX), 0);
 112   TEST_COMPARE (LOCKF (temp_fd, F_TLOCK, 1024), 0);
 113   TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), 0);
 114   TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024);
 115   TEST_COMPARE (LOCKF (temp_fd, F_ULOCK, 1024), 0);
 116   /* Parent process should have ([0, 1024), [2048, INT32_MAX)) ranges locked.  */
 117
 118   {
 119     struct support_capture_subprocess result;
 120     result = support_capture_subprocess (do_test_child_lockf, NULL);
 121     support_capture_subprocess_check (&result, "LOCKF", 0, sc_allow_none);
 122   }
 123
 124   if (sizeof (off_t) != sizeof (off64_t))
 125     {
 126       /* Check if previously locked regions with LFS symbol.  */
 127       TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0);
 128       TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
 129       TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), 0);
 130       TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), 0);
 131       /* Lock region [INT32_MAX+1024, INT64_MAX).  */
 132       off64_t off = (off64_t)INT32_MAX + 1024;
 133       TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
 134       TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
 135       /* Parent process should have ([0, 1024), [2048, INT32_MAX),
 136          [INT32_MAX+1024, INT64_MAX)) ranges locked.  */
 137
 138       {
 139         struct support_capture_subprocess result;
 140         result = support_capture_subprocess (do_test_child_lockf64, NULL);
 141         support_capture_subprocess_check (&result, "LOCKF", 0, sc_allow_none);
 142       }
 143     }
 144
 145   return 0;
 146 }
 147
 148 #include <support/test-driver.c>