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 int len, n;
143 char *name, *resolved, *end;
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 len = strlen(link) + strlen(name) + 1;
168
169 resolved = kmalloc(len, GFP_KERNEL);
170 if (resolved == NULL) {
171 n = -ENOMEM;
172 goto out_free;
173 }
174
175 sprintf(resolved, "%s%s", link, name);
176 __putname(name);
177 kfree(link);
178 return resolved;
179
180 out_free:
181 __putname(name);
182 return ERR_PTR(n);
183}
184
185static struct inode *hostfs_iget(struct super_block *sb)
186{
187 struct inode *inode = new_inode(sb);
188 if (!inode)
189 return ERR_PTR(-ENOMEM);
190 return inode;
191}
192
193static int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
194{
195
196
197
198
199
200 int err;
201 long long f_blocks;
202 long long f_bfree;
203 long long f_bavail;
204 long long f_files;
205 long long f_ffree;
206
207 err = do_statfs(dentry->d_sb->s_fs_info,
208 &sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
209 &f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
210 &sf->f_namelen);
211 if (err)
212 return err;
213 sf->f_blocks = f_blocks;
214 sf->f_bfree = f_bfree;
215 sf->f_bavail = f_bavail;
216 sf->f_files = f_files;
217 sf->f_ffree = f_ffree;
218 sf->f_type = HOSTFS_SUPER_MAGIC;
219 return 0;
220}
221
222static struct inode *hostfs_alloc_inode(struct super_block *sb)
223{
224 struct hostfs_inode_info *hi;
225
226 hi = kmalloc(sizeof(*hi), GFP_KERNEL_ACCOUNT);
227 if (hi == NULL)
228 return NULL;
229 hi->fd = -1;
230 hi->mode = 0;
231 inode_init_once(&hi->vfs_inode);
232 mutex_init(&hi->open_mutex);
233 return &hi->vfs_inode;
234}
235
236static void hostfs_evict_inode(struct inode *inode)
237{
238 truncate_inode_pages_final(&inode->i_data);
239 clear_inode(inode);
240 if (HOSTFS_I(inode)->fd != -1) {
241 close_file(&HOSTFS_I(inode)->fd);
242 HOSTFS_I(inode)->fd = -1;
243 }
244}
245
246static void hostfs_i_callback(struct rcu_head *head)
247{
248 struct inode *inode = container_of(head, struct inode, i_rcu);
249 kfree(HOSTFS_I(inode));
250}
251
252static void hostfs_destroy_inode(struct inode *inode)
253{
254 call_rcu(&inode->i_rcu, hostfs_i_callback);
255}
256
257static int hostfs_show_options(struct seq_file *seq, struct dentry *root)
258{
259 const char *root_path = root->d_sb->s_fs_info;
260 size_t offset = strlen(root_ino) + 1;
261
262 if (strlen(root_path) > offset)
263 seq_show_option(seq, root_path + offset, NULL);
264
265 if (append)
266 seq_puts(seq, ",append");
267
268 return 0;
269}
270
271static const struct super_operations hostfs_sbops = {
272 .alloc_inode = hostfs_alloc_inode,
273 .destroy_inode = hostfs_destroy_inode,
274 .evict_inode = hostfs_evict_inode,
275 .statfs = hostfs_statfs,
276 .show_options = hostfs_show_options,
277};
278
279static int hostfs_readdir(struct file *file, struct dir_context *ctx)
280{
281 void *dir;
282 char *name;
283 unsigned long long next, ino;
284 int error, len;
285 unsigned int type;
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 = ctx->pos;
295 seek_dir(dir, next);
296 while ((name = read_dir(dir, &next, &ino, &len, &type)) != NULL) {
297 if (!dir_emit(ctx, name, len, ino, type))
298 break;
299 ctx->pos = next;
300 }
301 close_dir(dir);
302 return 0;
303}
304
305static int hostfs_open(struct inode *ino, struct file *file)
306{
307 char *name;
308 fmode_t mode;
309 int err;
310 int r, w, fd;
311
312 mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
313 if ((mode & HOSTFS_I(ino)->mode) == mode)
314 return 0;
315
316 mode |= HOSTFS_I(ino)->mode;
317
318retry:
319 r = w = 0;
320
321 if (mode & FMODE_READ)
322 r = 1;
323 if (mode & FMODE_WRITE)
324 r = w = 1;
325
326 name = dentry_name(file->f_path.dentry);
327 if (name == NULL)
328 return -ENOMEM;
329
330 fd = open_file(name, r, w, append);
331 __putname(name);
332 if (fd < 0)
333 return fd;
334
335 mutex_lock(&HOSTFS_I(ino)->open_mutex);
336
337 if ((mode & HOSTFS_I(ino)->mode) == mode) {
338 mutex_unlock(&HOSTFS_I(ino)->open_mutex);
339 close_file(&fd);
340 return 0;
341 }
342 if ((mode | HOSTFS_I(ino)->mode) != mode) {
343 mode |= HOSTFS_I(ino)->mode;
344 mutex_unlock(&HOSTFS_I(ino)->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(&HOSTFS_I(ino)->open_mutex);
355 return err;
356 }
357 }
358 HOSTFS_I(ino)->mode = mode;
359 mutex_unlock(&HOSTFS_I(ino)->open_mutex);
360
361 return 0;
362}
363
364static int hostfs_file_release(struct inode *inode, struct file *file)
365{
366 filemap_write_and_wait(inode->i_mapping);
367
368 return 0;
369}
370
371static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
372 int datasync)
373{
374 struct inode *inode = file->f_mapping->host;
375 int ret;
376
377 ret = file_write_and_wait_range(file, start, end);
378 if (ret)
379 return ret;
380
381 inode_lock(inode);
382 ret = fsync_file(HOSTFS_I(inode)->fd, datasync);
383 inode_unlock(inode);
384
385 return ret;
386}
387
388static const struct file_operations hostfs_file_fops = {
389 .llseek = generic_file_llseek,
390 .splice_read = generic_file_splice_read,
391 .read_iter = generic_file_read_iter,
392 .write_iter = generic_file_write_iter,
393 .mmap = generic_file_mmap,
394 .open = hostfs_open,
395 .release = hostfs_file_release,
396 .fsync = hostfs_fsync,
397};
398
399static const struct file_operations hostfs_dir_fops = {
400 .llseek = generic_file_llseek,
401 .iterate_shared = hostfs_readdir,
402 .read = generic_read_dir,
403 .open = hostfs_open,
404 .fsync = hostfs_fsync,
405};
406
407static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
408{
409 struct address_space *mapping = page->mapping;
410 struct inode *inode = mapping->host;
411 char *buffer;
412 loff_t base = page_offset(page);
413 int count = PAGE_SIZE;
414 int end_index = inode->i_size >> PAGE_SHIFT;
415 int err;
416
417 if (page->index >= end_index)
418 count = inode->i_size & (PAGE_SIZE-1);
419
420 buffer = kmap(page);
421
422 err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
423 if (err != count) {
424 ClearPageUptodate(page);
425 goto out;
426 }
427
428 if (base > inode->i_size)
429 inode->i_size = base;
430
431 if (PageError(page))
432 ClearPageError(page);
433 err = 0;
434
435 out:
436 kunmap(page);
437
438 unlock_page(page);
439 return err;
440}
441
442static int hostfs_readpage(struct file *file, struct page *page)
443{
444 char *buffer;
445 loff_t start = page_offset(page);
446 int bytes_read, ret = 0;
447
448 buffer = kmap(page);
449 bytes_read = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
450 PAGE_SIZE);
451 if (bytes_read < 0) {
452 ClearPageUptodate(page);
453 SetPageError(page);
454 ret = bytes_read;
455 goto out;
456 }
457
458 memset(buffer + bytes_read, 0, PAGE_SIZE - bytes_read);
459
460 ClearPageError(page);
461 SetPageUptodate(page);
462
463 out:
464 flush_dcache_page(page);
465 kunmap(page);
466 unlock_page(page);
467 return ret;
468}
469
470static int hostfs_write_begin(struct file *file, struct address_space *mapping,
471 loff_t pos, unsigned len, unsigned flags,
472 struct page **pagep, void **fsdata)
473{
474 pgoff_t index = pos >> PAGE_SHIFT;
475
476 *pagep = grab_cache_page_write_begin(mapping, index, flags);
477 if (!*pagep)
478 return -ENOMEM;
479 return 0;
480}
481
482static int hostfs_write_end(struct file *file, struct address_space *mapping,
483 loff_t pos, unsigned len, unsigned copied,
484 struct page *page, void *fsdata)
485{
486 struct inode *inode = mapping->host;
487 void *buffer;
488 unsigned from = pos & (PAGE_SIZE - 1);
489 int err;
490
491 buffer = kmap(page);
492 err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
493 kunmap(page);
494
495 if (!PageUptodate(page) && err == PAGE_SIZE)
496 SetPageUptodate(page);
497
498
499
500
501
502 if (err > 0 && (pos > inode->i_size))
503 inode->i_size = pos;
504 unlock_page(page);
505 put_page(page);
506
507 return err;
508}
509
510static const struct address_space_operations hostfs_aops = {
511 .writepage = hostfs_writepage,
512 .readpage = hostfs_readpage,
513 .set_page_dirty = __set_page_dirty_nobuffers,
514 .write_begin = hostfs_write_begin,
515 .write_end = hostfs_write_end,
516};
517
518static int read_name(struct inode *ino, char *name)
519{
520 dev_t rdev;
521 struct hostfs_stat st;
522 int err = stat_file(name, &st, -1);
523 if (err)
524 return err;
525
526
527 rdev = MKDEV(st.maj, st.min);
528
529 switch (st.mode & S_IFMT) {
530 case S_IFLNK:
531 ino->i_op = &hostfs_link_iops;
532 break;
533 case S_IFDIR:
534 ino->i_op = &hostfs_dir_iops;
535 ino->i_fop = &hostfs_dir_fops;
536 break;
537 case S_IFCHR:
538 case S_IFBLK:
539 case S_IFIFO:
540 case S_IFSOCK:
541 init_special_inode(ino, st.mode & S_IFMT, rdev);
542 ino->i_op = &hostfs_iops;
543 break;
544 case S_IFREG:
545 ino->i_op = &hostfs_iops;
546 ino->i_fop = &hostfs_file_fops;
547 ino->i_mapping->a_ops = &hostfs_aops;
548 break;
549 default:
550 return -EIO;
551 }
552
553 ino->i_ino = st.ino;
554 ino->i_mode = st.mode;
555 set_nlink(ino, st.nlink);
556 i_uid_write(ino, st.uid);
557 i_gid_write(ino, st.gid);
558 ino->i_atime = timespec_to_timespec64(st.atime);
559 ino->i_mtime = timespec_to_timespec64(st.mtime);
560 ino->i_ctime = timespec_to_timespec64(st.ctime);
561 ino->i_size = st.size;
562 ino->i_blocks = st.blocks;
563 return 0;
564}
565
566static int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
567 bool excl)
568{
569 struct inode *inode;
570 char *name;
571 int error, fd;
572
573 inode = hostfs_iget(dir->i_sb);
574 if (IS_ERR(inode)) {
575 error = PTR_ERR(inode);
576 goto out;
577 }
578
579 error = -ENOMEM;
580 name = dentry_name(dentry);
581 if (name == NULL)
582 goto out_put;
583
584 fd = file_create(name, mode & 0777);
585 if (fd < 0)
586 error = fd;
587 else
588 error = read_name(inode, name);
589
590 __putname(name);
591 if (error)
592 goto out_put;
593
594 HOSTFS_I(inode)->fd = fd;
595 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
596 d_instantiate(dentry, inode);
597 return 0;
598
599 out_put:
600 iput(inode);
601 out:
602 return error;
603}
604
605static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
606 unsigned int flags)
607{
608 struct inode *inode;
609 char *name;
610 int err;
611
612 inode = hostfs_iget(ino->i_sb);
613 if (IS_ERR(inode))
614 goto out;
615
616 err = -ENOMEM;
617 name = dentry_name(dentry);
618 if (name) {
619 err = read_name(inode, name);
620 __putname(name);
621 }
622 if (err) {
623 iput(inode);
624 inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
625 }
626 out:
627 return d_splice_alias(inode, dentry);
628}
629
630static int hostfs_link(struct dentry *to, struct inode *ino,
631 struct dentry *from)
632{
633 char *from_name, *to_name;
634 int err;
635
636 if ((from_name = dentry_name(from)) == NULL)
637 return -ENOMEM;
638 to_name = dentry_name(to);
639 if (to_name == NULL) {
640 __putname(from_name);
641 return -ENOMEM;
642 }
643 err = link_file(to_name, from_name);
644 __putname(from_name);
645 __putname(to_name);
646 return err;
647}
648
649static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
650{
651 char *file;
652 int err;
653
654 if (append)
655 return -EPERM;
656
657 if ((file = dentry_name(dentry)) == NULL)
658 return -ENOMEM;
659
660 err = unlink_file(file);
661 __putname(file);
662 return err;
663}
664
665static int hostfs_symlink(struct inode *ino, struct dentry *dentry,
666 const char *to)
667{
668 char *file;
669 int err;
670
671 if ((file = dentry_name(dentry)) == NULL)
672 return -ENOMEM;
673 err = make_symlink(file, to);
674 __putname(file);
675 return err;
676}
677
678static int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
679{
680 char *file;
681 int err;
682
683 if ((file = dentry_name(dentry)) == NULL)
684 return -ENOMEM;
685 err = do_mkdir(file, mode);
686 __putname(file);
687 return err;
688}
689
690static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
691{
692 char *file;
693 int err;
694
695 if ((file = dentry_name(dentry)) == NULL)
696 return -ENOMEM;
697 err = hostfs_do_rmdir(file);
698 __putname(file);
699 return err;
700}
701
702static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
703{
704 struct inode *inode;
705 char *name;
706 int err;
707
708 inode = hostfs_iget(dir->i_sb);
709 if (IS_ERR(inode)) {
710 err = PTR_ERR(inode);
711 goto out;
712 }
713
714 err = -ENOMEM;
715 name = dentry_name(dentry);
716 if (name == NULL)
717 goto out_put;
718
719 init_special_inode(inode, mode, dev);
720 err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
721 if (err)
722 goto out_free;
723
724 err = read_name(inode, name);
725 __putname(name);
726 if (err)
727 goto out_put;
728
729 d_instantiate(dentry, inode);
730 return 0;
731
732 out_free:
733 __putname(name);
734 out_put:
735 iput(inode);
736 out:
737 return err;
738}
739
740static int hostfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
741 struct inode *new_dir, struct dentry *new_dentry,
742 unsigned int flags)
743{
744 char *old_name, *new_name;
745 int err;
746
747 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
748 return -EINVAL;
749
750 old_name = dentry_name(old_dentry);
751 if (old_name == NULL)
752 return -ENOMEM;
753 new_name = dentry_name(new_dentry);
754 if (new_name == NULL) {
755 __putname(old_name);
756 return -ENOMEM;
757 }
758 if (!flags)
759 err = rename_file(old_name, new_name);
760 else
761 err = rename2_file(old_name, new_name, flags);
762
763 __putname(old_name);
764 __putname(new_name);
765 return err;
766}
767
768static int hostfs_permission(struct inode *ino, int desired)
769{
770 char *name;
771 int r = 0, w = 0, x = 0, err;
772
773 if (desired & MAY_NOT_BLOCK)
774 return -ECHILD;
775
776 if (desired & MAY_READ) r = 1;
777 if (desired & MAY_WRITE) w = 1;
778 if (desired & MAY_EXEC) x = 1;
779 name = inode_name(ino);
780 if (name == NULL)
781 return -ENOMEM;
782
783 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
784 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
785 err = 0;
786 else
787 err = access_file(name, r, w, x);
788 __putname(name);
789 if (!err)
790 err = generic_permission(ino, desired);
791 return err;
792}
793
794static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
795{
796 struct inode *inode = d_inode(dentry);
797 struct hostfs_iattr attrs;
798 char *name;
799 int err;
800
801 int fd = HOSTFS_I(inode)->fd;
802
803 err = setattr_prepare(dentry, attr);
804 if (err)
805 return err;
806
807 if (append)
808 attr->ia_valid &= ~ATTR_SIZE;
809
810 attrs.ia_valid = 0;
811 if (attr->ia_valid & ATTR_MODE) {
812 attrs.ia_valid |= HOSTFS_ATTR_MODE;
813 attrs.ia_mode = attr->ia_mode;
814 }
815 if (attr->ia_valid & ATTR_UID) {
816 attrs.ia_valid |= HOSTFS_ATTR_UID;
817 attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
818 }
819 if (attr->ia_valid & ATTR_GID) {
820 attrs.ia_valid |= HOSTFS_ATTR_GID;
821 attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
822 }
823 if (attr->ia_valid & ATTR_SIZE) {
824 attrs.ia_valid |= HOSTFS_ATTR_SIZE;
825 attrs.ia_size = attr->ia_size;
826 }
827 if (attr->ia_valid & ATTR_ATIME) {
828 attrs.ia_valid |= HOSTFS_ATTR_ATIME;
829 attrs.ia_atime = timespec64_to_timespec(attr->ia_atime);
830 }
831 if (attr->ia_valid & ATTR_MTIME) {
832 attrs.ia_valid |= HOSTFS_ATTR_MTIME;
833 attrs.ia_mtime = timespec64_to_timespec(attr->ia_mtime);
834 }
835 if (attr->ia_valid & ATTR_CTIME) {
836 attrs.ia_valid |= HOSTFS_ATTR_CTIME;
837 attrs.ia_ctime = timespec64_to_timespec(attr->ia_ctime);
838 }
839 if (attr->ia_valid & ATTR_ATIME_SET) {
840 attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
841 }
842 if (attr->ia_valid & ATTR_MTIME_SET) {
843 attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
844 }
845 name = dentry_name(dentry);
846 if (name == NULL)
847 return -ENOMEM;
848 err = set_attr(name, &attrs, fd);
849 __putname(name);
850 if (err)
851 return err;
852
853 if ((attr->ia_valid & ATTR_SIZE) &&
854 attr->ia_size != i_size_read(inode))
855 truncate_setsize(inode, attr->ia_size);
856
857 setattr_copy(inode, attr);
858 mark_inode_dirty(inode);
859 return 0;
860}
861
862static const struct inode_operations hostfs_iops = {
863 .permission = hostfs_permission,
864 .setattr = hostfs_setattr,
865};
866
867static const struct inode_operations hostfs_dir_iops = {
868 .create = hostfs_create,
869 .lookup = hostfs_lookup,
870 .link = hostfs_link,
871 .unlink = hostfs_unlink,
872 .symlink = hostfs_symlink,
873 .mkdir = hostfs_mkdir,
874 .rmdir = hostfs_rmdir,
875 .mknod = hostfs_mknod,
876 .rename = hostfs_rename2,
877 .permission = hostfs_permission,
878 .setattr = hostfs_setattr,
879};
880
881static const char *hostfs_get_link(struct dentry *dentry,
882 struct inode *inode,
883 struct delayed_call *done)
884{
885 char *link;
886 if (!dentry)
887 return ERR_PTR(-ECHILD);
888 link = kmalloc(PATH_MAX, GFP_KERNEL);
889 if (link) {
890 char *path = dentry_name(dentry);
891 int err = -ENOMEM;
892 if (path) {
893 err = hostfs_do_readlink(path, link, PATH_MAX);
894 if (err == PATH_MAX)
895 err = -E2BIG;
896 __putname(path);
897 }
898 if (err < 0) {
899 kfree(link);
900 return ERR_PTR(err);
901 }
902 } else {
903 return ERR_PTR(-ENOMEM);
904 }
905
906 set_delayed_call(done, kfree_link, link);
907 return link;
908}
909
910static const struct inode_operations hostfs_link_iops = {
911 .get_link = hostfs_get_link,
912};
913
914static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
915{
916 struct inode *root_inode;
917 char *host_root_path, *req_root = d;
918 int err;
919
920 sb->s_blocksize = 1024;
921 sb->s_blocksize_bits = 10;
922 sb->s_magic = HOSTFS_SUPER_MAGIC;
923 sb->s_op = &hostfs_sbops;
924 sb->s_d_op = &simple_dentry_operations;
925 sb->s_maxbytes = MAX_LFS_FILESIZE;
926
927
928 if (req_root == NULL)
929 req_root = "";
930
931 err = -ENOMEM;
932 sb->s_fs_info = host_root_path =
933 kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL);
934 if (host_root_path == NULL)
935 goto out;
936
937 sprintf(host_root_path, "%s/%s", root_ino, req_root);
938
939 root_inode = new_inode(sb);
940 if (!root_inode)
941 goto out;
942
943 err = read_name(root_inode, host_root_path);
944 if (err)
945 goto out_put;
946
947 if (S_ISLNK(root_inode->i_mode)) {
948 char *name = follow_link(host_root_path);
949 if (IS_ERR(name)) {
950 err = PTR_ERR(name);
951 goto out_put;
952 }
953 err = read_name(root_inode, name);
954 kfree(name);
955 if (err)
956 goto out_put;
957 }
958
959 err = -ENOMEM;
960 sb->s_root = d_make_root(root_inode);
961 if (sb->s_root == NULL)
962 goto out;
963
964 return 0;
965
966out_put:
967 iput(root_inode);
968out:
969 return err;
970}
971
972static struct dentry *hostfs_read_sb(struct file_system_type *type,
973 int flags, const char *dev_name,
974 void *data)
975{
976 return mount_nodev(type, flags, data, hostfs_fill_sb_common);
977}
978
979static void hostfs_kill_sb(struct super_block *s)
980{
981 kill_anon_super(s);
982 kfree(s->s_fs_info);
983}
984
985static struct file_system_type hostfs_type = {
986 .owner = THIS_MODULE,
987 .name = "hostfs",
988 .mount = hostfs_read_sb,
989 .kill_sb = hostfs_kill_sb,
990 .fs_flags = 0,
991};
992MODULE_ALIAS_FS("hostfs");
993
994static int __init init_hostfs(void)
995{
996 return register_filesystem(&hostfs_type);
997}
998
999static void __exit exit_hostfs(void)
1000{
1001 unregister_filesystem(&hostfs_type);
1002}
1003
1004module_init(init_hostfs)
1005module_exit(exit_hostfs)
1006MODULE_LICENSE("GPL");
1007
