Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 3124eb1679b28726eacbc8973a891235dca3ed99

Authored by Tejun Heo
Committed by Greg Kroah-Hartman
1 parent 49fe604781
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

sysfs: merge regular and bin file handling 

With the previous changes, sysfs regular file code is ready to handle
bin files too.  This patch makes bin files share the regular file
path.

* sysfs_create/remove_bin_file() are moved to fs/sysfs/file.c.

* sysfs_init_inode() is updated to use the new sysfs_bin_operations
  instead of bin_fops for bin files.

* fs/sysfs/bin.c and the related pieces are removed.

This patch shouldn't introduce any behavior difference to bin file
accesses.

Overall, this unification reduces the amount of duplicate logic, makes
behaviors more consistent and paves the road for building simpler and
more versatile interface which will allow other subsystems to make use
of sysfs for their pseudo filesystems.

v2: Stale fs/sysfs/bin.c reference dropped from
    Documentation/DocBook/filesystems.tmpl.  Reported by kbuild test
    robot.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Kay Sievers <kay@vrfy.org>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 7 changed files with 28 additions and 502 deletions Side-by-side Diff

Documentation/DocBook/filesystems.tmpl
Diff comments   View file @ 3124eb1
... ... @@ -91,7 +91,6 @@
91 91 <title>The Filesystem for Exporting Kernel Objects</title>
92 92 !Efs/sysfs/file.c
93 93 !Efs/sysfs/symlink.c
94   -!Efs/sysfs/bin.c
95 94 </chapter>
96 95  
97 96 <chapter id="debugfs">
... ... @@ -2,6 +2,5 @@
2 2 # Makefile for the sysfs virtual filesystem
3 3 #
4 4  
5   -obj-y := inode.o file.o dir.o symlink.o mount.o bin.o \
6   - group.o
  5 +obj-y := inode.o file.o dir.o symlink.o mount.o group.o
fs/sysfs/bin.c
View file @ 3124eb1
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   -#include <linux/mm.h>
25   -#include <linux/uaccess.h>
26   -
27   -#include "sysfs.h"
28   -
29   -/*
30   - * There's one bin_buffer for each open file.
31   - *
32   - * filp->private_data points to bin_buffer and
33   - * sysfs_dirent->s_bin_attr.buffers points to a the bin_buffer s
34   - * sysfs_dirent->s_bin_attr.buffers is protected by sysfs_bin_lock
35   - */
36   -static DEFINE_MUTEX(sysfs_bin_lock);
37   -
38   -struct bin_buffer {
39   - struct mutex mutex;
40   - void *buffer;
41   - int mmapped;
42   - const struct vm_operations_struct *vm_ops;
43   - struct file *file;
44   - struct hlist_node list;
45   -};
46   -
47   -static ssize_t
48   -read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
49   -{
50   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
51   - struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
52   - struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
53   - struct bin_buffer *bb = file->private_data;
54   - int size = file_inode(file)->i_size;
55   - loff_t offs = *off;
56   - int count = min_t(size_t, bytes, PAGE_SIZE);
57   - char *buf;
58   -
59   - if (!bytes)
60   - return 0;
61   -
62   - if (size) {
63   - if (offs > size)
64   - return 0;
65   - if (offs + count > size)
66   - count = size - offs;
67   - }
68   -
69   - buf = kmalloc(count, GFP_KERNEL);
70   - if (!buf)
71   - return -ENOMEM;
72   -
73   - /* need attr_sd for attr, its parent for kobj */
74   - mutex_lock(&bb->mutex);
75   - if (!sysfs_get_active(attr_sd)) {
76   - count = -ENODEV;
77   - mutex_unlock(&bb->mutex);
78   - goto out_free;
79   - }
80   -
81   - if (attr->read)
82   - count = attr->read(file, kobj, attr, buf, offs, count);
83   - else
84   - count = -EIO;
85   -
86   - sysfs_put_active(attr_sd);
87   - mutex_unlock(&bb->mutex);
88   -
89   - if (count < 0)
90   - goto out_free;
91   -
92   - if (copy_to_user(userbuf, buf, 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(buf);
103   - return count;
104   -}
105   -
106   -static int
107   -flush_write(struct file *file, char *buffer, loff_t offset, size_t count)
108   -{
109   - struct sysfs_dirent *attr_sd = file->f_path.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(attr_sd))
116   - return -ENODEV;
117   -
118   - rc = -EIO;
119   - if (attr->write)
120   - rc = attr->write(file, kobj, attr, buffer, offset, count);
121   -
122   - sysfs_put_active(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   - int size = file_inode(file)->i_size;
132   - loff_t offs = *off;
133   - int count = min_t(size_t, bytes, PAGE_SIZE);
134   - char *temp;
135   -
136   - if (!bytes)
137   - return 0;
138   -
139   - if (size) {
140   - if (offs > size)
141   - return 0;
142   - if (offs + count > size)
143   - count = size - offs;
144   - }
145   -
146   - temp = memdup_user(userbuf, count);
147   - if (IS_ERR(temp))
148   - return PTR_ERR(temp);
149   -
150   - mutex_lock(&bb->mutex);
151   -
152   - memcpy(bb->buffer, temp, count);
153   -
154   - count = flush_write(file, bb->buffer, offs, count);
155   - mutex_unlock(&bb->mutex);
156   -
157   - if (count > 0)
158   - *off = offs + count;
159   -
160   - kfree(temp);
161   - return count;
162   -}
163   -
164   -static void bin_vma_open(struct vm_area_struct *vma)
165   -{
166   - struct file *file = vma->vm_file;
167   - struct bin_buffer *bb = file->private_data;
168   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
169   -
170   - if (!bb->vm_ops)
171   - return;
172   -
173   - if (!sysfs_get_active(attr_sd))
174   - return;
175   -
176   - if (bb->vm_ops->open)
177   - bb->vm_ops->open(vma);
178   -
179   - sysfs_put_active(attr_sd);
180   -}
181   -
182   -static int bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
183   -{
184   - struct file *file = vma->vm_file;
185   - struct bin_buffer *bb = file->private_data;
186   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
187   - int ret;
188   -
189   - if (!bb->vm_ops)
190   - return VM_FAULT_SIGBUS;
191   -
192   - if (!sysfs_get_active(attr_sd))
193   - return VM_FAULT_SIGBUS;
194   -
195   - ret = VM_FAULT_SIGBUS;
196   - if (bb->vm_ops->fault)
197   - ret = bb->vm_ops->fault(vma, vmf);
198   -
199   - sysfs_put_active(attr_sd);
200   - return ret;
201   -}
202   -
203   -static int bin_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
204   -{
205   - struct file *file = vma->vm_file;
206   - struct bin_buffer *bb = file->private_data;
207   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
208   - int ret;
209   -
210   - if (!bb->vm_ops)
211   - return VM_FAULT_SIGBUS;
212   -
213   - if (!sysfs_get_active(attr_sd))
214   - return VM_FAULT_SIGBUS;
215   -
216   - ret = 0;
217   - if (bb->vm_ops->page_mkwrite)
218   - ret = bb->vm_ops->page_mkwrite(vma, vmf);
219   - else
220   - file_update_time(file);
221   -
222   - sysfs_put_active(attr_sd);
223   - return ret;
224   -}
225   -
226   -static int bin_access(struct vm_area_struct *vma, unsigned long addr,
227   - void *buf, int len, int write)
228   -{
229   - struct file *file = vma->vm_file;
230   - struct bin_buffer *bb = file->private_data;
231   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
232   - int ret;
233   -
234   - if (!bb->vm_ops)
235   - return -EINVAL;
236   -
237   - if (!sysfs_get_active(attr_sd))
238   - return -EINVAL;
239   -
240   - ret = -EINVAL;
241   - if (bb->vm_ops->access)
242   - ret = bb->vm_ops->access(vma, addr, buf, len, write);
243   -
244   - sysfs_put_active(attr_sd);
245   - return ret;
246   -}
247   -
248   -#ifdef CONFIG_NUMA
249   -static int bin_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
250   -{
251   - struct file *file = vma->vm_file;
252   - struct bin_buffer *bb = file->private_data;
253   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
254   - int ret;
255   -
256   - if (!bb->vm_ops)
257   - return 0;
258   -
259   - if (!sysfs_get_active(attr_sd))
260   - return -EINVAL;
261   -
262   - ret = 0;
263   - if (bb->vm_ops->set_policy)
264   - ret = bb->vm_ops->set_policy(vma, new);
265   -
266   - sysfs_put_active(attr_sd);
267   - return ret;
268   -}
269   -
270   -static struct mempolicy *bin_get_policy(struct vm_area_struct *vma,
271   - unsigned long addr)
272   -{
273   - struct file *file = vma->vm_file;
274   - struct bin_buffer *bb = file->private_data;
275   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
276   - struct mempolicy *pol;
277   -
278   - if (!bb->vm_ops)
279   - return vma->vm_policy;
280   -
281   - if (!sysfs_get_active(attr_sd))
282   - return vma->vm_policy;
283   -
284   - pol = vma->vm_policy;
285   - if (bb->vm_ops->get_policy)
286   - pol = bb->vm_ops->get_policy(vma, addr);
287   -
288   - sysfs_put_active(attr_sd);
289   - return pol;
290   -}
291   -
292   -static int bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
293   - const nodemask_t *to, unsigned long flags)
294   -{
295   - struct file *file = vma->vm_file;
296   - struct bin_buffer *bb = file->private_data;
297   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
298   - int ret;
299   -
300   - if (!bb->vm_ops)
301   - return 0;
302   -
303   - if (!sysfs_get_active(attr_sd))
304   - return 0;
305   -
306   - ret = 0;
307   - if (bb->vm_ops->migrate)
308   - ret = bb->vm_ops->migrate(vma, from, to, flags);
309   -
310   - sysfs_put_active(attr_sd);
311   - return ret;
312   -}
313   -#endif
314   -
315   -static const struct vm_operations_struct bin_vm_ops = {
316   - .open = bin_vma_open,
317   - .fault = bin_fault,
318   - .page_mkwrite = bin_page_mkwrite,
319   - .access = bin_access,
320   -#ifdef CONFIG_NUMA
321   - .set_policy = bin_set_policy,
322   - .get_policy = bin_get_policy,
323   - .migrate = bin_migrate,
324   -#endif
325   -};
326   -
327   -static int mmap(struct file *file, struct vm_area_struct *vma)
328   -{
329   - struct bin_buffer *bb = file->private_data;
330   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
331   - struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
332   - struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
333   - int rc;
334   -
335   - mutex_lock(&bb->mutex);
336   -
337   - /* need attr_sd for attr, its parent for kobj */
338   - rc = -ENODEV;
339   - if (!sysfs_get_active(attr_sd))
340   - goto out_unlock;
341   -
342   - rc = -EINVAL;
343   - if (!attr->mmap)
344   - goto out_put;
345   -
346   - rc = attr->mmap(file, kobj, attr, vma);
347   - if (rc)
348   - goto out_put;
349   -
350   - /*
351   - * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
352   - * to satisfy versions of X which crash if the mmap fails: that
353   - * substitutes a new vm_file, and we don't then want bin_vm_ops.
354   - */
355   - if (vma->vm_file != file)
356   - goto out_put;
357   -
358   - rc = -EINVAL;
359   - if (bb->mmapped && bb->vm_ops != vma->vm_ops)
360   - goto out_put;
361   -
362   - /*
363   - * It is not possible to successfully wrap close.
364   - * So error if someone is trying to use close.
365   - */
366   - rc = -EINVAL;
367   - if (vma->vm_ops && vma->vm_ops->close)
368   - goto out_put;
369   -
370   - rc = 0;
371   - bb->mmapped = 1;
372   - bb->vm_ops = vma->vm_ops;
373   - vma->vm_ops = &bin_vm_ops;
374   -out_put:
375   - sysfs_put_active(attr_sd);
376   -out_unlock:
377   - mutex_unlock(&bb->mutex);
378   -
379   - return rc;
380   -}
381   -
382   -static int open(struct inode *inode, struct file *file)
383   -{
384   - struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
385   - struct bin_attribute *attr = attr_sd->s_bin_attr.bin_attr;
386   - struct bin_buffer *bb = NULL;
387   - int error;
388   -
389   - /* binary file operations requires both @sd and its parent */
390   - if (!sysfs_get_active(attr_sd))
391   - return -ENODEV;
392   -
393   - error = -EACCES;
394   - if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
395   - goto err_out;
396   - if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
397   - goto err_out;
398   -
399   - error = -ENOMEM;
400   - bb = kzalloc(sizeof(*bb), GFP_KERNEL);
401   - if (!bb)
402   - goto err_out;
403   -
404   - bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
405   - if (!bb->buffer)
406   - goto err_out;
407   -
408   - mutex_init(&bb->mutex);
409   - bb->file = file;
410   - file->private_data = bb;
411   -
412   - mutex_lock(&sysfs_bin_lock);
413   - hlist_add_head(&bb->list, &attr_sd->s_bin_attr.buffers);
414   - mutex_unlock(&sysfs_bin_lock);
415   -
416   - /* open succeeded, put active references */
417   - sysfs_put_active(attr_sd);
418   - return 0;
419   -
420   - err_out:
421   - sysfs_put_active(attr_sd);
422   - kfree(bb);
423   - return error;
424   -}
425   -
426   -static int release(struct inode *inode, struct file *file)
427   -{
428   - struct bin_buffer *bb = file->private_data;
429   -
430   - mutex_lock(&sysfs_bin_lock);
431   - hlist_del(&bb->list);
432   - mutex_unlock(&sysfs_bin_lock);
433   -
434   - kfree(bb->buffer);
435   - kfree(bb);
436   - return 0;
437   -}
438   -
439   -const struct file_operations bin_fops = {
440   - .read = read,
441   - .write = write,
442   - .mmap = mmap,
443   - .llseek = generic_file_llseek,
444   - .open = open,
445   - .release = release,
446   -};
447   -
448   -
449   -void unmap_bin_file(struct sysfs_dirent *attr_sd)
450   -{
451   - struct bin_buffer *bb;
452   -
453   - if (sysfs_type(attr_sd) != SYSFS_KOBJ_BIN_ATTR)
454   - return;
455   -
456   - mutex_lock(&sysfs_bin_lock);
457   -
458   - hlist_for_each_entry(bb, &attr_sd->s_bin_attr.buffers, list) {
459   - struct inode *inode = file_inode(bb->file);
460   -
461   - unmap_mapping_range(inode->i_mapping, 0, 0, 1);
462   - }
463   -
464   - mutex_unlock(&sysfs_bin_lock);
465   -}
466   -
467   -/**
468   - * sysfs_create_bin_file - create binary file for object.
469   - * @kobj: object.
470   - * @attr: attribute descriptor.
471   - */
472   -int sysfs_create_bin_file(struct kobject *kobj,
473   - const struct bin_attribute *attr)
474   -{
475   - BUG_ON(!kobj || !kobj->sd || !attr);
476   -
477   - return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
478   -}
479   -EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
480   -
481   -/**
482   - * sysfs_remove_bin_file - remove binary file for object.
483   - * @kobj: object.
484   - * @attr: attribute descriptor.
485   - */
486   -void sysfs_remove_bin_file(struct kobject *kobj,
487   - const struct bin_attribute *attr)
488   -{
489   - sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
490   -}
491   -EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
... ... @@ -596,7 +596,6 @@
596 596  
597 597 sysfs_deactivate(sd);
598 598 sysfs_unmap_bin_file(sd);
599   - unmap_bin_file(sd);
600 599 sysfs_put(sd);
601 600 }
602 601 }
... ... @@ -987,6 +987,32 @@
987 987 }
988 988 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
989 989  
  990 +/**
  991 + * sysfs_create_bin_file - create binary file for object.
  992 + * @kobj: object.
  993 + * @attr: attribute descriptor.
  994 + */
  995 +int sysfs_create_bin_file(struct kobject *kobj,
  996 + const struct bin_attribute *attr)
  997 +{
  998 + BUG_ON(!kobj || !kobj->sd || !attr);
  999 +
  1000 + return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
  1001 +}
  1002 +EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
  1003 +
  1004 +/**
  1005 + * sysfs_remove_bin_file - remove binary file for object.
  1006 + * @kobj: object.
  1007 + * @attr: attribute descriptor.
  1008 + */
  1009 +void sysfs_remove_bin_file(struct kobject *kobj,
  1010 + const struct bin_attribute *attr)
  1011 +{
  1012 + sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
  1013 +}
  1014 +EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
  1015 +
990 1016 struct sysfs_schedule_callback_struct {
991 1017 struct list_head workq_list;
992 1018 struct kobject *kobj;
... ... @@ -260,7 +260,7 @@
260 260 case SYSFS_KOBJ_BIN_ATTR:
261 261 bin_attr = sd->s_bin_attr.bin_attr;
262 262 inode->i_size = bin_attr->size;
263   - inode->i_fop = &bin_fops;
  263 + inode->i_fop = &sysfs_bin_operations;
264 264 break;
265 265 case SYSFS_KOBJ_LINK:
266 266 inode->i_op = &sysfs_symlink_inode_operations;
... ... @@ -223,12 +223,6 @@
223 223 void sysfs_unmap_bin_file(struct sysfs_dirent *sd);
224 224  
225 225 /*
226   - * bin.c
227   - */
228   -extern const struct file_operations bin_fops;
229   -void unmap_bin_file(struct sysfs_dirent *attr_sd);
230   -
231   -/*
232 226 * symlink.c
233 227 */
234 228 extern const struct inode_operations sysfs_symlink_inode_operations;