1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* Internal procfs definitions
3 *
4 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/proc_fs.h>
9 #include <linux/proc_ns.h>
10 #include <linux/refcount.h>
11 #include <linux/spinlock.h>
12 #include <linux/atomic.h>
13 #include <linux/binfmts.h>
14 #include <linux/sched/coredump.h>
15 #include <linux/sched/task.h>
16 #include <linux/mm.h>
17
18 struct ctl_table_header;
19 struct mempolicy;
20
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 *
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.
30 */
31 struct proc_dir_entry {
32 /*
33 * number of callers into module in progress;
34 * negative -> it's going away RSN
35 */
36 atomic_t in_use;
37 refcount_t refcnt;
38 struct list_head pde_openers; /* who did ->open, but not ->release */
39 /* protects ->pde_openers and all struct pde_opener instances */
40 spinlock_t pde_unload_lock;
41 struct completion *pde_unload_completion;
42 const struct inode_operations *proc_iops;
43 union {
44 const struct proc_ops *proc_ops;
45 const struct file_operations *proc_dir_ops;
46 };
47 union {
48 const struct seq_operations *seq_ops;
49 int (*single_show)(struct seq_file *, void *);
50 };
51 proc_write_t write;
52 void *data;
53 unsigned int state_size;
54 unsigned int low_ino;
55 nlink_t nlink;
56 kuid_t uid;
57 kgid_t gid;
58 loff_t size;
59 struct proc_dir_entry *parent;
60 struct rb_root subdir;
61 struct rb_node subdir_node;
62 char *name;
63 umode_t mode;
64 u8 flags;
65 u8 namelen;
66 char inline_name[];
67 } __randomize_layout;
68
69 #define SIZEOF_PDE ( \
70 sizeof(struct proc_dir_entry) < 128 ? 128 : \
71 sizeof(struct proc_dir_entry) < 192 ? 192 : \
72 sizeof(struct proc_dir_entry) < 256 ? 256 : \
73 sizeof(struct proc_dir_entry) < 512 ? 512 : \
74 0)
75 #define SIZEOF_PDE_INLINE_NAME (SIZEOF_PDE - sizeof(struct proc_dir_entry))
76
pde_is_permanent(const struct proc_dir_entry * pde)77 static inline bool pde_is_permanent(const struct proc_dir_entry *pde)
78 {
79 return pde->flags & PROC_ENTRY_PERMANENT;
80 }
81
82 /* This is for builtin code, not even for modules which are compiled in. */
pde_make_permanent(struct proc_dir_entry * pde)83 static inline void pde_make_permanent(struct proc_dir_entry *pde)
84 {
85 /* Ensure magic flag does something. */
86 static_assert(PROC_ENTRY_PERMANENT != 0);
87 pde->flags |= PROC_ENTRY_PERMANENT;
88 }
89
pde_has_proc_read_iter(const struct proc_dir_entry * pde)90 static inline bool pde_has_proc_read_iter(const struct proc_dir_entry *pde)
91 {
92 return pde->flags & PROC_ENTRY_proc_read_iter;
93 }
94
pde_has_proc_compat_ioctl(const struct proc_dir_entry * pde)95 static inline bool pde_has_proc_compat_ioctl(const struct proc_dir_entry *pde)
96 {
97 #ifdef CONFIG_COMPAT
98 return pde->flags & PROC_ENTRY_proc_compat_ioctl;
99 #else
100 return false;
101 #endif
102 }
103
pde_has_proc_lseek(const struct proc_dir_entry * pde)104 static inline bool pde_has_proc_lseek(const struct proc_dir_entry *pde)
105 {
106 return pde->flags & PROC_ENTRY_proc_lseek;
107 }
108
109 extern struct kmem_cache *proc_dir_entry_cache;
110 void pde_free(struct proc_dir_entry *pde);
111
112 union proc_op {
113 int (*proc_get_link)(struct dentry *, struct path *, struct task_struct *);
114 int (*proc_show)(struct seq_file *m,
115 struct pid_namespace *ns, struct pid *pid,
116 struct task_struct *task);
117 int lsmid;
118 };
119
120 struct proc_inode {
121 struct pid *pid;
122 unsigned int fd;
123 union proc_op op;
124 struct proc_dir_entry *pde;
125 struct ctl_table_header *sysctl;
126 const struct ctl_table *sysctl_entry;
127 struct hlist_node sibling_inodes;
128 const struct proc_ns_operations *ns_ops;
129 struct inode vfs_inode;
130 } __randomize_layout;
131
132 /*
133 * General functions
134 */
PROC_I(const struct inode * inode)135 static inline struct proc_inode *PROC_I(const struct inode *inode)
136 {
137 return container_of(inode, struct proc_inode, vfs_inode);
138 }
139
PDE(const struct inode * inode)140 static inline struct proc_dir_entry *PDE(const struct inode *inode)
141 {
142 return PROC_I(inode)->pde;
143 }
144
proc_pid(const struct inode * inode)145 static inline struct pid *proc_pid(const struct inode *inode)
146 {
147 return PROC_I(inode)->pid;
148 }
149
get_proc_task(const struct inode * inode)150 static inline struct task_struct *get_proc_task(const struct inode *inode)
151 {
152 return get_pid_task(proc_pid(inode), PIDTYPE_PID);
153 }
154
155 void task_dump_owner(struct task_struct *task, umode_t mode,
156 kuid_t *ruid, kgid_t *rgid);
157
158 unsigned name_to_int(const struct qstr *qstr);
159 /*
160 * Offset of the first process in the /proc root directory..
161 */
162 #define FIRST_PROCESS_ENTRY 256
163
164 /* Worst case buffer size needed for holding an integer. */
165 #define PROC_NUMBUF 13
166
167 #ifdef CONFIG_PAGE_MAPCOUNT
168 /**
169 * folio_precise_page_mapcount() - Number of mappings of this folio page.
170 * @folio: The folio.
171 * @page: The page.
172 *
173 * The number of present user page table entries that reference this page
174 * as tracked via the RMAP: either referenced directly (PTE) or as part of
175 * a larger area that covers this page (e.g., PMD).
176 *
177 * Use this function only for the calculation of existing statistics
178 * (USS, PSS, mapcount_max) and for debugging purposes (/proc/kpagecount).
179 *
180 * Do not add new users.
181 *
182 * Returns: The number of mappings of this folio page. 0 for
183 * folios that are not mapped to user space or are not tracked via the RMAP
184 * (e.g., shared zeropage).
185 */
folio_precise_page_mapcount(struct folio * folio,struct page * page)186 static inline int folio_precise_page_mapcount(struct folio *folio,
187 struct page *page)
188 {
189 int mapcount = atomic_read(&page->_mapcount) + 1;
190
191 if (page_mapcount_is_type(mapcount))
192 mapcount = 0;
193 if (folio_test_large(folio))
194 mapcount += folio_entire_mapcount(folio);
195
196 return mapcount;
197 }
198 #else /* !CONFIG_PAGE_MAPCOUNT */
folio_precise_page_mapcount(struct folio * folio,struct page * page)199 static inline int folio_precise_page_mapcount(struct folio *folio,
200 struct page *page)
201 {
202 BUILD_BUG();
203 }
204 #endif /* CONFIG_PAGE_MAPCOUNT */
205
206 /**
207 * folio_average_page_mapcount() - Average number of mappings per page in this
208 * folio
209 * @folio: The folio.
210 *
211 * The average number of user page table entries that reference each page in
212 * this folio as tracked via the RMAP: either referenced directly (PTE) or
213 * as part of a larger area that covers this page (e.g., PMD).
214 *
215 * The average is calculated by rounding to the nearest integer; however,
216 * to avoid duplicated code in current callers, the average is at least
217 * 1 if any page of the folio is mapped.
218 *
219 * Returns: The average number of mappings per page in this folio.
220 */
folio_average_page_mapcount(struct folio * folio)221 static inline int folio_average_page_mapcount(struct folio *folio)
222 {
223 int mapcount, entire_mapcount, avg;
224
225 if (!folio_test_large(folio))
226 return atomic_read(&folio->_mapcount) + 1;
227
228 mapcount = folio_large_mapcount(folio);
229 if (unlikely(mapcount <= 0))
230 return 0;
231 entire_mapcount = folio_entire_mapcount(folio);
232 if (mapcount <= entire_mapcount)
233 return entire_mapcount;
234 mapcount -= entire_mapcount;
235
236 /* Round to closest integer ... */
237 avg = ((unsigned int)mapcount + folio_large_nr_pages(folio) / 2) >> folio_large_order(folio);
238 /* ... but return at least 1. */
239 return max_t(int, avg + entire_mapcount, 1);
240 }
241 /*
242 * array.c
243 */
244 extern const struct file_operations proc_tid_children_operations;
245
246 extern void proc_task_name(struct seq_file *m, struct task_struct *p,
247 bool escape);
248 extern int proc_tid_stat(struct seq_file *, struct pid_namespace *,
249 struct pid *, struct task_struct *);
250 extern int proc_tgid_stat(struct seq_file *, struct pid_namespace *,
251 struct pid *, struct task_struct *);
252 extern int proc_pid_status(struct seq_file *, struct pid_namespace *,
253 struct pid *, struct task_struct *);
254 extern int proc_pid_statm(struct seq_file *, struct pid_namespace *,
255 struct pid *, struct task_struct *);
256
257 /*
258 * base.c
259 */
260 extern const struct dentry_operations pid_dentry_operations;
261 extern int pid_getattr(struct mnt_idmap *, const struct path *,
262 struct kstat *, u32, unsigned int);
263 int proc_nochmod_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
264 struct iattr *attr);
265 extern void proc_pid_evict_inode(struct proc_inode *);
266 extern struct inode *proc_pid_make_inode(struct super_block *, struct task_struct *, umode_t);
267 extern void pid_update_inode(struct task_struct *, struct inode *);
268 extern int pid_delete_dentry(const struct dentry *);
269 extern int proc_pid_readdir(struct file *, struct dir_context *);
270 struct dentry *proc_pid_lookup(struct dentry *, unsigned int);
271 extern loff_t mem_lseek(struct file *, loff_t, int);
272
273 /* Lookups */
274 typedef struct dentry *instantiate_t(struct dentry *,
275 struct task_struct *, const void *);
276 bool proc_fill_cache(struct file *, struct dir_context *, const char *, unsigned int,
277 instantiate_t, struct task_struct *, const void *);
278
279 /*
280 * generic.c
281 */
282 struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode,
283 struct proc_dir_entry **parent, void *data);
284 struct proc_dir_entry *proc_register(struct proc_dir_entry *dir,
285 struct proc_dir_entry *dp);
286 extern struct dentry *proc_lookup(struct inode *, struct dentry *, unsigned int);
287 struct dentry *proc_lookup_de(struct inode *, struct dentry *, struct proc_dir_entry *);
288 extern int proc_readdir(struct file *, struct dir_context *);
289 int proc_readdir_de(struct file *, struct dir_context *, struct proc_dir_entry *);
290
pde_get(struct proc_dir_entry * pde)291 static inline void pde_get(struct proc_dir_entry *pde)
292 {
293 refcount_inc(&pde->refcnt);
294 }
295 extern void pde_put(struct proc_dir_entry *);
296
is_empty_pde(const struct proc_dir_entry * pde)297 static inline bool is_empty_pde(const struct proc_dir_entry *pde)
298 {
299 return S_ISDIR(pde->mode) && !pde->proc_iops;
300 }
301 extern ssize_t proc_simple_write(struct file *, const char __user *, size_t, loff_t *);
302
303 /*
304 * inode.c
305 */
306 struct pde_opener {
307 struct list_head lh;
308 struct file *file;
309 bool closing;
310 struct completion *c;
311 } __randomize_layout;
312 extern const struct inode_operations proc_link_inode_operations;
313 extern const struct inode_operations proc_pid_link_inode_operations;
314 extern const struct super_operations proc_sops;
315
316 void proc_init_kmemcache(void);
317 void proc_invalidate_siblings_dcache(struct hlist_head *inodes, spinlock_t *lock);
318 void set_proc_pid_nlink(void);
319 extern struct inode *proc_get_inode(struct super_block *, struct proc_dir_entry *);
320 extern void proc_entry_rundown(struct proc_dir_entry *);
321
322 /*
323 * proc_namespaces.c
324 */
325 extern const struct inode_operations proc_ns_dir_inode_operations;
326 extern const struct file_operations proc_ns_dir_operations;
327
328 /*
329 * proc_net.c
330 */
331 extern const struct file_operations proc_net_operations;
332 extern const struct inode_operations proc_net_inode_operations;
333
334 #ifdef CONFIG_NET
335 extern int proc_net_init(void);
336 #else
proc_net_init(void)337 static inline int proc_net_init(void) { return 0; }
338 #endif
339
340 /*
341 * proc_self.c
342 */
343 extern int proc_setup_self(struct super_block *);
344
345 /*
346 * proc_thread_self.c
347 */
348 extern int proc_setup_thread_self(struct super_block *);
349 extern void proc_thread_self_init(void);
350
351 /*
352 * proc_sysctl.c
353 */
354 #ifdef CONFIG_SYSCTL
355 extern int proc_sys_init(void);
356 extern void proc_sys_evict_inode(struct inode *inode,
357 struct ctl_table_header *head);
358 #else
proc_sys_init(void)359 static inline void proc_sys_init(void) { }
proc_sys_evict_inode(struct inode * inode,struct ctl_table_header * head)360 static inline void proc_sys_evict_inode(struct inode *inode,
361 struct ctl_table_header *head) { }
362 #endif
363
364 /*
365 * proc_tty.c
366 */
367 #ifdef CONFIG_TTY
368 extern void proc_tty_init(void);
369 #else
proc_tty_init(void)370 static inline void proc_tty_init(void) {}
371 #endif
372
373 /*
374 * root.c
375 */
376 extern struct proc_dir_entry proc_root;
377
378 extern void proc_self_init(void);
379 extern unsigned self_inum, thread_self_inum;
380
381 /*
382 * task_[no]mmu.c
383 */
384 struct mem_size_stats;
385
386 struct proc_maps_locking_ctx {
387 struct mm_struct *mm;
388 #ifdef CONFIG_PER_VMA_LOCK
389 bool mmap_locked;
390 struct vm_area_struct *locked_vma;
391 #endif
392 };
393
394 struct proc_maps_private {
395 struct inode *inode;
396 struct task_struct *task;
397 struct vma_iterator iter;
398 loff_t last_pos;
399 struct proc_maps_locking_ctx lock_ctx;
400 #ifdef CONFIG_NUMA
401 struct mempolicy *task_mempolicy;
402 #endif
403 } __randomize_layout;
404
405 struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode);
406
407 extern const struct file_operations proc_pid_maps_operations;
408 extern const struct file_operations proc_pid_numa_maps_operations;
409 extern const struct file_operations proc_pid_smaps_operations;
410 extern const struct file_operations proc_pid_smaps_rollup_operations;
411 extern const struct file_operations proc_clear_refs_operations;
412 extern const struct file_operations proc_pagemap_operations;
413
414 extern unsigned long task_vsize(struct mm_struct *);
415 extern unsigned long task_statm(struct mm_struct *,
416 unsigned long *, unsigned long *,
417 unsigned long *, unsigned long *);
418 extern void task_mem(struct seq_file *, struct mm_struct *);
419
420 extern const struct dentry_operations proc_net_dentry_ops;
pde_force_lookup(struct proc_dir_entry * pde)421 static inline void pde_force_lookup(struct proc_dir_entry *pde)
422 {
423 /* /proc/net/ entries can be changed under us by setns(CLONE_NEWNET) */
424 pde->flags |= PROC_ENTRY_FORCE_LOOKUP;
425 }
426
427 /*
428 * Add a new procfs dentry that can't serve as a mountpoint. That should
429 * encompass anything that is ephemeral and can just disappear while the
430 * process is still around.
431 */
proc_splice_unmountable(struct inode * inode,struct dentry * dentry,const struct dentry_operations * d_ops)432 static inline struct dentry *proc_splice_unmountable(struct inode *inode,
433 struct dentry *dentry, const struct dentry_operations *d_ops)
434 {
435 dont_mount(dentry);
436 return d_splice_alias_ops(inode, dentry, d_ops);
437 }
438