Loading...
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/seq_file.h>
19#include <linux/pagemap.h>
20#include <linux/namei.h>
21#include <linux/debugfs.h>
22#include <linux/io.h>
23#include <linux/slab.h>
24#include <linux/atomic.h>
25
26static ssize_t default_read_file(struct file *file, char __user *buf,
27 size_t count, loff_t *ppos)
28{
29 return 0;
30}
31
32static ssize_t default_write_file(struct file *file, const char __user *buf,
33 size_t count, loff_t *ppos)
34{
35 return count;
36}
37
38const struct file_operations debugfs_file_operations = {
39 .read = default_read_file,
40 .write = default_write_file,
41 .open = simple_open,
42 .llseek = noop_llseek,
43};
44
45static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
46{
47 nd_set_link(nd, dentry->d_inode->i_private);
48 return NULL;
49}
50
51const struct inode_operations debugfs_link_operations = {
52 .readlink = generic_readlink,
53 .follow_link = debugfs_follow_link,
54};
55
56static int debugfs_u8_set(void *data, u64 val)
57{
58 *(u8 *)data = val;
59 return 0;
60}
61static int debugfs_u8_get(void *data, u64 *val)
62{
63 *val = *(u8 *)data;
64 return 0;
65}
66DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
67DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
68DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
69
70/**
71 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
72 * @name: a pointer to a string containing the name of the file to create.
73 * @mode: the permission that the file should have
74 * @parent: a pointer to the parent dentry for this file. This should be a
75 * directory dentry if set. If this parameter is %NULL, then the
76 * file will be created in the root of the debugfs filesystem.
77 * @value: a pointer to the variable that the file should read to and write
78 * from.
79 *
80 * This function creates a file in debugfs with the given name that
81 * contains the value of the variable @value. If the @mode variable is so
82 * set, it can be read from, and written to.
83 *
84 * This function will return a pointer to a dentry if it succeeds. This
85 * pointer must be passed to the debugfs_remove() function when the file is
86 * to be removed (no automatic cleanup happens if your module is unloaded,
87 * you are responsible here.) If an error occurs, %NULL will be returned.
88 *
89 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
90 * returned. It is not wise to check for this value, but rather, check for
91 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
92 * code.
93 */
94struct dentry *debugfs_create_u8(const char *name, umode_t mode,
95 struct dentry *parent, u8 *value)
96{
97 /* if there are no write bits set, make read only */
98 if (!(mode & S_IWUGO))
99 return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
100 /* if there are no read bits set, make write only */
101 if (!(mode & S_IRUGO))
102 return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
103
104 return debugfs_create_file(name, mode, parent, value, &fops_u8);
105}
106EXPORT_SYMBOL_GPL(debugfs_create_u8);
107
108static int debugfs_u16_set(void *data, u64 val)
109{
110 *(u16 *)data = val;
111 return 0;
112}
113static int debugfs_u16_get(void *data, u64 *val)
114{
115 *val = *(u16 *)data;
116 return 0;
117}
118DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
119DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
120DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
121
122/**
123 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
124 * @name: a pointer to a string containing the name of the file to create.
125 * @mode: the permission that the file should have
126 * @parent: a pointer to the parent dentry for this file. This should be a
127 * directory dentry if set. If this parameter is %NULL, then the
128 * file will be created in the root of the debugfs filesystem.
129 * @value: a pointer to the variable that the file should read to and write
130 * from.
131 *
132 * This function creates a file in debugfs with the given name that
133 * contains the value of the variable @value. If the @mode variable is so
134 * set, it can be read from, and written to.
135 *
136 * This function will return a pointer to a dentry if it succeeds. This
137 * pointer must be passed to the debugfs_remove() function when the file is
138 * to be removed (no automatic cleanup happens if your module is unloaded,
139 * you are responsible here.) If an error occurs, %NULL will be returned.
140 *
141 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
142 * returned. It is not wise to check for this value, but rather, check for
143 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
144 * code.
145 */
146struct dentry *debugfs_create_u16(const char *name, umode_t mode,
147 struct dentry *parent, u16 *value)
148{
149 /* if there are no write bits set, make read only */
150 if (!(mode & S_IWUGO))
151 return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
152 /* if there are no read bits set, make write only */
153 if (!(mode & S_IRUGO))
154 return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
155
156 return debugfs_create_file(name, mode, parent, value, &fops_u16);
157}
158EXPORT_SYMBOL_GPL(debugfs_create_u16);
159
160static int debugfs_u32_set(void *data, u64 val)
161{
162 *(u32 *)data = val;
163 return 0;
164}
165static int debugfs_u32_get(void *data, u64 *val)
166{
167 *val = *(u32 *)data;
168 return 0;
169}
170DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
171DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
172DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
173
174/**
175 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
176 * @name: a pointer to a string containing the name of the file to create.
177 * @mode: the permission that the file should have
178 * @parent: a pointer to the parent dentry for this file. This should be a
179 * directory dentry if set. If this parameter is %NULL, then the
180 * file will be created in the root of the debugfs filesystem.
181 * @value: a pointer to the variable that the file should read to and write
182 * from.
183 *
184 * This function creates a file in debugfs with the given name that
185 * contains the value of the variable @value. If the @mode variable is so
186 * set, it can be read from, and written to.
187 *
188 * This function will return a pointer to a dentry if it succeeds. This
189 * pointer must be passed to the debugfs_remove() function when the file is
190 * to be removed (no automatic cleanup happens if your module is unloaded,
191 * you are responsible here.) If an error occurs, %NULL will be returned.
192 *
193 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
194 * returned. It is not wise to check for this value, but rather, check for
195 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
196 * code.
197 */
198struct dentry *debugfs_create_u32(const char *name, umode_t mode,
199 struct dentry *parent, u32 *value)
200{
201 /* if there are no write bits set, make read only */
202 if (!(mode & S_IWUGO))
203 return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
204 /* if there are no read bits set, make write only */
205 if (!(mode & S_IRUGO))
206 return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
207
208 return debugfs_create_file(name, mode, parent, value, &fops_u32);
209}
210EXPORT_SYMBOL_GPL(debugfs_create_u32);
211
212static int debugfs_u64_set(void *data, u64 val)
213{
214 *(u64 *)data = val;
215 return 0;
216}
217
218static int debugfs_u64_get(void *data, u64 *val)
219{
220 *val = *(u64 *)data;
221 return 0;
222}
223DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
224DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
225DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
226
227/**
228 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
229 * @name: a pointer to a string containing the name of the file to create.
230 * @mode: the permission that the file should have
231 * @parent: a pointer to the parent dentry for this file. This should be a
232 * directory dentry if set. If this parameter is %NULL, then the
233 * file will be created in the root of the debugfs filesystem.
234 * @value: a pointer to the variable that the file should read to and write
235 * from.
236 *
237 * This function creates a file in debugfs with the given name that
238 * contains the value of the variable @value. If the @mode variable is so
239 * set, it can be read from, and written to.
240 *
241 * This function will return a pointer to a dentry if it succeeds. This
242 * pointer must be passed to the debugfs_remove() function when the file is
243 * to be removed (no automatic cleanup happens if your module is unloaded,
244 * you are responsible here.) If an error occurs, %NULL will be returned.
245 *
246 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
247 * returned. It is not wise to check for this value, but rather, check for
248 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
249 * code.
250 */
251struct dentry *debugfs_create_u64(const char *name, umode_t mode,
252 struct dentry *parent, u64 *value)
253{
254 /* if there are no write bits set, make read only */
255 if (!(mode & S_IWUGO))
256 return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
257 /* if there are no read bits set, make write only */
258 if (!(mode & S_IRUGO))
259 return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
260
261 return debugfs_create_file(name, mode, parent, value, &fops_u64);
262}
263EXPORT_SYMBOL_GPL(debugfs_create_u64);
264
265DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
266DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
267DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
268
269DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
270DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
271DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
272
273DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
274DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
275DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
276
277DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
278
279/*
280 * 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
281 *
282 * These functions are exactly the same as the above functions (but use a hex
283 * output for the decimal challenged). For details look at the above unsigned
284 * decimal functions.
285 */
286
287/**
288 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
289 * @name: a pointer to a string containing the name of the file to create.
290 * @mode: the permission that the file should have
291 * @parent: a pointer to the parent dentry for this file. This should be a
292 * directory dentry if set. If this parameter is %NULL, then the
293 * file will be created in the root of the debugfs filesystem.
294 * @value: a pointer to the variable that the file should read to and write
295 * from.
296 */
297struct dentry *debugfs_create_x8(const char *name, umode_t mode,
298 struct dentry *parent, u8 *value)
299{
300 /* if there are no write bits set, make read only */
301 if (!(mode & S_IWUGO))
302 return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
303 /* if there are no read bits set, make write only */
304 if (!(mode & S_IRUGO))
305 return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
306
307 return debugfs_create_file(name, mode, parent, value, &fops_x8);
308}
309EXPORT_SYMBOL_GPL(debugfs_create_x8);
310
311/**
312 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit 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 */
321struct dentry *debugfs_create_x16(const char *name, umode_t mode,
322 struct dentry *parent, u16 *value)
323{
324 /* if there are no write bits set, make read only */
325 if (!(mode & S_IWUGO))
326 return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
327 /* if there are no read bits set, make write only */
328 if (!(mode & S_IRUGO))
329 return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
330
331 return debugfs_create_file(name, mode, parent, value, &fops_x16);
332}
333EXPORT_SYMBOL_GPL(debugfs_create_x16);
334
335/**
336 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
337 * @name: a pointer to a string containing the name of the file to create.
338 * @mode: the permission that the file should have
339 * @parent: a pointer to the parent dentry for this file. This should be a
340 * directory dentry if set. If this parameter is %NULL, then the
341 * file will be created in the root of the debugfs filesystem.
342 * @value: a pointer to the variable that the file should read to and write
343 * from.
344 */
345struct dentry *debugfs_create_x32(const char *name, umode_t mode,
346 struct dentry *parent, u32 *value)
347{
348 /* if there are no write bits set, make read only */
349 if (!(mode & S_IWUGO))
350 return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
351 /* if there are no read bits set, make write only */
352 if (!(mode & S_IRUGO))
353 return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
354
355 return debugfs_create_file(name, mode, parent, value, &fops_x32);
356}
357EXPORT_SYMBOL_GPL(debugfs_create_x32);
358
359/**
360 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
361 * @name: a pointer to a string containing the name of the file to create.
362 * @mode: the permission that the file should have
363 * @parent: a pointer to the parent dentry for this file. This should be a
364 * directory dentry if set. If this parameter is %NULL, then the
365 * file will be created in the root of the debugfs filesystem.
366 * @value: a pointer to the variable that the file should read to and write
367 * from.
368 */
369struct dentry *debugfs_create_x64(const char *name, umode_t mode,
370 struct dentry *parent, u64 *value)
371{
372 return debugfs_create_file(name, mode, parent, value, &fops_x64);
373}
374EXPORT_SYMBOL_GPL(debugfs_create_x64);
375
376
377static int debugfs_size_t_set(void *data, u64 val)
378{
379 *(size_t *)data = val;
380 return 0;
381}
382static int debugfs_size_t_get(void *data, u64 *val)
383{
384 *val = *(size_t *)data;
385 return 0;
386}
387DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
388 "%llu\n"); /* %llu and %zu are more or less the same */
389
390/**
391 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
392 * @name: a pointer to a string containing the name of the file to create.
393 * @mode: the permission that the file should have
394 * @parent: a pointer to the parent dentry for this file. This should be a
395 * directory dentry if set. If this parameter is %NULL, then the
396 * file will be created in the root of the debugfs filesystem.
397 * @value: a pointer to the variable that the file should read to and write
398 * from.
399 */
400struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
401 struct dentry *parent, size_t *value)
402{
403 return debugfs_create_file(name, mode, parent, value, &fops_size_t);
404}
405EXPORT_SYMBOL_GPL(debugfs_create_size_t);
406
407static int debugfs_atomic_t_set(void *data, u64 val)
408{
409 atomic_set((atomic_t *)data, val);
410 return 0;
411}
412static int debugfs_atomic_t_get(void *data, u64 *val)
413{
414 *val = atomic_read((atomic_t *)data);
415 return 0;
416}
417DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
418 debugfs_atomic_t_set, "%lld\n");
419DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
420DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
421
422/**
423 * debugfs_create_atomic_t - create a debugfs file that is used to read and
424 * write an atomic_t value
425 * @name: a pointer to a string containing the name of the file to create.
426 * @mode: the permission that the file should have
427 * @parent: a pointer to the parent dentry for this file. This should be a
428 * directory dentry if set. If this parameter is %NULL, then the
429 * file will be created in the root of the debugfs filesystem.
430 * @value: a pointer to the variable that the file should read to and write
431 * from.
432 */
433struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
434 struct dentry *parent, atomic_t *value)
435{
436 /* if there are no write bits set, make read only */
437 if (!(mode & S_IWUGO))
438 return debugfs_create_file(name, mode, parent, value,
439 &fops_atomic_t_ro);
440 /* if there are no read bits set, make write only */
441 if (!(mode & S_IRUGO))
442 return debugfs_create_file(name, mode, parent, value,
443 &fops_atomic_t_wo);
444
445 return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
446}
447EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
448
449static ssize_t read_file_bool(struct file *file, char __user *user_buf,
450 size_t count, loff_t *ppos)
451{
452 char buf[3];
453 u32 *val = file->private_data;
454
455 if (*val)
456 buf[0] = 'Y';
457 else
458 buf[0] = 'N';
459 buf[1] = '\n';
460 buf[2] = 0x00;
461 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
462}
463
464static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
465 size_t count, loff_t *ppos)
466{
467 char buf[32];
468 size_t buf_size;
469 bool bv;
470 u32 *val = file->private_data;
471
472 buf_size = min(count, (sizeof(buf)-1));
473 if (copy_from_user(buf, user_buf, buf_size))
474 return -EFAULT;
475
476 buf[buf_size] = '\0';
477 if (strtobool(buf, &bv) == 0)
478 *val = bv;
479
480 return count;
481}
482
483static const struct file_operations fops_bool = {
484 .read = read_file_bool,
485 .write = write_file_bool,
486 .open = simple_open,
487 .llseek = default_llseek,
488};
489
490/**
491 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
492 * @name: a pointer to a string containing the name of the file to create.
493 * @mode: the permission that the file should have
494 * @parent: a pointer to the parent dentry for this file. This should be a
495 * directory dentry if set. If this parameter is %NULL, then the
496 * file will be created in the root of the debugfs filesystem.
497 * @value: a pointer to the variable that the file should read to and write
498 * from.
499 *
500 * This function creates a file in debugfs with the given name that
501 * contains the value of the variable @value. If the @mode variable is so
502 * set, it can be read from, and written to.
503 *
504 * This function will return a pointer to a dentry if it succeeds. This
505 * pointer must be passed to the debugfs_remove() function when the file is
506 * to be removed (no automatic cleanup happens if your module is unloaded,
507 * you are responsible here.) If an error occurs, %NULL will be returned.
508 *
509 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
510 * returned. It is not wise to check for this value, but rather, check for
511 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
512 * code.
513 */
514struct dentry *debugfs_create_bool(const char *name, umode_t mode,
515 struct dentry *parent, u32 *value)
516{
517 return debugfs_create_file(name, mode, parent, value, &fops_bool);
518}
519EXPORT_SYMBOL_GPL(debugfs_create_bool);
520
521static ssize_t read_file_blob(struct file *file, char __user *user_buf,
522 size_t count, loff_t *ppos)
523{
524 struct debugfs_blob_wrapper *blob = file->private_data;
525 return simple_read_from_buffer(user_buf, count, ppos, blob->data,
526 blob->size);
527}
528
529static const struct file_operations fops_blob = {
530 .read = read_file_blob,
531 .open = simple_open,
532 .llseek = default_llseek,
533};
534
535/**
536 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
537 * @name: a pointer to a string containing the name of the file to create.
538 * @mode: the permission that the file should have
539 * @parent: a pointer to the parent dentry for this file. This should be a
540 * directory dentry if set. If this parameter is %NULL, then the
541 * file will be created in the root of the debugfs filesystem.
542 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
543 * to the blob data and the size of the data.
544 *
545 * This function creates a file in debugfs with the given name that exports
546 * @blob->data as a binary blob. If the @mode variable is so set it can be
547 * read from. Writing is not supported.
548 *
549 * This function will return a pointer to a dentry if it succeeds. This
550 * pointer must be passed to the debugfs_remove() function when the file is
551 * to be removed (no automatic cleanup happens if your module is unloaded,
552 * you are responsible here.) If an error occurs, %NULL will be returned.
553 *
554 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
555 * returned. It is not wise to check for this value, but rather, check for
556 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
557 * code.
558 */
559struct dentry *debugfs_create_blob(const char *name, umode_t mode,
560 struct dentry *parent,
561 struct debugfs_blob_wrapper *blob)
562{
563 return debugfs_create_file(name, mode, parent, blob, &fops_blob);
564}
565EXPORT_SYMBOL_GPL(debugfs_create_blob);
566
567struct array_data {
568 void *array;
569 u32 elements;
570};
571
572static size_t u32_format_array(char *buf, size_t bufsize,
573 u32 *array, int array_size)
574{
575 size_t ret = 0;
576
577 while (--array_size >= 0) {
578 size_t len;
579 char term = array_size ? ' ' : '\n';
580
581 len = snprintf(buf, bufsize, "%u%c", *array++, term);
582 ret += len;
583
584 buf += len;
585 bufsize -= len;
586 }
587 return ret;
588}
589
590static int u32_array_open(struct inode *inode, struct file *file)
591{
592 struct array_data *data = inode->i_private;
593 int size, elements = data->elements;
594 char *buf;
595
596 /*
597 * Max size:
598 * - 10 digits + ' '/'\n' = 11 bytes per number
599 * - terminating NUL character
600 */
601 size = elements*11;
602 buf = kmalloc(size+1, GFP_KERNEL);
603 if (!buf)
604 return -ENOMEM;
605 buf[size] = 0;
606
607 file->private_data = buf;
608 u32_format_array(buf, size, data->array, data->elements);
609
610 return nonseekable_open(inode, file);
611}
612
613static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
614 loff_t *ppos)
615{
616 size_t size = strlen(file->private_data);
617
618 return simple_read_from_buffer(buf, len, ppos,
619 file->private_data, size);
620}
621
622static int u32_array_release(struct inode *inode, struct file *file)
623{
624 kfree(file->private_data);
625
626 return 0;
627}
628
629static const struct file_operations u32_array_fops = {
630 .owner = THIS_MODULE,
631 .open = u32_array_open,
632 .release = u32_array_release,
633 .read = u32_array_read,
634 .llseek = no_llseek,
635};
636
637/**
638 * debugfs_create_u32_array - create a debugfs file that is used to read u32
639 * array.
640 * @name: a pointer to a string containing the name of the file to create.
641 * @mode: the permission that the file should have.
642 * @parent: a pointer to the parent dentry for this file. This should be a
643 * directory dentry if set. If this parameter is %NULL, then the
644 * file will be created in the root of the debugfs filesystem.
645 * @array: u32 array that provides data.
646 * @elements: total number of elements in the array.
647 *
648 * This function creates a file in debugfs with the given name that exports
649 * @array as data. If the @mode variable is so set it can be read from.
650 * Writing is not supported. Seek within the file is also not supported.
651 * Once array is created its size can not be changed.
652 *
653 * The function returns a pointer to dentry on success. If debugfs is not
654 * enabled in the kernel, the value -%ENODEV will be returned.
655 */
656struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
657 struct dentry *parent,
658 u32 *array, u32 elements)
659{
660 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
661
662 if (data == NULL)
663 return NULL;
664
665 data->array = array;
666 data->elements = elements;
667
668 return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
669}
670EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
671
672#ifdef CONFIG_HAS_IOMEM
673
674/*
675 * The regset32 stuff is used to print 32-bit registers using the
676 * seq_file utilities. We offer printing a register set in an already-opened
677 * sequential file or create a debugfs file that only prints a regset32.
678 */
679
680/**
681 * debugfs_print_regs32 - use seq_print to describe a set of registers
682 * @s: the seq_file structure being used to generate output
683 * @regs: an array if struct debugfs_reg32 structures
684 * @nregs: the length of the above array
685 * @base: the base address to be used in reading the registers
686 * @prefix: a string to be prefixed to every output line
687 *
688 * This function outputs a text block describing the current values of
689 * some 32-bit hardware registers. It is meant to be used within debugfs
690 * files based on seq_file that need to show registers, intermixed with other
691 * information. The prefix argument may be used to specify a leading string,
692 * because some peripherals have several blocks of identical registers,
693 * for example configuration of dma channels
694 */
695int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
696 int nregs, void __iomem *base, char *prefix)
697{
698 int i, ret = 0;
699
700 for (i = 0; i < nregs; i++, regs++) {
701 if (prefix)
702 ret += seq_printf(s, "%s", prefix);
703 ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
704 readl(base + regs->offset));
705 }
706 return ret;
707}
708EXPORT_SYMBOL_GPL(debugfs_print_regs32);
709
710static int debugfs_show_regset32(struct seq_file *s, void *data)
711{
712 struct debugfs_regset32 *regset = s->private;
713
714 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
715 return 0;
716}
717
718static int debugfs_open_regset32(struct inode *inode, struct file *file)
719{
720 return single_open(file, debugfs_show_regset32, inode->i_private);
721}
722
723static const struct file_operations fops_regset32 = {
724 .open = debugfs_open_regset32,
725 .read = seq_read,
726 .llseek = seq_lseek,
727 .release = single_release,
728};
729
730/**
731 * debugfs_create_regset32 - create a debugfs file that returns register values
732 * @name: a pointer to a string containing the name of the file to create.
733 * @mode: the permission that the file should have
734 * @parent: a pointer to the parent dentry for this file. This should be a
735 * directory dentry if set. If this parameter is %NULL, then the
736 * file will be created in the root of the debugfs filesystem.
737 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
738 * to an array of register definitions, the array size and the base
739 * address where the register bank is to be found.
740 *
741 * This function creates a file in debugfs with the given name that reports
742 * the names and values of a set of 32-bit registers. If the @mode variable
743 * is so set it can be read from. Writing is not supported.
744 *
745 * This function will return a pointer to a dentry if it succeeds. This
746 * pointer must be passed to the debugfs_remove() function when the file is
747 * to be removed (no automatic cleanup happens if your module is unloaded,
748 * you are responsible here.) If an error occurs, %NULL will be returned.
749 *
750 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
751 * returned. It is not wise to check for this value, but rather, check for
752 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
753 * code.
754 */
755struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
756 struct dentry *parent,
757 struct debugfs_regset32 *regset)
758{
759 return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
760}
761EXPORT_SYMBOL_GPL(debugfs_create_regset32);
762
763#endif /* CONFIG_HAS_IOMEM */
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/seq_file.h>
19#include <linux/pagemap.h>
20#include <linux/debugfs.h>
21#include <linux/io.h>
22#include <linux/slab.h>
23#include <linux/atomic.h>
24#include <linux/device.h>
25
26static ssize_t default_read_file(struct file *file, char __user *buf,
27 size_t count, loff_t *ppos)
28{
29 return 0;
30}
31
32static ssize_t default_write_file(struct file *file, const char __user *buf,
33 size_t count, loff_t *ppos)
34{
35 return count;
36}
37
38const struct file_operations debugfs_file_operations = {
39 .read = default_read_file,
40 .write = default_write_file,
41 .open = simple_open,
42 .llseek = noop_llseek,
43};
44
45static struct dentry *debugfs_create_mode(const char *name, umode_t mode,
46 struct dentry *parent, void *value,
47 const struct file_operations *fops,
48 const struct file_operations *fops_ro,
49 const struct file_operations *fops_wo)
50{
51 /* if there are no write bits set, make read only */
52 if (!(mode & S_IWUGO))
53 return debugfs_create_file(name, mode, parent, value, fops_ro);
54 /* if there are no read bits set, make write only */
55 if (!(mode & S_IRUGO))
56 return debugfs_create_file(name, mode, parent, value, fops_wo);
57
58 return debugfs_create_file(name, mode, parent, value, fops);
59}
60
61static int debugfs_u8_set(void *data, u64 val)
62{
63 *(u8 *)data = val;
64 return 0;
65}
66static int debugfs_u8_get(void *data, u64 *val)
67{
68 *val = *(u8 *)data;
69 return 0;
70}
71DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
72DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
73DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
74
75/**
76 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
77 * @name: a pointer to a string containing the name of the file to create.
78 * @mode: the permission that the file should have
79 * @parent: a pointer to the parent dentry for this file. This should be a
80 * directory dentry if set. If this parameter is %NULL, then the
81 * file will be created in the root of the debugfs filesystem.
82 * @value: a pointer to the variable that the file should read to and write
83 * from.
84 *
85 * This function creates a file in debugfs with the given name that
86 * contains the value of the variable @value. If the @mode variable is so
87 * set, it can be read from, and written to.
88 *
89 * This function will return a pointer to a dentry if it succeeds. This
90 * pointer must be passed to the debugfs_remove() function when the file is
91 * to be removed (no automatic cleanup happens if your module is unloaded,
92 * you are responsible here.) If an error occurs, %NULL will be returned.
93 *
94 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
95 * returned. It is not wise to check for this value, but rather, check for
96 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
97 * code.
98 */
99struct dentry *debugfs_create_u8(const char *name, umode_t mode,
100 struct dentry *parent, u8 *value)
101{
102 return debugfs_create_mode(name, mode, parent, value, &fops_u8,
103 &fops_u8_ro, &fops_u8_wo);
104}
105EXPORT_SYMBOL_GPL(debugfs_create_u8);
106
107static int debugfs_u16_set(void *data, u64 val)
108{
109 *(u16 *)data = val;
110 return 0;
111}
112static int debugfs_u16_get(void *data, u64 *val)
113{
114 *val = *(u16 *)data;
115 return 0;
116}
117DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
118DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
119DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
120
121/**
122 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
123 * @name: a pointer to a string containing the name of the file to create.
124 * @mode: the permission that the file should have
125 * @parent: a pointer to the parent dentry for this file. This should be a
126 * directory dentry if set. If this parameter is %NULL, then the
127 * file will be created in the root of the debugfs filesystem.
128 * @value: a pointer to the variable that the file should read to and write
129 * from.
130 *
131 * This function creates a file in debugfs with the given name that
132 * contains the value of the variable @value. If the @mode variable is so
133 * set, it can be read from, and written to.
134 *
135 * This function will return a pointer to a dentry if it succeeds. This
136 * pointer must be passed to the debugfs_remove() function when the file is
137 * to be removed (no automatic cleanup happens if your module is unloaded,
138 * you are responsible here.) If an error occurs, %NULL will be returned.
139 *
140 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
141 * returned. It is not wise to check for this value, but rather, check for
142 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
143 * code.
144 */
145struct dentry *debugfs_create_u16(const char *name, umode_t mode,
146 struct dentry *parent, u16 *value)
147{
148 return debugfs_create_mode(name, mode, parent, value, &fops_u16,
149 &fops_u16_ro, &fops_u16_wo);
150}
151EXPORT_SYMBOL_GPL(debugfs_create_u16);
152
153static int debugfs_u32_set(void *data, u64 val)
154{
155 *(u32 *)data = val;
156 return 0;
157}
158static int debugfs_u32_get(void *data, u64 *val)
159{
160 *val = *(u32 *)data;
161 return 0;
162}
163DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
164DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
165DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
166
167/**
168 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
169 * @name: a pointer to a string containing the name of the file to create.
170 * @mode: the permission that the file should have
171 * @parent: a pointer to the parent dentry for this file. This should be a
172 * directory dentry if set. If this parameter is %NULL, then the
173 * file will be created in the root of the debugfs filesystem.
174 * @value: a pointer to the variable that the file should read to and write
175 * from.
176 *
177 * This function creates a file in debugfs with the given name that
178 * contains the value of the variable @value. If the @mode variable is so
179 * set, it can be read from, and written to.
180 *
181 * This function will return a pointer to a dentry if it succeeds. This
182 * pointer must be passed to the debugfs_remove() function when the file is
183 * to be removed (no automatic cleanup happens if your module is unloaded,
184 * you are responsible here.) If an error occurs, %NULL will be returned.
185 *
186 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
187 * returned. It is not wise to check for this value, but rather, check for
188 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
189 * code.
190 */
191struct dentry *debugfs_create_u32(const char *name, umode_t mode,
192 struct dentry *parent, u32 *value)
193{
194 return debugfs_create_mode(name, mode, parent, value, &fops_u32,
195 &fops_u32_ro, &fops_u32_wo);
196}
197EXPORT_SYMBOL_GPL(debugfs_create_u32);
198
199static int debugfs_u64_set(void *data, u64 val)
200{
201 *(u64 *)data = val;
202 return 0;
203}
204
205static int debugfs_u64_get(void *data, u64 *val)
206{
207 *val = *(u64 *)data;
208 return 0;
209}
210DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
211DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
212DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
213
214/**
215 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
216 * @name: a pointer to a string containing the name of the file to create.
217 * @mode: the permission that the file should have
218 * @parent: a pointer to the parent dentry for this file. This should be a
219 * directory dentry if set. If this parameter is %NULL, then the
220 * file will be created in the root of the debugfs filesystem.
221 * @value: a pointer to the variable that the file should read to and write
222 * from.
223 *
224 * This function creates a file in debugfs with the given name that
225 * contains the value of the variable @value. If the @mode variable is so
226 * set, it can be read from, and written to.
227 *
228 * This function will return a pointer to a dentry if it succeeds. This
229 * pointer must be passed to the debugfs_remove() function when the file is
230 * to be removed (no automatic cleanup happens if your module is unloaded,
231 * you are responsible here.) If an error occurs, %NULL will be returned.
232 *
233 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
234 * returned. It is not wise to check for this value, but rather, check for
235 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
236 * code.
237 */
238struct dentry *debugfs_create_u64(const char *name, umode_t mode,
239 struct dentry *parent, u64 *value)
240{
241 return debugfs_create_mode(name, mode, parent, value, &fops_u64,
242 &fops_u64_ro, &fops_u64_wo);
243}
244EXPORT_SYMBOL_GPL(debugfs_create_u64);
245
246static int debugfs_ulong_set(void *data, u64 val)
247{
248 *(unsigned long *)data = val;
249 return 0;
250}
251
252static int debugfs_ulong_get(void *data, u64 *val)
253{
254 *val = *(unsigned long *)data;
255 return 0;
256}
257DEFINE_SIMPLE_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set, "%llu\n");
258DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
259DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
260
261/**
262 * debugfs_create_ulong - create a debugfs file that is used to read and write
263 * an unsigned long value.
264 * @name: a pointer to a string containing the name of the file to create.
265 * @mode: the permission that the file should have
266 * @parent: a pointer to the parent dentry for this file. This should be a
267 * directory dentry if set. If this parameter is %NULL, then the
268 * file will be created in the root of the debugfs filesystem.
269 * @value: a pointer to the variable that the file should read to and write
270 * from.
271 *
272 * This function creates a file in debugfs with the given name that
273 * contains the value of the variable @value. If the @mode variable is so
274 * set, it can be read from, and written to.
275 *
276 * This function will return a pointer to a dentry if it succeeds. This
277 * pointer must be passed to the debugfs_remove() function when the file is
278 * to be removed (no automatic cleanup happens if your module is unloaded,
279 * you are responsible here.) If an error occurs, %NULL will be returned.
280 *
281 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
282 * returned. It is not wise to check for this value, but rather, check for
283 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
284 * code.
285 */
286struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
287 struct dentry *parent, unsigned long *value)
288{
289 return debugfs_create_mode(name, mode, parent, value, &fops_ulong,
290 &fops_ulong_ro, &fops_ulong_wo);
291}
292EXPORT_SYMBOL_GPL(debugfs_create_ulong);
293
294DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
295DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
296DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
297
298DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
299DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
300DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
301
302DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
303DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
304DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
305
306DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
307DEFINE_SIMPLE_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
308DEFINE_SIMPLE_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
309
310/*
311 * 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
312 *
313 * These functions are exactly the same as the above functions (but use a hex
314 * output for the decimal challenged). For details look at the above unsigned
315 * decimal functions.
316 */
317
318/**
319 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
320 * @name: a pointer to a string containing the name of the file to create.
321 * @mode: the permission that the file should have
322 * @parent: a pointer to the parent dentry for this file. This should be a
323 * directory dentry if set. If this parameter is %NULL, then the
324 * file will be created in the root of the debugfs filesystem.
325 * @value: a pointer to the variable that the file should read to and write
326 * from.
327 */
328struct dentry *debugfs_create_x8(const char *name, umode_t mode,
329 struct dentry *parent, u8 *value)
330{
331 return debugfs_create_mode(name, mode, parent, value, &fops_x8,
332 &fops_x8_ro, &fops_x8_wo);
333}
334EXPORT_SYMBOL_GPL(debugfs_create_x8);
335
336/**
337 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
338 * @name: a pointer to a string containing the name of the file to create.
339 * @mode: the permission that the file should have
340 * @parent: a pointer to the parent dentry for this file. This should be a
341 * directory dentry if set. If this parameter is %NULL, then the
342 * file will be created in the root of the debugfs filesystem.
343 * @value: a pointer to the variable that the file should read to and write
344 * from.
345 */
346struct dentry *debugfs_create_x16(const char *name, umode_t mode,
347 struct dentry *parent, u16 *value)
348{
349 return debugfs_create_mode(name, mode, parent, value, &fops_x16,
350 &fops_x16_ro, &fops_x16_wo);
351}
352EXPORT_SYMBOL_GPL(debugfs_create_x16);
353
354/**
355 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
356 * @name: a pointer to a string containing the name of the file to create.
357 * @mode: the permission that the file should have
358 * @parent: a pointer to the parent dentry for this file. This should be a
359 * directory dentry if set. If this parameter is %NULL, then the
360 * file will be created in the root of the debugfs filesystem.
361 * @value: a pointer to the variable that the file should read to and write
362 * from.
363 */
364struct dentry *debugfs_create_x32(const char *name, umode_t mode,
365 struct dentry *parent, u32 *value)
366{
367 return debugfs_create_mode(name, mode, parent, value, &fops_x32,
368 &fops_x32_ro, &fops_x32_wo);
369}
370EXPORT_SYMBOL_GPL(debugfs_create_x32);
371
372/**
373 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
374 * @name: a pointer to a string containing the name of the file to create.
375 * @mode: the permission that the file should have
376 * @parent: a pointer to the parent dentry for this file. This should be a
377 * directory dentry if set. If this parameter is %NULL, then the
378 * file will be created in the root of the debugfs filesystem.
379 * @value: a pointer to the variable that the file should read to and write
380 * from.
381 */
382struct dentry *debugfs_create_x64(const char *name, umode_t mode,
383 struct dentry *parent, u64 *value)
384{
385 return debugfs_create_mode(name, mode, parent, value, &fops_x64,
386 &fops_x64_ro, &fops_x64_wo);
387}
388EXPORT_SYMBOL_GPL(debugfs_create_x64);
389
390
391static int debugfs_size_t_set(void *data, u64 val)
392{
393 *(size_t *)data = val;
394 return 0;
395}
396static int debugfs_size_t_get(void *data, u64 *val)
397{
398 *val = *(size_t *)data;
399 return 0;
400}
401DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
402 "%llu\n"); /* %llu and %zu are more or less the same */
403DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
404DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
405
406/**
407 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
408 * @name: a pointer to a string containing the name of the file to create.
409 * @mode: the permission that the file should have
410 * @parent: a pointer to the parent dentry for this file. This should be a
411 * directory dentry if set. If this parameter is %NULL, then the
412 * file will be created in the root of the debugfs filesystem.
413 * @value: a pointer to the variable that the file should read to and write
414 * from.
415 */
416struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
417 struct dentry *parent, size_t *value)
418{
419 return debugfs_create_mode(name, mode, parent, value, &fops_size_t,
420 &fops_size_t_ro, &fops_size_t_wo);
421}
422EXPORT_SYMBOL_GPL(debugfs_create_size_t);
423
424static int debugfs_atomic_t_set(void *data, u64 val)
425{
426 atomic_set((atomic_t *)data, val);
427 return 0;
428}
429static int debugfs_atomic_t_get(void *data, u64 *val)
430{
431 *val = atomic_read((atomic_t *)data);
432 return 0;
433}
434DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
435 debugfs_atomic_t_set, "%lld\n");
436DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
437DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
438
439/**
440 * debugfs_create_atomic_t - create a debugfs file that is used to read and
441 * write an atomic_t value
442 * @name: a pointer to a string containing the name of the file to create.
443 * @mode: the permission that the file should have
444 * @parent: a pointer to the parent dentry for this file. This should be a
445 * directory dentry if set. If this parameter is %NULL, then the
446 * file will be created in the root of the debugfs filesystem.
447 * @value: a pointer to the variable that the file should read to and write
448 * from.
449 */
450struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
451 struct dentry *parent, atomic_t *value)
452{
453 return debugfs_create_mode(name, mode, parent, value, &fops_atomic_t,
454 &fops_atomic_t_ro, &fops_atomic_t_wo);
455}
456EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
457
458ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
459 size_t count, loff_t *ppos)
460{
461 char buf[3];
462 bool *val = file->private_data;
463
464 if (*val)
465 buf[0] = 'Y';
466 else
467 buf[0] = 'N';
468 buf[1] = '\n';
469 buf[2] = 0x00;
470 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
471}
472EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
473
474ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
475 size_t count, loff_t *ppos)
476{
477 char buf[32];
478 size_t buf_size;
479 bool bv;
480 bool *val = file->private_data;
481
482 buf_size = min(count, (sizeof(buf)-1));
483 if (copy_from_user(buf, user_buf, buf_size))
484 return -EFAULT;
485
486 buf[buf_size] = '\0';
487 if (strtobool(buf, &bv) == 0)
488 *val = bv;
489
490 return count;
491}
492EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
493
494static const struct file_operations fops_bool = {
495 .read = debugfs_read_file_bool,
496 .write = debugfs_write_file_bool,
497 .open = simple_open,
498 .llseek = default_llseek,
499};
500
501static const struct file_operations fops_bool_ro = {
502 .read = debugfs_read_file_bool,
503 .open = simple_open,
504 .llseek = default_llseek,
505};
506
507static const struct file_operations fops_bool_wo = {
508 .write = debugfs_write_file_bool,
509 .open = simple_open,
510 .llseek = default_llseek,
511};
512
513/**
514 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
515 * @name: a pointer to a string containing the name of the file to create.
516 * @mode: the permission that the file should have
517 * @parent: a pointer to the parent dentry for this file. This should be a
518 * directory dentry if set. If this parameter is %NULL, then the
519 * file will be created in the root of the debugfs filesystem.
520 * @value: a pointer to the variable that the file should read to and write
521 * from.
522 *
523 * This function creates a file in debugfs with the given name that
524 * contains the value of the variable @value. If the @mode variable is so
525 * set, it can be read from, and written to.
526 *
527 * This function will return a pointer to a dentry if it succeeds. This
528 * pointer must be passed to the debugfs_remove() function when the file is
529 * to be removed (no automatic cleanup happens if your module is unloaded,
530 * you are responsible here.) If an error occurs, %NULL will be returned.
531 *
532 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
533 * returned. It is not wise to check for this value, but rather, check for
534 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
535 * code.
536 */
537struct dentry *debugfs_create_bool(const char *name, umode_t mode,
538 struct dentry *parent, bool *value)
539{
540 return debugfs_create_mode(name, mode, parent, value, &fops_bool,
541 &fops_bool_ro, &fops_bool_wo);
542}
543EXPORT_SYMBOL_GPL(debugfs_create_bool);
544
545static ssize_t read_file_blob(struct file *file, char __user *user_buf,
546 size_t count, loff_t *ppos)
547{
548 struct debugfs_blob_wrapper *blob = file->private_data;
549 return simple_read_from_buffer(user_buf, count, ppos, blob->data,
550 blob->size);
551}
552
553static const struct file_operations fops_blob = {
554 .read = read_file_blob,
555 .open = simple_open,
556 .llseek = default_llseek,
557};
558
559/**
560 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
561 * @name: a pointer to a string containing the name of the file to create.
562 * @mode: the permission that the file should have
563 * @parent: a pointer to the parent dentry for this file. This should be a
564 * directory dentry if set. If this parameter is %NULL, then the
565 * file will be created in the root of the debugfs filesystem.
566 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
567 * to the blob data and the size of the data.
568 *
569 * This function creates a file in debugfs with the given name that exports
570 * @blob->data as a binary blob. If the @mode variable is so set it can be
571 * read from. Writing is not supported.
572 *
573 * This function will return a pointer to a dentry if it succeeds. This
574 * pointer must be passed to the debugfs_remove() function when the file is
575 * to be removed (no automatic cleanup happens if your module is unloaded,
576 * you are responsible here.) If an error occurs, %NULL will be returned.
577 *
578 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
579 * returned. It is not wise to check for this value, but rather, check for
580 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
581 * code.
582 */
583struct dentry *debugfs_create_blob(const char *name, umode_t mode,
584 struct dentry *parent,
585 struct debugfs_blob_wrapper *blob)
586{
587 return debugfs_create_file(name, mode, parent, blob, &fops_blob);
588}
589EXPORT_SYMBOL_GPL(debugfs_create_blob);
590
591struct array_data {
592 void *array;
593 u32 elements;
594};
595
596static size_t u32_format_array(char *buf, size_t bufsize,
597 u32 *array, int array_size)
598{
599 size_t ret = 0;
600
601 while (--array_size >= 0) {
602 size_t len;
603 char term = array_size ? ' ' : '\n';
604
605 len = snprintf(buf, bufsize, "%u%c", *array++, term);
606 ret += len;
607
608 buf += len;
609 bufsize -= len;
610 }
611 return ret;
612}
613
614static int u32_array_open(struct inode *inode, struct file *file)
615{
616 struct array_data *data = inode->i_private;
617 int size, elements = data->elements;
618 char *buf;
619
620 /*
621 * Max size:
622 * - 10 digits + ' '/'\n' = 11 bytes per number
623 * - terminating NUL character
624 */
625 size = elements*11;
626 buf = kmalloc(size+1, GFP_KERNEL);
627 if (!buf)
628 return -ENOMEM;
629 buf[size] = 0;
630
631 file->private_data = buf;
632 u32_format_array(buf, size, data->array, data->elements);
633
634 return nonseekable_open(inode, file);
635}
636
637static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
638 loff_t *ppos)
639{
640 size_t size = strlen(file->private_data);
641
642 return simple_read_from_buffer(buf, len, ppos,
643 file->private_data, size);
644}
645
646static int u32_array_release(struct inode *inode, struct file *file)
647{
648 kfree(file->private_data);
649
650 return 0;
651}
652
653static const struct file_operations u32_array_fops = {
654 .owner = THIS_MODULE,
655 .open = u32_array_open,
656 .release = u32_array_release,
657 .read = u32_array_read,
658 .llseek = no_llseek,
659};
660
661/**
662 * debugfs_create_u32_array - create a debugfs file that is used to read u32
663 * array.
664 * @name: a pointer to a string containing the name of the file to create.
665 * @mode: the permission that the file should have.
666 * @parent: a pointer to the parent dentry for this file. This should be a
667 * directory dentry if set. If this parameter is %NULL, then the
668 * file will be created in the root of the debugfs filesystem.
669 * @array: u32 array that provides data.
670 * @elements: total number of elements in the array.
671 *
672 * This function creates a file in debugfs with the given name that exports
673 * @array as data. If the @mode variable is so set it can be read from.
674 * Writing is not supported. Seek within the file is also not supported.
675 * Once array is created its size can not be changed.
676 *
677 * The function returns a pointer to dentry on success. If debugfs is not
678 * enabled in the kernel, the value -%ENODEV will be returned.
679 */
680struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
681 struct dentry *parent,
682 u32 *array, u32 elements)
683{
684 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
685
686 if (data == NULL)
687 return NULL;
688
689 data->array = array;
690 data->elements = elements;
691
692 return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
693}
694EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
695
696#ifdef CONFIG_HAS_IOMEM
697
698/*
699 * The regset32 stuff is used to print 32-bit registers using the
700 * seq_file utilities. We offer printing a register set in an already-opened
701 * sequential file or create a debugfs file that only prints a regset32.
702 */
703
704/**
705 * debugfs_print_regs32 - use seq_print to describe a set of registers
706 * @s: the seq_file structure being used to generate output
707 * @regs: an array if struct debugfs_reg32 structures
708 * @nregs: the length of the above array
709 * @base: the base address to be used in reading the registers
710 * @prefix: a string to be prefixed to every output line
711 *
712 * This function outputs a text block describing the current values of
713 * some 32-bit hardware registers. It is meant to be used within debugfs
714 * files based on seq_file that need to show registers, intermixed with other
715 * information. The prefix argument may be used to specify a leading string,
716 * because some peripherals have several blocks of identical registers,
717 * for example configuration of dma channels
718 */
719void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
720 int nregs, void __iomem *base, char *prefix)
721{
722 int i;
723
724 for (i = 0; i < nregs; i++, regs++) {
725 if (prefix)
726 seq_printf(s, "%s", prefix);
727 seq_printf(s, "%s = 0x%08x\n", regs->name,
728 readl(base + regs->offset));
729 if (seq_has_overflowed(s))
730 break;
731 }
732}
733EXPORT_SYMBOL_GPL(debugfs_print_regs32);
734
735static int debugfs_show_regset32(struct seq_file *s, void *data)
736{
737 struct debugfs_regset32 *regset = s->private;
738
739 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
740 return 0;
741}
742
743static int debugfs_open_regset32(struct inode *inode, struct file *file)
744{
745 return single_open(file, debugfs_show_regset32, inode->i_private);
746}
747
748static const struct file_operations fops_regset32 = {
749 .open = debugfs_open_regset32,
750 .read = seq_read,
751 .llseek = seq_lseek,
752 .release = single_release,
753};
754
755/**
756 * debugfs_create_regset32 - create a debugfs file that returns register values
757 * @name: a pointer to a string containing the name of the file to create.
758 * @mode: the permission that the file should have
759 * @parent: a pointer to the parent dentry for this file. This should be a
760 * directory dentry if set. If this parameter is %NULL, then the
761 * file will be created in the root of the debugfs filesystem.
762 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
763 * to an array of register definitions, the array size and the base
764 * address where the register bank is to be found.
765 *
766 * This function creates a file in debugfs with the given name that reports
767 * the names and values of a set of 32-bit registers. If the @mode variable
768 * is so set it can be read from. Writing is not supported.
769 *
770 * This function will return a pointer to a dentry if it succeeds. This
771 * pointer must be passed to the debugfs_remove() function when the file is
772 * to be removed (no automatic cleanup happens if your module is unloaded,
773 * you are responsible here.) If an error occurs, %NULL will be returned.
774 *
775 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
776 * returned. It is not wise to check for this value, but rather, check for
777 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
778 * code.
779 */
780struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
781 struct dentry *parent,
782 struct debugfs_regset32 *regset)
783{
784 return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
785}
786EXPORT_SYMBOL_GPL(debugfs_create_regset32);
787
788#endif /* CONFIG_HAS_IOMEM */
789
790struct debugfs_devm_entry {
791 int (*read)(struct seq_file *seq, void *data);
792 struct device *dev;
793};
794
795static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
796{
797 struct debugfs_devm_entry *entry = inode->i_private;
798
799 return single_open(f, entry->read, entry->dev);
800}
801
802static const struct file_operations debugfs_devm_entry_ops = {
803 .owner = THIS_MODULE,
804 .open = debugfs_devm_entry_open,
805 .release = single_release,
806 .read = seq_read,
807 .llseek = seq_lseek
808};
809
810/**
811 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
812 *
813 * @dev: device related to this debugfs file.
814 * @name: name of the debugfs file.
815 * @parent: a pointer to the parent dentry for this file. This should be a
816 * directory dentry if set. If this parameter is %NULL, then the
817 * file will be created in the root of the debugfs filesystem.
818 * @read_fn: function pointer called to print the seq_file content.
819 */
820struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
821 struct dentry *parent,
822 int (*read_fn)(struct seq_file *s,
823 void *data))
824{
825 struct debugfs_devm_entry *entry;
826
827 if (IS_ERR(parent))
828 return ERR_PTR(-ENOENT);
829
830 entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
831 if (!entry)
832 return ERR_PTR(-ENOMEM);
833
834 entry->read = read_fn;
835 entry->dev = dev;
836
837 return debugfs_create_file(name, S_IRUGO, parent, entry,
838 &debugfs_devm_entry_ops);
839}
840EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
841