// SPDX-License-Identifier: GPL-2.0

/*

* file.c - part of debugfs, a tiny little debug file system

*

* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>

* Copyright (C) 2004 IBM Inc.

*

* debugfs is for people to use instead of /proc or /sys.

* See Documentation/filesystems/ for more details.

*/

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/seq_file.h>

#include <linux/pagemap.h>

#include <linux/debugfs.h>

#include <linux/io.h>

#include <linux/slab.h>

#include <linux/atomic.h>

#include <linux/device.h>

#include <linux/pm_runtime.h>

#include <linux/poll.h>

#include <linux/security.h>

#include "internal.h"

struct poll_table_struct;

static ssize_t default_read_file(struct file *file, char __user *buf,

size_t count, loff_t *ppos)

{

return 0;

}

static ssize_t default_write_file(struct file *file, const char __user *buf,

size_t count, loff_t *ppos)

{

return count;

}

const struct file_operations debugfs_noop_file_operations = {

.read = default_read_file,

.write = default_write_file,

.open = simple_open,

.llseek = noop_llseek,

};

#define F_DENTRY(filp) ((filp)->f_path.dentry)

void *debugfs_get_aux(const struct file *file)

{

return DEBUGFS_I(file_inode(file))->aux;

}

EXPORT_SYMBOL_GPL(debugfs_get_aux);

enum dbgfs_get_mode {

DBGFS_GET_ALREADY,

DBGFS_GET_REGULAR,

DBGFS_GET_SHORT,

};

static int __debugfs_file_get(struct dentry *dentry, enum dbgfs_get_mode mode)

{

struct debugfs_fsdata *fsd;

void *d_fsd;

/*

* This could only happen if some debugfs user erroneously calls

* debugfs_file_get() on a dentry that isn't even a file, let

* them know about it.

*/

if (WARN_ON(!d_is_reg(dentry)))

return -EINVAL;

d_fsd = READ_ONCE(dentry->d_fsdata);

if (d_fsd) {

fsd = d_fsd;

} else {

struct inode *inode = dentry->d_inode;

unsigned int methods = 0;

if (WARN_ON(mode == DBGFS_GET_ALREADY))

return -EINVAL;

fsd = kmalloc_obj(*fsd);

if (!fsd)

return -ENOMEM;

if (mode == DBGFS_GET_SHORT) {

const struct debugfs_short_fops *ops;

ops = fsd->short_fops = DEBUGFS_I(inode)->short_fops;

if (ops->llseek)

methods |= HAS_LSEEK;

if (ops->read)

methods |= HAS_READ;

if (ops->write)

methods |= HAS_WRITE;

fsd->real_fops = NULL;

} else {

const struct file_operations *ops;

ops = fsd->real_fops = DEBUGFS_I(inode)->real_fops;

if (ops->llseek)

methods |= HAS_LSEEK;

if (ops->read)

methods |= HAS_READ;

if (ops->write)

methods |= HAS_WRITE;

if (ops->unlocked_ioctl)

methods |= HAS_IOCTL;

if (ops->poll)

methods |= HAS_POLL;

fsd->short_fops = NULL;

}

fsd->methods = methods;

refcount_set(&fsd->active_users, 1);

init_completion(&fsd->active_users_drained);

INIT_LIST_HEAD(&fsd->cancellations);

mutex_init(&fsd->cancellations_mtx);

d_fsd = cmpxchg(&dentry->d_fsdata, NULL, fsd);

if (d_fsd) {

mutex_destroy(&fsd->cancellations_mtx);

kfree(fsd);

fsd = d_fsd;

}

}

/*

* In case of a successful cmpxchg() above, this check is

* strictly necessary and must follow it, see the comment in

* __debugfs_remove_file().

* OTOH, if the cmpxchg() hasn't been executed or wasn't

* successful, this serves the purpose of not starving

* removers.

*/

if (d_unlinked(dentry))

return -EIO;

if (!refcount_inc_not_zero(&fsd->active_users))

return -EIO;

return 0;

}

/**

* debugfs_file_get - mark the beginning of file data access

* @dentry: the dentry object whose data is being accessed.

*

* Up to a matching call to debugfs_file_put(), any successive call

* into the file removing functions debugfs_remove() and

* debugfs_remove_recursive() will block. Since associated private

* file data may only get freed after a successful return of any of

* the removal functions, you may safely access it after a successful

* call to debugfs_file_get() without worrying about lifetime issues.

*

* If -%EIO is returned, the file has already been removed and thus,

* it is not safe to access any of its data. If, on the other hand,

* it is allowed to access the file data, zero is returned.

*/

int debugfs_file_get(struct dentry *dentry)

{

return __debugfs_file_get(dentry, DBGFS_GET_ALREADY);

}

EXPORT_SYMBOL_GPL(debugfs_file_get);

/**

* debugfs_file_put - mark the end of file data access

* @dentry: the dentry object formerly passed to

* debugfs_file_get().

*

* Allow any ongoing concurrent call into debugfs_remove() or

* debugfs_remove_recursive() blocked by a former call to

* debugfs_file_get() to proceed and return to its caller.

*/

void debugfs_file_put(struct dentry *dentry)

{

struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata);

if (refcount_dec_and_test(&fsd->active_users))

complete(&fsd->active_users_drained);

}

EXPORT_SYMBOL_GPL(debugfs_file_put);

/**

* debugfs_enter_cancellation - enter a debugfs cancellation

* @file: the file being accessed

* @cancellation: the cancellation object, the cancel callback

* inside of it must be initialized

*

* When a debugfs file is removed it needs to wait for all active

* operations to complete. However, the operation itself may need

* to wait for hardware or completion of some asynchronous process

* or similar. As such, it may need to be cancelled to avoid long

* waits or even deadlocks.

*

* This function can be used inside a debugfs handler that may

* need to be cancelled. As soon as this function is called, the

* cancellation's 'cancel' callback may be called, at which point

* the caller should proceed to call debugfs_leave_cancellation()

* and leave the debugfs handler function as soon as possible.

* Note that the 'cancel' callback is only ever called in the

* context of some kind of debugfs_remove().

*

* This function must be paired with debugfs_leave_cancellation().

*/

void debugfs_enter_cancellation(struct file *file,

struct debugfs_cancellation *cancellation)

{

struct debugfs_fsdata *fsd;

struct dentry *dentry = F_DENTRY(file);

INIT_LIST_HEAD(&cancellation->list);

if (WARN_ON(!d_is_reg(dentry)))

return;

if (WARN_ON(!cancellation->cancel))

return;

fsd = READ_ONCE(dentry->d_fsdata);

if (WARN_ON(!fsd))

return;

mutex_lock(&fsd->cancellations_mtx);

list_add(&cancellation->list, &fsd->cancellations);

mutex_unlock(&fsd->cancellations_mtx);

/* if we're already removing wake it up to cancel */

if (d_unlinked(dentry))

complete(&fsd->active_users_drained);

}

EXPORT_SYMBOL_GPL(debugfs_enter_cancellation);

/**

* debugfs_leave_cancellation - leave cancellation section

* @file: the file being accessed

* @cancellation: the cancellation previously registered with

* debugfs_enter_cancellation()

*

* See the documentation of debugfs_enter_cancellation().

*/

void debugfs_leave_cancellation(struct file *file,

struct debugfs_cancellation *cancellation)

{

struct debugfs_fsdata *fsd;

struct dentry *dentry = F_DENTRY(file);

if (WARN_ON(!d_is_reg(dentry)))

return;

fsd = READ_ONCE(dentry->d_fsdata);

if (WARN_ON(!fsd))

return;

mutex_lock(&fsd->cancellations_mtx);

if (!list_empty(&cancellation->list))

list_del(&cancellation->list);

mutex_unlock(&fsd->cancellations_mtx);

}

EXPORT_SYMBOL_GPL(debugfs_leave_cancellation);

/*

* Only permit access to world-readable files when the kernel is locked down.

* We also need to exclude any file that has ways to write or alter it as root

* can bypass the permissions check.

*/

static int debugfs_locked_down(struct inode *inode,

struct file *filp,

const struct file_operations *real_fops)

{

if ((inode->i_mode & 07777 & ~0444) == 0 &&

!(filp->f_mode & FMODE_WRITE) &&

(!real_fops ||

(!real_fops->unlocked_ioctl &&

!real_fops->compat_ioctl &&

!real_fops->mmap)))

return 0;

if (security_locked_down(LOCKDOWN_DEBUGFS))

return -EPERM;

return 0;

}

static int open_proxy_open(struct inode *inode, struct file *filp)

{

struct dentry *dentry = F_DENTRY(filp);

const struct file_operations *real_fops = DEBUGFS_I(inode)->real_fops;

int r;

r = __debugfs_file_get(dentry, DBGFS_GET_REGULAR);

if (r)

return r == -EIO ? -ENOENT : r;

r = debugfs_locked_down(inode, filp, real_fops);

if (r)

goto out;

if (!fops_get(real_fops)) {

#ifdef CONFIG_MODULES

if (real_fops->owner &&

real_fops->owner->state == MODULE_STATE_GOING) {

r = -ENXIO;

goto out;

}

#endif

/* Huh? Module did not clean up after itself at exit? */

WARN(1, "debugfs file owner did not clean up at exit: %pd",

dentry);

r = -ENXIO;

goto out;

}

replace_fops(filp, real_fops);

if (real_fops->open)

r = real_fops->open(inode, filp);

out:

debugfs_file_put(dentry);

return r;

}

const struct file_operations debugfs_open_proxy_file_operations = {

.open = open_proxy_open,

};

#define PROTO(args...) args

#define ARGS(args...) args

#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args, bit, ret) \

static ret_type full_proxy_ ## name(proto) \

{ \

struct dentry *dentry = F_DENTRY(filp); \

struct debugfs_fsdata *fsd = dentry->d_fsdata; \

ret_type r; \

\

if (!(fsd->methods & bit)) \

return ret; \

r = debugfs_file_get(dentry); \

if (unlikely(r)) \

return r; \

r = fsd->real_fops->name(args); \

debugfs_file_put(dentry); \

return r; \

}

#define SHORT_PROXY_FUNC(name, ret_type, filp, proto, args, bit, ret) \

static ret_type short_proxy_ ## name(proto) \

{ \

struct dentry *dentry = F_DENTRY(filp); \

struct debugfs_fsdata *fsd = dentry->d_fsdata; \

ret_type r; \

\

if (!(fsd->methods & bit)) \

return ret; \

r = debugfs_file_get(dentry); \

if (unlikely(r)) \

return r; \

r = fsd->short_fops->name(args); \

debugfs_file_put(dentry); \

return r; \

}

SHORT_PROXY_FUNC(llseek, loff_t, filp,

PROTO(struct file *filp, loff_t offset, int whence),

ARGS(filp, offset, whence), HAS_LSEEK, -ESPIPE);

FULL_PROXY_FUNC(llseek, loff_t, filp,

PROTO(struct file *filp, loff_t offset, int whence),

ARGS(filp, offset, whence), HAS_LSEEK, -ESPIPE);

SHORT_PROXY_FUNC(read, ssize_t, filp,

PROTO(struct file *filp, char __user *buf, size_t size,

loff_t *ppos),

ARGS(filp, buf, size, ppos), HAS_READ, -EINVAL);

FULL_PROXY_FUNC(read, ssize_t, filp,

PROTO(struct file *filp, char __user *buf, size_t size,

loff_t *ppos),

ARGS(filp, buf, size, ppos), HAS_READ, -EINVAL);

SHORT_PROXY_FUNC(write, ssize_t, filp,

PROTO(struct file *filp, const char __user *buf,

size_t size, loff_t *ppos),

ARGS(filp, buf, size, ppos), HAS_WRITE, -EINVAL);

FULL_PROXY_FUNC(write, ssize_t, filp,

PROTO(struct file *filp, const char __user *buf,

size_t size, loff_t *ppos),

ARGS(filp, buf, size, ppos), HAS_WRITE, -EINVAL);

FULL_PROXY_FUNC(unlocked_ioctl, long, filp,

PROTO(struct file *filp, unsigned int cmd, unsigned long arg),

ARGS(filp, cmd, arg), HAS_IOCTL, -ENOTTY);

static __poll_t full_proxy_poll(struct file *filp,

struct poll_table_struct *wait)

{

struct dentry *dentry = F_DENTRY(filp);

struct debugfs_fsdata *fsd = dentry->d_fsdata;

__poll_t r = 0;

if (!(fsd->methods & HAS_POLL))

return DEFAULT_POLLMASK;

if (debugfs_file_get(dentry))

return EPOLLHUP;

r = fsd->real_fops->poll(filp, wait);

debugfs_file_put(dentry);

return r;

}

static int full_proxy_release(struct inode *inode, struct file *file)

{

struct debugfs_fsdata *fsd = F_DENTRY(file)->d_fsdata;

const struct file_operations *real_fops = fsd->real_fops;

int r = 0;

/*

* We must not protect this against removal races here: the

* original releaser should be called unconditionally in order

* not to leak any resources. Releasers must not assume that

* ->i_private is still being meaningful here.

*/

if (real_fops->release)

r = real_fops->release(inode, file);

fops_put(real_fops);

return r;

}

static int full_proxy_open_regular(struct inode *inode, struct file *filp)

{

struct dentry *dentry = F_DENTRY(filp);

const struct file_operations *real_fops;

struct debugfs_fsdata *fsd;

int r;

r = __debugfs_file_get(dentry, DBGFS_GET_REGULAR);

if (r)

return r == -EIO ? -ENOENT : r;

fsd = dentry->d_fsdata;

real_fops = fsd->real_fops;

r = debugfs_locked_down(inode, filp, real_fops);

if (r)

goto out;

if (!fops_get(real_fops)) {

#ifdef CONFIG_MODULES

if (real_fops->owner &&

real_fops->owner->state == MODULE_STATE_GOING) {

r = -ENXIO;

goto out;

}

#endif

/* Huh? Module did not cleanup after itself at exit? */

WARN(1, "debugfs file owner did not clean up at exit: %pd",

dentry);

r = -ENXIO;

goto out;

}

if (real_fops->open) {

r = real_fops->open(inode, filp);

if (r) {

fops_put(real_fops);

} else if (filp->f_op != &debugfs_full_proxy_file_operations) {

/* No protection against file removal anymore. */

WARN(1, "debugfs file owner replaced proxy fops: %pd",

dentry);

fops_put(real_fops);

}

}

out:

debugfs_file_put(dentry);

return r;

}

const struct file_operations debugfs_full_proxy_file_operations = {

.open = full_proxy_open_regular,

.release = full_proxy_release,

.llseek = full_proxy_llseek,

.read = full_proxy_read,

.write = full_proxy_write,

.poll = full_proxy_poll,

.unlocked_ioctl = full_proxy_unlocked_ioctl

};

static int full_proxy_open_short(struct inode *inode, struct file *filp)

{

struct dentry *dentry = F_DENTRY(filp);

int r;

r = __debugfs_file_get(dentry, DBGFS_GET_SHORT);

if (r)

return r == -EIO ? -ENOENT : r;

r = debugfs_locked_down(inode, filp, NULL);

if (!r)

r = simple_open(inode, filp);

debugfs_file_put(dentry);

return r;

}

const struct file_operations debugfs_full_short_proxy_file_operations = {

.open = full_proxy_open_short,

.llseek = short_proxy_llseek,

.read = short_proxy_read,

.write = short_proxy_write,

};

ssize_t debugfs_attr_read(struct file *file, char __user *buf,

size_t len, loff_t *ppos)

{

struct dentry *dentry = F_DENTRY(file);

ssize_t ret;

ret = debugfs_file_get(dentry);

if (unlikely(ret))

return ret;

ret = simple_attr_read(file, buf, len, ppos);

debugfs_file_put(dentry);

return ret;

}

EXPORT_SYMBOL_GPL(debugfs_attr_read);

static ssize_t debugfs_attr_write_xsigned(struct file *file, const char __user *buf,

size_t len, loff_t *ppos, bool is_signed)

{

struct dentry *dentry = F_DENTRY(file);

ssize_t ret;

ret = debugfs_file_get(dentry);

if (unlikely(ret))

return ret;

if (is_signed)

ret = simple_attr_write_signed(file, buf, len, ppos);

else

ret = simple_attr_write(file, buf, len, ppos);

debugfs_file_put(dentry);

return ret;

}

ssize_t debugfs_attr_write(struct file *file, const char __user *buf,

size_t len, loff_t *ppos)

{

return debugfs_attr_write_xsigned(file, buf, len, ppos, false);

}

EXPORT_SYMBOL_GPL(debugfs_attr_write);

ssize_t debugfs_attr_write_signed(struct file *file, const char __user *buf,

size_t len, loff_t *ppos)

{

return debugfs_attr_write_xsigned(file, buf, len, ppos, true);

}

EXPORT_SYMBOL_GPL(debugfs_attr_write_signed);

static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,

struct dentry *parent, void *value,

const struct file_operations *fops,

const struct file_operations *fops_ro,

const struct file_operations *fops_wo)

{

/* if there are no write bits set, make read only */

if (!(mode & S_IWUGO))

return debugfs_create_file_unsafe(name, mode, parent, value,

fops_ro);

/* if there are no read bits set, make write only */

if (!(mode & S_IRUGO))

return debugfs_create_file_unsafe(name, mode, parent, value,

fops_wo);

return debugfs_create_file_unsafe(name, mode, parent, value, fops);

}

static int debugfs_u8_set(void *data, u64 val)

{

*(u8 *)data = val;

return 0;

}

static int debugfs_u8_get(void *data, u64 *val)

{

*val = *(u8 *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");

/**

* debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*

* This function creates a file in debugfs with the given name that

* contains the value of the variable @value. If the @mode variable is so

* set, it can be read from, and written to.

*/

void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,

u8 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,

&fops_u8_ro, &fops_u8_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_u8);

static int debugfs_u16_set(void *data, u64 val)

{

*(u16 *)data = val;

return 0;

}

static int debugfs_u16_get(void *data, u64 *val)

{

*val = *(u16 *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");

/**

* debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*

* This function creates a file in debugfs with the given name that

* contains the value of the variable @value. If the @mode variable is so

* set, it can be read from, and written to.

*/

void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,

u16 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,

&fops_u16_ro, &fops_u16_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_u16);

static int debugfs_u32_set(void *data, u64 val)

{

*(u32 *)data = val;

return 0;

}

static int debugfs_u32_get(void *data, u64 *val)

{

*val = *(u32 *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");

/**

* debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*

* This function creates a file in debugfs with the given name that

* contains the value of the variable @value. If the @mode variable is so

* set, it can be read from, and written to.

*/

void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,

u32 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,

&fops_u32_ro, &fops_u32_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_u32);

static int debugfs_u64_set(void *data, u64 val)

{

*(u64 *)data = val;

return 0;

}

static int debugfs_u64_get(void *data, u64 *val)

{

*val = *(u64 *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");

/**

* debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*

* This function creates a file in debugfs with the given name that

* contains the value of the variable @value. If the @mode variable is so

* set, it can be read from, and written to.

*/

void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,

u64 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,

&fops_u64_ro, &fops_u64_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_u64);

static int debugfs_ulong_set(void *data, u64 val)

{

*(unsigned long *)data = val;

return 0;

}

static int debugfs_ulong_get(void *data, u64 *val)

{

*val = *(unsigned long *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,

"%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");

/**

* debugfs_create_ulong - create a debugfs file that is used to read and write

* an unsigned long value.

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*

* This function creates a file in debugfs with the given name that

* contains the value of the variable @value. If the @mode variable is so

* set, it can be read from, and written to.

*/

void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent,

unsigned long *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_ulong,

&fops_ulong_ro, &fops_ulong_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_ulong);

DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,

"0x%04llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,

"0x%08llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,

"0x%016llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");

/*

* debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value

*

* These functions are exactly the same as the above functions (but use a hex

* output for the decimal challenged). For details look at the above unsigned

* decimal functions.

*/

/**

* debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,

u8 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,

&fops_x8_ro, &fops_x8_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_x8);

/**

* debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,

u16 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,

&fops_x16_ro, &fops_x16_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_x16);

/**

* debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,

u32 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,

&fops_x32_ro, &fops_x32_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_x32);

/**

* debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,

u64 *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,

&fops_x64_ro, &fops_x64_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_x64);

static int debugfs_size_t_set(void *data, u64 val)

{

*(size_t *)data = val;

return 0;

}

static int debugfs_size_t_get(void *data, u64 *val)

{

*val = *(size_t *)data;

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,

"%llu\n"); /* %llu and %zu are more or less the same */

DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");

DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");

/**

* debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_size_t(const char *name, umode_t mode,

struct dentry *parent, size_t *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,

&fops_size_t_ro, &fops_size_t_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_size_t);

static int debugfs_atomic_t_set(void *data, u64 val)

{

atomic_set((atomic_t *)data, val);

return 0;

}

static int debugfs_atomic_t_get(void *data, u64 *val)

{

*val = atomic_read((atomic_t *)data);

return 0;

}

DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t, debugfs_atomic_t_get,

debugfs_atomic_t_set, "%lld\n");

DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,

"%lld\n");

DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,

"%lld\n");

/**

* debugfs_create_atomic_t - create a debugfs file that is used to read and

* write an atomic_t value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.

* @value: a pointer to the variable that the file should read to and write

* from.

*/

void debugfs_create_atomic_t(const char *name, umode_t mode,

struct dentry *parent, atomic_t *value)

{

debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,

&fops_atomic_t_ro, &fops_atomic_t_wo);

}

EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);

ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,

size_t count, loff_t *ppos)

{

char buf[2];

bool val;

int r;

struct dentry *dentry = F_DENTRY(file);

r = debugfs_file_get(dentry);

if (unlikely(r))

return r;

val = *(bool *)file->private_data;

debugfs_file_put(dentry);

if (val)

buf[0] = 'Y';

else

buf[0] = 'N';

buf[1] = '\n';

return simple_read_from_buffer(user_buf, count, ppos, buf, 2);

}

EXPORT_SYMBOL_GPL(debugfs_read_file_bool);

ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,

size_t count, loff_t *ppos)

{

bool bv;

int r;

bool *val = file->private_data;

struct dentry *dentry = F_DENTRY(file);

r = kstrtobool_from_user(user_buf, count, &bv);

if (!r) {

r = debugfs_file_get(dentry);

if (unlikely(r))

return r;

*val = bv;

debugfs_file_put(dentry);

}

return count;

}

EXPORT_SYMBOL_GPL(debugfs_write_file_bool);

static const struct file_operations fops_bool = {

.read = debugfs_read_file_bool,

.write = debugfs_write_file_bool,

.open = simple_open,

.llseek = default_llseek,

};

static const struct file_operations fops_bool_ro = {

.read = debugfs_read_file_bool,

.open = simple_open,

.llseek = default_llseek,

};

static const struct file_operations fops_bool_wo = {

.write = debugfs_write_file_bool,

.open = simple_open,

.llseek = default_llseek,

};

/**

* debugfs_create_bool - create a debugfs file that is used to read and write a boolean value

* @name: a pointer to a string containing the name of the file to create.

* @mode: the permission that the file should have

* @parent: a pointer to the parent dentry for this file. This should be a

* directory dentry if set. If this parameter is %NULL, then the

* file will be created in the root of the debugfs filesystem.