lkml.org 
[lkml]   [2020]   [Jul]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH 09/23] ns: Introduce ns_idr to be able to iterate all allocated namespaces in the system
    From
    Date
    This patch introduces a new IDR and functions to add/remove and iterate
    registered namespaces in the system. It will be used to list namespaces
    in /proc/namespaces/... in next patches.

    The IDR is protected by ns_idr, and it's choosen to be a spinlock (not
    mutex) to allow calling ns_idr_unregister() from put_xxx_ns() methods,
    which may be called from (say) softirq context. Spinlock allows us
    to avoid introduction of kwork on top of put_xxx_ns() to call mutex_lock().

    We introduce a new IDR, because there is no appropriate items to reuse
    instead of this. The closest proc_inum_ida does not fit our goals:
    it is IDA and its convertation to IDR will bring a big overhead by proc
    entries, which are not interested in IDR functionality (pointers).

    Read access to ns_idr is made lockless (see ns_get_next()). This is made
    for better parallelism and better performance from start. One new requirement
    to do this is that namespace memory must be freed one RCU grace period
    after ns_idr_unregister(). Some namespaces types already does this (say, net),
    the rest will be converted to use kfree_rcu()/etc, where they become
    linked to the IDR. See next patches in this series for the details.

    Signed-off-by: Kirill Tkhai <ktkhai@virtuozzo.com>
    ---
    fs/nsfs.c | 76 +++++++++++++++++++++++++++++++++++++++++++++
    include/linux/ns_common.h | 10 ++++++
    include/linux/proc_ns.h | 11 ++++---
    3 files changed, 92 insertions(+), 5 deletions(-)

    diff --git a/fs/nsfs.c b/fs/nsfs.c
    index 800c1d0eb0d0..ee4be67d3a0b 100644
    --- a/fs/nsfs.c
    +++ b/fs/nsfs.c
    @@ -11,10 +11,13 @@
    #include <linux/user_namespace.h>
    #include <linux/nsfs.h>
    #include <linux/uaccess.h>
    +#include <linux/idr.h>

    #include "internal.h"

    static struct vfsmount *nsfs_mnt;
    +static DEFINE_SPINLOCK(ns_lock);
    +static DEFINE_IDR(ns_idr);

    static long ns_ioctl(struct file *filp, unsigned int ioctl,
    unsigned long arg);
    @@ -304,3 +307,76 @@ void __init nsfs_init(void)
    panic("can't set nsfs up\n");
    nsfs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
    }
    +
    +/*
    + * Add a newly created ns to ns_idr. The ns must be fully
    + * initialized since it becomes available for ns_get_next()
    + * right after we exit this function.
    + */
    +int ns_idr_register(struct ns_common *ns)
    +{
    + int ret, id = ns->inum - PROC_NS_MIN_INO;
    +
    + if (WARN_ON(id < 0))
    + return -EINVAL;
    +
    + idr_preload(GFP_KERNEL);
    + spin_lock_irq(&ns_lock);
    + ret = idr_alloc(&ns_idr, ns, id, id + 1, GFP_ATOMIC);
    + spin_unlock_irq(&ns_lock);
    + idr_preload_end();
    +
    + return ret < 0 ? ret : 0;
    +}
    +
    +/*
    + * Remove a dead ns from ns_idr. Note, that ns memory must
    + * be freed not earlier then one RCU grace period after
    + * this function, since ns_get_next() uses RCU to iterate the IDR.
    + */
    +void ns_idr_unregister(struct ns_common *ns)
    +{
    + int id = ns->inum - PROC_NS_MIN_INO;
    + unsigned long flags;
    +
    + if (WARN_ON(id < 0))
    + return;
    +
    + spin_lock_irqsave(&ns_lock, flags);
    + idr_remove(&ns_idr, id);
    + spin_unlock_irqrestore(&ns_lock, flags);
    +}
    +
    +/*
    + * This returns ns with inum greater than @id or NULL.
    + * @id is updated to refer the ns inum.
    + */
    +struct ns_common *ns_get_next(unsigned int *id)
    +{
    + struct ns_common *ns;
    +
    + if (*id < PROC_NS_MIN_INO - 1)
    + *id = PROC_NS_MIN_INO - 1;
    +
    + *id += 1;
    + *id -= PROC_NS_MIN_INO;
    +
    + rcu_read_lock();
    + do {
    + ns = idr_get_next(&ns_idr, id);
    + if (!ns)
    + break;
    + if (!refcount_inc_not_zero(&ns->count)) {
    + ns = NULL;
    + *id += 1;
    + }
    + } while (!ns);
    + rcu_read_unlock();
    +
    + if (ns) {
    + *id += PROC_NS_MIN_INO;
    + WARN_ON(*id != ns->inum);
    + }
    +
    + return ns;
    +}
    diff --git a/include/linux/ns_common.h b/include/linux/ns_common.h
    index 27db02ebdf36..5f460e97151a 100644
    --- a/include/linux/ns_common.h
    +++ b/include/linux/ns_common.h
    @@ -4,6 +4,12 @@

    struct proc_ns_operations;

    +/*
    + * Common part of all namespaces. Note, that we link namespaces
    + * into IDR, and they are dereferenced via RCU. So, a namespace
    + * memory is allowed to be freed one RCU grace period after final
    + * .count put. See ns_get_next() for the details.
    + */
    struct ns_common {
    atomic_long_t stashed;
    const struct proc_ns_operations *ops;
    @@ -11,4 +17,8 @@ struct ns_common {
    refcount_t count;
    };

    +extern int ns_idr_register(struct ns_common *ns);
    +extern void ns_idr_unregister(struct ns_common *ns);
    +extern struct ns_common *ns_get_next(unsigned int *id);
    +
    #endif
    diff --git a/include/linux/proc_ns.h b/include/linux/proc_ns.h
    index 75807ecef880..906e6ebb43e4 100644
    --- a/include/linux/proc_ns.h
    +++ b/include/linux/proc_ns.h
    @@ -40,12 +40,13 @@ extern const struct proc_ns_operations timens_for_children_operations;
    */
    enum {
    PROC_ROOT_INO = 1,
    - PROC_IPC_INIT_INO = 0xEFFFFFFFU,
    - PROC_UTS_INIT_INO = 0xEFFFFFFEU,
    - PROC_USER_INIT_INO = 0xEFFFFFFDU,
    - PROC_PID_INIT_INO = 0xEFFFFFFCU,
    - PROC_CGROUP_INIT_INO = 0xEFFFFFFBU,
    PROC_TIME_INIT_INO = 0xEFFFFFFAU,
    + PROC_NS_MIN_INO = PROC_TIME_INIT_INO,
    + PROC_CGROUP_INIT_INO = 0xEFFFFFFBU,
    + PROC_PID_INIT_INO = 0xEFFFFFFCU,
    + PROC_USER_INIT_INO = 0xEFFFFFFDU,
    + PROC_UTS_INIT_INO = 0xEFFFFFFEU,
    + PROC_IPC_INIT_INO = 0xEFFFFFFFU,
    };

    #ifdef CONFIG_PROC_FS

    \
     
     \ /
      Last update: 2020-07-30 14:00    [W:2.718 / U:0.088 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site