blob: 85ffbd27f2883a8e6fb3dfe8275c2e1a36ac3ffe [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/fs/proc/inode.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 */
7
Alexey Dobriyanefb1a572018-02-06 15:37:24 -08008#include <linux/cache.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/time.h>
10#include <linux/proc_fs.h>
11#include <linux/kernel.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080012#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/mm.h>
14#include <linux/string.h>
15#include <linux/stat.h>
Alexey Dobriyan786d7e12007-07-15 23:39:00 -070016#include <linux/completion.h>
Alexey Dobriyandd23aae2007-09-11 15:23:55 -070017#include <linux/poll.h>
Andrew Morton87ebdc02013-02-27 17:03:16 -080018#include <linux/printk.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/file.h>
20#include <linux/limits.h>
21#include <linux/init.h>
22#include <linux/module.h>
Al Viro9043476f2008-07-15 08:54:06 -040023#include <linux/sysctl.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080024#include <linux/seq_file.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080026#include <linux/mount.h>
David Howells303eb7e2013-04-11 23:55:54 +010027#include <linux/magic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080029#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Adrian Bunkfee781e2006-01-08 01:04:16 -080031#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Al Viro82679522010-06-04 22:17:56 -040033static void proc_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034{
35 struct proc_dir_entry *de;
Al Virodfef6dcd32011-03-08 01:25:28 -050036 struct ctl_table_header *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Johannes Weiner91b0abe2014-04-03 14:47:49 -070038 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +020039 clear_inode(inode);
Mark Fashehfef26652005-09-09 13:01:31 -070040
Eric W. Biederman99f89552006-06-26 00:25:55 -070041 /* Stop tracking associated processes */
Eric W. Biederman13b41b02006-06-26 00:25:56 -070042 put_pid(PROC_I(inode)->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44 /* Let go of any associated proc directory entry */
Alexander Kuleshov6bee55f2015-02-12 15:01:03 -080045 de = PDE(inode);
Alexey Dobriyan99b76232009-03-25 22:48:06 +030046 if (de)
Alexey Dobriyan135d5652009-12-15 16:45:39 -080047 pde_put(de);
Konstantin Khlebnikovd6cffbb2017-02-10 10:35:02 +030048
Al Virodfef6dcd32011-03-08 01:25:28 -050049 head = PROC_I(inode)->sysctl;
50 if (head) {
Monam Agarwal1c44dbc2014-04-07 15:38:35 -070051 RCU_INIT_POINTER(PROC_I(inode)->sysctl, NULL);
Konstantin Khlebnikovd6cffbb2017-02-10 10:35:02 +030052 proc_sys_evict_inode(inode, head);
Al Virodfef6dcd32011-03-08 01:25:28 -050053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070054}
55
Alexey Dobriyanefb1a572018-02-06 15:37:24 -080056static struct kmem_cache *proc_inode_cachep __ro_after_init;
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -070057static struct kmem_cache *pde_opener_cache __ro_after_init;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59static struct inode *proc_alloc_inode(struct super_block *sb)
60{
61 struct proc_inode *ei;
62 struct inode *inode;
63
Tobin C. Hardingf245e1c172017-05-08 15:54:55 -070064 ei = kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 if (!ei)
66 return NULL;
Eric W. Biederman13b41b02006-06-26 00:25:56 -070067 ei->pid = NULL;
Eric W. Biedermanaed7a6c2006-06-26 00:25:44 -070068 ei->fd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 ei->op.proc_get_link = NULL;
70 ei->pde = NULL;
Al Viro9043476f2008-07-15 08:54:06 -040071 ei->sysctl = NULL;
72 ei->sysctl_entry = NULL;
Al Viro3d3d35b2014-11-01 11:10:28 -040073 ei->ns_ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 inode = &ei->vfs_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 return inode;
76}
77
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110078static void proc_i_callback(struct rcu_head *head)
79{
80 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110081 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
82}
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static void proc_destroy_inode(struct inode *inode)
85{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110086 call_rcu(&inode->i_rcu, proc_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087}
88
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070089static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
91 struct proc_inode *ei = (struct proc_inode *) foo;
92
Christoph Lametera35afb82007-05-16 22:10:57 -070093 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
Paul Mundt20c2df82007-07-20 10:11:58 +090095
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -070096void __init proc_init_kmemcache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
98 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
99 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800100 0, (SLAB_RECLAIM_ACCOUNT|
Vladimir Davydov5d097052016-01-14 15:18:21 -0800101 SLAB_MEM_SPREAD|SLAB_ACCOUNT|
102 SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900103 init_once);
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -0700104 pde_opener_cache =
105 kmem_cache_create("pde_opener", sizeof(struct pde_opener), 0,
Alexey Dobriyan2acddbe2018-04-10 16:31:12 -0700106 SLAB_ACCOUNT|SLAB_PANIC, NULL);
Alexey Dobriyanb4884f22018-04-10 16:31:52 -0700107 proc_dir_entry_cache = kmem_cache_create_usercopy(
David Howells24074a32018-06-13 19:43:19 +0100108 "proc_dir_entry", SIZEOF_PDE_SLOT, 0, SLAB_PANIC,
109 OFFSETOF_PDE_NAME, SIZEOF_PDE_INLINE_NAME, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800112static int proc_show_options(struct seq_file *seq, struct dentry *root)
113{
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800114 struct super_block *sb = root->d_sb;
115 struct pid_namespace *pid = sb->s_fs_info;
116
Eric W. Biedermandcb0f222012-02-09 08:48:21 -0800117 if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
118 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
Lafcadio Wluiki796f5712017-02-24 15:00:23 -0800119 if (pid->hide_pid != HIDEPID_OFF)
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800120 seq_printf(seq, ",hidepid=%u", pid->hide_pid);
121
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800122 return 0;
123}
124
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800125static const struct super_operations proc_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 .alloc_inode = proc_alloc_inode,
127 .destroy_inode = proc_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 .drop_inode = generic_delete_inode,
Al Viro82679522010-06-04 22:17:56 -0400129 .evict_inode = proc_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 .statfs = simple_statfs,
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800131 .remount_fs = proc_remount,
132 .show_options = proc_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133};
134
Al Viro866ad9a72013-04-03 19:07:30 -0400135enum {BIAS = -1U<<31};
136
137static inline int use_pde(struct proc_dir_entry *pde)
138{
Alexey Dobriyan15b158b2018-02-06 15:37:28 -0800139 return likely(atomic_inc_unless_negative(&pde->in_use));
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700140}
141
Al Viro866ad9a72013-04-03 19:07:30 -0400142static void unuse_pde(struct proc_dir_entry *pde)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700143{
Alexey Dobriyan15b158b2018-02-06 15:37:28 -0800144 if (unlikely(atomic_dec_return(&pde->in_use) == BIAS))
Al Viro05c0ae22013-04-04 16:28:47 -0400145 complete(pde->pde_unload_completion);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700146}
147
Alexey Dobriyan2f897422018-04-10 16:30:54 -0700148/* pde is locked on entry, unlocked on exit */
Al Viroca469f32013-04-03 19:57:00 -0400149static void close_pdeo(struct proc_dir_entry *pde, struct pde_opener *pdeo)
150{
Alexey Dobriyan492b2da2016-12-12 16:45:22 -0800151 /*
152 * close() (proc_reg_release()) can't delete an entry and proceed:
153 * ->release hook needs to be available at the right moment.
154 *
155 * rmmod (remove_proc_entry() et al) can't delete an entry and proceed:
156 * "struct file" needs to be available at the right moment.
157 *
158 * Therefore, first process to enter this function does ->release() and
159 * signals its completion to the other process which does nothing.
160 */
Al Viro05c0ae22013-04-04 16:28:47 -0400161 if (pdeo->closing) {
Al Viroca469f32013-04-03 19:57:00 -0400162 /* somebody else is doing that, just wait */
Al Viro05c0ae22013-04-04 16:28:47 -0400163 DECLARE_COMPLETION_ONSTACK(c);
164 pdeo->c = &c;
Al Viroca469f32013-04-03 19:57:00 -0400165 spin_unlock(&pde->pde_unload_lock);
Al Viro05c0ae22013-04-04 16:28:47 -0400166 wait_for_completion(&c);
Al Viroca469f32013-04-03 19:57:00 -0400167 } else {
168 struct file *file;
Alexey Dobriyan2f897422018-04-10 16:30:54 -0700169 struct completion *c;
170
Alexey Dobriyanf5887c712016-12-12 16:45:17 -0800171 pdeo->closing = true;
Al Viroca469f32013-04-03 19:57:00 -0400172 spin_unlock(&pde->pde_unload_lock);
173 file = pdeo->file;
174 pde->proc_fops->release(file_inode(file), file);
175 spin_lock(&pde->pde_unload_lock);
Alexey Dobriyan492b2da2016-12-12 16:45:22 -0800176 /* After ->release. */
Alexey Dobriyan06a0c412016-12-12 16:45:14 -0800177 list_del(&pdeo->lh);
Alexey Dobriyan2f897422018-04-10 16:30:54 -0700178 c = pdeo->c;
179 spin_unlock(&pde->pde_unload_lock);
180 if (unlikely(c))
181 complete(c);
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -0700182 kmem_cache_free(pde_opener_cache, pdeo);
Al Viro05c0ae22013-04-04 16:28:47 -0400183 }
Al Viroca469f32013-04-03 19:57:00 -0400184}
185
Al Viro866ad9a72013-04-03 19:07:30 -0400186void proc_entry_rundown(struct proc_dir_entry *de)
187{
Al Viro05c0ae22013-04-04 16:28:47 -0400188 DECLARE_COMPLETION_ONSTACK(c);
Al Viro866ad9a72013-04-03 19:07:30 -0400189 /* Wait until all existing callers into module are done. */
Al Viro05c0ae22013-04-04 16:28:47 -0400190 de->pde_unload_completion = &c;
191 if (atomic_add_return(BIAS, &de->in_use) != BIAS)
192 wait_for_completion(&c);
Al Viro866ad9a72013-04-03 19:07:30 -0400193
Alexey Dobriyan492b2da2016-12-12 16:45:22 -0800194 /* ->pde_openers list can't grow from now on. */
195
Al Viro05c0ae22013-04-04 16:28:47 -0400196 spin_lock(&de->pde_unload_lock);
Al Viro866ad9a72013-04-03 19:07:30 -0400197 while (!list_empty(&de->pde_openers)) {
198 struct pde_opener *pdeo;
Al Viro866ad9a72013-04-03 19:07:30 -0400199 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh);
Al Viroca469f32013-04-03 19:57:00 -0400200 close_pdeo(de, pdeo);
Alexey Dobriyan2f897422018-04-10 16:30:54 -0700201 spin_lock(&de->pde_unload_lock);
Al Viro866ad9a72013-04-03 19:07:30 -0400202 }
203 spin_unlock(&de->pde_unload_lock);
204}
205
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700206static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
207{
Al Viro496ad9a2013-01-23 17:07:38 -0500208 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700209 loff_t rv = -EINVAL;
Al Viro866ad9a72013-04-03 19:07:30 -0400210 if (use_pde(pde)) {
211 loff_t (*llseek)(struct file *, loff_t, int);
212 llseek = pde->proc_fops->llseek;
213 if (!llseek)
214 llseek = default_llseek;
215 rv = llseek(file, offset, whence);
216 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700217 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700218 return rv;
219}
220
221static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
222{
Al Viro866ad9a72013-04-03 19:07:30 -0400223 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500224 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700225 ssize_t rv = -EIO;
Al Viro866ad9a72013-04-03 19:07:30 -0400226 if (use_pde(pde)) {
227 read = pde->proc_fops->read;
228 if (read)
229 rv = read(file, buf, count, ppos);
230 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700231 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700232 return rv;
233}
234
235static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
236{
Al Viro866ad9a72013-04-03 19:07:30 -0400237 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500238 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700239 ssize_t rv = -EIO;
Al Viro866ad9a72013-04-03 19:07:30 -0400240 if (use_pde(pde)) {
241 write = pde->proc_fops->write;
242 if (write)
243 rv = write(file, buf, count, ppos);
244 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700245 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700246 return rv;
247}
248
Al Viro076ccb72017-07-03 01:02:18 -0400249static __poll_t proc_reg_poll(struct file *file, struct poll_table_struct *pts)
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700250{
Al Viro496ad9a2013-01-23 17:07:38 -0500251 struct proc_dir_entry *pde = PDE(file_inode(file));
Al Viroe6c8adc2017-07-03 22:25:56 -0400252 __poll_t rv = DEFAULT_POLLMASK;
Al Viroa3f86832017-07-02 22:22:01 -0400253 __poll_t (*poll)(struct file *, struct poll_table_struct *);
Al Viro866ad9a72013-04-03 19:07:30 -0400254 if (use_pde(pde)) {
255 poll = pde->proc_fops->poll;
256 if (poll)
257 rv = poll(file, pts);
258 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700259 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700260 return rv;
261}
262
263static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
264{
Al Viro496ad9a2013-01-23 17:07:38 -0500265 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700266 long rv = -ENOTTY;
Arnd Bergmannb19dd422010-07-04 00:15:10 +0200267 long (*ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a72013-04-03 19:07:30 -0400268 if (use_pde(pde)) {
269 ioctl = pde->proc_fops->unlocked_ioctl;
270 if (ioctl)
271 rv = ioctl(file, cmd, arg);
272 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700273 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700274 return rv;
275}
276
277#ifdef CONFIG_COMPAT
278static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
279{
Al Viro496ad9a2013-01-23 17:07:38 -0500280 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700281 long rv = -ENOTTY;
282 long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a72013-04-03 19:07:30 -0400283 if (use_pde(pde)) {
284 compat_ioctl = pde->proc_fops->compat_ioctl;
285 if (compat_ioctl)
286 rv = compat_ioctl(file, cmd, arg);
287 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700288 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700289 return rv;
290}
291#endif
292
293static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
294{
Al Viro496ad9a2013-01-23 17:07:38 -0500295 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700296 int rv = -EIO;
297 int (*mmap)(struct file *, struct vm_area_struct *);
Al Viro866ad9a72013-04-03 19:07:30 -0400298 if (use_pde(pde)) {
299 mmap = pde->proc_fops->mmap;
300 if (mmap)
301 rv = mmap(file, vma);
302 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700303 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700304 return rv;
305}
306
HATAYAMA Daisuke5721cf82013-11-12 15:11:15 -0800307static unsigned long
308proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr,
309 unsigned long len, unsigned long pgoff,
310 unsigned long flags)
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300311{
312 struct proc_dir_entry *pde = PDE(file_inode(file));
HATAYAMA Daisuke2cbe3b02013-10-16 13:47:04 -0700313 unsigned long rv = -EIO;
Jan Beulichae5758a2013-12-12 17:12:22 -0800314
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300315 if (use_pde(pde)) {
Jan Beulichae5758a2013-12-12 17:12:22 -0800316 typeof(proc_reg_get_unmapped_area) *get_area;
317
318 get_area = pde->proc_fops->get_unmapped_area;
HATAYAMA Daisukefad1a862013-10-16 13:47:05 -0700319#ifdef CONFIG_MMU
Jan Beulichae5758a2013-12-12 17:12:22 -0800320 if (!get_area)
321 get_area = current->mm->get_unmapped_area;
HATAYAMA Daisukefad1a862013-10-16 13:47:05 -0700322#endif
Jan Beulichae5758a2013-12-12 17:12:22 -0800323
HATAYAMA Daisuke5721cf82013-11-12 15:11:15 -0800324 if (get_area)
325 rv = get_area(file, orig_addr, len, pgoff, flags);
Jan Beulichae5758a2013-12-12 17:12:22 -0800326 else
327 rv = orig_addr;
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300328 unuse_pde(pde);
329 }
330 return rv;
331}
332
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700333static int proc_reg_open(struct inode *inode, struct file *file)
334{
335 struct proc_dir_entry *pde = PDE(inode);
336 int rv = 0;
337 int (*open)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700338 int (*release)(struct inode *, struct file *);
339 struct pde_opener *pdeo;
340
341 /*
Alexey Dobriyan492b2da2016-12-12 16:45:22 -0800342 * Ensure that
343 * 1) PDE's ->release hook will be called no matter what
344 * either normally by close()/->release, or forcefully by
345 * rmmod/remove_proc_entry.
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700346 *
Alexey Dobriyan492b2da2016-12-12 16:45:22 -0800347 * 2) rmmod isn't blocked by opening file in /proc and sitting on
348 * the descriptor (including "rmmod foo </proc/foo" scenario).
349 *
350 * Save every "struct file" with custom ->release hook.
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700351 */
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700352 if (!use_pde(pde))
Daisuke Oginod2857e72011-07-26 16:08:37 -0700353 return -ENOENT;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700354
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700355 release = pde->proc_fops->release;
356 if (release) {
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -0700357 pdeo = kmem_cache_alloc(pde_opener_cache, GFP_KERNEL);
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700358 if (!pdeo) {
359 rv = -ENOMEM;
360 goto out_unuse;
361 }
362 }
363
364 open = pde->proc_fops->open;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700365 if (open)
366 rv = open(inode, file);
367
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700368 if (release) {
369 if (rv == 0) {
370 /* To know what to release. */
371 pdeo->file = file;
372 pdeo->closing = false;
373 pdeo->c = NULL;
374 spin_lock(&pde->pde_unload_lock);
375 list_add(&pdeo->lh, &pde->pde_openers);
376 spin_unlock(&pde->pde_unload_lock);
377 } else
Alexey Dobriyan195b8cf2018-04-10 16:31:09 -0700378 kmem_cache_free(pde_opener_cache, pdeo);
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700379 }
Al Viro05c0ae22013-04-04 16:28:47 -0400380
Alexey Dobriyane7a6e292018-04-10 16:31:01 -0700381out_unuse:
Al Viro05c0ae22013-04-04 16:28:47 -0400382 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700383 return rv;
384}
385
386static int proc_reg_release(struct inode *inode, struct file *file)
387{
388 struct proc_dir_entry *pde = PDE(inode);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700389 struct pde_opener *pdeo;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700390 spin_lock(&pde->pde_unload_lock);
Al Viroca469f32013-04-03 19:57:00 -0400391 list_for_each_entry(pdeo, &pde->pde_openers, lh) {
392 if (pdeo->file == file) {
393 close_pdeo(pde, pdeo);
Alexey Dobriyan2f897422018-04-10 16:30:54 -0700394 return 0;
Al Viroca469f32013-04-03 19:57:00 -0400395 }
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700396 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700397 spin_unlock(&pde->pde_unload_lock);
Al Viroca469f32013-04-03 19:57:00 -0400398 return 0;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700399}
400
401static const struct file_operations proc_reg_file_ops = {
402 .llseek = proc_reg_llseek,
403 .read = proc_reg_read,
404 .write = proc_reg_write,
405 .poll = proc_reg_poll,
406 .unlocked_ioctl = proc_reg_unlocked_ioctl,
407#ifdef CONFIG_COMPAT
408 .compat_ioctl = proc_reg_compat_ioctl,
409#endif
410 .mmap = proc_reg_mmap,
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300411 .get_unmapped_area = proc_reg_get_unmapped_area,
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700412 .open = proc_reg_open,
413 .release = proc_reg_release,
414};
415
David Miller778f3dd2007-07-27 22:58:37 -0700416#ifdef CONFIG_COMPAT
417static const struct file_operations proc_reg_file_ops_no_compat = {
418 .llseek = proc_reg_llseek,
419 .read = proc_reg_read,
420 .write = proc_reg_write,
421 .poll = proc_reg_poll,
422 .unlocked_ioctl = proc_reg_unlocked_ioctl,
423 .mmap = proc_reg_mmap,
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300424 .get_unmapped_area = proc_reg_get_unmapped_area,
David Miller778f3dd2007-07-27 22:58:37 -0700425 .open = proc_reg_open,
426 .release = proc_reg_release,
427};
428#endif
429
Al Virofceef392015-12-29 15:58:39 -0500430static void proc_put_link(void *p)
431{
432 unuse_pde(p);
433}
434
Al Viro6b255392015-11-17 10:20:54 -0500435static const char *proc_get_link(struct dentry *dentry,
Al Virofceef392015-12-29 15:58:39 -0500436 struct inode *inode,
437 struct delayed_call *done)
Al Viro7e0e9532015-02-21 22:16:11 -0500438{
Al Viro6b255392015-11-17 10:20:54 -0500439 struct proc_dir_entry *pde = PDE(inode);
Alexey Dobriyan15b158b2018-02-06 15:37:28 -0800440 if (!use_pde(pde))
Al Viro7e0e9532015-02-21 22:16:11 -0500441 return ERR_PTR(-EINVAL);
Al Virofceef392015-12-29 15:58:39 -0500442 set_delayed_call(done, proc_put_link, pde);
Al Viro680baac2015-05-02 13:32:22 -0400443 return pde->data;
Al Viro7e0e9532015-02-21 22:16:11 -0500444}
445
Al Viro7e0e9532015-02-21 22:16:11 -0500446const struct inode_operations proc_link_inode_operations = {
Al Viro6b255392015-11-17 10:20:54 -0500447 .get_link = proc_get_link,
Al Viro7e0e9532015-02-21 22:16:11 -0500448};
449
Alexey Dobriyan6d1b6e42011-01-12 17:00:33 -0800450struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Linus Torvalds51f08852013-03-22 11:44:04 -0700452 struct inode *inode = new_inode_pseudo(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Linus Torvalds51f08852013-03-22 11:44:04 -0700454 if (inode) {
455 inode->i_ino = de->low_ino;
Deepa Dinamani078cd822016-09-14 07:48:04 -0700456 inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
David Howellsa1d4aeb2008-02-07 00:15:45 -0800457 PROC_I(inode)->pde = de;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700458
Eric W. Biedermaneb6d38d2015-05-11 16:44:25 -0500459 if (is_empty_pde(de)) {
460 make_empty_dir_inode(inode);
461 return inode;
462 }
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700463 if (de->mode) {
464 inode->i_mode = de->mode;
465 inode->i_uid = de->uid;
466 inode->i_gid = de->gid;
467 }
468 if (de->size)
469 inode->i_size = de->size;
470 if (de->nlink)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200471 set_nlink(inode, de->nlink);
Al Virob6cdc732013-03-30 21:20:14 -0400472 WARN_ON(!de->proc_iops);
473 inode->i_op = de->proc_iops;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700474 if (de->proc_fops) {
475 if (S_ISREG(inode->i_mode)) {
David Howellsa1d4aeb2008-02-07 00:15:45 -0800476#ifdef CONFIG_COMPAT
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700477 if (!de->proc_fops->compat_ioctl)
478 inode->i_fop =
479 &proc_reg_file_ops_no_compat;
480 else
David Howellsa1d4aeb2008-02-07 00:15:45 -0800481#endif
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700482 inode->i_fop = &proc_reg_file_ops;
483 } else {
484 inode->i_fop = de->proc_fops;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800485 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700486 }
Alexey Dobriyan99b76232009-03-25 22:48:06 +0300487 } else
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800488 pde_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return inode;
Al Virod3d009c2013-01-25 20:11:22 -0500490}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Eric W. Biedermane94591d2016-06-09 15:32:10 -0500492int proc_fill_super(struct super_block *s, void *data, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Eric W. Biedermane94591d2016-06-09 15:32:10 -0500494 struct pid_namespace *ns = get_pid_ns(s->s_fs_info);
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100495 struct inode *root_inode;
Eric W. Biederman00978752014-07-31 03:10:50 -0700496 int ret;
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100497
Eric W. Biedermane94591d2016-06-09 15:32:10 -0500498 if (!proc_parse_options(data, ns))
499 return -EINVAL;
500
Eric W. Biedermana2982cc2016-06-09 15:34:02 -0500501 /* User space would break if executables or devices appear on proc */
502 s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800503 s->s_flags |= SB_NODIRATIME | SB_NOSUID | SB_NOEXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 s->s_blocksize = 1024;
505 s->s_blocksize_bits = 10;
506 s->s_magic = PROC_SUPER_MAGIC;
507 s->s_op = &proc_sops;
508 s->s_time_gran = 1;
Linus Torvaldsa867d732016-07-29 15:54:19 -0700509
510 /*
511 * procfs isn't actually a stacking filesystem; however, there is
512 * too much magic going on inside it to permit stacking things on
513 * top of it
514 */
515 s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800517 pde_get(&proc_root);
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100518 root_inode = proc_get_inode(s, &proc_root);
519 if (!root_inode) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800520 pr_err("proc_fill_super: get root inode failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100521 return -ENOMEM;
522 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100524 s->s_root = d_make_root(root_inode);
525 if (!s->s_root) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800526 pr_err("proc_fill_super: allocate dentry failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100527 return -ENOMEM;
528 }
529
Eric W. Biederman00978752014-07-31 03:10:50 -0700530 ret = proc_setup_self(s);
531 if (ret) {
532 return ret;
533 }
534 return proc_setup_thread_self(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535}