Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * bin.c - binary file operations for sysfs. |
| 3 | * |
| 4 | * Copyright (c) 2003 Patrick Mochel |
| 5 | * Copyright (c) 2003 Matthew Wilcox |
| 6 | * Copyright (c) 2004 Silicon Graphics, Inc. |
| 7 | */ |
| 8 | |
| 9 | #undef DEBUG |
| 10 | |
| 11 | #include <linux/errno.h> |
| 12 | #include <linux/fs.h> |
Randy.Dunlap | 995982c | 2006-07-10 23:05:25 -0700 | [diff] [blame] | 13 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/kobject.h> |
| 15 | #include <linux/module.h> |
| 16 | #include <linux/slab.h> |
| 17 | |
| 18 | #include <asm/uaccess.h> |
Oliver Neukum | 94bebf4 | 2006-12-20 10:52:44 +0100 | [diff] [blame] | 19 | #include <asm/semaphore.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | |
| 21 | #include "sysfs.h" |
| 22 | |
| 23 | static int |
| 24 | fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count) |
| 25 | { |
| 26 | struct bin_attribute * attr = to_bin_attr(dentry); |
| 27 | struct kobject * kobj = to_kobj(dentry->d_parent); |
| 28 | |
| 29 | if (!attr->read) |
Dmitry Torokhov | c76d0ab | 2005-04-29 01:22:00 -0500 | [diff] [blame] | 30 | return -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
| 32 | return attr->read(kobj, buffer, off, count); |
| 33 | } |
| 34 | |
| 35 | static ssize_t |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 36 | read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | { |
| 38 | char *buffer = file->private_data; |
Josef "Jeff" Sipek | f427f5d | 2006-12-08 02:36:36 -0800 | [diff] [blame] | 39 | struct dentry *dentry = file->f_path.dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | int size = dentry->d_inode->i_size; |
| 41 | loff_t offs = *off; |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 42 | int count = min_t(size_t, bytes, PAGE_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | |
| 44 | if (size) { |
| 45 | if (offs > size) |
| 46 | return 0; |
| 47 | if (offs + count > size) |
| 48 | count = size - offs; |
| 49 | } |
| 50 | |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 51 | count = fill_read(dentry, buffer, offs, count); |
| 52 | if (count < 0) |
| 53 | return count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | if (copy_to_user(userbuf, buffer, count)) |
| 56 | return -EFAULT; |
| 57 | |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 58 | pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | |
| 60 | *off = offs + count; |
| 61 | |
| 62 | return count; |
| 63 | } |
| 64 | |
| 65 | static int |
| 66 | flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count) |
| 67 | { |
| 68 | struct bin_attribute *attr = to_bin_attr(dentry); |
| 69 | struct kobject *kobj = to_kobj(dentry->d_parent); |
| 70 | |
| 71 | if (!attr->write) |
Dmitry Torokhov | c76d0ab | 2005-04-29 01:22:00 -0500 | [diff] [blame] | 72 | return -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | return attr->write(kobj, buffer, offset, count); |
| 75 | } |
| 76 | |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 77 | static ssize_t write(struct file *file, const char __user *userbuf, |
| 78 | size_t bytes, loff_t *off) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | { |
| 80 | char *buffer = file->private_data; |
Josef "Jeff" Sipek | f427f5d | 2006-12-08 02:36:36 -0800 | [diff] [blame] | 81 | struct dentry *dentry = file->f_path.dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | int size = dentry->d_inode->i_size; |
| 83 | loff_t offs = *off; |
Tejun Heo | 93e3cd8 | 2007-06-14 03:45:13 +0900 | [diff] [blame^] | 84 | int count = min_t(size_t, bytes, PAGE_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | if (size) { |
| 87 | if (offs > size) |
| 88 | return 0; |
| 89 | if (offs + count > size) |
| 90 | count = size - offs; |
| 91 | } |
| 92 | |
| 93 | if (copy_from_user(buffer, userbuf, count)) |
| 94 | return -EFAULT; |
| 95 | |
| 96 | count = flush_write(dentry, buffer, offs, count); |
| 97 | if (count > 0) |
| 98 | *off = offs + count; |
| 99 | return count; |
| 100 | } |
| 101 | |
| 102 | static int mmap(struct file *file, struct vm_area_struct *vma) |
| 103 | { |
Josef "Jeff" Sipek | f427f5d | 2006-12-08 02:36:36 -0800 | [diff] [blame] | 104 | struct dentry *dentry = file->f_path.dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | struct bin_attribute *attr = to_bin_attr(dentry); |
| 106 | struct kobject *kobj = to_kobj(dentry->d_parent); |
| 107 | |
| 108 | if (!attr->mmap) |
| 109 | return -EINVAL; |
| 110 | |
| 111 | return attr->mmap(kobj, attr, vma); |
| 112 | } |
| 113 | |
| 114 | static int open(struct inode * inode, struct file * file) |
| 115 | { |
Josef "Jeff" Sipek | f427f5d | 2006-12-08 02:36:36 -0800 | [diff] [blame] | 116 | struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent); |
| 117 | struct bin_attribute * attr = to_bin_attr(file->f_path.dentry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | int error = -EINVAL; |
| 119 | |
| 120 | if (!kobj || !attr) |
| 121 | goto Done; |
| 122 | |
| 123 | /* Grab the module reference for this attribute if we have one */ |
| 124 | error = -ENODEV; |
| 125 | if (!try_module_get(attr->attr.owner)) |
| 126 | goto Done; |
| 127 | |
| 128 | error = -EACCES; |
| 129 | if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap)) |
| 130 | goto Error; |
| 131 | if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap)) |
| 132 | goto Error; |
| 133 | |
| 134 | error = -ENOMEM; |
| 135 | file->private_data = kmalloc(PAGE_SIZE, GFP_KERNEL); |
| 136 | if (!file->private_data) |
| 137 | goto Error; |
| 138 | |
| 139 | error = 0; |
| 140 | goto Done; |
| 141 | |
| 142 | Error: |
| 143 | module_put(attr->attr.owner); |
| 144 | Done: |
Mariusz Kozlowski | f750653 | 2007-01-02 13:41:10 +0100 | [diff] [blame] | 145 | if (error) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | kobject_put(kobj); |
| 147 | return error; |
| 148 | } |
| 149 | |
| 150 | static int release(struct inode * inode, struct file * file) |
| 151 | { |
Josef "Jeff" Sipek | f427f5d | 2006-12-08 02:36:36 -0800 | [diff] [blame] | 152 | struct kobject * kobj = to_kobj(file->f_path.dentry->d_parent); |
| 153 | struct bin_attribute * attr = to_bin_attr(file->f_path.dentry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | u8 * buffer = file->private_data; |
| 155 | |
Mariusz Kozlowski | f750653 | 2007-01-02 13:41:10 +0100 | [diff] [blame] | 156 | kobject_put(kobj); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | module_put(attr->attr.owner); |
| 158 | kfree(buffer); |
| 159 | return 0; |
| 160 | } |
| 161 | |
Arjan van de Ven | 4b6f5d2 | 2006-03-28 01:56:42 -0800 | [diff] [blame] | 162 | const struct file_operations bin_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | .read = read, |
| 164 | .write = write, |
| 165 | .mmap = mmap, |
| 166 | .llseek = generic_file_llseek, |
| 167 | .open = open, |
| 168 | .release = release, |
| 169 | }; |
| 170 | |
| 171 | /** |
| 172 | * sysfs_create_bin_file - create binary file for object. |
| 173 | * @kobj: object. |
| 174 | * @attr: attribute descriptor. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | */ |
| 176 | |
| 177 | int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr) |
| 178 | { |
| 179 | BUG_ON(!kobj || !kobj->dentry || !attr); |
| 180 | |
| 181 | return sysfs_add_file(kobj->dentry, &attr->attr, SYSFS_KOBJ_BIN_ATTR); |
| 182 | } |
| 183 | |
| 184 | |
| 185 | /** |
| 186 | * sysfs_remove_bin_file - remove binary file for object. |
| 187 | * @kobj: object. |
| 188 | * @attr: attribute descriptor. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | */ |
| 190 | |
Randy.Dunlap | 995982c | 2006-07-10 23:05:25 -0700 | [diff] [blame] | 191 | void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | { |
Randy.Dunlap | 995982c | 2006-07-10 23:05:25 -0700 | [diff] [blame] | 193 | if (sysfs_hash_and_remove(kobj->dentry, attr->attr.name) < 0) { |
| 194 | printk(KERN_ERR "%s: " |
| 195 | "bad dentry or inode or no such file: \"%s\"\n", |
| 196 | __FUNCTION__, attr->attr.name); |
| 197 | dump_stack(); |
| 198 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | EXPORT_SYMBOL_GPL(sysfs_create_bin_file); |
| 202 | EXPORT_SYMBOL_GPL(sysfs_remove_bin_file); |