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