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