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