Merge branch 'for-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Jun 2018 00:31:33 +0000 (17:31 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Jun 2018 00:31:33 +0000 (17:31 -0700)
Pull workqueue updates from Tejun Heo:

 - make kworkers report the workqueue it is executing or has executed
   most recently in /proc/PID/comm (so they show up in ps/top)

 - CONFIG_SMP shuffle to move stuff which isn't necessary for UP builds
   inside CONFIG_SMP.

* 'for-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: move function definitions within CONFIG_SMP block
  workqueue: Make sure struct worker is accessible for wq_worker_comm()
  workqueue: Show the latest workqueue name in /proc/PID/{comm,stat,status}
  proc: Consolidate task->comm formatting into proc_task_name()
  workqueue: Set worker->desc to workqueue name by default
  workqueue: Make worker_attach/detach_pool() update worker->pool
  workqueue: Replace pool->attach_mutex with global wq_pool_attach_mutex

1  2 
fs/proc/array.c
fs/proc/base.c
fs/proc/internal.h

diff --combined fs/proc/array.c
index e6d7f41b66845af42f51fe442fee288152161870,bb1d3619ca12dec0762c9546103ca8937c9aeb3c..004077f1a7bfd1c4083665f998390e3586a15506
@@@ -85,7 -85,6 +85,7 @@@
  #include <linux/delayacct.h>
  #include <linux/seq_file.h>
  #include <linux/pid_namespace.h>
 +#include <linux/prctl.h>
  #include <linux/ptrace.h>
  #include <linux/tracehook.h>
  #include <linux/string_helpers.h>
  #include <asm/processor.h>
  #include "internal.h"
  
static inline void task_name(struct seq_file *m, struct task_struct *p)
void proc_task_name(struct seq_file *m, struct task_struct *p, bool escape)
  {
        char *buf;
        size_t size;
-       char tcomm[sizeof(p->comm)];
+       char tcomm[64];
        int ret;
  
-       get_task_comm(tcomm, p);
-       seq_puts(m, "Name:\t");
+       if (p->flags & PF_WQ_WORKER)
+               wq_worker_comm(tcomm, sizeof(tcomm), p);
+       else
+               __get_task_comm(tcomm, sizeof(tcomm), p);
  
        size = seq_get_buf(m, &buf);
-       ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
-       seq_commit(m, ret < size ? ret : -1);
+       if (escape) {
+               ret = string_escape_str(tcomm, buf, size,
+                                       ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
+               if (ret >= size)
+                       ret = -1;
+       } else {
+               ret = strscpy(buf, tcomm, size);
+       }
  
-       seq_putc(m, '\n');
+       seq_commit(m, ret);
  }
  
  /*
@@@ -336,30 -342,6 +343,30 @@@ static inline void task_seccomp(struct 
  #ifdef CONFIG_SECCOMP
        seq_put_decimal_ull(m, "\nSeccomp:\t", p->seccomp.mode);
  #endif
 +      seq_printf(m, "\nSpeculation_Store_Bypass:\t");
 +      switch (arch_prctl_spec_ctrl_get(p, PR_SPEC_STORE_BYPASS)) {
 +      case -EINVAL:
 +              seq_printf(m, "unknown");
 +              break;
 +      case PR_SPEC_NOT_AFFECTED:
 +              seq_printf(m, "not vulnerable");
 +              break;
 +      case PR_SPEC_PRCTL | PR_SPEC_FORCE_DISABLE:
 +              seq_printf(m, "thread force mitigated");
 +              break;
 +      case PR_SPEC_PRCTL | PR_SPEC_DISABLE:
 +              seq_printf(m, "thread mitigated");
 +              break;
 +      case PR_SPEC_PRCTL | PR_SPEC_ENABLE:
 +              seq_printf(m, "thread vulnerable");
 +              break;
 +      case PR_SPEC_DISABLE:
 +              seq_printf(m, "globally mitigated");
 +              break;
 +      default:
 +              seq_printf(m, "vulnerable");
 +              break;
 +      }
        seq_putc(m, '\n');
  }
  
@@@ -390,7 -372,10 +397,10 @@@ int proc_pid_status(struct seq_file *m
  {
        struct mm_struct *mm = get_task_mm(task);
  
-       task_name(m, task);
+       seq_puts(m, "Name:\t");
+       proc_task_name(m, task, true);
+       seq_putc(m, '\n');
        task_state(m, ns, pid, task);
  
        if (mm) {
@@@ -425,7 -410,6 +435,6 @@@ static int do_task_stat(struct seq_fil
        u64 cutime, cstime, utime, stime;
        u64 cgtime, gtime;
        unsigned long rsslim = 0;
-       char tcomm[sizeof(task->comm)];
        unsigned long flags;
  
        state = *get_task_state(task);
                }
        }
  
-       get_task_comm(tcomm, task);
        sigemptyset(&sigign);
        sigemptyset(&sigcatch);
        cutime = cstime = utime = stime = 0;
  
        seq_put_decimal_ull(m, "", pid_nr_ns(pid, ns));
        seq_puts(m, " (");
-       seq_puts(m, tcomm);
+       proc_task_name(m, task, false);
        seq_puts(m, ") ");
        seq_putc(m, state);
        seq_put_decimal_ll(m, " ", ppid);
@@@ -702,22 -684,25 +709,22 @@@ out
  
  static int children_seq_show(struct seq_file *seq, void *v)
  {
 -      struct inode *inode = seq->private;
 -      pid_t pid;
 -
 -      pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
 -      seq_printf(seq, "%d ", pid);
 +      struct inode *inode = file_inode(seq->file);
  
 +      seq_printf(seq, "%d ", pid_nr_ns(v, proc_pid_ns(inode)));
        return 0;
  }
  
  static void *children_seq_start(struct seq_file *seq, loff_t *pos)
  {
 -      return get_children_pid(seq->private, NULL, *pos);
 +      return get_children_pid(file_inode(seq->file), NULL, *pos);
  }
  
  static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  {
        struct pid *pid;
  
 -      pid = get_children_pid(seq->private, v, *pos + 1);
 +      pid = get_children_pid(file_inode(seq->file), v, *pos + 1);
        put_pid(v);
  
        ++*pos;
@@@ -738,7 -723,17 +745,7 @@@ static const struct seq_operations chil
  
  static int children_seq_open(struct inode *inode, struct file *file)
  {
 -      struct seq_file *m;
 -      int ret;
 -
 -      ret = seq_open(file, &children_seq_ops);
 -      if (ret)
 -              return ret;
 -
 -      m = file->private_data;
 -      m->private = inode;
 -
 -      return ret;
 +      return seq_open(file, &children_seq_ops);
  }
  
  const struct file_operations proc_tid_children_operations = {
diff --combined fs/proc/base.c
index 33ed1746927a82ff4e39f57a65fb822561a9079c,bb192a699bce1a1025501314fe4d9711318ae479..af128b37414308025819ad8038507ad622ac3e94
@@@ -261,7 -261,7 +261,7 @@@ static ssize_t proc_pid_cmdline_read(st
         * Inherently racy -- command line shares address space
         * with code and data.
         */
 -      rv = access_remote_vm(mm, arg_end - 1, &c, 1, 0);
 +      rv = access_remote_vm(mm, arg_end - 1, &c, 1, FOLL_ANON);
        if (rv <= 0)
                goto out_free_page;
  
                        int nr_read;
  
                        _count = min3(count, len, PAGE_SIZE);
 -                      nr_read = access_remote_vm(mm, p, page, _count, 0);
 +                      nr_read = access_remote_vm(mm, p, page, _count, FOLL_ANON);
                        if (nr_read < 0)
                                rv = nr_read;
                        if (nr_read <= 0)
                                bool final;
  
                                _count = min3(count, len, PAGE_SIZE);
 -                              nr_read = access_remote_vm(mm, p, page, _count, 0);
 +                              nr_read = access_remote_vm(mm, p, page, _count, FOLL_ANON);
                                if (nr_read < 0)
                                        rv = nr_read;
                                if (nr_read <= 0)
@@@ -698,7 -698,7 +698,7 @@@ static bool has_pid_permissions(struct 
  
  static int proc_pid_permission(struct inode *inode, int mask)
  {
 -      struct pid_namespace *pid = inode->i_sb->s_fs_info;
 +      struct pid_namespace *pid = proc_pid_ns(inode);
        struct task_struct *task;
        bool has_perms;
  
@@@ -733,11 -733,13 +733,11 @@@ static const struct inode_operations pr
  static int proc_single_show(struct seq_file *m, void *v)
  {
        struct inode *inode = m->private;
 -      struct pid_namespace *ns;
 -      struct pid *pid;
 +      struct pid_namespace *ns = proc_pid_ns(inode);
 +      struct pid *pid = proc_pid(inode);
        struct task_struct *task;
        int ret;
  
 -      ns = inode->i_sb->s_fs_info;
 -      pid = proc_pid(inode);
        task = get_pid_task(pid, PIDTYPE_PID);
        if (!task)
                return -ESRCH;
@@@ -944,7 -946,7 +944,7 @@@ static ssize_t environ_read(struct fil
                max_len = min_t(size_t, PAGE_SIZE, count);
                this_len = min(max_len, this_len);
  
 -              retval = access_remote_vm(mm, (env_start + src), page, this_len, 0);
 +              retval = access_remote_vm(mm, (env_start + src), page, this_len, FOLL_ANON);
  
                if (retval <= 0) {
                        ret = retval;
@@@ -1408,7 -1410,7 +1408,7 @@@ static const struct file_operations pro
  static int sched_show(struct seq_file *m, void *v)
  {
        struct inode *inode = m->private;
 -      struct pid_namespace *ns = inode->i_sb->s_fs_info;
 +      struct pid_namespace *ns = proc_pid_ns(inode);
        struct task_struct *p;
  
        p = get_proc_task(inode);
@@@ -1563,9 -1565,8 +1563,8 @@@ static int comm_show(struct seq_file *m
        if (!p)
                return -ESRCH;
  
-       task_lock(p);
-       seq_printf(m, "%s\n", p->comm);
-       task_unlock(p);
+       proc_task_name(m, p, false);
+       seq_putc(m, '\n');
  
        put_task_struct(p);
  
@@@ -1780,8 -1781,8 +1779,8 @@@ int pid_getattr(const struct path *path
                u32 request_mask, unsigned int query_flags)
  {
        struct inode *inode = d_inode(path->dentry);
 +      struct pid_namespace *pid = proc_pid_ns(inode);
        struct task_struct *task;
 -      struct pid_namespace *pid = path->dentry->d_sb->s_fs_info;
  
        generic_fillattr(inode, stat);
  
  /* dentry stuff */
  
  /*
 - *    Exceptional case: normally we are not allowed to unhash a busy
 - * directory. In this case, however, we can do it - no aliasing problems
 - * due to the way we treat inodes.
 - *
 + * Set <pid>/... inode ownership (can change due to setuid(), etc.)
 + */
 +void pid_update_inode(struct task_struct *task, struct inode *inode)
 +{
 +      task_dump_owner(task, inode->i_mode, &inode->i_uid, &inode->i_gid);
 +
 +      inode->i_mode &= ~(S_ISUID | S_ISGID);
 +      security_task_to_inode(task, inode);
 +}
 +
 +/*
   * Rewrite the inode's ownerships here because the owning task may have
   * performed a setuid(), etc.
   *
   */
 -int pid_revalidate(struct dentry *dentry, unsigned int flags)
 +static int pid_revalidate(struct dentry *dentry, unsigned int flags)
  {
        struct inode *inode;
        struct task_struct *task;
        task = get_proc_task(inode);
  
        if (task) {
 -              task_dump_owner(task, inode->i_mode, &inode->i_uid, &inode->i_gid);
 -
 -              inode->i_mode &= ~(S_ISUID | S_ISGID);
 -              security_task_to_inode(task, inode);
 +              pid_update_inode(task, inode);
                put_task_struct(task);
                return 1;
        }
@@@ -1882,8 -1879,8 +1881,8 @@@ bool proc_fill_cache(struct file *file
        struct dentry *child, *dir = file->f_path.dentry;
        struct qstr qname = QSTR_INIT(name, len);
        struct inode *inode;
 -      unsigned type;
 -      ino_t ino;
 +      unsigned type = DT_UNKNOWN;
 +      ino_t ino = 1;
  
        child = d_hash_and_lookup(dir, &qname);
        if (!child) {
                if (IS_ERR(child))
                        goto end_instantiate;
                if (d_in_lookup(child)) {
 -                      int err = instantiate(d_inode(dir), child, task, ptr);
 +                      struct dentry *res;
 +                      res = instantiate(child, task, ptr);
                        d_lookup_done(child);
 -                      if (err < 0) {
 -                              dput(child);
 +                      if (IS_ERR(res))
                                goto end_instantiate;
 +                      if (unlikely(res)) {
 +                              dput(child);
 +                              child = res;
                        }
                }
        }
        inode = d_inode(child);
        ino = inode->i_ino;
        type = inode->i_mode >> 12;
 +end_instantiate:
        dput(child);
        return dir_emit(ctx, name, len, ino, type);
 -
 -end_instantiate:
 -      return dir_emit(ctx, name, len, 1, DT_UNKNOWN);
  }
  
  /*
@@@ -2070,19 -2066,19 +2069,19 @@@ static const struct inode_operations pr
        .setattr        = proc_setattr,
  };
  
 -static int
 -proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
 +static struct dentry *
 +proc_map_files_instantiate(struct dentry *dentry,
                           struct task_struct *task, const void *ptr)
  {
        fmode_t mode = (fmode_t)(unsigned long)ptr;
        struct proc_inode *ei;
        struct inode *inode;
  
 -      inode = proc_pid_make_inode(dir->i_sb, task, S_IFLNK |
 +      inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK |
                                    ((mode & FMODE_READ ) ? S_IRUSR : 0) |
                                    ((mode & FMODE_WRITE) ? S_IWUSR : 0));
        if (!inode)
 -              return -ENOENT;
 +              return ERR_PTR(-ENOENT);
  
        ei = PROC_I(inode);
        ei->op.proc_get_link = map_files_get_link;
        inode->i_size = 64;
  
        d_set_d_op(dentry, &tid_map_files_dentry_operations);
 -      d_add(dentry, inode);
 -
 -      return 0;
 +      return d_splice_alias(inode, dentry);
  }
  
  static struct dentry *proc_map_files_lookup(struct inode *dir,
        unsigned long vm_start, vm_end;
        struct vm_area_struct *vma;
        struct task_struct *task;
 -      int result;
 +      struct dentry *result;
        struct mm_struct *mm;
  
 -      result = -ENOENT;
 +      result = ERR_PTR(-ENOENT);
        task = get_proc_task(dir);
        if (!task)
                goto out;
  
 -      result = -EACCES;
 +      result = ERR_PTR(-EACCES);
        if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
                goto out_put_task;
  
 -      result = -ENOENT;
 +      result = ERR_PTR(-ENOENT);
        if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
                goto out_put_task;
  
                goto out_no_vma;
  
        if (vma->vm_file)
 -              result = proc_map_files_instantiate(dir, dentry, task,
 +              result = proc_map_files_instantiate(dentry, task,
                                (void *)(unsigned long)vma->vm_file->f_mode);
  
  out_no_vma:
  out_put_task:
        put_task_struct(task);
  out:
 -      return ERR_PTR(result);
 +      return result;
  }
  
  static const struct inode_operations proc_map_files_inode_operations = {
@@@ -2338,7 -2336,7 +2337,7 @@@ static int proc_timers_open(struct inod
                return -ENOMEM;
  
        tp->pid = proc_pid(inode);
 -      tp->ns = inode->i_sb->s_fs_info;
 +      tp->ns = proc_pid_ns(inode);
        return 0;
  }
  
@@@ -2436,16 -2434,16 +2435,16 @@@ static const struct file_operations pro
        .release        = single_release,
  };
  
 -static int proc_pident_instantiate(struct inode *dir,
 -      struct dentry *dentry, struct task_struct *task, const void *ptr)
 +static struct dentry *proc_pident_instantiate(struct dentry *dentry,
 +      struct task_struct *task, const void *ptr)
  {
        const struct pid_entry *p = ptr;
        struct inode *inode;
        struct proc_inode *ei;
  
 -      inode = proc_pid_make_inode(dir->i_sb, task, p->mode);
 +      inode = proc_pid_make_inode(dentry->d_sb, task, p->mode);
        if (!inode)
 -              goto out;
 +              return ERR_PTR(-ENOENT);
  
        ei = PROC_I(inode);
        if (S_ISDIR(inode->i_mode))
        if (p->fop)
                inode->i_fop = p->fop;
        ei->op = p->op;
 +      pid_update_inode(task, inode);
        d_set_d_op(dentry, &pid_dentry_operations);
 -      d_add(dentry, inode);
 -      /* Close the race of the process dying before we return the dentry */
 -      if (pid_revalidate(dentry, 0))
 -              return 0;
 -out:
 -      return -ENOENT;
 +      return d_splice_alias(inode, dentry);
  }
  
  static struct dentry *proc_pident_lookup(struct inode *dir, 
                                         const struct pid_entry *ents,
                                         unsigned int nents)
  {
 -      int error;
        struct task_struct *task = get_proc_task(dir);
        const struct pid_entry *p, *last;
 -
 -      error = -ENOENT;
 +      struct dentry *res = ERR_PTR(-ENOENT);
  
        if (!task)
                goto out_no_task;
        if (p >= last)
                goto out;
  
 -      error = proc_pident_instantiate(dir, dentry, task, p);
 +      res = proc_pident_instantiate(dentry, task, p);
  out:
        put_task_struct(task);
  out_no_task:
 -      return ERR_PTR(error);
 +      return res;
  }
  
  static int proc_pident_readdir(struct file *file, struct dir_context *ctx,
@@@ -3133,32 -3137,38 +3132,32 @@@ void proc_flush_task(struct task_struc
        }
  }
  
 -static int proc_pid_instantiate(struct inode *dir,
 -                                 struct dentry * dentry,
 +static struct dentry *proc_pid_instantiate(struct dentry * dentry,
                                   struct task_struct *task, const void *ptr)
  {
        struct inode *inode;
  
 -      inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);
 +      inode = proc_pid_make_inode(dentry->d_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);
        if (!inode)
 -              goto out;
 +              return ERR_PTR(-ENOENT);
  
        inode->i_op = &proc_tgid_base_inode_operations;
        inode->i_fop = &proc_tgid_base_operations;
        inode->i_flags|=S_IMMUTABLE;
  
        set_nlink(inode, nlink_tgid);
 +      pid_update_inode(task, inode);
  
        d_set_d_op(dentry, &pid_dentry_operations);
 -
 -      d_add(dentry, inode);
 -      /* Close the race of the process dying before we return the dentry */
 -      if (pid_revalidate(dentry, 0))
 -              return 0;
 -out:
 -      return -ENOENT;
 +      return d_splice_alias(inode, dentry);
  }
  
  struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
  {
 -      int result = -ENOENT;
        struct task_struct *task;
        unsigned tgid;
        struct pid_namespace *ns;
 +      struct dentry *result = ERR_PTR(-ENOENT);
  
        tgid = name_to_int(&dentry->d_name);
        if (tgid == ~0U)
        if (!task)
                goto out;
  
 -      result = proc_pid_instantiate(dir, dentry, task, NULL);
 +      result = proc_pid_instantiate(dentry, task, NULL);
        put_task_struct(task);
  out:
 -      return ERR_PTR(result);
 +      return result;
  }
  
  /*
@@@ -3228,7 -3238,7 +3227,7 @@@ retry
  int proc_pid_readdir(struct file *file, struct dir_context *ctx)
  {
        struct tgid_iter iter;
 -      struct pid_namespace *ns = file_inode(file)->i_sb->s_fs_info;
 +      struct pid_namespace *ns = proc_pid_ns(file_inode(file));
        loff_t pos = ctx->pos;
  
        if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
@@@ -3424,32 -3434,37 +3423,32 @@@ static const struct inode_operations pr
        .setattr        = proc_setattr,
  };
  
 -static int proc_task_instantiate(struct inode *dir,
 -      struct dentry *dentry, struct task_struct *task, const void *ptr)
 +static struct dentry *proc_task_instantiate(struct dentry *dentry,
 +      struct task_struct *task, const void *ptr)
  {
        struct inode *inode;
 -      inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);
 -
 +      inode = proc_pid_make_inode(dentry->d_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);
        if (!inode)
 -              goto out;
 +              return ERR_PTR(-ENOENT);
 +
        inode->i_op = &proc_tid_base_inode_operations;
        inode->i_fop = &proc_tid_base_operations;
 -      inode->i_flags|=S_IMMUTABLE;
 +      inode->i_flags |= S_IMMUTABLE;
  
        set_nlink(inode, nlink_tid);
 +      pid_update_inode(task, inode);
  
        d_set_d_op(dentry, &pid_dentry_operations);
 -
 -      d_add(dentry, inode);
 -      /* Close the race of the process dying before we return the dentry */
 -      if (pid_revalidate(dentry, 0))
 -              return 0;
 -out:
 -      return -ENOENT;
 +      return d_splice_alias(inode, dentry);
  }
  
  static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
  {
 -      int result = -ENOENT;
        struct task_struct *task;
        struct task_struct *leader = get_proc_task(dir);
        unsigned tid;
        struct pid_namespace *ns;
 +      struct dentry *result = ERR_PTR(-ENOENT);
  
        if (!leader)
                goto out_no_task;
        if (!same_thread_group(leader, task))
                goto out_drop_task;
  
 -      result = proc_task_instantiate(dir, dentry, task, NULL);
 +      result = proc_task_instantiate(dentry, task, NULL);
  out_drop_task:
        put_task_struct(task);
  out:
        put_task_struct(leader);
  out_no_task:
 -      return ERR_PTR(result);
 +      return result;
  }
  
  /*
@@@ -3572,7 -3587,7 +3571,7 @@@ static int proc_task_readdir(struct fil
        /* f_version caches the tgid value that the last readdir call couldn't
         * return. lseek aka telldir automagically resets f_version to 0.
         */
 -      ns = inode->i_sb->s_fs_info;
 +      ns = proc_pid_ns(inode);
        tid = (int)file->f_version;
        file->f_version = 0;
        for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);
diff --combined fs/proc/internal.h
index 43c70c9e6b6298cdea32ae02611d5025f3bb665e,b823fac621d2f7cbcf3a8d5bf4e130de279810db..93eb1906c28db04a2a78c56090c158e8b0076206
@@@ -44,12 -44,7 +44,12 @@@ struct proc_dir_entry 
        struct completion *pde_unload_completion;
        const struct inode_operations *proc_iops;
        const struct file_operations *proc_fops;
 +      union {
 +              const struct seq_operations *seq_ops;
 +              int (*single_show)(struct seq_file *, void *);
 +      };
        void *data;
 +      unsigned int state_size;
        unsigned int low_ino;
        nlink_t nlink;
        kuid_t uid;
@@@ -62,9 -57,9 +62,9 @@@
        umode_t mode;
        u8 namelen;
  #ifdef CONFIG_64BIT
 -#define SIZEOF_PDE_INLINE_NAME        (192-139)
 +#define SIZEOF_PDE_INLINE_NAME        (192-155)
  #else
 -#define SIZEOF_PDE_INLINE_NAME        (128-87)
 +#define SIZEOF_PDE_INLINE_NAME        (128-95)
  #endif
        char inline_name[SIZEOF_PDE_INLINE_NAME];
  } __randomize_layout;
@@@ -136,6 -131,8 +136,8 @@@ unsigned name_to_int(const struct qstr 
   */
  extern const struct file_operations proc_tid_children_operations;
  
+ extern void proc_task_name(struct seq_file *m, struct task_struct *p,
+                          bool escape);
  extern int proc_tid_stat(struct seq_file *, struct pid_namespace *,
                         struct pid *, struct task_struct *);
  extern int proc_tgid_stat(struct seq_file *, struct pid_namespace *,
@@@ -152,14 -149,14 +154,14 @@@ extern const struct dentry_operations p
  extern int pid_getattr(const struct path *, struct kstat *, u32, unsigned int);
  extern int proc_setattr(struct dentry *, struct iattr *);
  extern struct inode *proc_pid_make_inode(struct super_block *, struct task_struct *, umode_t);
 -extern int pid_revalidate(struct dentry *, unsigned int);
 +extern void pid_update_inode(struct task_struct *, struct inode *);
  extern int pid_delete_dentry(const struct dentry *);
  extern int proc_pid_readdir(struct file *, struct dir_context *);
  extern struct dentry *proc_pid_lookup(struct inode *, struct dentry *, unsigned int);
  extern loff_t mem_lseek(struct file *, loff_t, int);
  
  /* Lookups */
 -typedef int instantiate_t(struct inode *, struct dentry *,
 +typedef struct dentry *instantiate_t(struct dentry *,
                                     struct task_struct *, const void *);
  extern bool proc_fill_cache(struct file *, struct dir_context *, const char *, int,
                           instantiate_t, struct task_struct *, const void *);
  /*
   * generic.c
   */
 +struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode,
 +              struct proc_dir_entry **parent, void *data);
 +struct proc_dir_entry *proc_register(struct proc_dir_entry *dir,
 +              struct proc_dir_entry *dp);
  extern struct dentry *proc_lookup(struct inode *, struct dentry *, unsigned int);
  struct dentry *proc_lookup_de(struct inode *, struct dentry *, struct proc_dir_entry *);
  extern int proc_readdir(struct file *, struct dir_context *);