fs/sysfs/bin.c

   1 /*
   2  * bin.c - binary file operations for sysfs.
   3  */
   4
   5 #undef DEBUG
   6
   7 #include <linux/errno.h>
   8 #include <linux/fs.h>
   9 #include <linux/kobject.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12
  13 #include <asm/uaccess.h>
  14
  15 #include "sysfs.h"
  16
  17 static int
  18 fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
  19 {
  20         struct bin_attribute * attr = dentry->d_fsdata;
  21         struct kobject * kobj = dentry->d_parent->d_fsdata;
  22
  23         return attr->read(kobj, buffer, off, count);
  24 }
  25
  26 static ssize_t
  27 read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
  28 {
  29         char *buffer = file->private_data;
  30         struct dentry *dentry = file->f_dentry;
  31         int size = dentry->d_inode->i_size;
  32         loff_t offs = *off;
  33         int ret;
  34
  35         if (count > PAGE_SIZE)
  36                 count = PAGE_SIZE;
  37
  38         if (size) {
  39                 if (offs > size)
  40                         return 0;
  41                 if (offs + count > size)
  42                         count = size - offs;
  43         }
  44
  45         ret = fill_read(dentry, buffer, offs, count);
  46         if (ret < 0)
  47                 return ret;
  48         count = ret;
  49
  50         if (copy_to_user(userbuf, buffer + offs, count) != 0)
  51                 return -EINVAL;
  52
  53         pr_debug("offs = %lld, *off = %lld, count = %zd\n", offs, *off, count);
  54
  55         *off = offs + count;
  56
  57         return count;
  58 }
  59
  60 static int
  61 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
  62 {
  63         struct bin_attribute *attr = dentry->d_fsdata;
  64         struct kobject *kobj = dentry->d_parent->d_fsdata;
  65
  66         return attr->write(kobj, buffer, offset, count);
  67 }
  68
  69 static ssize_t write(struct file * file, const char __user * userbuf,
  70                      size_t count, loff_t * off)
  71 {
  72         char *buffer = file->private_data;
  73         struct dentry *dentry = file->f_dentry;
  74         int size = dentry->d_inode->i_size;
  75         loff_t offs = *off;
  76
  77         if (count > PAGE_SIZE)
  78                 count = PAGE_SIZE;
  79         if (size) {
  80                 if (offs > size)
  81                         return 0;
  82                 if (offs + count > size)
  83                         count = size - offs;
  84         }
  85
  86         if (copy_from_user(buffer + offs, userbuf, count))
  87                 return -EFAULT;
  88
  89         count = flush_write(dentry, buffer, offs, count);
  90         if (count > 0)
  91                 *off = offs + count;
  92         return count;
  93 }
  94
  95 static int open(struct inode * inode, struct file * file)
  96 {
  97         struct kobject * kobj = kobject_get(file->f_dentry->d_parent->d_fsdata);
  98         struct bin_attribute * attr = file->f_dentry->d_fsdata;
  99         int error = -EINVAL;
 100
 101         if (!kobj || !attr)
 102                 goto Done;
 103
 104         error = -EACCES;
 105         if ((file->f_mode & FMODE_WRITE) && !attr->write)
 106                 goto Done;
 107         if ((file->f_mode & FMODE_READ) && !attr->read)
 108                 goto Done;
 109
 110         error = -ENOMEM;
 111         file->private_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
 112         if (!file->private_data)
 113                 goto Done;
 114
 115         error = 0;
 116
 117  Done:
 118         if (error && kobj)
 119                 kobject_put(kobj);
 120         return error;
 121 }
 122
 123 static int release(struct inode * inode, struct file * file)
 124 {
 125         struct kobject * kobj = file->f_dentry->d_parent->d_fsdata;
 126         u8 * buffer = file->private_data;
 127
 128         if (kobj)
 129                 kobject_put(kobj);
 130         kfree(buffer);
 131         return 0;
 132 }
 133
 134 static struct file_operations bin_fops = {
 135         .read           = read,
 136         .write          = write,
 137         .llseek         = generic_file_llseek,
 138         .open           = open,
 139         .release        = release,
 140 };
 141
 142 /**
 143  *      sysfs_create_bin_file - create binary file for object.
 144  *      @kobj:  object.
 145  *      @attr:  attribute descriptor.
 146  *
 147  */
 148
 149 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 150 {
 151         struct dentry * dentry;
 152         struct dentry * parent;
 153         int error = 0;
 154
 155         if (!kobj || !attr)
 156                 return -EINVAL;
 157
 158         parent = kobj->dentry;
 159
 160         down(&parent->d_inode->i_sem);
 161         dentry = sysfs_get_dentry(parent,attr->attr.name);
 162         if (!IS_ERR(dentry)) {
 163                 dentry->d_fsdata = (void *)attr;
 164                 error = sysfs_create(dentry,
 165                                      (attr->attr.mode & S_IALLUGO) | S_IFREG,
 166                                      NULL);
 167                 if (!error) {
 168                         dentry->d_inode->i_size = attr->size;
 169                         dentry->d_inode->i_fop = &bin_fops;
 170                 }
 171         } else
 172                 error = PTR_ERR(dentry);
 173         up(&parent->d_inode->i_sem);
 174         return error;
 175 }
 176
 177
 178 /**
 179  *      sysfs_remove_bin_file - remove binary file for object.
 180  *      @kobj:  object.
 181  *      @attr:  attribute descriptor.
 182  *
 183  */
 184
 185 int sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 186 {
 187         sysfs_hash_and_remove(kobj->dentry,attr->attr.name);
 188         return 0;
 189 }
 190
 191 EXPORT_SYMBOL(sysfs_create_bin_file);
 192 EXPORT_SYMBOL(sysfs_remove_bin_file);