• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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