David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 1 | /* Internal procfs definitions |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved. |
| 4 | * Written by David Howells (dhowells@redhat.com) |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * as published by the Free Software Foundation; either version |
| 9 | * 2 of the License, or (at your option) any later version. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/proc_fs.h> |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 13 | #include <linux/proc_ns.h> |
| 14 | #include <linux/spinlock.h> |
| 15 | #include <linux/atomic.h> |
Kees Cook | e579d2c | 2013-02-27 17:03:15 -0800 | [diff] [blame] | 16 | #include <linux/binfmts.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 18 | struct ctl_table_header; |
| 19 | struct mempolicy; |
Eric W. Biederman | 77b14db | 2007-02-14 00:34:12 -0800 | [diff] [blame] | 20 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 21 | /* |
| 22 | * This is not completely implemented yet. The idea is to |
| 23 | * create an in-memory tree (like the actual /proc filesystem |
| 24 | * tree) of these proc_dir_entries, so that we can dynamically |
| 25 | * add new files to /proc. |
| 26 | * |
Nicolas Dichtel | 710585d | 2014-12-10 15:45:01 -0800 | [diff] [blame] | 27 | * parent/subdir are used for the directory structure (every /proc file has a |
| 28 | * parent, but "subdir" is empty for all non-directory entries). |
| 29 | * subdir_node is used to build the rb tree "subdir" of the parent. |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 30 | */ |
| 31 | struct proc_dir_entry { |
| 32 | unsigned int low_ino; |
| 33 | umode_t mode; |
| 34 | nlink_t nlink; |
| 35 | kuid_t uid; |
| 36 | kgid_t gid; |
| 37 | loff_t size; |
| 38 | const struct inode_operations *proc_iops; |
| 39 | const struct file_operations *proc_fops; |
Nicolas Dichtel | 710585d | 2014-12-10 15:45:01 -0800 | [diff] [blame] | 40 | struct proc_dir_entry *parent; |
| 41 | struct rb_root subdir; |
| 42 | struct rb_node subdir_node; |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 43 | void *data; |
| 44 | atomic_t count; /* use count */ |
| 45 | atomic_t in_use; /* number of callers into module in progress; */ |
| 46 | /* negative -> it's going away RSN */ |
| 47 | struct completion *pde_unload_completion; |
| 48 | struct list_head pde_openers; /* who did ->open, but not ->release */ |
| 49 | spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */ |
| 50 | u8 namelen; |
| 51 | char name[]; |
Stephen Wilson | f2beb79 | 2011-05-24 17:12:48 -0700 | [diff] [blame] | 52 | }; |
| 53 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 54 | union proc_op { |
| 55 | int (*proc_get_link)(struct dentry *, struct path *); |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 56 | int (*proc_show)(struct seq_file *m, |
| 57 | struct pid_namespace *ns, struct pid *pid, |
| 58 | struct task_struct *task); |
| 59 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 61 | struct proc_inode { |
Eric W. Biederman | 13b41b0 | 2006-06-26 00:25:56 -0700 | [diff] [blame] | 62 | struct pid *pid; |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 63 | int fd; |
| 64 | union proc_op op; |
| 65 | struct proc_dir_entry *pde; |
| 66 | struct ctl_table_header *sysctl; |
| 67 | struct ctl_table *sysctl_entry; |
Al Viro | 3d3d35b | 2014-11-01 11:10:28 -0400 | [diff] [blame] | 68 | const struct proc_ns_operations *ns_ops; |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 69 | struct inode vfs_inode; |
Eric W. Biederman | 99f8955 | 2006-06-26 00:25:55 -0700 | [diff] [blame] | 70 | }; |
| 71 | |
David Howells | c30480b | 2013-04-12 18:03:36 +0100 | [diff] [blame] | 72 | /* |
| 73 | * General functions |
| 74 | */ |
| 75 | static inline struct proc_inode *PROC_I(const struct inode *inode) |
| 76 | { |
| 77 | return container_of(inode, struct proc_inode, vfs_inode); |
| 78 | } |
| 79 | |
| 80 | static inline struct proc_dir_entry *PDE(const struct inode *inode) |
| 81 | { |
| 82 | return PROC_I(inode)->pde; |
| 83 | } |
| 84 | |
| 85 | static inline void *__PDE_DATA(const struct inode *inode) |
| 86 | { |
| 87 | return PDE(inode)->data; |
| 88 | } |
Adrian Bunk | fee781e | 2006-01-08 01:04:16 -0800 | [diff] [blame] | 89 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | static inline struct pid *proc_pid(struct inode *inode) |
| 91 | { |
Eric W. Biederman | 99f8955 | 2006-06-26 00:25:55 -0700 | [diff] [blame] | 92 | return PROC_I(inode)->pid; |
| 93 | } |
| 94 | |
| 95 | static inline struct task_struct *get_proc_task(struct inode *inode) |
| 96 | { |
Eric W. Biederman | 13b41b0 | 2006-06-26 00:25:56 -0700 | [diff] [blame] | 97 | return get_pid_task(proc_pid(inode), PIDTYPE_PID); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | } |
| 99 | |
Cyrill Gorcunov | faf60af | 2012-08-23 14:43:24 +0400 | [diff] [blame] | 100 | static inline int task_dumpable(struct task_struct *task) |
| 101 | { |
| 102 | int dumpable = 0; |
| 103 | struct mm_struct *mm; |
| 104 | |
| 105 | task_lock(task); |
| 106 | mm = task->mm; |
| 107 | if (mm) |
| 108 | dumpable = get_dumpable(mm); |
| 109 | task_unlock(task); |
Kees Cook | e579d2c | 2013-02-27 17:03:15 -0800 | [diff] [blame] | 110 | if (dumpable == SUID_DUMP_USER) |
Cyrill Gorcunov | faf60af | 2012-08-23 14:43:24 +0400 | [diff] [blame] | 111 | return 1; |
| 112 | return 0; |
| 113 | } |
| 114 | |
Alexey Dobriyan | dbcdb50 | 2014-08-08 14:21:25 -0700 | [diff] [blame] | 115 | static inline unsigned name_to_int(const struct qstr *qstr) |
Cyrill Gorcunov | faf60af | 2012-08-23 14:43:24 +0400 | [diff] [blame] | 116 | { |
Alexey Dobriyan | dbcdb50 | 2014-08-08 14:21:25 -0700 | [diff] [blame] | 117 | const char *name = qstr->name; |
| 118 | int len = qstr->len; |
Cyrill Gorcunov | faf60af | 2012-08-23 14:43:24 +0400 | [diff] [blame] | 119 | unsigned n = 0; |
| 120 | |
| 121 | if (len > 1 && *name == '0') |
| 122 | goto out; |
| 123 | while (len-- > 0) { |
| 124 | unsigned c = *name++ - '0'; |
| 125 | if (c > 9) |
| 126 | goto out; |
| 127 | if (n >= (~0U-9)/10) |
| 128 | goto out; |
| 129 | n *= 10; |
| 130 | n += c; |
| 131 | } |
| 132 | return n; |
| 133 | out: |
| 134 | return ~0U; |
| 135 | } |
| 136 | |
David Howells | 1dd704b | 2013-04-12 01:08:50 +0100 | [diff] [blame] | 137 | /* |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 138 | * Offset of the first process in the /proc root directory.. |
| 139 | */ |
| 140 | #define FIRST_PROCESS_ENTRY 256 |
Alexey Dobriyan | 881adb8 | 2008-07-25 01:48:29 -0700 | [diff] [blame] | 141 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 142 | /* Worst case buffer size needed for holding an integer. */ |
| 143 | #define PROC_NUMBUF 13 |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 144 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 145 | /* |
| 146 | * array.c |
| 147 | */ |
| 148 | extern const struct file_operations proc_tid_children_operations; |
| 149 | |
| 150 | extern int proc_tid_stat(struct seq_file *, struct pid_namespace *, |
| 151 | struct pid *, struct task_struct *); |
| 152 | extern int proc_tgid_stat(struct seq_file *, struct pid_namespace *, |
| 153 | struct pid *, struct task_struct *); |
| 154 | extern int proc_pid_status(struct seq_file *, struct pid_namespace *, |
| 155 | struct pid *, struct task_struct *); |
| 156 | extern int proc_pid_statm(struct seq_file *, struct pid_namespace *, |
| 157 | struct pid *, struct task_struct *); |
| 158 | |
| 159 | /* |
David Howells | 1dd704b | 2013-04-12 01:08:50 +0100 | [diff] [blame] | 160 | * base.c |
| 161 | */ |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 162 | extern const struct dentry_operations pid_dentry_operations; |
| 163 | extern int pid_getattr(struct vfsmount *, struct dentry *, struct kstat *); |
| 164 | extern int proc_setattr(struct dentry *, struct iattr *); |
| 165 | extern struct inode *proc_pid_make_inode(struct super_block *, struct task_struct *); |
| 166 | extern int pid_revalidate(struct dentry *, unsigned int); |
David Howells | 1dd704b | 2013-04-12 01:08:50 +0100 | [diff] [blame] | 167 | extern int pid_delete_dentry(const struct dentry *); |
Al Viro | f0c3b50 | 2013-05-16 12:07:31 -0400 | [diff] [blame] | 168 | extern int proc_pid_readdir(struct file *, struct dir_context *); |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 169 | extern struct dentry *proc_pid_lookup(struct inode *, struct dentry *, unsigned int); |
| 170 | extern loff_t mem_lseek(struct file *, loff_t, int); |
David Howells | 1dd704b | 2013-04-12 01:08:50 +0100 | [diff] [blame] | 171 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 172 | /* Lookups */ |
Al Viro | c52a47a | 2013-06-15 11:15:20 +0400 | [diff] [blame] | 173 | typedef int instantiate_t(struct inode *, struct dentry *, |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 174 | struct task_struct *, const void *); |
Al Viro | f0c3b50 | 2013-05-16 12:07:31 -0400 | [diff] [blame] | 175 | extern bool proc_fill_cache(struct file *, struct dir_context *, const char *, int, |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 176 | instantiate_t, struct task_struct *, const void *); |
Alexey Dobriyan | 881adb8 | 2008-07-25 01:48:29 -0700 | [diff] [blame] | 177 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 178 | /* |
| 179 | * generic.c |
| 180 | */ |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 181 | extern struct dentry *proc_lookup(struct inode *, struct dentry *, unsigned int); |
| 182 | extern struct dentry *proc_lookup_de(struct proc_dir_entry *, struct inode *, |
| 183 | struct dentry *); |
Al Viro | f0c3b50 | 2013-05-16 12:07:31 -0400 | [diff] [blame] | 184 | extern int proc_readdir(struct file *, struct dir_context *); |
| 185 | extern int proc_readdir_de(struct proc_dir_entry *, struct file *, struct dir_context *); |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 186 | |
Alexey Dobriyan | 135d565 | 2009-12-15 16:45:39 -0800 | [diff] [blame] | 187 | static inline struct proc_dir_entry *pde_get(struct proc_dir_entry *pde) |
| 188 | { |
| 189 | atomic_inc(&pde->count); |
| 190 | return pde; |
| 191 | } |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 192 | extern void pde_put(struct proc_dir_entry *); |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 193 | |
Eric W. Biederman | eb6d38d | 2015-05-11 16:44:25 -0500 | [diff] [blame] | 194 | static inline bool is_empty_pde(const struct proc_dir_entry *pde) |
| 195 | { |
| 196 | return S_ISDIR(pde->mode) && !pde->proc_iops; |
| 197 | } |
| 198 | struct proc_dir_entry *proc_create_mount_point(const char *name); |
| 199 | |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 200 | /* |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 201 | * inode.c |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 202 | */ |
Pavel Emelyanov | e9720ac | 2008-03-07 11:08:40 -0800 | [diff] [blame] | 203 | struct pde_opener { |
Alexey Dobriyan | 881adb8 | 2008-07-25 01:48:29 -0700 | [diff] [blame] | 204 | struct file *file; |
Alexey Dobriyan | 881adb8 | 2008-07-25 01:48:29 -0700 | [diff] [blame] | 205 | struct list_head lh; |
Al Viro | 05c0ae2 | 2013-04-04 16:28:47 -0400 | [diff] [blame] | 206 | int closing; |
| 207 | struct completion *c; |
Alexey Dobriyan | 881adb8 | 2008-07-25 01:48:29 -0700 | [diff] [blame] | 208 | }; |
Al Viro | 7e0e953 | 2015-02-21 22:16:11 -0500 | [diff] [blame] | 209 | extern const struct inode_operations proc_link_inode_operations; |
Eric W. Biederman | 6b4e306 | 2010-03-07 16:41:34 -0800 | [diff] [blame] | 210 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 211 | extern const struct inode_operations proc_pid_link_inode_operations; |
Eric W. Biederman | 6b4e306 | 2010-03-07 16:41:34 -0800 | [diff] [blame] | 212 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 213 | extern void proc_init_inodecache(void); |
| 214 | extern struct inode *proc_get_inode(struct super_block *, struct proc_dir_entry *); |
Eric W. Biederman | e94591d | 2016-06-09 15:32:10 -0500 | [diff] [blame] | 215 | extern int proc_fill_super(struct super_block *, void *data, int flags); |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 216 | extern void proc_entry_rundown(struct proc_dir_entry *); |
Eric W. Biederman | 6b4e306 | 2010-03-07 16:41:34 -0800 | [diff] [blame] | 217 | |
Al Viro | 3174c21 | 2009-04-07 13:19:18 -0400 | [diff] [blame] | 218 | /* |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 219 | * proc_namespaces.c |
| 220 | */ |
Eric W. Biederman | 6b4e306 | 2010-03-07 16:41:34 -0800 | [diff] [blame] | 221 | extern const struct inode_operations proc_ns_dir_inode_operations; |
| 222 | extern const struct file_operations proc_ns_dir_operations; |
| 223 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 224 | /* |
| 225 | * proc_net.c |
| 226 | */ |
| 227 | extern const struct file_operations proc_net_operations; |
| 228 | extern const struct inode_operations proc_net_inode_operations; |
| 229 | |
| 230 | #ifdef CONFIG_NET |
| 231 | extern int proc_net_init(void); |
| 232 | #else |
| 233 | static inline int proc_net_init(void) { return 0; } |
| 234 | #endif |
| 235 | |
| 236 | /* |
| 237 | * proc_self.c |
| 238 | */ |
| 239 | extern int proc_setup_self(struct super_block *); |
| 240 | |
| 241 | /* |
Eric W. Biederman | 0097875 | 2014-07-31 03:10:50 -0700 | [diff] [blame] | 242 | * proc_thread_self.c |
| 243 | */ |
| 244 | extern int proc_setup_thread_self(struct super_block *); |
| 245 | extern void proc_thread_self_init(void); |
| 246 | |
| 247 | /* |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 248 | * proc_sysctl.c |
| 249 | */ |
| 250 | #ifdef CONFIG_PROC_SYSCTL |
| 251 | extern int proc_sys_init(void); |
| 252 | extern void sysctl_head_put(struct ctl_table_header *); |
| 253 | #else |
| 254 | static inline void proc_sys_init(void) { } |
| 255 | static inline void sysctl_head_put(struct ctl_table_header *head) { } |
| 256 | #endif |
David Howells | 34db8aa | 2013-04-12 02:29:19 +0100 | [diff] [blame] | 257 | |
| 258 | /* |
| 259 | * proc_tty.c |
| 260 | */ |
| 261 | #ifdef CONFIG_TTY |
| 262 | extern void proc_tty_init(void); |
| 263 | #else |
| 264 | static inline void proc_tty_init(void) {} |
| 265 | #endif |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 266 | |
| 267 | /* |
| 268 | * root.c |
| 269 | */ |
| 270 | extern struct proc_dir_entry proc_root; |
Eric W. Biederman | e94591d | 2016-06-09 15:32:10 -0500 | [diff] [blame] | 271 | extern int proc_parse_options(char *options, struct pid_namespace *pid); |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 272 | |
| 273 | extern void proc_self_init(void); |
| 274 | extern int proc_remount(struct super_block *, int *, char *); |
| 275 | |
| 276 | /* |
| 277 | * task_[no]mmu.c |
| 278 | */ |
| 279 | struct proc_maps_private { |
Oleg Nesterov | 2c03376 | 2014-10-09 15:25:51 -0700 | [diff] [blame] | 280 | struct inode *inode; |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 281 | struct task_struct *task; |
Oleg Nesterov | 29a40ac | 2014-10-09 15:25:26 -0700 | [diff] [blame] | 282 | struct mm_struct *mm; |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 283 | #ifdef CONFIG_MMU |
| 284 | struct vm_area_struct *tail_vma; |
| 285 | #endif |
| 286 | #ifdef CONFIG_NUMA |
| 287 | struct mempolicy *task_mempolicy; |
| 288 | #endif |
| 289 | }; |
| 290 | |
Oleg Nesterov | 5381e16 | 2014-10-09 15:25:24 -0700 | [diff] [blame] | 291 | struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode); |
| 292 | |
David Howells | 59d8053 | 2013-04-11 13:34:43 +0100 | [diff] [blame] | 293 | extern const struct file_operations proc_pid_maps_operations; |
| 294 | extern const struct file_operations proc_tid_maps_operations; |
| 295 | extern const struct file_operations proc_pid_numa_maps_operations; |
| 296 | extern const struct file_operations proc_tid_numa_maps_operations; |
| 297 | extern const struct file_operations proc_pid_smaps_operations; |
| 298 | extern const struct file_operations proc_tid_smaps_operations; |
| 299 | extern const struct file_operations proc_clear_refs_operations; |
| 300 | extern const struct file_operations proc_pagemap_operations; |
| 301 | |
| 302 | extern unsigned long task_vsize(struct mm_struct *); |
| 303 | extern unsigned long task_statm(struct mm_struct *, |
| 304 | unsigned long *, unsigned long *, |
| 305 | unsigned long *, unsigned long *); |
| 306 | extern void task_mem(struct seq_file *, struct mm_struct *); |