Kernel+LibC: Add posix_fallocate syscall

Kernel/API/Syscall.h

@@ -128,6 +128,7 @@ enum class NeedsBigProcessLock {
     S(pipe, NeedsBigProcessLock::Yes)                       \
     S(pledge, NeedsBigProcessLock::Yes)                     \
     S(poll, NeedsBigProcessLock::Yes)                       \
+    S(posix_fallocate, NeedsBigProcessLock::No)             \
     S(prctl, NeedsBigProcessLock::Yes)                      \
     S(profiling_disable, NeedsBigProcessLock::Yes)          \
     S(profiling_enable, NeedsBigProcessLock::Yes)           \

Kernel/CMakeLists.txt

@@ -243,6 +243,7 @@ set(KERNEL_SOURCES
     Syscalls/emuctl.cpp
     Syscalls/execve.cpp
     Syscalls/exit.cpp
+    Syscalls/fallocate.cpp
     Syscalls/fcntl.cpp
     Syscalls/fork.cpp
     Syscalls/fsync.cpp

Kernel/Process.h

@@ -301,6 +301,7 @@ class Process final
     ErrorOr<FlatPtr> sys$stat(Userspace<Syscall::SC_stat_params const*>);
     ErrorOr<FlatPtr> sys$lseek(int fd, Userspace<off_t*>, int whence);
     ErrorOr<FlatPtr> sys$ftruncate(int fd, Userspace<off_t const*>);
+    ErrorOr<FlatPtr> sys$posix_fallocate(int fd, Userspace<off_t const*>, Userspace<off_t const*>);
     ErrorOr<FlatPtr> sys$kill(pid_t pid_or_pgid, int sig);
     [[noreturn]] void sys$exit(int status);
     ErrorOr<FlatPtr> sys$sigreturn(RegisterState& registers);

Kernel/Syscalls/fallocate.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022, Leon Albrecht <[email protected]>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Checked.h>
+#include <Kernel/FileSystem/Inode.h>
+#include <Kernel/FileSystem/InodeFile.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
+#include <Kernel/Process.h>
+
+namespace Kernel {
+
+ErrorOr<FlatPtr> Process::sys$posix_fallocate(int fd, Userspace<off_t const*> userspace_offset, Userspace<off_t const*> userspace_length)
+{
+    VERIFY_NO_PROCESS_BIG_LOCK(this);
+    TRY(require_promise(Pledge::stdio));
+
+    auto offset = TRY(copy_typed_from_user(userspace_offset));
+    if (offset < 0)
+        return EINVAL;
+    auto length = TRY(copy_typed_from_user(userspace_length));
+    if (length <= 0)
+        return EINVAL;
+
+    Checked<size_t> checked_size { length };
+    checked_size += offset;
+    // FIXME: Return EFBIG if offset+length > FileSizeMax
+    if (checked_size.has_overflow())
+        return EFBIG;
+
+    auto description = TRY(open_file_description(fd));
+    if (!description->is_writable())
+        return EBADF;
+
+    if (description->is_fifo())
+        return ESPIPE;
+
+    if (!S_ISREG(TRY(description->file().stat()).st_mode))
+        return ENODEV;
+
+    VERIFY(description->file().is_inode());
+
+    auto& file = static_cast<InodeFile&>(description->file());
+    if (file.inode().size() >= checked_size.value())
+        return 0;
+
+    // Note: truncate essentially calls resize in the inodes implementation
+    //       while resize is not a standard member of an inode, so we just call
+    //       truncate instead
+    TRY(file.inode().truncate(checked_size.value()));
+
+    // FIXME: ENOSPC: There is not enough space left on the device containing the file referred to by fd.
+    // FIXME: EINTR: A signal was caught during execution.
+    return 0;
+}
+
+}

Userland/Libraries/LibC/fcntl.cpp

@@ -104,6 +104,13 @@ int posix_fadvise(int fd, off_t offset, off_t len, int advice)
     return 0;
 }
 
+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_fallocate.html
+int posix_fallocate(int fd, off_t offset, off_t len)
+{
+    // posix_fallocate does not set errno.
+    return static_cast<int>(syscall(SC_posix_fallocate, fd, &offset, &len));
+}
+
 // https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimensat.html
 int utimensat(int dirfd, char const* path, struct timespec const times[2], int flag)
 {

Userland/Libraries/LibC/fcntl.h

@@ -29,6 +29,7 @@ int inode_watcher_add_watch(int fd, char const* path, size_t path_length, unsign
 int inode_watcher_remove_watch(int fd, int wd);
 
 int posix_fadvise(int fd, off_t offset, off_t len, int advice);
+int posix_fallocate(int fd, off_t offset, off_t len);
 
 int utimensat(int dirfd, char const* path, struct timespec const times[2], int flag);