include/linux/debugfs.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  debugfs.h - a tiny little debug file system
   4  *
   5  *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
   6  *  Copyright (C) 2004 IBM Inc.
   7  *
   8  *  debugfs is for people to use instead of /proc or /sys.
   9  *  See Documentation/filesystems/ for more details.
  10  */
  11
  12 #ifndef _DEBUGFS_H_
  13 #define _DEBUGFS_H_
  14
  15 #include <linux/fs.h>
  16 #include <linux/seq_file.h>
  17
  18 #include <linux/types.h>
  19 #include <linux/compiler.h>
  20
  21 struct device;
  22 struct file_operations;
  23
  24 struct debugfs_blob_wrapper {
  25         void *data;
  26         unsigned long size;
  27 };
  28
  29 struct debugfs_reg32 {
  30         char *name;
  31         unsigned long offset;
  32 };
  33
  34 struct debugfs_regset32 {
  35         const struct debugfs_reg32 *regs;
  36         int nregs;
  37         void __iomem *base;
  38         struct device *dev;     /* Optional device for Runtime PM */
  39 };
  40
  41 struct debugfs_u32_array {
  42         u32 *array;
  43         u32 n_elements;
  44 };
  45
  46 extern struct dentry *arch_debugfs_dir;
  47
  48 #define DEFINE_DEBUGFS_ATTRIBUTE(__fops, __get, __set, __fmt)           \
  49 static int __fops ## _open(struct inode *inode, struct file *file)      \
  50 {                                                                       \
  51         __simple_attr_check_format(__fmt, 0ull);                        \
  52         return simple_attr_open(inode, file, __get, __set, __fmt);      \
  53 }                                                                       \
  54 static const struct file_operations __fops = {                          \
  55         .owner   = THIS_MODULE,                                         \
  56         .open    = __fops ## _open,                                     \
  57         .release = simple_attr_release,                                 \
  58         .read    = debugfs_attr_read,                                   \
  59         .write   = debugfs_attr_write,                                  \
  60         .llseek  = no_llseek,                                           \
  61 }
  62
  63 typedef struct vfsmount *(*debugfs_automount_t)(struct dentry *, void *);
  64
  65 #if defined(CONFIG_DEBUG_FS)
  66
  67 struct dentry *debugfs_lookup(const char *name, struct dentry *parent);
  68
  69 struct dentry *debugfs_create_file(const char *name, umode_t mode,
  70                                    struct dentry *parent, void *data,
  71                                    const struct file_operations *fops);
  72 struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
  73                                    struct dentry *parent, void *data,
  74                                    const struct file_operations *fops);
  75
  76 void debugfs_create_file_size(const char *name, umode_t mode,
  77                               struct dentry *parent, void *data,
  78                               const struct file_operations *fops,
  79                               loff_t file_size);
  80
  81 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
  82
  83 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
  84                                       const char *dest);
  85
  86 struct dentry *debugfs_create_automount(const char *name,
  87                                         struct dentry *parent,
  88                                         debugfs_automount_t f,
  89                                         void *data);
  90
  91 void debugfs_remove(struct dentry *dentry);
  92 #define debugfs_remove_recursive debugfs_remove
  93
  94 void debugfs_lookup_and_remove(const char *name, struct dentry *parent);
  95
  96 const struct file_operations *debugfs_real_fops(const struct file *filp);
  97
  98 int debugfs_file_get(struct dentry *dentry);
  99 void debugfs_file_put(struct dentry *dentry);
 100
 101 ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 102                         size_t len, loff_t *ppos);
 103 ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
 104                         size_t len, loff_t *ppos);
 105
 106 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
 107                 struct dentry *new_dir, const char *new_name);
 108
 109 void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
 110                        u8 *value);
 111 void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
 112                         u16 *value);
 113 void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,
 114                         u32 *value);
 115 void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
 116                         u64 *value);
 117 void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent,
 118                           unsigned long *value);
 119 void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
 120                        u8 *value);
 121 void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
 122                         u16 *value);
 123 void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
 124                         u32 *value);
 125 void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
 126                         u64 *value);
 127 void debugfs_create_size_t(const char *name, umode_t mode,
 128                            struct dentry *parent, size_t *value);
 129 void debugfs_create_atomic_t(const char *name, umode_t mode,
 130                              struct dentry *parent, atomic_t *value);
 131 void debugfs_create_bool(const char *name, umode_t mode, struct dentry *parent,
 132                          bool *value);
 133 void debugfs_create_str(const char *name, umode_t mode,
 134                         struct dentry *parent, char **value);
 135
 136 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 137                                   struct dentry *parent,
 138                                   struct debugfs_blob_wrapper *blob);
 139
 140 void debugfs_create_regset32(const char *name, umode_t mode,
 141                              struct dentry *parent,
 142                              struct debugfs_regset32 *regset);
 143
 144 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
 145                           int nregs, void __iomem *base, char *prefix);
 146
 147 void debugfs_create_u32_array(const char *name, umode_t mode,
 148                               struct dentry *parent,
 149                               struct debugfs_u32_array *array);
 150
 151 void debugfs_create_devm_seqfile(struct device *dev, const char *name,
 152                                  struct dentry *parent,
 153                                  int (*read_fn)(struct seq_file *s, void *data));
 154
 155 bool debugfs_initialized(void);
 156
 157 ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 158                                size_t count, loff_t *ppos);
 159
 160 ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 161                                 size_t count, loff_t *ppos);
 162
 163 ssize_t debugfs_read_file_str(struct file *file, char __user *user_buf,
 164                               size_t count, loff_t *ppos);
 165
 166 #else
 167
 168 #include <linux/err.h>
 169
 170 /*
 171  * We do not return NULL from these functions if CONFIG_DEBUG_FS is not enabled
 172  * so users have a chance to detect if there was a real error or not.  We don't
 173  * want to duplicate the design decision mistakes of procfs and devfs again.
 174  */
 175
 176 static inline struct dentry *debugfs_lookup(const char *name,
 177                                             struct dentry *parent)
 178 {
 179         return ERR_PTR(-ENODEV);
 180 }
 181
 182 static inline struct dentry *debugfs_create_file(const char *name, umode_t mode,
 183                                         struct dentry *parent, void *data,
 184                                         const struct file_operations *fops)
 185 {
 186         return ERR_PTR(-ENODEV);
 187 }
 188
 189 static inline struct dentry *debugfs_create_file_unsafe(const char *name,
 190                                         umode_t mode, struct dentry *parent,
 191                                         void *data,
 192                                         const struct file_operations *fops)
 193 {
 194         return ERR_PTR(-ENODEV);
 195 }
 196
 197 static inline void debugfs_create_file_size(const char *name, umode_t mode,
 198                                             struct dentry *parent, void *data,
 199                                             const struct file_operations *fops,
 200                                             loff_t file_size)
 201 { }
 202
 203 static inline struct dentry *debugfs_create_dir(const char *name,
 204                                                 struct dentry *parent)
 205 {
 206         return ERR_PTR(-ENODEV);
 207 }
 208
 209 static inline struct dentry *debugfs_create_symlink(const char *name,
 210                                                     struct dentry *parent,
 211                                                     const char *dest)
 212 {
 213         return ERR_PTR(-ENODEV);
 214 }
 215
 216 static inline struct dentry *debugfs_create_automount(const char *name,
 217                                         struct dentry *parent,
 218                                         debugfs_automount_t f,
 219                                         void *data)
 220 {
 221         return ERR_PTR(-ENODEV);
 222 }
 223
 224 static inline void debugfs_remove(struct dentry *dentry)
 225 { }
 226
 227 static inline void debugfs_remove_recursive(struct dentry *dentry)
 228 { }
 229
 230 static inline void debugfs_lookup_and_remove(const char *name,
 231                                              struct dentry *parent)
 232 { }
 233
 234 const struct file_operations *debugfs_real_fops(const struct file *filp);
 235
 236 static inline int debugfs_file_get(struct dentry *dentry)
 237 {
 238         return 0;
 239 }
 240
 241 static inline void debugfs_file_put(struct dentry *dentry)
 242 { }
 243
 244 static inline ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 245                                         size_t len, loff_t *ppos)
 246 {
 247         return -ENODEV;
 248 }
 249
 250 static inline ssize_t debugfs_attr_write(struct file *file,
 251                                         const char __user *buf,
 252                                         size_t len, loff_t *ppos)
 253 {
 254         return -ENODEV;
 255 }
 256
 257 static inline struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
 258                 struct dentry *new_dir, char *new_name)
 259 {
 260         return ERR_PTR(-ENODEV);
 261 }
 262
 263 static inline void debugfs_create_u8(const char *name, umode_t mode,
 264                                      struct dentry *parent, u8 *value) { }
 265
 266 static inline void debugfs_create_u16(const char *name, umode_t mode,
 267                                       struct dentry *parent, u16 *value) { }
 268
 269 static inline void debugfs_create_u32(const char *name, umode_t mode,
 270                                       struct dentry *parent, u32 *value) { }
 271
 272 static inline void debugfs_create_u64(const char *name, umode_t mode,
 273                                       struct dentry *parent, u64 *value) { }
 274
 275 static inline void debugfs_create_ulong(const char *name, umode_t mode,
 276                                         struct dentry *parent,
 277                                         unsigned long *value) { }
 278
 279 static inline void debugfs_create_x8(const char *name, umode_t mode,
 280                                      struct dentry *parent, u8 *value) { }
 281
 282 static inline void debugfs_create_x16(const char *name, umode_t mode,
 283                                       struct dentry *parent, u16 *value) { }
 284
 285 static inline void debugfs_create_x32(const char *name, umode_t mode,
 286                                       struct dentry *parent, u32 *value) { }
 287
 288 static inline void debugfs_create_x64(const char *name, umode_t mode,
 289                                       struct dentry *parent, u64 *value) { }
 290
 291 static inline void debugfs_create_size_t(const char *name, umode_t mode,
 292                                          struct dentry *parent, size_t *value)
 293 { }
 294
 295 static inline void debugfs_create_atomic_t(const char *name, umode_t mode,
 296                                            struct dentry *parent,
 297                                            atomic_t *value)
 298 { }
 299
 300 static inline void debugfs_create_bool(const char *name, umode_t mode,
 301                                        struct dentry *parent, bool *value) { }
 302
 303 static inline void debugfs_create_str(const char *name, umode_t mode,
 304                                       struct dentry *parent,
 305                                       char **value)
 306 { }
 307
 308 static inline struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 309                                   struct dentry *parent,
 310                                   struct debugfs_blob_wrapper *blob)
 311 {
 312         return ERR_PTR(-ENODEV);
 313 }
 314
 315 static inline void debugfs_create_regset32(const char *name, umode_t mode,
 316                                            struct dentry *parent,
 317                                            struct debugfs_regset32 *regset)
 318 {
 319 }
 320
 321 static inline void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
 322                          int nregs, void __iomem *base, char *prefix)
 323 {
 324 }
 325
 326 static inline bool debugfs_initialized(void)
 327 {
 328         return false;
 329 }
 330
 331 static inline void debugfs_create_u32_array(const char *name, umode_t mode,
 332                                             struct dentry *parent,
 333                                             struct debugfs_u32_array *array)
 334 {
 335 }
 336
 337 static inline void debugfs_create_devm_seqfile(struct device *dev,
 338                                                const char *name,
 339                                                struct dentry *parent,
 340                                                int (*read_fn)(struct seq_file *s,
 341                                                               void *data))
 342 {
 343 }
 344
 345 static inline ssize_t debugfs_read_file_bool(struct file *file,
 346                                              char __user *user_buf,
 347                                              size_t count, loff_t *ppos)
 348 {
 349         return -ENODEV;
 350 }
 351
 352 static inline ssize_t debugfs_write_file_bool(struct file *file,
 353                                               const char __user *user_buf,
 354                                               size_t count, loff_t *ppos)
 355 {
 356         return -ENODEV;
 357 }
 358
 359 static inline ssize_t debugfs_read_file_str(struct file *file,
 360                                             char __user *user_buf,
 361                                             size_t count, loff_t *ppos)
 362 {
 363         return -ENODEV;
 364 }
 365
 366 #endif
 367
 368 /**
 369  * debugfs_create_xul - create a debugfs file that is used to read and write an
 370  * unsigned long value, formatted in hexadecimal
 371  * @name: a pointer to a string containing the name of the file to create.
 372  * @mode: the permission that the file should have
 373  * @parent: a pointer to the parent dentry for this file.  This should be a
 374  *          directory dentry if set.  If this parameter is %NULL, then the
 375  *          file will be created in the root of the debugfs filesystem.
 376  * @value: a pointer to the variable that the file should read to and write
 377  *         from.
 378  */
 379 static inline void debugfs_create_xul(const char *name, umode_t mode,
 380                                       struct dentry *parent,
 381                                       unsigned long *value)
 382 {
 383         if (sizeof(*value) == sizeof(u32))
 384                 debugfs_create_x32(name, mode, parent, (u32 *)value);
 385         else
 386                 debugfs_create_x64(name, mode, parent, (u64 *)value);
 387 }
 388
 389 #endif