1 #include <linux/init.h> 2 #include <linux/debugfs.h> 3 #include <linux/slab.h> 4 #include <linux/module.h> 5 6 #include "debugfs.h" 7 8 static struct dentry *d_xen_debug; 9 10 struct dentry * __init xen_init_debugfs(void) 11 { 12 if (!d_xen_debug) { 13 d_xen_debug = debugfs_create_dir("xen", NULL); 14 15 if (!d_xen_debug) 16 pr_warning("Could not create 'xen' debugfs directory\n"); 17 } 18 19 return d_xen_debug; 20 } 21 22 struct array_data 23 { 24 void *array; 25 unsigned elements; 26 }; 27 28 static int u32_array_open(struct inode *inode, struct file *file) 29 { 30 file->private_data = NULL; 31 return nonseekable_open(inode, file); 32 } 33 34 static size_t format_array(char *buf, size_t bufsize, const char *fmt, 35 u32 *array, unsigned array_size) 36 { 37 size_t ret = 0; 38 unsigned i; 39 40 for(i = 0; i < array_size; i++) { 41 size_t len; 42 43 len = snprintf(buf, bufsize, fmt, array[i]); 44 len++; /* ' ' or '\n' */ 45 ret += len; 46 47 if (buf) { 48 buf += len; 49 bufsize -= len; 50 buf[-1] = (i == array_size-1) ? '\n' : ' '; 51 } 52 } 53 54 ret++; /* \0 */ 55 if (buf) 56 *buf = '\0'; 57 58 return ret; 59 } 60 61 static char *format_array_alloc(const char *fmt, u32 *array, unsigned array_size) 62 { 63 size_t len = format_array(NULL, 0, fmt, array, array_size); 64 char *ret; 65 66 ret = kmalloc(len, GFP_KERNEL); 67 if (ret == NULL) 68 return NULL; 69 70 format_array(ret, len, fmt, array, array_size); 71 return ret; 72 } 73 74 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len, 75 loff_t *ppos) 76 { 77 struct inode *inode = file->f_path.dentry->d_inode; 78 struct array_data *data = inode->i_private; 79 size_t size; 80 81 if (*ppos == 0) { 82 if (file->private_data) { 83 kfree(file->private_data); 84 file->private_data = NULL; 85 } 86 87 file->private_data = format_array_alloc("%u", data->array, data->elements); 88 } 89 90 size = 0; 91 if (file->private_data) 92 size = strlen(file->private_data); 93 94 return simple_read_from_buffer(buf, len, ppos, file->private_data, size); 95 } 96 97 static int xen_array_release(struct inode *inode, struct file *file) 98 { 99 kfree(file->private_data); 100 101 return 0; 102 } 103 104 static const struct file_operations u32_array_fops = { 105 .owner = THIS_MODULE, 106 .open = u32_array_open, 107 .release= xen_array_release, 108 .read = u32_array_read, 109 }; 110 111 struct dentry *xen_debugfs_create_u32_array(const char *name, mode_t mode, 112 struct dentry *parent, 113 u32 *array, unsigned elements) 114 { 115 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL); 116 117 if (data == NULL) 118 return NULL; 119 120 data->array = array; 121 data->elements = elements; 122 123 return debugfs_create_file(name, mode, parent, data, &u32_array_fops); 124 } 125