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 super_block
*sb
, struct kstatfs
*buf
)
25 buf
->f_type
= 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_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_dentry
->d_inode
->i_mutex
);
82 offset
+= file
->f_pos
;
87 mutex_unlock(&file
->f_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_dentry
->d_subdirs
.next
;
100 while (n
&& p
!= &file
->f_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_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_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) {
154 list_add(q
, &dentry
->d_subdirs
);
156 for (p
=q
->next
; p
!= &dentry
->d_subdirs
; p
=p
->next
) {
158 next
= list_entry(p
, struct dentry
, d_u
.d_child
);
159 if (d_unhashed(next
) || !next
->d_inode
)
162 spin_unlock(&dcache_lock
);
163 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)
165 spin_lock(&dcache_lock
);
166 /* next is still alive */
172 spin_unlock(&dcache_lock
);
177 ssize_t
generic_read_dir(struct file
*filp
, char __user
*buf
, size_t siz
, loff_t
*ppos
)
182 const struct file_operations simple_dir_operations
= {
183 .open
= dcache_dir_open
,
184 .release
= dcache_dir_close
,
185 .llseek
= dcache_dir_lseek
,
186 .read
= generic_read_dir
,
187 .readdir
= dcache_readdir
,
188 .fsync
= simple_sync_file
,
191 struct inode_operations simple_dir_inode_operations
= {
192 .lookup
= simple_lookup
,
196 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
197 * will never be mountable)
200 get_sb_pseudo(struct file_system_type
*fs_type
, char *name
,
201 struct super_operations
*ops
, unsigned long magic
)
203 struct super_block
*s
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
204 static struct super_operations default_ops
= {.statfs
= simple_statfs
};
205 struct dentry
*dentry
;
207 struct qstr d_name
= {.name
= name
, .len
= strlen(name
)};
212 s
->s_flags
= MS_NOUSER
;
213 s
->s_maxbytes
= ~0ULL;
214 s
->s_blocksize
= 1024;
215 s
->s_blocksize_bits
= 10;
217 s
->s_op
= ops
? ops
: &default_ops
;
222 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
223 root
->i_uid
= root
->i_gid
= 0;
224 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= CURRENT_TIME
;
225 dentry
= d_alloc(NULL
, &d_name
);
231 dentry
->d_parent
= dentry
;
232 d_instantiate(dentry
, root
);
234 s
->s_flags
|= MS_ACTIVE
;
238 up_write(&s
->s_umount
);
240 return ERR_PTR(-ENOMEM
);
243 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
245 struct inode
*inode
= old_dentry
->d_inode
;
247 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
249 atomic_inc(&inode
->i_count
);
251 d_instantiate(dentry
, inode
);
255 static inline int simple_positive(struct dentry
*dentry
)
257 return dentry
->d_inode
&& !d_unhashed(dentry
);
260 int simple_empty(struct dentry
*dentry
)
262 struct dentry
*child
;
265 spin_lock(&dcache_lock
);
266 list_for_each_entry(child
, &dentry
->d_subdirs
, d_u
.d_child
)
267 if (simple_positive(child
))
271 spin_unlock(&dcache_lock
);
275 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
277 struct inode
*inode
= dentry
->d_inode
;
279 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
285 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
287 if (!simple_empty(dentry
))
290 dentry
->d_inode
->i_nlink
--;
291 simple_unlink(dir
, dentry
);
296 int simple_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
297 struct inode
*new_dir
, struct dentry
*new_dentry
)
299 struct inode
*inode
= old_dentry
->d_inode
;
300 int they_are_dirs
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
302 if (!simple_empty(new_dentry
))
305 if (new_dentry
->d_inode
) {
306 simple_unlink(new_dir
, new_dentry
);
309 } else if (they_are_dirs
) {
314 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
315 new_dir
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
320 int simple_readpage(struct file
*file
, struct page
*page
)
324 if (PageUptodate(page
))
327 kaddr
= kmap_atomic(page
, KM_USER0
);
328 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
329 kunmap_atomic(kaddr
, KM_USER0
);
330 flush_dcache_page(page
);
331 SetPageUptodate(page
);
337 int simple_prepare_write(struct file
*file
, struct page
*page
,
338 unsigned from
, unsigned to
)
340 if (!PageUptodate(page
)) {
341 if (to
- from
!= PAGE_CACHE_SIZE
) {
342 void *kaddr
= kmap_atomic(page
, KM_USER0
);
343 memset(kaddr
, 0, from
);
344 memset(kaddr
+ to
, 0, PAGE_CACHE_SIZE
- to
);
345 flush_dcache_page(page
);
346 kunmap_atomic(kaddr
, KM_USER0
);
348 SetPageUptodate(page
);
353 int simple_commit_write(struct file
*file
, struct page
*page
,
354 unsigned offset
, unsigned to
)
356 struct inode
*inode
= page
->mapping
->host
;
357 loff_t pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
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
);
369 int simple_fill_super(struct super_block
*s
, int magic
, struct tree_descr
*files
)
371 static struct super_operations s_ops
= {.statfs
= simple_statfs
};
374 struct dentry
*dentry
;
377 s
->s_blocksize
= PAGE_CACHE_SIZE
;
378 s
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
383 inode
= new_inode(s
);
386 inode
->i_mode
= S_IFDIR
| 0755;
387 inode
->i_uid
= inode
->i_gid
= 0;
388 inode
->i_blksize
= PAGE_CACHE_SIZE
;
390 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
391 inode
->i_op
= &simple_dir_inode_operations
;
392 inode
->i_fop
= &simple_dir_operations
;
394 root
= d_alloc_root(inode
);
399 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
402 dentry
= d_alloc_name(root
, files
->name
);
405 inode
= new_inode(s
);
408 inode
->i_mode
= S_IFREG
| files
->mode
;
409 inode
->i_uid
= inode
->i_gid
= 0;
410 inode
->i_blksize
= PAGE_CACHE_SIZE
;
412 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
413 inode
->i_fop
= files
->ops
;
415 d_add(dentry
, inode
);
425 static DEFINE_SPINLOCK(pin_fs_lock
);
427 int simple_pin_fs(char *name
, struct vfsmount
**mount
, int *count
)
429 struct vfsmount
*mnt
= NULL
;
430 spin_lock(&pin_fs_lock
);
431 if (unlikely(!*mount
)) {
432 spin_unlock(&pin_fs_lock
);
433 mnt
= do_kern_mount(name
, 0, name
, NULL
);
436 spin_lock(&pin_fs_lock
);
442 spin_unlock(&pin_fs_lock
);
447 void simple_release_fs(struct vfsmount
**mount
, int *count
)
449 struct vfsmount
*mnt
;
450 spin_lock(&pin_fs_lock
);
454 spin_unlock(&pin_fs_lock
);
458 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
459 const void *from
, size_t available
)
464 if (pos
>= available
)
466 if (count
> available
- pos
)
467 count
= available
- pos
;
468 if (copy_to_user(to
, from
+ pos
, count
))
475 * Transaction based IO.
476 * The file expects a single write which triggers the transaction, and then
477 * possibly a read which collects the result - which is stored in a
480 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
482 struct simple_transaction_argresp
*ar
;
483 static DEFINE_SPINLOCK(simple_transaction_lock
);
485 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
486 return ERR_PTR(-EFBIG
);
488 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
490 return ERR_PTR(-ENOMEM
);
492 spin_lock(&simple_transaction_lock
);
494 /* only one write allowed per open */
495 if (file
->private_data
) {
496 spin_unlock(&simple_transaction_lock
);
497 free_page((unsigned long)ar
);
498 return ERR_PTR(-EBUSY
);
501 file
->private_data
= ar
;
503 spin_unlock(&simple_transaction_lock
);
505 if (copy_from_user(ar
->data
, buf
, size
))
506 return ERR_PTR(-EFAULT
);
511 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
513 struct simple_transaction_argresp
*ar
= file
->private_data
;
517 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
520 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
522 free_page((unsigned long)file
->private_data
);
526 /* Simple attribute files */
530 void (*set
)(void *, u64
);
531 char get_buf
[24]; /* enough to store a u64 and "\n\0" */
534 const char *fmt
; /* format for read operation */
535 struct mutex mutex
; /* protects access to these buffers */
538 /* simple_attr_open is called by an actual attribute open file operation
539 * to set the attribute specific access operations. */
540 int simple_attr_open(struct inode
*inode
, struct file
*file
,
541 u64 (*get
)(void *), void (*set
)(void *, u64
),
544 struct simple_attr
*attr
;
546 attr
= kmalloc(sizeof(*attr
), GFP_KERNEL
);
552 attr
->data
= inode
->u
.generic_ip
;
554 mutex_init(&attr
->mutex
);
556 file
->private_data
= attr
;
558 return nonseekable_open(inode
, file
);
561 int simple_attr_close(struct inode
*inode
, struct file
*file
)
563 kfree(file
->private_data
);
567 /* read from the buffer that is filled with the get function */
568 ssize_t
simple_attr_read(struct file
*file
, char __user
*buf
,
569 size_t len
, loff_t
*ppos
)
571 struct simple_attr
*attr
;
575 attr
= file
->private_data
;
580 mutex_lock(&attr
->mutex
);
581 if (*ppos
) /* continued read */
582 size
= strlen(attr
->get_buf
);
583 else /* first read */
584 size
= scnprintf(attr
->get_buf
, sizeof(attr
->get_buf
),
586 (unsigned long long)attr
->get(attr
->data
));
588 ret
= simple_read_from_buffer(buf
, len
, ppos
, attr
->get_buf
, size
);
589 mutex_unlock(&attr
->mutex
);
593 /* interpret the buffer as a number to call the set function with */
594 ssize_t
simple_attr_write(struct file
*file
, const char __user
*buf
,
595 size_t len
, loff_t
*ppos
)
597 struct simple_attr
*attr
;
602 attr
= file
->private_data
;
607 mutex_lock(&attr
->mutex
);
609 size
= min(sizeof(attr
->set_buf
) - 1, len
);
610 if (copy_from_user(attr
->set_buf
, buf
, size
))
613 ret
= len
; /* claim we got the whole input */
614 attr
->set_buf
[size
] = '\0';
615 val
= simple_strtol(attr
->set_buf
, NULL
, 0);
616 attr
->set(attr
->data
, val
);
618 mutex_unlock(&attr
->mutex
);
622 EXPORT_SYMBOL(dcache_dir_close
);
623 EXPORT_SYMBOL(dcache_dir_lseek
);
624 EXPORT_SYMBOL(dcache_dir_open
);
625 EXPORT_SYMBOL(dcache_readdir
);
626 EXPORT_SYMBOL(generic_read_dir
);
627 EXPORT_SYMBOL(get_sb_pseudo
);
628 EXPORT_SYMBOL(simple_commit_write
);
629 EXPORT_SYMBOL(simple_dir_inode_operations
);
630 EXPORT_SYMBOL(simple_dir_operations
);
631 EXPORT_SYMBOL(simple_empty
);
632 EXPORT_SYMBOL(d_alloc_name
);
633 EXPORT_SYMBOL(simple_fill_super
);
634 EXPORT_SYMBOL(simple_getattr
);
635 EXPORT_SYMBOL(simple_link
);
636 EXPORT_SYMBOL(simple_lookup
);
637 EXPORT_SYMBOL(simple_pin_fs
);
638 EXPORT_SYMBOL(simple_prepare_write
);
639 EXPORT_SYMBOL(simple_readpage
);
640 EXPORT_SYMBOL(simple_release_fs
);
641 EXPORT_SYMBOL(simple_rename
);
642 EXPORT_SYMBOL(simple_rmdir
);
643 EXPORT_SYMBOL(simple_statfs
);
644 EXPORT_SYMBOL(simple_sync_file
);
645 EXPORT_SYMBOL(simple_unlink
);
646 EXPORT_SYMBOL(simple_read_from_buffer
);
647 EXPORT_SYMBOL(simple_transaction_get
);
648 EXPORT_SYMBOL(simple_transaction_read
);
649 EXPORT_SYMBOL(simple_transaction_release
);
650 EXPORT_SYMBOL_GPL(simple_attr_open
);
651 EXPORT_SYMBOL_GPL(simple_attr_close
);
652 EXPORT_SYMBOL_GPL(simple_attr_read
);
653 EXPORT_SYMBOL_GPL(simple_attr_write
);