1 /*
2 * fs/sysfs/bin.c - sysfs binary file implementation
3 *
4 * Copyright (c) 2003 Patrick Mochel
5 * Copyright (c) 2003 Matthew Wilcox
6 * Copyright (c) 2004 Silicon Graphics, Inc.
7 * Copyright (c) 2007 SUSE Linux Products GmbH
8 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
9 *
10 * This file is released under the GPLv2.
11 *
12 * Please see Documentation/filesystems/sysfs.txt for more information.
13 */
14
15 #undef DEBUG
16
17 #include <linux/errno.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/kobject.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/mutex.h>
24
25 #include <asm/uaccess.h>
26
27 #include "sysfs.h"
28
29 struct bin_buffer {
30 struct mutex mutex;
31 void *buffer;
32 int mmapped;
33 };
34
35 static int
fill_read(struct dentry * dentry,char * buffer,loff_t off,size_t count)36 fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
37 {
38 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
39 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
40 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
41 int rc;
42
43 /* need attr_sd for attr, its parent for kobj */
44 if (!sysfs_get_active_two(attr_sd))
45 return -ENODEV;
46
47 rc = -EIO;
48 if (attr->read)
49 rc = attr->read(kobj, attr, buffer, off, count);
50
51 sysfs_put_active_two(attr_sd);
52
53 return rc;
54 }
55
56 static ssize_t
read(struct file * file,char __user * userbuf,size_t bytes,loff_t * off)57 read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
58 {
59 struct bin_buffer *bb = file->private_data;
60 struct dentry *dentry = file->f_path.dentry;
61 int size = dentry->d_inode->i_size;
62 loff_t offs = *off;
63 int count = min_t(size_t, bytes, PAGE_SIZE);
64 char *temp;
65
66 if (!bytes)
67 return 0;
68
69 if (size) {
70 if (offs > size)
71 return 0;
72 if (offs + count > size)
73 count = size - offs;
74 }
75
76 temp = kmalloc(count, GFP_KERNEL);
77 if (!temp)
78 return -ENOMEM;
79
80 mutex_lock(&bb->mutex);
81
82 count = fill_read(dentry, bb->buffer, offs, count);
83 if (count < 0) {
84 mutex_unlock(&bb->mutex);
85 goto out_free;
86 }
87
88 memcpy(temp, bb->buffer, count);
89
90 mutex_unlock(&bb->mutex);
91
92 if (copy_to_user(userbuf, temp, count)) {
93 count = -EFAULT;
94 goto out_free;
95 }
96
97 pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
98
99 *off = offs + count;
100
101 out_free:
102 kfree(temp);
103 return count;
104 }
105
106 static int
flush_write(struct dentry * dentry,char * buffer,loff_t offset,size_t count)107 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
108 {
109 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
110 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
111 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
112 int rc;
113
114 /* need attr_sd for attr, its parent for kobj */
115 if (!sysfs_get_active_two(attr_sd))
116 return -ENODEV;
117
118 rc = -EIO;
119 if (attr->write)
120 rc = attr->write(kobj, attr, buffer, offset, count);
121
122 sysfs_put_active_two(attr_sd);
123
124 return rc;
125 }
126
write(struct file * file,const char __user * userbuf,size_t bytes,loff_t * off)127 static ssize_t write(struct file *file, const char __user *userbuf,
128 size_t bytes, loff_t *off)
129 {
130 struct bin_buffer *bb = file->private_data;
131 struct dentry *dentry = file->f_path.dentry;
132 int size = dentry->d_inode->i_size;
133 loff_t offs = *off;
134 int count = min_t(size_t, bytes, PAGE_SIZE);
135 char *temp;
136
137 if (!bytes)
138 return 0;
139
140 if (size) {
141 if (offs > size)
142 return 0;
143 if (offs + count > size)
144 count = size - offs;
145 }
146
147 temp = kmalloc(count, GFP_KERNEL);
148 if (!temp)
149 return -ENOMEM;
150
151 if (copy_from_user(temp, userbuf, count)) {
152 count = -EFAULT;
153 goto out_free;
154 }
155
156 mutex_lock(&bb->mutex);
157
158 memcpy(bb->buffer, temp, count);
159
160 count = flush_write(dentry, bb->buffer, offs, count);
161 mutex_unlock(&bb->mutex);
162
163 if (count > 0)
164 *off = offs + count;
165
166 out_free:
167 kfree(temp);
168 return count;
169 }
170
mmap(struct file * file,struct vm_area_struct * vma)171 static int mmap(struct file *file, struct vm_area_struct *vma)
172 {
173 struct bin_buffer *bb = file->private_data;
174 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
175 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
176 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
177 int rc;
178
179 mutex_lock(&bb->mutex);
180
181 /* need attr_sd for attr, its parent for kobj */
182 if (!sysfs_get_active_two(attr_sd))
183 return -ENODEV;
184
185 rc = -EINVAL;
186 if (attr->mmap)
187 rc = attr->mmap(kobj, attr, vma);
188
189 if (rc == 0 && !bb->mmapped)
190 bb->mmapped = 1;
191 else
192 sysfs_put_active_two(attr_sd);
193
194 mutex_unlock(&bb->mutex);
195
196 return rc;
197 }
198
open(struct inode * inode,struct file * file)199 static int open(struct inode * inode, struct file * file)
200 {
201 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
202 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
203 struct bin_buffer *bb = NULL;
204 int error;
205
206 /* binary file operations requires both @sd and its parent */
207 if (!sysfs_get_active_two(attr_sd))
208 return -ENODEV;
209
210 error = -EACCES;
211 if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
212 goto err_out;
213 if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
214 goto err_out;
215
216 error = -ENOMEM;
217 bb = kzalloc(sizeof(*bb), GFP_KERNEL);
218 if (!bb)
219 goto err_out;
220
221 bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
222 if (!bb->buffer)
223 goto err_out;
224
225 mutex_init(&bb->mutex);
226 file->private_data = bb;
227
228 /* open succeeded, put active references */
229 sysfs_put_active_two(attr_sd);
230 return 0;
231
232 err_out:
233 sysfs_put_active_two(attr_sd);
234 kfree(bb);
235 return error;
236 }
237
release(struct inode * inode,struct file * file)238 static int release(struct inode * inode, struct file * file)
239 {
240 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
241 struct bin_buffer *bb = file->private_data;
242
243 if (bb->mmapped)
244 sysfs_put_active_two(attr_sd);
245 kfree(bb->buffer);
246 kfree(bb);
247 return 0;
248 }
249
250 const struct file_operations bin_fops = {
251 .read = read,
252 .write = write,
253 .mmap = mmap,
254 .llseek = generic_file_llseek,
255 .open = open,
256 .release = release,
257 };
258
259 /**
260 * sysfs_create_bin_file - create binary file for object.
261 * @kobj: object.
262 * @attr: attribute descriptor.
263 */
264
sysfs_create_bin_file(struct kobject * kobj,struct bin_attribute * attr)265 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
266 {
267 BUG_ON(!kobj || !kobj->sd || !attr);
268
269 return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
270 }
271
272
273 /**
274 * sysfs_remove_bin_file - remove binary file for object.
275 * @kobj: object.
276 * @attr: attribute descriptor.
277 */
278
sysfs_remove_bin_file(struct kobject * kobj,struct bin_attribute * attr)279 void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
280 {
281 sysfs_hash_and_remove(kobj->sd, attr->attr.name);
282 }
283
284 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
285 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
286