Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
file.c
Go to the documentation of this file.
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * file.c - operations for regular (text) files.
5  *
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.
10  *
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.
15  *
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.
20  *
21  * Based on sysfs:
22  * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
23  *
24  * configfs Copyright (C) 2005 Oracle. All rights reserved.
25  */
26 
27 #include <linux/fs.h>
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/mutex.h>
31 #include <asm/uaccess.h>
32 
33 #include <linux/configfs.h>
34 #include "configfs_internal.h"
35 
36 /*
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.
41  */
42 #define SIMPLE_ATTR_SIZE 4096
43 
45  size_t count;
46  loff_t pos;
47  char * page;
49  struct mutex mutex;
51 };
52 
53 
64 static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buffer)
65 {
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;
69  int ret = 0;
70  ssize_t count;
71 
72  if (!buffer->page)
73  buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
74  if (!buffer->page)
75  return -ENOMEM;
76 
77  count = ops->show_attribute(item,attr,buffer->page);
78  buffer->needs_read_fill = 0;
80  if (count >= 0)
81  buffer->count = count;
82  else
83  ret = count;
84  return ret;
85 }
86 
106 static ssize_t
107 configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
108 {
109  struct configfs_buffer * buffer = file->private_data;
110  ssize_t retval = 0;
111 
112  mutex_lock(&buffer->mutex);
113  if (buffer->needs_read_fill) {
114  if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
115  goto out;
116  }
117  pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
118  __func__, count, *ppos, buffer->page);
119  retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
120  buffer->count);
121 out:
122  mutex_unlock(&buffer->mutex);
123  return retval;
124 }
125 
126 
137 static int
138 fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count)
139 {
140  int error;
141 
142  if (!buffer->page)
143  buffer->page = (char *)__get_free_pages(GFP_KERNEL, 0);
144  if (!buffer->page)
145  return -ENOMEM;
146 
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;
155 }
156 
157 
169 static int
170 flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size_t count)
171 {
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;
175 
176  return ops->store_attribute(item,attr,buffer->page,count);
177 }
178 
179 
197 static ssize_t
198 configfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
199 {
200  struct configfs_buffer * buffer = file->private_data;
201  ssize_t len;
202 
203  mutex_lock(&buffer->mutex);
204  len = fill_write_buffer(buffer, buf, count);
205  if (len > 0)
206  len = flush_write_buffer(file->f_path.dentry, buffer, count);
207  if (len > 0)
208  *ppos += len;
209  mutex_unlock(&buffer->mutex);
210  return len;
211 }
212 
213 static int check_perm(struct inode * inode, struct file * file)
214 {
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;
219  int error = 0;
220 
221  if (!item || !attr)
222  goto Einval;
223 
224  /* Grab the module reference for this attribute if we have one */
225  if (!try_module_get(attr->ca_owner)) {
226  error = -ENODEV;
227  goto Done;
228  }
229 
230  if (item->ci_type)
231  ops = item->ci_type->ct_item_ops;
232  else
233  goto Eaccess;
234 
235  /* File needs write support.
236  * The inode's perms must say it's ok,
237  * and we must have a store method.
238  */
239  if (file->f_mode & FMODE_WRITE) {
240 
241  if (!(inode->i_mode & S_IWUGO) || !ops->store_attribute)
242  goto Eaccess;
243 
244  }
245 
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.
249  */
250  if (file->f_mode & FMODE_READ) {
251  if (!(inode->i_mode & S_IRUGO) || !ops->show_attribute)
252  goto Eaccess;
253  }
254 
255  /* No error? Great, allocate a buffer for the file, and store it
256  * it in file->private_data for easy access.
257  */
258  buffer = kzalloc(sizeof(struct configfs_buffer),GFP_KERNEL);
259  if (!buffer) {
260  error = -ENOMEM;
261  goto Enomem;
262  }
263  mutex_init(&buffer->mutex);
264  buffer->needs_read_fill = 1;
265  buffer->ops = ops;
266  file->private_data = buffer;
267  goto Done;
268 
269  Einval:
270  error = -EINVAL;
271  goto Done;
272  Eaccess:
273  error = -EACCES;
274  Enomem:
275  module_put(attr->ca_owner);
276  Done:
277  if (error && item)
278  config_item_put(item);
279  return error;
280 }
281 
282 static int configfs_open_file(struct inode * inode, struct file * filp)
283 {
284  return check_perm(inode,filp);
285 }
286 
287 static int configfs_release(struct inode * inode, struct file * filp)
288 {
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;
293 
294  if (item)
295  config_item_put(item);
296  /* After this point, attr should not be accessed. */
297  module_put(owner);
298 
299  if (buffer) {
300  if (buffer->page)
301  free_page((unsigned long)buffer->page);
302  mutex_destroy(&buffer->mutex);
303  kfree(buffer);
304  }
305  return 0;
306 }
307 
309  .read = configfs_read_file,
310  .write = configfs_write_file,
311  .llseek = generic_file_llseek,
312  .open = configfs_open_file,
313  .release = configfs_release,
314 };
315 
316 
317 int configfs_add_file(struct dentry * dir, const struct configfs_attribute * attr, int type)
318 {
319  struct configfs_dirent * parent_sd = dir->d_fsdata;
320  umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
321  int error = 0;
322 
323  mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_NORMAL);
324  error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode, type);
325  mutex_unlock(&dir->d_inode->i_mutex);
326 
327  return error;
328 }
329 
330 
337 int configfs_create_file(struct config_item * item, const struct configfs_attribute * attr)
338 {
339  BUG_ON(!item || !item->ci_dentry || !attr);
340 
341  return configfs_add_file(item->ci_dentry, attr,
343 }
344