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 #include <linux/mutex.h>
  18
  19 #include <asm/uaccess.h>
  20
  21 #include "sysfs.h"
  22
  23 struct bin_buffer {
  24         struct mutex    mutex;
  25         void            *buffer;
  26         int             mmapped;
  27 };
  28
  29 static int
  30 fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
  31 {
  32         struct sysfs_dirent *attr_sd = dentry->d_fsdata;
  33         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
  34         struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
  35         int rc;
  36
  37         /* need attr_sd for attr, its parent for kobj */
  38         if (!sysfs_get_active_two(attr_sd))
  39                 return -ENODEV;
  40
  41         rc = -EIO;
  42         if (attr->read)
  43                 rc = attr->read(kobj, attr, buffer, off, count);
  44
  45         sysfs_put_active_two(attr_sd);
  46
  47         return rc;
  48 }
  49
  50 static ssize_t
  51 read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
  52 {
  53         struct bin_buffer *bb = file->private_data;
  54         struct dentry *dentry = file->f_path.dentry;
  55         int size = dentry->d_inode->i_size;
  56         loff_t offs = *off;
  57         int count = min_t(size_t, bytes, PAGE_SIZE);
  58
  59         if (size) {
  60                 if (offs > size)
  61                         return 0;
  62                 if (offs + count > size)
  63                         count = size - offs;
  64         }
  65
  66         mutex_lock(&bb->mutex);
  67
  68         count = fill_read(dentry, bb->buffer, offs, count);
  69         if (count < 0)
  70                 goto out_unlock;
  71
  72         if (copy_to_user(userbuf, bb->buffer, count)) {
  73                 count = -EFAULT;
  74                 goto out_unlock;
  75         }
  76
  77         pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
  78
  79         *off = offs + count;
  80
  81  out_unlock:
  82         mutex_unlock(&bb->mutex);
  83         return count;
  84 }
  85
  86 static int
  87 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
  88 {
  89         struct sysfs_dirent *attr_sd = dentry->d_fsdata;
  90         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
  91         struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
  92         int rc;
  93
  94         /* need attr_sd for attr, its parent for kobj */
  95         if (!sysfs_get_active_two(attr_sd))
  96                 return -ENODEV;
  97
  98         rc = -EIO;
  99         if (attr->write)
 100                 rc = attr->write(kobj, attr, buffer, offset, count);
 101
 102         sysfs_put_active_two(attr_sd);
 103
 104         return rc;
 105 }
 106
 107 static ssize_t write(struct file *file, const char __user *userbuf,
 108                      size_t bytes, loff_t *off)
 109 {
 110         struct bin_buffer *bb = file->private_data;
 111         struct dentry *dentry = file->f_path.dentry;
 112         int size = dentry->d_inode->i_size;
 113         loff_t offs = *off;
 114         int count = min_t(size_t, bytes, PAGE_SIZE);
 115
 116         if (size) {
 117                 if (offs > size)
 118                         return 0;
 119                 if (offs + count > size)
 120                         count = size - offs;
 121         }
 122
 123         mutex_lock(&bb->mutex);
 124
 125         if (copy_from_user(bb->buffer, userbuf, count)) {
 126                 count = -EFAULT;
 127                 goto out_unlock;
 128         }
 129
 130         count = flush_write(dentry, bb->buffer, offs, count);
 131         if (count > 0)
 132                 *off = offs + count;
 133
 134  out_unlock:
 135         mutex_unlock(&bb->mutex);
 136         return count;
 137 }
 138
 139 static int mmap(struct file *file, struct vm_area_struct *vma)
 140 {
 141         struct bin_buffer *bb = file->private_data;
 142         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 143         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
 144         struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
 145         int rc;
 146
 147         mutex_lock(&bb->mutex);
 148
 149         /* need attr_sd for attr, its parent for kobj */
 150         if (!sysfs_get_active_two(attr_sd))
 151                 return -ENODEV;
 152
 153         rc = -EINVAL;
 154         if (attr->mmap)
 155                 rc = attr->mmap(kobj, attr, vma);
 156
 157         if (rc == 0 && !bb->mmapped)
 158                 bb->mmapped = 1;
 159         else
 160                 sysfs_put_active_two(attr_sd);
 161
 162         mutex_unlock(&bb->mutex);
 163
 164         return rc;
 165 }
 166
 167 static int open(struct inode * inode, struct file * file)
 168 {
 169         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 170         struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
 171         struct bin_buffer *bb = NULL;
 172         int error;
 173
 174         /* binary file operations requires both @sd and its parent */
 175         if (!sysfs_get_active_two(attr_sd))
 176                 return -ENODEV;
 177
 178         error = -EACCES;
 179         if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
 180                 goto err_out;
 181         if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
 182                 goto err_out;
 183
 184         error = -ENOMEM;
 185         bb = kzalloc(sizeof(*bb), GFP_KERNEL);
 186         if (!bb)
 187                 goto err_out;
 188
 189         bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
 190         if (!bb->buffer)
 191                 goto err_out;
 192
 193         mutex_init(&bb->mutex);
 194         file->private_data = bb;
 195
 196         /* open succeeded, put active references */
 197         sysfs_put_active_two(attr_sd);
 198         return 0;
 199
 200  err_out:
 201         sysfs_put_active_two(attr_sd);
 202         kfree(bb);
 203         return error;
 204 }
 205
 206 static int release(struct inode * inode, struct file * file)
 207 {
 208         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 209         struct bin_buffer *bb = file->private_data;
 210
 211         if (bb->mmapped)
 212                 sysfs_put_active_two(attr_sd);
 213         kfree(bb->buffer);
 214         kfree(bb);
 215         return 0;
 216 }
 217
 218 const struct file_operations bin_fops = {
 219         .read           = read,
 220         .write          = write,
 221         .mmap           = mmap,
 222         .llseek         = generic_file_llseek,
 223         .open           = open,
 224         .release        = release,
 225 };
 226
 227 /**
 228  *      sysfs_create_bin_file - create binary file for object.
 229  *      @kobj:  object.
 230  *      @attr:  attribute descriptor.
 231  */
 232
 233 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 234 {
 235         BUG_ON(!kobj || !kobj->sd || !attr);
 236
 237         return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
 238 }
 239
 240
 241 /**
 242  *      sysfs_remove_bin_file - remove binary file for object.
 243  *      @kobj:  object.
 244  *      @attr:  attribute descriptor.
 245  */
 246
 247 void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 248 {
 249         sysfs_hash_and_remove(kobj->sd, attr->attr.name);
 250 }
 251
 252 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
 253 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);