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