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 .read_iter = generic_file_read_iter,
385 .write_iter = generic_file_write_iter,
386 .mmap = generic_file_mmap,
387 .open = hostfs_open,
388 .release = hostfs_file_release,
389 .fsync = hostfs_fsync,
390};
391
392static const struct file_operations hostfs_dir_fops = {
393 .llseek = generic_file_llseek,
394 .iterate_shared = hostfs_readdir,
395 .read = generic_read_dir,
396 .open = hostfs_open,
397 .fsync = hostfs_fsync,
398};
399
400static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
401{
402 struct address_space *mapping = page->mapping;
403 struct inode *inode = mapping->host;
404 char *buffer;
405 loff_t base = page_offset(page);
406 int count = PAGE_SIZE;
407 int end_index = inode->i_size >> PAGE_SHIFT;
408 int err;
409
410 if (page->index >= end_index)
411 count = inode->i_size & (PAGE_SIZE-1);
412
413 buffer = kmap(page);
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
435static int hostfs_readpage(struct file *file, struct page *page)
436{
437 char *buffer;
438 loff_t start = page_offset(page);
439 int bytes_read, ret = 0;
440
441 buffer = kmap(page);
442 bytes_read = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
443 PAGE_SIZE);
444 if (bytes_read < 0) {
445 ClearPageUptodate(page);
446 SetPageError(page);
447 ret = bytes_read;
448 goto out;
449 }
450
451 memset(buffer + bytes_read, 0, PAGE_SIZE - bytes_read);
452
453 ClearPageError(page);
454 SetPageUptodate(page);
455
456 out:
457 flush_dcache_page(page);
458 kunmap(page);
459 unlock_page(page);
460 return ret;
461}
462
463static int hostfs_write_begin(struct file *file, struct address_space *mapping,
464 loff_t pos, unsigned len, unsigned flags,
465 struct page **pagep, void **fsdata)
466{
467 pgoff_t index = pos >> PAGE_SHIFT;
468
469 *pagep = grab_cache_page_write_begin(mapping, index, flags);
470 if (!*pagep)
471 return -ENOMEM;
472 return 0;
473}
474
475static int hostfs_write_end(struct file *file, struct address_space *mapping,
476 loff_t pos, unsigned len, unsigned copied,
477 struct page *page, void *fsdata)
478{
479 struct inode *inode = mapping->host;
480 void *buffer;
481 unsigned from = pos & (PAGE_SIZE - 1);
482 int err;
483
484 buffer = kmap(page);
485 err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
486 kunmap(page);
487
488 if (!PageUptodate(page) && err == PAGE_SIZE)
489 SetPageUptodate(page);
490
491
492
493
494
495 if (err > 0 && (pos > inode->i_size))
496 inode->i_size = pos;
497 unlock_page(page);
498 put_page(page);
499
500 return err;
501}
502
503static const struct address_space_operations hostfs_aops = {
504 .writepage = hostfs_writepage,
505 .readpage = hostfs_readpage,
506 .set_page_dirty = __set_page_dirty_nobuffers,
507 .write_begin = hostfs_write_begin,
508 .write_end = hostfs_write_end,
509};
510
511static int read_name(struct inode *ino, char *name)
512{
513 dev_t rdev;
514 struct hostfs_stat st;
515 int err = stat_file(name, &st, -1);
516 if (err)
517 return err;
518
519
520 rdev = MKDEV(st.maj, st.min);
521
522 switch (st.mode & S_IFMT) {
523 case S_IFLNK:
524 ino->i_op = &hostfs_link_iops;
525 break;
526 case S_IFDIR:
527 ino->i_op = &hostfs_dir_iops;
528 ino->i_fop = &hostfs_dir_fops;
529 break;
530 case S_IFCHR:
531 case S_IFBLK:
532 case S_IFIFO:
533 case S_IFSOCK:
534 init_special_inode(ino, st.mode & S_IFMT, rdev);
535 ino->i_op = &hostfs_iops;
536 break;
537 case S_IFREG:
538 ino->i_op = &hostfs_iops;
539 ino->i_fop = &hostfs_file_fops;
540 ino->i_mapping->a_ops = &hostfs_aops;
541 break;
542 default:
543 return -EIO;
544 }
545
546 ino->i_ino = st.ino;
547 ino->i_mode = st.mode;
548 set_nlink(ino, st.nlink);
549 i_uid_write(ino, st.uid);
550 i_gid_write(ino, st.gid);
551 ino->i_atime = (struct timespec64){ st.atime.tv_sec, st.atime.tv_nsec };
552 ino->i_mtime = (struct timespec64){ st.mtime.tv_sec, st.mtime.tv_nsec };
553 ino->i_ctime = (struct timespec64){ st.ctime.tv_sec, st.ctime.tv_nsec };
554 ino->i_size = st.size;
555 ino->i_blocks = st.blocks;
556 return 0;
557}
558
559static int hostfs_create(struct user_namespace *mnt_userns, struct inode *dir,
560 struct dentry *dentry, umode_t mode, bool excl)
561{
562 struct inode *inode;
563 char *name;
564 int error, fd;
565
566 inode = hostfs_iget(dir->i_sb);
567 if (IS_ERR(inode)) {
568 error = PTR_ERR(inode);
569 goto out;
570 }
571
572 error = -ENOMEM;
573 name = dentry_name(dentry);
574 if (name == NULL)
575 goto out_put;
576
577 fd = file_create(name, mode & 0777);
578 if (fd < 0)
579 error = fd;
580 else
581 error = read_name(inode, name);
582
583 __putname(name);
584 if (error)
585 goto out_put;
586
587 HOSTFS_I(inode)->fd = fd;
588 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
589 d_instantiate(dentry, inode);
590 return 0;
591
592 out_put:
593 iput(inode);
594 out:
595 return error;
596}
597
598static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
599 unsigned int flags)
600{
601 struct inode *inode;
602 char *name;
603 int err;
604
605 inode = hostfs_iget(ino->i_sb);
606 if (IS_ERR(inode))
607 goto out;
608
609 err = -ENOMEM;
610 name = dentry_name(dentry);
611 if (name) {
612 err = read_name(inode, name);
613 __putname(name);
614 }
615 if (err) {
616 iput(inode);
617 inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
618 }
619 out:
620 return d_splice_alias(inode, dentry);
621}
622
623static int hostfs_link(struct dentry *to, struct inode *ino,
624 struct dentry *from)
625{
626 char *from_name, *to_name;
627 int err;
628
629 if ((from_name = dentry_name(from)) == NULL)
630 return -ENOMEM;
631 to_name = dentry_name(to);
632 if (to_name == NULL) {
633 __putname(from_name);
634 return -ENOMEM;
635 }
636 err = link_file(to_name, from_name);
637 __putname(from_name);
638 __putname(to_name);
639 return err;
640}
641
642static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
643{
644 char *file;
645 int err;
646
647 if (append)
648 return -EPERM;
649
650 if ((file = dentry_name(dentry)) == NULL)
651 return -ENOMEM;
652
653 err = unlink_file(file);
654 __putname(file);
655 return err;
656}
657
658static int hostfs_symlink(struct user_namespace *mnt_userns, struct inode *ino,
659 struct dentry *dentry, const char *to)
660{
661 char *file;
662 int err;
663
664 if ((file = dentry_name(dentry)) == NULL)
665 return -ENOMEM;
666 err = make_symlink(file, to);
667 __putname(file);
668 return err;
669}
670
671static int hostfs_mkdir(struct user_namespace *mnt_userns, struct inode *ino,
672 struct dentry *dentry, umode_t mode)
673{
674 char *file;
675 int err;
676
677 if ((file = dentry_name(dentry)) == NULL)
678 return -ENOMEM;
679 err = do_mkdir(file, mode);
680 __putname(file);
681 return err;
682}
683
684static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
685{
686 char *file;
687 int err;
688
689 if ((file = dentry_name(dentry)) == NULL)
690 return -ENOMEM;
691 err = hostfs_do_rmdir(file);
692 __putname(file);
693 return err;
694}
695
696static int hostfs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
697 struct dentry *dentry, umode_t mode, dev_t dev)
698{
699 struct inode *inode;
700 char *name;
701 int err;
702
703 inode = hostfs_iget(dir->i_sb);
704 if (IS_ERR(inode)) {
705 err = PTR_ERR(inode);
706 goto out;
707 }
708
709 err = -ENOMEM;
710 name = dentry_name(dentry);
711 if (name == NULL)
712 goto out_put;
713
714 err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
715 if (err)
716 goto out_free;
717
718 err = read_name(inode, name);
719 __putname(name);
720 if (err)
721 goto out_put;
722
723 d_instantiate(dentry, inode);
724 return 0;
725
726 out_free:
727 __putname(name);
728 out_put:
729 iput(inode);
730 out:
731 return err;
732}
733
734static int hostfs_rename2(struct user_namespace *mnt_userns,
735 struct inode *old_dir, struct dentry *old_dentry,
736 struct inode *new_dir, struct dentry *new_dentry,
737 unsigned int flags)
738{
739 char *old_name, *new_name;
740 int err;
741
742 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
743 return -EINVAL;
744
745 old_name = dentry_name(old_dentry);
746 if (old_name == NULL)
747 return -ENOMEM;
748 new_name = dentry_name(new_dentry);
749 if (new_name == NULL) {
750 __putname(old_name);
751 return -ENOMEM;
752 }
753 if (!flags)
754 err = rename_file(old_name, new_name);
755 else
756 err = rename2_file(old_name, new_name, flags);
757
758 __putname(old_name);
759 __putname(new_name);
760 return err;
761}
762
763static int hostfs_permission(struct user_namespace *mnt_userns,
764 struct inode *ino, int desired)
765{
766 char *name;
767 int r = 0, w = 0, x = 0, err;
768
769 if (desired & MAY_NOT_BLOCK)
770 return -ECHILD;
771
772 if (desired & MAY_READ) r = 1;
773 if (desired & MAY_WRITE) w = 1;
774 if (desired & MAY_EXEC) x = 1;
775 name = inode_name(ino);
776 if (name == NULL)
777 return -ENOMEM;
778
779 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
780 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
781 err = 0;
782 else
783 err = access_file(name, r, w, x);
784 __putname(name);
785 if (!err)
786 err = generic_permission(&init_user_ns, ino, desired);
787 return err;
788}
789
790static int hostfs_setattr(struct user_namespace *mnt_userns,
791 struct dentry *dentry, struct iattr *attr)
792{
793 struct inode *inode = d_inode(dentry);
794 struct hostfs_iattr attrs;
795 char *name;
796 int err;
797
798 int fd = HOSTFS_I(inode)->fd;
799
800 err = setattr_prepare(&init_user_ns, dentry, attr);
801 if (err)
802 return err;
803
804 if (append)
805 attr->ia_valid &= ~ATTR_SIZE;
806
807 attrs.ia_valid = 0;
808 if (attr->ia_valid & ATTR_MODE) {
809 attrs.ia_valid |= HOSTFS_ATTR_MODE;
810 attrs.ia_mode = attr->ia_mode;
811 }
812 if (attr->ia_valid & ATTR_UID) {
813 attrs.ia_valid |= HOSTFS_ATTR_UID;
814 attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
815 }
816 if (attr->ia_valid & ATTR_GID) {
817 attrs.ia_valid |= HOSTFS_ATTR_GID;
818 attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
819 }
820 if (attr->ia_valid & ATTR_SIZE) {
821 attrs.ia_valid |= HOSTFS_ATTR_SIZE;
822 attrs.ia_size = attr->ia_size;
823 }
824 if (attr->ia_valid & ATTR_ATIME) {
825 attrs.ia_valid |= HOSTFS_ATTR_ATIME;
826 attrs.ia_atime = (struct hostfs_timespec)
827 { attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec };
828 }
829 if (attr->ia_valid & ATTR_MTIME) {
830 attrs.ia_valid |= HOSTFS_ATTR_MTIME;
831 attrs.ia_mtime = (struct hostfs_timespec)
832 { attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec };
833 }
834 if (attr->ia_valid & ATTR_CTIME) {
835 attrs.ia_valid |= HOSTFS_ATTR_CTIME;
836 attrs.ia_ctime = (struct hostfs_timespec)
837 { attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec };
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(&init_user_ns, 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 kasprintf(GFP_KERNEL, "%s/%s", root_ino, req_root);
934 if (host_root_path == NULL)
935 goto out;
936
937 root_inode = new_inode(sb);
938 if (!root_inode)
939 goto out;
940
941 err = read_name(root_inode, host_root_path);
942 if (err)
943 goto out_put;
944
945 if (S_ISLNK(root_inode->i_mode)) {
946 char *name = follow_link(host_root_path);
947 if (IS_ERR(name)) {
948 err = PTR_ERR(name);
949 goto out_put;
950 }
951 err = read_name(root_inode, name);
952 kfree(name);
953 if (err)
954 goto out_put;
955 }
956
957 err = -ENOMEM;
958 sb->s_root = d_make_root(root_inode);
959 if (sb->s_root == NULL)
960 goto out;
961
962 return 0;
963
964out_put:
965 iput(root_inode);
966out:
967 return err;
968}
969
970static struct dentry *hostfs_read_sb(struct file_system_type *type,
971 int flags, const char *dev_name,
972 void *data)
973{
974 return mount_nodev(type, flags, data, hostfs_fill_sb_common);
975}
976
977static void hostfs_kill_sb(struct super_block *s)
978{
979 kill_anon_super(s);
980 kfree(s->s_fs_info);
981}
982
983static struct file_system_type hostfs_type = {
984 .owner = THIS_MODULE,
985 .name = "hostfs",
986 .mount = hostfs_read_sb,
987 .kill_sb = hostfs_kill_sb,
988 .fs_flags = 0,
989};
990MODULE_ALIAS_FS("hostfs");
991
992static int __init init_hostfs(void)
993{
994 hostfs_inode_cache = KMEM_CACHE(hostfs_inode_info, 0);
995 if (!hostfs_inode_cache)
996 return -ENOMEM;
997 return register_filesystem(&hostfs_type);
998}
999
1000static void __exit exit_hostfs(void)
1001{
1002 unregister_filesystem(&hostfs_type);
1003 kmem_cache_destroy(hostfs_inode_cache);
1004}
1005
1006module_init(init_hostfs)
1007module_exit(exit_hostfs)
1008MODULE_LICENSE("GPL");
1009
