1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/proc/inode.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
8 #include <linux/cache.h>
9 #include <linux/time.h>
10 #include <linux/proc_fs.h>
11 #include <linux/kernel.h>
12 #include <linux/pid_namespace.h>
14 #include <linux/string.h>
15 #include <linux/stat.h>
16 #include <linux/completion.h>
17 #include <linux/poll.h>
18 #include <linux/printk.h>
19 #include <linux/file.h>
20 #include <linux/limits.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/sysctl.h>
24 #include <linux/seq_file.h>
25 #include <linux/slab.h>
26 #include <linux/mount.h>
28 #include <linux/uaccess.h>
32 static void proc_evict_inode(struct inode
*inode
)
34 struct proc_dir_entry
*de
;
35 struct ctl_table_header
*head
;
37 truncate_inode_pages_final(&inode
->i_data
);
40 /* Stop tracking associated processes */
41 put_pid(PROC_I(inode
)->pid
);
43 /* Let go of any associated proc directory entry */
48 head
= PROC_I(inode
)->sysctl
;
50 RCU_INIT_POINTER(PROC_I(inode
)->sysctl
, NULL
);
51 proc_sys_evict_inode(inode
, head
);
55 static struct kmem_cache
*proc_inode_cachep __ro_after_init
;
56 static struct kmem_cache
*pde_opener_cache __ro_after_init
;
58 static struct inode
*proc_alloc_inode(struct super_block
*sb
)
60 struct proc_inode
*ei
;
62 ei
= kmem_cache_alloc(proc_inode_cachep
, GFP_KERNEL
);
67 ei
->op
.proc_get_link
= NULL
;
70 ei
->sysctl_entry
= NULL
;
72 return &ei
->vfs_inode
;
75 static void proc_free_inode(struct inode
*inode
)
77 kmem_cache_free(proc_inode_cachep
, PROC_I(inode
));
80 static void init_once(void *foo
)
82 struct proc_inode
*ei
= (struct proc_inode
*) foo
;
84 inode_init_once(&ei
->vfs_inode
);
87 void __init
proc_init_kmemcache(void)
89 proc_inode_cachep
= kmem_cache_create("proc_inode_cache",
90 sizeof(struct proc_inode
),
91 0, (SLAB_RECLAIM_ACCOUNT
|
92 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
|
96 kmem_cache_create("pde_opener", sizeof(struct pde_opener
), 0,
97 SLAB_ACCOUNT
|SLAB_PANIC
, NULL
);
98 proc_dir_entry_cache
= kmem_cache_create_usercopy(
99 "proc_dir_entry", SIZEOF_PDE
, 0, SLAB_PANIC
,
100 offsetof(struct proc_dir_entry
, inline_name
),
101 SIZEOF_PDE_INLINE_NAME
, NULL
);
102 BUILD_BUG_ON(sizeof(struct proc_dir_entry
) >= SIZEOF_PDE
);
105 static int proc_show_options(struct seq_file
*seq
, struct dentry
*root
)
107 struct super_block
*sb
= root
->d_sb
;
108 struct pid_namespace
*pid
= sb
->s_fs_info
;
110 if (!gid_eq(pid
->pid_gid
, GLOBAL_ROOT_GID
))
111 seq_printf(seq
, ",gid=%u", from_kgid_munged(&init_user_ns
, pid
->pid_gid
));
112 if (pid
->hide_pid
!= HIDEPID_OFF
)
113 seq_printf(seq
, ",hidepid=%u", pid
->hide_pid
);
118 const struct super_operations proc_sops
= {
119 .alloc_inode
= proc_alloc_inode
,
120 .free_inode
= proc_free_inode
,
121 .drop_inode
= generic_delete_inode
,
122 .evict_inode
= proc_evict_inode
,
123 .statfs
= simple_statfs
,
124 .show_options
= proc_show_options
,
127 enum {BIAS
= -1U<<31};
129 static inline int use_pde(struct proc_dir_entry
*pde
)
131 return likely(atomic_inc_unless_negative(&pde
->in_use
));
134 static void unuse_pde(struct proc_dir_entry
*pde
)
136 if (unlikely(atomic_dec_return(&pde
->in_use
) == BIAS
))
137 complete(pde
->pde_unload_completion
);
140 /* pde is locked on entry, unlocked on exit */
141 static void close_pdeo(struct proc_dir_entry
*pde
, struct pde_opener
*pdeo
)
144 * close() (proc_reg_release()) can't delete an entry and proceed:
145 * ->release hook needs to be available at the right moment.
147 * rmmod (remove_proc_entry() et al) can't delete an entry and proceed:
148 * "struct file" needs to be available at the right moment.
150 * Therefore, first process to enter this function does ->release() and
151 * signals its completion to the other process which does nothing.
154 /* somebody else is doing that, just wait */
155 DECLARE_COMPLETION_ONSTACK(c
);
157 spin_unlock(&pde
->pde_unload_lock
);
158 wait_for_completion(&c
);
161 struct completion
*c
;
163 pdeo
->closing
= true;
164 spin_unlock(&pde
->pde_unload_lock
);
166 pde
->proc_fops
->release(file_inode(file
), file
);
167 spin_lock(&pde
->pde_unload_lock
);
168 /* After ->release. */
171 spin_unlock(&pde
->pde_unload_lock
);
174 kmem_cache_free(pde_opener_cache
, pdeo
);
178 void proc_entry_rundown(struct proc_dir_entry
*de
)
180 DECLARE_COMPLETION_ONSTACK(c
);
181 /* Wait until all existing callers into module are done. */
182 de
->pde_unload_completion
= &c
;
183 if (atomic_add_return(BIAS
, &de
->in_use
) != BIAS
)
184 wait_for_completion(&c
);
186 /* ->pde_openers list can't grow from now on. */
188 spin_lock(&de
->pde_unload_lock
);
189 while (!list_empty(&de
->pde_openers
)) {
190 struct pde_opener
*pdeo
;
191 pdeo
= list_first_entry(&de
->pde_openers
, struct pde_opener
, lh
);
192 close_pdeo(de
, pdeo
);
193 spin_lock(&de
->pde_unload_lock
);
195 spin_unlock(&de
->pde_unload_lock
);
198 static loff_t
proc_reg_llseek(struct file
*file
, loff_t offset
, int whence
)
200 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
203 loff_t (*llseek
)(struct file
*, loff_t
, int);
204 llseek
= pde
->proc_fops
->llseek
;
206 llseek
= default_llseek
;
207 rv
= llseek(file
, offset
, whence
);
213 static ssize_t
proc_reg_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
215 ssize_t (*read
)(struct file
*, char __user
*, size_t, loff_t
*);
216 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
219 read
= pde
->proc_fops
->read
;
221 rv
= read(file
, buf
, count
, ppos
);
227 static ssize_t
proc_reg_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
229 ssize_t (*write
)(struct file
*, const char __user
*, size_t, loff_t
*);
230 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
233 write
= pde
->proc_fops
->write
;
235 rv
= write(file
, buf
, count
, ppos
);
241 static __poll_t
proc_reg_poll(struct file
*file
, struct poll_table_struct
*pts
)
243 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
244 __poll_t rv
= DEFAULT_POLLMASK
;
245 __poll_t (*poll
)(struct file
*, struct poll_table_struct
*);
247 poll
= pde
->proc_fops
->poll
;
249 rv
= poll(file
, pts
);
255 static long proc_reg_unlocked_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
257 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
259 long (*ioctl
)(struct file
*, unsigned int, unsigned long);
261 ioctl
= pde
->proc_fops
->unlocked_ioctl
;
263 rv
= ioctl(file
, cmd
, arg
);
270 static long proc_reg_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
272 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
274 long (*compat_ioctl
)(struct file
*, unsigned int, unsigned long);
276 compat_ioctl
= pde
->proc_fops
->compat_ioctl
;
278 rv
= compat_ioctl(file
, cmd
, arg
);
285 static int proc_reg_mmap(struct file
*file
, struct vm_area_struct
*vma
)
287 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
289 int (*mmap
)(struct file
*, struct vm_area_struct
*);
291 mmap
= pde
->proc_fops
->mmap
;
293 rv
= mmap(file
, vma
);
300 proc_reg_get_unmapped_area(struct file
*file
, unsigned long orig_addr
,
301 unsigned long len
, unsigned long pgoff
,
304 struct proc_dir_entry
*pde
= PDE(file_inode(file
));
305 unsigned long rv
= -EIO
;
308 typeof(proc_reg_get_unmapped_area
) *get_area
;
310 get_area
= pde
->proc_fops
->get_unmapped_area
;
313 get_area
= current
->mm
->get_unmapped_area
;
317 rv
= get_area(file
, orig_addr
, len
, pgoff
, flags
);
325 static int proc_reg_open(struct inode
*inode
, struct file
*file
)
327 struct proc_dir_entry
*pde
= PDE(inode
);
329 int (*open
)(struct inode
*, struct file
*);
330 int (*release
)(struct inode
*, struct file
*);
331 struct pde_opener
*pdeo
;
335 * 1) PDE's ->release hook will be called no matter what
336 * either normally by close()/->release, or forcefully by
337 * rmmod/remove_proc_entry.
339 * 2) rmmod isn't blocked by opening file in /proc and sitting on
340 * the descriptor (including "rmmod foo </proc/foo" scenario).
342 * Save every "struct file" with custom ->release hook.
347 release
= pde
->proc_fops
->release
;
349 pdeo
= kmem_cache_alloc(pde_opener_cache
, GFP_KERNEL
);
356 open
= pde
->proc_fops
->open
;
358 rv
= open(inode
, file
);
362 /* To know what to release. */
364 pdeo
->closing
= false;
366 spin_lock(&pde
->pde_unload_lock
);
367 list_add(&pdeo
->lh
, &pde
->pde_openers
);
368 spin_unlock(&pde
->pde_unload_lock
);
370 kmem_cache_free(pde_opener_cache
, pdeo
);
378 static int proc_reg_release(struct inode
*inode
, struct file
*file
)
380 struct proc_dir_entry
*pde
= PDE(inode
);
381 struct pde_opener
*pdeo
;
382 spin_lock(&pde
->pde_unload_lock
);
383 list_for_each_entry(pdeo
, &pde
->pde_openers
, lh
) {
384 if (pdeo
->file
== file
) {
385 close_pdeo(pde
, pdeo
);
389 spin_unlock(&pde
->pde_unload_lock
);
393 static const struct file_operations proc_reg_file_ops
= {
394 .llseek
= proc_reg_llseek
,
395 .read
= proc_reg_read
,
396 .write
= proc_reg_write
,
397 .poll
= proc_reg_poll
,
398 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
400 .compat_ioctl
= proc_reg_compat_ioctl
,
402 .mmap
= proc_reg_mmap
,
403 .get_unmapped_area
= proc_reg_get_unmapped_area
,
404 .open
= proc_reg_open
,
405 .release
= proc_reg_release
,
409 static const struct file_operations proc_reg_file_ops_no_compat
= {
410 .llseek
= proc_reg_llseek
,
411 .read
= proc_reg_read
,
412 .write
= proc_reg_write
,
413 .poll
= proc_reg_poll
,
414 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
415 .mmap
= proc_reg_mmap
,
416 .get_unmapped_area
= proc_reg_get_unmapped_area
,
417 .open
= proc_reg_open
,
418 .release
= proc_reg_release
,
422 static void proc_put_link(void *p
)
427 static const char *proc_get_link(struct dentry
*dentry
,
429 struct delayed_call
*done
)
431 struct proc_dir_entry
*pde
= PDE(inode
);
433 return ERR_PTR(-EINVAL
);
434 set_delayed_call(done
, proc_put_link
, pde
);
438 const struct inode_operations proc_link_inode_operations
= {
439 .get_link
= proc_get_link
,
442 struct inode
*proc_get_inode(struct super_block
*sb
, struct proc_dir_entry
*de
)
444 struct inode
*inode
= new_inode_pseudo(sb
);
447 inode
->i_ino
= de
->low_ino
;
448 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= current_time(inode
);
449 PROC_I(inode
)->pde
= de
;
451 if (is_empty_pde(de
)) {
452 make_empty_dir_inode(inode
);
456 inode
->i_mode
= de
->mode
;
457 inode
->i_uid
= de
->uid
;
458 inode
->i_gid
= de
->gid
;
461 inode
->i_size
= de
->size
;
463 set_nlink(inode
, de
->nlink
);
464 WARN_ON(!de
->proc_iops
);
465 inode
->i_op
= de
->proc_iops
;
467 if (S_ISREG(inode
->i_mode
)) {
469 if (!de
->proc_fops
->compat_ioctl
)
471 &proc_reg_file_ops_no_compat
;
474 inode
->i_fop
= &proc_reg_file_ops
;
476 inode
->i_fop
= de
->proc_fops
;