2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
5 * Ported the filesystem routines to 2.5.
6 * 2003-02-10 Petr Baudis <pasky@ucw.cz>
10 #include <linux/magic.h>
11 #include <linux/module.h>
13 #include <linux/pagemap.h>
14 #include <linux/statfs.h>
15 #include <linux/slab.h>
16 #include <linux/seq_file.h>
17 #include <linux/mount.h>
18 #include <linux/namei.h>
23 struct hostfs_inode_info
{
26 struct inode vfs_inode
;
29 static inline struct hostfs_inode_info
*HOSTFS_I(struct inode
*inode
)
31 return list_entry(inode
, struct hostfs_inode_info
, vfs_inode
);
34 #define FILE_HOSTFS_I(file) HOSTFS_I(file_inode(file))
36 /* Changed in hostfs_args before the kernel starts running */
37 static char *root_ino
= "";
38 static int append
= 0;
40 static const struct inode_operations hostfs_iops
;
41 static const struct inode_operations hostfs_dir_iops
;
42 static const struct inode_operations hostfs_link_iops
;
45 static int __init
hostfs_args(char *options
, int *add
)
49 ptr
= strchr(options
, ',');
57 ptr
= strchr(options
, ',');
60 if (*options
!= '\0') {
61 if (!strcmp(options
, "append"))
63 else printf("hostfs_args - unsupported option - %s\n",
71 __uml_setup("hostfs=", hostfs_args
,
72 "hostfs=<root dir>,<flags>,...\n"
73 " This is used to set hostfs parameters. The root directory argument\n"
74 " is used to confine all hostfs mounts to within the specified directory\n"
75 " tree on the host. If this isn't specified, then a user inside UML can\n"
76 " mount anything on the host that's accessible to the user that's running\n"
78 " The only flag currently supported is 'append', which specifies that all\n"
79 " files opened by hostfs will be opened in append mode.\n\n"
83 static char *__dentry_name(struct dentry
*dentry
, char *name
)
85 char *p
= dentry_path_raw(dentry
, name
, PATH_MAX
);
89 root
= dentry
->d_sb
->s_fs_info
;
95 strlcpy(name
, root
, PATH_MAX
);
100 if (p
> name
+ len
) {
101 char *s
= name
+ len
;
102 while ((*s
++ = *p
++) != '\0')
108 static char *dentry_name(struct dentry
*dentry
)
110 char *name
= __getname();
114 return __dentry_name(dentry
, name
);
117 static char *inode_name(struct inode
*ino
)
119 struct dentry
*dentry
;
122 dentry
= d_find_alias(ino
);
126 name
= dentry_name(dentry
);
133 static char *follow_link(char *link
)
136 char *name
, *resolved
, *end
;
141 name
= kmalloc(len
, GFP_KERNEL
);
145 n
= hostfs_do_readlink(link
, name
, len
);
157 end
= strrchr(link
, '/');
162 len
= strlen(link
) + strlen(name
) + 1;
164 resolved
= kmalloc(len
, GFP_KERNEL
);
165 if (resolved
== NULL
) {
170 sprintf(resolved
, "%s%s", link
, name
);
181 static struct inode
*hostfs_iget(struct super_block
*sb
)
183 struct inode
*inode
= new_inode(sb
);
185 return ERR_PTR(-ENOMEM
);
189 int hostfs_statfs(struct dentry
*dentry
, struct kstatfs
*sf
)
192 * do_statfs uses struct statfs64 internally, but the linux kernel
193 * struct statfs still has 32-bit versions for most of these fields,
194 * so we convert them here
203 err
= do_statfs(dentry
->d_sb
->s_fs_info
,
204 &sf
->f_bsize
, &f_blocks
, &f_bfree
, &f_bavail
, &f_files
,
205 &f_ffree
, &sf
->f_fsid
, sizeof(sf
->f_fsid
),
209 sf
->f_blocks
= f_blocks
;
210 sf
->f_bfree
= f_bfree
;
211 sf
->f_bavail
= f_bavail
;
212 sf
->f_files
= f_files
;
213 sf
->f_ffree
= f_ffree
;
214 sf
->f_type
= HOSTFS_SUPER_MAGIC
;
218 static struct inode
*hostfs_alloc_inode(struct super_block
*sb
)
220 struct hostfs_inode_info
*hi
;
222 hi
= kmalloc(sizeof(*hi
), GFP_KERNEL
);
227 inode_init_once(&hi
->vfs_inode
);
228 return &hi
->vfs_inode
;
231 static void hostfs_evict_inode(struct inode
*inode
)
233 truncate_inode_pages(&inode
->i_data
, 0);
235 if (HOSTFS_I(inode
)->fd
!= -1) {
236 close_file(&HOSTFS_I(inode
)->fd
);
237 HOSTFS_I(inode
)->fd
= -1;
241 static void hostfs_i_callback(struct rcu_head
*head
)
243 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
244 kfree(HOSTFS_I(inode
));
247 static void hostfs_destroy_inode(struct inode
*inode
)
249 call_rcu(&inode
->i_rcu
, hostfs_i_callback
);
252 static int hostfs_show_options(struct seq_file
*seq
, struct dentry
*root
)
254 const char *root_path
= root
->d_sb
->s_fs_info
;
255 size_t offset
= strlen(root_ino
) + 1;
257 if (strlen(root_path
) > offset
)
258 seq_printf(seq
, ",%s", root_path
+ offset
);
263 static const struct super_operations hostfs_sbops
= {
264 .alloc_inode
= hostfs_alloc_inode
,
265 .destroy_inode
= hostfs_destroy_inode
,
266 .evict_inode
= hostfs_evict_inode
,
267 .statfs
= hostfs_statfs
,
268 .show_options
= hostfs_show_options
,
271 int hostfs_readdir(struct file
*file
, struct dir_context
*ctx
)
275 unsigned long long next
, ino
;
279 name
= dentry_name(file
->f_path
.dentry
);
282 dir
= open_dir(name
, &error
);
287 while ((name
= read_dir(dir
, &next
, &ino
, &len
, &type
)) != NULL
) {
288 if (!dir_emit(ctx
, name
, len
, ino
, type
))
296 int hostfs_file_open(struct inode
*ino
, struct file
*file
)
298 static DEFINE_MUTEX(open_mutex
);
302 int r
= 0, w
= 0, fd
;
304 mode
= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
305 if ((mode
& HOSTFS_I(ino
)->mode
) == mode
)
308 mode
|= HOSTFS_I(ino
)->mode
;
311 if (mode
& FMODE_READ
)
313 if (mode
& FMODE_WRITE
)
318 name
= dentry_name(file
->f_path
.dentry
);
322 fd
= open_file(name
, r
, w
, append
);
327 mutex_lock(&open_mutex
);
328 /* somebody else had handled it first? */
329 if ((mode
& HOSTFS_I(ino
)->mode
) == mode
) {
330 mutex_unlock(&open_mutex
);
333 if ((mode
| HOSTFS_I(ino
)->mode
) != mode
) {
334 mode
|= HOSTFS_I(ino
)->mode
;
335 mutex_unlock(&open_mutex
);
339 if (HOSTFS_I(ino
)->fd
== -1) {
340 HOSTFS_I(ino
)->fd
= fd
;
342 err
= replace_file(fd
, HOSTFS_I(ino
)->fd
);
345 mutex_unlock(&open_mutex
);
349 HOSTFS_I(ino
)->mode
= mode
;
350 mutex_unlock(&open_mutex
);
355 static int hostfs_file_release(struct inode
*inode
, struct file
*file
)
357 filemap_write_and_wait(inode
->i_mapping
);
362 int hostfs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
364 struct inode
*inode
= file
->f_mapping
->host
;
367 ret
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
371 mutex_lock(&inode
->i_mutex
);
372 ret
= fsync_file(HOSTFS_I(inode
)->fd
, datasync
);
373 mutex_unlock(&inode
->i_mutex
);
378 static const struct file_operations hostfs_file_fops
= {
379 .llseek
= generic_file_llseek
,
380 .read
= do_sync_read
,
381 .splice_read
= generic_file_splice_read
,
382 .aio_read
= generic_file_aio_read
,
383 .aio_write
= generic_file_aio_write
,
384 .write
= do_sync_write
,
385 .mmap
= generic_file_mmap
,
386 .open
= hostfs_file_open
,
387 .release
= hostfs_file_release
,
388 .fsync
= hostfs_fsync
,
391 static const struct file_operations hostfs_dir_fops
= {
392 .llseek
= generic_file_llseek
,
393 .iterate
= hostfs_readdir
,
394 .read
= generic_read_dir
,
397 int hostfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
399 struct address_space
*mapping
= page
->mapping
;
400 struct inode
*inode
= mapping
->host
;
402 unsigned long long base
;
403 int count
= PAGE_CACHE_SIZE
;
404 int end_index
= inode
->i_size
>> PAGE_CACHE_SHIFT
;
407 if (page
->index
>= end_index
)
408 count
= inode
->i_size
& (PAGE_CACHE_SIZE
-1);
411 base
= ((unsigned long long) page
->index
) << PAGE_CACHE_SHIFT
;
413 err
= write_file(HOSTFS_I(inode
)->fd
, &base
, buffer
, count
);
415 ClearPageUptodate(page
);
419 if (base
> inode
->i_size
)
420 inode
->i_size
= base
;
423 ClearPageError(page
);
433 int hostfs_readpage(struct file
*file
, struct page
*page
)
439 start
= (long long) page
->index
<< PAGE_CACHE_SHIFT
;
441 err
= read_file(FILE_HOSTFS_I(file
)->fd
, &start
, buffer
,
446 memset(&buffer
[err
], 0, PAGE_CACHE_SIZE
- err
);
448 flush_dcache_page(page
);
449 SetPageUptodate(page
);
450 if (PageError(page
)) ClearPageError(page
);
458 int hostfs_write_begin(struct file
*file
, struct address_space
*mapping
,
459 loff_t pos
, unsigned len
, unsigned flags
,
460 struct page
**pagep
, void **fsdata
)
462 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
464 *pagep
= grab_cache_page_write_begin(mapping
, index
, flags
);
470 int hostfs_write_end(struct file
*file
, struct address_space
*mapping
,
471 loff_t pos
, unsigned len
, unsigned copied
,
472 struct page
*page
, void *fsdata
)
474 struct inode
*inode
= mapping
->host
;
476 unsigned from
= pos
& (PAGE_CACHE_SIZE
- 1);
480 err
= write_file(FILE_HOSTFS_I(file
)->fd
, &pos
, buffer
+ from
, copied
);
483 if (!PageUptodate(page
) && err
== PAGE_CACHE_SIZE
)
484 SetPageUptodate(page
);
487 * If err > 0, write_file has added err to pos, so we are comparing
488 * i_size against the last byte written.
490 if (err
> 0 && (pos
> inode
->i_size
))
493 page_cache_release(page
);
498 static const struct address_space_operations hostfs_aops
= {
499 .writepage
= hostfs_writepage
,
500 .readpage
= hostfs_readpage
,
501 .set_page_dirty
= __set_page_dirty_nobuffers
,
502 .write_begin
= hostfs_write_begin
,
503 .write_end
= hostfs_write_end
,
506 static int read_name(struct inode
*ino
, char *name
)
509 struct hostfs_stat st
;
510 int err
= stat_file(name
, &st
, -1);
514 /* Reencode maj and min with the kernel encoding.*/
515 rdev
= MKDEV(st
.maj
, st
.min
);
517 switch (st
.mode
& S_IFMT
) {
519 ino
->i_op
= &hostfs_link_iops
;
522 ino
->i_op
= &hostfs_dir_iops
;
523 ino
->i_fop
= &hostfs_dir_fops
;
529 init_special_inode(ino
, st
.mode
& S_IFMT
, rdev
);
530 ino
->i_op
= &hostfs_iops
;
534 ino
->i_op
= &hostfs_iops
;
535 ino
->i_fop
= &hostfs_file_fops
;
536 ino
->i_mapping
->a_ops
= &hostfs_aops
;
540 ino
->i_mode
= st
.mode
;
541 set_nlink(ino
, st
.nlink
);
542 i_uid_write(ino
, st
.uid
);
543 i_gid_write(ino
, st
.gid
);
544 ino
->i_atime
= st
.atime
;
545 ino
->i_mtime
= st
.mtime
;
546 ino
->i_ctime
= st
.ctime
;
547 ino
->i_size
= st
.size
;
548 ino
->i_blocks
= st
.blocks
;
552 int hostfs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
559 inode
= hostfs_iget(dir
->i_sb
);
561 error
= PTR_ERR(inode
);
566 name
= dentry_name(dentry
);
570 fd
= file_create(name
,
571 mode
& S_IRUSR
, mode
& S_IWUSR
, mode
& S_IXUSR
,
572 mode
& S_IRGRP
, mode
& S_IWGRP
, mode
& S_IXGRP
,
573 mode
& S_IROTH
, mode
& S_IWOTH
, mode
& S_IXOTH
);
577 error
= read_name(inode
, name
);
583 HOSTFS_I(inode
)->fd
= fd
;
584 HOSTFS_I(inode
)->mode
= FMODE_READ
| FMODE_WRITE
;
585 d_instantiate(dentry
, inode
);
594 struct dentry
*hostfs_lookup(struct inode
*ino
, struct dentry
*dentry
,
601 inode
= hostfs_iget(ino
->i_sb
);
603 err
= PTR_ERR(inode
);
608 name
= dentry_name(dentry
);
612 err
= read_name(inode
, name
);
615 if (err
== -ENOENT
) {
622 d_add(dentry
, inode
);
631 int hostfs_link(struct dentry
*to
, struct inode
*ino
, struct dentry
*from
)
633 char *from_name
, *to_name
;
636 if ((from_name
= dentry_name(from
)) == NULL
)
638 to_name
= dentry_name(to
);
639 if (to_name
== NULL
) {
640 __putname(from_name
);
643 err
= link_file(to_name
, from_name
);
644 __putname(from_name
);
649 int hostfs_unlink(struct inode
*ino
, struct dentry
*dentry
)
657 if ((file
= dentry_name(dentry
)) == NULL
)
660 err
= unlink_file(file
);
665 int hostfs_symlink(struct inode
*ino
, struct dentry
*dentry
, const char *to
)
670 if ((file
= dentry_name(dentry
)) == NULL
)
672 err
= make_symlink(file
, to
);
677 int hostfs_mkdir(struct inode
*ino
, struct dentry
*dentry
, umode_t mode
)
682 if ((file
= dentry_name(dentry
)) == NULL
)
684 err
= do_mkdir(file
, mode
);
689 int hostfs_rmdir(struct inode
*ino
, struct dentry
*dentry
)
694 if ((file
= dentry_name(dentry
)) == NULL
)
696 err
= do_rmdir(file
);
701 static int hostfs_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
, dev_t dev
)
707 inode
= hostfs_iget(dir
->i_sb
);
709 err
= PTR_ERR(inode
);
714 name
= dentry_name(dentry
);
718 init_special_inode(inode
, mode
, dev
);
719 err
= do_mknod(name
, mode
, MAJOR(dev
), MINOR(dev
));
723 err
= read_name(inode
, name
);
730 d_instantiate(dentry
, inode
);
741 int hostfs_rename(struct inode
*from_ino
, struct dentry
*from
,
742 struct inode
*to_ino
, struct dentry
*to
)
744 char *from_name
, *to_name
;
747 if ((from_name
= dentry_name(from
)) == NULL
)
749 if ((to_name
= dentry_name(to
)) == NULL
) {
750 __putname(from_name
);
753 err
= rename_file(from_name
, to_name
);
754 __putname(from_name
);
759 int hostfs_permission(struct inode
*ino
, int desired
)
762 int r
= 0, w
= 0, x
= 0, err
;
764 if (desired
& MAY_NOT_BLOCK
)
767 if (desired
& MAY_READ
) r
= 1;
768 if (desired
& MAY_WRITE
) w
= 1;
769 if (desired
& MAY_EXEC
) x
= 1;
770 name
= inode_name(ino
);
774 if (S_ISCHR(ino
->i_mode
) || S_ISBLK(ino
->i_mode
) ||
775 S_ISFIFO(ino
->i_mode
) || S_ISSOCK(ino
->i_mode
))
778 err
= access_file(name
, r
, w
, x
);
781 err
= generic_permission(ino
, desired
);
785 int hostfs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
787 struct inode
*inode
= dentry
->d_inode
;
788 struct hostfs_iattr attrs
;
792 int fd
= HOSTFS_I(inode
)->fd
;
794 err
= inode_change_ok(inode
, attr
);
799 attr
->ia_valid
&= ~ATTR_SIZE
;
802 if (attr
->ia_valid
& ATTR_MODE
) {
803 attrs
.ia_valid
|= HOSTFS_ATTR_MODE
;
804 attrs
.ia_mode
= attr
->ia_mode
;
806 if (attr
->ia_valid
& ATTR_UID
) {
807 attrs
.ia_valid
|= HOSTFS_ATTR_UID
;
808 attrs
.ia_uid
= from_kuid(&init_user_ns
, attr
->ia_uid
);
810 if (attr
->ia_valid
& ATTR_GID
) {
811 attrs
.ia_valid
|= HOSTFS_ATTR_GID
;
812 attrs
.ia_gid
= from_kgid(&init_user_ns
, attr
->ia_gid
);
814 if (attr
->ia_valid
& ATTR_SIZE
) {
815 attrs
.ia_valid
|= HOSTFS_ATTR_SIZE
;
816 attrs
.ia_size
= attr
->ia_size
;
818 if (attr
->ia_valid
& ATTR_ATIME
) {
819 attrs
.ia_valid
|= HOSTFS_ATTR_ATIME
;
820 attrs
.ia_atime
= attr
->ia_atime
;
822 if (attr
->ia_valid
& ATTR_MTIME
) {
823 attrs
.ia_valid
|= HOSTFS_ATTR_MTIME
;
824 attrs
.ia_mtime
= attr
->ia_mtime
;
826 if (attr
->ia_valid
& ATTR_CTIME
) {
827 attrs
.ia_valid
|= HOSTFS_ATTR_CTIME
;
828 attrs
.ia_ctime
= attr
->ia_ctime
;
830 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
831 attrs
.ia_valid
|= HOSTFS_ATTR_ATIME_SET
;
833 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
834 attrs
.ia_valid
|= HOSTFS_ATTR_MTIME_SET
;
836 name
= dentry_name(dentry
);
839 err
= set_attr(name
, &attrs
, fd
);
844 if ((attr
->ia_valid
& ATTR_SIZE
) &&
845 attr
->ia_size
!= i_size_read(inode
))
846 truncate_setsize(inode
, attr
->ia_size
);
848 setattr_copy(inode
, attr
);
849 mark_inode_dirty(inode
);
853 static const struct inode_operations hostfs_iops
= {
854 .permission
= hostfs_permission
,
855 .setattr
= hostfs_setattr
,
858 static const struct inode_operations hostfs_dir_iops
= {
859 .create
= hostfs_create
,
860 .lookup
= hostfs_lookup
,
862 .unlink
= hostfs_unlink
,
863 .symlink
= hostfs_symlink
,
864 .mkdir
= hostfs_mkdir
,
865 .rmdir
= hostfs_rmdir
,
866 .mknod
= hostfs_mknod
,
867 .rename
= hostfs_rename
,
868 .permission
= hostfs_permission
,
869 .setattr
= hostfs_setattr
,
872 static void *hostfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
874 char *link
= __getname();
876 char *path
= dentry_name(dentry
);
879 err
= hostfs_do_readlink(path
, link
, PATH_MAX
);
889 link
= ERR_PTR(-ENOMEM
);
892 nd_set_link(nd
, link
);
896 static void hostfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *cookie
)
898 char *s
= nd_get_link(nd
);
903 static const struct inode_operations hostfs_link_iops
= {
904 .readlink
= generic_readlink
,
905 .follow_link
= hostfs_follow_link
,
906 .put_link
= hostfs_put_link
,
909 static int hostfs_fill_sb_common(struct super_block
*sb
, void *d
, int silent
)
911 struct inode
*root_inode
;
912 char *host_root_path
, *req_root
= d
;
915 sb
->s_blocksize
= 1024;
916 sb
->s_blocksize_bits
= 10;
917 sb
->s_magic
= HOSTFS_SUPER_MAGIC
;
918 sb
->s_op
= &hostfs_sbops
;
919 sb
->s_d_op
= &simple_dentry_operations
;
920 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
922 /* NULL is printed as <NULL> by sprintf: avoid that. */
923 if (req_root
== NULL
)
927 sb
->s_fs_info
= host_root_path
=
928 kmalloc(strlen(root_ino
) + strlen(req_root
) + 2, GFP_KERNEL
);
929 if (host_root_path
== NULL
)
932 sprintf(host_root_path
, "%s/%s", root_ino
, req_root
);
934 root_inode
= new_inode(sb
);
938 err
= read_name(root_inode
, host_root_path
);
942 if (S_ISLNK(root_inode
->i_mode
)) {
943 char *name
= follow_link(host_root_path
);
947 err
= read_name(root_inode
, name
);
954 sb
->s_root
= d_make_root(root_inode
);
955 if (sb
->s_root
== NULL
)
966 static struct dentry
*hostfs_read_sb(struct file_system_type
*type
,
967 int flags
, const char *dev_name
,
970 return mount_nodev(type
, flags
, data
, hostfs_fill_sb_common
);
973 static void hostfs_kill_sb(struct super_block
*s
)
979 static struct file_system_type hostfs_type
= {
980 .owner
= THIS_MODULE
,
982 .mount
= hostfs_read_sb
,
983 .kill_sb
= hostfs_kill_sb
,
986 MODULE_ALIAS_FS("hostfs");
988 static int __init
init_hostfs(void)
990 return register_filesystem(&hostfs_type
);
993 static void __exit
exit_hostfs(void)
995 unregister_filesystem(&hostfs_type
);
998 module_init(init_hostfs
)
999 module_exit(exit_hostfs
)
1000 MODULE_LICENSE("GPL");