[linux-2.6-block.git] / fs / proc / thread_self.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/cache.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/pid_namespace.h>
#include "internal.h"

/*
 * /proc/thread_self:
 */
static const char *proc_thread_self_get_link(struct dentry *dentry,
					     struct inode *inode,
					     struct delayed_call *done)
{
	struct pid_namespace *ns = proc_pid_ns(inode);
	pid_t tgid = task_tgid_nr_ns(current, ns);
	pid_t pid = task_pid_nr_ns(current, ns);
	char *name;

	if (!pid)
		return ERR_PTR(-ENOENT);
	name = kmalloc(10 + 6 + 10 + 1, dentry ? GFP_KERNEL : GFP_ATOMIC);
	if (unlikely(!name))
		return dentry ? ERR_PTR(-ENOMEM) : ERR_PTR(-ECHILD);
	sprintf(name, "%u/task/%u", tgid, pid);
	set_delayed_call(done, kfree_link, name);
	return name;
}

static const struct inode_operations proc_thread_self_inode_operations = {
	.get_link	= proc_thread_self_get_link,
};

static unsigned thread_self_inum __ro_after_init;

int proc_setup_thread_self(struct super_block *s)
{
	struct inode *root_inode = d_inode(s->s_root);
	struct pid_namespace *ns = proc_pid_ns(root_inode);
	struct dentry *thread_self;

	inode_lock(root_inode);
	thread_self = d_alloc_name(s->s_root, "thread-self");
	if (thread_self) {
		struct inode *inode = new_inode_pseudo(s);
		if (inode) {
			inode->i_ino = thread_self_inum;
			inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
			inode->i_mode = S_IFLNK | S_IRWXUGO;
			inode->i_uid = GLOBAL_ROOT_UID;
			inode->i_gid = GLOBAL_ROOT_GID;
			inode->i_op = &proc_thread_self_inode_operations;
			d_add(thread_self, inode);
		} else {
			dput(thread_self);
			thread_self = ERR_PTR(-ENOMEM);
		}
	} else {
		thread_self = ERR_PTR(-ENOMEM);
	}
	inode_unlock(root_inode);
	if (IS_ERR(thread_self)) {
		pr_err("proc_fill_super: can't allocate /proc/thread_self\n");
		return PTR_ERR(thread_self);
	}
	ns->proc_thread_self = thread_self;
	return 0;
}

void __init proc_thread_self_init(void)
{
	proc_alloc_inum(&thread_self_inum);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
efb1a57d	2	#include <linux/cache.h>
0097875b	3	#include <linux/sched.h>
0097875b EB	4	#include <linux/slab.h>
	5	#include <linux/pid_namespace.h>
	6	#include "internal.h"
	7
	8	/*
	9	* /proc/thread_self:
	10	*/
6b255391	11	static const char proc_thread_self_get_link(struct dentry dentry,
fceef393 AV	12	struct inode *inode,
fceef393 AV	13	struct delayed_call *done)
0097875b	14	{
76f668be	15	struct pid_namespace *ns = proc_pid_ns(inode);
0097875b EB	16	pid_t tgid = task_tgid_nr_ns(current, ns);
0097875b EB	17	pid_t pid = task_pid_nr_ns(current, ns);
680baacb AV	18	char *name;
	19
	20	if (!pid)
	21	return ERR_PTR(-ENOENT);
e3912ac3	22	name = kmalloc(10 + 6 + 10 + 1, dentry ? GFP_KERNEL : GFP_ATOMIC);
1a384eaa AV	23	if (unlikely(!name))
1a384eaa AV	24	return dentry ? ERR_PTR(-ENOMEM) : ERR_PTR(-ECHILD);
e3912ac3	25	sprintf(name, "%u/task/%u", tgid, pid);
fceef393 AV	26	set_delayed_call(done, kfree_link, name);
fceef393 AV	27	return name;
0097875b EB	28	}
	29
	30	static const struct inode_operations proc_thread_self_inode_operations = {
6b255391	31	.get_link = proc_thread_self_get_link,
0097875b EB	32	};
0097875b EB	33
efb1a57d	34	static unsigned thread_self_inum __ro_after_init;
0097875b EB	35
	36	int proc_setup_thread_self(struct super_block *s)
	37	{
2b0143b5	38	struct inode *root_inode = d_inode(s->s_root);
76f668be	39	struct pid_namespace *ns = proc_pid_ns(root_inode);
0097875b EB	40	struct dentry *thread_self;
0097875b EB	41
5955102c	42	inode_lock(root_inode);
0097875b EB	43	thread_self = d_alloc_name(s->s_root, "thread-self");
	44	if (thread_self) {
	45	struct inode *inode = new_inode_pseudo(s);
	46	if (inode) {
	47	inode->i_ino = thread_self_inum;
078cd827	48	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
0097875b EB	49	inode->i_mode = S_IFLNK \| S_IRWXUGO;
	50	inode->i_uid = GLOBAL_ROOT_UID;
	51	inode->i_gid = GLOBAL_ROOT_GID;
	52	inode->i_op = &proc_thread_self_inode_operations;
	53	d_add(thread_self, inode);
	54	} else {
	55	dput(thread_self);
	56	thread_self = ERR_PTR(-ENOMEM);
	57	}
	58	} else {
	59	thread_self = ERR_PTR(-ENOMEM);
	60	}
5955102c	61	inode_unlock(root_inode);
0097875b EB	62	if (IS_ERR(thread_self)) {
	63	pr_err("proc_fill_super: can't allocate /proc/thread_self\n");
	64	return PTR_ERR(thread_self);
	65	}
	66	ns->proc_thread_self = thread_self;
	67	return 0;
	68	}
	69
	70	void __init proc_thread_self_init(void)
	71	{
	72	proc_alloc_inum(&thread_self_inum);
	73	}