3 * Library for filesystems writers.
6 #include <linux/module.h>
7 #include <linux/pagemap.h>
8 #include <linux/mount.h>
10 #include <linux/mutex.h>
12 #include <asm/uaccess.h>
14 int simple_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
17 struct inode
*inode
= dentry
->d_inode
;
18 generic_fillattr(inode
, stat
);
19 stat
->blocks
= inode
->i_mapping
->nrpages
<< (PAGE_CACHE_SHIFT
- 9);
23 int simple_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
25 buf
->f_type
= dentry
->d_sb
->s_magic
;
26 buf
->f_bsize
= PAGE_CACHE_SIZE
;
27 buf
->f_namelen
= NAME_MAX
;
32 * Retaining negative dentries for an in-memory filesystem just wastes
33 * memory and lookup time: arrange for them to be deleted immediately.
35 static int simple_delete_dentry(struct dentry
*dentry
)
41 * Lookup the data. This is trivial - if the dentry didn't already
42 * exist, we know it is negative. Set d_op to delete negative dentries.
44 struct dentry
*simple_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
46 static struct dentry_operations simple_dentry_operations
= {
47 .d_delete
= simple_delete_dentry
,
50 if (dentry
->d_name
.len
> NAME_MAX
)
51 return ERR_PTR(-ENAMETOOLONG
);
52 dentry
->d_op
= &simple_dentry_operations
;
57 int simple_sync_file(struct file
* file
, struct dentry
*dentry
, int datasync
)
62 int dcache_dir_open(struct inode
*inode
, struct file
*file
)
64 static struct qstr cursor_name
= {.len
= 1, .name
= "."};
66 file
->private_data
= d_alloc(file
->f_path
.dentry
, &cursor_name
);
68 return file
->private_data
? 0 : -ENOMEM
;
71 int dcache_dir_close(struct inode
*inode
, struct file
*file
)
73 dput(file
->private_data
);
77 loff_t
dcache_dir_lseek(struct file
*file
, loff_t offset
, int origin
)
79 mutex_lock(&file
->f_path
.dentry
->d_inode
->i_mutex
);
82 offset
+= file
->f_pos
;
87 mutex_unlock(&file
->f_path
.dentry
->d_inode
->i_mutex
);
90 if (offset
!= file
->f_pos
) {
92 if (file
->f_pos
>= 2) {
94 struct dentry
*cursor
= file
->private_data
;
95 loff_t n
= file
->f_pos
- 2;
97 spin_lock(&dcache_lock
);
98 list_del(&cursor
->d_u
.d_child
);
99 p
= file
->f_path
.dentry
->d_subdirs
.next
;
100 while (n
&& p
!= &file
->f_path
.dentry
->d_subdirs
) {
102 next
= list_entry(p
, struct dentry
, d_u
.d_child
);
103 if (!d_unhashed(next
) && next
->d_inode
)
107 list_add_tail(&cursor
->d_u
.d_child
, p
);
108 spin_unlock(&dcache_lock
);
111 mutex_unlock(&file
->f_path
.dentry
->d_inode
->i_mutex
);
115 /* Relationship between i_mode and the DT_xxx types */
116 static inline unsigned char dt_type(struct inode
*inode
)
118 return (inode
->i_mode
>> 12) & 15;
122 * Directory is locked and all positive dentries in it are safe, since
123 * for ramfs-type trees they can't go away without unlink() or rmdir(),
124 * both impossible due to the lock on directory.
127 int dcache_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
129 struct dentry
*dentry
= filp
->f_path
.dentry
;
130 struct dentry
*cursor
= filp
->private_data
;
131 struct list_head
*p
, *q
= &cursor
->d_u
.d_child
;
137 ino
= dentry
->d_inode
->i_ino
;
138 if (filldir(dirent
, ".", 1, i
, ino
, DT_DIR
) < 0)
144 ino
= parent_ino(dentry
);
145 if (filldir(dirent
, "..", 2, i
, ino
, DT_DIR
) < 0)
151 spin_lock(&dcache_lock
);
152 if (filp
->f_pos
== 2)
153 list_move(q
, &dentry
->d_subdirs
);
155 for (p
=q
->next
; p
!= &dentry
->d_subdirs
; p
=p
->next
) {
157 next
= list_entry(p
, struct dentry
, d_u
.d_child
);
158 if (d_unhashed(next
) || !next
->d_inode
)
161 spin_unlock(&dcache_lock
);
162 if (filldir(dirent
, next
->d_name
.name
, next
->d_name
.len
, filp
->f_pos
, next
->d_inode
->i_ino
, dt_type(next
->d_inode
)) < 0)
164 spin_lock(&dcache_lock
);
165 /* next is still alive */
170 spin_unlock(&dcache_lock
);
175 ssize_t
generic_read_dir(struct file
*filp
, char __user
*buf
, size_t siz
, loff_t
*ppos
)
180 const struct file_operations simple_dir_operations
= {
181 .open
= dcache_dir_open
,
182 .release
= dcache_dir_close
,
183 .llseek
= dcache_dir_lseek
,
184 .read
= generic_read_dir
,
185 .readdir
= dcache_readdir
,
186 .fsync
= simple_sync_file
,
189 const struct inode_operations simple_dir_inode_operations
= {
190 .lookup
= simple_lookup
,
193 static const struct super_operations simple_super_operations
= {
194 .statfs
= simple_statfs
,
198 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
199 * will never be mountable)
201 int get_sb_pseudo(struct file_system_type
*fs_type
, char *name
,
202 const struct super_operations
*ops
, unsigned long magic
,
203 struct vfsmount
*mnt
)
205 struct super_block
*s
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
206 struct dentry
*dentry
;
208 struct qstr d_name
= {.name
= name
, .len
= strlen(name
)};
213 s
->s_flags
= MS_NOUSER
;
214 s
->s_maxbytes
= ~0ULL;
215 s
->s_blocksize
= 1024;
216 s
->s_blocksize_bits
= 10;
218 s
->s_op
= ops
? ops
: &simple_super_operations
;
224 * since this is the first inode, make it number 1. New inodes created
225 * after this must take care not to collide with it (by passing
226 * max_reserved of 1 to iunique).
229 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
230 root
->i_uid
= root
->i_gid
= 0;
231 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= CURRENT_TIME
;
232 dentry
= d_alloc(NULL
, &d_name
);
238 dentry
->d_parent
= dentry
;
239 d_instantiate(dentry
, root
);
241 s
->s_flags
|= MS_ACTIVE
;
242 return simple_set_mnt(mnt
, s
);
245 up_write(&s
->s_umount
);
250 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
252 struct inode
*inode
= old_dentry
->d_inode
;
254 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
256 atomic_inc(&inode
->i_count
);
258 d_instantiate(dentry
, inode
);
262 static inline int simple_positive(struct dentry
*dentry
)
264 return dentry
->d_inode
&& !d_unhashed(dentry
);
267 int simple_empty(struct dentry
*dentry
)
269 struct dentry
*child
;
272 spin_lock(&dcache_lock
);
273 list_for_each_entry(child
, &dentry
->d_subdirs
, d_u
.d_child
)
274 if (simple_positive(child
))
278 spin_unlock(&dcache_lock
);
282 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
284 struct inode
*inode
= dentry
->d_inode
;
286 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
292 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
294 if (!simple_empty(dentry
))
297 drop_nlink(dentry
->d_inode
);
298 simple_unlink(dir
, dentry
);
303 int simple_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
304 struct inode
*new_dir
, struct dentry
*new_dentry
)
306 struct inode
*inode
= old_dentry
->d_inode
;
307 int they_are_dirs
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
309 if (!simple_empty(new_dentry
))
312 if (new_dentry
->d_inode
) {
313 simple_unlink(new_dir
, new_dentry
);
316 } else if (they_are_dirs
) {
321 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
322 new_dir
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
327 int simple_readpage(struct file
*file
, struct page
*page
)
329 clear_highpage(page
);
330 flush_dcache_page(page
);
331 SetPageUptodate(page
);
336 int simple_prepare_write(struct file
*file
, struct page
*page
,
337 unsigned from
, unsigned to
)
339 if (!PageUptodate(page
)) {
340 if (to
- from
!= PAGE_CACHE_SIZE
) {
341 void *kaddr
= kmap_atomic(page
, KM_USER0
);
342 memset(kaddr
, 0, from
);
343 memset(kaddr
+ to
, 0, PAGE_CACHE_SIZE
- to
);
344 flush_dcache_page(page
);
345 kunmap_atomic(kaddr
, KM_USER0
);
351 int simple_commit_write(struct file
*file
, struct page
*page
,
352 unsigned from
, unsigned to
)
354 struct inode
*inode
= page
->mapping
->host
;
355 loff_t pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
357 if (!PageUptodate(page
))
358 SetPageUptodate(page
);
360 * No need to use i_size_read() here, the i_size
361 * cannot change under us because we hold the i_mutex.
363 if (pos
> inode
->i_size
)
364 i_size_write(inode
, pos
);
365 set_page_dirty(page
);
370 * the inodes created here are not hashed. If you use iunique to generate
371 * unique inode values later for this filesystem, then you must take care
372 * to pass it an appropriate max_reserved value to avoid collisions.
374 int simple_fill_super(struct super_block
*s
, int magic
, struct tree_descr
*files
)
378 struct dentry
*dentry
;
381 s
->s_blocksize
= PAGE_CACHE_SIZE
;
382 s
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
384 s
->s_op
= &simple_super_operations
;
387 inode
= new_inode(s
);
391 * because the root inode is 1, the files array must not contain an
395 inode
->i_mode
= S_IFDIR
| 0755;
396 inode
->i_uid
= inode
->i_gid
= 0;
398 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
399 inode
->i_op
= &simple_dir_inode_operations
;
400 inode
->i_fop
= &simple_dir_operations
;
402 root
= d_alloc_root(inode
);
407 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
411 /* warn if it tries to conflict with the root inode */
412 if (unlikely(i
== 1))
413 printk(KERN_WARNING
"%s: %s passed in a files array"
414 "with an index of 1!\n", __func__
,
417 dentry
= d_alloc_name(root
, files
->name
);
420 inode
= new_inode(s
);
423 inode
->i_mode
= S_IFREG
| files
->mode
;
424 inode
->i_uid
= inode
->i_gid
= 0;
426 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
427 inode
->i_fop
= files
->ops
;
429 d_add(dentry
, inode
);
439 static DEFINE_SPINLOCK(pin_fs_lock
);
441 int simple_pin_fs(struct file_system_type
*type
, struct vfsmount
**mount
, int *count
)
443 struct vfsmount
*mnt
= NULL
;
444 spin_lock(&pin_fs_lock
);
445 if (unlikely(!*mount
)) {
446 spin_unlock(&pin_fs_lock
);
447 mnt
= vfs_kern_mount(type
, 0, type
->name
, NULL
);
450 spin_lock(&pin_fs_lock
);
456 spin_unlock(&pin_fs_lock
);
461 void simple_release_fs(struct vfsmount
**mount
, int *count
)
463 struct vfsmount
*mnt
;
464 spin_lock(&pin_fs_lock
);
468 spin_unlock(&pin_fs_lock
);
472 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
473 const void *from
, size_t available
)
478 if (pos
>= available
)
480 if (count
> available
- pos
)
481 count
= available
- pos
;
482 if (copy_to_user(to
, from
+ pos
, count
))
489 * Transaction based IO.
490 * The file expects a single write which triggers the transaction, and then
491 * possibly a read which collects the result - which is stored in a
494 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
496 struct simple_transaction_argresp
*ar
;
497 static DEFINE_SPINLOCK(simple_transaction_lock
);
499 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
500 return ERR_PTR(-EFBIG
);
502 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
504 return ERR_PTR(-ENOMEM
);
506 spin_lock(&simple_transaction_lock
);
508 /* only one write allowed per open */
509 if (file
->private_data
) {
510 spin_unlock(&simple_transaction_lock
);
511 free_page((unsigned long)ar
);
512 return ERR_PTR(-EBUSY
);
515 file
->private_data
= ar
;
517 spin_unlock(&simple_transaction_lock
);
519 if (copy_from_user(ar
->data
, buf
, size
))
520 return ERR_PTR(-EFAULT
);
525 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
527 struct simple_transaction_argresp
*ar
= file
->private_data
;
531 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
534 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
536 free_page((unsigned long)file
->private_data
);
540 /* Simple attribute files */
544 void (*set
)(void *, u64
);
545 char get_buf
[24]; /* enough to store a u64 and "\n\0" */
548 const char *fmt
; /* format for read operation */
549 struct mutex mutex
; /* protects access to these buffers */
552 /* simple_attr_open is called by an actual attribute open file operation
553 * to set the attribute specific access operations. */
554 int simple_attr_open(struct inode
*inode
, struct file
*file
,
555 u64 (*get
)(void *), void (*set
)(void *, u64
),
558 struct simple_attr
*attr
;
560 attr
= kmalloc(sizeof(*attr
), GFP_KERNEL
);
566 attr
->data
= inode
->i_private
;
568 mutex_init(&attr
->mutex
);
570 file
->private_data
= attr
;
572 return nonseekable_open(inode
, file
);
575 int simple_attr_close(struct inode
*inode
, struct file
*file
)
577 kfree(file
->private_data
);
581 /* read from the buffer that is filled with the get function */
582 ssize_t
simple_attr_read(struct file
*file
, char __user
*buf
,
583 size_t len
, loff_t
*ppos
)
585 struct simple_attr
*attr
;
589 attr
= file
->private_data
;
594 mutex_lock(&attr
->mutex
);
595 if (*ppos
) /* continued read */
596 size
= strlen(attr
->get_buf
);
597 else /* first read */
598 size
= scnprintf(attr
->get_buf
, sizeof(attr
->get_buf
),
600 (unsigned long long)attr
->get(attr
->data
));
602 ret
= simple_read_from_buffer(buf
, len
, ppos
, attr
->get_buf
, size
);
603 mutex_unlock(&attr
->mutex
);
607 /* interpret the buffer as a number to call the set function with */
608 ssize_t
simple_attr_write(struct file
*file
, const char __user
*buf
,
609 size_t len
, loff_t
*ppos
)
611 struct simple_attr
*attr
;
616 attr
= file
->private_data
;
621 mutex_lock(&attr
->mutex
);
623 size
= min(sizeof(attr
->set_buf
) - 1, len
);
624 if (copy_from_user(attr
->set_buf
, buf
, size
))
627 ret
= len
; /* claim we got the whole input */
628 attr
->set_buf
[size
] = '\0';
629 val
= simple_strtol(attr
->set_buf
, NULL
, 0);
630 attr
->set(attr
->data
, val
);
632 mutex_unlock(&attr
->mutex
);
636 EXPORT_SYMBOL(dcache_dir_close
);
637 EXPORT_SYMBOL(dcache_dir_lseek
);
638 EXPORT_SYMBOL(dcache_dir_open
);
639 EXPORT_SYMBOL(dcache_readdir
);
640 EXPORT_SYMBOL(generic_read_dir
);
641 EXPORT_SYMBOL(get_sb_pseudo
);
642 EXPORT_SYMBOL(simple_commit_write
);
643 EXPORT_SYMBOL(simple_dir_inode_operations
);
644 EXPORT_SYMBOL(simple_dir_operations
);
645 EXPORT_SYMBOL(simple_empty
);
646 EXPORT_SYMBOL(d_alloc_name
);
647 EXPORT_SYMBOL(simple_fill_super
);
648 EXPORT_SYMBOL(simple_getattr
);
649 EXPORT_SYMBOL(simple_link
);
650 EXPORT_SYMBOL(simple_lookup
);
651 EXPORT_SYMBOL(simple_pin_fs
);
652 EXPORT_SYMBOL(simple_prepare_write
);
653 EXPORT_SYMBOL(simple_readpage
);
654 EXPORT_SYMBOL(simple_release_fs
);
655 EXPORT_SYMBOL(simple_rename
);
656 EXPORT_SYMBOL(simple_rmdir
);
657 EXPORT_SYMBOL(simple_statfs
);
658 EXPORT_SYMBOL(simple_sync_file
);
659 EXPORT_SYMBOL(simple_unlink
);
660 EXPORT_SYMBOL(simple_read_from_buffer
);
661 EXPORT_SYMBOL(simple_transaction_get
);
662 EXPORT_SYMBOL(simple_transaction_read
);
663 EXPORT_SYMBOL(simple_transaction_release
);
664 EXPORT_SYMBOL_GPL(simple_attr_open
);
665 EXPORT_SYMBOL_GPL(simple_attr_close
);
666 EXPORT_SYMBOL_GPL(simple_attr_read
);
667 EXPORT_SYMBOL_GPL(simple_attr_write
);