Root/
1 | /* |
2 | * fs/libfs.c |
3 | * Library for filesystems writers. |
4 | */ |
5 | |
6 | #include <linux/module.h> |
7 | #include <linux/pagemap.h> |
8 | #include <linux/mount.h> |
9 | #include <linux/vfs.h> |
10 | #include <linux/mutex.h> |
11 | #include <linux/exportfs.h> |
12 | #include <linux/writeback.h> |
13 | #include <linux/buffer_head.h> |
14 | |
15 | #include <asm/uaccess.h> |
16 | |
17 | int simple_getattr(struct vfsmount *mnt, struct dentry *dentry, |
18 | struct kstat *stat) |
19 | { |
20 | struct inode *inode = dentry->d_inode; |
21 | generic_fillattr(inode, stat); |
22 | stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9); |
23 | return 0; |
24 | } |
25 | |
26 | int simple_statfs(struct dentry *dentry, struct kstatfs *buf) |
27 | { |
28 | buf->f_type = dentry->d_sb->s_magic; |
29 | buf->f_bsize = PAGE_CACHE_SIZE; |
30 | buf->f_namelen = NAME_MAX; |
31 | return 0; |
32 | } |
33 | |
34 | /* |
35 | * Retaining negative dentries for an in-memory filesystem just wastes |
36 | * memory and lookup time: arrange for them to be deleted immediately. |
37 | */ |
38 | static int simple_delete_dentry(struct dentry *dentry) |
39 | { |
40 | return 1; |
41 | } |
42 | |
43 | /* |
44 | * Lookup the data. This is trivial - if the dentry didn't already |
45 | * exist, we know it is negative. Set d_op to delete negative dentries. |
46 | */ |
47 | struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) |
48 | { |
49 | static const struct dentry_operations simple_dentry_operations = { |
50 | .d_delete = simple_delete_dentry, |
51 | }; |
52 | |
53 | if (dentry->d_name.len > NAME_MAX) |
54 | return ERR_PTR(-ENAMETOOLONG); |
55 | dentry->d_op = &simple_dentry_operations; |
56 | d_add(dentry, NULL); |
57 | return NULL; |
58 | } |
59 | |
60 | int simple_sync_file(struct file * file, struct dentry *dentry, int datasync) |
61 | { |
62 | return 0; |
63 | } |
64 | |
65 | int dcache_dir_open(struct inode *inode, struct file *file) |
66 | { |
67 | static struct qstr cursor_name = {.len = 1, .name = "."}; |
68 | |
69 | file->private_data = d_alloc(file->f_path.dentry, &cursor_name); |
70 | |
71 | return file->private_data ? 0 : -ENOMEM; |
72 | } |
73 | |
74 | int dcache_dir_close(struct inode *inode, struct file *file) |
75 | { |
76 | dput(file->private_data); |
77 | return 0; |
78 | } |
79 | |
80 | loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin) |
81 | { |
82 | mutex_lock(&file->f_path.dentry->d_inode->i_mutex); |
83 | switch (origin) { |
84 | case 1: |
85 | offset += file->f_pos; |
86 | case 0: |
87 | if (offset >= 0) |
88 | break; |
89 | default: |
90 | mutex_unlock(&file->f_path.dentry->d_inode->i_mutex); |
91 | return -EINVAL; |
92 | } |
93 | if (offset != file->f_pos) { |
94 | file->f_pos = offset; |
95 | if (file->f_pos >= 2) { |
96 | struct list_head *p; |
97 | struct dentry *cursor = file->private_data; |
98 | loff_t n = file->f_pos - 2; |
99 | |
100 | spin_lock(&dcache_lock); |
101 | list_del(&cursor->d_u.d_child); |
102 | p = file->f_path.dentry->d_subdirs.next; |
103 | while (n && p != &file->f_path.dentry->d_subdirs) { |
104 | struct dentry *next; |
105 | next = list_entry(p, struct dentry, d_u.d_child); |
106 | if (!d_unhashed(next) && next->d_inode) |
107 | n--; |
108 | p = p->next; |
109 | } |
110 | list_add_tail(&cursor->d_u.d_child, p); |
111 | spin_unlock(&dcache_lock); |
112 | } |
113 | } |
114 | mutex_unlock(&file->f_path.dentry->d_inode->i_mutex); |
115 | return offset; |
116 | } |
117 | |
118 | /* Relationship between i_mode and the DT_xxx types */ |
119 | static inline unsigned char dt_type(struct inode *inode) |
120 | { |
121 | return (inode->i_mode >> 12) & 15; |
122 | } |
123 | |
124 | /* |
125 | * Directory is locked and all positive dentries in it are safe, since |
126 | * for ramfs-type trees they can't go away without unlink() or rmdir(), |
127 | * both impossible due to the lock on directory. |
128 | */ |
129 | |
130 | int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir) |
131 | { |
132 | struct dentry *dentry = filp->f_path.dentry; |
133 | struct dentry *cursor = filp->private_data; |
134 | struct list_head *p, *q = &cursor->d_u.d_child; |
135 | ino_t ino; |
136 | int i = filp->f_pos; |
137 | |
138 | switch (i) { |
139 | case 0: |
140 | ino = dentry->d_inode->i_ino; |
141 | if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) |
142 | break; |
143 | filp->f_pos++; |
144 | i++; |
145 | /* fallthrough */ |
146 | case 1: |
147 | ino = parent_ino(dentry); |
148 | if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) |
149 | break; |
150 | filp->f_pos++; |
151 | i++; |
152 | /* fallthrough */ |
153 | default: |
154 | spin_lock(&dcache_lock); |
155 | if (filp->f_pos == 2) |
156 | list_move(q, &dentry->d_subdirs); |
157 | |
158 | for (p=q->next; p != &dentry->d_subdirs; p=p->next) { |
159 | struct dentry *next; |
160 | next = list_entry(p, struct dentry, d_u.d_child); |
161 | if (d_unhashed(next) || !next->d_inode) |
162 | continue; |
163 | |
164 | spin_unlock(&dcache_lock); |
165 | if (filldir(dirent, next->d_name.name, |
166 | next->d_name.len, filp->f_pos, |
167 | next->d_inode->i_ino, |
168 | dt_type(next->d_inode)) < 0) |
169 | return 0; |
170 | spin_lock(&dcache_lock); |
171 | /* next is still alive */ |
172 | list_move(q, p); |
173 | p = q; |
174 | filp->f_pos++; |
175 | } |
176 | spin_unlock(&dcache_lock); |
177 | } |
178 | return 0; |
179 | } |
180 | |
181 | ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos) |
182 | { |
183 | return -EISDIR; |
184 | } |
185 | |
186 | const struct file_operations simple_dir_operations = { |
187 | .open = dcache_dir_open, |
188 | .release = dcache_dir_close, |
189 | .llseek = dcache_dir_lseek, |
190 | .read = generic_read_dir, |
191 | .readdir = dcache_readdir, |
192 | .fsync = simple_sync_file, |
193 | }; |
194 | |
195 | const struct inode_operations simple_dir_inode_operations = { |
196 | .lookup = simple_lookup, |
197 | }; |
198 | |
199 | static const struct super_operations simple_super_operations = { |
200 | .statfs = simple_statfs, |
201 | }; |
202 | |
203 | /* |
204 | * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that |
205 | * will never be mountable) |
206 | */ |
207 | int get_sb_pseudo(struct file_system_type *fs_type, char *name, |
208 | const struct super_operations *ops, unsigned long magic, |
209 | struct vfsmount *mnt) |
210 | { |
211 | struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL); |
212 | struct dentry *dentry; |
213 | struct inode *root; |
214 | struct qstr d_name = {.name = name, .len = strlen(name)}; |
215 | |
216 | if (IS_ERR(s)) |
217 | return PTR_ERR(s); |
218 | |
219 | s->s_flags = MS_NOUSER; |
220 | s->s_maxbytes = MAX_LFS_FILESIZE; |
221 | s->s_blocksize = PAGE_SIZE; |
222 | s->s_blocksize_bits = PAGE_SHIFT; |
223 | s->s_magic = magic; |
224 | s->s_op = ops ? ops : &simple_super_operations; |
225 | s->s_time_gran = 1; |
226 | root = new_inode(s); |
227 | if (!root) |
228 | goto Enomem; |
229 | /* |
230 | * since this is the first inode, make it number 1. New inodes created |
231 | * after this must take care not to collide with it (by passing |
232 | * max_reserved of 1 to iunique). |
233 | */ |
234 | root->i_ino = 1; |
235 | root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR; |
236 | root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME; |
237 | dentry = d_alloc(NULL, &d_name); |
238 | if (!dentry) { |
239 | iput(root); |
240 | goto Enomem; |
241 | } |
242 | dentry->d_sb = s; |
243 | dentry->d_parent = dentry; |
244 | d_instantiate(dentry, root); |
245 | s->s_root = dentry; |
246 | s->s_flags |= MS_ACTIVE; |
247 | simple_set_mnt(mnt, s); |
248 | return 0; |
249 | |
250 | Enomem: |
251 | deactivate_locked_super(s); |
252 | return -ENOMEM; |
253 | } |
254 | |
255 | int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) |
256 | { |
257 | struct inode *inode = old_dentry->d_inode; |
258 | |
259 | inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; |
260 | inc_nlink(inode); |
261 | atomic_inc(&inode->i_count); |
262 | dget(dentry); |
263 | d_instantiate(dentry, inode); |
264 | return 0; |
265 | } |
266 | |
267 | static inline int simple_positive(struct dentry *dentry) |
268 | { |
269 | return dentry->d_inode && !d_unhashed(dentry); |
270 | } |
271 | |
272 | int simple_empty(struct dentry *dentry) |
273 | { |
274 | struct dentry *child; |
275 | int ret = 0; |
276 | |
277 | spin_lock(&dcache_lock); |
278 | list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) |
279 | if (simple_positive(child)) |
280 | goto out; |
281 | ret = 1; |
282 | out: |
283 | spin_unlock(&dcache_lock); |
284 | return ret; |
285 | } |
286 | |
287 | int simple_unlink(struct inode *dir, struct dentry *dentry) |
288 | { |
289 | struct inode *inode = dentry->d_inode; |
290 | |
291 | inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; |
292 | drop_nlink(inode); |
293 | dput(dentry); |
294 | return 0; |
295 | } |
296 | |
297 | int simple_rmdir(struct inode *dir, struct dentry *dentry) |
298 | { |
299 | if (!simple_empty(dentry)) |
300 | return -ENOTEMPTY; |
301 | |
302 | drop_nlink(dentry->d_inode); |
303 | simple_unlink(dir, dentry); |
304 | drop_nlink(dir); |
305 | return 0; |
306 | } |
307 | |
308 | int simple_rename(struct inode *old_dir, struct dentry *old_dentry, |
309 | struct inode *new_dir, struct dentry *new_dentry) |
310 | { |
311 | struct inode *inode = old_dentry->d_inode; |
312 | int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode); |
313 | |
314 | if (!simple_empty(new_dentry)) |
315 | return -ENOTEMPTY; |
316 | |
317 | if (new_dentry->d_inode) { |
318 | simple_unlink(new_dir, new_dentry); |
319 | if (they_are_dirs) |
320 | drop_nlink(old_dir); |
321 | } else if (they_are_dirs) { |
322 | drop_nlink(old_dir); |
323 | inc_nlink(new_dir); |
324 | } |
325 | |
326 | old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime = |
327 | new_dir->i_mtime = inode->i_ctime = CURRENT_TIME; |
328 | |
329 | return 0; |
330 | } |
331 | |
332 | int simple_readpage(struct file *file, struct page *page) |
333 | { |
334 | clear_highpage(page); |
335 | flush_dcache_page(page); |
336 | SetPageUptodate(page); |
337 | unlock_page(page); |
338 | return 0; |
339 | } |
340 | |
341 | int simple_prepare_write(struct file *file, struct page *page, |
342 | unsigned from, unsigned to) |
343 | { |
344 | if (!PageUptodate(page)) { |
345 | if (to - from != PAGE_CACHE_SIZE) |
346 | zero_user_segments(page, |
347 | 0, from, |
348 | to, PAGE_CACHE_SIZE); |
349 | } |
350 | return 0; |
351 | } |
352 | |
353 | int simple_write_begin(struct file *file, struct address_space *mapping, |
354 | loff_t pos, unsigned len, unsigned flags, |
355 | struct page **pagep, void **fsdata) |
356 | { |
357 | struct page *page; |
358 | pgoff_t index; |
359 | unsigned from; |
360 | |
361 | index = pos >> PAGE_CACHE_SHIFT; |
362 | from = pos & (PAGE_CACHE_SIZE - 1); |
363 | |
364 | page = grab_cache_page_write_begin(mapping, index, flags); |
365 | if (!page) |
366 | return -ENOMEM; |
367 | |
368 | *pagep = page; |
369 | |
370 | return simple_prepare_write(file, page, from, from+len); |
371 | } |
372 | |
373 | static int simple_commit_write(struct file *file, struct page *page, |
374 | unsigned from, unsigned to) |
375 | { |
376 | struct inode *inode = page->mapping->host; |
377 | loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; |
378 | |
379 | if (!PageUptodate(page)) |
380 | SetPageUptodate(page); |
381 | /* |
382 | * No need to use i_size_read() here, the i_size |
383 | * cannot change under us because we hold the i_mutex. |
384 | */ |
385 | if (pos > inode->i_size) |
386 | i_size_write(inode, pos); |
387 | set_page_dirty(page); |
388 | return 0; |
389 | } |
390 | |
391 | int simple_write_end(struct file *file, struct address_space *mapping, |
392 | loff_t pos, unsigned len, unsigned copied, |
393 | struct page *page, void *fsdata) |
394 | { |
395 | unsigned from = pos & (PAGE_CACHE_SIZE - 1); |
396 | |
397 | /* zero the stale part of the page if we did a short copy */ |
398 | if (copied < len) { |
399 | void *kaddr = kmap_atomic(page, KM_USER0); |
400 | memset(kaddr + from + copied, 0, len - copied); |
401 | flush_dcache_page(page); |
402 | kunmap_atomic(kaddr, KM_USER0); |
403 | } |
404 | |
405 | simple_commit_write(file, page, from, from+copied); |
406 | |
407 | unlock_page(page); |
408 | page_cache_release(page); |
409 | |
410 | return copied; |
411 | } |
412 | |
413 | /* |
414 | * the inodes created here are not hashed. If you use iunique to generate |
415 | * unique inode values later for this filesystem, then you must take care |
416 | * to pass it an appropriate max_reserved value to avoid collisions. |
417 | */ |
418 | int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files) |
419 | { |
420 | struct inode *inode; |
421 | struct dentry *root; |
422 | struct dentry *dentry; |
423 | int i; |
424 | |
425 | s->s_blocksize = PAGE_CACHE_SIZE; |
426 | s->s_blocksize_bits = PAGE_CACHE_SHIFT; |
427 | s->s_magic = magic; |
428 | s->s_op = &simple_super_operations; |
429 | s->s_time_gran = 1; |
430 | |
431 | inode = new_inode(s); |
432 | if (!inode) |
433 | return -ENOMEM; |
434 | /* |
435 | * because the root inode is 1, the files array must not contain an |
436 | * entry at index 1 |
437 | */ |
438 | inode->i_ino = 1; |
439 | inode->i_mode = S_IFDIR | 0755; |
440 | inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; |
441 | inode->i_op = &simple_dir_inode_operations; |
442 | inode->i_fop = &simple_dir_operations; |
443 | inode->i_nlink = 2; |
444 | root = d_alloc_root(inode); |
445 | if (!root) { |
446 | iput(inode); |
447 | return -ENOMEM; |
448 | } |
449 | for (i = 0; !files->name || files->name[0]; i++, files++) { |
450 | if (!files->name) |
451 | continue; |
452 | |
453 | /* warn if it tries to conflict with the root inode */ |
454 | if (unlikely(i == 1)) |
455 | printk(KERN_WARNING "%s: %s passed in a files array" |
456 | "with an index of 1!\n", __func__, |
457 | s->s_type->name); |
458 | |
459 | dentry = d_alloc_name(root, files->name); |
460 | if (!dentry) |
461 | goto out; |
462 | inode = new_inode(s); |
463 | if (!inode) |
464 | goto out; |
465 | inode->i_mode = S_IFREG | files->mode; |
466 | inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; |
467 | inode->i_fop = files->ops; |
468 | inode->i_ino = i; |
469 | d_add(dentry, inode); |
470 | } |
471 | s->s_root = root; |
472 | return 0; |
473 | out: |
474 | d_genocide(root); |
475 | dput(root); |
476 | return -ENOMEM; |
477 | } |
478 | |
479 | static DEFINE_SPINLOCK(pin_fs_lock); |
480 | |
481 | int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count) |
482 | { |
483 | struct vfsmount *mnt = NULL; |
484 | spin_lock(&pin_fs_lock); |
485 | if (unlikely(!*mount)) { |
486 | spin_unlock(&pin_fs_lock); |
487 | mnt = vfs_kern_mount(type, 0, type->name, NULL); |
488 | if (IS_ERR(mnt)) |
489 | return PTR_ERR(mnt); |
490 | spin_lock(&pin_fs_lock); |
491 | if (!*mount) |
492 | *mount = mnt; |
493 | } |
494 | mntget(*mount); |
495 | ++*count; |
496 | spin_unlock(&pin_fs_lock); |
497 | mntput(mnt); |
498 | return 0; |
499 | } |
500 | |
501 | void simple_release_fs(struct vfsmount **mount, int *count) |
502 | { |
503 | struct vfsmount *mnt; |
504 | spin_lock(&pin_fs_lock); |
505 | mnt = *mount; |
506 | if (!--*count) |
507 | *mount = NULL; |
508 | spin_unlock(&pin_fs_lock); |
509 | mntput(mnt); |
510 | } |
511 | |
512 | /** |
513 | * simple_read_from_buffer - copy data from the buffer to user space |
514 | * @to: the user space buffer to read to |
515 | * @count: the maximum number of bytes to read |
516 | * @ppos: the current position in the buffer |
517 | * @from: the buffer to read from |
518 | * @available: the size of the buffer |
519 | * |
520 | * The simple_read_from_buffer() function reads up to @count bytes from the |
521 | * buffer @from at offset @ppos into the user space address starting at @to. |
522 | * |
523 | * On success, the number of bytes read is returned and the offset @ppos is |
524 | * advanced by this number, or negative value is returned on error. |
525 | **/ |
526 | ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, |
527 | const void *from, size_t available) |
528 | { |
529 | loff_t pos = *ppos; |
530 | if (pos < 0) |
531 | return -EINVAL; |
532 | if (pos >= available) |
533 | return 0; |
534 | if (count > available - pos) |
535 | count = available - pos; |
536 | if (copy_to_user(to, from + pos, count)) |
537 | return -EFAULT; |
538 | *ppos = pos + count; |
539 | return count; |
540 | } |
541 | |
542 | /** |
543 | * memory_read_from_buffer - copy data from the buffer |
544 | * @to: the kernel space buffer to read to |
545 | * @count: the maximum number of bytes to read |
546 | * @ppos: the current position in the buffer |
547 | * @from: the buffer to read from |
548 | * @available: the size of the buffer |
549 | * |
550 | * The memory_read_from_buffer() function reads up to @count bytes from the |
551 | * buffer @from at offset @ppos into the kernel space address starting at @to. |
552 | * |
553 | * On success, the number of bytes read is returned and the offset @ppos is |
554 | * advanced by this number, or negative value is returned on error. |
555 | **/ |
556 | ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, |
557 | const void *from, size_t available) |
558 | { |
559 | loff_t pos = *ppos; |
560 | |
561 | if (pos < 0) |
562 | return -EINVAL; |
563 | if (pos >= available) |
564 | return 0; |
565 | if (count > available - pos) |
566 | count = available - pos; |
567 | memcpy(to, from + pos, count); |
568 | *ppos = pos + count; |
569 | |
570 | return count; |
571 | } |
572 | |
573 | /* |
574 | * Transaction based IO. |
575 | * The file expects a single write which triggers the transaction, and then |
576 | * possibly a read which collects the result - which is stored in a |
577 | * file-local buffer. |
578 | */ |
579 | |
580 | void simple_transaction_set(struct file *file, size_t n) |
581 | { |
582 | struct simple_transaction_argresp *ar = file->private_data; |
583 | |
584 | BUG_ON(n > SIMPLE_TRANSACTION_LIMIT); |
585 | |
586 | /* |
587 | * The barrier ensures that ar->size will really remain zero until |
588 | * ar->data is ready for reading. |
589 | */ |
590 | smp_mb(); |
591 | ar->size = n; |
592 | } |
593 | |
594 | char *simple_transaction_get(struct file *file, const char __user *buf, size_t size) |
595 | { |
596 | struct simple_transaction_argresp *ar; |
597 | static DEFINE_SPINLOCK(simple_transaction_lock); |
598 | |
599 | if (size > SIMPLE_TRANSACTION_LIMIT - 1) |
600 | return ERR_PTR(-EFBIG); |
601 | |
602 | ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL); |
603 | if (!ar) |
604 | return ERR_PTR(-ENOMEM); |
605 | |
606 | spin_lock(&simple_transaction_lock); |
607 | |
608 | /* only one write allowed per open */ |
609 | if (file->private_data) { |
610 | spin_unlock(&simple_transaction_lock); |
611 | free_page((unsigned long)ar); |
612 | return ERR_PTR(-EBUSY); |
613 | } |
614 | |
615 | file->private_data = ar; |
616 | |
617 | spin_unlock(&simple_transaction_lock); |
618 | |
619 | if (copy_from_user(ar->data, buf, size)) |
620 | return ERR_PTR(-EFAULT); |
621 | |
622 | return ar->data; |
623 | } |
624 | |
625 | ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) |
626 | { |
627 | struct simple_transaction_argresp *ar = file->private_data; |
628 | |
629 | if (!ar) |
630 | return 0; |
631 | return simple_read_from_buffer(buf, size, pos, ar->data, ar->size); |
632 | } |
633 | |
634 | int simple_transaction_release(struct inode *inode, struct file *file) |
635 | { |
636 | free_page((unsigned long)file->private_data); |
637 | return 0; |
638 | } |
639 | |
640 | /* Simple attribute files */ |
641 | |
642 | struct simple_attr { |
643 | int (*get)(void *, u64 *); |
644 | int (*set)(void *, u64); |
645 | char get_buf[24]; /* enough to store a u64 and "\n\0" */ |
646 | char set_buf[24]; |
647 | void *data; |
648 | const char *fmt; /* format for read operation */ |
649 | struct mutex mutex; /* protects access to these buffers */ |
650 | }; |
651 | |
652 | /* simple_attr_open is called by an actual attribute open file operation |
653 | * to set the attribute specific access operations. */ |
654 | int simple_attr_open(struct inode *inode, struct file *file, |
655 | int (*get)(void *, u64 *), int (*set)(void *, u64), |
656 | const char *fmt) |
657 | { |
658 | struct simple_attr *attr; |
659 | |
660 | attr = kmalloc(sizeof(*attr), GFP_KERNEL); |
661 | if (!attr) |
662 | return -ENOMEM; |
663 | |
664 | attr->get = get; |
665 | attr->set = set; |
666 | attr->data = inode->i_private; |
667 | attr->fmt = fmt; |
668 | mutex_init(&attr->mutex); |
669 | |
670 | file->private_data = attr; |
671 | |
672 | return nonseekable_open(inode, file); |
673 | } |
674 | |
675 | int simple_attr_release(struct inode *inode, struct file *file) |
676 | { |
677 | kfree(file->private_data); |
678 | return 0; |
679 | } |
680 | |
681 | /* read from the buffer that is filled with the get function */ |
682 | ssize_t simple_attr_read(struct file *file, char __user *buf, |
683 | size_t len, loff_t *ppos) |
684 | { |
685 | struct simple_attr *attr; |
686 | size_t size; |
687 | ssize_t ret; |
688 | |
689 | attr = file->private_data; |
690 | |
691 | if (!attr->get) |
692 | return -EACCES; |
693 | |
694 | ret = mutex_lock_interruptible(&attr->mutex); |
695 | if (ret) |
696 | return ret; |
697 | |
698 | if (*ppos) { /* continued read */ |
699 | size = strlen(attr->get_buf); |
700 | } else { /* first read */ |
701 | u64 val; |
702 | ret = attr->get(attr->data, &val); |
703 | if (ret) |
704 | goto out; |
705 | |
706 | size = scnprintf(attr->get_buf, sizeof(attr->get_buf), |
707 | attr->fmt, (unsigned long long)val); |
708 | } |
709 | |
710 | ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size); |
711 | out: |
712 | mutex_unlock(&attr->mutex); |
713 | return ret; |
714 | } |
715 | |
716 | /* interpret the buffer as a number to call the set function with */ |
717 | ssize_t simple_attr_write(struct file *file, const char __user *buf, |
718 | size_t len, loff_t *ppos) |
719 | { |
720 | struct simple_attr *attr; |
721 | u64 val; |
722 | size_t size; |
723 | ssize_t ret; |
724 | |
725 | attr = file->private_data; |
726 | if (!attr->set) |
727 | return -EACCES; |
728 | |
729 | ret = mutex_lock_interruptible(&attr->mutex); |
730 | if (ret) |
731 | return ret; |
732 | |
733 | ret = -EFAULT; |
734 | size = min(sizeof(attr->set_buf) - 1, len); |
735 | if (copy_from_user(attr->set_buf, buf, size)) |
736 | goto out; |
737 | |
738 | ret = len; /* claim we got the whole input */ |
739 | attr->set_buf[size] = '\0'; |
740 | val = simple_strtol(attr->set_buf, NULL, 0); |
741 | attr->set(attr->data, val); |
742 | out: |
743 | mutex_unlock(&attr->mutex); |
744 | return ret; |
745 | } |
746 | |
747 | /** |
748 | * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation |
749 | * @sb: filesystem to do the file handle conversion on |
750 | * @fid: file handle to convert |
751 | * @fh_len: length of the file handle in bytes |
752 | * @fh_type: type of file handle |
753 | * @get_inode: filesystem callback to retrieve inode |
754 | * |
755 | * This function decodes @fid as long as it has one of the well-known |
756 | * Linux filehandle types and calls @get_inode on it to retrieve the |
757 | * inode for the object specified in the file handle. |
758 | */ |
759 | struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid, |
760 | int fh_len, int fh_type, struct inode *(*get_inode) |
761 | (struct super_block *sb, u64 ino, u32 gen)) |
762 | { |
763 | struct inode *inode = NULL; |
764 | |
765 | if (fh_len < 2) |
766 | return NULL; |
767 | |
768 | switch (fh_type) { |
769 | case FILEID_INO32_GEN: |
770 | case FILEID_INO32_GEN_PARENT: |
771 | inode = get_inode(sb, fid->i32.ino, fid->i32.gen); |
772 | break; |
773 | } |
774 | |
775 | return d_obtain_alias(inode); |
776 | } |
777 | EXPORT_SYMBOL_GPL(generic_fh_to_dentry); |
778 | |
779 | /** |
780 | * generic_fh_to_dentry - generic helper for the fh_to_parent export operation |
781 | * @sb: filesystem to do the file handle conversion on |
782 | * @fid: file handle to convert |
783 | * @fh_len: length of the file handle in bytes |
784 | * @fh_type: type of file handle |
785 | * @get_inode: filesystem callback to retrieve inode |
786 | * |
787 | * This function decodes @fid as long as it has one of the well-known |
788 | * Linux filehandle types and calls @get_inode on it to retrieve the |
789 | * inode for the _parent_ object specified in the file handle if it |
790 | * is specified in the file handle, or NULL otherwise. |
791 | */ |
792 | struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid, |
793 | int fh_len, int fh_type, struct inode *(*get_inode) |
794 | (struct super_block *sb, u64 ino, u32 gen)) |
795 | { |
796 | struct inode *inode = NULL; |
797 | |
798 | if (fh_len <= 2) |
799 | return NULL; |
800 | |
801 | switch (fh_type) { |
802 | case FILEID_INO32_GEN_PARENT: |
803 | inode = get_inode(sb, fid->i32.parent_ino, |
804 | (fh_len > 3 ? fid->i32.parent_gen : 0)); |
805 | break; |
806 | } |
807 | |
808 | return d_obtain_alias(inode); |
809 | } |
810 | EXPORT_SYMBOL_GPL(generic_fh_to_parent); |
811 | |
812 | int simple_fsync(struct file *file, struct dentry *dentry, int datasync) |
813 | { |
814 | struct writeback_control wbc = { |
815 | .sync_mode = WB_SYNC_ALL, |
816 | .nr_to_write = 0, /* metadata-only; caller takes care of data */ |
817 | }; |
818 | struct inode *inode = dentry->d_inode; |
819 | int err; |
820 | int ret; |
821 | |
822 | ret = sync_mapping_buffers(inode->i_mapping); |
823 | if (!(inode->i_state & I_DIRTY)) |
824 | return ret; |
825 | if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) |
826 | return ret; |
827 | |
828 | err = sync_inode(inode, &wbc); |
829 | if (ret == 0) |
830 | ret = err; |
831 | return ret; |
832 | } |
833 | EXPORT_SYMBOL(simple_fsync); |
834 | |
835 | EXPORT_SYMBOL(dcache_dir_close); |
836 | EXPORT_SYMBOL(dcache_dir_lseek); |
837 | EXPORT_SYMBOL(dcache_dir_open); |
838 | EXPORT_SYMBOL(dcache_readdir); |
839 | EXPORT_SYMBOL(generic_read_dir); |
840 | EXPORT_SYMBOL(get_sb_pseudo); |
841 | EXPORT_SYMBOL(simple_write_begin); |
842 | EXPORT_SYMBOL(simple_write_end); |
843 | EXPORT_SYMBOL(simple_dir_inode_operations); |
844 | EXPORT_SYMBOL(simple_dir_operations); |
845 | EXPORT_SYMBOL(simple_empty); |
846 | EXPORT_SYMBOL(d_alloc_name); |
847 | EXPORT_SYMBOL(simple_fill_super); |
848 | EXPORT_SYMBOL(simple_getattr); |
849 | EXPORT_SYMBOL(simple_link); |
850 | EXPORT_SYMBOL(simple_lookup); |
851 | EXPORT_SYMBOL(simple_pin_fs); |
852 | EXPORT_UNUSED_SYMBOL(simple_prepare_write); |
853 | EXPORT_SYMBOL(simple_readpage); |
854 | EXPORT_SYMBOL(simple_release_fs); |
855 | EXPORT_SYMBOL(simple_rename); |
856 | EXPORT_SYMBOL(simple_rmdir); |
857 | EXPORT_SYMBOL(simple_statfs); |
858 | EXPORT_SYMBOL(simple_sync_file); |
859 | EXPORT_SYMBOL(simple_unlink); |
860 | EXPORT_SYMBOL(simple_read_from_buffer); |
861 | EXPORT_SYMBOL(memory_read_from_buffer); |
862 | EXPORT_SYMBOL(simple_transaction_set); |
863 | EXPORT_SYMBOL(simple_transaction_get); |
864 | EXPORT_SYMBOL(simple_transaction_read); |
865 | EXPORT_SYMBOL(simple_transaction_release); |
866 | EXPORT_SYMBOL_GPL(simple_attr_open); |
867 | EXPORT_SYMBOL_GPL(simple_attr_release); |
868 | EXPORT_SYMBOL_GPL(simple_attr_read); |
869 | EXPORT_SYMBOL_GPL(simple_attr_write); |
870 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9