1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
4 * file.c - operations for regular (text) files.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public
17 * License along with this program; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 021110-1307, USA.
22 * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
24 * configfs Copyright (C) 2005 Oracle. All rights reserved.
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <asm/uaccess.h>
31 #include <asm/semaphore.h>
33 #include <linux/configfs.h>
34 #include "configfs_internal.h"
37 * A simple attribute can only be 4096 characters. Why 4k? Because the
38 * original code limited it to PAGE_SIZE. That's a bad idea, though,
39 * because an attribute of 16k on ia64 won't work on x86. So we limit to
40 * 4k, our minimum common page size.
42 #define SIMPLE_ATTR_SIZE 4096
44 struct configfs_buffer
{
48 struct configfs_item_operations
* ops
;
55 * fill_read_buffer - allocate and fill buffer from item.
56 * @dentry: dentry pointer.
57 * @buffer: data buffer for file.
59 * Allocate @buffer->page, if it hasn't been already, then call the
60 * config_item's show() method to fill the buffer with this attribute's
62 * This is called only once, on the file's first read.
64 static int fill_read_buffer(struct dentry
* dentry
, struct configfs_buffer
* buffer
)
66 struct configfs_attribute
* attr
= to_attr(dentry
);
67 struct config_item
* item
= to_item(dentry
->d_parent
);
68 struct configfs_item_operations
* ops
= buffer
->ops
;
73 buffer
->page
= (char *) get_zeroed_page(GFP_KERNEL
);
77 count
= ops
->show_attribute(item
,attr
,buffer
->page
);
78 buffer
->needs_read_fill
= 0;
79 BUG_ON(count
> (ssize_t
)SIMPLE_ATTR_SIZE
);
81 buffer
->count
= count
;
88 * configfs_read_file - read an attribute.
89 * @file: file pointer.
90 * @buf: buffer to fill.
91 * @count: number of bytes to read.
92 * @ppos: starting offset in file.
94 * Userspace wants to read an attribute file. The attribute descriptor
95 * is in the file's ->d_fsdata. The target item is in the directory's
98 * We call fill_read_buffer() to allocate and fill the buffer from the
99 * item's show() method exactly once (if the read is happening from
100 * the beginning of the file). That should fill the entire buffer with
101 * all the data the item has to offer for that attribute.
102 * We then call flush_read_buffer() to copy the buffer to userspace
103 * in the increments specified.
107 configfs_read_file(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
109 struct configfs_buffer
* buffer
= file
->private_data
;
113 if (buffer
->needs_read_fill
) {
114 if ((retval
= fill_read_buffer(file
->f_path
.dentry
,buffer
)))
117 pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
118 __FUNCTION__
, count
, *ppos
, buffer
->page
);
119 retval
= simple_read_from_buffer(buf
, count
, ppos
, buffer
->page
,
128 * fill_write_buffer - copy buffer from userspace.
129 * @buffer: data buffer for file.
130 * @buf: data from user.
131 * @count: number of bytes in @userbuf.
133 * Allocate @buffer->page if it hasn't been already, then
134 * copy the user-supplied buffer into it.
138 fill_write_buffer(struct configfs_buffer
* buffer
, const char __user
* buf
, size_t count
)
143 buffer
->page
= (char *)__get_free_pages(GFP_KERNEL
, 0);
147 if (count
>= SIMPLE_ATTR_SIZE
)
148 count
= SIMPLE_ATTR_SIZE
- 1;
149 error
= copy_from_user(buffer
->page
,buf
,count
);
150 buffer
->needs_read_fill
= 1;
151 /* if buf is assumed to contain a string, terminate it by \0,
152 * so e.g. sscanf() can scan the string easily */
153 buffer
->page
[count
] = 0;
154 return error
? -EFAULT
: count
;
159 * flush_write_buffer - push buffer to config_item.
160 * @dentry: dentry to the attribute
161 * @buffer: data buffer for file.
162 * @count: number of bytes
164 * Get the correct pointers for the config_item and the attribute we're
165 * dealing with, then call the store() method for the attribute,
166 * passing the buffer that we acquired in fill_write_buffer().
170 flush_write_buffer(struct dentry
* dentry
, struct configfs_buffer
* buffer
, size_t count
)
172 struct configfs_attribute
* attr
= to_attr(dentry
);
173 struct config_item
* item
= to_item(dentry
->d_parent
);
174 struct configfs_item_operations
* ops
= buffer
->ops
;
176 return ops
->store_attribute(item
,attr
,buffer
->page
,count
);
181 * configfs_write_file - write an attribute.
182 * @file: file pointer
183 * @buf: data to write
184 * @count: number of bytes
185 * @ppos: starting offset
187 * Similar to configfs_read_file(), though working in the opposite direction.
188 * We allocate and fill the data from the user in fill_write_buffer(),
189 * then push it to the config_item in flush_write_buffer().
190 * There is no easy way for us to know if userspace is only doing a partial
191 * write, so we don't support them. We expect the entire buffer to come
192 * on the first write.
193 * Hint: if you're writing a value, first read the file, modify only the
194 * the value you're changing, then write entire buffer back.
198 configfs_write_file(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
200 struct configfs_buffer
* buffer
= file
->private_data
;
204 len
= fill_write_buffer(buffer
, buf
, count
);
206 len
= flush_write_buffer(file
->f_path
.dentry
, buffer
, count
);
213 static int check_perm(struct inode
* inode
, struct file
* file
)
215 struct config_item
*item
= configfs_get_config_item(file
->f_path
.dentry
->d_parent
);
216 struct configfs_attribute
* attr
= to_attr(file
->f_path
.dentry
);
217 struct configfs_buffer
* buffer
;
218 struct configfs_item_operations
* ops
= NULL
;
224 /* Grab the module reference for this attribute if we have one */
225 if (!try_module_get(attr
->ca_owner
)) {
231 ops
= item
->ci_type
->ct_item_ops
;
235 /* File needs write support.
236 * The inode's perms must say it's ok,
237 * and we must have a store method.
239 if (file
->f_mode
& FMODE_WRITE
) {
241 if (!(inode
->i_mode
& S_IWUGO
) || !ops
->store_attribute
)
246 /* File needs read support.
247 * The inode's perms must say it's ok, and we there
248 * must be a show method for it.
250 if (file
->f_mode
& FMODE_READ
) {
251 if (!(inode
->i_mode
& S_IRUGO
) || !ops
->show_attribute
)
255 /* No error? Great, allocate a buffer for the file, and store it
256 * it in file->private_data for easy access.
258 buffer
= kzalloc(sizeof(struct configfs_buffer
),GFP_KERNEL
);
263 init_MUTEX(&buffer
->sem
);
264 buffer
->needs_read_fill
= 1;
266 file
->private_data
= buffer
;
275 module_put(attr
->ca_owner
);
278 config_item_put(item
);
282 static int configfs_open_file(struct inode
* inode
, struct file
* filp
)
284 return check_perm(inode
,filp
);
287 static int configfs_release(struct inode
* inode
, struct file
* filp
)
289 struct config_item
* item
= to_item(filp
->f_path
.dentry
->d_parent
);
290 struct configfs_attribute
* attr
= to_attr(filp
->f_path
.dentry
);
291 struct module
* owner
= attr
->ca_owner
;
292 struct configfs_buffer
* buffer
= filp
->private_data
;
295 config_item_put(item
);
296 /* After this point, attr should not be accessed. */
301 free_page((unsigned long)buffer
->page
);
307 const struct file_operations configfs_file_operations
= {
308 .read
= configfs_read_file
,
309 .write
= configfs_write_file
,
310 .llseek
= generic_file_llseek
,
311 .open
= configfs_open_file
,
312 .release
= configfs_release
,
316 int configfs_add_file(struct dentry
* dir
, const struct configfs_attribute
* attr
, int type
)
318 struct configfs_dirent
* parent_sd
= dir
->d_fsdata
;
319 umode_t mode
= (attr
->ca_mode
& S_IALLUGO
) | S_IFREG
;
322 mutex_lock(&dir
->d_inode
->i_mutex
);
323 error
= configfs_make_dirent(parent_sd
, NULL
, (void *) attr
, mode
, type
);
324 mutex_unlock(&dir
->d_inode
->i_mutex
);
331 * configfs_create_file - create an attribute file for an item.
332 * @item: item we're creating for.
333 * @attr: atrribute descriptor.
336 int configfs_create_file(struct config_item
* item
, const struct configfs_attribute
* attr
)
338 BUG_ON(!item
|| !item
->ci_dentry
|| !attr
);
340 return configfs_add_file(item
->ci_dentry
, attr
,