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_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_child
);
101 if (!d_unhashed(next
) && next
->d_inode
)
105 list_add_tail(&cursor
->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_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_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
,
188 struct inode_operations simple_dir_inode_operations
= {
189 .lookup
= simple_lookup
,
193 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
194 * will never be mountable)
197 get_sb_pseudo(struct file_system_type
*fs_type
, char *name
,
198 struct super_operations
*ops
, unsigned long magic
)
200 struct super_block
*s
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
201 static struct super_operations default_ops
= {.statfs
= simple_statfs
};
202 struct dentry
*dentry
;
204 struct qstr d_name
= {.name
= name
, .len
= strlen(name
)};
209 s
->s_flags
= MS_NOUSER
;
210 s
->s_maxbytes
= ~0ULL;
211 s
->s_blocksize
= 1024;
212 s
->s_blocksize_bits
= 10;
214 s
->s_op
= ops
? ops
: &default_ops
;
219 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
220 root
->i_uid
= root
->i_gid
= 0;
221 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= CURRENT_TIME
;
222 dentry
= d_alloc(NULL
, &d_name
);
228 dentry
->d_parent
= dentry
;
229 d_instantiate(dentry
, root
);
231 s
->s_flags
|= MS_ACTIVE
;
235 up_write(&s
->s_umount
);
237 return ERR_PTR(-ENOMEM
);
240 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
242 struct inode
*inode
= old_dentry
->d_inode
;
244 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
246 atomic_inc(&inode
->i_count
);
248 d_instantiate(dentry
, inode
);
252 static inline int simple_positive(struct dentry
*dentry
)
254 return dentry
->d_inode
&& !d_unhashed(dentry
);
257 int simple_empty(struct dentry
*dentry
)
259 struct dentry
*child
;
262 spin_lock(&dcache_lock
);
263 list_for_each_entry(child
, &dentry
->d_subdirs
, d_child
)
264 if (simple_positive(child
))
268 spin_unlock(&dcache_lock
);
272 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
274 struct inode
*inode
= dentry
->d_inode
;
276 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
282 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
284 if (!simple_empty(dentry
))
287 dentry
->d_inode
->i_nlink
--;
288 simple_unlink(dir
, dentry
);
293 int simple_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
294 struct inode
*new_dir
, struct dentry
*new_dentry
)
296 struct inode
*inode
= old_dentry
->d_inode
;
297 int they_are_dirs
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
299 if (!simple_empty(new_dentry
))
302 if (new_dentry
->d_inode
) {
303 simple_unlink(new_dir
, new_dentry
);
306 } else if (they_are_dirs
) {
311 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
312 new_dir
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
317 int simple_readpage(struct file
*file
, struct page
*page
)
321 if (PageUptodate(page
))
324 kaddr
= kmap_atomic(page
, KM_USER0
);
325 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
326 kunmap_atomic(kaddr
, KM_USER0
);
327 flush_dcache_page(page
);
328 SetPageUptodate(page
);
334 int simple_prepare_write(struct file
*file
, struct page
*page
,
335 unsigned from
, unsigned to
)
337 if (!PageUptodate(page
)) {
338 if (to
- from
!= PAGE_CACHE_SIZE
) {
339 void *kaddr
= kmap_atomic(page
, KM_USER0
);
340 memset(kaddr
, 0, from
);
341 memset(kaddr
+ to
, 0, PAGE_CACHE_SIZE
- to
);
342 flush_dcache_page(page
);
343 kunmap_atomic(kaddr
, KM_USER0
);
345 SetPageUptodate(page
);
350 int simple_commit_write(struct file
*file
, struct page
*page
,
351 unsigned offset
, unsigned to
)
353 struct inode
*inode
= page
->mapping
->host
;
354 loff_t pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
357 * No need to use i_size_read() here, the i_size
358 * cannot change under us because we hold the i_sem.
360 if (pos
> inode
->i_size
)
361 i_size_write(inode
, pos
);
362 set_page_dirty(page
);
366 int simple_fill_super(struct super_block
*s
, int magic
, struct tree_descr
*files
)
368 static struct super_operations s_ops
= {.statfs
= simple_statfs
};
371 struct dentry
*dentry
;
374 s
->s_blocksize
= PAGE_CACHE_SIZE
;
375 s
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
380 inode
= new_inode(s
);
383 inode
->i_mode
= S_IFDIR
| 0755;
384 inode
->i_uid
= inode
->i_gid
= 0;
385 inode
->i_blksize
= PAGE_CACHE_SIZE
;
387 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
388 inode
->i_op
= &simple_dir_inode_operations
;
389 inode
->i_fop
= &simple_dir_operations
;
390 root
= d_alloc_root(inode
);
395 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
398 dentry
= d_alloc_name(root
, files
->name
);
401 inode
= new_inode(s
);
404 inode
->i_mode
= S_IFREG
| files
->mode
;
405 inode
->i_uid
= inode
->i_gid
= 0;
406 inode
->i_blksize
= PAGE_CACHE_SIZE
;
408 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
409 inode
->i_fop
= files
->ops
;
411 d_add(dentry
, inode
);
421 static DEFINE_SPINLOCK(pin_fs_lock
);
423 int simple_pin_fs(char *name
, struct vfsmount
**mount
, int *count
)
425 struct vfsmount
*mnt
= NULL
;
426 spin_lock(&pin_fs_lock
);
427 if (unlikely(!*mount
)) {
428 spin_unlock(&pin_fs_lock
);
429 mnt
= do_kern_mount(name
, 0, name
, NULL
);
432 spin_lock(&pin_fs_lock
);
438 spin_unlock(&pin_fs_lock
);
443 void simple_release_fs(struct vfsmount
**mount
, int *count
)
445 struct vfsmount
*mnt
;
446 spin_lock(&pin_fs_lock
);
450 spin_unlock(&pin_fs_lock
);
454 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
455 const void *from
, size_t available
)
460 if (pos
>= available
)
462 if (count
> available
- pos
)
463 count
= available
- pos
;
464 if (copy_to_user(to
, from
+ pos
, count
))
471 * Transaction based IO.
472 * The file expects a single write which triggers the transaction, and then
473 * possibly a read which collects the result - which is stored in a
476 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
478 struct simple_transaction_argresp
*ar
;
479 static DEFINE_SPINLOCK(simple_transaction_lock
);
481 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
482 return ERR_PTR(-EFBIG
);
484 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
486 return ERR_PTR(-ENOMEM
);
488 spin_lock(&simple_transaction_lock
);
490 /* only one write allowed per open */
491 if (file
->private_data
) {
492 spin_unlock(&simple_transaction_lock
);
493 free_page((unsigned long)ar
);
494 return ERR_PTR(-EBUSY
);
497 file
->private_data
= ar
;
499 spin_unlock(&simple_transaction_lock
);
501 if (copy_from_user(ar
->data
, buf
, size
))
502 return ERR_PTR(-EFAULT
);
507 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
509 struct simple_transaction_argresp
*ar
= file
->private_data
;
513 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
516 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
518 free_page((unsigned long)file
->private_data
);
522 EXPORT_SYMBOL(dcache_dir_close
);
523 EXPORT_SYMBOL(dcache_dir_lseek
);
524 EXPORT_SYMBOL(dcache_dir_open
);
525 EXPORT_SYMBOL(dcache_readdir
);
526 EXPORT_SYMBOL(generic_read_dir
);
527 EXPORT_SYMBOL(get_sb_pseudo
);
528 EXPORT_SYMBOL(simple_commit_write
);
529 EXPORT_SYMBOL(simple_dir_inode_operations
);
530 EXPORT_SYMBOL(simple_dir_operations
);
531 EXPORT_SYMBOL(simple_empty
);
532 EXPORT_SYMBOL(d_alloc_name
);
533 EXPORT_SYMBOL(simple_fill_super
);
534 EXPORT_SYMBOL(simple_getattr
);
535 EXPORT_SYMBOL(simple_link
);
536 EXPORT_SYMBOL(simple_lookup
);
537 EXPORT_SYMBOL(simple_pin_fs
);
538 EXPORT_SYMBOL(simple_prepare_write
);
539 EXPORT_SYMBOL(simple_readpage
);
540 EXPORT_SYMBOL(simple_release_fs
);
541 EXPORT_SYMBOL(simple_rename
);
542 EXPORT_SYMBOL(simple_rmdir
);
543 EXPORT_SYMBOL(simple_statfs
);
544 EXPORT_SYMBOL(simple_sync_file
);
545 EXPORT_SYMBOL(simple_unlink
);
546 EXPORT_SYMBOL(simple_read_from_buffer
);
547 EXPORT_SYMBOL(simple_transaction_get
);
548 EXPORT_SYMBOL(simple_transaction_read
);
549 EXPORT_SYMBOL(simple_transaction_release
);