projects/linux·blob master · refs

437 lines · 12.6 KiB

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 ([email protected])
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
18struct ctl_table_header;
19struct 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 */
31struct 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
77static 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. */
83static 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
90static 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
95static 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
104static inline bool pde_has_proc_lseek(const struct proc_dir_entry *pde)
105{
106 return pde->flags & PROC_ENTRY_proc_lseek;
107}
108
109extern struct kmem_cache *proc_dir_entry_cache;
110void pde_free(struct proc_dir_entry *pde);
111
112union 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
120struct 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 */
135static inline struct proc_inode *PROC_I(const struct inode *inode)
136{
137 return container_of(inode, struct proc_inode, vfs_inode);
138}
139
140static inline struct proc_dir_entry *PDE(const struct inode *inode)
141{
142 return PROC_I(inode)->pde;
143}
144
145static inline struct pid *proc_pid(const struct inode *inode)
146{
147 return PROC_I(inode)->pid;
148}
149
150static inline struct task_struct *get_proc_task(const struct inode *inode)
151{
152 return get_pid_task(proc_pid(inode), PIDTYPE_PID);
153}
154
155void task_dump_owner(struct task_struct *task, umode_t mode,
156 kuid_t *ruid, kgid_t *rgid);
157
158unsigned 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 */
186static 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 */
199static 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 */
221static 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 */
244extern const struct file_operations proc_tid_children_operations;
245
246extern void proc_task_name(struct seq_file *m, struct task_struct *p,
247 bool escape);
248extern int proc_tid_stat(struct seq_file *, struct pid_namespace *,
249 struct pid *, struct task_struct *);
250extern int proc_tgid_stat(struct seq_file *, struct pid_namespace *,
251 struct pid *, struct task_struct *);
252extern int proc_pid_status(struct seq_file *, struct pid_namespace *,
253 struct pid *, struct task_struct *);
254extern int proc_pid_statm(struct seq_file *, struct pid_namespace *,
255 struct pid *, struct task_struct *);
256
257/*
258 * base.c
259 */
260extern const struct dentry_operations pid_dentry_operations;
261extern int pid_getattr(const struct mnt_idmap *, const struct path *,
262 struct kstat *, u32, unsigned int);
263int proc_nochmod_setattr(const struct mnt_idmap *idmap, struct dentry *dentry,
264 struct iattr *attr);
265extern void proc_pid_evict_inode(struct proc_inode *);
266extern struct inode *proc_pid_make_inode(struct super_block *, struct task_struct *, umode_t);
267extern void pid_update_inode(struct task_struct *, struct inode *);
268extern int pid_delete_dentry(const struct dentry *);
269extern int proc_pid_readdir(struct file *, struct dir_context *);
270struct dentry *proc_pid_lookup(struct dentry *, unsigned int);
271extern loff_t mem_lseek(struct file *, loff_t, int);
272
273/* Lookups */
274typedef struct dentry *instantiate_t(struct dentry *,
275 struct task_struct *, const void *);
276bool 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 */
282struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode,
283 struct proc_dir_entry **parent, void *data);
284struct proc_dir_entry *proc_register(struct proc_dir_entry *dir,
285 struct proc_dir_entry *dp);
286extern struct dentry *proc_lookup(struct inode *, struct dentry *, unsigned int);
287struct dentry *proc_lookup_de(struct inode *, struct dentry *, struct proc_dir_entry *);
288extern int proc_readdir(struct file *, struct dir_context *);
289int proc_readdir_de(struct file *, struct dir_context *, struct proc_dir_entry *);
290
291static inline void pde_get(struct proc_dir_entry *pde)
292{
293 refcount_inc(&pde->refcnt);
294}
295extern void pde_put(struct proc_dir_entry *);
296
297static inline bool is_empty_pde(const struct proc_dir_entry *pde)
298{
299 return S_ISDIR(pde->mode) && !pde->proc_iops;
300}
301extern ssize_t proc_simple_write(struct file *, const char __user *, size_t, loff_t *);
302
303/*
304 * inode.c
305 */
306struct pde_opener {
307 struct list_head lh;
308 struct file *file;
309 bool closing;
310 struct completion *c;
311} __randomize_layout;
312extern const struct inode_operations proc_link_inode_operations;
313extern const struct inode_operations proc_pid_link_inode_operations;
314extern const struct super_operations proc_sops;
315
316void proc_init_kmemcache(void);
317void proc_invalidate_siblings_dcache(struct hlist_head *inodes, spinlock_t *lock);
318void set_proc_pid_nlink(void);
319extern struct inode *proc_get_inode(struct super_block *, struct proc_dir_entry *);
320extern void proc_entry_rundown(struct proc_dir_entry *);
321
322/*
323 * proc_namespaces.c
324 */
325extern const struct inode_operations proc_ns_dir_inode_operations;
326extern const struct file_operations proc_ns_dir_operations;
327
328/*
329 * proc_net.c
330 */
331extern const struct file_operations proc_net_operations;
332extern const struct inode_operations proc_net_inode_operations;
333
334#ifdef CONFIG_NET
335extern int proc_net_init(void);
336#else
337static inline int proc_net_init(void) { return 0; }
338#endif
339
340/*
341 * proc_self.c
342 */
343extern int proc_setup_self(struct super_block *);
344
345/*
346 * proc_thread_self.c
347 */
348extern int proc_setup_thread_self(struct super_block *);
349extern void proc_thread_self_init(void);
350
351/*
352 * proc_sysctl.c
353 */
354#ifdef CONFIG_SYSCTL
355extern int proc_sys_init(void);
356extern void proc_sys_evict_inode(struct inode *inode,
357 struct ctl_table_header *head);
358#else
359static inline void proc_sys_init(void) { }
360static 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
368extern void proc_tty_init(void);
369#else
370static inline void proc_tty_init(void) {}
371#endif
372
373/*
374 * root.c
375 */
376extern struct proc_dir_entry proc_root;
377
378extern void proc_self_init(void);
379extern unsigned self_inum, thread_self_inum;
380
381/*
382 * task_[no]mmu.c
383 */
384struct mem_size_stats;
385
386struct 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
394struct 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
405struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode);
406
407extern const struct file_operations proc_pid_maps_operations;
408extern const struct file_operations proc_pid_numa_maps_operations;
409extern const struct file_operations proc_pid_smaps_operations;
410extern const struct file_operations proc_pid_smaps_rollup_operations;
411extern const struct file_operations proc_clear_refs_operations;
412extern const struct file_operations proc_pagemap_operations;
413
414extern unsigned long task_vsize(struct mm_struct *);
415extern unsigned long task_statm(struct mm_struct *,
416 unsigned long *, unsigned long *,
417 unsigned long *, unsigned long *);
418extern void task_mem(struct seq_file *, struct mm_struct *);
419
420extern const struct dentry_operations proc_net_dentry_ops;
421static 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 */
432static 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}