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/filesystems for more details. 13 * 14 */ 15 16 #include <linux/module.h> 17 #include <linux/fs.h> 18 #include <linux/pagemap.h> 19 #include <linux/namei.h> 20 #include <linux/debugfs.h> 21 22 static ssize_t default_read_file(struct file *file, char __user *buf, 23 size_t count, loff_t *ppos) 24 { 25 return 0; 26 } 27 28 static ssize_t default_write_file(struct file *file, const char __user *buf, 29 size_t count, loff_t *ppos) 30 { 31 return count; 32 } 33 34 static int default_open(struct inode *inode, struct file *file) 35 { 36 if (inode->i_private) 37 file->private_data = inode->i_private; 38 39 return 0; 40 } 41 42 const struct file_operations debugfs_file_operations = { 43 .read = default_read_file, 44 .write = default_write_file, 45 .open = default_open, 46 }; 47 48 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd) 49 { 50 nd_set_link(nd, dentry->d_inode->i_private); 51 return NULL; 52 } 53 54 const struct inode_operations debugfs_link_operations = { 55 .readlink = generic_readlink, 56 .follow_link = debugfs_follow_link, 57 }; 58 59 static int debugfs_u8_set(void *data, u64 val) 60 { 61 *(u8 *)data = val; 62 return 0; 63 } 64 static int debugfs_u8_get(void *data, u64 *val) 65 { 66 *val = *(u8 *)data; 67 return 0; 68 } 69 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n"); 70 71 /** 72 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value 73 * @name: a pointer to a string containing the name of the file to create. 74 * @mode: the permission that the file should have 75 * @parent: a pointer to the parent dentry for this file. This should be a 76 * directory dentry if set. If this parameter is %NULL, then the 77 * file will be created in the root of the debugfs filesystem. 78 * @value: a pointer to the variable that the file should read to and write 79 * from. 80 * 81 * This function creates a file in debugfs with the given name that 82 * contains the value of the variable @value. If the @mode variable is so 83 * set, it can be read from, and written to. 84 * 85 * This function will return a pointer to a dentry if it succeeds. This 86 * pointer must be passed to the debugfs_remove() function when the file is 87 * to be removed (no automatic cleanup happens if your module is unloaded, 88 * you are responsible here.) If an error occurs, %NULL will be returned. 89 * 90 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 91 * returned. It is not wise to check for this value, but rather, check for 92 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 93 * code. 94 */ 95 struct dentry *debugfs_create_u8(const char *name, mode_t mode, 96 struct dentry *parent, u8 *value) 97 { 98 return debugfs_create_file(name, mode, parent, value, &fops_u8); 99 } 100 EXPORT_SYMBOL_GPL(debugfs_create_u8); 101 102 static int debugfs_u16_set(void *data, u64 val) 103 { 104 *(u16 *)data = val; 105 return 0; 106 } 107 static int debugfs_u16_get(void *data, u64 *val) 108 { 109 *val = *(u16 *)data; 110 return 0; 111 } 112 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n"); 113 114 /** 115 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value 116 * @name: a pointer to a string containing the name of the file to create. 117 * @mode: the permission that the file should have 118 * @parent: a pointer to the parent dentry for this file. This should be a 119 * directory dentry if set. If this parameter is %NULL, then the 120 * file will be created in the root of the debugfs filesystem. 121 * @value: a pointer to the variable that the file should read to and write 122 * from. 123 * 124 * This function creates a file in debugfs with the given name that 125 * contains the value of the variable @value. If the @mode variable is so 126 * set, it can be read from, and written to. 127 * 128 * This function will return a pointer to a dentry if it succeeds. This 129 * pointer must be passed to the debugfs_remove() function when the file is 130 * to be removed (no automatic cleanup happens if your module is unloaded, 131 * you are responsible here.) If an error occurs, %NULL will be returned. 132 * 133 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 134 * returned. It is not wise to check for this value, but rather, check for 135 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 136 * code. 137 */ 138 struct dentry *debugfs_create_u16(const char *name, mode_t mode, 139 struct dentry *parent, u16 *value) 140 { 141 return debugfs_create_file(name, mode, parent, value, &fops_u16); 142 } 143 EXPORT_SYMBOL_GPL(debugfs_create_u16); 144 145 static int debugfs_u32_set(void *data, u64 val) 146 { 147 *(u32 *)data = val; 148 return 0; 149 } 150 static int debugfs_u32_get(void *data, u64 *val) 151 { 152 *val = *(u32 *)data; 153 return 0; 154 } 155 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n"); 156 157 /** 158 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value 159 * @name: a pointer to a string containing the name of the file to create. 160 * @mode: the permission that the file should have 161 * @parent: a pointer to the parent dentry for this file. This should be a 162 * directory dentry if set. If this parameter is %NULL, then the 163 * file will be created in the root of the debugfs filesystem. 164 * @value: a pointer to the variable that the file should read to and write 165 * from. 166 * 167 * This function creates a file in debugfs with the given name that 168 * contains the value of the variable @value. If the @mode variable is so 169 * set, it can be read from, and written to. 170 * 171 * This function will return a pointer to a dentry if it succeeds. This 172 * pointer must be passed to the debugfs_remove() function when the file is 173 * to be removed (no automatic cleanup happens if your module is unloaded, 174 * you are responsible here.) If an error occurs, %NULL will be returned. 175 * 176 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 177 * returned. It is not wise to check for this value, but rather, check for 178 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 179 * code. 180 */ 181 struct dentry *debugfs_create_u32(const char *name, mode_t mode, 182 struct dentry *parent, u32 *value) 183 { 184 return debugfs_create_file(name, mode, parent, value, &fops_u32); 185 } 186 EXPORT_SYMBOL_GPL(debugfs_create_u32); 187 188 static int debugfs_u64_set(void *data, u64 val) 189 { 190 *(u64 *)data = val; 191 return 0; 192 } 193 194 static int debugfs_u64_get(void *data, u64 *val) 195 { 196 *val = *(u64 *)data; 197 return 0; 198 } 199 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n"); 200 201 /** 202 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value 203 * @name: a pointer to a string containing the name of the file to create. 204 * @mode: the permission that the file should have 205 * @parent: a pointer to the parent dentry for this file. This should be a 206 * directory dentry if set. If this parameter is %NULL, then the 207 * file will be created in the root of the debugfs filesystem. 208 * @value: a pointer to the variable that the file should read to and write 209 * from. 210 * 211 * This function creates a file in debugfs with the given name that 212 * contains the value of the variable @value. If the @mode variable is so 213 * set, it can be read from, and written to. 214 * 215 * This function will return a pointer to a dentry if it succeeds. This 216 * pointer must be passed to the debugfs_remove() function when the file is 217 * to be removed (no automatic cleanup happens if your module is unloaded, 218 * you are responsible here.) If an error occurs, %NULL will be returned. 219 * 220 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 221 * returned. It is not wise to check for this value, but rather, check for 222 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 223 * code. 224 */ 225 struct dentry *debugfs_create_u64(const char *name, mode_t mode, 226 struct dentry *parent, u64 *value) 227 { 228 return debugfs_create_file(name, mode, parent, value, &fops_u64); 229 } 230 EXPORT_SYMBOL_GPL(debugfs_create_u64); 231 232 DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n"); 233 234 DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n"); 235 236 DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n"); 237 238 /* 239 * debugfs_create_x{8,16,32} - create a debugfs file that is used to read and write an unsigned {8,16,32}-bit value 240 * 241 * These functions are exactly the same as the above functions (but use a hex 242 * output for the decimal challenged). For details look at the above unsigned 243 * decimal functions. 244 */ 245 246 /** 247 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value 248 * @name: a pointer to a string containing the name of the file to create. 249 * @mode: the permission that the file should have 250 * @parent: a pointer to the parent dentry for this file. This should be a 251 * directory dentry if set. If this parameter is %NULL, then the 252 * file will be created in the root of the debugfs filesystem. 253 * @value: a pointer to the variable that the file should read to and write 254 * from. 255 */ 256 struct dentry *debugfs_create_x8(const char *name, mode_t mode, 257 struct dentry *parent, u8 *value) 258 { 259 return debugfs_create_file(name, mode, parent, value, &fops_x8); 260 } 261 EXPORT_SYMBOL_GPL(debugfs_create_x8); 262 263 /** 264 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value 265 * @name: a pointer to a string containing the name of the file to create. 266 * @mode: the permission that the file should have 267 * @parent: a pointer to the parent dentry for this file. This should be a 268 * directory dentry if set. If this parameter is %NULL, then the 269 * file will be created in the root of the debugfs filesystem. 270 * @value: a pointer to the variable that the file should read to and write 271 * from. 272 */ 273 struct dentry *debugfs_create_x16(const char *name, mode_t mode, 274 struct dentry *parent, u16 *value) 275 { 276 return debugfs_create_file(name, mode, parent, value, &fops_x16); 277 } 278 EXPORT_SYMBOL_GPL(debugfs_create_x16); 279 280 /** 281 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value 282 * @name: a pointer to a string containing the name of the file to create. 283 * @mode: the permission that the file should have 284 * @parent: a pointer to the parent dentry for this file. This should be a 285 * directory dentry if set. If this parameter is %NULL, then the 286 * file will be created in the root of the debugfs filesystem. 287 * @value: a pointer to the variable that the file should read to and write 288 * from. 289 */ 290 struct dentry *debugfs_create_x32(const char *name, mode_t mode, 291 struct dentry *parent, u32 *value) 292 { 293 return debugfs_create_file(name, mode, parent, value, &fops_x32); 294 } 295 EXPORT_SYMBOL_GPL(debugfs_create_x32); 296 297 298 static int debugfs_size_t_set(void *data, u64 val) 299 { 300 *(size_t *)data = val; 301 return 0; 302 } 303 static int debugfs_size_t_get(void *data, u64 *val) 304 { 305 *val = *(size_t *)data; 306 return 0; 307 } 308 DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set, 309 "%llu\n"); /* %llu and %zu are more or less the same */ 310 311 /** 312 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value 313 * @name: a pointer to a string containing the name of the file to create. 314 * @mode: the permission that the file should have 315 * @parent: a pointer to the parent dentry for this file. This should be a 316 * directory dentry if set. If this parameter is %NULL, then the 317 * file will be created in the root of the debugfs filesystem. 318 * @value: a pointer to the variable that the file should read to and write 319 * from. 320 */ 321 struct dentry *debugfs_create_size_t(const char *name, mode_t mode, 322 struct dentry *parent, size_t *value) 323 { 324 return debugfs_create_file(name, mode, parent, value, &fops_size_t); 325 } 326 EXPORT_SYMBOL_GPL(debugfs_create_size_t); 327 328 329 static ssize_t read_file_bool(struct file *file, char __user *user_buf, 330 size_t count, loff_t *ppos) 331 { 332 char buf[3]; 333 u32 *val = file->private_data; 334 335 if (*val) 336 buf[0] = 'Y'; 337 else 338 buf[0] = 'N'; 339 buf[1] = '\n'; 340 buf[2] = 0x00; 341 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 342 } 343 344 static ssize_t write_file_bool(struct file *file, const char __user *user_buf, 345 size_t count, loff_t *ppos) 346 { 347 char buf[32]; 348 int buf_size; 349 u32 *val = file->private_data; 350 351 buf_size = min(count, (sizeof(buf)-1)); 352 if (copy_from_user(buf, user_buf, buf_size)) 353 return -EFAULT; 354 355 switch (buf[0]) { 356 case 'y': 357 case 'Y': 358 case '1': 359 *val = 1; 360 break; 361 case 'n': 362 case 'N': 363 case '0': 364 *val = 0; 365 break; 366 } 367 368 return count; 369 } 370 371 static const struct file_operations fops_bool = { 372 .read = read_file_bool, 373 .write = write_file_bool, 374 .open = default_open, 375 }; 376 377 /** 378 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value 379 * @name: a pointer to a string containing the name of the file to create. 380 * @mode: the permission that the file should have 381 * @parent: a pointer to the parent dentry for this file. This should be a 382 * directory dentry if set. If this parameter is %NULL, then the 383 * file will be created in the root of the debugfs filesystem. 384 * @value: a pointer to the variable that the file should read to and write 385 * from. 386 * 387 * This function creates a file in debugfs with the given name that 388 * contains the value of the variable @value. If the @mode variable is so 389 * set, it can be read from, and written to. 390 * 391 * This function will return a pointer to a dentry if it succeeds. This 392 * pointer must be passed to the debugfs_remove() function when the file is 393 * to be removed (no automatic cleanup happens if your module is unloaded, 394 * you are responsible here.) If an error occurs, %NULL will be returned. 395 * 396 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 397 * returned. It is not wise to check for this value, but rather, check for 398 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 399 * code. 400 */ 401 struct dentry *debugfs_create_bool(const char *name, mode_t mode, 402 struct dentry *parent, u32 *value) 403 { 404 return debugfs_create_file(name, mode, parent, value, &fops_bool); 405 } 406 EXPORT_SYMBOL_GPL(debugfs_create_bool); 407 408 static ssize_t read_file_blob(struct file *file, char __user *user_buf, 409 size_t count, loff_t *ppos) 410 { 411 struct debugfs_blob_wrapper *blob = file->private_data; 412 return simple_read_from_buffer(user_buf, count, ppos, blob->data, 413 blob->size); 414 } 415 416 static const struct file_operations fops_blob = { 417 .read = read_file_blob, 418 .open = default_open, 419 }; 420 421 /** 422 * debugfs_create_blob - create a debugfs file that is used to read and write a binary blob 423 * @name: a pointer to a string containing the name of the file to create. 424 * @mode: the permission that the file should have 425 * @parent: a pointer to the parent dentry for this file. This should be a 426 * directory dentry if set. If this parameter is %NULL, then the 427 * file will be created in the root of the debugfs filesystem. 428 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer 429 * to the blob data and the size of the data. 430 * 431 * This function creates a file in debugfs with the given name that exports 432 * @blob->data as a binary blob. If the @mode variable is so set it can be 433 * read from. Writing is not supported. 434 * 435 * This function will return a pointer to a dentry if it succeeds. This 436 * pointer must be passed to the debugfs_remove() function when the file is 437 * to be removed (no automatic cleanup happens if your module is unloaded, 438 * you are responsible here.) If an error occurs, %NULL will be returned. 439 * 440 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 441 * returned. It is not wise to check for this value, but rather, check for 442 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling 443 * code. 444 */ 445 struct dentry *debugfs_create_blob(const char *name, mode_t mode, 446 struct dentry *parent, 447 struct debugfs_blob_wrapper *blob) 448 { 449 return debugfs_create_file(name, mode, parent, blob, &fops_blob); 450 } 451 EXPORT_SYMBOL_GPL(debugfs_create_blob); 452