file.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304
  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. #include <linux/module.h>
  16. #include <linux/fs.h>
  17. #include <linux/pagemap.h>
  18. #include <linux/namei.h>
  19. #include <linux/debugfs.h>
  20. static ssize_t default_read_file(struct file *file, char __user *buf,
  21. size_t count, loff_t *ppos)
  22. {
  23. return 0;
  24. }
  25. static ssize_t default_write_file(struct file *file, const char __user *buf,
  26. size_t count, loff_t *ppos)
  27. {
  28. return count;
  29. }
  30. static int default_open(struct inode *inode, struct file *file)
  31. {
  32. if (inode->i_private)
  33. file->private_data = inode->i_private;
  34. return 0;
  35. }
  36. const struct file_operations debugfs_file_operations = {
  37. .read = default_read_file,
  38. .write = default_write_file,
  39. .open = default_open,
  40. };
  41. static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
  42. {
  43. nd_set_link(nd, dentry->d_inode->i_private);
  44. return NULL;
  45. }
  46. const struct inode_operations debugfs_link_operations = {
  47. .readlink = generic_readlink,
  48. .follow_link = debugfs_follow_link,
  49. };
  50. static void debugfs_u8_set(void *data, u64 val)
  51. {
  52. *(u8 *)data = val;
  53. }
  54. static u64 debugfs_u8_get(void *data)
  55. {
  56. return *(u8 *)data;
  57. }
  58. DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
  59. /**
  60. * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
  61. * @name: a pointer to a string containing the name of the file to create.
  62. * @mode: the permission that the file should have
  63. * @parent: a pointer to the parent dentry for this file. This should be a
  64. * directory dentry if set. If this parameter is %NULL, then the
  65. * file will be created in the root of the debugfs filesystem.
  66. * @value: a pointer to the variable that the file should read to and write
  67. * from.
  68. *
  69. * This function creates a file in debugfs with the given name that
  70. * contains the value of the variable @value. If the @mode variable is so
  71. * set, it can be read from, and written to.
  72. *
  73. * This function will return a pointer to a dentry if it succeeds. This
  74. * pointer must be passed to the debugfs_remove() function when the file is
  75. * to be removed (no automatic cleanup happens if your module is unloaded,
  76. * you are responsible here.) If an error occurs, %NULL will be returned.
  77. *
  78. * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  79. * returned. It is not wise to check for this value, but rather, check for
  80. * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  81. * code.
  82. */
  83. struct dentry *debugfs_create_u8(const char *name, mode_t mode,
  84. struct dentry *parent, u8 *value)
  85. {
  86. return debugfs_create_file(name, mode, parent, value, &fops_u8);
  87. }
  88. EXPORT_SYMBOL_GPL(debugfs_create_u8);
  89. static void debugfs_u16_set(void *data, u64 val)
  90. {
  91. *(u16 *)data = val;
  92. }
  93. static u64 debugfs_u16_get(void *data)
  94. {
  95. return *(u16 *)data;
  96. }
  97. DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
  98. /**
  99. * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
  100. * @name: a pointer to a string containing the name of the file to create.
  101. * @mode: the permission that the file should have
  102. * @parent: a pointer to the parent dentry for this file. This should be a
  103. * directory dentry if set. If this parameter is %NULL, then the
  104. * file will be created in the root of the debugfs filesystem.
  105. * @value: a pointer to the variable that the file should read to and write
  106. * from.
  107. *
  108. * This function creates a file in debugfs with the given name that
  109. * contains the value of the variable @value. If the @mode variable is so
  110. * set, it can be read from, and written to.
  111. *
  112. * This function will return a pointer to a dentry if it succeeds. This
  113. * pointer must be passed to the debugfs_remove() function when the file is
  114. * to be removed (no automatic cleanup happens if your module is unloaded,
  115. * you are responsible here.) If an error occurs, %NULL will be returned.
  116. *
  117. * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  118. * returned. It is not wise to check for this value, but rather, check for
  119. * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  120. * code.
  121. */
  122. struct dentry *debugfs_create_u16(const char *name, mode_t mode,
  123. struct dentry *parent, u16 *value)
  124. {
  125. return debugfs_create_file(name, mode, parent, value, &fops_u16);
  126. }
  127. EXPORT_SYMBOL_GPL(debugfs_create_u16);
  128. static void debugfs_u32_set(void *data, u64 val)
  129. {
  130. *(u32 *)data = val;
  131. }
  132. static u64 debugfs_u32_get(void *data)
  133. {
  134. return *(u32 *)data;
  135. }
  136. DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
  137. /**
  138. * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
  139. * @name: a pointer to a string containing the name of the file to create.
  140. * @mode: the permission that the file should have
  141. * @parent: a pointer to the parent dentry for this file. This should be a
  142. * directory dentry if set. If this parameter is %NULL, then the
  143. * file will be created in the root of the debugfs filesystem.
  144. * @value: a pointer to the variable that the file should read to and write
  145. * from.
  146. *
  147. * This function creates a file in debugfs with the given name that
  148. * contains the value of the variable @value. If the @mode variable is so
  149. * set, it can be read from, and written to.
  150. *
  151. * This function will return a pointer to a dentry if it succeeds. This
  152. * pointer must be passed to the debugfs_remove() function when the file is
  153. * to be removed (no automatic cleanup happens if your module is unloaded,
  154. * you are responsible here.) If an error occurs, %NULL will be returned.
  155. *
  156. * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  157. * returned. It is not wise to check for this value, but rather, check for
  158. * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  159. * code.
  160. */
  161. struct dentry *debugfs_create_u32(const char *name, mode_t mode,
  162. struct dentry *parent, u32 *value)
  163. {
  164. return debugfs_create_file(name, mode, parent, value, &fops_u32);
  165. }
  166. EXPORT_SYMBOL_GPL(debugfs_create_u32);
  167. static ssize_t read_file_bool(struct file *file, char __user *user_buf,
  168. size_t count, loff_t *ppos)
  169. {
  170. char buf[3];
  171. u32 *val = file->private_data;
  172. if (*val)
  173. buf[0] = 'Y';
  174. else
  175. buf[0] = 'N';
  176. buf[1] = '\n';
  177. buf[2] = 0x00;
  178. return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
  179. }
  180. static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
  181. size_t count, loff_t *ppos)
  182. {
  183. char buf[32];
  184. int buf_size;
  185. u32 *val = file->private_data;
  186. buf_size = min(count, (sizeof(buf)-1));
  187. if (copy_from_user(buf, user_buf, buf_size))
  188. return -EFAULT;
  189. switch (buf[0]) {
  190. case 'y':
  191. case 'Y':
  192. case '1':
  193. *val = 1;
  194. break;
  195. case 'n':
  196. case 'N':
  197. case '0':
  198. *val = 0;
  199. break;
  200. }
  201. return count;
  202. }
  203. static const struct file_operations fops_bool = {
  204. .read = read_file_bool,
  205. .write = write_file_bool,
  206. .open = default_open,
  207. };
  208. /**
  209. * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
  210. * @name: a pointer to a string containing the name of the file to create.
  211. * @mode: the permission that the file should have
  212. * @parent: a pointer to the parent dentry for this file. This should be a
  213. * directory dentry if set. If this parameter is %NULL, then the
  214. * file will be created in the root of the debugfs filesystem.
  215. * @value: a pointer to the variable that the file should read to and write
  216. * from.
  217. *
  218. * This function creates a file in debugfs with the given name that
  219. * contains the value of the variable @value. If the @mode variable is so
  220. * set, it can be read from, and written to.
  221. *
  222. * This function will return a pointer to a dentry if it succeeds. This
  223. * pointer must be passed to the debugfs_remove() function when the file is
  224. * to be removed (no automatic cleanup happens if your module is unloaded,
  225. * you are responsible here.) If an error occurs, %NULL will be returned.
  226. *
  227. * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  228. * returned. It is not wise to check for this value, but rather, check for
  229. * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  230. * code.
  231. */
  232. struct dentry *debugfs_create_bool(const char *name, mode_t mode,
  233. struct dentry *parent, u32 *value)
  234. {
  235. return debugfs_create_file(name, mode, parent, value, &fops_bool);
  236. }
  237. EXPORT_SYMBOL_GPL(debugfs_create_bool);
  238. static ssize_t read_file_blob(struct file *file, char __user *user_buf,
  239. size_t count, loff_t *ppos)
  240. {
  241. struct debugfs_blob_wrapper *blob = file->private_data;
  242. return simple_read_from_buffer(user_buf, count, ppos, blob->data,
  243. blob->size);
  244. }
  245. static const struct file_operations fops_blob = {
  246. .read = read_file_blob,
  247. .open = default_open,
  248. };
  249. /**
  250. * debugfs_create_blob - create a debugfs file that is used to read and write a binary blob
  251. * @name: a pointer to a string containing the name of the file to create.
  252. * @mode: the permission that the file should have
  253. * @parent: a pointer to the parent dentry for this file. This should be a
  254. * directory dentry if set. If this parameter is %NULL, then the
  255. * file will be created in the root of the debugfs filesystem.
  256. * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
  257. * to the blob data and the size of the data.
  258. *
  259. * This function creates a file in debugfs with the given name that exports
  260. * @blob->data as a binary blob. If the @mode variable is so set it can be
  261. * read from. Writing is not supported.
  262. *
  263. * This function will return a pointer to a dentry if it succeeds. This
  264. * pointer must be passed to the debugfs_remove() function when the file is
  265. * to be removed (no automatic cleanup happens if your module is unloaded,
  266. * you are responsible here.) If an error occurs, %NULL will be returned.
  267. *
  268. * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  269. * returned. It is not wise to check for this value, but rather, check for
  270. * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  271. * code.
  272. */
  273. struct dentry *debugfs_create_blob(const char *name, mode_t mode,
  274. struct dentry *parent,
  275. struct debugfs_blob_wrapper *blob)
  276. {
  277. return debugfs_create_file(name, mode, parent, blob, &fops_blob);
  278. }
  279. EXPORT_SYMBOL_GPL(debugfs_create_blob);