mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-14 21:01:29 +00:00
3790ee4bd8
Ultimately to implement /proc perfectly we need an implementation of d_revalidate because files and directories can be removed behind the back of the VFS, and d_revalidate is the only way we can let the VFS know that this has happened. Unfortunately the linux VFS can not cope with anything in the path to a mount point going away. So a proper d_revalidate method that calls d_drop also needs to call have_submounts which is moderately expensive, so you really don't want a d_revalidate method that unconditionally calls it, but instead only calls it when the backing object has really gone away. proc generic entries only disappear on module_unload (when not counting the fledgling network namespace) so it is quite rare that we actually encounter that case and has not actually caused us real world trouble yet. So until we get a proper test for keeping dentries in the dcache fix the current d_revalidate method by completely removing it. This returns us to the current status quo. So with CONFIG_NETNS=n things should look as they have always looked. For CONFIG_NETNS=y things work most of the time but there are a few rare corner cases that don't behave properly. As the network namespace is barely present in 2.6.24 this should not be a problem. Signed-off-by: Eric W. Biederman <ebiederm@xmission.com> Cc: "Rafael J. Wysocki" <rjw@sisk.pl> Cc: Pavel Emelyanov <xemul@openvz.org> Cc: "David S. Miller" <davem@davemloft.net> Cc: Herbert Xu <herbert@gondor.apana.org.au> Cc: Alexey Dobriyan <adobriyan@gmail.com> Cc: Trond Myklebust <trond.myklebust@fys.uio.no> Cc: "Denis V. Lunev" <den@openvz.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
745 lines
17 KiB
C
745 lines
17 KiB
C
/*
|
|
* proc/fs/generic.c --- generic routines for the proc-fs
|
|
*
|
|
* This file contains generic proc-fs routines for handling
|
|
* directories and files.
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds.
|
|
* Copyright (C) 1997 Theodore Ts'o
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/time.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/init.h>
|
|
#include <linux/idr.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/completion.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "internal.h"
|
|
|
|
static ssize_t proc_file_read(struct file *file, char __user *buf,
|
|
size_t nbytes, loff_t *ppos);
|
|
static ssize_t proc_file_write(struct file *file, const char __user *buffer,
|
|
size_t count, loff_t *ppos);
|
|
static loff_t proc_file_lseek(struct file *, loff_t, int);
|
|
|
|
DEFINE_SPINLOCK(proc_subdir_lock);
|
|
|
|
static int proc_match(int len, const char *name, struct proc_dir_entry *de)
|
|
{
|
|
if (de->namelen != len)
|
|
return 0;
|
|
return !memcmp(name, de->name, len);
|
|
}
|
|
|
|
static const struct file_operations proc_file_operations = {
|
|
.llseek = proc_file_lseek,
|
|
.read = proc_file_read,
|
|
.write = proc_file_write,
|
|
};
|
|
|
|
/* buffer size is one page but our output routines use some slack for overruns */
|
|
#define PROC_BLOCK_SIZE (PAGE_SIZE - 1024)
|
|
|
|
static ssize_t
|
|
proc_file_read(struct file *file, char __user *buf, size_t nbytes,
|
|
loff_t *ppos)
|
|
{
|
|
struct inode * inode = file->f_path.dentry->d_inode;
|
|
char *page;
|
|
ssize_t retval=0;
|
|
int eof=0;
|
|
ssize_t n, count;
|
|
char *start;
|
|
struct proc_dir_entry * dp;
|
|
unsigned long long pos;
|
|
|
|
/*
|
|
* Gaah, please just use "seq_file" instead. The legacy /proc
|
|
* interfaces cut loff_t down to off_t for reads, and ignore
|
|
* the offset entirely for writes..
|
|
*/
|
|
pos = *ppos;
|
|
if (pos > MAX_NON_LFS)
|
|
return 0;
|
|
if (nbytes > MAX_NON_LFS - pos)
|
|
nbytes = MAX_NON_LFS - pos;
|
|
|
|
dp = PDE(inode);
|
|
if (!(page = (char*) __get_free_page(GFP_TEMPORARY)))
|
|
return -ENOMEM;
|
|
|
|
while ((nbytes > 0) && !eof) {
|
|
count = min_t(size_t, PROC_BLOCK_SIZE, nbytes);
|
|
|
|
start = NULL;
|
|
if (dp->get_info) {
|
|
/* Handle old net routines */
|
|
n = dp->get_info(page, &start, *ppos, count);
|
|
if (n < count)
|
|
eof = 1;
|
|
} else if (dp->read_proc) {
|
|
/*
|
|
* How to be a proc read function
|
|
* ------------------------------
|
|
* Prototype:
|
|
* int f(char *buffer, char **start, off_t offset,
|
|
* int count, int *peof, void *dat)
|
|
*
|
|
* Assume that the buffer is "count" bytes in size.
|
|
*
|
|
* If you know you have supplied all the data you
|
|
* have, set *peof.
|
|
*
|
|
* You have three ways to return data:
|
|
* 0) Leave *start = NULL. (This is the default.)
|
|
* Put the data of the requested offset at that
|
|
* offset within the buffer. Return the number (n)
|
|
* of bytes there are from the beginning of the
|
|
* buffer up to the last byte of data. If the
|
|
* number of supplied bytes (= n - offset) is
|
|
* greater than zero and you didn't signal eof
|
|
* and the reader is prepared to take more data
|
|
* you will be called again with the requested
|
|
* offset advanced by the number of bytes
|
|
* absorbed. This interface is useful for files
|
|
* no larger than the buffer.
|
|
* 1) Set *start = an unsigned long value less than
|
|
* the buffer address but greater than zero.
|
|
* Put the data of the requested offset at the
|
|
* beginning of the buffer. Return the number of
|
|
* bytes of data placed there. If this number is
|
|
* greater than zero and you didn't signal eof
|
|
* and the reader is prepared to take more data
|
|
* you will be called again with the requested
|
|
* offset advanced by *start. This interface is
|
|
* useful when you have a large file consisting
|
|
* of a series of blocks which you want to count
|
|
* and return as wholes.
|
|
* (Hack by Paul.Russell@rustcorp.com.au)
|
|
* 2) Set *start = an address within the buffer.
|
|
* Put the data of the requested offset at *start.
|
|
* Return the number of bytes of data placed there.
|
|
* If this number is greater than zero and you
|
|
* didn't signal eof and the reader is prepared to
|
|
* take more data you will be called again with the
|
|
* requested offset advanced by the number of bytes
|
|
* absorbed.
|
|
*/
|
|
n = dp->read_proc(page, &start, *ppos,
|
|
count, &eof, dp->data);
|
|
} else
|
|
break;
|
|
|
|
if (n == 0) /* end of file */
|
|
break;
|
|
if (n < 0) { /* error */
|
|
if (retval == 0)
|
|
retval = n;
|
|
break;
|
|
}
|
|
|
|
if (start == NULL) {
|
|
if (n > PAGE_SIZE) {
|
|
printk(KERN_ERR
|
|
"proc_file_read: Apparent buffer overflow!\n");
|
|
n = PAGE_SIZE;
|
|
}
|
|
n -= *ppos;
|
|
if (n <= 0)
|
|
break;
|
|
if (n > count)
|
|
n = count;
|
|
start = page + *ppos;
|
|
} else if (start < page) {
|
|
if (n > PAGE_SIZE) {
|
|
printk(KERN_ERR
|
|
"proc_file_read: Apparent buffer overflow!\n");
|
|
n = PAGE_SIZE;
|
|
}
|
|
if (n > count) {
|
|
/*
|
|
* Don't reduce n because doing so might
|
|
* cut off part of a data block.
|
|
*/
|
|
printk(KERN_WARNING
|
|
"proc_file_read: Read count exceeded\n");
|
|
}
|
|
} else /* start >= page */ {
|
|
unsigned long startoff = (unsigned long)(start - page);
|
|
if (n > (PAGE_SIZE - startoff)) {
|
|
printk(KERN_ERR
|
|
"proc_file_read: Apparent buffer overflow!\n");
|
|
n = PAGE_SIZE - startoff;
|
|
}
|
|
if (n > count)
|
|
n = count;
|
|
}
|
|
|
|
n -= copy_to_user(buf, start < page ? page : start, n);
|
|
if (n == 0) {
|
|
if (retval == 0)
|
|
retval = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
*ppos += start < page ? (unsigned long)start : n;
|
|
nbytes -= n;
|
|
buf += n;
|
|
retval += n;
|
|
}
|
|
free_page((unsigned long) page);
|
|
return retval;
|
|
}
|
|
|
|
static ssize_t
|
|
proc_file_write(struct file *file, const char __user *buffer,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
|
struct proc_dir_entry * dp;
|
|
|
|
dp = PDE(inode);
|
|
|
|
if (!dp->write_proc)
|
|
return -EIO;
|
|
|
|
/* FIXME: does this routine need ppos? probably... */
|
|
return dp->write_proc(file, buffer, count, dp->data);
|
|
}
|
|
|
|
|
|
static loff_t
|
|
proc_file_lseek(struct file *file, loff_t offset, int orig)
|
|
{
|
|
loff_t retval = -EINVAL;
|
|
switch (orig) {
|
|
case 1:
|
|
offset += file->f_pos;
|
|
/* fallthrough */
|
|
case 0:
|
|
if (offset < 0 || offset > MAX_NON_LFS)
|
|
break;
|
|
file->f_pos = retval = offset;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct proc_dir_entry *de = PDE(inode);
|
|
int error;
|
|
|
|
error = inode_change_ok(inode, iattr);
|
|
if (error)
|
|
goto out;
|
|
|
|
error = inode_setattr(inode, iattr);
|
|
if (error)
|
|
goto out;
|
|
|
|
de->uid = inode->i_uid;
|
|
de->gid = inode->i_gid;
|
|
de->mode = inode->i_mode;
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|
struct kstat *stat)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
struct proc_dir_entry *de = PROC_I(inode)->pde;
|
|
if (de && de->nlink)
|
|
inode->i_nlink = de->nlink;
|
|
|
|
generic_fillattr(inode, stat);
|
|
return 0;
|
|
}
|
|
|
|
static const struct inode_operations proc_file_inode_operations = {
|
|
.setattr = proc_notify_change,
|
|
};
|
|
|
|
/*
|
|
* This function parses a name such as "tty/driver/serial", and
|
|
* returns the struct proc_dir_entry for "/proc/tty/driver", and
|
|
* returns "serial" in residual.
|
|
*/
|
|
static int xlate_proc_name(const char *name,
|
|
struct proc_dir_entry **ret, const char **residual)
|
|
{
|
|
const char *cp = name, *next;
|
|
struct proc_dir_entry *de;
|
|
int len;
|
|
int rtn = 0;
|
|
|
|
spin_lock(&proc_subdir_lock);
|
|
de = &proc_root;
|
|
while (1) {
|
|
next = strchr(cp, '/');
|
|
if (!next)
|
|
break;
|
|
|
|
len = next - cp;
|
|
for (de = de->subdir; de ; de = de->next) {
|
|
if (proc_match(len, cp, de))
|
|
break;
|
|
}
|
|
if (!de) {
|
|
rtn = -ENOENT;
|
|
goto out;
|
|
}
|
|
cp += len + 1;
|
|
}
|
|
*residual = cp;
|
|
*ret = de;
|
|
out:
|
|
spin_unlock(&proc_subdir_lock);
|
|
return rtn;
|
|
}
|
|
|
|
static DEFINE_IDR(proc_inum_idr);
|
|
static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */
|
|
|
|
#define PROC_DYNAMIC_FIRST 0xF0000000UL
|
|
|
|
/*
|
|
* Return an inode number between PROC_DYNAMIC_FIRST and
|
|
* 0xffffffff, or zero on failure.
|
|
*/
|
|
static unsigned int get_inode_number(void)
|
|
{
|
|
int i, inum = 0;
|
|
int error;
|
|
|
|
retry:
|
|
if (idr_pre_get(&proc_inum_idr, GFP_KERNEL) == 0)
|
|
return 0;
|
|
|
|
spin_lock(&proc_inum_lock);
|
|
error = idr_get_new(&proc_inum_idr, NULL, &i);
|
|
spin_unlock(&proc_inum_lock);
|
|
if (error == -EAGAIN)
|
|
goto retry;
|
|
else if (error)
|
|
return 0;
|
|
|
|
inum = (i & MAX_ID_MASK) + PROC_DYNAMIC_FIRST;
|
|
|
|
/* inum will never be more than 0xf0ffffff, so no check
|
|
* for overflow.
|
|
*/
|
|
|
|
return inum;
|
|
}
|
|
|
|
static void release_inode_number(unsigned int inum)
|
|
{
|
|
int id = (inum - PROC_DYNAMIC_FIRST) | ~MAX_ID_MASK;
|
|
|
|
spin_lock(&proc_inum_lock);
|
|
idr_remove(&proc_inum_idr, id);
|
|
spin_unlock(&proc_inum_lock);
|
|
}
|
|
|
|
static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
nd_set_link(nd, PDE(dentry->d_inode)->data);
|
|
return NULL;
|
|
}
|
|
|
|
static const struct inode_operations proc_link_inode_operations = {
|
|
.readlink = generic_readlink,
|
|
.follow_link = proc_follow_link,
|
|
};
|
|
|
|
/*
|
|
* As some entries in /proc are volatile, we want to
|
|
* get rid of unused dentries. This could be made
|
|
* smarter: we could keep a "volatile" flag in the
|
|
* inode to indicate which ones to keep.
|
|
*/
|
|
static int proc_delete_dentry(struct dentry * dentry)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static struct dentry_operations proc_dentry_operations =
|
|
{
|
|
.d_delete = proc_delete_dentry,
|
|
};
|
|
|
|
/*
|
|
* Don't create negative dentries here, return -ENOENT by hand
|
|
* instead.
|
|
*/
|
|
struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
struct inode *inode = NULL;
|
|
struct proc_dir_entry * de;
|
|
int error = -ENOENT;
|
|
|
|
lock_kernel();
|
|
spin_lock(&proc_subdir_lock);
|
|
de = PDE(dir);
|
|
if (de) {
|
|
for (de = de->subdir; de ; de = de->next) {
|
|
if (de->namelen != dentry->d_name.len)
|
|
continue;
|
|
if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
|
|
unsigned int ino;
|
|
|
|
if (de->shadow_proc)
|
|
de = de->shadow_proc(current, de);
|
|
ino = de->low_ino;
|
|
de_get(de);
|
|
spin_unlock(&proc_subdir_lock);
|
|
error = -EINVAL;
|
|
inode = proc_get_inode(dir->i_sb, ino, de);
|
|
spin_lock(&proc_subdir_lock);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock(&proc_subdir_lock);
|
|
unlock_kernel();
|
|
|
|
if (inode) {
|
|
dentry->d_op = &proc_dentry_operations;
|
|
d_add(dentry, inode);
|
|
return NULL;
|
|
}
|
|
de_put(de);
|
|
return ERR_PTR(error);
|
|
}
|
|
|
|
/*
|
|
* This returns non-zero if at EOF, so that the /proc
|
|
* root directory can use this and check if it should
|
|
* continue with the <pid> entries..
|
|
*
|
|
* Note that the VFS-layer doesn't care about the return
|
|
* value of the readdir() call, as long as it's non-negative
|
|
* for success..
|
|
*/
|
|
int proc_readdir(struct file * filp,
|
|
void * dirent, filldir_t filldir)
|
|
{
|
|
struct proc_dir_entry * de;
|
|
unsigned int ino;
|
|
int i;
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
|
int ret = 0;
|
|
|
|
lock_kernel();
|
|
|
|
ino = inode->i_ino;
|
|
de = PDE(inode);
|
|
if (!de) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
i = filp->f_pos;
|
|
switch (i) {
|
|
case 0:
|
|
if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
|
|
goto out;
|
|
i++;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
case 1:
|
|
if (filldir(dirent, "..", 2, i,
|
|
parent_ino(filp->f_path.dentry),
|
|
DT_DIR) < 0)
|
|
goto out;
|
|
i++;
|
|
filp->f_pos++;
|
|
/* fall through */
|
|
default:
|
|
spin_lock(&proc_subdir_lock);
|
|
de = de->subdir;
|
|
i -= 2;
|
|
for (;;) {
|
|
if (!de) {
|
|
ret = 1;
|
|
spin_unlock(&proc_subdir_lock);
|
|
goto out;
|
|
}
|
|
if (!i)
|
|
break;
|
|
de = de->next;
|
|
i--;
|
|
}
|
|
|
|
do {
|
|
struct proc_dir_entry *next;
|
|
|
|
/* filldir passes info to user space */
|
|
de_get(de);
|
|
spin_unlock(&proc_subdir_lock);
|
|
if (filldir(dirent, de->name, de->namelen, filp->f_pos,
|
|
de->low_ino, de->mode >> 12) < 0) {
|
|
de_put(de);
|
|
goto out;
|
|
}
|
|
spin_lock(&proc_subdir_lock);
|
|
filp->f_pos++;
|
|
next = de->next;
|
|
de_put(de);
|
|
de = next;
|
|
} while (de);
|
|
spin_unlock(&proc_subdir_lock);
|
|
}
|
|
ret = 1;
|
|
out: unlock_kernel();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* These are the generic /proc directory operations. They
|
|
* use the in-memory "struct proc_dir_entry" tree to parse
|
|
* the /proc directory.
|
|
*/
|
|
static const struct file_operations proc_dir_operations = {
|
|
.read = generic_read_dir,
|
|
.readdir = proc_readdir,
|
|
};
|
|
|
|
/*
|
|
* proc directories can do almost nothing..
|
|
*/
|
|
static const struct inode_operations proc_dir_inode_operations = {
|
|
.lookup = proc_lookup,
|
|
.getattr = proc_getattr,
|
|
.setattr = proc_notify_change,
|
|
};
|
|
|
|
static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
|
|
{
|
|
unsigned int i;
|
|
|
|
i = get_inode_number();
|
|
if (i == 0)
|
|
return -EAGAIN;
|
|
dp->low_ino = i;
|
|
|
|
if (S_ISDIR(dp->mode)) {
|
|
if (dp->proc_iops == NULL) {
|
|
dp->proc_fops = &proc_dir_operations;
|
|
dp->proc_iops = &proc_dir_inode_operations;
|
|
}
|
|
dir->nlink++;
|
|
} else if (S_ISLNK(dp->mode)) {
|
|
if (dp->proc_iops == NULL)
|
|
dp->proc_iops = &proc_link_inode_operations;
|
|
} else if (S_ISREG(dp->mode)) {
|
|
if (dp->proc_fops == NULL)
|
|
dp->proc_fops = &proc_file_operations;
|
|
if (dp->proc_iops == NULL)
|
|
dp->proc_iops = &proc_file_inode_operations;
|
|
}
|
|
|
|
spin_lock(&proc_subdir_lock);
|
|
dp->next = dir->subdir;
|
|
dp->parent = dir;
|
|
dir->subdir = dp;
|
|
spin_unlock(&proc_subdir_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct proc_dir_entry *proc_create(struct proc_dir_entry **parent,
|
|
const char *name,
|
|
mode_t mode,
|
|
nlink_t nlink)
|
|
{
|
|
struct proc_dir_entry *ent = NULL;
|
|
const char *fn = name;
|
|
int len;
|
|
|
|
/* make sure name is valid */
|
|
if (!name || !strlen(name)) goto out;
|
|
|
|
if (!(*parent) && xlate_proc_name(name, parent, &fn) != 0)
|
|
goto out;
|
|
|
|
/* At this point there must not be any '/' characters beyond *fn */
|
|
if (strchr(fn, '/'))
|
|
goto out;
|
|
|
|
len = strlen(fn);
|
|
|
|
ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL);
|
|
if (!ent) goto out;
|
|
|
|
memset(ent, 0, sizeof(struct proc_dir_entry));
|
|
memcpy(((char *) ent) + sizeof(struct proc_dir_entry), fn, len + 1);
|
|
ent->name = ((char *) ent) + sizeof(*ent);
|
|
ent->namelen = len;
|
|
ent->mode = mode;
|
|
ent->nlink = nlink;
|
|
atomic_set(&ent->count, 1);
|
|
ent->pde_users = 0;
|
|
spin_lock_init(&ent->pde_unload_lock);
|
|
ent->pde_unload_completion = NULL;
|
|
out:
|
|
return ent;
|
|
}
|
|
|
|
struct proc_dir_entry *proc_symlink(const char *name,
|
|
struct proc_dir_entry *parent, const char *dest)
|
|
{
|
|
struct proc_dir_entry *ent;
|
|
|
|
ent = proc_create(&parent,name,
|
|
(S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
|
|
|
|
if (ent) {
|
|
ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
|
|
if (ent->data) {
|
|
strcpy((char*)ent->data,dest);
|
|
if (proc_register(parent, ent) < 0) {
|
|
kfree(ent->data);
|
|
kfree(ent);
|
|
ent = NULL;
|
|
}
|
|
} else {
|
|
kfree(ent);
|
|
ent = NULL;
|
|
}
|
|
}
|
|
return ent;
|
|
}
|
|
|
|
struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
|
|
struct proc_dir_entry *parent)
|
|
{
|
|
struct proc_dir_entry *ent;
|
|
|
|
ent = proc_create(&parent, name, S_IFDIR | mode, 2);
|
|
if (ent) {
|
|
if (proc_register(parent, ent) < 0) {
|
|
kfree(ent);
|
|
ent = NULL;
|
|
}
|
|
}
|
|
return ent;
|
|
}
|
|
|
|
struct proc_dir_entry *proc_mkdir(const char *name,
|
|
struct proc_dir_entry *parent)
|
|
{
|
|
return proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent);
|
|
}
|
|
|
|
struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
|
|
struct proc_dir_entry *parent)
|
|
{
|
|
struct proc_dir_entry *ent;
|
|
nlink_t nlink;
|
|
|
|
if (S_ISDIR(mode)) {
|
|
if ((mode & S_IALLUGO) == 0)
|
|
mode |= S_IRUGO | S_IXUGO;
|
|
nlink = 2;
|
|
} else {
|
|
if ((mode & S_IFMT) == 0)
|
|
mode |= S_IFREG;
|
|
if ((mode & S_IALLUGO) == 0)
|
|
mode |= S_IRUGO;
|
|
nlink = 1;
|
|
}
|
|
|
|
ent = proc_create(&parent,name,mode,nlink);
|
|
if (ent) {
|
|
if (proc_register(parent, ent) < 0) {
|
|
kfree(ent);
|
|
ent = NULL;
|
|
}
|
|
}
|
|
return ent;
|
|
}
|
|
|
|
void free_proc_entry(struct proc_dir_entry *de)
|
|
{
|
|
unsigned int ino = de->low_ino;
|
|
|
|
if (ino < PROC_DYNAMIC_FIRST)
|
|
return;
|
|
|
|
release_inode_number(ino);
|
|
|
|
if (S_ISLNK(de->mode) && de->data)
|
|
kfree(de->data);
|
|
kfree(de);
|
|
}
|
|
|
|
/*
|
|
* Remove a /proc entry and free it if it's not currently in use.
|
|
*/
|
|
void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
|
|
{
|
|
struct proc_dir_entry **p;
|
|
struct proc_dir_entry *de;
|
|
const char *fn = name;
|
|
int len;
|
|
|
|
if (!parent && xlate_proc_name(name, &parent, &fn) != 0)
|
|
goto out;
|
|
len = strlen(fn);
|
|
|
|
spin_lock(&proc_subdir_lock);
|
|
for (p = &parent->subdir; *p; p=&(*p)->next ) {
|
|
if (!proc_match(len, fn, *p))
|
|
continue;
|
|
de = *p;
|
|
*p = de->next;
|
|
de->next = NULL;
|
|
|
|
spin_lock(&de->pde_unload_lock);
|
|
/*
|
|
* Stop accepting new callers into module. If you're
|
|
* dynamically allocating ->proc_fops, save a pointer somewhere.
|
|
*/
|
|
de->proc_fops = NULL;
|
|
/* Wait until all existing callers into module are done. */
|
|
if (de->pde_users > 0) {
|
|
DECLARE_COMPLETION_ONSTACK(c);
|
|
|
|
if (!de->pde_unload_completion)
|
|
de->pde_unload_completion = &c;
|
|
|
|
spin_unlock(&de->pde_unload_lock);
|
|
spin_unlock(&proc_subdir_lock);
|
|
|
|
wait_for_completion(de->pde_unload_completion);
|
|
|
|
spin_lock(&proc_subdir_lock);
|
|
goto continue_removing;
|
|
}
|
|
spin_unlock(&de->pde_unload_lock);
|
|
|
|
continue_removing:
|
|
if (S_ISDIR(de->mode))
|
|
parent->nlink--;
|
|
de->nlink = 0;
|
|
WARN_ON(de->subdir);
|
|
if (atomic_dec_and_test(&de->count))
|
|
free_proc_entry(de);
|
|
break;
|
|
}
|
|
spin_unlock(&proc_subdir_lock);
|
|
out:
|
|
return;
|
|
}
|