fs/proc/self.c

   1 #include <linux/sched.h>
   2 #include <linux/slab.h>
   3 #include <linux/pid_namespace.h>
   4 #include "internal.h"
   5
   6 /*
   7  * /proc/self:
   8  */
   9 static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
  10                               int buflen)
  11 {
  12         struct pid_namespace *ns = dentry->d_sb->s_fs_info;
  13         pid_t tgid = task_tgid_nr_ns(current, ns);
  14         char tmp[PROC_NUMBUF];
  15         if (!tgid)
  16                 return -ENOENT;
  17         sprintf(tmp, "%d", tgid);
  18         return readlink_copy(buffer, buflen, tmp);
  19 }
  20
  21 static const char *proc_self_get_link(struct dentry *dentry,
  22                                       struct inode *inode,
  23                                       struct delayed_call *done)
  24 {
  25         struct pid_namespace *ns = inode->i_sb->s_fs_info;
  26         pid_t tgid = task_tgid_nr_ns(current, ns);
  27         char *name;
  28
  29         /*
  30          * Not currently supported. Once we can inherit all of struct pid,
  31          * we can allow this.
  32          */
  33         if (current->flags & PF_KTHREAD)
  34                 return ERR_PTR(-EOPNOTSUPP);
  35
  36         if (!tgid)
  37                 return ERR_PTR(-ENOENT);
  38         /* 11 for max length of signed int in decimal + NULL term */
  39         name = kmalloc(12, dentry ? GFP_KERNEL : GFP_ATOMIC);
  40         if (unlikely(!name))
  41                 return dentry ? ERR_PTR(-ENOMEM) : ERR_PTR(-ECHILD);
  42         sprintf(name, "%d", tgid);
  43         set_delayed_call(done, kfree_link, name);
  44         return name;
  45 }
  46
  47 static const struct inode_operations proc_self_inode_operations = {
  48         .readlink       = proc_self_readlink,
  49         .get_link       = proc_self_get_link,
  50 };
  51
  52 static unsigned self_inum;
  53
  54 int proc_setup_self(struct super_block *s)
  55 {
  56         struct inode *root_inode = d_inode(s->s_root);
  57         struct pid_namespace *ns = s->s_fs_info;
  58         struct dentry *self;
  59
  60         inode_lock(root_inode);
  61         self = d_alloc_name(s->s_root, "self");
  62         if (self) {
  63                 struct inode *inode = new_inode(s);
  64                 if (inode) {
  65                         inode->i_ino = self_inum;
  66                         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
  67                         inode->i_mode = S_IFLNK | S_IRWXUGO;
  68                         inode->i_uid = GLOBAL_ROOT_UID;
  69                         inode->i_gid = GLOBAL_ROOT_GID;
  70                         inode->i_op = &proc_self_inode_operations;
  71                         d_add(self, inode);
  72                 } else {
  73                         dput(self);
  74                         self = ERR_PTR(-ENOMEM);
  75                 }
  76         } else {
  77                 self = ERR_PTR(-ENOMEM);
  78         }
  79         inode_unlock(root_inode);
  80         if (IS_ERR(self)) {
  81                 pr_err("proc_fill_super: can't allocate /proc/self\n");
  82                 return PTR_ERR(self);
  83         }
  84         ns->proc_self = self;
  85         return 0;
  86 }
  87
  88 void __init proc_self_init(void)
  89 {
  90         proc_alloc_inum(&self_inum);
  91 }