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