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/module.h>
12 #include <linux/pagemap.h>
13 #include <linux/statfs.h>
14 #include <linux/slab.h>
15 #include <linux/seq_file.h>
16 #include <linux/mount.h>
17 #include <linux/namei.h>
22 struct hostfs_inode_info
{
25 struct inode vfs_inode
;
28 static inline struct hostfs_inode_info
*HOSTFS_I(struct inode
*inode
)
30 return list_entry(inode
, struct hostfs_inode_info
, vfs_inode
);
33 #define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode)
35 static int hostfs_d_delete(const struct dentry
*dentry
)
40 static const struct dentry_operations hostfs_dentry_ops
= {
41 .d_delete
= hostfs_d_delete
,
44 /* Changed in hostfs_args before the kernel starts running */
45 static char *root_ino
= "";
46 static int append
= 0;
48 #define HOSTFS_SUPER_MAGIC 0x00c0ffee
50 static const struct inode_operations hostfs_iops
;
51 static const struct inode_operations hostfs_dir_iops
;
52 static const struct inode_operations hostfs_link_iops
;
55 static int __init
hostfs_args(char *options
, int *add
)
59 ptr
= strchr(options
, ',');
67 ptr
= strchr(options
, ',');
70 if (*options
!= '\0') {
71 if (!strcmp(options
, "append"))
73 else printf("hostfs_args - unsupported option - %s\n",
81 __uml_setup("hostfs=", hostfs_args
,
82 "hostfs=<root dir>,<flags>,...\n"
83 " This is used to set hostfs parameters. The root directory argument\n"
84 " is used to confine all hostfs mounts to within the specified directory\n"
85 " tree on the host. If this isn't specified, then a user inside UML can\n"
86 " mount anything on the host that's accessible to the user that's running\n"
88 " The only flag currently supported is 'append', which specifies that all\n"
89 " files opened by hostfs will be opened in append mode.\n\n"
93 static char *__dentry_name(struct dentry
*dentry
, char *name
)
95 char *p
= dentry_path_raw(dentry
, name
, PATH_MAX
);
99 root
= dentry
->d_sb
->s_fs_info
;
105 strlcpy(name
, root
, PATH_MAX
);
106 if (len
> p
- name
) {
110 if (p
> name
+ len
) {
111 char *s
= name
+ len
;
112 while ((*s
++ = *p
++) != '\0')
118 static char *dentry_name(struct dentry
*dentry
)
120 char *name
= __getname();
124 return __dentry_name(dentry
, name
); /* will unlock */
127 static char *inode_name(struct inode
*ino
)
129 struct dentry
*dentry
;
132 dentry
= d_find_alias(ino
);
136 name
= dentry_name(dentry
);
143 static char *follow_link(char *link
)
146 char *name
, *resolved
, *end
;
151 name
= kmalloc(len
, GFP_KERNEL
);
155 n
= hostfs_do_readlink(link
, name
, len
);
167 end
= strrchr(link
, '/');
172 len
= strlen(link
) + strlen(name
) + 1;
174 resolved
= kmalloc(len
, GFP_KERNEL
);
175 if (resolved
== NULL
) {
180 sprintf(resolved
, "%s%s", link
, name
);
191 static struct inode
*hostfs_iget(struct super_block
*sb
)
193 struct inode
*inode
= new_inode(sb
);
195 return ERR_PTR(-ENOMEM
);
199 int hostfs_statfs(struct dentry
*dentry
, struct kstatfs
*sf
)
202 * do_statfs uses struct statfs64 internally, but the linux kernel
203 * struct statfs still has 32-bit versions for most of these fields,
204 * so we convert them here
213 err
= do_statfs(dentry
->d_sb
->s_fs_info
,
214 &sf
->f_bsize
, &f_blocks
, &f_bfree
, &f_bavail
, &f_files
,
215 &f_ffree
, &sf
->f_fsid
, sizeof(sf
->f_fsid
),
219 sf
->f_blocks
= f_blocks
;
220 sf
->f_bfree
= f_bfree
;
221 sf
->f_bavail
= f_bavail
;
222 sf
->f_files
= f_files
;
223 sf
->f_ffree
= f_ffree
;
224 sf
->f_type
= HOSTFS_SUPER_MAGIC
;
228 static struct inode
*hostfs_alloc_inode(struct super_block
*sb
)
230 struct hostfs_inode_info
*hi
;
232 hi
= kzalloc(sizeof(*hi
), GFP_KERNEL
);
236 inode_init_once(&hi
->vfs_inode
);
237 return &hi
->vfs_inode
;
240 static void hostfs_evict_inode(struct inode
*inode
)
242 truncate_inode_pages(&inode
->i_data
, 0);
243 end_writeback(inode
);
244 if (HOSTFS_I(inode
)->fd
!= -1) {
245 close_file(&HOSTFS_I(inode
)->fd
);
246 HOSTFS_I(inode
)->fd
= -1;
250 static void hostfs_destroy_inode(struct inode
*inode
)
252 kfree(HOSTFS_I(inode
));
255 static int hostfs_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
257 const char *root_path
= vfs
->mnt_sb
->s_fs_info
;
258 size_t offset
= strlen(root_ino
) + 1;
260 if (strlen(root_path
) > offset
)
261 seq_printf(seq
, ",%s", root_path
+ offset
);
266 static const struct super_operations hostfs_sbops
= {
267 .alloc_inode
= hostfs_alloc_inode
,
268 .destroy_inode
= hostfs_destroy_inode
,
269 .evict_inode
= hostfs_evict_inode
,
270 .statfs
= hostfs_statfs
,
271 .show_options
= hostfs_show_options
,
274 int hostfs_readdir(struct file
*file
, void *ent
, filldir_t filldir
)
278 unsigned long long next
, ino
;
281 name
= dentry_name(file
->f_path
.dentry
);
284 dir
= open_dir(name
, &error
);
289 while ((name
= read_dir(dir
, &next
, &ino
, &len
)) != NULL
) {
290 error
= (*filldir
)(ent
, name
, len
, file
->f_pos
,
299 int hostfs_file_open(struct inode
*ino
, struct file
*file
)
301 static DEFINE_MUTEX(open_mutex
);
305 int r
= 0, w
= 0, fd
;
307 mode
= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
308 if ((mode
& HOSTFS_I(ino
)->mode
) == mode
)
311 mode
|= HOSTFS_I(ino
)->mode
;
314 if (mode
& FMODE_READ
)
316 if (mode
& FMODE_WRITE
)
321 name
= dentry_name(file
->f_path
.dentry
);
325 fd
= open_file(name
, r
, w
, append
);
330 mutex_lock(&open_mutex
);
331 /* somebody else had handled it first? */
332 if ((mode
& HOSTFS_I(ino
)->mode
) == mode
) {
333 mutex_unlock(&open_mutex
);
336 if ((mode
| HOSTFS_I(ino
)->mode
) != mode
) {
337 mode
|= HOSTFS_I(ino
)->mode
;
338 mutex_unlock(&open_mutex
);
342 if (HOSTFS_I(ino
)->fd
== -1) {
343 HOSTFS_I(ino
)->fd
= fd
;
345 err
= replace_file(fd
, HOSTFS_I(ino
)->fd
);
348 mutex_unlock(&open_mutex
);
352 HOSTFS_I(ino
)->mode
= mode
;
353 mutex_unlock(&open_mutex
);
358 int hostfs_fsync(struct file
*file
, int datasync
)
360 return fsync_file(HOSTFS_I(file
->f_mapping
->host
)->fd
, datasync
);
363 static const struct file_operations hostfs_file_fops
= {
364 .llseek
= generic_file_llseek
,
365 .read
= do_sync_read
,
366 .splice_read
= generic_file_splice_read
,
367 .aio_read
= generic_file_aio_read
,
368 .aio_write
= generic_file_aio_write
,
369 .write
= do_sync_write
,
370 .mmap
= generic_file_mmap
,
371 .open
= hostfs_file_open
,
373 .fsync
= hostfs_fsync
,
376 static const struct file_operations hostfs_dir_fops
= {
377 .llseek
= generic_file_llseek
,
378 .readdir
= hostfs_readdir
,
379 .read
= generic_read_dir
,
382 int hostfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
384 struct address_space
*mapping
= page
->mapping
;
385 struct inode
*inode
= mapping
->host
;
387 unsigned long long base
;
388 int count
= PAGE_CACHE_SIZE
;
389 int end_index
= inode
->i_size
>> PAGE_CACHE_SHIFT
;
392 if (page
->index
>= end_index
)
393 count
= inode
->i_size
& (PAGE_CACHE_SIZE
-1);
396 base
= ((unsigned long long) page
->index
) << PAGE_CACHE_SHIFT
;
398 err
= write_file(HOSTFS_I(inode
)->fd
, &base
, buffer
, count
);
400 ClearPageUptodate(page
);
404 if (base
> inode
->i_size
)
405 inode
->i_size
= base
;
408 ClearPageError(page
);
418 int hostfs_readpage(struct file
*file
, struct page
*page
)
424 start
= (long long) page
->index
<< PAGE_CACHE_SHIFT
;
426 err
= read_file(FILE_HOSTFS_I(file
)->fd
, &start
, buffer
,
431 memset(&buffer
[err
], 0, PAGE_CACHE_SIZE
- err
);
433 flush_dcache_page(page
);
434 SetPageUptodate(page
);
435 if (PageError(page
)) ClearPageError(page
);
443 int hostfs_write_begin(struct file
*file
, struct address_space
*mapping
,
444 loff_t pos
, unsigned len
, unsigned flags
,
445 struct page
**pagep
, void **fsdata
)
447 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
449 *pagep
= grab_cache_page_write_begin(mapping
, index
, flags
);
455 int hostfs_write_end(struct file
*file
, struct address_space
*mapping
,
456 loff_t pos
, unsigned len
, unsigned copied
,
457 struct page
*page
, void *fsdata
)
459 struct inode
*inode
= mapping
->host
;
461 unsigned from
= pos
& (PAGE_CACHE_SIZE
- 1);
465 err
= write_file(FILE_HOSTFS_I(file
)->fd
, &pos
, buffer
+ from
, copied
);
468 if (!PageUptodate(page
) && err
== PAGE_CACHE_SIZE
)
469 SetPageUptodate(page
);
472 * If err > 0, write_file has added err to pos, so we are comparing
473 * i_size against the last byte written.
475 if (err
> 0 && (pos
> inode
->i_size
))
478 page_cache_release(page
);
483 static const struct address_space_operations hostfs_aops
= {
484 .writepage
= hostfs_writepage
,
485 .readpage
= hostfs_readpage
,
486 .set_page_dirty
= __set_page_dirty_nobuffers
,
487 .write_begin
= hostfs_write_begin
,
488 .write_end
= hostfs_write_end
,
491 static int read_name(struct inode
*ino
, char *name
)
494 struct hostfs_stat st
;
495 int err
= stat_file(name
, &st
, -1);
499 /* Reencode maj and min with the kernel encoding.*/
500 rdev
= MKDEV(st
.maj
, st
.min
);
502 switch (st
.mode
& S_IFMT
) {
504 ino
->i_op
= &hostfs_link_iops
;
507 ino
->i_op
= &hostfs_dir_iops
;
508 ino
->i_fop
= &hostfs_dir_fops
;
514 init_special_inode(ino
, st
.mode
& S_IFMT
, rdev
);
515 ino
->i_op
= &hostfs_iops
;
519 ino
->i_op
= &hostfs_iops
;
520 ino
->i_fop
= &hostfs_file_fops
;
521 ino
->i_mapping
->a_ops
= &hostfs_aops
;
525 ino
->i_mode
= st
.mode
;
526 ino
->i_nlink
= st
.nlink
;
529 ino
->i_atime
= st
.atime
;
530 ino
->i_mtime
= st
.mtime
;
531 ino
->i_ctime
= st
.ctime
;
532 ino
->i_size
= st
.size
;
533 ino
->i_blocks
= st
.blocks
;
537 int hostfs_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
538 struct nameidata
*nd
)
544 inode
= hostfs_iget(dir
->i_sb
);
546 error
= PTR_ERR(inode
);
551 name
= dentry_name(dentry
);
555 fd
= file_create(name
,
556 mode
& S_IRUSR
, mode
& S_IWUSR
, mode
& S_IXUSR
,
557 mode
& S_IRGRP
, mode
& S_IWGRP
, mode
& S_IXGRP
,
558 mode
& S_IROTH
, mode
& S_IWOTH
, mode
& S_IXOTH
);
562 error
= read_name(inode
, name
);
568 HOSTFS_I(inode
)->fd
= fd
;
569 HOSTFS_I(inode
)->mode
= FMODE_READ
| FMODE_WRITE
;
570 d_instantiate(dentry
, inode
);
579 struct dentry
*hostfs_lookup(struct inode
*ino
, struct dentry
*dentry
,
580 struct nameidata
*nd
)
586 inode
= hostfs_iget(ino
->i_sb
);
588 err
= PTR_ERR(inode
);
593 name
= dentry_name(dentry
);
597 err
= read_name(inode
, name
);
600 if (err
== -ENOENT
) {
607 d_add(dentry
, inode
);
608 dentry
->d_op
= &hostfs_dentry_ops
;
617 int hostfs_link(struct dentry
*to
, struct inode
*ino
, struct dentry
*from
)
619 char *from_name
, *to_name
;
622 if ((from_name
= dentry_name(from
)) == NULL
)
624 to_name
= dentry_name(to
);
625 if (to_name
== NULL
) {
626 __putname(from_name
);
629 err
= link_file(to_name
, from_name
);
630 __putname(from_name
);
635 int hostfs_unlink(struct inode
*ino
, struct dentry
*dentry
)
643 if ((file
= dentry_name(dentry
)) == NULL
)
646 err
= unlink_file(file
);
651 int hostfs_symlink(struct inode
*ino
, struct dentry
*dentry
, const char *to
)
656 if ((file
= dentry_name(dentry
)) == NULL
)
658 err
= make_symlink(file
, to
);
663 int hostfs_mkdir(struct inode
*ino
, struct dentry
*dentry
, int mode
)
668 if ((file
= dentry_name(dentry
)) == NULL
)
670 err
= do_mkdir(file
, mode
);
675 int hostfs_rmdir(struct inode
*ino
, struct dentry
*dentry
)
680 if ((file
= dentry_name(dentry
)) == NULL
)
682 err
= do_rmdir(file
);
687 int hostfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t dev
)
693 inode
= hostfs_iget(dir
->i_sb
);
695 err
= PTR_ERR(inode
);
700 name
= dentry_name(dentry
);
704 init_special_inode(inode
, mode
, dev
);
705 err
= do_mknod(name
, mode
, MAJOR(dev
), MINOR(dev
));
709 err
= read_name(inode
, name
);
716 d_instantiate(dentry
, inode
);
727 int hostfs_rename(struct inode
*from_ino
, struct dentry
*from
,
728 struct inode
*to_ino
, struct dentry
*to
)
730 char *from_name
, *to_name
;
733 if ((from_name
= dentry_name(from
)) == NULL
)
735 if ((to_name
= dentry_name(to
)) == NULL
) {
736 __putname(from_name
);
739 err
= rename_file(from_name
, to_name
);
740 __putname(from_name
);
745 int hostfs_permission(struct inode
*ino
, int desired
)
748 int r
= 0, w
= 0, x
= 0, err
;
750 if (desired
& MAY_READ
) r
= 1;
751 if (desired
& MAY_WRITE
) w
= 1;
752 if (desired
& MAY_EXEC
) x
= 1;
753 name
= inode_name(ino
);
757 if (S_ISCHR(ino
->i_mode
) || S_ISBLK(ino
->i_mode
) ||
758 S_ISFIFO(ino
->i_mode
) || S_ISSOCK(ino
->i_mode
))
761 err
= access_file(name
, r
, w
, x
);
764 err
= generic_permission(ino
, desired
, NULL
);
768 int hostfs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
770 struct inode
*inode
= dentry
->d_inode
;
771 struct hostfs_iattr attrs
;
775 int fd
= HOSTFS_I(inode
)->fd
;
777 err
= inode_change_ok(inode
, attr
);
782 attr
->ia_valid
&= ~ATTR_SIZE
;
785 if (attr
->ia_valid
& ATTR_MODE
) {
786 attrs
.ia_valid
|= HOSTFS_ATTR_MODE
;
787 attrs
.ia_mode
= attr
->ia_mode
;
789 if (attr
->ia_valid
& ATTR_UID
) {
790 attrs
.ia_valid
|= HOSTFS_ATTR_UID
;
791 attrs
.ia_uid
= attr
->ia_uid
;
793 if (attr
->ia_valid
& ATTR_GID
) {
794 attrs
.ia_valid
|= HOSTFS_ATTR_GID
;
795 attrs
.ia_gid
= attr
->ia_gid
;
797 if (attr
->ia_valid
& ATTR_SIZE
) {
798 attrs
.ia_valid
|= HOSTFS_ATTR_SIZE
;
799 attrs
.ia_size
= attr
->ia_size
;
801 if (attr
->ia_valid
& ATTR_ATIME
) {
802 attrs
.ia_valid
|= HOSTFS_ATTR_ATIME
;
803 attrs
.ia_atime
= attr
->ia_atime
;
805 if (attr
->ia_valid
& ATTR_MTIME
) {
806 attrs
.ia_valid
|= HOSTFS_ATTR_MTIME
;
807 attrs
.ia_mtime
= attr
->ia_mtime
;
809 if (attr
->ia_valid
& ATTR_CTIME
) {
810 attrs
.ia_valid
|= HOSTFS_ATTR_CTIME
;
811 attrs
.ia_ctime
= attr
->ia_ctime
;
813 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
814 attrs
.ia_valid
|= HOSTFS_ATTR_ATIME_SET
;
816 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
817 attrs
.ia_valid
|= HOSTFS_ATTR_MTIME_SET
;
819 name
= dentry_name(dentry
);
822 err
= set_attr(name
, &attrs
, fd
);
827 if ((attr
->ia_valid
& ATTR_SIZE
) &&
828 attr
->ia_size
!= i_size_read(inode
)) {
831 error
= vmtruncate(inode
, attr
->ia_size
);
836 setattr_copy(inode
, attr
);
837 mark_inode_dirty(inode
);
841 static const struct inode_operations hostfs_iops
= {
842 .create
= hostfs_create
,
844 .unlink
= hostfs_unlink
,
845 .symlink
= hostfs_symlink
,
846 .mkdir
= hostfs_mkdir
,
847 .rmdir
= hostfs_rmdir
,
848 .mknod
= hostfs_mknod
,
849 .rename
= hostfs_rename
,
850 .permission
= hostfs_permission
,
851 .setattr
= hostfs_setattr
,
854 static const struct inode_operations hostfs_dir_iops
= {
855 .create
= hostfs_create
,
856 .lookup
= hostfs_lookup
,
858 .unlink
= hostfs_unlink
,
859 .symlink
= hostfs_symlink
,
860 .mkdir
= hostfs_mkdir
,
861 .rmdir
= hostfs_rmdir
,
862 .mknod
= hostfs_mknod
,
863 .rename
= hostfs_rename
,
864 .permission
= hostfs_permission
,
865 .setattr
= hostfs_setattr
,
868 static void *hostfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
870 char *link
= __getname();
872 char *path
= dentry_name(dentry
);
875 err
= hostfs_do_readlink(path
, link
, PATH_MAX
);
885 link
= ERR_PTR(-ENOMEM
);
888 nd_set_link(nd
, link
);
892 static void hostfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *cookie
)
894 char *s
= nd_get_link(nd
);
899 static const struct inode_operations hostfs_link_iops
= {
900 .readlink
= generic_readlink
,
901 .follow_link
= hostfs_follow_link
,
902 .put_link
= hostfs_put_link
,
905 static int hostfs_fill_sb_common(struct super_block
*sb
, void *d
, int silent
)
907 struct inode
*root_inode
;
908 char *host_root_path
, *req_root
= d
;
911 sb
->s_blocksize
= 1024;
912 sb
->s_blocksize_bits
= 10;
913 sb
->s_magic
= HOSTFS_SUPER_MAGIC
;
914 sb
->s_op
= &hostfs_sbops
;
915 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
917 /* NULL is printed as <NULL> by sprintf: avoid that. */
918 if (req_root
== NULL
)
922 sb
->s_fs_info
= host_root_path
=
923 kmalloc(strlen(root_ino
) + strlen(req_root
) + 2, GFP_KERNEL
);
924 if (host_root_path
== NULL
)
927 sprintf(host_root_path
, "%s/%s", root_ino
, req_root
);
929 root_inode
= new_inode(sb
);
933 err
= read_name(root_inode
, host_root_path
);
937 if (S_ISLNK(root_inode
->i_mode
)) {
938 char *name
= follow_link(host_root_path
);
942 err
= read_name(root_inode
, name
);
949 sb
->s_root
= d_alloc_root(root_inode
);
950 if (sb
->s_root
== NULL
)
961 static struct dentry
*hostfs_read_sb(struct file_system_type
*type
,
962 int flags
, const char *dev_name
,
965 return mount_nodev(type
, flags
, data
, hostfs_fill_sb_common
);
968 static void hostfs_kill_sb(struct super_block
*s
)
974 static struct file_system_type hostfs_type
= {
975 .owner
= THIS_MODULE
,
977 .mount
= hostfs_read_sb
,
978 .kill_sb
= hostfs_kill_sb
,
982 static int __init
init_hostfs(void)
984 return register_filesystem(&hostfs_type
);
987 static void __exit
exit_hostfs(void)
989 unregister_filesystem(&hostfs_type
);
992 module_init(init_hostfs
)
993 module_exit(exit_hostfs
)
994 MODULE_LICENSE("GPL");