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
;
218 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
219 root
->i_uid
= root
->i_gid
= 0;
220 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= CURRENT_TIME
;
221 dentry
= d_alloc(NULL
, &d_name
);
227 dentry
->d_parent
= dentry
;
228 d_instantiate(dentry
, root
);
230 s
->s_flags
|= MS_ACTIVE
;
234 up_write(&s
->s_umount
);
236 return ERR_PTR(-ENOMEM
);
239 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
241 struct inode
*inode
= old_dentry
->d_inode
;
243 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
245 atomic_inc(&inode
->i_count
);
247 d_instantiate(dentry
, inode
);
251 static inline int simple_positive(struct dentry
*dentry
)
253 return dentry
->d_inode
&& !d_unhashed(dentry
);
256 int simple_empty(struct dentry
*dentry
)
258 struct dentry
*child
;
261 spin_lock(&dcache_lock
);
262 list_for_each_entry(child
, &dentry
->d_subdirs
, d_child
)
263 if (simple_positive(child
))
267 spin_unlock(&dcache_lock
);
271 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
273 struct inode
*inode
= dentry
->d_inode
;
275 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
281 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
283 if (!simple_empty(dentry
))
286 dentry
->d_inode
->i_nlink
--;
287 simple_unlink(dir
, dentry
);
292 int simple_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
293 struct inode
*new_dir
, struct dentry
*new_dentry
)
295 struct inode
*inode
= old_dentry
->d_inode
;
296 int they_are_dirs
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
298 if (!simple_empty(new_dentry
))
301 if (new_dentry
->d_inode
) {
302 simple_unlink(new_dir
, new_dentry
);
305 } else if (they_are_dirs
) {
310 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
311 new_dir
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
316 int simple_readpage(struct file
*file
, struct page
*page
)
320 if (PageUptodate(page
))
323 kaddr
= kmap_atomic(page
, KM_USER0
);
324 memset(kaddr
, 0, PAGE_CACHE_SIZE
);
325 kunmap_atomic(kaddr
, KM_USER0
);
326 flush_dcache_page(page
);
327 SetPageUptodate(page
);
333 int simple_prepare_write(struct file
*file
, struct page
*page
,
334 unsigned from
, unsigned to
)
336 if (!PageUptodate(page
)) {
337 if (to
- from
!= PAGE_CACHE_SIZE
) {
338 void *kaddr
= kmap_atomic(page
, KM_USER0
);
339 memset(kaddr
, 0, from
);
340 memset(kaddr
+ to
, 0, PAGE_CACHE_SIZE
- to
);
341 flush_dcache_page(page
);
342 kunmap_atomic(kaddr
, KM_USER0
);
344 SetPageUptodate(page
);
349 int simple_commit_write(struct file
*file
, struct page
*page
,
350 unsigned offset
, unsigned to
)
352 struct inode
*inode
= page
->mapping
->host
;
353 loff_t pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
356 * No need to use i_size_read() here, the i_size
357 * cannot change under us because we hold the i_sem.
359 if (pos
> inode
->i_size
)
360 i_size_write(inode
, pos
);
361 set_page_dirty(page
);
365 int simple_fill_super(struct super_block
*s
, int magic
, struct tree_descr
*files
)
367 static struct super_operations s_ops
= {.statfs
= simple_statfs
};
370 struct dentry
*dentry
;
373 s
->s_blocksize
= PAGE_CACHE_SIZE
;
374 s
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
378 inode
= new_inode(s
);
381 inode
->i_mode
= S_IFDIR
| 0755;
382 inode
->i_uid
= inode
->i_gid
= 0;
383 inode
->i_blksize
= PAGE_CACHE_SIZE
;
385 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
386 inode
->i_op
= &simple_dir_inode_operations
;
387 inode
->i_fop
= &simple_dir_operations
;
388 root
= d_alloc_root(inode
);
393 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
397 name
.name
= files
->name
;
398 name
.len
= strlen(name
.name
);
399 name
.hash
= full_name_hash(name
.name
, name
.len
);
400 dentry
= d_alloc(root
, &name
);
403 inode
= new_inode(s
);
406 inode
->i_mode
= S_IFREG
| files
->mode
;
407 inode
->i_uid
= inode
->i_gid
= 0;
408 inode
->i_blksize
= PAGE_CACHE_SIZE
;
410 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
411 inode
->i_fop
= files
->ops
;
413 d_add(dentry
, inode
);
423 static spinlock_t pin_fs_lock
= SPIN_LOCK_UNLOCKED
;
425 int simple_pin_fs(char *name
, struct vfsmount
**mount
, int *count
)
427 struct vfsmount
*mnt
= NULL
;
428 spin_lock(&pin_fs_lock
);
429 if (unlikely(!*mount
)) {
430 spin_unlock(&pin_fs_lock
);
431 mnt
= do_kern_mount(name
, 0, name
, NULL
);
434 spin_lock(&pin_fs_lock
);
440 spin_unlock(&pin_fs_lock
);
445 void simple_release_fs(struct vfsmount
**mount
, int *count
)
447 struct vfsmount
*mnt
;
448 spin_lock(&pin_fs_lock
);
452 spin_unlock(&pin_fs_lock
);
456 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
457 const void *from
, size_t available
)
462 if (pos
>= available
)
464 if (count
> available
- pos
)
465 count
= available
- pos
;
466 if (copy_to_user(to
, from
+ pos
, count
))
473 * Transaction based IO.
474 * The file expects a single write which triggers the transaction, and then
475 * possibly a read which collects the result - which is stored in a
478 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
480 struct simple_transaction_argresp
*ar
;
481 static spinlock_t simple_transaction_lock
= SPIN_LOCK_UNLOCKED
;
483 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
484 return ERR_PTR(-EFBIG
);
486 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
488 return ERR_PTR(-ENOMEM
);
490 spin_lock(&simple_transaction_lock
);
492 /* only one write allowed per open */
493 if (file
->private_data
) {
494 spin_unlock(&simple_transaction_lock
);
495 free_page((unsigned long)ar
);
496 return ERR_PTR(-EBUSY
);
499 file
->private_data
= ar
;
501 spin_unlock(&simple_transaction_lock
);
503 if (copy_from_user(ar
->data
, buf
, size
))
504 return ERR_PTR(-EFAULT
);
509 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
511 struct simple_transaction_argresp
*ar
= file
->private_data
;
515 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
518 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
520 free_page((unsigned long)file
->private_data
);
524 EXPORT_SYMBOL(dcache_dir_close
);
525 EXPORT_SYMBOL(dcache_dir_lseek
);
526 EXPORT_SYMBOL(dcache_dir_open
);
527 EXPORT_SYMBOL(dcache_readdir
);
528 EXPORT_SYMBOL(generic_read_dir
);
529 EXPORT_SYMBOL(simple_commit_write
);
530 EXPORT_SYMBOL(simple_dir_inode_operations
);
531 EXPORT_SYMBOL(simple_dir_operations
);
532 EXPORT_SYMBOL(simple_empty
);
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
);