blob: bd95b9fdebb005cd9912c3b80027cfc1659fc530 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/proc/inode.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7#include <linux/time.h>
8#include <linux/proc_fs.h>
9#include <linux/kernel.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080010#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/mm.h>
12#include <linux/string.h>
13#include <linux/stat.h>
Alexey Dobriyan786d7e12007-07-15 23:39:00 -070014#include <linux/completion.h>
Alexey Dobriyandd23aae2007-09-11 15:23:55 -070015#include <linux/poll.h>
Andrew Morton87ebdc02013-02-27 17:03:16 -080016#include <linux/printk.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/file.h>
18#include <linux/limits.h>
19#include <linux/init.h>
20#include <linux/module.h>
Al Viro9043476f2008-07-15 08:54:06 -040021#include <linux/sysctl.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080022#include <linux/seq_file.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Vasiliy Kulikov97412952012-01-10 15:11:27 -080024#include <linux/mount.h>
David Howells303eb7e2013-04-11 23:55:54 +010025#include <linux/magic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <asm/uaccess.h>
28
Adrian Bunkfee781e2006-01-08 01:04:16 -080029#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Al Viro82679522010-06-04 22:17:56 -040031static void proc_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070032{
33 struct proc_dir_entry *de;
Al Virodfef6dcd32011-03-08 01:25:28 -050034 struct ctl_table_header *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Johannes Weiner91b0abe2014-04-03 14:47:49 -070036 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +020037 clear_inode(inode);
Mark Fashehfef26652005-09-09 13:01:31 -070038
Eric W. Biederman99f89552006-06-26 00:25:55 -070039 /* Stop tracking associated processes */
Eric W. Biederman13b41b02006-06-26 00:25:56 -070040 put_pid(PROC_I(inode)->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42 /* Let go of any associated proc directory entry */
Alexander Kuleshov6bee55f2015-02-12 15:01:03 -080043 de = PDE(inode);
Alexey Dobriyan99b76232009-03-25 22:48:06 +030044 if (de)
Alexey Dobriyan135d5652009-12-15 16:45:39 -080045 pde_put(de);
Al Virodfef6dcd32011-03-08 01:25:28 -050046 head = PROC_I(inode)->sysctl;
47 if (head) {
Monam Agarwal1c44dbc2014-04-07 15:38:35 -070048 RCU_INIT_POINTER(PROC_I(inode)->sysctl, NULL);
Al Virodfef6dcd32011-03-08 01:25:28 -050049 sysctl_head_put(head);
50 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070051}
52
Christoph Lametere18b8902006-12-06 20:33:20 -080053static struct kmem_cache * proc_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55static struct inode *proc_alloc_inode(struct super_block *sb)
56{
57 struct proc_inode *ei;
58 struct inode *inode;
59
Christoph Lametere94b1762006-12-06 20:33:17 -080060 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 if (!ei)
62 return NULL;
Eric W. Biederman13b41b02006-06-26 00:25:56 -070063 ei->pid = NULL;
Eric W. Biedermanaed7a6c2006-06-26 00:25:44 -070064 ei->fd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 ei->op.proc_get_link = NULL;
66 ei->pde = NULL;
Al Viro9043476f2008-07-15 08:54:06 -040067 ei->sysctl = NULL;
68 ei->sysctl_entry = NULL;
Al Viro3d3d35b2014-11-01 11:10:28 -040069 ei->ns_ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 inode = &ei->vfs_inode;
71 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
72 return inode;
73}
74
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110075static void proc_i_callback(struct rcu_head *head)
76{
77 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110078 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
79}
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081static void proc_destroy_inode(struct inode *inode)
82{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110083 call_rcu(&inode->i_rcu, proc_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070086static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
88 struct proc_inode *ei = (struct proc_inode *) foo;
89
Christoph Lametera35afb82007-05-16 22:10:57 -070090 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
Paul Mundt20c2df82007-07-20 10:11:58 +090092
Alexey Dobriyan5bcd7ff2008-10-17 03:43:55 +040093void __init proc_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
96 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -080097 0, (SLAB_RECLAIM_ACCOUNT|
Alexey Dobriyan040b5c62007-10-16 23:26:10 -070098 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +090099 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800102static int proc_show_options(struct seq_file *seq, struct dentry *root)
103{
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800104 struct super_block *sb = root->d_sb;
105 struct pid_namespace *pid = sb->s_fs_info;
106
Eric W. Biedermandcb0f222012-02-09 08:48:21 -0800107 if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
108 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800109 if (pid->hide_pid != 0)
110 seq_printf(seq, ",hidepid=%u", pid->hide_pid);
111
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800112 return 0;
113}
114
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800115static const struct super_operations proc_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 .alloc_inode = proc_alloc_inode,
117 .destroy_inode = proc_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 .drop_inode = generic_delete_inode,
Al Viro82679522010-06-04 22:17:56 -0400119 .evict_inode = proc_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 .statfs = simple_statfs,
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800121 .remount_fs = proc_remount,
122 .show_options = proc_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123};
124
Al Viro866ad9a2013-04-03 19:07:30 -0400125enum {BIAS = -1U<<31};
126
127static inline int use_pde(struct proc_dir_entry *pde)
128{
Al Viro05c0ae22013-04-04 16:28:47 -0400129 return atomic_inc_unless_negative(&pde->in_use);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700130}
131
Al Viro866ad9a2013-04-03 19:07:30 -0400132static void unuse_pde(struct proc_dir_entry *pde)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700133{
Al Viro05c0ae22013-04-04 16:28:47 -0400134 if (atomic_dec_return(&pde->in_use) == BIAS)
135 complete(pde->pde_unload_completion);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700136}
137
Al Viroca469f32013-04-03 19:57:00 -0400138/* pde is locked */
139static void close_pdeo(struct proc_dir_entry *pde, struct pde_opener *pdeo)
140{
Al Viro05c0ae22013-04-04 16:28:47 -0400141 if (pdeo->closing) {
Al Viroca469f32013-04-03 19:57:00 -0400142 /* somebody else is doing that, just wait */
Al Viro05c0ae22013-04-04 16:28:47 -0400143 DECLARE_COMPLETION_ONSTACK(c);
144 pdeo->c = &c;
Al Viroca469f32013-04-03 19:57:00 -0400145 spin_unlock(&pde->pde_unload_lock);
Al Viro05c0ae22013-04-04 16:28:47 -0400146 wait_for_completion(&c);
Al Viroca469f32013-04-03 19:57:00 -0400147 spin_lock(&pde->pde_unload_lock);
Al Viroca469f32013-04-03 19:57:00 -0400148 } else {
149 struct file *file;
Al Viro05c0ae22013-04-04 16:28:47 -0400150 pdeo->closing = 1;
Al Viroca469f32013-04-03 19:57:00 -0400151 spin_unlock(&pde->pde_unload_lock);
152 file = pdeo->file;
153 pde->proc_fops->release(file_inode(file), file);
154 spin_lock(&pde->pde_unload_lock);
155 list_del_init(&pdeo->lh);
Al Viro05c0ae22013-04-04 16:28:47 -0400156 if (pdeo->c)
157 complete(pdeo->c);
Al Viroca469f32013-04-03 19:57:00 -0400158 kfree(pdeo);
Al Viro05c0ae22013-04-04 16:28:47 -0400159 }
Al Viroca469f32013-04-03 19:57:00 -0400160}
161
Al Viro866ad9a2013-04-03 19:07:30 -0400162void proc_entry_rundown(struct proc_dir_entry *de)
163{
Al Viro05c0ae22013-04-04 16:28:47 -0400164 DECLARE_COMPLETION_ONSTACK(c);
Al Viro866ad9a2013-04-03 19:07:30 -0400165 /* Wait until all existing callers into module are done. */
Al Viro05c0ae22013-04-04 16:28:47 -0400166 de->pde_unload_completion = &c;
167 if (atomic_add_return(BIAS, &de->in_use) != BIAS)
168 wait_for_completion(&c);
Al Viro866ad9a2013-04-03 19:07:30 -0400169
Al Viro05c0ae22013-04-04 16:28:47 -0400170 spin_lock(&de->pde_unload_lock);
Al Viro866ad9a2013-04-03 19:07:30 -0400171 while (!list_empty(&de->pde_openers)) {
172 struct pde_opener *pdeo;
Al Viro866ad9a2013-04-03 19:07:30 -0400173 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh);
Al Viroca469f32013-04-03 19:57:00 -0400174 close_pdeo(de, pdeo);
Al Viro866ad9a2013-04-03 19:07:30 -0400175 }
176 spin_unlock(&de->pde_unload_lock);
177}
178
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700179static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
180{
Al Viro496ad9a2013-01-23 17:07:38 -0500181 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700182 loff_t rv = -EINVAL;
Al Viro866ad9a2013-04-03 19:07:30 -0400183 if (use_pde(pde)) {
184 loff_t (*llseek)(struct file *, loff_t, int);
185 llseek = pde->proc_fops->llseek;
186 if (!llseek)
187 llseek = default_llseek;
188 rv = llseek(file, offset, whence);
189 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700190 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700191 return rv;
192}
193
194static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
195{
Al Viro866ad9a2013-04-03 19:07:30 -0400196 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500197 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700198 ssize_t rv = -EIO;
Al Viro866ad9a2013-04-03 19:07:30 -0400199 if (use_pde(pde)) {
200 read = pde->proc_fops->read;
201 if (read)
202 rv = read(file, buf, count, ppos);
203 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700204 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700205 return rv;
206}
207
208static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
209{
Al Viro866ad9a2013-04-03 19:07:30 -0400210 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500211 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700212 ssize_t rv = -EIO;
Al Viro866ad9a2013-04-03 19:07:30 -0400213 if (use_pde(pde)) {
214 write = pde->proc_fops->write;
215 if (write)
216 rv = write(file, buf, count, ppos);
217 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700218 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700219 return rv;
220}
221
222static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
223{
Al Viro496ad9a2013-01-23 17:07:38 -0500224 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyandd23aae2007-09-11 15:23:55 -0700225 unsigned int rv = DEFAULT_POLLMASK;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700226 unsigned int (*poll)(struct file *, struct poll_table_struct *);
Al Viro866ad9a2013-04-03 19:07:30 -0400227 if (use_pde(pde)) {
228 poll = pde->proc_fops->poll;
229 if (poll)
230 rv = poll(file, pts);
231 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700232 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700233 return rv;
234}
235
236static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
237{
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 long rv = -ENOTTY;
Arnd Bergmannb19dd422010-07-04 00:15:10 +0200240 long (*ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a2013-04-03 19:07:30 -0400241 if (use_pde(pde)) {
242 ioctl = pde->proc_fops->unlocked_ioctl;
243 if (ioctl)
244 rv = ioctl(file, cmd, arg);
245 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700246 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700247 return rv;
248}
249
250#ifdef CONFIG_COMPAT
251static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
252{
Al Viro496ad9a2013-01-23 17:07:38 -0500253 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700254 long rv = -ENOTTY;
255 long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a2013-04-03 19:07:30 -0400256 if (use_pde(pde)) {
257 compat_ioctl = pde->proc_fops->compat_ioctl;
258 if (compat_ioctl)
259 rv = compat_ioctl(file, cmd, arg);
260 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700261 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700262 return rv;
263}
264#endif
265
266static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
267{
Al Viro496ad9a2013-01-23 17:07:38 -0500268 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700269 int rv = -EIO;
270 int (*mmap)(struct file *, struct vm_area_struct *);
Al Viro866ad9a2013-04-03 19:07:30 -0400271 if (use_pde(pde)) {
272 mmap = pde->proc_fops->mmap;
273 if (mmap)
274 rv = mmap(file, vma);
275 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700276 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700277 return rv;
278}
279
HATAYAMA Daisuke5721cf82013-11-12 15:11:15 -0800280static unsigned long
281proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr,
282 unsigned long len, unsigned long pgoff,
283 unsigned long flags)
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300284{
285 struct proc_dir_entry *pde = PDE(file_inode(file));
HATAYAMA Daisuke2cbe3b02013-10-16 13:47:04 -0700286 unsigned long rv = -EIO;
Jan Beulichae5758a2013-12-12 17:12:22 -0800287
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300288 if (use_pde(pde)) {
Jan Beulichae5758a2013-12-12 17:12:22 -0800289 typeof(proc_reg_get_unmapped_area) *get_area;
290
291 get_area = pde->proc_fops->get_unmapped_area;
HATAYAMA Daisukefad1a862013-10-16 13:47:05 -0700292#ifdef CONFIG_MMU
Jan Beulichae5758a2013-12-12 17:12:22 -0800293 if (!get_area)
294 get_area = current->mm->get_unmapped_area;
HATAYAMA Daisukefad1a862013-10-16 13:47:05 -0700295#endif
Jan Beulichae5758a2013-12-12 17:12:22 -0800296
HATAYAMA Daisuke5721cf82013-11-12 15:11:15 -0800297 if (get_area)
298 rv = get_area(file, orig_addr, len, pgoff, flags);
Jan Beulichae5758a2013-12-12 17:12:22 -0800299 else
300 rv = orig_addr;
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300301 unuse_pde(pde);
302 }
303 return rv;
304}
305
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700306static int proc_reg_open(struct inode *inode, struct file *file)
307{
308 struct proc_dir_entry *pde = PDE(inode);
309 int rv = 0;
310 int (*open)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700311 int (*release)(struct inode *, struct file *);
312 struct pde_opener *pdeo;
313
314 /*
315 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
316 * sequence. ->release won't be called because ->proc_fops will be
317 * cleared. Depending on complexity of ->release, consequences vary.
318 *
319 * We can't wait for mercy when close will be done for real, it's
320 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
321 * by hand in remove_proc_entry(). For this, save opener's credentials
322 * for later.
323 */
Al Viro05c0ae22013-04-04 16:28:47 -0400324 pdeo = kzalloc(sizeof(struct pde_opener), GFP_KERNEL);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700325 if (!pdeo)
326 return -ENOMEM;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700327
Al Viro866ad9a2013-04-03 19:07:30 -0400328 if (!use_pde(pde)) {
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700329 kfree(pdeo);
Daisuke Oginod2857e72011-07-26 16:08:37 -0700330 return -ENOENT;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700331 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700332 open = pde->proc_fops->open;
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700333 release = pde->proc_fops->release;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700334
335 if (open)
336 rv = open(inode, file);
337
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700338 if (rv == 0 && release) {
339 /* To know what to release. */
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700340 pdeo->file = file;
341 /* Strictly for "too late" ->release in proc_reg_release(). */
Al Viro05c0ae22013-04-04 16:28:47 -0400342 spin_lock(&pde->pde_unload_lock);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700343 list_add(&pdeo->lh, &pde->pde_openers);
Al Viro05c0ae22013-04-04 16:28:47 -0400344 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700345 } else
346 kfree(pdeo);
Al Viro05c0ae22013-04-04 16:28:47 -0400347
348 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700349 return rv;
350}
351
352static int proc_reg_release(struct inode *inode, struct file *file)
353{
354 struct proc_dir_entry *pde = PDE(inode);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700355 struct pde_opener *pdeo;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700356 spin_lock(&pde->pde_unload_lock);
Al Viroca469f32013-04-03 19:57:00 -0400357 list_for_each_entry(pdeo, &pde->pde_openers, lh) {
358 if (pdeo->file == file) {
359 close_pdeo(pde, pdeo);
360 break;
361 }
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700362 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700363 spin_unlock(&pde->pde_unload_lock);
Al Viroca469f32013-04-03 19:57:00 -0400364 return 0;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700365}
366
367static const struct file_operations proc_reg_file_ops = {
368 .llseek = proc_reg_llseek,
369 .read = proc_reg_read,
370 .write = proc_reg_write,
371 .poll = proc_reg_poll,
372 .unlocked_ioctl = proc_reg_unlocked_ioctl,
373#ifdef CONFIG_COMPAT
374 .compat_ioctl = proc_reg_compat_ioctl,
375#endif
376 .mmap = proc_reg_mmap,
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300377 .get_unmapped_area = proc_reg_get_unmapped_area,
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700378 .open = proc_reg_open,
379 .release = proc_reg_release,
380};
381
David Miller778f3dd2007-07-27 22:58:37 -0700382#ifdef CONFIG_COMPAT
383static const struct file_operations proc_reg_file_ops_no_compat = {
384 .llseek = proc_reg_llseek,
385 .read = proc_reg_read,
386 .write = proc_reg_write,
387 .poll = proc_reg_poll,
388 .unlocked_ioctl = proc_reg_unlocked_ioctl,
389 .mmap = proc_reg_mmap,
Alexey Dobriyanc4fe2442013-08-20 22:17:24 +0300390 .get_unmapped_area = proc_reg_get_unmapped_area,
David Miller778f3dd2007-07-27 22:58:37 -0700391 .open = proc_reg_open,
392 .release = proc_reg_release,
393};
394#endif
395
Al Viro6e771372015-05-02 13:37:52 -0400396static const char *proc_follow_link(struct dentry *dentry, void **cookie)
Al Viro7e0e9532015-02-21 22:16:11 -0500397{
David Howells2b0143b2015-03-17 22:25:59 +0000398 struct proc_dir_entry *pde = PDE(d_inode(dentry));
Al Viro7e0e9532015-02-21 22:16:11 -0500399 if (unlikely(!use_pde(pde)))
400 return ERR_PTR(-EINVAL);
Al Viro680baac2015-05-02 13:32:22 -0400401 *cookie = pde;
402 return pde->data;
Al Viro7e0e9532015-02-21 22:16:11 -0500403}
404
Al Viro5f2c4172015-05-07 11:14:26 -0400405static void proc_put_link(struct inode *unused, void *p)
Al Viro7e0e9532015-02-21 22:16:11 -0500406{
407 unuse_pde(p);
408}
409
410const struct inode_operations proc_link_inode_operations = {
411 .readlink = generic_readlink,
412 .follow_link = proc_follow_link,
413 .put_link = proc_put_link,
414};
415
Alexey Dobriyan6d1b6e42011-01-12 17:00:33 -0800416struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
Linus Torvalds51f08852013-03-22 11:44:04 -0700418 struct inode *inode = new_inode_pseudo(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Linus Torvalds51f08852013-03-22 11:44:04 -0700420 if (inode) {
421 inode->i_ino = de->low_ino;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800422 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800423 PROC_I(inode)->pde = de;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700424
Eric W. Biedermaneb6d38d2015-05-11 16:44:25 -0500425 if (is_empty_pde(de)) {
426 make_empty_dir_inode(inode);
427 return inode;
428 }
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700429 if (de->mode) {
430 inode->i_mode = de->mode;
431 inode->i_uid = de->uid;
432 inode->i_gid = de->gid;
433 }
434 if (de->size)
435 inode->i_size = de->size;
436 if (de->nlink)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200437 set_nlink(inode, de->nlink);
Al Virob6cdc732013-03-30 21:20:14 -0400438 WARN_ON(!de->proc_iops);
439 inode->i_op = de->proc_iops;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700440 if (de->proc_fops) {
441 if (S_ISREG(inode->i_mode)) {
David Howellsa1d4aeb2008-02-07 00:15:45 -0800442#ifdef CONFIG_COMPAT
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700443 if (!de->proc_fops->compat_ioctl)
444 inode->i_fop =
445 &proc_reg_file_ops_no_compat;
446 else
David Howellsa1d4aeb2008-02-07 00:15:45 -0800447#endif
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700448 inode->i_fop = &proc_reg_file_ops;
449 } else {
450 inode->i_fop = de->proc_fops;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800451 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700452 }
Alexey Dobriyan99b76232009-03-25 22:48:06 +0300453 } else
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800454 pde_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 return inode;
Al Virod3d009c2013-01-25 20:11:22 -0500456}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Pavel Emelyanov07543f52007-10-18 23:40:08 -0700458int proc_fill_super(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100460 struct inode *root_inode;
Eric W. Biederman00978752014-07-31 03:10:50 -0700461 int ret;
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100462
Linus Torvalds92d03282006-07-15 12:20:05 -0700463 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 s->s_blocksize = 1024;
465 s->s_blocksize_bits = 10;
466 s->s_magic = PROC_SUPER_MAGIC;
467 s->s_op = &proc_sops;
468 s->s_time_gran = 1;
469
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800470 pde_get(&proc_root);
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100471 root_inode = proc_get_inode(s, &proc_root);
472 if (!root_inode) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800473 pr_err("proc_fill_super: get root inode failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100474 return -ENOMEM;
475 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100477 s->s_root = d_make_root(root_inode);
478 if (!s->s_root) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800479 pr_err("proc_fill_super: allocate dentry failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100480 return -ENOMEM;
481 }
482
Eric W. Biederman00978752014-07-31 03:10:50 -0700483 ret = proc_setup_self(s);
484 if (ret) {
485 return ret;
486 }
487 return proc_setup_thread_self(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}