]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - fs/sysfs/bin.c
Merge branch 'fix/hda' into for-linus
[linux-2.6-omap-h63xx.git] / fs / sysfs / bin.c
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
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
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
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
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
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
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
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
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
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);