blob: 5f2dc2032c79e2eb62fe6bf0f92062306c53dc3c [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
Jan Kara31051c82016-05-26 16:55:18 +0200108 error = setattr_prepare(dentry, iattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 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);
Dmitry Torokhovc1104862016-08-10 14:36:01 -0700393 proc_set_user(ent, (*parent)->uid, (*parent)->gid);
394
yan17baa2a2012-10-04 17:15:43 -0700395out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 return ent;
397}
398
399struct proc_dir_entry *proc_symlink(const char *name,
400 struct proc_dir_entry *parent, const char *dest)
401{
402 struct proc_dir_entry *ent;
403
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800404 ent = __proc_create(&parent, name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
406
407 if (ent) {
408 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
409 if (ent->data) {
410 strcpy((char*)ent->data,dest);
Al Virod443b9f2014-12-25 16:47:49 -0500411 ent->proc_iops = &proc_link_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (proc_register(parent, ent) < 0) {
413 kfree(ent->data);
414 kfree(ent);
415 ent = NULL;
416 }
417 } else {
418 kfree(ent);
419 ent = NULL;
420 }
421 }
422 return ent;
423}
Helight.Xu587d4a12009-12-30 13:24:41 +0800424EXPORT_SYMBOL(proc_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
David Howells270b5ac2013-04-12 02:48:30 +0100426struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
427 struct proc_dir_entry *parent, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
429 struct proc_dir_entry *ent;
430
David Howells270b5ac2013-04-12 02:48:30 +0100431 if (mode == 0)
432 mode = S_IRUGO | S_IXUGO;
433
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800434 ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (ent) {
David Howells270b5ac2013-04-12 02:48:30 +0100436 ent->data = data;
Al Virod443b9f2014-12-25 16:47:49 -0500437 ent->proc_fops = &proc_dir_operations;
438 ent->proc_iops = &proc_dir_inode_operations;
439 parent->nlink++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 if (proc_register(parent, ent) < 0) {
441 kfree(ent);
Al Virod443b9f2014-12-25 16:47:49 -0500442 parent->nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 ent = NULL;
444 }
445 }
446 return ent;
447}
David Howells270b5ac2013-04-12 02:48:30 +0100448EXPORT_SYMBOL_GPL(proc_mkdir_data);
449
450struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
451 struct proc_dir_entry *parent)
452{
453 return proc_mkdir_data(name, mode, parent, NULL);
454}
Alexey Dobriyan011159a2011-05-14 00:12:48 +0300455EXPORT_SYMBOL(proc_mkdir_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457struct proc_dir_entry *proc_mkdir(const char *name,
458 struct proc_dir_entry *parent)
459{
David Howells270b5ac2013-04-12 02:48:30 +0100460 return proc_mkdir_data(name, 0, parent, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
Helight.Xu587d4a12009-12-30 13:24:41 +0800462EXPORT_SYMBOL(proc_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Eric W. Biedermaneb6d38d2015-05-11 16:44:25 -0500464struct proc_dir_entry *proc_create_mount_point(const char *name)
465{
466 umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
467 struct proc_dir_entry *ent, *parent = NULL;
468
469 ent = __proc_create(&parent, name, mode, 2);
470 if (ent) {
471 ent->data = NULL;
472 ent->proc_fops = NULL;
473 ent->proc_iops = NULL;
474 if (proc_register(parent, ent) < 0) {
475 kfree(ent);
476 parent->nlink--;
477 ent = NULL;
478 }
479 }
480 return ent;
481}
482
Al Virod161a132011-07-24 03:36:29 -0400483struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
Denis V. Lunev59b74352008-04-29 01:02:00 -0700484 struct proc_dir_entry *parent,
485 const struct file_operations *proc_fops,
486 void *data)
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800487{
488 struct proc_dir_entry *pde;
Al Virob6cdc732013-03-30 21:20:14 -0400489 if ((mode & S_IFMT) == 0)
490 mode |= S_IFREG;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800491
Al Virob6cdc732013-03-30 21:20:14 -0400492 if (!S_ISREG(mode)) {
493 WARN_ON(1); /* use proc_mkdir() */
494 return NULL;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800495 }
496
Al Virod443b9f2014-12-25 16:47:49 -0500497 BUG_ON(proc_fops == NULL);
498
Al Virob6cdc732013-03-30 21:20:14 -0400499 if ((mode & S_IALLUGO) == 0)
500 mode |= S_IRUGO;
501 pde = __proc_create(&parent, name, mode, 1);
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800502 if (!pde)
503 goto out;
504 pde->proc_fops = proc_fops;
Denis V. Lunev59b74352008-04-29 01:02:00 -0700505 pde->data = data;
Al Virod443b9f2014-12-25 16:47:49 -0500506 pde->proc_iops = &proc_file_inode_operations;
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800507 if (proc_register(parent, pde) < 0)
508 goto out_free;
509 return pde;
510out_free:
511 kfree(pde);
512out:
513 return NULL;
514}
Helight.Xu587d4a12009-12-30 13:24:41 +0800515EXPORT_SYMBOL(proc_create_data);
David Howells271a15e2013-04-12 00:38:51 +0100516
517void proc_set_size(struct proc_dir_entry *de, loff_t size)
518{
519 de->size = size;
520}
521EXPORT_SYMBOL(proc_set_size);
522
523void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
524{
525 de->uid = uid;
526 de->gid = gid;
527}
528EXPORT_SYMBOL(proc_set_user);
Alexey Dobriyan2d3a4e32008-02-08 04:18:37 -0800529
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800530static void free_proc_entry(struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531{
Eric W. Biederman33d6dce2011-06-17 13:33:20 -0700532 proc_free_inum(de->low_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Alexey Dobriyanfd2cbe42008-02-08 04:18:28 -0800534 if (S_ISLNK(de->mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 kfree(de->data);
536 kfree(de);
537}
538
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800539void pde_put(struct proc_dir_entry *pde)
540{
541 if (atomic_dec_and_test(&pde->count))
542 free_proc_entry(pde);
543}
544
Al Viro8ce584c2013-03-30 20:13:46 -0400545/*
546 * Remove a /proc entry and free it if it's not currently in use.
547 */
548void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
549{
Al Viro8ce584c2013-03-30 20:13:46 -0400550 struct proc_dir_entry *de = NULL;
551 const char *fn = name;
552 unsigned int len;
553
Waiman Longecf1a3d2015-09-09 15:35:57 -0700554 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400555 if (__xlate_proc_name(name, &parent, &fn) != 0) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700556 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400557 return;
558 }
559 len = strlen(fn);
560
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800561 de = pde_subdir_find(parent, fn, len);
562 if (de)
563 rb_erase(&de->subdir_node, &parent->subdir);
Waiman Longecf1a3d2015-09-09 15:35:57 -0700564 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400565 if (!de) {
566 WARN(1, "name '%s'\n", name);
567 return;
568 }
569
Al Viro866ad9a2013-04-03 19:07:30 -0400570 proc_entry_rundown(de);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700571
Alexey Dobriyanf649d6d2008-04-29 01:01:39 -0700572 if (S_ISDIR(de->mode))
573 parent->nlink--;
574 de->nlink = 0;
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800575 WARN(pde_subdir_first(de),
576 "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
577 __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
Alexey Dobriyan135d5652009-12-15 16:45:39 -0800578 pde_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
Helight.Xu587d4a12009-12-30 13:24:41 +0800580EXPORT_SYMBOL(remove_proc_entry);
Al Viro8ce584c2013-03-30 20:13:46 -0400581
582int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
583{
Al Viro8ce584c2013-03-30 20:13:46 -0400584 struct proc_dir_entry *root = NULL, *de, *next;
585 const char *fn = name;
586 unsigned int len;
587
Waiman Longecf1a3d2015-09-09 15:35:57 -0700588 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400589 if (__xlate_proc_name(name, &parent, &fn) != 0) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700590 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400591 return -ENOENT;
592 }
593 len = strlen(fn);
594
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800595 root = pde_subdir_find(parent, fn, len);
Al Viro8ce584c2013-03-30 20:13:46 -0400596 if (!root) {
Waiman Longecf1a3d2015-09-09 15:35:57 -0700597 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400598 return -ENOENT;
599 }
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800600 rb_erase(&root->subdir_node, &parent->subdir);
601
Al Viro8ce584c2013-03-30 20:13:46 -0400602 de = root;
603 while (1) {
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800604 next = pde_subdir_first(de);
Al Viro8ce584c2013-03-30 20:13:46 -0400605 if (next) {
Nicolas Dichtel710585d2014-12-10 15:45:01 -0800606 rb_erase(&next->subdir_node, &de->subdir);
Al Viro8ce584c2013-03-30 20:13:46 -0400607 de = next;
608 continue;
609 }
Waiman Longecf1a3d2015-09-09 15:35:57 -0700610 write_unlock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400611
Al Viro866ad9a2013-04-03 19:07:30 -0400612 proc_entry_rundown(de);
Al Viro8ce584c2013-03-30 20:13:46 -0400613 next = de->parent;
614 if (S_ISDIR(de->mode))
615 next->nlink--;
616 de->nlink = 0;
617 if (de == root)
618 break;
619 pde_put(de);
620
Waiman Longecf1a3d2015-09-09 15:35:57 -0700621 write_lock(&proc_subdir_lock);
Al Viro8ce584c2013-03-30 20:13:46 -0400622 de = next;
623 }
624 pde_put(root);
625 return 0;
626}
627EXPORT_SYMBOL(remove_proc_subtree);
David Howells4a520d22013-04-12 14:06:01 +0100628
629void *proc_get_parent_data(const struct inode *inode)
630{
631 struct proc_dir_entry *de = PDE(inode);
632 return de->parent->data;
633}
634EXPORT_SYMBOL_GPL(proc_get_parent_data);
David Howellsa8ca16e2013-04-12 17:27:28 +0100635
636void proc_remove(struct proc_dir_entry *de)
637{
638 if (de)
639 remove_proc_subtree(de->name, de->parent);
640}
641EXPORT_SYMBOL(proc_remove);
David Howellsc30480b2013-04-12 18:03:36 +0100642
643void *PDE_DATA(const struct inode *inode)
644{
645 return __PDE_DATA(inode);
646}
647EXPORT_SYMBOL(PDE_DATA);