rm: Add the -v flag

apps/rm.cpp

@@ -1,10 +1,35 @@
 #include <os/ArgumentParser.h>
+#include <os/Directory.h>
+#include <os/File.h>
 #include <os/FileSystem.h>
 
+Result<void> remove_wrapper(const os::Path& path, bool verbose)
+{
+    TRY(os::FileSystem::remove(path));
+    if (verbose) os::println("removed '%s'", path.name().chars());
+    return {};
+}
+
+Result<void> remove_tree(const os::Path& path, bool verbose)
+{
+    auto rc = remove_wrapper(path, verbose);
+    if (!rc.has_error()) return {};
+    if (rc.error() != ENOTEMPTY) return rc.release_error();
+
+    auto dir = TRY(os::Directory::open(path));
+
+    Vector<String> entries = TRY(dir->list_names(os::Directory::Filter::ParentAndBase));
+
+    for (const auto& entry : entries) { TRY(remove_tree({ dir->fd(), entry.view() }, verbose)); }
+
+    return remove_wrapper(path, verbose);
+}
+
 Result<int> luna_main(int argc, char** argv)
 {
     StringView path;
     bool recursive;
+    bool verbose;
 
     os::ArgumentParser parser;
     parser.add_description("Remove a path from the file system."_sv);
@@ -12,11 +37,12 @@ Result<int> luna_main(int argc, char** argv)
     parser.add_positional_argument(path, "path"_sv, true);
     parser.add_switch_argument(recursive, 'r', "recursive"_sv,
                                "remove a directory recursively (by default, rm removes only empty directories)"_sv);
+    parser.add_switch_argument(verbose, 'v', "verbose"_sv, "log every removed file and directory"_sv);
     parser.parse(argc, argv);
 
-    if (!recursive) TRY(os::FileSystem::remove(path));
+    if (!recursive) TRY(remove_wrapper(path, verbose));
     else
-        TRY(os::FileSystem::remove_tree(path));
+        TRY(remove_tree(path, verbose));
 
     return 0;
 }

libos/include/os/FileSystem.h

@@ -68,15 +68,6 @@ namespace os
          */
         Result<void> remove(const Path& path);
 
-        /**
-         * @brief Remove a directory tree from the file system recursively, deleting subfiles and subdirectories as
-         * well.
-         *
-         * @param path The path to remove.
-         * @return Result<void> Whether the operation succeeded.
-         */
-        Result<void> remove_tree(const Path& path);
-
         /**
          * @brief Read the target of a symbolic link.
          *

libos/src/Directory.cpp

@@ -12,7 +12,6 @@
 #include <luna/CString.h>
 #include <os/Directory.h>
 #include <os/FileSystem.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
 static bool should_skip_entry(const char* name, os::Directory::Filter filter)
@@ -33,8 +32,8 @@ namespace os
     {
         auto dir = TRY(adopt_shared_if_nonnull(new (std::nothrow) Directory({})));
 
-        long rc = syscall(SYS_openat, path.dirfd(), path.name().chars(), O_RDONLY | O_DIRECTORY, 0);
-        int fd = TRY(Result<int>::from_syscall(rc));
+        int fd = openat(path.dirfd(), path.name().chars(), O_RDONLY | O_DIRECTORY, 0);
+        if (fd < 0) return err(errno);
 
         DIR* dp = fdopendir(fd);
         if (!dp)

libos/src/File.cpp

@@ -10,7 +10,6 @@
 #include <errno.h>
 #include <luna/StringBuilder.h>
 #include <os/File.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
 static SharedPtr<os::File> g_stdin = {};
@@ -83,8 +82,8 @@ namespace os
     {
         auto file = TRY(adopt_shared_if_nonnull(new (std::nothrow) File({})));
 
-        long rc = syscall(SYS_openat, path.dirfd(), path.name().chars(), flags, mode);
-        int fd = TRY(Result<int>::from_syscall(rc));
+        int fd = openat(path.dirfd(), path.name().chars(), flags, mode);
+        if (fd < 0) return err(errno);
 
         file->m_file = fdopen(fd, stdio_mode_from_openmode(flags));
         if (!file->m_file) return err(errno);

libos/src/FileSystem.cpp

@@ -10,13 +10,13 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <luna/Buffer.h>
 #include <luna/PathParser.h>
 #include <luna/String.h>
 #include <os/Directory.h>
 #include <os/FileSystem.h>
 #include <pwd.h>
 #include <stdlib.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
 namespace os::FileSystem
@@ -41,39 +41,26 @@ namespace os::FileSystem
 
     Result<void> stat(const Path& path, struct stat& st, bool follow_symlinks)
     {
-        long rc = syscall(SYS_fstatat, path.dirfd(), path.name().chars(), &st,
-                          (int)(path.is_empty_path() | (follow_symlinks ? 0 : AT_SYMLINK_NOFOLLOW)));
+        int rc = fstatat(path.dirfd(), path.name().chars(), &st,
+                         (int)(path.is_empty_path() | (follow_symlinks ? 0 : AT_SYMLINK_NOFOLLOW)));
 
-        return Result<void>::from_syscall(rc);
+        if (rc < 0) return err(errno);
+        return {};
     }
 
     Result<void> create_directory(StringView path, mode_t mode)
     {
-        long rc = syscall(SYS_mkdir, path.chars(), mode);
-
-        return Result<void>::from_syscall(rc);
+        int rc = mkdir(path.chars(), mode);
+        if (rc < 0) return err(errno);
+        return {};
     }
 
     Result<void> remove(const Path& path)
     {
-        long rc = syscall(SYS_unlinkat, path.dirfd(), path.name().chars(), 0);
-
-        return Result<void>::from_syscall(rc);
-    }
-
-    Result<void> remove_tree(const Path& path)
-    {
-        auto rc = remove(path);
-        if (!rc.has_error()) return {};
-        if (rc.error() != ENOTEMPTY) return rc.release_error();
-
-        auto dir = TRY(os::Directory::open(path));
-
-        Vector<String> entries = TRY(dir->list_names(os::Directory::Filter::ParentAndBase));
-
-        for (const auto& entry : entries) { TRY(remove_tree({ dir->fd(), entry.view() })); }
-
-        return remove(path);
+        // FIXME: This will not work on many operating systems that require rmdir() for directories.
+        int rc = unlinkat(path.dirfd(), path.name().chars(), 0);
+        if (rc < 0) return err(errno);
+        return {};
     }
 
     Result<String> readlink(const Path& path)
@@ -82,14 +69,13 @@ namespace os::FileSystem
         TRY(stat(path, st, false));
         if (!S_ISLNK(st.st_mode)) return String {};
 
-        char* buf = (char*)TRY(calloc_impl(st.st_size + 1, 1));
-        auto guard = make_scope_guard([buf] { free_impl(buf); });
-        usize nread = TRY(
-            Result<usize>::from_syscall(syscall(SYS_readlinkat, path.dirfd(), path.name().chars(), buf, st.st_size)));
+        Buffer buf = TRY(Buffer::create_sized(st.st_size + 1));
+        memset(buf.data(), 0, buf.size());
 
-        guard.deactivate();
+        ssize_t nread = readlinkat(path.dirfd(), path.name().chars(), (char*)buf.data(), st.st_size);
+        if (nread < 0) return err(errno);
 
-        return String { buf, nread };
+        return String { (char*)buf.release_data(), (usize)nread };
     }
 
     Result<String> working_directory()
@@ -112,8 +98,8 @@ namespace os::FileSystem
 
     Result<void> change_directory(StringView path)
     {
-        long rc = syscall(SYS_chdir, path.chars());
-
-        return Result<void>::from_syscall(rc);
+        int rc = chdir(path.chars());
+        if (rc < 0) return err(errno);
+        return {};
     }
 }

libos/src/Process.cpp

@@ -9,8 +9,8 @@
 
 #include <errno.h>
 #include <os/Process.h>
+#include <signal.h>
 #include <stdlib.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
 extern char** environ;
@@ -19,8 +19,9 @@ namespace os
 {
     Result<pid_t> Process::fork()
     {
-        long rc = syscall(SYS_fork);
-        return Result<pid_t>::from_syscall(rc);
+        pid_t pid = ::fork();
+        if (pid < 0) return err(errno);
+        return pid;
     }
 
     Result<void> Process::exec(StringView path, Slice<String> args, bool search_in_path)
@@ -121,14 +122,16 @@ namespace os
 
     Result<pid_t> Process::wait(pid_t child, int* status, int options)
     {
-        long rc = syscall(SYS_waitpid, child, status, options);
-        return Result<pid_t>::from_syscall(rc);
+        pid_t pid = waitpid(child, status, options);
+        if (pid < 0) return err(errno);
+        return pid;
     }
 
     Result<void> Process::kill(pid_t pid, int signo)
     {
-        long rc = syscall(SYS_kill, pid, signo);
-        return Result<void>::from_syscall(rc);
+        int rc = ::kill(pid, signo);
+        if (rc < 0) return err(errno);
+        return {};
     }
 
     [[noreturn]] void Process::exit(int status)