2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* debugfs.h - a tiny little debug file system
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
|
|
|
|
|
* Copyright (C) 2004 IBM Inc.
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License version
|
|
|
|
|
* 2 as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* debugfs is for people to use instead of /proc or /sys.
|
2009-09-24 02:56:17 +04:00
|
|
|
* See Documentation/DocBook/filesystems for more details.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _DEBUGFS_H_
|
|
|
|
|
#define _DEBUGFS_H_
|
|
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
2011-11-18 17:50:21 +04:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-04-19 08:57:33 +04:00
|
|
|
#include <linux/types.h>
|
debugfs: prevent access to removed files' private data
Upon return of debugfs_remove()/debugfs_remove_recursive(), it might
still be attempted to access associated private file data through
previously opened struct file objects. If that data has been freed by
the caller of debugfs_remove*() in the meanwhile, the reading/writing
process would either encounter a fault or, if the memory address in
question has been reassigned again, unrelated data structures could get
overwritten.
However, since debugfs files are seldomly removed, usually from module
exit handlers only, the impact is very low.
Currently, there are ~1000 call sites of debugfs_create_file() spread
throughout the whole tree and touching all of those struct file_operations
in order to make them file removal aware by means of checking the result of
debugfs_use_file_start() from within their methods is unfeasible.
Instead, wrap the struct file_operations by a lifetime managing proxy at
file open:
- In debugfs_create_file(), the original fops handed in has got stashed
away in ->d_fsdata already.
- In debugfs_create_file(), install a proxy file_operations factory,
debugfs_full_proxy_file_operations, at ->i_fop.
This proxy factory has got an ->open() method only. It carries out some
lifetime checks and if successful, dynamically allocates and sets up a new
struct file_operations proxy at ->f_op. Afterwards, it forwards to the
->open() of the original struct file_operations in ->d_fsdata, if any.
The dynamically set up proxy at ->f_op has got a lifetime managing wrapper
set for each of the methods defined in the original struct file_operations
in ->d_fsdata.
Its ->release()er frees the proxy again and forwards to the original
->release(), if any.
In order not to mislead the VFS layer, it is strictly necessary to leave
those fields blank in the proxy that have been NULL in the original
struct file_operations also, i.e. aren't supported. This is why there is a
need for dynamically allocated proxies. The choice made not to allocate a
proxy instance for every dentry at file creation, but for every
struct file object instantiated thereof is justified by the expected usage
pattern of debugfs, namely that in general very few files get opened more
than once at a time.
The wrapper methods set in the struct file_operations implement lifetime
managing by means of the SRCU protection facilities already in place for
debugfs:
They set up a SRCU read side critical section and check whether the dentry
is still alive by means of debugfs_use_file_start(). If so, they forward
the call to the original struct file_operation stored in ->d_fsdata, still
under the protection of the SRCU read side critical section.
This SRCU read side critical section prevents any pending debugfs_remove()
and friends to return to their callers. Since a file's private data must
only be freed after the return of debugfs_remove(), the ongoing proxied
call is guarded against any file removal race.
If, on the other hand, the initial call to debugfs_use_file_start() detects
that the dentry is dead, the wrapper simply returns -EIO and does not
forward the call. Note that the ->poll() wrapper is special in that its
signature does not allow for the return of arbitrary -EXXX values and thus,
POLLHUP is returned here.
In order not to pollute debugfs with wrapper definitions that aren't ever
needed, I chose not to define a wrapper for every struct file_operations
method possible. Instead, a wrapper is defined only for the subset of
methods which are actually set by any debugfs users.
Currently, these are:
->llseek()
->read()
->write()
->unlocked_ioctl()
->poll()
The ->release() wrapper is special in that it does not protect the original
->release() in any way from dead files in order not to leak resources.
Thus, any ->release() handed to debugfs must implement file lifetime
management manually, if needed.
For only 33 out of a total of 434 releasers handed in to debugfs, it could
not be verified immediately whether they access data structures that might
have been freed upon a debugfs_remove() return in the meanwhile.
Export debugfs_use_file_start() and debugfs_use_file_finish() in order to
allow any ->release() to manually implement file lifetime management.
For a set of common cases of struct file_operations implemented by the
debugfs_core itself, future patches will incorporate file lifetime
management directly within those in order to allow for their unproxied
operation. Rename the original, non-proxying "debugfs_create_file()" to
"debugfs_create_file_unsafe()" and keep it for future internal use by
debugfs itself. Factor out code common to both into the new
__debugfs_create_file().
Signed-off-by: Nicolai Stange <nicstange@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-03-22 16:11:14 +03:00
|
|
|
#include <linux/compiler.h>
|
2005-04-19 08:57:33 +04:00
|
|
|
|
2014-11-30 18:31:21 +03:00
|
|
|
struct device;
|
2005-04-19 08:57:33 +04:00
|
|
|
struct file_operations;
|
debugfs: prevent access to removed files' private data
Upon return of debugfs_remove()/debugfs_remove_recursive(), it might
still be attempted to access associated private file data through
previously opened struct file objects. If that data has been freed by
the caller of debugfs_remove*() in the meanwhile, the reading/writing
process would either encounter a fault or, if the memory address in
question has been reassigned again, unrelated data structures could get
overwritten.
However, since debugfs files are seldomly removed, usually from module
exit handlers only, the impact is very low.
Currently, there are ~1000 call sites of debugfs_create_file() spread
throughout the whole tree and touching all of those struct file_operations
in order to make them file removal aware by means of checking the result of
debugfs_use_file_start() from within their methods is unfeasible.
Instead, wrap the struct file_operations by a lifetime managing proxy at
file open:
- In debugfs_create_file(), the original fops handed in has got stashed
away in ->d_fsdata already.
- In debugfs_create_file(), install a proxy file_operations factory,
debugfs_full_proxy_file_operations, at ->i_fop.
This proxy factory has got an ->open() method only. It carries out some
lifetime checks and if successful, dynamically allocates and sets up a new
struct file_operations proxy at ->f_op. Afterwards, it forwards to the
->open() of the original struct file_operations in ->d_fsdata, if any.
The dynamically set up proxy at ->f_op has got a lifetime managing wrapper
set for each of the methods defined in the original struct file_operations
in ->d_fsdata.
Its ->release()er frees the proxy again and forwards to the original
->release(), if any.
In order not to mislead the VFS layer, it is strictly necessary to leave
those fields blank in the proxy that have been NULL in the original
struct file_operations also, i.e. aren't supported. This is why there is a
need for dynamically allocated proxies. The choice made not to allocate a
proxy instance for every dentry at file creation, but for every
struct file object instantiated thereof is justified by the expected usage
pattern of debugfs, namely that in general very few files get opened more
than once at a time.
The wrapper methods set in the struct file_operations implement lifetime
managing by means of the SRCU protection facilities already in place for
debugfs:
They set up a SRCU read side critical section and check whether the dentry
is still alive by means of debugfs_use_file_start(). If so, they forward
the call to the original struct file_operation stored in ->d_fsdata, still
under the protection of the SRCU read side critical section.
This SRCU read side critical section prevents any pending debugfs_remove()
and friends to return to their callers. Since a file's private data must
only be freed after the return of debugfs_remove(), the ongoing proxied
call is guarded against any file removal race.
If, on the other hand, the initial call to debugfs_use_file_start() detects
that the dentry is dead, the wrapper simply returns -EIO and does not
forward the call. Note that the ->poll() wrapper is special in that its
signature does not allow for the return of arbitrary -EXXX values and thus,
POLLHUP is returned here.
In order not to pollute debugfs with wrapper definitions that aren't ever
needed, I chose not to define a wrapper for every struct file_operations
method possible. Instead, a wrapper is defined only for the subset of
methods which are actually set by any debugfs users.
Currently, these are:
->llseek()
->read()
->write()
->unlocked_ioctl()
->poll()
The ->release() wrapper is special in that it does not protect the original
->release() in any way from dead files in order not to leak resources.
Thus, any ->release() handed to debugfs must implement file lifetime
management manually, if needed.
For only 33 out of a total of 434 releasers handed in to debugfs, it could
not be verified immediately whether they access data structures that might
have been freed upon a debugfs_remove() return in the meanwhile.
Export debugfs_use_file_start() and debugfs_use_file_finish() in order to
allow any ->release() to manually implement file lifetime management.
For a set of common cases of struct file_operations implemented by the
debugfs_core itself, future patches will incorporate file lifetime
management directly within those in order to allow for their unproxied
operation. Rename the original, non-proxying "debugfs_create_file()" to
"debugfs_create_file_unsafe()" and keep it for future internal use by
debugfs itself. Factor out code common to both into the new
__debugfs_create_file().
Signed-off-by: Nicolai Stange <nicstange@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-03-22 16:11:14 +03:00
|
|
|
struct srcu_struct;
|
2005-04-19 08:57:33 +04:00
|
|
|
|
2006-03-07 13:41:59 +03:00
|
|
|
struct debugfs_blob_wrapper {
|
|
|
|
|
void *data;
|
|
|
|
|
unsigned long size;
|
|
|
|
|
};
|
|
|
|
|
|
2011-11-18 17:50:21 +04:00
|
|
|
struct debugfs_reg32 {
|
|
|
|
|
char *name;
|
|
|
|
|
unsigned long offset;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct debugfs_regset32 {
|
2013-01-19 00:40:32 +04:00
|
|
|
const struct debugfs_reg32 *regs;
|
2011-11-18 17:50:21 +04:00
|
|
|
int nregs;
|
|
|
|
|
void __iomem *base;
|
|
|
|
|
};
|
|
|
|
|
|
2008-07-19 03:08:13 +04:00
|
|
|
extern struct dentry *arch_debugfs_dir;
|
|
|
|
|
|
debugfs: prevent access to removed files' private data
Upon return of debugfs_remove()/debugfs_remove_recursive(), it might
still be attempted to access associated private file data through
previously opened struct file objects. If that data has been freed by
the caller of debugfs_remove*() in the meanwhile, the reading/writing
process would either encounter a fault or, if the memory address in
question has been reassigned again, unrelated data structures could get
overwritten.
However, since debugfs files are seldomly removed, usually from module
exit handlers only, the impact is very low.
Currently, there are ~1000 call sites of debugfs_create_file() spread
throughout the whole tree and touching all of those struct file_operations
in order to make them file removal aware by means of checking the result of
debugfs_use_file_start() from within their methods is unfeasible.
Instead, wrap the struct file_operations by a lifetime managing proxy at
file open:
- In debugfs_create_file(), the original fops handed in has got stashed
away in ->d_fsdata already.
- In debugfs_create_file(), install a proxy file_operations factory,
debugfs_full_proxy_file_operations, at ->i_fop.
This proxy factory has got an ->open() method only. It carries out some
lifetime checks and if successful, dynamically allocates and sets up a new
struct file_operations proxy at ->f_op. Afterwards, it forwards to the
->open() of the original struct file_operations in ->d_fsdata, if any.
The dynamically set up proxy at ->f_op has got a lifetime managing wrapper
set for each of the methods defined in the original struct file_operations
in ->d_fsdata.
Its ->release()er frees the proxy again and forwards to the original
->release(), if any.
In order not to mislead the VFS layer, it is strictly necessary to leave
those fields blank in the proxy that have been NULL in the original
struct file_operations also, i.e. aren't supported. This is why there is a
need for dynamically allocated proxies. The choice made not to allocate a
proxy instance for every dentry at file creation, but for every
struct file object instantiated thereof is justified by the expected usage
pattern of debugfs, namely that in general very few files get opened more
than once at a time.
The wrapper methods set in the struct file_operations implement lifetime
managing by means of the SRCU protection facilities already in place for
debugfs:
They set up a SRCU read side critical section and check whether the dentry
is still alive by means of debugfs_use_file_start(). If so, they forward
the call to the original struct file_operation stored in ->d_fsdata, still
under the protection of the SRCU read side critical section.
This SRCU read side critical section prevents any pending debugfs_remove()
and friends to return to their callers. Since a file's private data must
only be freed after the return of debugfs_remove(), the ongoing proxied
call is guarded against any file removal race.
If, on the other hand, the initial call to debugfs_use_file_start() detects
that the dentry is dead, the wrapper simply returns -EIO and does not
forward the call. Note that the ->poll() wrapper is special in that its
signature does not allow for the return of arbitrary -EXXX values and thus,
POLLHUP is returned here.
In order not to pollute debugfs with wrapper definitions that aren't ever
needed, I chose not to define a wrapper for every struct file_operations
method possible. Instead, a wrapper is defined only for the subset of
methods which are actually set by any debugfs users.
Currently, these are:
->llseek()
->read()
->write()
->unlocked_ioctl()
->poll()
The ->release() wrapper is special in that it does not protect the original
->release() in any way from dead files in order not to leak resources.
Thus, any ->release() handed to debugfs must implement file lifetime
management manually, if needed.
For only 33 out of a total of 434 releasers handed in to debugfs, it could
not be verified immediately whether they access data structures that might
have been freed upon a debugfs_remove() return in the meanwhile.
Export debugfs_use_file_start() and debugfs_use_file_finish() in order to
allow any ->release() to manually implement file lifetime management.
For a set of common cases of struct file_operations implemented by the
debugfs_core itself, future patches will incorporate file lifetime
management directly within those in order to allow for their unproxied
operation. Rename the original, non-proxying "debugfs_create_file()" to
"debugfs_create_file_unsafe()" and keep it for future internal use by
debugfs itself. Factor out code common to both into the new
__debugfs_create_file().
Signed-off-by: Nicolai Stange <nicstange@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-03-22 16:11:14 +03:00
|
|
|
extern struct srcu_struct debugfs_srcu;
|
|
|
|
|
|
2016-09-17 22:43:01 +03:00
|
|
|
/**
|
|
|
|
|
* debugfs_real_fops - getter for the real file operation
|
|
|
|
|
* @filp: a pointer to a struct file
|
|
|
|
|
*
|
|
|
|
|
* Must only be called under the protection established by
|
|
|
|
|
* debugfs_use_file_start().
|
|
|
|
|
*/
|
2016-12-14 18:33:39 +03:00
|
|
|
static inline const struct file_operations *debugfs_real_fops(const struct file *filp)
|
2016-09-17 22:43:01 +03:00
|
|
|
__must_hold(&debugfs_srcu)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Neither the pointer to the struct file_operations, nor its
|
|
|
|
|
* contents ever change -- srcu_dereference() is not needed here.
|
|
|
|
|
*/
|
|
|
|
|
return filp->f_path.dentry->d_fsdata;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-20 23:07:53 +03:00
|
|
|
#define DEFINE_DEBUGFS_ATTRIBUTE(__fops, __get, __set, __fmt) \
|
|
|
|
|
static int __fops ## _open(struct inode *inode, struct file *file) \
|
|
|
|
|
{ \
|
|
|
|
|
__simple_attr_check_format(__fmt, 0ull); \
|
|
|
|
|
return simple_attr_open(inode, file, __get, __set, __fmt); \
|
|
|
|
|
} \
|
|
|
|
|
static const struct file_operations __fops = { \
|
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
|
.open = __fops ## _open, \
|
|
|
|
|
.release = simple_attr_release, \
|
|
|
|
|
.read = debugfs_attr_read, \
|
|
|
|
|
.write = debugfs_attr_write, \
|
|
|
|
|
.llseek = generic_file_llseek, \
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#if defined(CONFIG_DEBUG_FS)
|
2008-02-14 04:08:16 +03:00
|
|
|
|
2017-02-01 01:53:17 +03:00
|
|
|
struct dentry *debugfs_lookup(const char *name, struct dentry *parent);
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_file(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent, void *data,
|
2006-03-28 13:56:41 +04:00
|
|
|
const struct file_operations *fops);
|
2016-03-22 16:11:15 +03:00
|
|
|
struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, void *data,
|
|
|
|
|
const struct file_operations *fops);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-01-21 23:03:40 +03:00
|
|
|
struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, void *data,
|
|
|
|
|
const struct file_operations *fops,
|
|
|
|
|
loff_t file_size);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
|
|
|
|
|
|
2007-02-13 14:13:54 +03:00
|
|
|
struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
|
|
|
|
|
const char *dest);
|
|
|
|
|
|
2017-01-31 20:06:16 +03:00
|
|
|
typedef struct vfsmount *(*debugfs_automount_t)(struct dentry *, void *);
|
2015-01-25 23:10:32 +03:00
|
|
|
struct dentry *debugfs_create_automount(const char *name,
|
|
|
|
|
struct dentry *parent,
|
2017-01-31 20:06:16 +03:00
|
|
|
debugfs_automount_t f,
|
2015-01-25 23:10:32 +03:00
|
|
|
void *data);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
void debugfs_remove(struct dentry *dentry);
|
2008-07-01 17:14:51 +04:00
|
|
|
void debugfs_remove_recursive(struct dentry *dentry);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
debugfs: prevent access to removed files' private data
Upon return of debugfs_remove()/debugfs_remove_recursive(), it might
still be attempted to access associated private file data through
previously opened struct file objects. If that data has been freed by
the caller of debugfs_remove*() in the meanwhile, the reading/writing
process would either encounter a fault or, if the memory address in
question has been reassigned again, unrelated data structures could get
overwritten.
However, since debugfs files are seldomly removed, usually from module
exit handlers only, the impact is very low.
Currently, there are ~1000 call sites of debugfs_create_file() spread
throughout the whole tree and touching all of those struct file_operations
in order to make them file removal aware by means of checking the result of
debugfs_use_file_start() from within their methods is unfeasible.
Instead, wrap the struct file_operations by a lifetime managing proxy at
file open:
- In debugfs_create_file(), the original fops handed in has got stashed
away in ->d_fsdata already.
- In debugfs_create_file(), install a proxy file_operations factory,
debugfs_full_proxy_file_operations, at ->i_fop.
This proxy factory has got an ->open() method only. It carries out some
lifetime checks and if successful, dynamically allocates and sets up a new
struct file_operations proxy at ->f_op. Afterwards, it forwards to the
->open() of the original struct file_operations in ->d_fsdata, if any.
The dynamically set up proxy at ->f_op has got a lifetime managing wrapper
set for each of the methods defined in the original struct file_operations
in ->d_fsdata.
Its ->release()er frees the proxy again and forwards to the original
->release(), if any.
In order not to mislead the VFS layer, it is strictly necessary to leave
those fields blank in the proxy that have been NULL in the original
struct file_operations also, i.e. aren't supported. This is why there is a
need for dynamically allocated proxies. The choice made not to allocate a
proxy instance for every dentry at file creation, but for every
struct file object instantiated thereof is justified by the expected usage
pattern of debugfs, namely that in general very few files get opened more
than once at a time.
The wrapper methods set in the struct file_operations implement lifetime
managing by means of the SRCU protection facilities already in place for
debugfs:
They set up a SRCU read side critical section and check whether the dentry
is still alive by means of debugfs_use_file_start(). If so, they forward
the call to the original struct file_operation stored in ->d_fsdata, still
under the protection of the SRCU read side critical section.
This SRCU read side critical section prevents any pending debugfs_remove()
and friends to return to their callers. Since a file's private data must
only be freed after the return of debugfs_remove(), the ongoing proxied
call is guarded against any file removal race.
If, on the other hand, the initial call to debugfs_use_file_start() detects
that the dentry is dead, the wrapper simply returns -EIO and does not
forward the call. Note that the ->poll() wrapper is special in that its
signature does not allow for the return of arbitrary -EXXX values and thus,
POLLHUP is returned here.
In order not to pollute debugfs with wrapper definitions that aren't ever
needed, I chose not to define a wrapper for every struct file_operations
method possible. Instead, a wrapper is defined only for the subset of
methods which are actually set by any debugfs users.
Currently, these are:
->llseek()
->read()
->write()
->unlocked_ioctl()
->poll()
The ->release() wrapper is special in that it does not protect the original
->release() in any way from dead files in order not to leak resources.
Thus, any ->release() handed to debugfs must implement file lifetime
management manually, if needed.
For only 33 out of a total of 434 releasers handed in to debugfs, it could
not be verified immediately whether they access data structures that might
have been freed upon a debugfs_remove() return in the meanwhile.
Export debugfs_use_file_start() and debugfs_use_file_finish() in order to
allow any ->release() to manually implement file lifetime management.
For a set of common cases of struct file_operations implemented by the
debugfs_core itself, future patches will incorporate file lifetime
management directly within those in order to allow for their unproxied
operation. Rename the original, non-proxying "debugfs_create_file()" to
"debugfs_create_file_unsafe()" and keep it for future internal use by
debugfs itself. Factor out code common to both into the new
__debugfs_create_file().
Signed-off-by: Nicolai Stange <nicstange@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-03-22 16:11:14 +03:00
|
|
|
int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx)
|
|
|
|
|
__acquires(&debugfs_srcu);
|
|
|
|
|
|
|
|
|
|
void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu);
|
|
|
|
|
|
2016-03-22 16:11:15 +03:00
|
|
|
ssize_t debugfs_attr_read(struct file *file, char __user *buf,
|
|
|
|
|
size_t len, loff_t *ppos);
|
|
|
|
|
ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
|
|
|
|
|
size_t len, loff_t *ppos);
|
|
|
|
|
|
2007-05-09 15:19:52 +04:00
|
|
|
struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
|
|
|
|
|
struct dentry *new_dir, const char *new_name);
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_u8(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent, u8 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_u16(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent, u16 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_u32(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent, u32 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_u64(const char *name, umode_t mode,
|
2007-04-17 09:59:36 +04:00
|
|
|
struct dentry *parent, u64 *value);
|
2015-10-18 20:13:19 +03:00
|
|
|
struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, unsigned long *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_x8(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent, u8 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_x16(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent, u16 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_x32(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent, u32 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_x64(const char *name, umode_t mode,
|
2010-05-18 10:35:23 +04:00
|
|
|
struct dentry *parent, u64 *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
|
2008-12-21 03:57:39 +03:00
|
|
|
struct dentry *parent, size_t *value);
|
2013-06-04 00:33:02 +04:00
|
|
|
struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, atomic_t *value);
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
2015-09-27 01:04:07 +03:00
|
|
|
struct dentry *parent, bool *value);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
struct dentry *debugfs_create_blob(const char *name, umode_t mode,
|
2006-03-07 13:41:59 +03:00
|
|
|
struct dentry *parent,
|
|
|
|
|
struct debugfs_blob_wrapper *blob);
|
2009-03-23 01:10:44 +03:00
|
|
|
|
2012-03-20 14:00:24 +04:00
|
|
|
struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
|
2011-11-18 17:50:21 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
struct debugfs_regset32 *regset);
|
|
|
|
|
|
2014-09-30 03:08:26 +04:00
|
|
|
void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
|
|
|
|
|
int nregs, void __iomem *base, char *prefix);
|
2011-11-18 17:50:21 +04:00
|
|
|
|
2012-03-23 12:06:28 +04:00
|
|
|
struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
u32 *array, u32 elements);
|
|
|
|
|
|
2014-11-09 13:31:58 +03:00
|
|
|
struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
int (*read_fn)(struct seq_file *s,
|
|
|
|
|
void *data));
|
|
|
|
|
|
2009-03-23 01:10:44 +03:00
|
|
|
bool debugfs_initialized(void);
|
|
|
|
|
|
2015-06-23 16:32:54 +03:00
|
|
|
ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
|
|
|
|
|
size_t count, loff_t *ppos);
|
|
|
|
|
|
|
|
|
|
ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
|
|
|
|
|
size_t count, loff_t *ppos);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#else
|
2005-04-19 08:57:33 +04:00
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
|
2014-11-09 13:31:58 +03:00
|
|
|
/*
|
2005-04-17 02:20:36 +04:00
|
|
|
* We do not return NULL from these functions if CONFIG_DEBUG_FS is not enabled
|
|
|
|
|
* so users have a chance to detect if there was a real error or not. We don't
|
|
|
|
|
* want to duplicate the design decision mistakes of procfs and devfs again.
|
|
|
|
|
*/
|
|
|
|
|
|
2017-02-01 01:53:17 +03:00
|
|
|
static inline struct dentry *debugfs_lookup(const char *name,
|
|
|
|
|
struct dentry *parent)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_file(const char *name, umode_t mode,
|
2006-04-19 08:30:22 +04:00
|
|
|
struct dentry *parent, void *data,
|
|
|
|
|
const struct file_operations *fops)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-21 23:03:40 +03:00
|
|
|
static inline struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, void *data,
|
|
|
|
|
const struct file_operations *fops,
|
|
|
|
|
loff_t file_size)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static inline struct dentry *debugfs_create_dir(const char *name,
|
|
|
|
|
struct dentry *parent)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-13 14:13:54 +03:00
|
|
|
static inline struct dentry *debugfs_create_symlink(const char *name,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
const char *dest)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-22 11:05:10 +03:00
|
|
|
static inline struct dentry *debugfs_create_automount(const char *name,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
struct vfsmount *(*f)(void *),
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static inline void debugfs_remove(struct dentry *dentry)
|
|
|
|
|
{ }
|
|
|
|
|
|
2008-07-01 17:14:51 +04:00
|
|
|
static inline void debugfs_remove_recursive(struct dentry *dentry)
|
|
|
|
|
{ }
|
|
|
|
|
|
debugfs: prevent access to removed files' private data
Upon return of debugfs_remove()/debugfs_remove_recursive(), it might
still be attempted to access associated private file data through
previously opened struct file objects. If that data has been freed by
the caller of debugfs_remove*() in the meanwhile, the reading/writing
process would either encounter a fault or, if the memory address in
question has been reassigned again, unrelated data structures could get
overwritten.
However, since debugfs files are seldomly removed, usually from module
exit handlers only, the impact is very low.
Currently, there are ~1000 call sites of debugfs_create_file() spread
throughout the whole tree and touching all of those struct file_operations
in order to make them file removal aware by means of checking the result of
debugfs_use_file_start() from within their methods is unfeasible.
Instead, wrap the struct file_operations by a lifetime managing proxy at
file open:
- In debugfs_create_file(), the original fops handed in has got stashed
away in ->d_fsdata already.
- In debugfs_create_file(), install a proxy file_operations factory,
debugfs_full_proxy_file_operations, at ->i_fop.
This proxy factory has got an ->open() method only. It carries out some
lifetime checks and if successful, dynamically allocates and sets up a new
struct file_operations proxy at ->f_op. Afterwards, it forwards to the
->open() of the original struct file_operations in ->d_fsdata, if any.
The dynamically set up proxy at ->f_op has got a lifetime managing wrapper
set for each of the methods defined in the original struct file_operations
in ->d_fsdata.
Its ->release()er frees the proxy again and forwards to the original
->release(), if any.
In order not to mislead the VFS layer, it is strictly necessary to leave
those fields blank in the proxy that have been NULL in the original
struct file_operations also, i.e. aren't supported. This is why there is a
need for dynamically allocated proxies. The choice made not to allocate a
proxy instance for every dentry at file creation, but for every
struct file object instantiated thereof is justified by the expected usage
pattern of debugfs, namely that in general very few files get opened more
than once at a time.
The wrapper methods set in the struct file_operations implement lifetime
managing by means of the SRCU protection facilities already in place for
debugfs:
They set up a SRCU read side critical section and check whether the dentry
is still alive by means of debugfs_use_file_start(). If so, they forward
the call to the original struct file_operation stored in ->d_fsdata, still
under the protection of the SRCU read side critical section.
This SRCU read side critical section prevents any pending debugfs_remove()
and friends to return to their callers. Since a file's private data must
only be freed after the return of debugfs_remove(), the ongoing proxied
call is guarded against any file removal race.
If, on the other hand, the initial call to debugfs_use_file_start() detects
that the dentry is dead, the wrapper simply returns -EIO and does not
forward the call. Note that the ->poll() wrapper is special in that its
signature does not allow for the return of arbitrary -EXXX values and thus,
POLLHUP is returned here.
In order not to pollute debugfs with wrapper definitions that aren't ever
needed, I chose not to define a wrapper for every struct file_operations
method possible. Instead, a wrapper is defined only for the subset of
methods which are actually set by any debugfs users.
Currently, these are:
->llseek()
->read()
->write()
->unlocked_ioctl()
->poll()
The ->release() wrapper is special in that it does not protect the original
->release() in any way from dead files in order not to leak resources.
Thus, any ->release() handed to debugfs must implement file lifetime
management manually, if needed.
For only 33 out of a total of 434 releasers handed in to debugfs, it could
not be verified immediately whether they access data structures that might
have been freed upon a debugfs_remove() return in the meanwhile.
Export debugfs_use_file_start() and debugfs_use_file_finish() in order to
allow any ->release() to manually implement file lifetime management.
For a set of common cases of struct file_operations implemented by the
debugfs_core itself, future patches will incorporate file lifetime
management directly within those in order to allow for their unproxied
operation. Rename the original, non-proxying "debugfs_create_file()" to
"debugfs_create_file_unsafe()" and keep it for future internal use by
debugfs itself. Factor out code common to both into the new
__debugfs_create_file().
Signed-off-by: Nicolai Stange <nicstange@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-03-22 16:11:14 +03:00
|
|
|
static inline int debugfs_use_file_start(const struct dentry *dentry,
|
|
|
|
|
int *srcu_idx)
|
|
|
|
|
__acquires(&debugfs_srcu)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void debugfs_use_file_finish(int srcu_idx)
|
|
|
|
|
__releases(&debugfs_srcu)
|
|
|
|
|
{ }
|
|
|
|
|
|
2016-10-20 23:07:53 +03:00
|
|
|
static inline ssize_t debugfs_attr_read(struct file *file, char __user *buf,
|
|
|
|
|
size_t len, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline ssize_t debugfs_attr_write(struct file *file,
|
|
|
|
|
const char __user *buf,
|
|
|
|
|
size_t len, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
2016-03-22 16:11:15 +03:00
|
|
|
|
2007-05-09 15:19:52 +04:00
|
|
|
static inline struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
|
|
|
|
|
struct dentry *new_dir, char *new_name)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_u8(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
u8 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_u16(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent,
|
2005-04-19 08:57:34 +04:00
|
|
|
u16 *value)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_u32(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent,
|
2005-04-19 08:57:34 +04:00
|
|
|
u32 *value)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_u64(const char *name, umode_t mode,
|
2007-04-17 09:59:36 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
u64 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_x8(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
u8 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_x16(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
u16 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_x32(const char *name, umode_t mode,
|
2007-08-03 02:23:50 +04:00
|
|
|
struct dentry *parent,
|
|
|
|
|
u32 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-26 11:58:30 +04:00
|
|
|
static inline struct dentry *debugfs_create_x64(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
u64 *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
|
2009-01-20 23:17:28 +03:00
|
|
|
struct dentry *parent,
|
|
|
|
|
size_t *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-27 13:09:07 +04:00
|
|
|
static inline struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent, atomic_t *value)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct dentry *parent,
|
2015-09-27 01:04:07 +03:00
|
|
|
bool *value)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-24 12:33:43 +04:00
|
|
|
static inline struct dentry *debugfs_create_blob(const char *name, umode_t mode,
|
2006-03-07 13:41:59 +03:00
|
|
|
struct dentry *parent,
|
|
|
|
|
struct debugfs_blob_wrapper *blob)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-18 17:50:21 +04:00
|
|
|
static inline struct dentry *debugfs_create_regset32(const char *name,
|
2012-03-20 14:00:24 +04:00
|
|
|
umode_t mode, struct dentry *parent,
|
2011-11-18 17:50:21 +04:00
|
|
|
struct debugfs_regset32 *regset)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-30 03:08:26 +04:00
|
|
|
static inline void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
|
2013-09-27 13:09:07 +04:00
|
|
|
int nregs, void __iomem *base, char *prefix)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-23 01:10:44 +03:00
|
|
|
static inline bool debugfs_initialized(void)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-23 12:06:28 +04:00
|
|
|
static inline struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
u32 *array, u32 elements)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-09 13:31:58 +03:00
|
|
|
static inline struct dentry *debugfs_create_devm_seqfile(struct device *dev,
|
|
|
|
|
const char *name,
|
|
|
|
|
struct dentry *parent,
|
|
|
|
|
int (*read_fn)(struct seq_file *s,
|
|
|
|
|
void *data))
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-23 16:32:54 +03:00
|
|
|
static inline ssize_t debugfs_read_file_bool(struct file *file,
|
|
|
|
|
char __user *user_buf,
|
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline ssize_t debugfs_write_file_bool(struct file *file,
|
|
|
|
|
const char __user *user_buf,
|
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif
|
