sysfs: make sysfs_dirent->s_element a union
[linux-2.6.git] / fs / sysfs / bin.c
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>
13 #include <linux/kernel.h>
14 #include <linux/kobject.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17
18 #include <asm/uaccess.h>
19 #include <asm/semaphore.h>
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 sysfs_dirent *attr_sd = dentry->d_fsdata;
27         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
28         struct kobject * kobj = to_kobj(dentry->d_parent);
29
30         if (!attr->read)
31                 return -EIO;
32
33         return attr->read(kobj, buffer, off, count);
34 }
35
36 static ssize_t
37 read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
38 {
39         char *buffer = file->private_data;
40         struct dentry *dentry = file->f_path.dentry;
41         int size = dentry->d_inode->i_size;
42         loff_t offs = *off;
43         int count = min_t(size_t, bytes, PAGE_SIZE);
44
45         if (size) {
46                 if (offs > size)
47                         return 0;
48                 if (offs + count > size)
49                         count = size - offs;
50         }
51
52         count = fill_read(dentry, buffer, offs, count);
53         if (count < 0)
54                 return count;
55
56         if (copy_to_user(userbuf, buffer, count))
57                 return -EFAULT;
58
59         pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
60
61         *off = offs + count;
62
63         return count;
64 }
65
66 static int
67 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
68 {
69         struct sysfs_dirent *attr_sd = dentry->d_fsdata;
70         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
71         struct kobject *kobj = to_kobj(dentry->d_parent);
72
73         if (!attr->write)
74                 return -EIO;
75
76         return attr->write(kobj, buffer, offset, count);
77 }
78
79 static ssize_t write(struct file *file, const char __user *userbuf,
80                      size_t bytes, loff_t *off)
81 {
82         char *buffer = file->private_data;
83         struct dentry *dentry = file->f_path.dentry;
84         int size = dentry->d_inode->i_size;
85         loff_t offs = *off;
86         int count = min_t(size_t, bytes, PAGE_SIZE);
87
88         if (size) {
89                 if (offs > size)
90                         return 0;
91                 if (offs + count > size)
92                         count = size - offs;
93         }
94
95         if (copy_from_user(buffer, userbuf, count))
96                 return -EFAULT;
97
98         count = flush_write(dentry, buffer, offs, count);
99         if (count > 0)
100                 *off = offs + count;
101         return count;
102 }
103
104 static int mmap(struct file *file, struct vm_area_struct *vma)
105 {
106         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
107         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
108         struct kobject *kobj = to_kobj(file->f_path.dentry->d_parent);
109
110         if (!attr->mmap)
111                 return -EINVAL;
112
113         return attr->mmap(kobj, attr, vma);
114 }
115
116 static int open(struct inode * inode, struct file * file)
117 {
118         struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
119         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
120         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
121         int error = -EINVAL;
122
123         if (!kobj || !attr)
124                 goto Done;
125
126         /* Grab the module reference for this attribute if we have one */
127         error = -ENODEV;
128         if (!try_module_get(attr->attr.owner)) 
129                 goto Done;
130
131         error = -EACCES;
132         if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
133                 goto Error;
134         if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
135                 goto Error;
136
137         error = -ENOMEM;
138         file->private_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
139         if (!file->private_data)
140                 goto Error;
141
142         error = 0;
143     goto Done;
144
145  Error:
146         module_put(attr->attr.owner);
147  Done:
148         if (error)
149                 kobject_put(kobj);
150         return error;
151 }
152
153 static int release(struct inode * inode, struct file * file)
154 {
155         struct kobject * kobj = to_kobj(file->f_path.dentry->d_parent);
156         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
157         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
158         u8 * buffer = file->private_data;
159
160         kobject_put(kobj);
161         module_put(attr->attr.owner);
162         kfree(buffer);
163         return 0;
164 }
165
166 const struct file_operations bin_fops = {
167         .read           = read,
168         .write          = write,
169         .mmap           = mmap,
170         .llseek         = generic_file_llseek,
171         .open           = open,
172         .release        = release,
173 };
174
175 /**
176  *      sysfs_create_bin_file - create binary file for object.
177  *      @kobj:  object.
178  *      @attr:  attribute descriptor.
179  */
180
181 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
182 {
183         BUG_ON(!kobj || !kobj->dentry || !attr);
184
185         return sysfs_add_file(kobj->dentry, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
186 }
187
188
189 /**
190  *      sysfs_remove_bin_file - remove binary file for object.
191  *      @kobj:  object.
192  *      @attr:  attribute descriptor.
193  */
194
195 void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
196 {
197         if (sysfs_hash_and_remove(kobj->dentry, attr->attr.name) < 0) {
198                 printk(KERN_ERR "%s: "
199                         "bad dentry or inode or no such file: \"%s\"\n",
200                         __FUNCTION__, attr->attr.name);
201                 dump_stack();
202         }
203 }
204
205 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
206 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);