mountfd 0.1.0

data/ext/mountfd/compat.h

@@ -0,0 +1,197 @@
+#ifndef MOUNTFD_COMPAT_H
+#define MOUNTFD_COMPAT_H
+
+#ifdef __linux__
+# include <fcntl.h>
+# include <stdint.h>
+# include <sys/ioctl.h>
+# include <sys/syscall.h>
+# ifdef HAVE_LINUX_MOUNT_H
+#  include <linux/mount.h>
+# endif
+
+# ifndef SYS_open_tree
+#  define SYS_open_tree 428
+# endif
+# ifndef SYS_move_mount
+#  define SYS_move_mount 429
+# endif
+# ifndef SYS_fsopen
+#  define SYS_fsopen 430
+# endif
+# ifndef SYS_fsconfig
+#  define SYS_fsconfig 431
+# endif
+# ifndef SYS_fsmount
+#  define SYS_fsmount 432
+# endif
+# ifndef SYS_fspick
+#  define SYS_fspick 433
+# endif
+# ifndef SYS_mount_setattr
+#  define SYS_mount_setattr 442
+# endif
+# ifndef SYS_statmount
+#  define SYS_statmount 457
+# endif
+# ifndef SYS_listmount
+#  define SYS_listmount 458
+# endif
+# ifndef SYS_pivot_root
+#  ifdef __NR_pivot_root
+#   define SYS_pivot_root __NR_pivot_root
+#  elif defined(__x86_64__)
+#   define SYS_pivot_root 155
+#  elif defined(__aarch64__)
+#   define SYS_pivot_root 41
+#  else
+#   error "SYS_pivot_root is unavailable for this architecture"
+#  endif
+# endif
+
+# ifndef FSOPEN_CLOEXEC
+#  define FSOPEN_CLOEXEC 0x00000001
+# endif
+# ifndef FSPICK_CLOEXEC
+#  define FSPICK_CLOEXEC 0x00000001
+#  define FSPICK_SYMLINK_NOFOLLOW 0x00000002
+#  define FSPICK_NO_AUTOMOUNT 0x00000004
+#  define FSPICK_EMPTY_PATH 0x00000008
+# endif
+# ifndef FSCONFIG_SET_FLAG
+#  define FSCONFIG_SET_FLAG 0
+#  define FSCONFIG_SET_STRING 1
+#  define FSCONFIG_SET_BINARY 2
+#  define FSCONFIG_SET_PATH 3
+#  define FSCONFIG_SET_PATH_EMPTY 4
+#  define FSCONFIG_SET_FD 5
+#  define FSCONFIG_CMD_CREATE 6
+#  define FSCONFIG_CMD_RECONFIGURE 7
+# endif
+# ifndef FSCONFIG_CMD_CREATE_EXCL
+#  define FSCONFIG_CMD_CREATE_EXCL 8
+# endif
+# ifndef FSMOUNT_CLOEXEC
+#  define FSMOUNT_CLOEXEC 0x00000001
+# endif
+# ifndef OPEN_TREE_CLONE
+#  define OPEN_TREE_CLONE 1
+# endif
+# ifndef OPEN_TREE_CLOEXEC
+#  define OPEN_TREE_CLOEXEC O_CLOEXEC
+# endif
+# ifndef MOVE_MOUNT_F_SYMLINKS
+#  define MOVE_MOUNT_F_SYMLINKS 0x00000001
+#  define MOVE_MOUNT_F_AUTOMOUNTS 0x00000002
+#  define MOVE_MOUNT_F_EMPTY_PATH 0x00000004
+#  define MOVE_MOUNT_T_SYMLINKS 0x00000010
+#  define MOVE_MOUNT_T_AUTOMOUNTS 0x00000020
+#  define MOVE_MOUNT_T_EMPTY_PATH 0x00000040
+# endif
+# ifndef MOVE_MOUNT_SET_GROUP
+#  define MOVE_MOUNT_SET_GROUP 0x00000100
+# endif
+# ifndef MOVE_MOUNT_BENEATH
+#  define MOVE_MOUNT_BENEATH 0x00000200
+# endif
+# ifndef MOUNT_ATTR_RDONLY
+#  define MOUNT_ATTR_RDONLY 0x00000001ULL
+#  define MOUNT_ATTR_NOSUID 0x00000002ULL
+#  define MOUNT_ATTR_NODEV 0x00000004ULL
+#  define MOUNT_ATTR_NOEXEC 0x00000008ULL
+#  define MOUNT_ATTR__ATIME 0x00000070ULL
+#  define MOUNT_ATTR_RELATIME 0x00000000ULL
+#  define MOUNT_ATTR_NOATIME 0x00000010ULL
+#  define MOUNT_ATTR_STRICTATIME 0x00000020ULL
+#  define MOUNT_ATTR_NODIRATIME 0x00000080ULL
+# endif
+# ifndef MOUNT_ATTR_IDMAP
+#  define MOUNT_ATTR_IDMAP 0x00100000ULL
+# endif
+# ifndef MOUNT_ATTR_NOSYMFOLLOW
+#  define MOUNT_ATTR_NOSYMFOLLOW 0x00200000ULL
+# endif
+# ifndef MOUNT_ATTR_SIZE_VER0
+#  define MOUNT_ATTR_SIZE_VER0 32
+struct mount_attr {
+    uint64_t attr_set;
+    uint64_t attr_clr;
+    uint64_t propagation;
+    uint64_t userns_fd;
+};
+# endif
+# ifndef AT_RECURSIVE
+#  define AT_RECURSIVE 0x8000
+# endif
+# ifndef AT_EMPTY_PATH
+#  define AT_EMPTY_PATH 0x1000
+# endif
+# ifndef MS_UNBINDABLE
+#  define MS_UNBINDABLE (1 << 17)
+# endif
+# ifndef MS_REC
+#  define MS_REC 16384
+# endif
+# ifndef MS_PRIVATE
+#  define MS_PRIVATE (1 << 18)
+# endif
+# ifndef MS_SLAVE
+#  define MS_SLAVE (1 << 19)
+# endif
+# ifndef MS_SHARED
+#  define MS_SHARED (1 << 20)
+# endif
+# ifndef CLONE_NEWNS
+#  define CLONE_NEWNS 0x00020000
+# endif
+# ifndef CLONE_NEWUSER
+#  define CLONE_NEWUSER 0x10000000
+# endif
+# ifndef NSIO
+#  define NSIO 0xb7
+# endif
+# ifndef NS_GET_MNTNS_ID
+#  define NS_GET_MNTNS_ID _IOR(NSIO, 0x5, uint64_t)
+# endif
+# ifndef MNT_ID_REQ_SIZE_VER0
+#  define MNT_ID_REQ_SIZE_VER0 24
+# endif
+# ifndef MNT_ID_REQ_SIZE_VER1
+#  define MNT_ID_REQ_SIZE_VER1 32
+# endif
+# ifndef STATMOUNT_SB_BASIC
+#  define STATMOUNT_SB_BASIC 0x00000001U
+# endif
+# ifndef STATMOUNT_MNT_BASIC
+#  define STATMOUNT_MNT_BASIC 0x00000002U
+# endif
+# ifndef STATMOUNT_PROPAGATE_FROM
+#  define STATMOUNT_PROPAGATE_FROM 0x00000004U
+# endif
+# ifndef STATMOUNT_MNT_ROOT
+#  define STATMOUNT_MNT_ROOT 0x00000008U
+# endif
+# ifndef STATMOUNT_MNT_POINT
+#  define STATMOUNT_MNT_POINT 0x00000010U
+# endif
+# ifndef STATMOUNT_FS_TYPE
+#  define STATMOUNT_FS_TYPE 0x00000020U
+# endif
+# ifndef STATMOUNT_MNT_NS_ID
+#  define STATMOUNT_MNT_NS_ID 0x00000040U
+# endif
+# ifndef STATMOUNT_MNT_OPTS
+#  define STATMOUNT_MNT_OPTS 0x00000080U
+# endif
+# ifndef STATMOUNT_FS_SUBTYPE
+#  define STATMOUNT_FS_SUBTYPE 0x00000100U
+# endif
+# ifndef STATMOUNT_SB_SOURCE
+#  define STATMOUNT_SB_SOURCE 0x00000200U
+# endif
+# ifndef LSMT_ROOT
+#  define LSMT_ROOT UINT64_MAX
+# endif
+#endif
+
+#endif

data/ext/mountfd/constants.c

@@ -0,0 +1,53 @@
+/* Generated by tools/generate_constants.rb from Linux UAPI headers. */
+#include "ruby.h"
+
+void mountfd_define_constants(VALUE native)
+{
+#define DEF(name, value) rb_define_const(native, name, ULL2NUM(value))
+    DEF("FSOPEN_CLOEXEC", 1ULL);
+    DEF("FSPICK_CLOEXEC", 1ULL);
+    DEF("FSPICK_SYMLINK_NOFOLLOW", 2ULL);
+    DEF("FSPICK_NO_AUTOMOUNT", 4ULL);
+    DEF("FSPICK_EMPTY_PATH", 8ULL);
+    DEF("FSCONFIG_SET_FLAG", 0ULL);
+    DEF("FSCONFIG_SET_STRING", 1ULL);
+    DEF("FSCONFIG_SET_BINARY", 2ULL);
+    DEF("FSCONFIG_SET_PATH", 3ULL);
+    DEF("FSCONFIG_SET_PATH_EMPTY", 4ULL);
+    DEF("FSCONFIG_SET_FD", 5ULL);
+    DEF("FSCONFIG_CMD_CREATE", 6ULL);
+    DEF("FSCONFIG_CMD_RECONFIGURE", 7ULL);
+    DEF("FSCONFIG_CMD_CREATE_EXCL", 8ULL);
+    DEF("FSMOUNT_CLOEXEC", 1ULL);
+    DEF("OPEN_TREE_CLONE", 1ULL);
+    DEF("OPEN_TREE_CLOEXEC", 524288ULL);
+    DEF("MOVE_MOUNT_F_SYMLINKS", 1ULL);
+    DEF("MOVE_MOUNT_F_AUTOMOUNTS", 2ULL);
+    DEF("MOVE_MOUNT_F_EMPTY_PATH", 4ULL);
+    DEF("MOVE_MOUNT_T_SYMLINKS", 16ULL);
+    DEF("MOVE_MOUNT_T_AUTOMOUNTS", 32ULL);
+    DEF("MOVE_MOUNT_T_EMPTY_PATH", 64ULL);
+    DEF("MOVE_MOUNT_SET_GROUP", 256ULL);
+    DEF("MOVE_MOUNT_BENEATH", 512ULL);
+    DEF("MOUNT_ATTR_RDONLY", 1ULL);
+    DEF("MOUNT_ATTR_NOSUID", 2ULL);
+    DEF("MOUNT_ATTR_NODEV", 4ULL);
+    DEF("MOUNT_ATTR_NOEXEC", 8ULL);
+    DEF("MOUNT_ATTR__ATIME", 112ULL);
+    DEF("MOUNT_ATTR_RELATIME", 0ULL);
+    DEF("MOUNT_ATTR_NOATIME", 16ULL);
+    DEF("MOUNT_ATTR_STRICTATIME", 32ULL);
+    DEF("MOUNT_ATTR_NODIRATIME", 128ULL);
+    DEF("MOUNT_ATTR_IDMAP", 1048576ULL);
+    DEF("MOUNT_ATTR_NOSYMFOLLOW", 2097152ULL);
+    DEF("AT_RECURSIVE", 32768ULL);
+    DEF("AT_EMPTY_PATH", 4096ULL);
+    DEF("MS_UNBINDABLE", 131072ULL);
+    DEF("MS_REC", 16384ULL);
+    DEF("MS_PRIVATE", 262144ULL);
+    DEF("MS_SLAVE", 524288ULL);
+    DEF("MS_SHARED", 1048576ULL);
+    DEF("CLONE_NEWNS", 131072ULL);
+    DEF("CLONE_NEWUSER", 268435456ULL);
+#undef DEF
+}

data/ext/mountfd/extconf.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+have_header("linux/mount.h")
+have_header("sys/mount.h")
+have_header("sys/syscall.h")
+have_header("sched.h")
+have_func("syscall", "unistd.h")
+have_func("unshare", "sched.h")
+create_header
+create_makefile("mountfd/mountfd")

data/ext/mountfd/mount_info.c

@@ -0,0 +1,166 @@
+#include "ruby.h"
+#include "mountfd.h"
+#include "compat.h"
+
+#ifdef __linux__
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#define MOUNTFD_STAT_SIZE 512
+#define MOUNTFD_STAT_MASK (STATMOUNT_SB_BASIC | STATMOUNT_MNT_BASIC | \
+    STATMOUNT_PROPAGATE_FROM | STATMOUNT_MNT_ROOT | STATMOUNT_MNT_POINT | \
+    STATMOUNT_FS_TYPE | STATMOUNT_MNT_NS_ID | STATMOUNT_MNT_OPTS | \
+    STATMOUNT_FS_SUBTYPE | STATMOUNT_SB_SOURCE)
+
+struct mountfd_mnt_id_req {
+    uint32_t size;
+    uint32_t spare;
+    uint64_t mnt_id;
+    uint64_t param;
+    uint64_t mnt_ns_id;
+};
+
+struct mountfd_statmount {
+    uint32_t size;
+    uint32_t mnt_opts;
+    uint64_t mask;
+    uint32_t dev_major;
+    uint32_t dev_minor;
+    uint64_t sb_magic;
+    uint32_t sb_flags;
+    uint32_t fs_type;
+    uint64_t mnt_id;
+    uint64_t parent_id;
+    uint32_t old_id;
+    uint32_t old_parent_id;
+    uint64_t attrs;
+    uint64_t propagation;
+    uint64_t peer_group;
+    uint64_t master;
+    uint64_t propagate_from;
+    uint32_t root;
+    uint32_t point;
+    uint64_t namespace_id;
+    uint32_t fs_subtype;
+    uint32_t source;
+    unsigned char reserved[MOUNTFD_STAT_SIZE - 128];
+};
+
+static VALUE symbol(const char *name)
+{
+    return ID2SYM(rb_intern(name));
+}
+
+static VALUE stat_string(char *buffer, size_t capacity, uint32_t offset)
+{
+    struct mountfd_statmount *stat = (struct mountfd_statmount *)buffer;
+    size_t position = MOUNTFD_STAT_SIZE + offset;
+    size_t available;
+    if (position >= capacity || position >= stat->size) return Qnil;
+    available = stat->size < capacity ? stat->size - position : capacity - position;
+    return rb_str_new(buffer + position, strnlen(buffer + position, available));
+}
+
+static VALUE stat_hash(char *buffer, size_t capacity)
+{
+    struct mountfd_statmount *stat = (struct mountfd_statmount *)buffer;
+    VALUE hash = rb_hash_new();
+#define PUT(name, value) rb_hash_aset(hash, symbol(name), value)
+    PUT("mnt_id", ULL2NUM(stat->mnt_id));
+    PUT("parent_id", ULL2NUM(stat->parent_id));
+    PUT("old_id", UINT2NUM(stat->old_id));
+    PUT("old_parent_id", UINT2NUM(stat->old_parent_id));
+    PUT("dev_major", UINT2NUM(stat->dev_major));
+    PUT("dev_minor", UINT2NUM(stat->dev_minor));
+    PUT("attrs", ULL2NUM(stat->attrs));
+    PUT("propagation", ULL2NUM(stat->propagation));
+    PUT("peer_group", ULL2NUM(stat->peer_group));
+    PUT("master", ULL2NUM(stat->master));
+    PUT("propagate_from", ULL2NUM(stat->propagate_from));
+    PUT("mnt_root", (stat->mask & STATMOUNT_MNT_ROOT) ? stat_string(buffer, capacity, stat->root) : Qnil);
+    PUT("mount_point", (stat->mask & STATMOUNT_MNT_POINT) ? stat_string(buffer, capacity, stat->point) : Qnil);
+    PUT("fs_type", (stat->mask & STATMOUNT_FS_TYPE) ? stat_string(buffer, capacity, stat->fs_type) : Qnil);
+    PUT("source", (stat->mask & STATMOUNT_SB_SOURCE) ? stat_string(buffer, capacity, stat->source) : Qnil);
+    PUT("options", (stat->mask & STATMOUNT_MNT_OPTS) ? stat_string(buffer, capacity, stat->mnt_opts) : Qnil);
+#undef PUT
+    return hash;
+}
+
+static VALUE stat_one(uint64_t id, uint64_t namespace_id, int namespace_selected)
+{
+    struct mountfd_mnt_id_req request = {
+        namespace_selected ? MNT_ID_REQ_SIZE_VER1 : MNT_ID_REQ_SIZE_VER0,
+        0, id, MOUNTFD_STAT_MASK, namespace_id
+    };
+    size_t capacity = 4096;
+    char *buffer = NULL;
+    long result;
+
+    while (capacity <= 1024 * 1024) {
+        buffer = realloc(buffer, capacity);
+        if (!buffer) rb_memerror();
+        memset(buffer, 0, capacity);
+        result = syscall(SYS_statmount, &request, buffer, capacity, 0);
+        if (result == 0) {
+            VALUE hash = stat_hash(buffer, capacity);
+            free(buffer);
+            return hash;
+        }
+        if (errno == ENOENT) { free(buffer); return Qnil; }
+        if (errno != EOVERFLOW) {
+            int error = errno;
+            free(buffer); errno = error; mountfd_syscall_failed("statmount");
+        }
+        capacity *= 2;
+    }
+    free(buffer);
+    rb_raise(rb_eRuntimeError, "statmount response exceeds 1 MiB");
+}
+#endif
+
+static VALUE native_statmounts(VALUE self, VALUE namespace_fd)
+{
+#ifdef __linux__
+    uint64_t namespace_id = 0;
+    int namespace_selected = !NIL_P(namespace_fd);
+    struct mountfd_mnt_id_req request = {MNT_ID_REQ_SIZE_VER0, 0, LSMT_ROOT, 0, 0};
+    uint64_t ids[256];
+    VALUE mounts = rb_ary_new();
+    long count;
+    size_t index;
+
+    if (namespace_selected) {
+        if (ioctl(NUM2INT(namespace_fd), NS_GET_MNTNS_ID, &namespace_id) < 0)
+            mountfd_syscall_failed("NS_GET_MNTNS_ID");
+        request.size = MNT_ID_REQ_SIZE_VER1;
+        request.mnt_ns_id = namespace_id;
+    }
+
+    while (1) {
+        count = syscall(SYS_listmount, &request, ids, 256, 0);
+        if (count < 0) mountfd_syscall_failed("listmount");
+        if (count == 0) break;
+        for (index = 0; index < (size_t)count; index++) {
+            VALUE value = stat_one(ids[index], namespace_id, namespace_selected);
+            if (!NIL_P(value)) rb_ary_push(mounts, value);
+        }
+        request.param = ids[count - 1];
+        if (count < 256) break;
+    }
+    return mounts;
+#else
+    (void)namespace_fd;
+    VALUE mountfd = rb_const_get(rb_cObject, rb_intern("Mountfd"));
+    VALUE error = rb_const_get(mountfd, rb_intern("UnsupportedError"));
+    rb_raise(error, "statmount is unavailable on this platform");
+#endif
+}
+
+void mountfd_mount_info_init(VALUE native)
+{
+    rb_define_singleton_method(native, "statmounts", native_statmounts, 1);
+}