bin.c 4.5 KB

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