sysdeps/posix/posix_fallocate64.c

   1 /* Copyright (C) 2000-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21 #include <stdint.h>
  22 #include <sys/fcntl.h>
  23 #include <sys/stat.h>
  24 #include <sys/statfs.h>
  25
  26 /* Reserve storage for the data of the file associated with FD.  This
  27    emulation is far from perfect, but the kernel cannot do not much
  28    better for network file systems, either.  */
  29
  30 int
  31 __posix_fallocate64_l64 (int fd, __off64_t offset, __off64_t len)
  32 {
  33   struct __stat64_t64 st;
  34
  35   if (offset < 0 || len < 0)
  36     return EINVAL;
  37
  38   /* Perform overflow check.  The outer cast relies on a GCC
  39      extension.  */
  40   if ((__off64_t) ((uint64_t) offset + (uint64_t) len) < 0)
  41     return EFBIG;
  42
  43   /* pwrite64 below will not do the right thing in O_APPEND mode.  */
  44   {
  45     int flags = __fcntl (fd, F_GETFL, 0);
  46     if (flags < 0 || (flags & O_APPEND) != 0)
  47       return EBADF;
  48   }
  49
  50   /* We have to make sure that this is really a regular file.  */
  51   if (__fstat64_time64 (fd, &st) != 0)
  52     return EBADF;
  53   if (S_ISFIFO (st.st_mode))
  54     return ESPIPE;
  55   if (! S_ISREG (st.st_mode))
  56     return ENODEV;
  57
  58   if (len == 0)
  59     {
  60       /* This is racy, but there is no good way to satisfy a
  61          zero-length allocation request.  */
  62       if (st.st_size < offset)
  63         {
  64           int ret = __ftruncate64 (fd, offset);
  65
  66           if (ret != 0)
  67             ret = errno;
  68           return ret;
  69         }
  70       return 0;
  71     }
  72
  73   /* Minimize data transfer for network file systems, by issuing
  74      single-byte write requests spaced by the file system block size.
  75      (Most local file systems have fallocate support, so this fallback
  76      code is not used there.)  */
  77
  78   unsigned increment;
  79   {
  80     struct statfs64 f;
  81
  82     if (__fstatfs64 (fd, &f) != 0)
  83       return errno;
  84     if (f.f_bsize == 0)
  85       increment = 512;
  86     else if (f.f_bsize < 4096)
  87       increment = f.f_bsize;
  88     else
  89       /* NFS clients do not propagate the block size of the underlying
  90          storage and may report a much larger value which would still
  91          leave holes after the loop below, so we cap the increment at
  92          4096.  */
  93       increment = 4096;
  94   }
  95
  96   /* Write a null byte to every block.  This is racy; we currently
  97      lack a better option.  Compare-and-swap against a file mapping
  98      might address local races, but requires interposition of a signal
  99      handler to catch SIGBUS.  */
 100   for (offset += (len - 1) % increment; len > 0; offset += increment)
 101     {
 102       len -= increment;
 103
 104       if (offset < st.st_size)
 105         {
 106           unsigned char c;
 107           ssize_t rsize = __libc_pread64 (fd, &c, 1, offset);
 108
 109           if (rsize < 0)
 110             return errno;
 111           /* If there is a non-zero byte, the block must have been
 112              allocated already.  */
 113           else if (rsize == 1 && c != 0)
 114             continue;
 115         }
 116
 117       if (__libc_pwrite64 (fd, "", 1, offset) != 1)
 118         return errno;
 119     }
 120
 121   return 0;
 122 }
 123
 124 #undef __posix_fallocate64_l64
 125 #include <shlib-compat.h>
 126 #include <bits/wordsize.h>
 127
 128 #if __WORDSIZE == 32 && SHLIB_COMPAT(libc, GLIBC_2_2, GLIBC_2_3_3)
 129
 130 int
 131 attribute_compat_text_section
 132 __posix_fallocate64_l32 (int fd, off64_t offset, size_t len)
 133 {
 134   return __posix_fallocate64_l64 (fd, offset, len);
 135 }
 136
 137 versioned_symbol (libc, __posix_fallocate64_l64, posix_fallocate64,
 138                   GLIBC_2_3_3);
 139 compat_symbol (libc, __posix_fallocate64_l32, posix_fallocate64, GLIBC_2_2);
 140 #else
 141 strong_alias (__posix_fallocate64_l64, posix_fallocate64);
 142 #endif