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