fs/sysfs/bin.c

   1 /*
   2  * fs/sysfs/bin.c - sysfs binary file implementation
   3  *
   4  * Copyright (c) 2003 Patrick Mochel
   5  * Copyright (c) 2003 Matthew Wilcox
   6  * Copyright (c) 2004 Silicon Graphics, Inc.
   7  * Copyright (c) 2007 SUSE Linux Products GmbH
   8  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
   9  *
  10  * This file is released under the GPLv2.
  11  *
  12  * Please see Documentation/filesystems/sysfs.txt for more information.
  13  */
  14
  15 #undef DEBUG
  16
  17 #include <linux/errno.h>
  18 #include <linux/fs.h>
  19 #include <linux/kernel.h>
  20 #include <linux/kobject.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/mutex.h>
  24
  25 #include <asm/uaccess.h>
  26
  27 #include "sysfs.h"
  28
  29 struct bin_buffer {
  30         struct mutex    mutex;
  31         void            *buffer;
  32         int             mmapped;
  33 };
  34
  35 static int
  36 fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
  37 {
  38         struct sysfs_dirent *attr_sd = dentry->d_fsdata;
  39         struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
  40         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
  41         int rc;
  42
  43         /* need attr_sd for attr, its parent for kobj */
  44         if (!sysfs_get_active_two(attr_sd))
  45                 return -ENODEV;
  46
  47         rc = -EIO;
  48         if (attr->read)
  49                 rc = attr->read(kobj, attr, buffer, off, count);
  50
  51         sysfs_put_active_two(attr_sd);
  52
  53         return rc;
  54 }
  55
  56 static ssize_t
  57 read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
  58 {
  59         struct bin_buffer *bb = file->private_data;
  60         struct dentry *dentry = file->f_path.dentry;
  61         int size = dentry->d_inode->i_size;
  62         loff_t offs = *off;
  63         int count = min_t(size_t, bytes, PAGE_SIZE);
  64         char *temp;
  65
  66         if (!bytes)
  67                 return 0;
  68
  69         if (size) {
  70                 if (offs > size)
  71                         return 0;
  72                 if (offs + count > size)
  73                         count = size - offs;
  74         }
  75
  76         temp = kmalloc(count, GFP_KERNEL);
  77         if (!temp)
  78                 return -ENOMEM;
  79
  80         mutex_lock(&bb->mutex);
  81
  82         count = fill_read(dentry, bb->buffer, offs, count);
  83         if (count < 0) {
  84                 mutex_unlock(&bb->mutex);
  85                 goto out_free;
  86         }
  87
  88         memcpy(temp, bb->buffer, count);
  89
  90         mutex_unlock(&bb->mutex);
  91
  92         if (copy_to_user(userbuf, temp, count)) {
  93                 count = -EFAULT;
  94                 goto out_free;
  95         }
  96
  97         pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
  98
  99         *off = offs + count;
 100
 101  out_free:
 102         kfree(temp);
 103         return count;
 104 }
 105
 106 static int
 107 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
 108 {
 109         struct sysfs_dirent *attr_sd = dentry->d_fsdata;
 110         struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
 111         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
 112         int rc;
 113
 114         /* need attr_sd for attr, its parent for kobj */
 115         if (!sysfs_get_active_two(attr_sd))
 116                 return -ENODEV;
 117
 118         rc = -EIO;
 119         if (attr->write)
 120                 rc = attr->write(kobj, attr, buffer, offset, count);
 121
 122         sysfs_put_active_two(attr_sd);
 123
 124         return rc;
 125 }
 126
 127 static ssize_t write(struct file *file, const char __user *userbuf,
 128                      size_t bytes, loff_t *off)
 129 {
 130         struct bin_buffer *bb = file->private_data;
 131         struct dentry *dentry = file->f_path.dentry;
 132         int size = dentry->d_inode->i_size;
 133         loff_t offs = *off;
 134         int count = min_t(size_t, bytes, PAGE_SIZE);
 135         char *temp;
 136
 137         if (!bytes)
 138                 return 0;
 139
 140         if (size) {
 141                 if (offs > size)
 142                         return 0;
 143                 if (offs + count > size)
 144                         count = size - offs;
 145         }
 146
 147         temp = kmalloc(count, GFP_KERNEL);
 148         if (!temp)
 149                 return -ENOMEM;
 150
 151         if (copy_from_user(temp, userbuf, count)) {
 152                 count = -EFAULT;
 153                 goto out_free;
 154         }
 155
 156         mutex_lock(&bb->mutex);
 157
 158         memcpy(bb->buffer, temp, count);
 159
 160         count = flush_write(dentry, bb->buffer, offs, count);
 161         mutex_unlock(&bb->mutex);
 162
 163         if (count > 0)
 164                 *off = offs + count;
 165
 166 out_free:
 167         kfree(temp);
 168         return count;
 169 }
 170
 171 static int mmap(struct file *file, struct vm_area_struct *vma)
 172 {
 173         struct bin_buffer *bb = file->private_data;
 174         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 175         struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
 176         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
 177         int rc;
 178
 179         mutex_lock(&bb->mutex);
 180
 181         /* need attr_sd for attr, its parent for kobj */
 182         if (!sysfs_get_active_two(attr_sd))
 183                 return -ENODEV;
 184
 185         rc = -EINVAL;
 186         if (attr->mmap)
 187                 rc = attr->mmap(kobj, attr, vma);
 188
 189         if (rc == 0 && !bb->mmapped)
 190                 bb->mmapped = 1;
 191         else
 192                 sysfs_put_active_two(attr_sd);
 193
 194         mutex_unlock(&bb->mutex);
 195
 196         return rc;
 197 }
 198
 199 static int open(struct inode * inode, struct file * file)
 200 {
 201         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 202         struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
 203         struct bin_buffer *bb = NULL;
 204         int error;
 205
 206         /* binary file operations requires both @sd and its parent */
 207         if (!sysfs_get_active_two(attr_sd))
 208                 return -ENODEV;
 209
 210         error = -EACCES;
 211         if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
 212                 goto err_out;
 213         if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
 214                 goto err_out;
 215
 216         error = -ENOMEM;
 217         bb = kzalloc(sizeof(*bb), GFP_KERNEL);
 218         if (!bb)
 219                 goto err_out;
 220
 221         bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
 222         if (!bb->buffer)
 223                 goto err_out;
 224
 225         mutex_init(&bb->mutex);
 226         file->private_data = bb;
 227
 228         /* open succeeded, put active references */
 229         sysfs_put_active_two(attr_sd);
 230         return 0;
 231
 232  err_out:
 233         sysfs_put_active_two(attr_sd);
 234         kfree(bb);
 235         return error;
 236 }
 237
 238 static int release(struct inode * inode, struct file * file)
 239 {
 240         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
 241         struct bin_buffer *bb = file->private_data;
 242
 243         if (bb->mmapped)
 244                 sysfs_put_active_two(attr_sd);
 245         kfree(bb->buffer);
 246         kfree(bb);
 247         return 0;
 248 }
 249
 250 const struct file_operations bin_fops = {
 251         .read           = read,
 252         .write          = write,
 253         .mmap           = mmap,
 254         .llseek         = generic_file_llseek,
 255         .open           = open,
 256         .release        = release,
 257 };
 258
 259 /**
 260  *      sysfs_create_bin_file - create binary file for object.
 261  *      @kobj:  object.
 262  *      @attr:  attribute descriptor.
 263  */
 264
 265 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 266 {
 267         BUG_ON(!kobj || !kobj->sd || !attr);
 268
 269         return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
 270 }
 271
 272
 273 /**
 274  *      sysfs_remove_bin_file - remove binary file for object.
 275  *      @kobj:  object.
 276  *      @attr:  attribute descriptor.
 277  */
 278
 279 void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 280 {
 281         sysfs_hash_and_remove(kobj->sd, attr->attr.name);
 282 }
 283
 284 EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
 285 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);