3 * Library for filesystems writers.
6 #include <linux/module.h>
7 #include <linux/pagemap.h>
8 #include <linux/mount.h>
10 #include <asm/uaccess.h>
12 int simple_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
15 struct inode
*inode
= dentry
->d_inode
;
16 generic_fillattr(inode
, stat
);
17 stat
->blocks
= inode
->i_mapping
->nrpages
<< (PAGE_CACHE_SHIFT
- 9);
21 int simple_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
23 buf
->f_type
= sb
->s_magic
;
24 buf
->f_bsize
= PAGE_CACHE_SIZE
;
25 buf
->f_namelen
= NAME_MAX
;
30 * Retaining negative dentries for an in-memory filesystem just wastes
31 * memory and lookup time: arrange for them to be deleted immediately.
33 static int simple_delete_dentry(struct dentry
*dentry
)
39 * Lookup the data. This is trivial - if the dentry didn't already
40 * exist, we know it is negative. Set d_op to delete negative dentries.
42 struct dentry
*simple_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
44 static struct dentry_operations simple_dentry_operations
= {
45 .d_delete
= simple_delete_dentry
,
48 if (dentry
->d_name
.len
> NAME_MAX
)
49 return ERR_PTR(-ENAMETOOLONG
);
50 dentry
->d_op
= &simple_dentry_operations
;
55 int simple_sync_file(struct file
* file
, struct dentry
*dentry
, int datasync
)
60 int dcache_dir_open(struct inode
*inode
, struct file
*file
)
62 static struct qstr cursor_name
= {.len
= 1, .name
= "."};
64 file
->private_data
= d_alloc(file
->f_dentry
, &cursor_name
);
66 return file
->private_data
? 0 : -ENOMEM
;
69 int dcache_dir_close(struct inode
*inode
, struct file
*file
)
71 dput(file
->private_data
);
75 loff_t
dcache_dir_lseek(struct file
*file
, loff_t offset
, int origin
)
77 down(&file
->f_dentry
->d_inode
->i_sem
);
80 offset
+= file
->f_pos
;
85 up(&file
->f_dentry
->d_inode
->i_sem
);
88 if (offset
!= file
->f_pos
) {
90 if (file
->f_pos
>= 2) {
92 struct dentry
*cursor
= file
->private_data
;
93 loff_t n
= file
->f_pos
- 2;
95 spin_lock(&dcache_lock
);
96 list_del(&cursor
->d_u
.d_child
);
97 p
= file
->f_dentry
->d_subdirs
.next
;
98 while (n
&& p
!= &file
->f_dentry
->d_subdirs
) {
100 next
= list_entry(p
, struct dentry
, d_u
.d_child
);
101 if (!d_unhashed(next
) && next
->d_inode
)
105 list_add_tail(&cursor
->d_u
.d_child
, p
);
106 spin_unlock(&dcache_lock
);
109 up(&file
->f_dentry
->d_inode
->i_sem
);
113 /* Relationship between i_mode and the DT_xxx types */
114 static inline unsigned char dt_type(struct inode
*inode
)
116 return (inode
->i_mode
>> 12) & 15;
120 * Directory is locked and all positive dentries in it are safe, since
121 * for ramfs-type trees they can't go away without unlink() or rmdir(),
122 * both impossible due to the lock on directory.
125 int dcache_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
127 struct dentry
*dentry
= filp
->f_dentry
;
128 struct dentry
*cursor
= filp
->private_data
;
129 struct list_head
*p
, *q
= &cursor
->d_u
.d_child
;
135 ino
= dentry
->d_inode
->i_ino
;
136 if (filldir(dirent
, ".", 1, i
, ino
, DT_DIR
) < 0)
142 ino
= parent_ino(dentry
);
143 if (filldir(dirent
, "..", 2, i
, ino
, DT_DIR
) < 0)
149 spin_lock(&dcache_lock
);
150 if (filp
->f_pos
== 2) {
152 list_add(q
, &dentry
->d_subdirs
);
154 for (p
=q
->next
; p
!= &dentry
->d_subdirs
; p
=p
->next
) {
156 next
= list_entry(p
, struct dentry
, d_u
.d_child
);
157 if (d_unhashed(next
) || !next
->d_inode
)
160 spin_unlock(&dcache_lock
);
161 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)
163 spin_lock(&dcache_lock
);
164 /* 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 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 struct inode_operations simple_dir_inode_operations
= {
190 .lookup
= simple_lookup
,
194 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
195 * will never be mountable)
198 get_sb_pseudo(struct file_system_type
*fs_type
, char *name
,
199 struct super_operations
*ops
, unsigned long magic
)
201 struct super_block
*s
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
202 static struct super_operations default_ops
= {.statfs
= simple_statfs
};
203 struct dentry
*dentry
;
205 struct qstr d_name
= {.name
= name
, .len
= strlen(name
)};
210 s
->s_flags
= MS_NOUSER
;
211 s
->s_maxbytes
= ~0ULL;
212 s
->s_blocksize
= 1024;
213 s
->s_blocksize_bits
= 10;
215 s
->s_op
= ops
? ops
: &default_ops
;
220 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
221 root
->i_uid
= root
->i_gid
= 0;
222 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= CURRENT_TIME
;
223 dentry
= d_alloc(NULL
, &d_name
);
229 dentry
->d_parent
= dentry
;
230 d_instantiate(dentry
, root
);
232 s
->s_flags
|= MS_ACTIVE
;
236 up_write(&s
->s_umount
);
238 return ERR_PTR(-ENOMEM
);
241 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
243 struct inode
*inode
= old_dentry
->d_inode
;
245 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
247 atomic_inc(&inode
->i_count
);
249 d_instantiate(dentry
, inode
);
253 static inline int simple_positive(struct dentry
*dentry
)
255 return dentry
->d_inode
&& !d_unhashed(dentry
);
258 int simple_empty(struct dentry
*dentry
)
260 struct dentry
*child
;
263 spin_lock(&dcache_lock
);
264 list_for_each_entry(child
, &dentry
->d_subdirs
, d_u
.d_child
)
265 if (simple_positive(child
))
269 spin_unlock(&dcache_lock
);
273 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
275 struct inode
*inode
= dentry
->d_inode
;
277 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
283 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
285 if (!simple_empty(dentry
))
288 dentry
->d_inode
->i_nlink
--;
289 simple_unlink(dir
, dentry
);
294 int simple_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
295 struct inode
*new_dir
, struct dentry
*new_dentry
)
297 struct inode
*inode
= old_dentry
->d_inode
;
298 int they_are_dirs
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
300 if (!simple_empty(new_dentry
))
303 if (new_dentry
->d_inode
) {
304 simple_unlink(new_dir
, new_dentry
);
307 } else if (they_are_dirs
) {
312 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
313 new_dir
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
318 int simple_readpage(struct file
*file
, struct page
*page
)
322 if (PageUptodate(page
))
325 kaddr
= kmap_atomic(page
, KM_USER0
);
326 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
327 kunmap_atomic(kaddr
, KM_USER0
);
328 flush_dcache_page(page
);
329 SetPageUptodate(page
);
335 int simple_prepare_write(struct file
*file
, struct page
*page
,
336 unsigned from
, unsigned to
)
338 if (!PageUptodate(page
)) {
339 if (to
- from
!= PAGE_CACHE_SIZE
) {
340 void *kaddr
= kmap_atomic(page
, KM_USER0
);
341 memset(kaddr
, 0, from
);
342 memset(kaddr
+ to
, 0, PAGE_CACHE_SIZE
- to
);
343 flush_dcache_page(page
);
344 kunmap_atomic(kaddr
, KM_USER0
);
346 SetPageUptodate(page
);
351 int simple_commit_write(struct file
*file
, struct page
*page
,
352 unsigned offset
, unsigned to
)
354 struct inode
*inode
= page
->mapping
->host
;
355 loff_t pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
358 * No need to use i_size_read() here, the i_size
359 * cannot change under us because we hold the i_sem.
361 if (pos
> inode
->i_size
)
362 i_size_write(inode
, pos
);
363 set_page_dirty(page
);
367 int simple_fill_super(struct super_block
*s
, int magic
, struct tree_descr
*files
)
369 static struct super_operations s_ops
= {.statfs
= simple_statfs
};
372 struct dentry
*dentry
;
375 s
->s_blocksize
= PAGE_CACHE_SIZE
;
376 s
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
381 inode
= new_inode(s
);
384 inode
->i_mode
= S_IFDIR
| 0755;
385 inode
->i_uid
= inode
->i_gid
= 0;
386 inode
->i_blksize
= PAGE_CACHE_SIZE
;
388 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
389 inode
->i_op
= &simple_dir_inode_operations
;
390 inode
->i_fop
= &simple_dir_operations
;
391 root
= d_alloc_root(inode
);
396 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
399 dentry
= d_alloc_name(root
, files
->name
);
402 inode
= new_inode(s
);
405 inode
->i_mode
= S_IFREG
| files
->mode
;
406 inode
->i_uid
= inode
->i_gid
= 0;
407 inode
->i_blksize
= PAGE_CACHE_SIZE
;
409 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
410 inode
->i_fop
= files
->ops
;
412 d_add(dentry
, inode
);
422 static DEFINE_SPINLOCK(pin_fs_lock
);
424 int simple_pin_fs(char *name
, struct vfsmount
**mount
, int *count
)
426 struct vfsmount
*mnt
= NULL
;
427 spin_lock(&pin_fs_lock
);
428 if (unlikely(!*mount
)) {
429 spin_unlock(&pin_fs_lock
);
430 mnt
= do_kern_mount(name
, 0, name
, NULL
);
433 spin_lock(&pin_fs_lock
);
439 spin_unlock(&pin_fs_lock
);
444 void simple_release_fs(struct vfsmount
**mount
, int *count
)
446 struct vfsmount
*mnt
;
447 spin_lock(&pin_fs_lock
);
451 spin_unlock(&pin_fs_lock
);
455 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
456 const void *from
, size_t available
)
461 if (pos
>= available
)
463 if (count
> available
- pos
)
464 count
= available
- pos
;
465 if (copy_to_user(to
, from
+ pos
, count
))
472 * Transaction based IO.
473 * The file expects a single write which triggers the transaction, and then
474 * possibly a read which collects the result - which is stored in a
477 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
479 struct simple_transaction_argresp
*ar
;
480 static DEFINE_SPINLOCK(simple_transaction_lock
);
482 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
483 return ERR_PTR(-EFBIG
);
485 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
487 return ERR_PTR(-ENOMEM
);
489 spin_lock(&simple_transaction_lock
);
491 /* only one write allowed per open */
492 if (file
->private_data
) {
493 spin_unlock(&simple_transaction_lock
);
494 free_page((unsigned long)ar
);
495 return ERR_PTR(-EBUSY
);
498 file
->private_data
= ar
;
500 spin_unlock(&simple_transaction_lock
);
502 if (copy_from_user(ar
->data
, buf
, size
))
503 return ERR_PTR(-EFAULT
);
508 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
510 struct simple_transaction_argresp
*ar
= file
->private_data
;
514 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
517 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
519 free_page((unsigned long)file
->private_data
);
523 /* Simple attribute files */
527 void (*set
)(void *, u64
);
528 char get_buf
[24]; /* enough to store a u64 and "\n\0" */
531 const char *fmt
; /* format for read operation */
532 struct semaphore sem
; /* protects access to these buffers */
535 /* simple_attr_open is called by an actual attribute open file operation
536 * to set the attribute specific access operations. */
537 int simple_attr_open(struct inode
*inode
, struct file
*file
,
538 u64 (*get
)(void *), void (*set
)(void *, u64
),
541 struct simple_attr
*attr
;
543 attr
= kmalloc(sizeof(*attr
), GFP_KERNEL
);
549 attr
->data
= inode
->u
.generic_ip
;
551 init_MUTEX(&attr
->sem
);
553 file
->private_data
= attr
;
555 return nonseekable_open(inode
, file
);
558 int simple_attr_close(struct inode
*inode
, struct file
*file
)
560 kfree(file
->private_data
);
564 /* read from the buffer that is filled with the get function */
565 ssize_t
simple_attr_read(struct file
*file
, char __user
*buf
,
566 size_t len
, loff_t
*ppos
)
568 struct simple_attr
*attr
;
572 attr
= file
->private_data
;
578 if (*ppos
) /* continued read */
579 size
= strlen(attr
->get_buf
);
580 else /* first read */
581 size
= scnprintf(attr
->get_buf
, sizeof(attr
->get_buf
),
583 (unsigned long long)attr
->get(attr
->data
));
585 ret
= simple_read_from_buffer(buf
, len
, ppos
, attr
->get_buf
, size
);
590 /* interpret the buffer as a number to call the set function with */
591 ssize_t
simple_attr_write(struct file
*file
, const char __user
*buf
,
592 size_t len
, loff_t
*ppos
)
594 struct simple_attr
*attr
;
599 attr
= file
->private_data
;
606 size
= min(sizeof(attr
->set_buf
) - 1, len
);
607 if (copy_from_user(attr
->set_buf
, buf
, size
))
610 ret
= len
; /* claim we got the whole input */
611 attr
->set_buf
[size
] = '\0';
612 val
= simple_strtol(attr
->set_buf
, NULL
, 0);
613 attr
->set(attr
->data
, val
);
619 EXPORT_SYMBOL(dcache_dir_close
);
620 EXPORT_SYMBOL(dcache_dir_lseek
);
621 EXPORT_SYMBOL(dcache_dir_open
);
622 EXPORT_SYMBOL(dcache_readdir
);
623 EXPORT_SYMBOL(generic_read_dir
);
624 EXPORT_SYMBOL(get_sb_pseudo
);
625 EXPORT_SYMBOL(simple_commit_write
);
626 EXPORT_SYMBOL(simple_dir_inode_operations
);
627 EXPORT_SYMBOL(simple_dir_operations
);
628 EXPORT_SYMBOL(simple_empty
);
629 EXPORT_SYMBOL(d_alloc_name
);
630 EXPORT_SYMBOL(simple_fill_super
);
631 EXPORT_SYMBOL(simple_getattr
);
632 EXPORT_SYMBOL(simple_link
);
633 EXPORT_SYMBOL(simple_lookup
);
634 EXPORT_SYMBOL(simple_pin_fs
);
635 EXPORT_SYMBOL(simple_prepare_write
);
636 EXPORT_SYMBOL(simple_readpage
);
637 EXPORT_SYMBOL(simple_release_fs
);
638 EXPORT_SYMBOL(simple_rename
);
639 EXPORT_SYMBOL(simple_rmdir
);
640 EXPORT_SYMBOL(simple_statfs
);
641 EXPORT_SYMBOL(simple_sync_file
);
642 EXPORT_SYMBOL(simple_unlink
);
643 EXPORT_SYMBOL(simple_read_from_buffer
);
644 EXPORT_SYMBOL(simple_transaction_get
);
645 EXPORT_SYMBOL(simple_transaction_read
);
646 EXPORT_SYMBOL(simple_transaction_release
);
647 EXPORT_SYMBOL_GPL(simple_attr_open
);
648 EXPORT_SYMBOL_GPL(simple_attr_close
);
649 EXPORT_SYMBOL_GPL(simple_attr_read
);
650 EXPORT_SYMBOL_GPL(simple_attr_write
);