blob: c633476616e0fe7be920d9421f8eba627a4398b3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * proc/fs/generic.c --- generic routines for the proc-fs
3 *
4 * This file contains generic proc-fs routines for handling
5 * directories and files.
6 *
7 * Copyright (C) 1991, 1992 Linus Torvalds.
8 * Copyright (C) 1997 Theodore Ts'o
9 */
10
11#include <linux/errno.h>
12#include <linux/time.h>
13#include <linux/proc_fs.h>
14#include <linux/stat.h>
Christoph Hellwig10257742010-06-04 11:30:02 +020015#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Andrew Morton87ebdc02013-02-27 17:03:16 -080018#include <linux/printk.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/init.h>
21#include <linux/idr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/bitops.h>
Steven Rostedt64a07bd2006-03-26 01:36:55 -080023#include <linux/spinlock.h>
Alexey Dobriyan786d7e12007-07-15 23:39:00 -070024#include <linux/completion.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <asm/uaccess.h>
26
Adrian Bunkfee781e2006-01-08 01:04:16 -080027#include "internal.h"
28
Waiman Longecf1a3d2015-09-09 15:35:57 -070029static DEFINE_RWLOCK(proc_subdir_lock);
Steven Rostedt64a07bd2006-03-26 01:36:55 -080030
Alexey Dobriyan312ec7e2011-03-23 16:42:52 -070031static int proc_match(unsigned int len, const char *name, struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070032{
Nicolas Dichtel710585d2014-12-10 15:45:01 -080033 if (len < de->namelen)
34 return -1;
35 if (len > de->namelen)
36 return 1;
37
38 return memcmp(name, de->name, len);
39}
40
41static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir)
42{
Nicolas Dichtel2fc1e942014-12-10 15:45:07 -080043 return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry,
44 subdir_node);
Nicolas Dichtel710585d2014-12-10 15:45:01 -080045}
46
47static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir)
48{
Nicolas Dichtel2fc1e942014-12-10 15:45:07 -080049 return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry,
50 subdir_node);
Nicolas Dichtel710585d2014-12-10 15:45:01 -080051}
52
53static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir,
54 const char *name,
55 unsigned int len)
56{
57 struct rb_node *node = dir->subdir.rb_node;
58
59 while (node) {
60 struct proc_dir_entry *de = container_of(node,
61 struct proc_dir_entry,
62 subdir_node);
63 int result = proc_match(len, name, de);
64
65 if (result < 0)
66 node = node->rb_left;
67 else if (result > 0)
68 node = node->rb_right;
69 else
70 return de;
71 }
72 return NULL;
73}
74
75static bool pde_subdir_insert(struct proc_dir_entry *dir,
76 struct proc_dir_entry *de)
77{
78 struct rb_root *root = &dir->subdir;
79 struct rb_node **new = &root->rb_node, *parent = NULL;
80
81 /* Figure out where to put new node */
82 while (*new) {
83 struct proc_dir_entry *this =
84 container_of(*new, struct proc_dir_entry, subdir_node);
85 int result = proc_match(de->namelen, de->name, this);
86
87 parent = *new;
88 if (result < 0)
89 new = &(*new)->rb_left;
90 else if (result > 0)
91 new = &(*new)->rb_right;
92 else
93 return false;
94 }
95
96 /* Add new node and rebalance tree. */
97 rb_link_node(&de->subdir_node, parent, new);
98 rb_insert_color(&de->subdir_node, root);
99 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
103{
David Howells2b0143b2015-03-17 22:25:59 +0000104 struct inode *inode = d_inode(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 struct proc_dir_entry *de = PDE(inode);
106 int error;
107
108 error = inode_change_ok(inode, iattr);
109 if (error)
Christoph Hellwig10257742010-06-04 11:30:02 +0200110 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Christoph Hellwig10257742010-06-04 11:30:02 +0200112 setattr_copy(inode, iattr);
113 mark_inode_dirty(inode);
Marco Stornelli46f69552012-12-15 11:48:48 +0100114
Rui Xiangcdf7e8d2014-01-23 15:55:41 -0800115 proc_set_user(de, inode->i_uid, inode->i_gid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 de->mode = inode->i_mode;
Christoph Hellwig10257742010-06-04 11:30:02 +0200117 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
Miklos Szeredi2b579be2005-09-06 15:17:18 -0700120static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
121 struct kstat *stat)
122{
David Howells2b0143b2015-03-17 22:25:59 +0000123 struct inode *inode = d_inode(dentry);
Alexander Kuleshov6bee55f2015-02-12 15:01:03 -0800124 struct proc_dir_entry *de = PDE(inode);
Miklos Szeredi2b579be2005-09-06 15:17:18 -0700125 if (de && de->nlink)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200126 set_nlink(inode, de->nlink);
Miklos Szeredi2b579be2005-09-06 15:17:18 -0700127
128 generic_fillattr(inode, stat);
129 return 0;
130}
131
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800132static const struct inode_operations proc_file_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 .setattr = proc_notify_change,
134};
135
136/*
137 * This function parses a name such as "tty/driver/serial", and
138 * returns the struct proc_dir_entry for "/proc/tty/driver", and
139 * returns "serial" in residual.
140 */
Alexey Dobriyane17a5762010-03-05 13:43:59 -0800141static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret,
142 const char **residual)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
144 const char *cp = name, *next;
145 struct proc_dir_entry *de;
Alexey Dobriyan312ec7e2011-03-23 16:42:52 -0700146 unsigned int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Alexey Dobriyan7cee4e02008-04-29 01:01:40 -0700148 de = *ret;
149 if (!de)
150 de = &proc_root;
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 while (1) {
153 next = strchr(cp, '/');
154 if (!next)
155 break;
156
157 len = next - cp;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800158 de = pde_subdir_find(de, cp, len);
Alexey Dobriyan12bac0d2010-03-05 13:44:00 -0800159 if (!de) {
160 WARN(1, "name '%s'\n", name);
Alexey Dobriyane17a5762010-03-05 13:43:59 -0800161 return -ENOENT;
Alexey Dobriyan12bac0d2010-03-05 13:44:00 -0800162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 cp += len + 1;
164 }
165 *residual = cp;
166 *ret = de;
Alexey Dobriyane17a5762010-03-05 13:43:59 -0800167 return 0;
168}
169
170static int xlate_proc_name(const char *name, struct proc_dir_entry **ret,
171 const char **residual)
172{
173 int rv;
174
Waiman Longecf1a3d2015-09-09 15:35:57 -0700175 read_lock(&proc_subdir_lock);
Alexey Dobriyane17a5762010-03-05 13:43:59 -0800176 rv = __xlate_proc_name(name, ret, residual);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700177 read_unlock(&proc_subdir_lock);
Alexey Dobriyane17a5762010-03-05 13:43:59 -0800178 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
Alexey Dobriyan9a185402008-07-26 11:21:37 +0400181static DEFINE_IDA(proc_inum_ida);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */
183
Alexey Dobriyan67935df2008-07-26 11:18:28 +0400184#define PROC_DYNAMIC_FIRST 0xF0000000U
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186/*
187 * Return an inode number between PROC_DYNAMIC_FIRST and
188 * 0xffffffff, or zero on failure.
189 */
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700190int proc_alloc_inum(unsigned int *inum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
Alexey Dobriyan67935df2008-07-26 11:18:28 +0400192 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 int error;
194
195retry:
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700196 if (!ida_pre_get(&proc_inum_ida, GFP_KERNEL))
197 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800199 spin_lock_irq(&proc_inum_lock);
Alexey Dobriyan9a185402008-07-26 11:21:37 +0400200 error = ida_get_new(&proc_inum_ida, &i);
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800201 spin_unlock_irq(&proc_inum_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 if (error == -EAGAIN)
203 goto retry;
204 else if (error)
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700205 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Alexey Dobriyan67935df2008-07-26 11:18:28 +0400207 if (i > UINT_MAX - PROC_DYNAMIC_FIRST) {
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800208 spin_lock_irq(&proc_inum_lock);
Alexey Dobriyan9a185402008-07-26 11:21:37 +0400209 ida_remove(&proc_inum_ida, i);
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800210 spin_unlock_irq(&proc_inum_lock);
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700211 return -ENOSPC;
Alexey Dobriyan67935df2008-07-26 11:18:28 +0400212 }
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700213 *inum = PROC_DYNAMIC_FIRST + i;
214 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700217void proc_free_inum(unsigned int inum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800219 unsigned long flags;
220 spin_lock_irqsave(&proc_inum_lock, flags);
Alexey Dobriyan9a185402008-07-26 11:21:37 +0400221 ida_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
Eric W. Biedermandfb2ea42012-12-21 20:38:00 -0800222 spin_unlock_irqrestore(&proc_inum_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 * Don't create negative dentries here, return -ENOENT by hand
227 * instead.
228 */
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800229struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
230 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
Al Virod3d009c2013-01-25 20:11:22 -0500232 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Waiman Longecf1a3d2015-09-09 15:35:57 -0700234 read_lock(&proc_subdir_lock);
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800235 de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
236 if (de) {
237 pde_get(de);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700238 read_unlock(&proc_subdir_lock);
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800239 inode = proc_get_inode(dir->i_sb, de);
240 if (!inode)
241 return ERR_PTR(-ENOMEM);
242 d_set_d_op(dentry, &simple_dentry_operations);
243 d_add(dentry, inode);
244 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
Waiman Longecf1a3d2015-09-09 15:35:57 -0700246 read_unlock(&proc_subdir_lock);
Al Virod3d009c2013-01-25 20:11:22 -0500247 return ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248}
249
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800250struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400251 unsigned int flags)
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800252{
253 return proc_lookup_de(PDE(dir), dir, dentry);
254}
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256/*
257 * This returns non-zero if at EOF, so that the /proc
258 * root directory can use this and check if it should
259 * continue with the <pid> entries..
260 *
261 * Note that the VFS-layer doesn't care about the return
262 * value of the readdir() call, as long as it's non-negative
263 * for success..
264 */
Al Virof0c3b502013-05-16 12:07:31 -0400265int proc_readdir_de(struct proc_dir_entry *de, struct file *file,
266 struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Al Virof0c3b502013-05-16 12:07:31 -0400270 if (!dir_emit_dots(file, ctx))
271 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Waiman Longecf1a3d2015-09-09 15:35:57 -0700273 read_lock(&proc_subdir_lock);
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800274 de = pde_subdir_first(de);
Al Virof0c3b502013-05-16 12:07:31 -0400275 i = ctx->pos - 2;
276 for (;;) {
277 if (!de) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700278 read_unlock(&proc_subdir_lock);
Al Virof0c3b502013-05-16 12:07:31 -0400279 return 0;
280 }
281 if (!i)
282 break;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800283 de = pde_subdir_next(de);
Al Virof0c3b502013-05-16 12:07:31 -0400284 i--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
Al Virof0c3b502013-05-16 12:07:31 -0400286
287 do {
288 struct proc_dir_entry *next;
289 pde_get(de);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700290 read_unlock(&proc_subdir_lock);
Al Virof0c3b502013-05-16 12:07:31 -0400291 if (!dir_emit(ctx, de->name, de->namelen,
292 de->low_ino, de->mode >> 12)) {
293 pde_put(de);
294 return 0;
295 }
Waiman Longecf1a3d2015-09-09 15:35:57 -0700296 read_lock(&proc_subdir_lock);
Al Virof0c3b502013-05-16 12:07:31 -0400297 ctx->pos++;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800298 next = pde_subdir_next(de);
Al Virof0c3b502013-05-16 12:07:31 -0400299 pde_put(de);
300 de = next;
301 } while (de);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700302 read_unlock(&proc_subdir_lock);
Linus Torvaldsfd3930f2013-08-19 16:26:12 -0700303 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304}
305
Al Virof0c3b502013-05-16 12:07:31 -0400306int proc_readdir(struct file *file, struct dir_context *ctx)
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800307{
Al Virof0c3b502013-05-16 12:07:31 -0400308 struct inode *inode = file_inode(file);
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800309
Al Virof0c3b502013-05-16 12:07:31 -0400310 return proc_readdir_de(PDE(inode), file, ctx);
Pavel Emelyanove9720ac2008-03-07 11:08:40 -0800311}
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313/*
314 * These are the generic /proc directory operations. They
315 * use the in-memory "struct proc_dir_entry" tree to parse
316 * the /proc directory.
317 */
Arjan van de Ven00977a52007-02-12 00:55:34 -0800318static const struct file_operations proc_dir_operations = {
Alexey Dobriyanb4df2b92008-10-27 22:48:36 +0300319 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 .read = generic_read_dir,
Al Virof50752e2016-04-20 17:13:54 -0400321 .iterate_shared = proc_readdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322};
323
324/*
325 * proc directories can do almost nothing..
326 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800327static const struct inode_operations proc_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 .lookup = proc_lookup,
Miklos Szeredi2b579be2005-09-06 15:17:18 -0700329 .getattr = proc_getattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 .setattr = proc_notify_change,
331};
332
333static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
334{
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700335 int ret;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800336
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700337 ret = proc_alloc_inum(&dp->low_ino);
338 if (ret)
339 return ret;
Steven Rostedt64a07bd2006-03-26 01:36:55 -0800340
Waiman Longecf1a3d2015-09-09 15:35:57 -0700341 write_lock(&proc_subdir_lock);
Changli Gao99fc06d2007-07-15 23:40:09 -0700342 dp->parent = dir;
Debabrata Banerjeeb208d542014-12-10 15:45:04 -0800343 if (pde_subdir_insert(dir, dp) == false) {
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800344 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
345 dir->name, dp->name);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700346 write_unlock(&proc_subdir_lock);
Debabrata Banerjeeb208d542014-12-10 15:45:04 -0800347 proc_free_inum(dp->low_ino);
348 return -EEXIST;
349 }
Waiman Longecf1a3d2015-09-09 15:35:57 -0700350 write_unlock(&proc_subdir_lock);
Changli Gao99fc06d2007-07-15 23:40:09 -0700351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 return 0;
353}
354
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800355static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 const char *name,
Al Virod161a132011-07-24 03:36:29 -0400357 umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 nlink_t nlink)
359{
360 struct proc_dir_entry *ent = NULL;
Alexey Dobriyandbcdb502014-08-08 14:21:25 -0700361 const char *fn;
362 struct qstr qstr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Alexey Dobriyan7cee4e02008-04-29 01:01:40 -0700364 if (xlate_proc_name(name, parent, &fn) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 goto out;
Alexey Dobriyandbcdb502014-08-08 14:21:25 -0700366 qstr.name = fn;
367 qstr.len = strlen(fn);
368 if (qstr.len == 0 || qstr.len >= 256) {
369 WARN(1, "name len %u\n", qstr.len);
370 return NULL;
371 }
372 if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
373 WARN(1, "create '/proc/%s' by hand\n", qstr.name);
374 return NULL;
375 }
Eric W. Biedermaneb6d38d2015-05-11 16:44:25 -0500376 if (is_empty_pde(*parent)) {
377 WARN(1, "attempt to add to permanently empty directory");
378 return NULL;
379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Alexey Dobriyandbcdb502014-08-08 14:21:25 -0700381 ent = kzalloc(sizeof(struct proc_dir_entry) + qstr.len + 1, GFP_KERNEL);
yan17baa2a2012-10-04 17:15:43 -0700382 if (!ent)
383 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Alexey Dobriyandbcdb502014-08-08 14:21:25 -0700385 memcpy(ent->name, fn, qstr.len + 1);
386 ent->namelen = qstr.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 ent->mode = mode;
388 ent->nlink = nlink;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800389 ent->subdir = RB_ROOT;
Alexey Dobriyan5a622f22007-12-04 23:45:28 -0800390 atomic_set(&ent->count, 1);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700391 spin_lock_init(&ent->pde_unload_lock);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700392 INIT_LIST_HEAD(&ent->pde_openers);
yan17baa2a2012-10-04 17:15:43 -0700393out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return ent;
395}
396
397struct proc_dir_entry *proc_symlink(const char *name,
398 struct proc_dir_entry *parent, const char *dest)
399{
400 struct proc_dir_entry *ent;
401
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800402 ent = __proc_create(&parent, name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
404
405 if (ent) {
406 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
407 if (ent->data) {
408 strcpy((char*)ent->data,dest);
Al Virod443b9f2014-12-25 16:47:49 -0500409 ent->proc_iops = &proc_link_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if (proc_register(parent, ent) < 0) {
411 kfree(ent->data);
412 kfree(ent);
413 ent = NULL;
414 }
415 } else {
416 kfree(ent);
417 ent = NULL;
418 }
419 }
420 return ent;
421}
Helight.Xu587d4a12009-12-30 13:24:41 +0800422EXPORT_SYMBOL(proc_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
David Howells270b5ac2013-04-12 02:48:30 +0100424struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
425 struct proc_dir_entry *parent, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 struct proc_dir_entry *ent;
428
David Howells270b5ac2013-04-12 02:48:30 +0100429 if (mode == 0)
430 mode = S_IRUGO | S_IXUGO;
431
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800432 ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 if (ent) {
David Howells270b5ac2013-04-12 02:48:30 +0100434 ent->data = data;
Al Virod443b9f2014-12-25 16:47:49 -0500435 ent->proc_fops = &proc_dir_operations;
436 ent->proc_iops = &proc_dir_inode_operations;
437 parent->nlink++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 if (proc_register(parent, ent) < 0) {
439 kfree(ent);
Al Virod443b9f2014-12-25 16:47:49 -0500440 parent->nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 ent = NULL;
442 }
443 }
444 return ent;
445}
David Howells270b5ac2013-04-12 02:48:30 +0100446EXPORT_SYMBOL_GPL(proc_mkdir_data);
447
448struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
449 struct proc_dir_entry *parent)
450{
451 return proc_mkdir_data(name, mode, parent, NULL);
452}
Alexey Dobriyan011159a2011-05-14 00:12:48 +0300453EXPORT_SYMBOL(proc_mkdir_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455struct proc_dir_entry *proc_mkdir(const char *name,
456 struct proc_dir_entry *parent)
457{
David Howells270b5ac2013-04-12 02:48:30 +0100458 return proc_mkdir_data(name, 0, parent, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
Helight.Xu587d4a12009-12-30 13:24:41 +0800460EXPORT_SYMBOL(proc_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Eric W. Biedermaneb6d38d2015-05-11 16:44:25 -0500462struct proc_dir_entry *proc_create_mount_point(const char *name)
463{
464 umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
465 struct proc_dir_entry *ent, *parent = NULL;
466
467 ent = __proc_create(&parent, name, mode, 2);
468 if (ent) {
469 ent->data = NULL;
470 ent->proc_fops = NULL;
471 ent->proc_iops = NULL;
472 if (proc_register(parent, ent) < 0) {
473 kfree(ent);
474 parent->nlink--;
475 ent = NULL;
476 }
477 }
478 return ent;
479}
480
Al Virod161a132011-07-24 03:36:29 -0400481struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
Denis V. Lunev59b74352008-04-29 01:02:00 -0700482 struct proc_dir_entry *parent,
483 const struct file_operations *proc_fops,
484 void *data)
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800485{
486 struct proc_dir_entry *pde;
Al Virob6cdc732013-03-30 21:20:14 -0400487 if ((mode & S_IFMT) == 0)
488 mode |= S_IFREG;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800489
Al Virob6cdc732013-03-30 21:20:14 -0400490 if (!S_ISREG(mode)) {
491 WARN_ON(1); /* use proc_mkdir() */
492 return NULL;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800493 }
494
Al Virod443b9f2014-12-25 16:47:49 -0500495 BUG_ON(proc_fops == NULL);
496
Al Virob6cdc732013-03-30 21:20:14 -0400497 if ((mode & S_IALLUGO) == 0)
498 mode |= S_IRUGO;
499 pde = __proc_create(&parent, name, mode, 1);
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800500 if (!pde)
501 goto out;
502 pde->proc_fops = proc_fops;
Denis V. Lunev59b74352008-04-29 01:02:00 -0700503 pde->data = data;
Al Virod443b9f2014-12-25 16:47:49 -0500504 pde->proc_iops = &proc_file_inode_operations;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800505 if (proc_register(parent, pde) < 0)
506 goto out_free;
507 return pde;
508out_free:
509 kfree(pde);
510out:
511 return NULL;
512}
Helight.Xu587d4a12009-12-30 13:24:41 +0800513EXPORT_SYMBOL(proc_create_data);
David Howells271a15e2013-04-12 00:38:51 +0100514
515void proc_set_size(struct proc_dir_entry *de, loff_t size)
516{
517 de->size = size;
518}
519EXPORT_SYMBOL(proc_set_size);
520
521void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
522{
523 de->uid = uid;
524 de->gid = gid;
525}
526EXPORT_SYMBOL(proc_set_user);
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800527
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800528static void free_proc_entry(struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700530 proc_free_inum(de->low_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Alexey Dobriyanfd2cbe42008-02-08 04:18:28 -0800532 if (S_ISLNK(de->mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 kfree(de->data);
534 kfree(de);
535}
536
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800537void pde_put(struct proc_dir_entry *pde)
538{
539 if (atomic_dec_and_test(&pde->count))
540 free_proc_entry(pde);
541}
542
Al Viro8ce584c2013-03-30 20:13:46 -0400543/*
544 * Remove a /proc entry and free it if it's not currently in use.
545 */
546void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
547{
Al Viro8ce584c2013-03-30 20:13:46 -0400548 struct proc_dir_entry *de = NULL;
549 const char *fn = name;
550 unsigned int len;
551
Waiman Longecf1a3d2015-09-09 15:35:57 -0700552 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400553 if (__xlate_proc_name(name, &parent, &fn) != 0) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700554 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400555 return;
556 }
557 len = strlen(fn);
558
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800559 de = pde_subdir_find(parent, fn, len);
560 if (de)
561 rb_erase(&de->subdir_node, &parent->subdir);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700562 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400563 if (!de) {
564 WARN(1, "name '%s'\n", name);
565 return;
566 }
567
Al Viro866ad9a2013-04-03 19:07:30 -0400568 proc_entry_rundown(de);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700569
Alexey Dobriyanf649d6d2008-04-29 01:01:39 -0700570 if (S_ISDIR(de->mode))
571 parent->nlink--;
572 de->nlink = 0;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800573 WARN(pde_subdir_first(de),
574 "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
575 __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800576 pde_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577}
Helight.Xu587d4a12009-12-30 13:24:41 +0800578EXPORT_SYMBOL(remove_proc_entry);
Al Viro8ce584c2013-03-30 20:13:46 -0400579
580int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
581{
Al Viro8ce584c2013-03-30 20:13:46 -0400582 struct proc_dir_entry *root = NULL, *de, *next;
583 const char *fn = name;
584 unsigned int len;
585
Waiman Longecf1a3d2015-09-09 15:35:57 -0700586 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400587 if (__xlate_proc_name(name, &parent, &fn) != 0) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700588 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400589 return -ENOENT;
590 }
591 len = strlen(fn);
592
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800593 root = pde_subdir_find(parent, fn, len);
Al Viro8ce584c2013-03-30 20:13:46 -0400594 if (!root) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700595 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400596 return -ENOENT;
597 }
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800598 rb_erase(&root->subdir_node, &parent->subdir);
599
Al Viro8ce584c2013-03-30 20:13:46 -0400600 de = root;
601 while (1) {
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800602 next = pde_subdir_first(de);
Al Viro8ce584c2013-03-30 20:13:46 -0400603 if (next) {
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800604 rb_erase(&next->subdir_node, &de->subdir);
Al Viro8ce584c2013-03-30 20:13:46 -0400605 de = next;
606 continue;
607 }
Waiman Longecf1a3d2015-09-09 15:35:57 -0700608 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400609
Al Viro866ad9a2013-04-03 19:07:30 -0400610 proc_entry_rundown(de);
Al Viro8ce584c2013-03-30 20:13:46 -0400611 next = de->parent;
612 if (S_ISDIR(de->mode))
613 next->nlink--;
614 de->nlink = 0;
615 if (de == root)
616 break;
617 pde_put(de);
618
Waiman Longecf1a3d2015-09-09 15:35:57 -0700619 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400620 de = next;
621 }
622 pde_put(root);
623 return 0;
624}
625EXPORT_SYMBOL(remove_proc_subtree);
David Howells4a520d22013-04-12 14:06:01 +0100626
627void *proc_get_parent_data(const struct inode *inode)
628{
629 struct proc_dir_entry *de = PDE(inode);
630 return de->parent->data;
631}
632EXPORT_SYMBOL_GPL(proc_get_parent_data);
David Howellsa8ca16e2013-04-12 17:27:28 +0100633
634void proc_remove(struct proc_dir_entry *de)
635{
636 if (de)
637 remove_proc_subtree(de->name, de->parent);
638}
639EXPORT_SYMBOL(proc_remove);
David Howellsc30480b2013-04-12 18:03:36 +0100640
641void *PDE_DATA(const struct inode *inode)
642{
643 return __PDE_DATA(inode);
644}
645EXPORT_SYMBOL(PDE_DATA);