~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/configfs/file.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <linux/vmalloc.h>
 32 #include <asm/uaccess.h>
 33 
 34 #include <linux/configfs.h>
 35 #include "configfs_internal.h"
 36 
 37 /*
 38  * A simple attribute can only be 4096 characters.  Why 4k?  Because the
 39  * original code limited it to PAGE_SIZE.  That's a bad idea, though,
 40  * because an attribute of 16k on ia64 won't work on x86.  So we limit to
 41  * 4k, our minimum common page size.
 42  */
 43 #define SIMPLE_ATTR_SIZE 4096
 44 
 45 struct configfs_buffer {
 46         size_t                  count;
 47         loff_t                  pos;
 48         char                    * page;
 49         struct configfs_item_operations * ops;
 50         struct mutex            mutex;
 51         int                     needs_read_fill;
 52         bool                    read_in_progress;
 53         bool                    write_in_progress;
 54         char                    *bin_buffer;
 55         int                     bin_buffer_size;
 56 };
 57 
 58 
 59 /**
 60  *      fill_read_buffer - allocate and fill buffer from item.
 61  *      @dentry:        dentry pointer.
 62  *      @buffer:        data buffer for file.
 63  *
 64  *      Allocate @buffer->page, if it hasn't been already, then call the
 65  *      config_item's show() method to fill the buffer with this attribute's
 66  *      data.
 67  *      This is called only once, on the file's first read.
 68  */
 69 static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buffer)
 70 {
 71         struct configfs_attribute * attr = to_attr(dentry);
 72         struct config_item * item = to_item(dentry->d_parent);
 73         int ret = 0;
 74         ssize_t count;
 75 
 76         if (!buffer->page)
 77                 buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
 78         if (!buffer->page)
 79                 return -ENOMEM;
 80 
 81         count = attr->show(item, buffer->page);
 82 
 83         buffer->needs_read_fill = 0;
 84         BUG_ON(count > (ssize_t)SIMPLE_ATTR_SIZE);
 85         if (count >= 0)
 86                 buffer->count = count;
 87         else
 88                 ret = count;
 89         return ret;
 90 }
 91 
 92 /**
 93  *      configfs_read_file - read an attribute.
 94  *      @file:  file pointer.
 95  *      @buf:   buffer to fill.
 96  *      @count: number of bytes to read.
 97  *      @ppos:  starting offset in file.
 98  *
 99  *      Userspace wants to read an attribute file. The attribute descriptor
100  *      is in the file's ->d_fsdata. The target item is in the directory's
101  *      ->d_fsdata.
102  *
103  *      We call fill_read_buffer() to allocate and fill the buffer from the
104  *      item's show() method exactly once (if the read is happening from
105  *      the beginning of the file). That should fill the entire buffer with
106  *      all the data the item has to offer for that attribute.
107  *      We then call flush_read_buffer() to copy the buffer to userspace
108  *      in the increments specified.
109  */
110 
111 static ssize_t
112 configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
113 {
114         struct configfs_buffer * buffer = file->private_data;
115         ssize_t retval = 0;
116 
117         mutex_lock(&buffer->mutex);
118         if (buffer->needs_read_fill) {
119                 if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
120                         goto out;
121         }
122         pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
123                  __func__, count, *ppos, buffer->page);
124         retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
125                                          buffer->count);
126 out:
127         mutex_unlock(&buffer->mutex);
128         return retval;
129 }
130 
131 /**
132  *      configfs_read_bin_file - read a binary attribute.
133  *      @file:  file pointer.
134  *      @buf:   buffer to fill.
135  *      @count: number of bytes to read.
136  *      @ppos:  starting offset in file.
137  *
138  *      Userspace wants to read a binary attribute file. The attribute
139  *      descriptor is in the file's ->d_fsdata. The target item is in the
140  *      directory's ->d_fsdata.
141  *
142  *      We check whether we need to refill the buffer. If so we will
143  *      call the attributes' attr->read() twice. The first time we
144  *      will pass a NULL as a buffer pointer, which the attributes' method
145  *      will use to return the size of the buffer required. If no error
146  *      occurs we will allocate the buffer using vmalloc and call
147  *      attr->read() again passing that buffer as an argument.
148  *      Then we just copy to user-space using simple_read_from_buffer.
149  */
150 
151 static ssize_t
152 configfs_read_bin_file(struct file *file, char __user *buf,
153                        size_t count, loff_t *ppos)
154 {
155         struct configfs_buffer *buffer = file->private_data;
156         struct dentry *dentry = file->f_path.dentry;
157         struct config_item *item = to_item(dentry->d_parent);
158         struct configfs_bin_attribute *bin_attr = to_bin_attr(dentry);
159         ssize_t retval = 0;
160         ssize_t len = min_t(size_t, count, PAGE_SIZE);
161 
162         mutex_lock(&buffer->mutex);
163 
164         /* we don't support switching read/write modes */
165         if (buffer->write_in_progress) {
166                 retval = -ETXTBSY;
167                 goto out;
168         }
169         buffer->read_in_progress = 1;
170 
171         if (buffer->needs_read_fill) {
172                 /* perform first read with buf == NULL to get extent */
173                 len = bin_attr->read(item, NULL, 0);
174                 if (len <= 0) {
175                         retval = len;
176                         goto out;
177                 }
178 
179                 /* do not exceed the maximum value */
180                 if (bin_attr->cb_max_size && len > bin_attr->cb_max_size) {
181                         retval = -EFBIG;
182                         goto out;
183                 }
184 
185                 buffer->bin_buffer = vmalloc(len);
186                 if (buffer->bin_buffer == NULL) {
187                         retval = -ENOMEM;
188                         goto out;
189                 }
190                 buffer->bin_buffer_size = len;
191 
192                 /* perform second read to fill buffer */
193                 len = bin_attr->read(item, buffer->bin_buffer, len);
194                 if (len < 0) {
195                         retval = len;
196                         vfree(buffer->bin_buffer);
197                         buffer->bin_buffer_size = 0;
198                         buffer->bin_buffer = NULL;
199                         goto out;
200                 }
201 
202                 buffer->needs_read_fill = 0;
203         }
204 
205         retval = simple_read_from_buffer(buf, count, ppos, buffer->bin_buffer,
206                                         buffer->bin_buffer_size);
207 out:
208         mutex_unlock(&buffer->mutex);
209         return retval;
210 }
211 
212 
213 /**
214  *      fill_write_buffer - copy buffer from userspace.
215  *      @buffer:        data buffer for file.
216  *      @buf:           data from user.
217  *      @count:         number of bytes in @userbuf.
218  *
219  *      Allocate @buffer->page if it hasn't been already, then
220  *      copy the user-supplied buffer into it.
221  */
222 
223 static int
224 fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count)
225 {
226         int error;
227 
228         if (!buffer->page)
229                 buffer->page = (char *)__get_free_pages(GFP_KERNEL, 0);
230         if (!buffer->page)
231                 return -ENOMEM;
232 
233         if (count >= SIMPLE_ATTR_SIZE)
234                 count = SIMPLE_ATTR_SIZE - 1;
235         error = copy_from_user(buffer->page,buf,count);
236         buffer->needs_read_fill = 1;
237         /* if buf is assumed to contain a string, terminate it by \0,
238          * so e.g. sscanf() can scan the string easily */
239         buffer->page[count] = 0;
240         return error ? -EFAULT : count;
241 }
242 
243 
244 /**
245  *      flush_write_buffer - push buffer to config_item.
246  *      @dentry:        dentry to the attribute
247  *      @buffer:        data buffer for file.
248  *      @count:         number of bytes
249  *
250  *      Get the correct pointers for the config_item and the attribute we're
251  *      dealing with, then call the store() method for the attribute,
252  *      passing the buffer that we acquired in fill_write_buffer().
253  */
254 
255 static int
256 flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size_t count)
257 {
258         struct configfs_attribute * attr = to_attr(dentry);
259         struct config_item * item = to_item(dentry->d_parent);
260 
261         return attr->store(item, buffer->page, count);
262 }
263 
264 
265 /**
266  *      configfs_write_file - write an attribute.
267  *      @file:  file pointer
268  *      @buf:   data to write
269  *      @count: number of bytes
270  *      @ppos:  starting offset
271  *
272  *      Similar to configfs_read_file(), though working in the opposite direction.
273  *      We allocate and fill the data from the user in fill_write_buffer(),
274  *      then push it to the config_item in flush_write_buffer().
275  *      There is no easy way for us to know if userspace is only doing a partial
276  *      write, so we don't support them. We expect the entire buffer to come
277  *      on the first write.
278  *      Hint: if you're writing a value, first read the file, modify only the
279  *      the value you're changing, then write entire buffer back.
280  */
281 
282 static ssize_t
283 configfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
284 {
285         struct configfs_buffer * buffer = file->private_data;
286         ssize_t len;
287 
288         mutex_lock(&buffer->mutex);
289         len = fill_write_buffer(buffer, buf, count);
290         if (len > 0)
291                 len = flush_write_buffer(file->f_path.dentry, buffer, len);
292         if (len > 0)
293                 *ppos += len;
294         mutex_unlock(&buffer->mutex);
295         return len;
296 }
297 
298 /**
299  *      configfs_write_bin_file - write a binary attribute.
300  *      @file:  file pointer
301  *      @buf:   data to write
302  *      @count: number of bytes
303  *      @ppos:  starting offset
304  *
305  *      Writing to a binary attribute file is similar to a normal read.
306  *      We buffer the consecutive writes (binary attribute files do not
307  *      support lseek) in a continuously growing buffer, but we don't
308  *      commit until the close of the file.
309  */
310 
311 static ssize_t
312 configfs_write_bin_file(struct file *file, const char __user *buf,
313                         size_t count, loff_t *ppos)
314 {
315         struct configfs_buffer *buffer = file->private_data;
316         struct dentry *dentry = file->f_path.dentry;
317         struct configfs_bin_attribute *bin_attr = to_bin_attr(dentry);
318         void *tbuf = NULL;
319         ssize_t len;
320 
321         mutex_lock(&buffer->mutex);
322 
323         /* we don't support switching read/write modes */
324         if (buffer->read_in_progress) {
325                 len = -ETXTBSY;
326                 goto out;
327         }
328         buffer->write_in_progress = 1;
329 
330         /* buffer grows? */
331         if (*ppos + count > buffer->bin_buffer_size) {
332 
333                 if (bin_attr->cb_max_size &&
334                         *ppos + count > bin_attr->cb_max_size) {
335                         len = -EFBIG;
336                 }
337 
338                 tbuf = vmalloc(*ppos + count);
339                 if (tbuf == NULL) {
340                         len = -ENOMEM;
341                         goto out;
342                 }
343 
344                 /* copy old contents */
345                 if (buffer->bin_buffer) {
346                         memcpy(tbuf, buffer->bin_buffer,
347                                 buffer->bin_buffer_size);
348                         vfree(buffer->bin_buffer);
349                 }
350 
351                 /* clear the new area */
352                 memset(tbuf + buffer->bin_buffer_size, 0,
353                         *ppos + count - buffer->bin_buffer_size);
354                 buffer->bin_buffer = tbuf;
355                 buffer->bin_buffer_size = *ppos + count;
356         }
357 
358         len = simple_write_to_buffer(buffer->bin_buffer,
359                         buffer->bin_buffer_size, ppos, buf, count);
360         if (len > 0)
361                 *ppos += len;
362 out:
363         mutex_unlock(&buffer->mutex);
364         return len;
365 }
366 
367 static int check_perm(struct inode * inode, struct file * file, int type)
368 {
369         struct config_item *item = configfs_get_config_item(file->f_path.dentry->d_parent);
370         struct configfs_attribute * attr = to_attr(file->f_path.dentry);
371         struct configfs_bin_attribute *bin_attr = NULL;
372         struct configfs_buffer * buffer;
373         struct configfs_item_operations * ops = NULL;
374         int error = 0;
375 
376         if (!item || !attr)
377                 goto Einval;
378 
379         if (type & CONFIGFS_ITEM_BIN_ATTR)
380                 bin_attr = to_bin_attr(file->f_path.dentry);
381 
382         /* Grab the module reference for this attribute if we have one */
383         if (!try_module_get(attr->ca_owner)) {
384                 error = -ENODEV;
385                 goto Done;
386         }
387 
388         if (item->ci_type)
389                 ops = item->ci_type->ct_item_ops;
390         else
391                 goto Eaccess;
392 
393         /* File needs write support.
394          * The inode's perms must say it's ok,
395          * and we must have a store method.
396          */
397         if (file->f_mode & FMODE_WRITE) {
398                 if (!(inode->i_mode & S_IWUGO))
399                         goto Eaccess;
400 
401                 if ((type & CONFIGFS_ITEM_ATTR) && !attr->store)
402                         goto Eaccess;
403 
404                 if ((type & CONFIGFS_ITEM_BIN_ATTR) && !bin_attr->write)
405                         goto Eaccess;
406         }
407 
408         /* File needs read support.
409          * The inode's perms must say it's ok, and we there
410          * must be a show method for it.
411          */
412         if (file->f_mode & FMODE_READ) {
413                 if (!(inode->i_mode & S_IRUGO))
414                         goto Eaccess;
415 
416                 if ((type & CONFIGFS_ITEM_ATTR) && !attr->show)
417                         goto Eaccess;
418 
419                 if ((type & CONFIGFS_ITEM_BIN_ATTR) && !bin_attr->read)
420                         goto Eaccess;
421         }
422 
423         /* No error? Great, allocate a buffer for the file, and store it
424          * it in file->private_data for easy access.
425          */
426         buffer = kzalloc(sizeof(struct configfs_buffer),GFP_KERNEL);
427         if (!buffer) {
428                 error = -ENOMEM;
429                 goto Enomem;
430         }
431         mutex_init(&buffer->mutex);
432         buffer->needs_read_fill = 1;
433         buffer->read_in_progress = 0;
434         buffer->write_in_progress = 0;
435         buffer->ops = ops;
436         file->private_data = buffer;
437         goto Done;
438 
439  Einval:
440         error = -EINVAL;
441         goto Done;
442  Eaccess:
443         error = -EACCES;
444  Enomem:
445         module_put(attr->ca_owner);
446  Done:
447         if (error && item)
448                 config_item_put(item);
449         return error;
450 }
451 
452 static int configfs_release(struct inode *inode, struct file *filp)
453 {
454         struct config_item * item = to_item(filp->f_path.dentry->d_parent);
455         struct configfs_attribute * attr = to_attr(filp->f_path.dentry);
456         struct module * owner = attr->ca_owner;
457         struct configfs_buffer * buffer = filp->private_data;
458 
459         if (item)
460                 config_item_put(item);
461         /* After this point, attr should not be accessed. */
462         module_put(owner);
463 
464         if (buffer) {
465                 if (buffer->page)
466                         free_page((unsigned long)buffer->page);
467                 mutex_destroy(&buffer->mutex);
468                 kfree(buffer);
469         }
470         return 0;
471 }
472 
473 static int configfs_open_file(struct inode *inode, struct file *filp)
474 {
475         return check_perm(inode, filp, CONFIGFS_ITEM_ATTR);
476 }
477 
478 static int configfs_open_bin_file(struct inode *inode, struct file *filp)
479 {
480         return check_perm(inode, filp, CONFIGFS_ITEM_BIN_ATTR);
481 }
482 
483 static int configfs_release_bin_file(struct inode *inode, struct file *filp)
484 {
485         struct configfs_buffer *buffer = filp->private_data;
486         struct dentry *dentry = filp->f_path.dentry;
487         struct config_item *item = to_item(dentry->d_parent);
488         struct configfs_bin_attribute *bin_attr = to_bin_attr(dentry);
489         ssize_t len = 0;
490         int ret;
491 
492         buffer->read_in_progress = 0;
493 
494         if (buffer->write_in_progress) {
495                 buffer->write_in_progress = 0;
496 
497                 len = bin_attr->write(item, buffer->bin_buffer,
498                                 buffer->bin_buffer_size);
499 
500                 /* vfree on NULL is safe */
501                 vfree(buffer->bin_buffer);
502                 buffer->bin_buffer = NULL;
503                 buffer->bin_buffer_size = 0;
504                 buffer->needs_read_fill = 1;
505         }
506 
507         ret = configfs_release(inode, filp);
508         if (len < 0)
509                 return len;
510         return ret;
511 }
512 
513 
514 const struct file_operations configfs_file_operations = {
515         .read           = configfs_read_file,
516         .write          = configfs_write_file,
517         .llseek         = generic_file_llseek,
518         .open           = configfs_open_file,
519         .release        = configfs_release,
520 };
521 
522 const struct file_operations configfs_bin_file_operations = {
523         .read           = configfs_read_bin_file,
524         .write          = configfs_write_bin_file,
525         .llseek         = NULL,         /* bin file is not seekable */
526         .open           = configfs_open_bin_file,
527         .release        = configfs_release_bin_file,
528 };
529 
530 /**
531  *      configfs_create_file - create an attribute file for an item.
532  *      @item:  item we're creating for.
533  *      @attr:  atrribute descriptor.
534  */
535 
536 int configfs_create_file(struct config_item * item, const struct configfs_attribute * attr)
537 {
538         struct dentry *dir = item->ci_dentry;
539         struct configfs_dirent *parent_sd = dir->d_fsdata;
540         umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
541         int error = 0;
542 
543         inode_lock_nested(d_inode(dir), I_MUTEX_NORMAL);
544         error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode,
545                                      CONFIGFS_ITEM_ATTR);
546         inode_unlock(d_inode(dir));
547 
548         return error;
549 }
550 
551 /**
552  *      configfs_create_bin_file - create a binary attribute file for an item.
553  *      @item:  item we're creating for.
554  *      @attr:  atrribute descriptor.
555  */
556 
557 int configfs_create_bin_file(struct config_item *item,
558                 const struct configfs_bin_attribute *bin_attr)
559 {
560         struct dentry *dir = item->ci_dentry;
561         struct configfs_dirent *parent_sd = dir->d_fsdata;
562         umode_t mode = (bin_attr->cb_attr.ca_mode & S_IALLUGO) | S_IFREG;
563         int error = 0;
564 
565         inode_lock_nested(dir->d_inode, I_MUTEX_NORMAL);
566         error = configfs_make_dirent(parent_sd, NULL, (void *) bin_attr, mode,
567                                      CONFIGFS_ITEM_BIN_ATTR);
568         inode_unlock(dir->d_inode);
569 
570         return error;
571 }
572 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp