blob: 96cc2bf6a84e424290aaa14f060c5a543e0b1af0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tejun Heo6d66f5c2007-09-20 17:31:38 +09002 * fs/sysfs/bin.c - sysfs binary file implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (c) 2003 Patrick Mochel
5 * Copyright (c) 2003 Matthew Wilcox
6 * Copyright (c) 2004 Silicon Graphics, Inc.
Tejun Heo6d66f5c2007-09-20 17:31:38 +09007 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 */
14
15#undef DEBUG
16
17#include <linux/errno.h>
18#include <linux/fs.h>
Randy.Dunlap995982c2006-07-10 23:05:25 -070019#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/kobject.h>
21#include <linux/module.h>
22#include <linux/slab.h>
Dave Young869512a2007-07-26 14:53:53 +000023#include <linux/mutex.h>
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -080024#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include <asm/uaccess.h>
27
28#include "sysfs.h"
29
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -080030/*
31 * There's one bin_buffer for each open file.
32 *
33 * filp->private_data points to bin_buffer and
34 * sysfs_dirent->s_bin_attr.buffers points to a the bin_buffer s
35 * sysfs_dirent->s_bin_attr.buffers is protected by sysfs_bin_lock
36 */
37static DEFINE_MUTEX(sysfs_bin_lock);
38
Tejun Heoeb361652007-06-14 03:45:16 +090039struct bin_buffer {
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -080040 struct mutex mutex;
41 void *buffer;
42 int mmapped;
43 struct vm_operations_struct *vm_ops;
44 struct file *file;
45 struct hlist_node list;
Tejun Heoeb361652007-06-14 03:45:16 +090046};
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048static int
49fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
50{
Tejun Heo3e519032007-06-14 03:45:15 +090051 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
Tejun Heob1fc3d62007-09-20 16:05:11 +090052 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
53 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
Tejun Heo0ab66082007-06-14 03:45:16 +090054 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Tejun Heo0ab66082007-06-14 03:45:16 +090056 /* need attr_sd for attr, its parent for kobj */
57 if (!sysfs_get_active_two(attr_sd))
58 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Tejun Heo0ab66082007-06-14 03:45:16 +090060 rc = -EIO;
61 if (attr->read)
Zhang Rui91a69022007-06-09 13:57:22 +080062 rc = attr->read(kobj, attr, buffer, off, count);
Tejun Heo0ab66082007-06-14 03:45:16 +090063
64 sysfs_put_active_two(attr_sd);
65
66 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067}
68
69static ssize_t
Tejun Heo93e3cd822007-06-14 03:45:13 +090070read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Tejun Heoeb361652007-06-14 03:45:16 +090072 struct bin_buffer *bb = file->private_data;
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -080073 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 int size = dentry->d_inode->i_size;
75 loff_t offs = *off;
Tejun Heo93e3cd822007-06-14 03:45:13 +090076 int count = min_t(size_t, bytes, PAGE_SIZE);
Nick Pigginb31ca3f2008-09-12 11:24:11 +020077 char *temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Greg Kroah-Hartman4503efd2009-01-20 15:51:16 -080079 if (!bytes)
80 return 0;
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 if (size) {
83 if (offs > size)
84 return 0;
85 if (offs + count > size)
86 count = size - offs;
87 }
88
Nick Pigginb31ca3f2008-09-12 11:24:11 +020089 temp = kmalloc(count, GFP_KERNEL);
90 if (!temp)
91 return -ENOMEM;
92
Tejun Heoeb361652007-06-14 03:45:16 +090093 mutex_lock(&bb->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Tejun Heoeb361652007-06-14 03:45:16 +090095 count = fill_read(dentry, bb->buffer, offs, count);
Nick Pigginb31ca3f2008-09-12 11:24:11 +020096 if (count < 0) {
97 mutex_unlock(&bb->mutex);
98 goto out_free;
99 }
Tejun Heoeb361652007-06-14 03:45:16 +0900100
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200101 memcpy(temp, bb->buffer, count);
102
103 mutex_unlock(&bb->mutex);
104
105 if (copy_to_user(userbuf, temp, count)) {
Tejun Heoeb361652007-06-14 03:45:16 +0900106 count = -EFAULT;
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200107 goto out_free;
Tejun Heoeb361652007-06-14 03:45:16 +0900108 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Tejun Heo93e3cd822007-06-14 03:45:13 +0900110 pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112 *off = offs + count;
113
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200114 out_free:
115 kfree(temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return count;
117}
118
119static int
120flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
121{
Tejun Heo3e519032007-06-14 03:45:15 +0900122 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900123 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
124 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
Tejun Heo0ab66082007-06-14 03:45:16 +0900125 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Tejun Heo0ab66082007-06-14 03:45:16 +0900127 /* need attr_sd for attr, its parent for kobj */
128 if (!sysfs_get_active_two(attr_sd))
129 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Tejun Heo0ab66082007-06-14 03:45:16 +0900131 rc = -EIO;
132 if (attr->write)
Zhang Rui91a69022007-06-09 13:57:22 +0800133 rc = attr->write(kobj, attr, buffer, offset, count);
Tejun Heo0ab66082007-06-14 03:45:16 +0900134
135 sysfs_put_active_two(attr_sd);
136
137 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138}
139
Tejun Heo93e3cd822007-06-14 03:45:13 +0900140static ssize_t write(struct file *file, const char __user *userbuf,
141 size_t bytes, loff_t *off)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Tejun Heoeb361652007-06-14 03:45:16 +0900143 struct bin_buffer *bb = file->private_data;
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -0800144 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 int size = dentry->d_inode->i_size;
146 loff_t offs = *off;
Tejun Heo93e3cd822007-06-14 03:45:13 +0900147 int count = min_t(size_t, bytes, PAGE_SIZE);
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200148 char *temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Greg Kroah-Hartman4503efd2009-01-20 15:51:16 -0800150 if (!bytes)
151 return 0;
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 if (size) {
154 if (offs > size)
155 return 0;
156 if (offs + count > size)
157 count = size - offs;
158 }
159
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200160 temp = kmalloc(count, GFP_KERNEL);
161 if (!temp)
162 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200164 if (copy_from_user(temp, userbuf, count)) {
Tejun Heoeb361652007-06-14 03:45:16 +0900165 count = -EFAULT;
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200166 goto out_free;
Tejun Heoeb361652007-06-14 03:45:16 +0900167 }
168
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200169 mutex_lock(&bb->mutex);
170
171 memcpy(bb->buffer, temp, count);
172
Tejun Heoeb361652007-06-14 03:45:16 +0900173 count = flush_write(dentry, bb->buffer, offs, count);
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200174 mutex_unlock(&bb->mutex);
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 if (count > 0)
177 *off = offs + count;
Tejun Heoeb361652007-06-14 03:45:16 +0900178
Nick Pigginb31ca3f2008-09-12 11:24:11 +0200179out_free:
180 kfree(temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return count;
182}
183
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800184static void bin_vma_open(struct vm_area_struct *vma)
185{
186 struct file *file = vma->vm_file;
187 struct bin_buffer *bb = file->private_data;
188 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
189
190 if (!bb->vm_ops || !bb->vm_ops->open)
191 return;
192
193 if (!sysfs_get_active_two(attr_sd))
194 return;
195
196 bb->vm_ops->open(vma);
197
198 sysfs_put_active_two(attr_sd);
199}
200
201static void bin_vma_close(struct vm_area_struct *vma)
202{
203 struct file *file = vma->vm_file;
204 struct bin_buffer *bb = file->private_data;
205 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
206
207 if (!bb->vm_ops || !bb->vm_ops->close)
208 return;
209
210 if (!sysfs_get_active_two(attr_sd))
211 return;
212
213 bb->vm_ops->close(vma);
214
215 sysfs_put_active_two(attr_sd);
216}
217
218static int bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
219{
220 struct file *file = vma->vm_file;
221 struct bin_buffer *bb = file->private_data;
222 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
223 int ret;
224
225 if (!bb->vm_ops || !bb->vm_ops->fault)
226 return VM_FAULT_SIGBUS;
227
228 if (!sysfs_get_active_two(attr_sd))
229 return VM_FAULT_SIGBUS;
230
231 ret = bb->vm_ops->fault(vma, vmf);
232
233 sysfs_put_active_two(attr_sd);
234 return ret;
235}
236
237static int bin_page_mkwrite(struct vm_area_struct *vma, struct page *page)
238{
239 struct file *file = vma->vm_file;
240 struct bin_buffer *bb = file->private_data;
241 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
242 int ret;
243
244 if (!bb->vm_ops || !bb->vm_ops->page_mkwrite)
245 return -EINVAL;
246
247 if (!sysfs_get_active_two(attr_sd))
248 return -EINVAL;
249
250 ret = bb->vm_ops->page_mkwrite(vma, page);
251
252 sysfs_put_active_two(attr_sd);
253 return ret;
254}
255
256static int bin_access(struct vm_area_struct *vma, unsigned long addr,
257 void *buf, int len, int write)
258{
259 struct file *file = vma->vm_file;
260 struct bin_buffer *bb = file->private_data;
261 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
262 int ret;
263
264 if (!bb->vm_ops || !bb->vm_ops->access)
265 return -EINVAL;
266
267 if (!sysfs_get_active_two(attr_sd))
268 return -EINVAL;
269
270 ret = bb->vm_ops->access(vma, addr, buf, len, write);
271
272 sysfs_put_active_two(attr_sd);
273 return ret;
274}
275
276static struct vm_operations_struct bin_vm_ops = {
277 .open = bin_vma_open,
278 .close = bin_vma_close,
279 .fault = bin_fault,
280 .page_mkwrite = bin_page_mkwrite,
281 .access = bin_access,
282};
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284static int mmap(struct file *file, struct vm_area_struct *vma)
285{
Tejun Heoeb361652007-06-14 03:45:16 +0900286 struct bin_buffer *bb = file->private_data;
Tejun Heo3e519032007-06-14 03:45:15 +0900287 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900288 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
289 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800290 struct vm_operations_struct *vm_ops;
Tejun Heoeb361652007-06-14 03:45:16 +0900291 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Tejun Heoeb361652007-06-14 03:45:16 +0900293 mutex_lock(&bb->mutex);
Tejun Heo0ab66082007-06-14 03:45:16 +0900294
295 /* need attr_sd for attr, its parent for kobj */
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800296 rc = -ENODEV;
Tejun Heo0ab66082007-06-14 03:45:16 +0900297 if (!sysfs_get_active_two(attr_sd))
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800298 goto out_unlock;
Tejun Heo0ab66082007-06-14 03:45:16 +0900299
300 rc = -EINVAL;
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800301 if (!attr->mmap)
302 goto out_put;
Tejun Heo0ab66082007-06-14 03:45:16 +0900303
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800304 rc = attr->mmap(kobj, attr, vma);
305 vm_ops = vma->vm_ops;
306 vma->vm_ops = &bin_vm_ops;
307 if (rc)
308 goto out_put;
Tejun Heo0ab66082007-06-14 03:45:16 +0900309
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800310 rc = -EINVAL;
311 if (bb->mmapped && bb->vm_ops != vma->vm_ops)
312 goto out_put;
313
314#ifdef CONFIG_NUMA
315 rc = -EINVAL;
316 if (vm_ops && ((vm_ops->set_policy || vm_ops->get_policy || vm_ops->migrate)))
317 goto out_put;
318#endif
319
320 rc = 0;
321 bb->mmapped = 1;
322 bb->vm_ops = vm_ops;
323out_put:
324 sysfs_put_active_two(attr_sd);
325out_unlock:
Tejun Heoeb361652007-06-14 03:45:16 +0900326 mutex_unlock(&bb->mutex);
327
328 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
331static int open(struct inode * inode, struct file * file)
332{
Tejun Heo3e519032007-06-14 03:45:15 +0900333 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900334 struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
Tejun Heoeb361652007-06-14 03:45:16 +0900335 struct bin_buffer *bb = NULL;
Tejun Heo0ab66082007-06-14 03:45:16 +0900336 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Tejun Heo078ce642007-09-20 16:05:10 +0900338 /* binary file operations requires both @sd and its parent */
339 if (!sysfs_get_active_two(attr_sd))
Tejun Heo0ab66082007-06-14 03:45:16 +0900340 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 error = -EACCES;
343 if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
Tejun Heo7b595752007-06-14 03:45:17 +0900344 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
Tejun Heo7b595752007-06-14 03:45:17 +0900346 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 error = -ENOMEM;
Tejun Heoeb361652007-06-14 03:45:16 +0900349 bb = kzalloc(sizeof(*bb), GFP_KERNEL);
350 if (!bb)
Tejun Heo7b595752007-06-14 03:45:17 +0900351 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Tejun Heoeb361652007-06-14 03:45:16 +0900353 bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
354 if (!bb->buffer)
Tejun Heo7b595752007-06-14 03:45:17 +0900355 goto err_out;
Tejun Heoeb361652007-06-14 03:45:16 +0900356
357 mutex_init(&bb->mutex);
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800358 bb->file = file;
Tejun Heoeb361652007-06-14 03:45:16 +0900359 file->private_data = bb;
360
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800361 mutex_lock(&sysfs_bin_lock);
362 hlist_add_head(&bb->list, &attr_sd->s_bin_attr.buffers);
363 mutex_unlock(&sysfs_bin_lock);
364
Tejun Heo078ce642007-09-20 16:05:10 +0900365 /* open succeeded, put active references */
366 sysfs_put_active_two(attr_sd);
Tejun Heo0ab66082007-06-14 03:45:16 +0900367 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Tejun Heo7b595752007-06-14 03:45:17 +0900369 err_out:
Tejun Heo078ce642007-09-20 16:05:10 +0900370 sysfs_put_active_two(attr_sd);
Tejun Heo0ab66082007-06-14 03:45:16 +0900371 kfree(bb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return error;
373}
374
375static int release(struct inode * inode, struct file * file)
376{
Tejun Heoeb361652007-06-14 03:45:16 +0900377 struct bin_buffer *bb = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800379 mutex_lock(&sysfs_bin_lock);
380 hlist_del(&bb->list);
381 mutex_unlock(&sysfs_bin_lock);
382
Tejun Heoeb361652007-06-14 03:45:16 +0900383 kfree(bb->buffer);
384 kfree(bb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 return 0;
386}
387
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800388const struct file_operations bin_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 .read = read,
390 .write = write,
391 .mmap = mmap,
392 .llseek = generic_file_llseek,
393 .open = open,
394 .release = release,
395};
396
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800397
398void unmap_bin_file(struct sysfs_dirent *attr_sd)
399{
400 struct bin_buffer *bb;
401 struct hlist_node *tmp;
402
403 if (sysfs_type(attr_sd) != SYSFS_KOBJ_BIN_ATTR)
404 return;
405
406 mutex_lock(&sysfs_bin_lock);
407
408 hlist_for_each_entry(bb, tmp, &attr_sd->s_bin_attr.buffers, list) {
409 struct inode *inode = bb->file->f_path.dentry->d_inode;
410
411 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
412 }
413
414 mutex_unlock(&sysfs_bin_lock);
415}
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417/**
418 * sysfs_create_bin_file - create binary file for object.
419 * @kobj: object.
420 * @attr: attribute descriptor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 */
422
423int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
424{
Tejun Heo608e2662007-06-14 04:27:22 +0900425 BUG_ON(!kobj || !kobj->sd || !attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Tejun Heo608e2662007-06-14 04:27:22 +0900427 return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428}
429
430
431/**
432 * sysfs_remove_bin_file - remove binary file for object.
433 * @kobj: object.
434 * @attr: attribute descriptor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 */
436
Randy.Dunlap995982c2006-07-10 23:05:25 -0700437void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
Alan Stern5f1835d2007-08-16 16:13:06 -0400439 sysfs_hash_and_remove(kobj->sd, attr->attr.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440}
441
442EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
443EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);