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