blob: 0cd9d80f28e8aaa1a5278914c762392cd487edc4 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/uaccess.h>
27
Adrian Bunkfee781e2006-01-08 01:04:16 -080028#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Al Viro82679522010-06-04 22:17:56 -040030static void proc_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070031{
32 struct proc_dir_entry *de;
Al Virodfef6dcd32011-03-08 01:25:28 -050033 struct ctl_table_header *head;
Eric W. Biederman6b4e3062010-03-07 16:41:34 -080034 const struct proc_ns_operations *ns_ops;
Eric W. Biedermanbf056bf2011-06-18 17:48:18 -070035 void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Mark Fashehfef26652005-09-09 13:01:31 -070037 truncate_inode_pages(&inode->i_data, 0);
Jan Karadbd57682012-05-03 14:48:02 +020038 clear_inode(inode);
Mark Fashehfef26652005-09-09 13:01:31 -070039
Eric W. Biederman99f89552006-06-26 00:25:55 -070040 /* Stop tracking associated processes */
Eric W. Biederman13b41b02006-06-26 00:25:56 -070041 put_pid(PROC_I(inode)->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43 /* Let go of any associated proc directory entry */
44 de = PROC_I(inode)->pde;
Alexey Dobriyan99b76232009-03-25 22:48:06 +030045 if (de)
Alexey Dobriyan135d5652009-12-15 16:45:39 -080046 pde_put(de);
Al Virodfef6dcd32011-03-08 01:25:28 -050047 head = PROC_I(inode)->sysctl;
48 if (head) {
49 rcu_assign_pointer(PROC_I(inode)->sysctl, NULL);
50 sysctl_head_put(head);
51 }
Eric W. Biederman6b4e3062010-03-07 16:41:34 -080052 /* Release any associated namespace */
53 ns_ops = PROC_I(inode)->ns_ops;
Eric W. Biedermanbf056bf2011-06-18 17:48:18 -070054 ns = PROC_I(inode)->ns;
55 if (ns_ops && ns)
56 ns_ops->put(ns);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057}
58
Christoph Lametere18b8902006-12-06 20:33:20 -080059static struct kmem_cache * proc_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61static struct inode *proc_alloc_inode(struct super_block *sb)
62{
63 struct proc_inode *ei;
64 struct inode *inode;
65
Christoph Lametere94b1762006-12-06 20:33:17 -080066 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 if (!ei)
68 return NULL;
Eric W. Biederman13b41b02006-06-26 00:25:56 -070069 ei->pid = NULL;
Eric W. Biedermanaed7a6c2006-06-26 00:25:44 -070070 ei->fd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 ei->op.proc_get_link = NULL;
72 ei->pde = NULL;
Al Viro9043476f2008-07-15 08:54:06 -040073 ei->sysctl = NULL;
74 ei->sysctl_entry = NULL;
Eric W. Biederman6b4e3062010-03-07 16:41:34 -080075 ei->ns = NULL;
76 ei->ns_ops = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 inode = &ei->vfs_inode;
78 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
79 return inode;
80}
81
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110082static void proc_i_callback(struct rcu_head *head)
83{
84 struct inode *inode = container_of(head, struct inode, i_rcu);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110085 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
86}
87
Linus Torvalds1da177e2005-04-16 15:20:36 -070088static void proc_destroy_inode(struct inode *inode)
89{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +110090 call_rcu(&inode->i_rcu, proc_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070093static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 struct proc_inode *ei = (struct proc_inode *) foo;
96
Christoph Lametera35afb82007-05-16 22:10:57 -070097 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
Paul Mundt20c2df82007-07-20 10:11:58 +090099
Alexey Dobriyan5bcd7ff2008-10-17 03:43:55 +0400100void __init proc_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
103 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800104 0, (SLAB_RECLAIM_ACCOUNT|
Alexey Dobriyan040b5c62007-10-16 23:26:10 -0700105 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900106 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800109static int proc_show_options(struct seq_file *seq, struct dentry *root)
110{
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800111 struct super_block *sb = root->d_sb;
112 struct pid_namespace *pid = sb->s_fs_info;
113
Eric W. Biedermandcb0f222012-02-09 08:48:21 -0800114 if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
115 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
Vasiliy Kulikov04996802012-01-10 15:11:31 -0800116 if (pid->hide_pid != 0)
117 seq_printf(seq, ",hidepid=%u", pid->hide_pid);
118
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800119 return 0;
120}
121
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800122static const struct super_operations proc_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 .alloc_inode = proc_alloc_inode,
124 .destroy_inode = proc_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 .drop_inode = generic_delete_inode,
Al Viro82679522010-06-04 22:17:56 -0400126 .evict_inode = proc_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 .statfs = simple_statfs,
Vasiliy Kulikov97412952012-01-10 15:11:27 -0800128 .remount_fs = proc_remount,
129 .show_options = proc_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
Al Viro866ad9a2013-04-03 19:07:30 -0400132enum {BIAS = -1U<<31};
133
134static inline int use_pde(struct proc_dir_entry *pde)
135{
136 int res = 1;
137 spin_lock(&pde->pde_unload_lock);
138 if (unlikely(pde->pde_users < 0))
139 res = 0;
140 else
141 pde->pde_users++;
142 spin_unlock(&pde->pde_unload_lock);
143 return res;
144}
145
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700146static void __pde_users_dec(struct proc_dir_entry *pde)
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700147{
Al Viro866ad9a2013-04-03 19:07:30 -0400148 if (--pde->pde_users == BIAS)
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700149 complete(pde->pde_unload_completion);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700150}
151
Al Viro866ad9a2013-04-03 19:07:30 -0400152static void unuse_pde(struct proc_dir_entry *pde)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700153{
154 spin_lock(&pde->pde_unload_lock);
155 __pde_users_dec(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700156 spin_unlock(&pde->pde_unload_lock);
157}
158
Al Viro866ad9a2013-04-03 19:07:30 -0400159void proc_entry_rundown(struct proc_dir_entry *de)
160{
161 spin_lock(&de->pde_unload_lock);
162 de->pde_users += BIAS;
163 /* Wait until all existing callers into module are done. */
164 if (de->pde_users != BIAS) {
165 DECLARE_COMPLETION_ONSTACK(c);
166 de->pde_unload_completion = &c;
167 spin_unlock(&de->pde_unload_lock);
168
169 wait_for_completion(de->pde_unload_completion);
170
171 spin_lock(&de->pde_unload_lock);
172 }
173
174 while (!list_empty(&de->pde_openers)) {
175 struct pde_opener *pdeo;
176 struct file *file;
177
178 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh);
179 list_del(&pdeo->lh);
180 spin_unlock(&de->pde_unload_lock);
181 file = pdeo->file;
182 de->proc_fops->release(file_inode(file), file);
183 kfree(pdeo);
184 spin_lock(&de->pde_unload_lock);
185 }
186 spin_unlock(&de->pde_unload_lock);
187}
188
189/* ->read_proc() users - legacy crap */
190static ssize_t
191proc_file_read(struct file *file, char __user *buf, size_t nbytes,
192 loff_t *ppos)
193{
194 struct proc_dir_entry *pde = PDE(file_inode(file));
195 ssize_t rv = -EIO;
196 if (use_pde(pde)) {
197 rv = __proc_file_read(file, buf, nbytes, ppos);
198 unuse_pde(pde);
199 }
200 return rv;
201}
202
203static loff_t
204proc_file_lseek(struct file *file, loff_t offset, int orig)
205{
206 loff_t retval = -EINVAL;
207 switch (orig) {
208 case 1:
209 offset += file->f_pos;
210 /* fallthrough */
211 case 0:
212 if (offset < 0 || offset > MAX_NON_LFS)
213 break;
214 file->f_pos = retval = offset;
215 }
216 return retval;
217}
218
219const struct file_operations proc_file_operations = {
220 .llseek = proc_file_lseek,
221 .read = proc_file_read,
222};
223
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700224static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
225{
Al Viro496ad9a2013-01-23 17:07:38 -0500226 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700227 loff_t rv = -EINVAL;
Al Viro866ad9a2013-04-03 19:07:30 -0400228 if (use_pde(pde)) {
229 loff_t (*llseek)(struct file *, loff_t, int);
230 llseek = pde->proc_fops->llseek;
231 if (!llseek)
232 llseek = default_llseek;
233 rv = llseek(file, offset, whence);
234 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700235 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700236 return rv;
237}
238
239static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
240{
Al Viro866ad9a2013-04-03 19:07:30 -0400241 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500242 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700243 ssize_t rv = -EIO;
Al Viro866ad9a2013-04-03 19:07:30 -0400244 if (use_pde(pde)) {
245 read = pde->proc_fops->read;
246 if (read)
247 rv = read(file, buf, count, ppos);
248 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700249 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700250 return rv;
251}
252
253static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
254{
Al Viro866ad9a2013-04-03 19:07:30 -0400255 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
Al Viro496ad9a2013-01-23 17:07:38 -0500256 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700257 ssize_t rv = -EIO;
Al Viro866ad9a2013-04-03 19:07:30 -0400258 if (use_pde(pde)) {
259 write = pde->proc_fops->write;
260 if (write)
261 rv = write(file, buf, count, ppos);
262 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700263 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700264 return rv;
265}
266
267static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
268{
Al Viro496ad9a2013-01-23 17:07:38 -0500269 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyandd23aae2007-09-11 15:23:55 -0700270 unsigned int rv = DEFAULT_POLLMASK;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700271 unsigned int (*poll)(struct file *, struct poll_table_struct *);
Al Viro866ad9a2013-04-03 19:07:30 -0400272 if (use_pde(pde)) {
273 poll = pde->proc_fops->poll;
274 if (poll)
275 rv = poll(file, pts);
276 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700277 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700278 return rv;
279}
280
281static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
282{
Al Viro496ad9a2013-01-23 17:07:38 -0500283 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700284 long rv = -ENOTTY;
Arnd Bergmannb19dd422010-07-04 00:15:10 +0200285 long (*ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a2013-04-03 19:07:30 -0400286 if (use_pde(pde)) {
287 ioctl = pde->proc_fops->unlocked_ioctl;
288 if (ioctl)
289 rv = ioctl(file, cmd, arg);
290 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700291 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700292 return rv;
293}
294
295#ifdef CONFIG_COMPAT
296static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
297{
Al Viro496ad9a2013-01-23 17:07:38 -0500298 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700299 long rv = -ENOTTY;
300 long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
Al Viro866ad9a2013-04-03 19:07:30 -0400301 if (use_pde(pde)) {
302 compat_ioctl = pde->proc_fops->compat_ioctl;
303 if (compat_ioctl)
304 rv = compat_ioctl(file, cmd, arg);
305 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700306 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700307 return rv;
308}
309#endif
310
311static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
312{
Al Viro496ad9a2013-01-23 17:07:38 -0500313 struct proc_dir_entry *pde = PDE(file_inode(file));
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700314 int rv = -EIO;
315 int (*mmap)(struct file *, struct vm_area_struct *);
Al Viro866ad9a2013-04-03 19:07:30 -0400316 if (use_pde(pde)) {
317 mmap = pde->proc_fops->mmap;
318 if (mmap)
319 rv = mmap(file, vma);
320 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700321 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700322 return rv;
323}
324
325static int proc_reg_open(struct inode *inode, struct file *file)
326{
327 struct proc_dir_entry *pde = PDE(inode);
328 int rv = 0;
329 int (*open)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700330 int (*release)(struct inode *, struct file *);
331 struct pde_opener *pdeo;
332
333 /*
334 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
335 * sequence. ->release won't be called because ->proc_fops will be
336 * cleared. Depending on complexity of ->release, consequences vary.
337 *
338 * We can't wait for mercy when close will be done for real, it's
339 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
340 * by hand in remove_proc_entry(). For this, save opener's credentials
341 * for later.
342 */
343 pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL);
344 if (!pdeo)
345 return -ENOMEM;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700346
Al Viro866ad9a2013-04-03 19:07:30 -0400347 if (!use_pde(pde)) {
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700348 kfree(pdeo);
Daisuke Oginod2857e72011-07-26 16:08:37 -0700349 return -ENOENT;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700350 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700351 open = pde->proc_fops->open;
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700352 release = pde->proc_fops->release;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700353
354 if (open)
355 rv = open(inode, file);
356
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700357 spin_lock(&pde->pde_unload_lock);
358 if (rv == 0 && release) {
359 /* To know what to release. */
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700360 pdeo->file = file;
361 /* Strictly for "too late" ->release in proc_reg_release(). */
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700362 list_add(&pdeo->lh, &pde->pde_openers);
363 } else
364 kfree(pdeo);
365 __pde_users_dec(pde);
366 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700367 return rv;
368}
369
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700370static struct pde_opener *find_pde_opener(struct proc_dir_entry *pde,
Al Viro866ad9a2013-04-03 19:07:30 -0400371 struct file *file)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700372{
373 struct pde_opener *pdeo;
374
375 list_for_each_entry(pdeo, &pde->pde_openers, lh) {
Al Viro866ad9a2013-04-03 19:07:30 -0400376 if (pdeo->file == file)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700377 return pdeo;
378 }
379 return NULL;
380}
381
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700382static int proc_reg_release(struct inode *inode, struct file *file)
383{
384 struct proc_dir_entry *pde = PDE(inode);
385 int rv = 0;
386 int (*release)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700387 struct pde_opener *pdeo;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700388
389 spin_lock(&pde->pde_unload_lock);
Al Viro866ad9a2013-04-03 19:07:30 -0400390 pdeo = find_pde_opener(pde, file);
391 if (pde->pde_users < 0) {
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700392 /*
393 * Can't simply exit, __fput() will think that everything is OK,
394 * and move on to freeing struct file. remove_proc_entry() will
395 * find slacker in opener's list and will try to do non-trivial
396 * things with struct file. Therefore, remove opener from list.
397 *
398 * But if opener is removed from list, who will ->release it?
399 */
400 if (pdeo) {
401 list_del(&pdeo->lh);
402 spin_unlock(&pde->pde_unload_lock);
Al Viro866ad9a2013-04-03 19:07:30 -0400403 rv = pde->proc_fops->release(inode, file);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700404 kfree(pdeo);
405 } else
406 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700407 return rv;
408 }
409 pde->pde_users++;
410 release = pde->proc_fops->release;
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700411 if (pdeo) {
412 list_del(&pdeo->lh);
413 kfree(pdeo);
414 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700415 spin_unlock(&pde->pde_unload_lock);
416
417 if (release)
418 rv = release(inode, file);
419
Al Viro866ad9a2013-04-03 19:07:30 -0400420 unuse_pde(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700421 return rv;
422}
423
424static const struct file_operations proc_reg_file_ops = {
425 .llseek = proc_reg_llseek,
426 .read = proc_reg_read,
427 .write = proc_reg_write,
428 .poll = proc_reg_poll,
429 .unlocked_ioctl = proc_reg_unlocked_ioctl,
430#ifdef CONFIG_COMPAT
431 .compat_ioctl = proc_reg_compat_ioctl,
432#endif
433 .mmap = proc_reg_mmap,
434 .open = proc_reg_open,
435 .release = proc_reg_release,
436};
437
David Miller778f3dd2007-07-27 22:58:37 -0700438#ifdef CONFIG_COMPAT
439static const struct file_operations proc_reg_file_ops_no_compat = {
440 .llseek = proc_reg_llseek,
441 .read = proc_reg_read,
442 .write = proc_reg_write,
443 .poll = proc_reg_poll,
444 .unlocked_ioctl = proc_reg_unlocked_ioctl,
445 .mmap = proc_reg_mmap,
446 .open = proc_reg_open,
447 .release = proc_reg_release,
448};
449#endif
450
Alexey Dobriyan6d1b6e42011-01-12 17:00:33 -0800451struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
Linus Torvalds51f08852013-03-22 11:44:04 -0700453 struct inode *inode = new_inode_pseudo(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Linus Torvalds51f08852013-03-22 11:44:04 -0700455 if (inode) {
456 inode->i_ino = de->low_ino;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800457 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800458 PROC_I(inode)->pde = de;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700459
460 if (de->mode) {
461 inode->i_mode = de->mode;
462 inode->i_uid = de->uid;
463 inode->i_gid = de->gid;
464 }
465 if (de->size)
466 inode->i_size = de->size;
467 if (de->nlink)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200468 set_nlink(inode, de->nlink);
Al Virob6cdc732013-03-30 21:20:14 -0400469 WARN_ON(!de->proc_iops);
470 inode->i_op = de->proc_iops;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700471 if (de->proc_fops) {
472 if (S_ISREG(inode->i_mode)) {
David Howellsa1d4aeb2008-02-07 00:15:45 -0800473#ifdef CONFIG_COMPAT
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700474 if (!de->proc_fops->compat_ioctl)
475 inode->i_fop =
476 &proc_reg_file_ops_no_compat;
477 else
David Howellsa1d4aeb2008-02-07 00:15:45 -0800478#endif
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700479 inode->i_fop = &proc_reg_file_ops;
480 } else {
481 inode->i_fop = de->proc_fops;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800482 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700483 }
Alexey Dobriyan99b76232009-03-25 22:48:06 +0300484 } else
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800485 pde_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return inode;
Al Virod3d009c2013-01-25 20:11:22 -0500487}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Pavel Emelyanov07543f52007-10-18 23:40:08 -0700489int proc_fill_super(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100491 struct inode *root_inode;
492
Linus Torvalds92d03282006-07-15 12:20:05 -0700493 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 s->s_blocksize = 1024;
495 s->s_blocksize_bits = 10;
496 s->s_magic = PROC_SUPER_MAGIC;
497 s->s_op = &proc_sops;
498 s->s_time_gran = 1;
499
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800500 pde_get(&proc_root);
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100501 root_inode = proc_get_inode(s, &proc_root);
502 if (!root_inode) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800503 pr_err("proc_fill_super: get root inode failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100504 return -ENOMEM;
505 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100507 s->s_root = d_make_root(root_inode);
508 if (!s->s_root) {
Andrew Morton87ebdc02013-02-27 17:03:16 -0800509 pr_err("proc_fill_super: allocate dentry failed\n");
Maxim Patlasov87e0aab2013-02-20 13:13:32 +1100510 return -ENOMEM;
511 }
512
Al Viro021ada72013-03-29 19:27:05 -0400513 return proc_setup_self(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}