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_free_inode(struct inode *inode)
247{
248 kfree(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->f_path.dentry);
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 .read_iter = generic_file_read_iter,
386 .write_iter = generic_file_write_iter,
387 .mmap = generic_file_mmap,
388 .open = hostfs_open,
389 .release = hostfs_file_release,
390 .fsync = hostfs_fsync,
391};
392
393static const struct file_operations hostfs_dir_fops = {
394 .llseek = generic_file_llseek,
395 .iterate_shared = hostfs_readdir,
396 .read = generic_read_dir,
397 .open = hostfs_open,
398 .fsync = hostfs_fsync,
399};
400
401static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
402{
403 struct address_space *mapping = page->mapping;
404 struct inode *inode = mapping->host;
405 char *buffer;
406 loff_t base = page_offset(page);
407 int count = PAGE_SIZE;
408 int end_index = inode->i_size >> PAGE_SHIFT;
409 int err;
410
411 if (page->index >= end_index)
412 count = inode->i_size & (PAGE_SIZE-1);
413
414 buffer = kmap(page);
415
416 err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
417 if (err != count) {
418 ClearPageUptodate(page);
419 goto out;
420 }
421
422 if (base > inode->i_size)
423 inode->i_size = base;
424
425 if (PageError(page))
426 ClearPageError(page);
427 err = 0;
428
429 out:
430 kunmap(page);
431
432 unlock_page(page);
433 return err;
434}
435
436static int hostfs_readpage(struct file *file, struct page *page)
437{
438 char *buffer;
439 loff_t start = page_offset(page);
440 int bytes_read, ret = 0;
441
442 buffer = kmap(page);
443 bytes_read = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
444 PAGE_SIZE);
445 if (bytes_read < 0) {
446 ClearPageUptodate(page);
447 SetPageError(page);
448 ret = bytes_read;
449 goto out;
450 }
451
452 memset(buffer + bytes_read, 0, PAGE_SIZE - bytes_read);
453
454 ClearPageError(page);
455 SetPageUptodate(page);
456
457 out:
458 flush_dcache_page(page);
459 kunmap(page);
460 unlock_page(page);
461 return ret;
462}
463
464static int hostfs_write_begin(struct file *file, struct address_space *mapping,
465 loff_t pos, unsigned len, unsigned flags,
466 struct page **pagep, void **fsdata)
467{
468 pgoff_t index = pos >> PAGE_SHIFT;
469
470 *pagep = grab_cache_page_write_begin(mapping, index, flags);
471 if (!*pagep)
472 return -ENOMEM;
473 return 0;
474}
475
476static int hostfs_write_end(struct file *file, struct address_space *mapping,
477 loff_t pos, unsigned len, unsigned copied,
478 struct page *page, void *fsdata)
479{
480 struct inode *inode = mapping->host;
481 void *buffer;
482 unsigned from = pos & (PAGE_SIZE - 1);
483 int err;
484
485 buffer = kmap(page);
486 err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
487 kunmap(page);
488
489 if (!PageUptodate(page) && err == PAGE_SIZE)
490 SetPageUptodate(page);
491
492 /*
493 * If err > 0, write_file has added err to pos, so we are comparing
494 * i_size against the last byte written.
495 */
496 if (err > 0 && (pos > inode->i_size))
497 inode->i_size = pos;
498 unlock_page(page);
499 put_page(page);
500
501 return err;
502}
503
504static const struct address_space_operations hostfs_aops = {
505 .writepage = hostfs_writepage,
506 .readpage = hostfs_readpage,
507 .set_page_dirty = __set_page_dirty_nobuffers,
508 .write_begin = hostfs_write_begin,
509 .write_end = hostfs_write_end,
510};
511
512static int read_name(struct inode *ino, char *name)
513{
514 dev_t rdev;
515 struct hostfs_stat st;
516 int err = stat_file(name, &st, -1);
517 if (err)
518 return err;
519
520 /* Reencode maj and min with the kernel encoding.*/
521 rdev = MKDEV(st.maj, st.min);
522
523 switch (st.mode & S_IFMT) {
524 case S_IFLNK:
525 ino->i_op = &hostfs_link_iops;
526 break;
527 case S_IFDIR:
528 ino->i_op = &hostfs_dir_iops;
529 ino->i_fop = &hostfs_dir_fops;
530 break;
531 case S_IFCHR:
532 case S_IFBLK:
533 case S_IFIFO:
534 case S_IFSOCK:
535 init_special_inode(ino, st.mode & S_IFMT, rdev);
536 ino->i_op = &hostfs_iops;
537 break;
538 case S_IFREG:
539 ino->i_op = &hostfs_iops;
540 ino->i_fop = &hostfs_file_fops;
541 ino->i_mapping->a_ops = &hostfs_aops;
542 break;
543 default:
544 return -EIO;
545 }
546
547 ino->i_ino = st.ino;
548 ino->i_mode = st.mode;
549 set_nlink(ino, st.nlink);
550 i_uid_write(ino, st.uid);
551 i_gid_write(ino, st.gid);
552 ino->i_atime = timespec_to_timespec64(st.atime);
553 ino->i_mtime = timespec_to_timespec64(st.mtime);
554 ino->i_ctime = timespec_to_timespec64(st.ctime);
555 ino->i_size = st.size;
556 ino->i_blocks = st.blocks;
557 return 0;
558}
559
560static int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
561 bool excl)
562{
563 struct inode *inode;
564 char *name;
565 int error, fd;
566
567 inode = hostfs_iget(dir->i_sb);
568 if (IS_ERR(inode)) {
569 error = PTR_ERR(inode);
570 goto out;
571 }
572
573 error = -ENOMEM;
574 name = dentry_name(dentry);
575 if (name == NULL)
576 goto out_put;
577
578 fd = file_create(name, mode & 0777);
579 if (fd < 0)
580 error = fd;
581 else
582 error = read_name(inode, name);
583
584 __putname(name);
585 if (error)
586 goto out_put;
587
588 HOSTFS_I(inode)->fd = fd;
589 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
590 d_instantiate(dentry, inode);
591 return 0;
592
593 out_put:
594 iput(inode);
595 out:
596 return error;
597}
598
599static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
600 unsigned int flags)
601{
602 struct inode *inode;
603 char *name;
604 int err;
605
606 inode = hostfs_iget(ino->i_sb);
607 if (IS_ERR(inode))
608 goto out;
609
610 err = -ENOMEM;
611 name = dentry_name(dentry);
612 if (name) {
613 err = read_name(inode, name);
614 __putname(name);
615 }
616 if (err) {
617 iput(inode);
618 inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
619 }
620 out:
621 return d_splice_alias(inode, dentry);
622}
623
624static int hostfs_link(struct dentry *to, struct inode *ino,
625 struct dentry *from)
626{
627 char *from_name, *to_name;
628 int err;
629
630 if ((from_name = dentry_name(from)) == NULL)
631 return -ENOMEM;
632 to_name = dentry_name(to);
633 if (to_name == NULL) {
634 __putname(from_name);
635 return -ENOMEM;
636 }
637 err = link_file(to_name, from_name);
638 __putname(from_name);
639 __putname(to_name);
640 return err;
641}
642
643static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
644{
645 char *file;
646 int err;
647
648 if (append)
649 return -EPERM;
650
651 if ((file = dentry_name(dentry)) == NULL)
652 return -ENOMEM;
653
654 err = unlink_file(file);
655 __putname(file);
656 return err;
657}
658
659static int hostfs_symlink(struct inode *ino, struct dentry *dentry,
660 const char *to)
661{
662 char *file;
663 int err;
664
665 if ((file = dentry_name(dentry)) == NULL)
666 return -ENOMEM;
667 err = make_symlink(file, to);
668 __putname(file);
669 return err;
670}
671
672static int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
673{
674 char *file;
675 int err;
676
677 if ((file = dentry_name(dentry)) == NULL)
678 return -ENOMEM;
679 err = do_mkdir(file, mode);
680 __putname(file);
681 return err;
682}
683
684static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
685{
686 char *file;
687 int err;
688
689 if ((file = dentry_name(dentry)) == NULL)
690 return -ENOMEM;
691 err = hostfs_do_rmdir(file);
692 __putname(file);
693 return err;
694}
695
696static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
697{
698 struct inode *inode;
699 char *name;
700 int err;
701
702 inode = hostfs_iget(dir->i_sb);
703 if (IS_ERR(inode)) {
704 err = PTR_ERR(inode);
705 goto out;
706 }
707
708 err = -ENOMEM;
709 name = dentry_name(dentry);
710 if (name == NULL)
711 goto out_put;
712
713 init_special_inode(inode, mode, dev);
714 err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
715 if (err)
716 goto out_free;
717
718 err = read_name(inode, name);
719 __putname(name);
720 if (err)
721 goto out_put;
722
723 d_instantiate(dentry, inode);
724 return 0;
725
726 out_free:
727 __putname(name);
728 out_put:
729 iput(inode);
730 out:
731 return err;
732}
733
734static int hostfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
735 struct inode *new_dir, struct dentry *new_dentry,
736 unsigned int flags)
737{
738 char *old_name, *new_name;
739 int err;
740
741 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
742 return -EINVAL;
743
744 old_name = dentry_name(old_dentry);
745 if (old_name == NULL)
746 return -ENOMEM;
747 new_name = dentry_name(new_dentry);
748 if (new_name == NULL) {
749 __putname(old_name);
750 return -ENOMEM;
751 }
752 if (!flags)
753 err = rename_file(old_name, new_name);
754 else
755 err = rename2_file(old_name, new_name, flags);
756
757 __putname(old_name);
758 __putname(new_name);
759 return err;
760}
761
762static int hostfs_permission(struct inode *ino, int desired)
763{
764 char *name;
765 int r = 0, w = 0, x = 0, err;
766
767 if (desired & MAY_NOT_BLOCK)
768 return -ECHILD;
769
770 if (desired & MAY_READ) r = 1;
771 if (desired & MAY_WRITE) w = 1;
772 if (desired & MAY_EXEC) x = 1;
773 name = inode_name(ino);
774 if (name == NULL)
775 return -ENOMEM;
776
777 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
778 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
779 err = 0;
780 else
781 err = access_file(name, r, w, x);
782 __putname(name);
783 if (!err)
784 err = generic_permission(ino, desired);
785 return err;
786}
787
788static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
789{
790 struct inode *inode = d_inode(dentry);
791 struct hostfs_iattr attrs;
792 char *name;
793 int err;
794
795 int fd = HOSTFS_I(inode)->fd;
796
797 err = setattr_prepare(dentry, attr);
798 if (err)
799 return err;
800
801 if (append)
802 attr->ia_valid &= ~ATTR_SIZE;
803
804 attrs.ia_valid = 0;
805 if (attr->ia_valid & ATTR_MODE) {
806 attrs.ia_valid |= HOSTFS_ATTR_MODE;
807 attrs.ia_mode = attr->ia_mode;
808 }
809 if (attr->ia_valid & ATTR_UID) {
810 attrs.ia_valid |= HOSTFS_ATTR_UID;
811 attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
812 }
813 if (attr->ia_valid & ATTR_GID) {
814 attrs.ia_valid |= HOSTFS_ATTR_GID;
815 attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
816 }
817 if (attr->ia_valid & ATTR_SIZE) {
818 attrs.ia_valid |= HOSTFS_ATTR_SIZE;
819 attrs.ia_size = attr->ia_size;
820 }
821 if (attr->ia_valid & ATTR_ATIME) {
822 attrs.ia_valid |= HOSTFS_ATTR_ATIME;
823 attrs.ia_atime = timespec64_to_timespec(attr->ia_atime);
824 }
825 if (attr->ia_valid & ATTR_MTIME) {
826 attrs.ia_valid |= HOSTFS_ATTR_MTIME;
827 attrs.ia_mtime = timespec64_to_timespec(attr->ia_mtime);
828 }
829 if (attr->ia_valid & ATTR_CTIME) {
830 attrs.ia_valid |= HOSTFS_ATTR_CTIME;
831 attrs.ia_ctime = timespec64_to_timespec(attr->ia_ctime);
832 }
833 if (attr->ia_valid & ATTR_ATIME_SET) {
834 attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
835 }
836 if (attr->ia_valid & ATTR_MTIME_SET) {
837 attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
838 }
839 name = dentry_name(dentry);
840 if (name == NULL)
841 return -ENOMEM;
842 err = set_attr(name, &attrs, fd);
843 __putname(name);
844 if (err)
845 return err;
846
847 if ((attr->ia_valid & ATTR_SIZE) &&
848 attr->ia_size != i_size_read(inode))
849 truncate_setsize(inode, attr->ia_size);
850
851 setattr_copy(inode, attr);
852 mark_inode_dirty(inode);
853 return 0;
854}
855
856static const struct inode_operations hostfs_iops = {
857 .permission = hostfs_permission,
858 .setattr = hostfs_setattr,
859};
860
861static const struct inode_operations hostfs_dir_iops = {
862 .create = hostfs_create,
863 .lookup = hostfs_lookup,
864 .link = hostfs_link,
865 .unlink = hostfs_unlink,
866 .symlink = hostfs_symlink,
867 .mkdir = hostfs_mkdir,
868 .rmdir = hostfs_rmdir,
869 .mknod = hostfs_mknod,
870 .rename = hostfs_rename2,
871 .permission = hostfs_permission,
872 .setattr = hostfs_setattr,
873};
874
875static const char *hostfs_get_link(struct dentry *dentry,
876 struct inode *inode,
877 struct delayed_call *done)
878{
879 char *link;
880 if (!dentry)
881 return ERR_PTR(-ECHILD);
882 link = kmalloc(PATH_MAX, GFP_KERNEL);
883 if (link) {
884 char *path = dentry_name(dentry);
885 int err = -ENOMEM;
886 if (path) {
887 err = hostfs_do_readlink(path, link, PATH_MAX);
888 if (err == PATH_MAX)
889 err = -E2BIG;
890 __putname(path);
891 }
892 if (err < 0) {
893 kfree(link);
894 return ERR_PTR(err);
895 }
896 } else {
897 return ERR_PTR(-ENOMEM);
898 }
899
900 set_delayed_call(done, kfree_link, link);
901 return link;
902}
903
904static const struct inode_operations hostfs_link_iops = {
905 .get_link = hostfs_get_link,
906};
907
908static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
909{
910 struct inode *root_inode;
911 char *host_root_path, *req_root = d;
912 int err;
913
914 sb->s_blocksize = 1024;
915 sb->s_blocksize_bits = 10;
916 sb->s_magic = HOSTFS_SUPER_MAGIC;
917 sb->s_op = &hostfs_sbops;
918 sb->s_d_op = &simple_dentry_operations;
919 sb->s_maxbytes = MAX_LFS_FILESIZE;
920
921 /* NULL is printed as <NULL> by sprintf: avoid that. */
922 if (req_root == NULL)
923 req_root = "";
924
925 err = -ENOMEM;
926 sb->s_fs_info = host_root_path =
927 kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL);
928 if (host_root_path == NULL)
929 goto out;
930
931 sprintf(host_root_path, "%s/%s", root_ino, req_root);
932
933 root_inode = new_inode(sb);
934 if (!root_inode)
935 goto out;
936
937 err = read_name(root_inode, host_root_path);
938 if (err)
939 goto out_put;
940
941 if (S_ISLNK(root_inode->i_mode)) {
942 char *name = follow_link(host_root_path);
943 if (IS_ERR(name)) {
944 err = PTR_ERR(name);
945 goto out_put;
946 }
947 err = read_name(root_inode, name);
948 kfree(name);
949 if (err)
950 goto out_put;
951 }
952
953 err = -ENOMEM;
954 sb->s_root = d_make_root(root_inode);
955 if (sb->s_root == NULL)
956 goto out;
957
958 return 0;
959
960out_put:
961 iput(root_inode);
962out:
963 return err;
964}
965
966static struct dentry *hostfs_read_sb(struct file_system_type *type,
967 int flags, const char *dev_name,
968 void *data)
969{
970 return mount_nodev(type, flags, data, hostfs_fill_sb_common);
971}
972
973static void hostfs_kill_sb(struct super_block *s)
974{
975 kill_anon_super(s);
976 kfree(s->s_fs_info);
977}
978
979static struct file_system_type hostfs_type = {
980 .owner = THIS_MODULE,
981 .name = "hostfs",
982 .mount = hostfs_read_sb,
983 .kill_sb = hostfs_kill_sb,
984 .fs_flags = 0,
985};
986MODULE_ALIAS_FS("hostfs");
987
988static int __init init_hostfs(void)
989{
990 return register_filesystem(&hostfs_type);
991}
992
993static void __exit exit_hostfs(void)
994{
995 unregister_filesystem(&hostfs_type);
996}
997
998module_init(init_hostfs)
999module_exit(exit_hostfs)
1000MODULE_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/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 = filemap_write_and_wait_range(inode->i_mapping, 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 = 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 = 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 = inode_change_ok(inode, 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 .rename2 = 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 .readlink = generic_readlink,
924 .get_link = hostfs_get_link,
925};
926
927static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
928{
929 struct inode *root_inode;
930 char *host_root_path, *req_root = d;
931 int err;
932
933 sb->s_blocksize = 1024;
934 sb->s_blocksize_bits = 10;
935 sb->s_magic = HOSTFS_SUPER_MAGIC;
936 sb->s_op = &hostfs_sbops;
937 sb->s_d_op = &simple_dentry_operations;
938 sb->s_maxbytes = MAX_LFS_FILESIZE;
939
940 /* NULL is printed as <NULL> by sprintf: avoid that. */
941 if (req_root == NULL)
942 req_root = "";
943
944 err = -ENOMEM;
945 sb->s_fs_info = host_root_path =
946 kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL);
947 if (host_root_path == NULL)
948 goto out;
949
950 sprintf(host_root_path, "%s/%s", root_ino, req_root);
951
952 root_inode = new_inode(sb);
953 if (!root_inode)
954 goto out;
955
956 err = read_name(root_inode, host_root_path);
957 if (err)
958 goto out_put;
959
960 if (S_ISLNK(root_inode->i_mode)) {
961 char *name = follow_link(host_root_path);
962 if (IS_ERR(name))
963 err = PTR_ERR(name);
964 else
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");