1
2
3
4
5
6
7
8
9#include <linux/fs.h>
10#include <linux/magic.h>
11#include <linux/module.h>
12#include <linux/mm.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>
19#include "hostfs.h"
20#include <init.h>
21#include <kern.h>
22
23struct hostfs_inode_info {
24 int fd;
25 fmode_t mode;
26 struct inode vfs_inode;
27};
28
29static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
30{
31 return list_entry(inode, struct hostfs_inode_info, vfs_inode);
32}
33
34#define FILE_HOSTFS_I(file) HOSTFS_I(file_inode(file))
35
36
37static char *root_ino = "";
38static int append = 0;
39
40static const struct inode_operations hostfs_iops;
41static const struct inode_operations hostfs_dir_iops;
42static const struct inode_operations hostfs_link_iops;
43
44#ifndef MODULE
45static int __init hostfs_args(char *options, int *add)
46{
47 char *ptr;
48
49 ptr = strchr(options, ',');
50 if (ptr != NULL)
51 *ptr++ = '\0';
52 if (*options != '\0')
53 root_ino = options;
54
55 options = ptr;
56 while (options) {
57 ptr = strchr(options, ',');
58 if (ptr != NULL)
59 *ptr++ = '\0';
60 if (*options != '\0') {
61 if (!strcmp(options, "append"))
62 append = 1;
63 else printf("hostfs_args - unsupported option - %s\n",
64 options);
65 }
66 options = ptr;
67 }
68 return 0;
69}
70
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"
77" it.\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"
80);
81#endif
82
83static char *__dentry_name(struct dentry *dentry, char *name)
84{
85 char *p = dentry_path_raw(dentry, name, PATH_MAX);
86 char *root;
87 size_t len;
88
89 root = dentry->d_sb->s_fs_info;
90 len = strlen(root);
91 if (IS_ERR(p)) {
92 __putname(name);
93 return NULL;
94 }
95 strlcpy(name, root, PATH_MAX);
96 if (len > p - name) {
97 __putname(name);
98 return NULL;
99 }
100 if (p > name + len) {
101 char *s = name + len;
102 while ((*s++ = *p++) != '\0')
103 ;
104 }
105 return name;
106}
107
108static char *dentry_name(struct dentry *dentry)
109{
110 char *name = __getname();
111 if (!name)
112 return NULL;
113
114 return __dentry_name(dentry, name);
115}
116
117static char *inode_name(struct inode *ino)
118{
119 struct dentry *dentry;
120 char *name;
121
122 dentry = d_find_alias(ino);
123 if (!dentry)
124 return NULL;
125
126 name = dentry_name(dentry);
127
128 dput(dentry);
129
130 return name;
131}
132
133static char *follow_link(char *link)
134{
135 int len, n;
136 char *name, *resolved, *end;
137
138 len = 64;
139 while (1) {
140 n = -ENOMEM;
141 name = kmalloc(len, GFP_KERNEL);
142 if (name == NULL)
143 goto out;
144
145 n = hostfs_do_readlink(link, name, len);
146 if (n < len)
147 break;
148 len *= 2;
149 kfree(name);
150 }
151 if (n < 0)
152 goto out_free;
153
154 if (*name == '/')
155 return name;
156
157 end = strrchr(link, '/');
158 if (end == NULL)
159 return name;
160
161 *(end + 1) = '\0';
162 len = strlen(link) + strlen(name) + 1;
163
164 resolved = kmalloc(len, GFP_KERNEL);
165 if (resolved == NULL) {
166 n = -ENOMEM;
167 goto out_free;
168 }
169
170 sprintf(resolved, "%s%s", link, name);
171 kfree(name);
172 kfree(link);
173 return resolved;
174
175 out_free:
176 kfree(name);
177 out:
178 return ERR_PTR(n);
179}
180
181static struct inode *hostfs_iget(struct super_block *sb)
182{
183 struct inode *inode = new_inode(sb);
184 if (!inode)
185 return ERR_PTR(-ENOMEM);
186 return inode;
187}
188
189static int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
190{
191
192
193
194
195
196 int err;
197 long long f_blocks;
198 long long f_bfree;
199 long long f_bavail;
200 long long f_files;
201 long long f_ffree;
202
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),
206 &sf->f_namelen);
207 if (err)
208 return err;
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;
215 return 0;
216}
217
218static struct inode *hostfs_alloc_inode(struct super_block *sb)
219{
220 struct hostfs_inode_info *hi;
221
222 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
223 if (hi == NULL)
224 return NULL;
225 hi->fd = -1;
226 hi->mode = 0;
227 inode_init_once(&hi->vfs_inode);
228 return &hi->vfs_inode;
229}
230
231static void hostfs_evict_inode(struct inode *inode)
232{
233 truncate_inode_pages_final(&inode->i_data);
234 clear_inode(inode);
235 if (HOSTFS_I(inode)->fd != -1) {
236 close_file(&HOSTFS_I(inode)->fd);
237 HOSTFS_I(inode)->fd = -1;
238 }
239}
240
241static void hostfs_i_callback(struct rcu_head *head)
242{
243 struct inode *inode = container_of(head, struct inode, i_rcu);
244 kfree(HOSTFS_I(inode));
245}
246
247static void hostfs_destroy_inode(struct inode *inode)
248{
249 call_rcu(&inode->i_rcu, hostfs_i_callback);
250}
251
252static int hostfs_show_options(struct seq_file *seq, struct dentry *root)
253{
254 const char *root_path = root->d_sb->s_fs_info;
255 size_t offset = strlen(root_ino) + 1;
256
257 if (strlen(root_path) > offset)
258 seq_printf(seq, ",%s", root_path + offset);
259
260 return 0;
261}
262
263static 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,
269};
270
271static int hostfs_readdir(struct file *file, struct dir_context *ctx)
272{
273 void *dir;
274 char *name;
275 unsigned long long next, ino;
276 int error, len;
277 unsigned int type;
278
279 name = dentry_name(file->f_path.dentry);
280 if (name == NULL)
281 return -ENOMEM;
282 dir = open_dir(name, &error);
283 __putname(name);
284 if (dir == NULL)
285 return -error;
286 next = ctx->pos;
287 while ((name = read_dir(dir, &next, &ino, &len, &type)) != NULL) {
288 if (!dir_emit(ctx, name, len, ino, type))
289 break;
290 ctx->pos = next;
291 }
292 close_dir(dir);
293 return 0;
294}
295
296static int hostfs_file_open(struct inode *ino, struct file *file)
297{
298 static DEFINE_MUTEX(open_mutex);
299 char *name;
300 fmode_t mode = 0;
301 int err;
302 int r = 0, w = 0, fd;
303
304 mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
305 if ((mode & HOSTFS_I(ino)->mode) == mode)
306 return 0;
307
308 mode |= HOSTFS_I(ino)->mode;
309
310retry:
311 if (mode & FMODE_READ)
312 r = 1;
313 if (mode & FMODE_WRITE)
314 w = 1;
315 if (w)
316 r = 1;
317
318 name = dentry_name(file->f_path.dentry);
319 if (name == NULL)
320 return -ENOMEM;
321
322 fd = open_file(name, r, w, append);
323 __putname(name);
324 if (fd < 0)
325 return fd;
326
327 mutex_lock(&open_mutex);
328
329 if ((mode & HOSTFS_I(ino)->mode) == mode) {
330 mutex_unlock(&open_mutex);
331 return 0;
332 }
333 if ((mode | HOSTFS_I(ino)->mode) != mode) {
334 mode |= HOSTFS_I(ino)->mode;
335 mutex_unlock(&open_mutex);
336 close_file(&fd);
337 goto retry;
338 }
339 if (HOSTFS_I(ino)->fd == -1) {
340 HOSTFS_I(ino)->fd = fd;
341 } else {
342 err = replace_file(fd, HOSTFS_I(ino)->fd);
343 close_file(&fd);
344 if (err < 0) {
345 mutex_unlock(&open_mutex);
346 return err;
347 }
348 }
349 HOSTFS_I(ino)->mode = mode;
350 mutex_unlock(&open_mutex);
351
352 return 0;
353}
354
355static int hostfs_file_release(struct inode *inode, struct file *file)
356{
357 filemap_write_and_wait(inode->i_mapping);
358
359 return 0;
360}
361
362static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
363 int datasync)
364{
365 struct inode *inode = file->f_mapping->host;
366 int ret;
367
368 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
369 if (ret)
370 return ret;
371
372 mutex_lock(&inode->i_mutex);
373 ret = fsync_file(HOSTFS_I(inode)->fd, datasync);
374 mutex_unlock(&inode->i_mutex);
375
376 return ret;
377}
378
379static const struct file_operations hostfs_file_fops = {
380 .llseek = generic_file_llseek,
381 .read = new_sync_read,
382 .splice_read = generic_file_splice_read,
383 .read_iter = generic_file_read_iter,
384 .write_iter = generic_file_write_iter,
385 .write = new_sync_write,
386 .mmap = generic_file_mmap,
387 .open = hostfs_file_open,
388 .release = hostfs_file_release,
389 .fsync = hostfs_fsync,
390};
391
392static const struct file_operations hostfs_dir_fops = {
393 .llseek = generic_file_llseek,
394 .iterate = hostfs_readdir,
395 .read = generic_read_dir,
396};
397
398static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
399{
400 struct address_space *mapping = page->mapping;
401 struct inode *inode = mapping->host;
402 char *buffer;
403 unsigned long long base;
404 int count = PAGE_CACHE_SIZE;
405 int end_index = inode->i_size >> PAGE_CACHE_SHIFT;
406 int err;
407
408 if (page->index >= end_index)
409 count = inode->i_size & (PAGE_CACHE_SIZE-1);
410
411 buffer = kmap(page);
412 base = ((unsigned long long) page->index) << PAGE_CACHE_SHIFT;
413
414 err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
415 if (err != count) {
416 ClearPageUptodate(page);
417 goto out;
418 }
419
420 if (base > inode->i_size)
421 inode->i_size = base;
422
423 if (PageError(page))
424 ClearPageError(page);
425 err = 0;
426
427 out:
428 kunmap(page);
429
430 unlock_page(page);
431 return err;
432}
433
434static int hostfs_readpage(struct file *file, struct page *page)
435{
436 char *buffer;
437 long long start;
438 int err = 0;
439
440 start = (long long) page->index << PAGE_CACHE_SHIFT;
441 buffer = kmap(page);
442 err = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
443 PAGE_CACHE_SIZE);
444 if (err < 0)
445 goto out;
446
447 memset(&buffer[err], 0, PAGE_CACHE_SIZE - err);
448
449 flush_dcache_page(page);
450 SetPageUptodate(page);
451 if (PageError(page)) ClearPageError(page);
452 err = 0;
453 out:
454 kunmap(page);
455 unlock_page(page);
456 return err;
457}
458
459static int hostfs_write_begin(struct file *file, struct address_space *mapping,
460 loff_t pos, unsigned len, unsigned flags,
461 struct page **pagep, void **fsdata)
462{
463 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
464
465 *pagep = grab_cache_page_write_begin(mapping, index, flags);
466 if (!*pagep)
467 return -ENOMEM;
468 return 0;
469}
470
471static int hostfs_write_end(struct file *file, struct address_space *mapping,
472 loff_t pos, unsigned len, unsigned copied,
473 struct page *page, void *fsdata)
474{
475 struct inode *inode = mapping->host;
476 void *buffer;
477 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
478 int err;
479
480 buffer = kmap(page);
481 err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
482 kunmap(page);
483
484 if (!PageUptodate(page) && err == PAGE_CACHE_SIZE)
485 SetPageUptodate(page);
486
487
488
489
490
491 if (err > 0 && (pos > inode->i_size))
492 inode->i_size = pos;
493 unlock_page(page);
494 page_cache_release(page);
495
496 return err;
497}
498
499static const struct address_space_operations hostfs_aops = {
500 .writepage = hostfs_writepage,
501 .readpage = hostfs_readpage,
502 .set_page_dirty = __set_page_dirty_nobuffers,
503 .write_begin = hostfs_write_begin,
504 .write_end = hostfs_write_end,
505};
506
507static int read_name(struct inode *ino, char *name)
508{
509 dev_t rdev;
510 struct hostfs_stat st;
511 int err = stat_file(name, &st, -1);
512 if (err)
513 return err;
514
515
516 rdev = MKDEV(st.maj, st.min);
517
518 switch (st.mode & S_IFMT) {
519 case S_IFLNK:
520 ino->i_op = &hostfs_link_iops;
521 break;
522 case S_IFDIR:
523 ino->i_op = &hostfs_dir_iops;
524 ino->i_fop = &hostfs_dir_fops;
525 break;
526 case S_IFCHR:
527 case S_IFBLK:
528 case S_IFIFO:
529 case S_IFSOCK:
530 init_special_inode(ino, st.mode & S_IFMT, rdev);
531 ino->i_op = &hostfs_iops;
532 break;
533
534 default:
535 ino->i_op = &hostfs_iops;
536 ino->i_fop = &hostfs_file_fops;
537 ino->i_mapping->a_ops = &hostfs_aops;
538 }
539
540 ino->i_ino = st.ino;
541 ino->i_mode = st.mode;
542 set_nlink(ino, st.nlink);
543 i_uid_write(ino, st.uid);
544 i_gid_write(ino, st.gid);
545 ino->i_atime = st.atime;
546 ino->i_mtime = st.mtime;
547 ino->i_ctime = st.ctime;
548 ino->i_size = st.size;
549 ino->i_blocks = st.blocks;
550 return 0;
551}
552
553static int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
554 bool excl)
555{
556 struct inode *inode;
557 char *name;
558 int error, fd;
559
560 inode = hostfs_iget(dir->i_sb);
561 if (IS_ERR(inode)) {
562 error = PTR_ERR(inode);
563 goto out;
564 }
565
566 error = -ENOMEM;
567 name = dentry_name(dentry);
568 if (name == NULL)
569 goto out_put;
570
571 fd = file_create(name,
572 mode & S_IRUSR, mode & S_IWUSR, mode & S_IXUSR,
573 mode & S_IRGRP, mode & S_IWGRP, mode & S_IXGRP,
574 mode & S_IROTH, mode & S_IWOTH, mode & S_IXOTH);
575 if (fd < 0)
576 error = fd;
577 else
578 error = read_name(inode, name);
579
580 __putname(name);
581 if (error)
582 goto out_put;
583
584 HOSTFS_I(inode)->fd = fd;
585 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
586 d_instantiate(dentry, inode);
587 return 0;
588
589 out_put:
590 iput(inode);
591 out:
592 return error;
593}
594
595static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
596 unsigned int flags)
597{
598 struct inode *inode;
599 char *name;
600 int err;
601
602 inode = hostfs_iget(ino->i_sb);
603 if (IS_ERR(inode)) {
604 err = PTR_ERR(inode);
605 goto out;
606 }
607
608 err = -ENOMEM;
609 name = dentry_name(dentry);
610 if (name == NULL)
611 goto out_put;
612
613 err = read_name(inode, name);
614
615 __putname(name);
616 if (err == -ENOENT) {
617 iput(inode);
618 inode = NULL;
619 }
620 else if (err)
621 goto out_put;
622
623 d_add(dentry, inode);
624 return NULL;
625
626 out_put:
627 iput(inode);
628 out:
629 return ERR_PTR(err);
630}
631
632static int hostfs_link(struct dentry *to, struct inode *ino,
633 struct dentry *from)
634{
635 char *from_name, *to_name;
636 int err;
637
638 if ((from_name = dentry_name(from)) == NULL)
639 return -ENOMEM;
640 to_name = dentry_name(to);
641 if (to_name == NULL) {
642 __putname(from_name);
643 return -ENOMEM;
644 }
645 err = link_file(to_name, from_name);
646 __putname(from_name);
647 __putname(to_name);
648 return err;
649}
650
651static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
652{
653 char *file;
654 int err;
655
656 if (append)
657 return -EPERM;
658
659 if ((file = dentry_name(dentry)) == NULL)
660 return -ENOMEM;
661
662 err = unlink_file(file);
663 __putname(file);
664 return err;
665}
666
667static int hostfs_symlink(struct inode *ino, struct dentry *dentry,
668 const char *to)
669{
670 char *file;
671 int err;
672
673 if ((file = dentry_name(dentry)) == NULL)
674 return -ENOMEM;
675 err = make_symlink(file, to);
676 __putname(file);
677 return err;
678}
679
680static int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
681{
682 char *file;
683 int err;
684
685 if ((file = dentry_name(dentry)) == NULL)
686 return -ENOMEM;
687 err = do_mkdir(file, mode);
688 __putname(file);
689 return err;
690}
691
692static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
693{
694 char *file;
695 int err;
696
697 if ((file = dentry_name(dentry)) == NULL)
698 return -ENOMEM;
699 err = do_rmdir(file);
700 __putname(file);
701 return err;
702}
703
704static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
705{
706 struct inode *inode;
707 char *name;
708 int err;
709
710 inode = hostfs_iget(dir->i_sb);
711 if (IS_ERR(inode)) {
712 err = PTR_ERR(inode);
713 goto out;
714 }
715
716 err = -ENOMEM;
717 name = dentry_name(dentry);
718 if (name == NULL)
719 goto out_put;
720
721 init_special_inode(inode, mode, dev);
722 err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
723 if (!err)
724 goto out_free;
725
726 err = read_name(inode, name);
727 __putname(name);
728 if (err)
729 goto out_put;
730 if (err)
731 goto out_put;
732
733 d_instantiate(dentry, inode);
734 return 0;
735
736 out_free:
737 __putname(name);
738 out_put:
739 iput(inode);
740 out:
741 return err;
742}
743
744static int hostfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
745 struct inode *new_dir, struct dentry *new_dentry,
746 unsigned int flags)
747{
748 char *old_name, *new_name;
749 int err;
750
751 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
752 return -EINVAL;
753
754 old_name = dentry_name(old_dentry);
755 if (old_name == NULL)
756 return -ENOMEM;
757 new_name = dentry_name(new_dentry);
758 if (new_name == NULL) {
759 __putname(old_name);
760 return -ENOMEM;
761 }
762 if (!flags)
763 err = rename_file(old_name, new_name);
764 else
765 err = rename2_file(old_name, new_name, flags);
766
767 __putname(old_name);
768 __putname(new_name);
769 return err;
770}
771
772static int hostfs_permission(struct inode *ino, int desired)
773{
774 char *name;
775 int r = 0, w = 0, x = 0, err;
776
777 if (desired & MAY_NOT_BLOCK)
778 return -ECHILD;
779
780 if (desired & MAY_READ) r = 1;
781 if (desired & MAY_WRITE) w = 1;
782 if (desired & MAY_EXEC) x = 1;
783 name = inode_name(ino);
784 if (name == NULL)
785 return -ENOMEM;
786
787 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
788 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
789 err = 0;
790 else
791 err = access_file(name, r, w, x);
792 __putname(name);
793 if (!err)
794 err = generic_permission(ino, desired);
795 return err;
796}
797
798static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
799{
800 struct inode *inode = dentry->d_inode;
801 struct hostfs_iattr attrs;
802 char *name;
803 int err;
804
805 int fd = HOSTFS_I(inode)->fd;
806
807 err = inode_change_ok(inode, attr);
808 if (err)
809 return err;
810
811 if (append)
812 attr->ia_valid &= ~ATTR_SIZE;
813
814 attrs.ia_valid = 0;
815 if (attr->ia_valid & ATTR_MODE) {
816 attrs.ia_valid |= HOSTFS_ATTR_MODE;
817 attrs.ia_mode = attr->ia_mode;
818 }
819 if (attr->ia_valid & ATTR_UID) {
820 attrs.ia_valid |= HOSTFS_ATTR_UID;
821 attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
822 }
823 if (attr->ia_valid & ATTR_GID) {
824 attrs.ia_valid |= HOSTFS_ATTR_GID;
825 attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
826 }
827 if (attr->ia_valid & ATTR_SIZE) {
828 attrs.ia_valid |= HOSTFS_ATTR_SIZE;
829 attrs.ia_size = attr->ia_size;
830 }
831 if (attr->ia_valid & ATTR_ATIME) {
832 attrs.ia_valid |= HOSTFS_ATTR_ATIME;
833 attrs.ia_atime = attr->ia_atime;
834 }
835 if (attr->ia_valid & ATTR_MTIME) {
836 attrs.ia_valid |= HOSTFS_ATTR_MTIME;
837 attrs.ia_mtime = attr->ia_mtime;
838 }
839 if (attr->ia_valid & ATTR_CTIME) {
840 attrs.ia_valid |= HOSTFS_ATTR_CTIME;
841 attrs.ia_ctime = attr->ia_ctime;
842 }
843 if (attr->ia_valid & ATTR_ATIME_SET) {
844 attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
845 }
846 if (attr->ia_valid & ATTR_MTIME_SET) {
847 attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
848 }
849 name = dentry_name(dentry);
850 if (name == NULL)
851 return -ENOMEM;
852 err = set_attr(name, &attrs, fd);
853 __putname(name);
854 if (err)
855 return err;
856
857 if ((attr->ia_valid & ATTR_SIZE) &&
858 attr->ia_size != i_size_read(inode))
859 truncate_setsize(inode, attr->ia_size);
860
861 setattr_copy(inode, attr);
862 mark_inode_dirty(inode);
863 return 0;
864}
865
866static const struct inode_operations hostfs_iops = {
867 .permission = hostfs_permission,
868 .setattr = hostfs_setattr,
869};
870
871static const struct inode_operations hostfs_dir_iops = {
872 .create = hostfs_create,
873 .lookup = hostfs_lookup,
874 .link = hostfs_link,
875 .unlink = hostfs_unlink,
876 .symlink = hostfs_symlink,
877 .mkdir = hostfs_mkdir,
878 .rmdir = hostfs_rmdir,
879 .mknod = hostfs_mknod,
880 .rename2 = hostfs_rename2,
881 .permission = hostfs_permission,
882 .setattr = hostfs_setattr,
883};
884
885static void *hostfs_follow_link(struct dentry *dentry, struct nameidata *nd)
886{
887 char *link = __getname();
888 if (link) {
889 char *path = dentry_name(dentry);
890 int err = -ENOMEM;
891 if (path) {
892 err = hostfs_do_readlink(path, link, PATH_MAX);
893 if (err == PATH_MAX)
894 err = -E2BIG;
895 __putname(path);
896 }
897 if (err < 0) {
898 __putname(link);
899 link = ERR_PTR(err);
900 }
901 } else {
902 link = ERR_PTR(-ENOMEM);
903 }
904
905 nd_set_link(nd, link);
906 return NULL;
907}
908
909static void hostfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
910{
911 char *s = nd_get_link(nd);
912 if (!IS_ERR(s))
913 __putname(s);
914}
915
916static const struct inode_operations hostfs_link_iops = {
917 .readlink = generic_readlink,
918 .follow_link = hostfs_follow_link,
919 .put_link = hostfs_put_link,
920};
921
922static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
923{
924 struct inode *root_inode;
925 char *host_root_path, *req_root = d;
926 int err;
927
928 sb->s_blocksize = 1024;
929 sb->s_blocksize_bits = 10;
930 sb->s_magic = HOSTFS_SUPER_MAGIC;
931 sb->s_op = &hostfs_sbops;
932 sb->s_d_op = &simple_dentry_operations;
933 sb->s_maxbytes = MAX_LFS_FILESIZE;
934
935
936 if (req_root == NULL)
937 req_root = "";
938
939 err = -ENOMEM;
940 sb->s_fs_info = host_root_path =
941 kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL);
942 if (host_root_path == NULL)
943 goto out;
944
945 sprintf(host_root_path, "%s/%s", root_ino, req_root);
946
947 root_inode = new_inode(sb);
948 if (!root_inode)
949 goto out;
950
951 err = read_name(root_inode, host_root_path);
952 if (err)
953 goto out_put;
954
955 if (S_ISLNK(root_inode->i_mode)) {
956 char *name = follow_link(host_root_path);
957 if (IS_ERR(name))
958 err = PTR_ERR(name);
959 else
960 err = read_name(root_inode, name);
961 kfree(name);
962 if (err)
963 goto out_put;
964 }
965
966 err = -ENOMEM;
967 sb->s_root = d_make_root(root_inode);
968 if (sb->s_root == NULL)
969 goto out;
970
971 return 0;
972
973out_put:
974 iput(root_inode);
975out:
976 return err;
977}
978
979static struct dentry *hostfs_read_sb(struct file_system_type *type,
980 int flags, const char *dev_name,
981 void *data)
982{
983 return mount_nodev(type, flags, data, hostfs_fill_sb_common);
984}
985
986static void hostfs_kill_sb(struct super_block *s)
987{
988 kill_anon_super(s);
989 kfree(s->s_fs_info);
990}
991
992static struct file_system_type hostfs_type = {
993 .owner = THIS_MODULE,
994 .name = "hostfs",
995 .mount = hostfs_read_sb,
996 .kill_sb = hostfs_kill_sb,
997 .fs_flags = 0,
998};
999MODULE_ALIAS_FS("hostfs");
1000
1001static int __init init_hostfs(void)
1002{
1003 return register_filesystem(&hostfs_type);
1004}
1005
1006static void __exit exit_hostfs(void)
1007{
1008 unregister_filesystem(&hostfs_type);
1009}
1010
1011module_init(init_hostfs)
1012module_exit(exit_hostfs)
1013MODULE_LICENSE("GPL");
1014
