1 /* 2 * file.c - part of debugfs, a tiny little debug file system 3 * 4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> 5 * Copyright (C) 2004 IBM Inc. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * debugfs is for people to use instead of /proc or /sys. 12 * See Documentation/DocBook/kernel-api for more details. 13 * 14 */ 15 16 /* uncomment to get debug messages from the debug filesystem, ah the irony. */ 17 /* #define DEBUG */ 18 19 #include <linux/module.h> 20 #include <linux/fs.h> 21 #include <linux/mount.h> 22 #include <linux/pagemap.h> 23 #include <linux/init.h> 24 #include <linux/kobject.h> 25 #include <linux/namei.h> 26 #include <linux/debugfs.h> 27 #include <linux/fsnotify.h> 28 #include <linux/string.h> 29 30 #define DEBUGFS_MAGIC 0x64626720 31 32 static struct vfsmount *debugfs_mount; 33 static int debugfs_mount_count; 34 35 static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev) 36 { 37 struct inode *inode = new_inode(sb); 38 39 if (inode) { 40 inode->i_mode = mode; 41 inode->i_uid = 0; 42 inode->i_gid = 0; 43 inode->i_blocks = 0; 44 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 45 switch (mode & S_IFMT) { 46 default: 47 init_special_inode(inode, mode, dev); 48 break; 49 case S_IFREG: 50 inode->i_fop = &debugfs_file_operations; 51 break; 52 case S_IFLNK: 53 inode->i_op = &debugfs_link_operations; 54 break; 55 case S_IFDIR: 56 inode->i_op = &simple_dir_inode_operations; 57 inode->i_fop = &simple_dir_operations; 58 59 /* directory inodes start off with i_nlink == 2 60 * (for "." entry) */ 61 inc_nlink(inode); 62 break; 63 } 64 } 65 return inode; 66 } 67 68 /* SMP-safe */ 69 static int debugfs_mknod(struct inode *dir, struct dentry *dentry, 70 int mode, dev_t dev) 71 { 72 struct inode *inode; 73 int error = -EPERM; 74 75 if (dentry->d_inode) 76 return -EEXIST; 77 78 inode = debugfs_get_inode(dir->i_sb, mode, dev); 79 if (inode) { 80 d_instantiate(dentry, inode); 81 dget(dentry); 82 error = 0; 83 } 84 return error; 85 } 86 87 static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 88 { 89 int res; 90 91 mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR; 92 res = debugfs_mknod(dir, dentry, mode, 0); 93 if (!res) { 94 inc_nlink(dir); 95 fsnotify_mkdir(dir, dentry); 96 } 97 return res; 98 } 99 100 static int debugfs_link(struct inode *dir, struct dentry *dentry, int mode) 101 { 102 mode = (mode & S_IALLUGO) | S_IFLNK; 103 return debugfs_mknod(dir, dentry, mode, 0); 104 } 105 106 static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode) 107 { 108 int res; 109 110 mode = (mode & S_IALLUGO) | S_IFREG; 111 res = debugfs_mknod(dir, dentry, mode, 0); 112 if (!res) 113 fsnotify_create(dir, dentry); 114 return res; 115 } 116 117 static inline int debugfs_positive(struct dentry *dentry) 118 { 119 return dentry->d_inode && !d_unhashed(dentry); 120 } 121 122 static int debug_fill_super(struct super_block *sb, void *data, int silent) 123 { 124 static struct tree_descr debug_files[] = {{""}}; 125 126 return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files); 127 } 128 129 static int debug_get_sb(struct file_system_type *fs_type, 130 int flags, const char *dev_name, 131 void *data, struct vfsmount *mnt) 132 { 133 return get_sb_single(fs_type, flags, data, debug_fill_super, mnt); 134 } 135 136 static struct file_system_type debug_fs_type = { 137 .owner = THIS_MODULE, 138 .name = "debugfs", 139 .get_sb = debug_get_sb, 140 .kill_sb = kill_litter_super, 141 }; 142 143 static int debugfs_create_by_name(const char *name, mode_t mode, 144 struct dentry *parent, 145 struct dentry **dentry) 146 { 147 int error = 0; 148 149 /* If the parent is not specified, we create it in the root. 150 * We need the root dentry to do this, which is in the super 151 * block. A pointer to that is in the struct vfsmount that we 152 * have around. 153 */ 154 if (!parent) { 155 if (debugfs_mount && debugfs_mount->mnt_sb) { 156 parent = debugfs_mount->mnt_sb->s_root; 157 } 158 } 159 if (!parent) { 160 pr_debug("debugfs: Ah! can not find a parent!\n"); 161 return -EFAULT; 162 } 163 164 *dentry = NULL; 165 mutex_lock(&parent->d_inode->i_mutex); 166 *dentry = lookup_one_len(name, parent, strlen(name)); 167 if (!IS_ERR(*dentry)) { 168 switch (mode & S_IFMT) { 169 case S_IFDIR: 170 error = debugfs_mkdir(parent->d_inode, *dentry, mode); 171 break; 172 case S_IFLNK: 173 error = debugfs_link(parent->d_inode, *dentry, mode); 174 break; 175 default: 176 error = debugfs_create(parent->d_inode, *dentry, mode); 177 break; 178 } 179 dput(*dentry); 180 } else 181 error = PTR_ERR(*dentry); 182 mutex_unlock(&parent->d_inode->i_mutex); 183 184 return error; 185 } 186 187 /** 188 * debugfs_create_file - create a file in the debugfs filesystem 189 * @name: a pointer to a string containing the name of the file to create. 190 * @mode: the permission that the file should have 191 * @parent: a pointer to the parent dentry for this file. This should be a 192 * directory dentry if set. If this paramater is NULL, then the 193 * file will be created in the root of the debugfs filesystem. 194 * @data: a pointer to something that the caller will want to get to later 195 * on. The inode.i_private pointer will point to this value on 196 * the open() call. 197 * @fops: a pointer to a struct file_operations that should be used for 198 * this file. 199 * 200 * This is the basic "create a file" function for debugfs. It allows for a 201 * wide range of flexibility in createing a file, or a directory (if you 202 * want to create a directory, the debugfs_create_dir() function is 203 * recommended to be used instead.) 204 * 205 * This function will return a pointer to a dentry if it succeeds. This 206 * pointer must be passed to the debugfs_remove() function when the file is 207 * to be removed (no automatic cleanup happens if your module is unloaded, 208 * you are responsible here.) If an error occurs, %NULL will be returned. 209 * 210 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 211 * returned. 212 */ 213 struct dentry *debugfs_create_file(const char *name, mode_t mode, 214 struct dentry *parent, void *data, 215 const struct file_operations *fops) 216 { 217 struct dentry *dentry = NULL; 218 int error; 219 220 pr_debug("debugfs: creating file '%s'\n",name); 221 222 error = simple_pin_fs(&debug_fs_type, &debugfs_mount, 223 &debugfs_mount_count); 224 if (error) 225 goto exit; 226 227 error = debugfs_create_by_name(name, mode, parent, &dentry); 228 if (error) { 229 dentry = NULL; 230 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 231 goto exit; 232 } 233 234 if (dentry->d_inode) { 235 if (data) 236 dentry->d_inode->i_private = data; 237 if (fops) 238 dentry->d_inode->i_fop = fops; 239 } 240 exit: 241 return dentry; 242 } 243 EXPORT_SYMBOL_GPL(debugfs_create_file); 244 245 /** 246 * debugfs_create_dir - create a directory in the debugfs filesystem 247 * @name: a pointer to a string containing the name of the directory to 248 * create. 249 * @parent: a pointer to the parent dentry for this file. This should be a 250 * directory dentry if set. If this paramater is NULL, then the 251 * directory will be created in the root of the debugfs filesystem. 252 * 253 * This function creates a directory in debugfs with the given name. 254 * 255 * This function will return a pointer to a dentry if it succeeds. This 256 * pointer must be passed to the debugfs_remove() function when the file is 257 * to be removed (no automatic cleanup happens if your module is unloaded, 258 * you are responsible here.) If an error occurs, %NULL will be returned. 259 * 260 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 261 * returned. 262 */ 263 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) 264 { 265 return debugfs_create_file(name, 266 S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, 267 parent, NULL, NULL); 268 } 269 EXPORT_SYMBOL_GPL(debugfs_create_dir); 270 271 /** 272 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem 273 * @name: a pointer to a string containing the name of the symbolic link to 274 * create. 275 * @parent: a pointer to the parent dentry for this symbolic link. This 276 * should be a directory dentry if set. If this paramater is NULL, 277 * then the symbolic link will be created in the root of the debugfs 278 * filesystem. 279 * @target: a pointer to a string containing the path to the target of the 280 * symbolic link. 281 * 282 * This function creates a symbolic link with the given name in debugfs that 283 * links to the given target path. 284 * 285 * This function will return a pointer to a dentry if it succeeds. This 286 * pointer must be passed to the debugfs_remove() function when the symbolic 287 * link is to be removed (no automatic cleanup happens if your module is 288 * unloaded, you are responsible here.) If an error occurs, %NULL will be 289 * returned. 290 * 291 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 292 * returned. 293 */ 294 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, 295 const char *target) 296 { 297 struct dentry *result; 298 char *link; 299 300 link = kstrdup(target, GFP_KERNEL); 301 if (!link) 302 return NULL; 303 304 result = debugfs_create_file(name, S_IFLNK | S_IRWXUGO, parent, link, 305 NULL); 306 if (!result) 307 kfree(link); 308 return result; 309 } 310 EXPORT_SYMBOL_GPL(debugfs_create_symlink); 311 312 /** 313 * debugfs_remove - removes a file or directory from the debugfs filesystem 314 * @dentry: a pointer to a the dentry of the file or directory to be 315 * removed. 316 * 317 * This function removes a file or directory in debugfs that was previously 318 * created with a call to another debugfs function (like 319 * debugfs_create_file() or variants thereof.) 320 * 321 * This function is required to be called in order for the file to be 322 * removed, no automatic cleanup of files will happen when a module is 323 * removed, you are responsible here. 324 */ 325 void debugfs_remove(struct dentry *dentry) 326 { 327 struct dentry *parent; 328 int ret = 0; 329 330 if (!dentry) 331 return; 332 333 parent = dentry->d_parent; 334 if (!parent || !parent->d_inode) 335 return; 336 337 mutex_lock(&parent->d_inode->i_mutex); 338 if (debugfs_positive(dentry)) { 339 if (dentry->d_inode) { 340 dget(dentry); 341 switch (dentry->d_inode->i_mode & S_IFMT) { 342 case S_IFDIR: 343 ret = simple_rmdir(parent->d_inode, dentry); 344 break; 345 case S_IFLNK: 346 kfree(dentry->d_inode->i_private); 347 /* fall through */ 348 default: 349 simple_unlink(parent->d_inode, dentry); 350 break; 351 } 352 if (!ret) 353 d_delete(dentry); 354 dput(dentry); 355 } 356 } 357 mutex_unlock(&parent->d_inode->i_mutex); 358 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 359 } 360 EXPORT_SYMBOL_GPL(debugfs_remove); 361 362 /** 363 * debugfs_rename - rename a file/directory in the debugfs filesystem 364 * @old_dir: a pointer to the parent dentry for the renamed object. This 365 * should be a directory dentry. 366 * @old_dentry: dentry of an object to be renamed. 367 * @new_dir: a pointer to the parent dentry where the object should be 368 * moved. This should be a directory dentry. 369 * @new_name: a pointer to a string containing the target name. 370 * 371 * This function renames a file/directory in debugfs. The target must not 372 * exist for rename to succeed. 373 * 374 * This function will return a pointer to old_dentry (which is updated to 375 * reflect renaming) if it succeeds. If an error occurs, %NULL will be 376 * returned. 377 * 378 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 379 * returned. 380 */ 381 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry, 382 struct dentry *new_dir, const char *new_name) 383 { 384 int error; 385 struct dentry *dentry = NULL, *trap; 386 const char *old_name; 387 388 trap = lock_rename(new_dir, old_dir); 389 /* Source or destination directories don't exist? */ 390 if (!old_dir->d_inode || !new_dir->d_inode) 391 goto exit; 392 /* Source does not exist, cyclic rename, or mountpoint? */ 393 if (!old_dentry->d_inode || old_dentry == trap || 394 d_mountpoint(old_dentry)) 395 goto exit; 396 dentry = lookup_one_len(new_name, new_dir, strlen(new_name)); 397 /* Lookup failed, cyclic rename or target exists? */ 398 if (IS_ERR(dentry) || dentry == trap || dentry->d_inode) 399 goto exit; 400 401 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 402 403 error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode, 404 dentry); 405 if (error) { 406 fsnotify_oldname_free(old_name); 407 goto exit; 408 } 409 d_move(old_dentry, dentry); 410 fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name, 411 old_dentry->d_name.name, S_ISDIR(old_dentry->d_inode->i_mode), 412 NULL, old_dentry); 413 fsnotify_oldname_free(old_name); 414 unlock_rename(new_dir, old_dir); 415 dput(dentry); 416 return old_dentry; 417 exit: 418 if (dentry && !IS_ERR(dentry)) 419 dput(dentry); 420 unlock_rename(new_dir, old_dir); 421 return NULL; 422 } 423 EXPORT_SYMBOL_GPL(debugfs_rename); 424 425 static struct kobject *debug_kobj; 426 427 static int __init debugfs_init(void) 428 { 429 int retval; 430 431 debug_kobj = kobject_create_and_add("debug", kernel_kobj); 432 if (!debug_kobj) 433 return -EINVAL; 434 435 retval = register_filesystem(&debug_fs_type); 436 if (retval) 437 kobject_put(debug_kobj); 438 return retval; 439 } 440 441 static void __exit debugfs_exit(void) 442 { 443 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 444 unregister_filesystem(&debug_fs_type); 445 kobject_put(debug_kobj); 446 } 447 448 core_initcall(debugfs_init); 449 module_exit(debugfs_exit); 450 MODULE_LICENSE("GPL"); 451 452