linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/mount.h>

#include <linux/file.h>

#include <linux/fs.h>

#include <linux/proc_ns.h>

#include <linux/magic.h>

#include <linux/ktime.h>

#include <linux/seq_file.h>

#include <linux/user_namespace.h>

#include <linux/nsfs.h>

#include <linux/uaccess.h>

​

static struct vfsmount *nsfs_mnt;

​

static long ns_ioctl(struct file *filp, unsigned int ioctl,

            unsigned long arg);

static const struct file_operations ns_file_operations = {

    .llseek     = no_llseek,

    .unlocked_ioctl = ns_ioctl,

};

​

static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)

{

    struct inode *inode = d_inode(dentry);

    const struct proc_ns_operations *ns_ops = dentry->d_fsdata;

​

    return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]",

        ns_ops->name, inode->i_ino);

}

​

static void ns_prune_dentry(struct dentry *dentry)

{

    struct inode *inode = d_inode(dentry);

    if (inode) {

        struct ns_common *ns = inode->i_private;

        atomic_long_set(&ns->stashed, 0);

    }

}

​

const struct dentry_operations ns_dentry_operations =

{

    .d_prune    = ns_prune_dentry,

    .d_delete   = always_delete_dentry,

    .d_dname    = ns_dname,

};

​

static void nsfs_evict(struct inode *inode)

{

    struct ns_common *ns = inode->i_private;

    clear_inode(inode);

    ns->ops->put(ns);

}

​

static void *__ns_get_path(struct path *path, struct ns_common *ns)

{

    struct vfsmount *mnt = nsfs_mnt;

    struct dentry *dentry;

    struct inode *inode;

    unsigned long d;

​

    rcu_read_lock();

    d = atomic_long_read(&ns->stashed);

    if (!d)

        goto slow;

    dentry = (struct dentry *)d;

    if (!lockref_get_not_dead(&dentry->d_lockref))

        goto slow;

    rcu_read_unlock();

    ns->ops->put(ns);

got_it:

    path->mnt = mntget(mnt);

    path->dentry = dentry;

    return NULL;

slow:

    rcu_read_unlock();

    inode = new_inode_pseudo(mnt->mnt_sb);

    if (!inode) {

        ns->ops->put(ns);

        return ERR_PTR(-ENOMEM);

    }

    inode->i_ino = ns->inum;

    inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);

    inode->i_flags |= S_IMMUTABLE;

    inode->i_mode = S_IFREG | S_IRUGO;

    inode->i_fop = &ns_file_operations;

    inode->i_private = ns;

​

    dentry = d_alloc_pseudo(mnt->mnt_sb, &empty_name);

    if (!dentry) {

        iput(inode);

        return ERR_PTR(-ENOMEM);

    }