• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
23 struct hostfs_inode_info {
24 	int fd;
25 	fmode_t mode;
26 	struct inode vfs_inode;
27 	struct mutex open_mutex;
28 };
29 
HOSTFS_I(struct inode * inode)30 static 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 */
38 static char *root_ino = "";
39 static int append = 0;
40 
41 static const struct inode_operations hostfs_iops;
42 static const struct inode_operations hostfs_dir_iops;
43 static const struct inode_operations hostfs_link_iops;
44 
45 #ifndef MODULE
hostfs_args(char * options,int * add)46 static 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 
__dentry_name(struct dentry * dentry,char * name)84 static 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 
dentry_name(struct dentry * dentry)115 static 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 
inode_name(struct inode * ino)124 static 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 
follow_link(char * link)140 static char *follow_link(char *link)
141 {
142 	char *name, *resolved, *end;
143 	int n;
144 
145 	name = kmalloc(PATH_MAX, GFP_KERNEL);
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 
168 	resolved = kasprintf(GFP_KERNEL, "%s%s", link, name);
169 	if (resolved == NULL) {
170 		n = -ENOMEM;
171 		goto out_free;
172 	}
173 
174 	kfree(name);
175 	return resolved;
176 
177  out_free:
178 	kfree(name);
179 	return ERR_PTR(n);
180 }
181 
hostfs_iget(struct super_block * sb)182 static struct inode *hostfs_iget(struct super_block *sb)
183 {
184 	struct inode *inode = new_inode(sb);
185 	if (!inode)
186 		return ERR_PTR(-ENOMEM);
187 	return inode;
188 }
189 
hostfs_statfs(struct dentry * dentry,struct kstatfs * sf)190 static int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
191 {
192 	/*
193 	 * do_statfs uses struct statfs64 internally, but the linux kernel
194 	 * struct statfs still has 32-bit versions for most of these fields,
195 	 * so we convert them here
196 	 */
197 	int err;
198 	long long f_blocks;
199 	long long f_bfree;
200 	long long f_bavail;
201 	long long f_files;
202 	long long f_ffree;
203 
204 	err = do_statfs(dentry->d_sb->s_fs_info,
205 			&sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
206 			&f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
207 			&sf->f_namelen);
208 	if (err)
209 		return err;
210 	sf->f_blocks = f_blocks;
211 	sf->f_bfree = f_bfree;
212 	sf->f_bavail = f_bavail;
213 	sf->f_files = f_files;
214 	sf->f_ffree = f_ffree;
215 	sf->f_type = HOSTFS_SUPER_MAGIC;
216 	return 0;
217 }
218 
hostfs_alloc_inode(struct super_block * sb)219 static struct inode *hostfs_alloc_inode(struct super_block *sb)
220 {
221 	struct hostfs_inode_info *hi;
222 
223 	hi = kmalloc(sizeof(*hi), GFP_KERNEL_ACCOUNT);
224 	if (hi == NULL)
225 		return NULL;
226 	hi->fd = -1;
227 	hi->mode = 0;
228 	inode_init_once(&hi->vfs_inode);
229 	mutex_init(&hi->open_mutex);
230 	return &hi->vfs_inode;
231 }
232 
hostfs_evict_inode(struct inode * inode)233 static void hostfs_evict_inode(struct inode *inode)
234 {
235 	truncate_inode_pages_final(&inode->i_data);
236 	clear_inode(inode);
237 	if (HOSTFS_I(inode)->fd != -1) {
238 		close_file(&HOSTFS_I(inode)->fd);
239 		HOSTFS_I(inode)->fd = -1;
240 	}
241 }
242 
hostfs_free_inode(struct inode * inode)243 static void hostfs_free_inode(struct inode *inode)
244 {
245 	kfree(HOSTFS_I(inode));
246 }
247 
hostfs_show_options(struct seq_file * seq,struct dentry * root)248 static int hostfs_show_options(struct seq_file *seq, struct dentry *root)
249 {
250 	const char *root_path = root->d_sb->s_fs_info;
251 	size_t offset = strlen(root_ino) + 1;
252 
253 	if (strlen(root_path) > offset)
254 		seq_show_option(seq, root_path + offset, NULL);
255 
256 	if (append)
257 		seq_puts(seq, ",append");
258 
259 	return 0;
260 }
261 
262 static const struct super_operations hostfs_sbops = {
263 	.alloc_inode	= hostfs_alloc_inode,
264 	.free_inode	= hostfs_free_inode,
265 	.evict_inode	= hostfs_evict_inode,
266 	.statfs		= hostfs_statfs,
267 	.show_options	= hostfs_show_options,
268 };
269 
hostfs_readdir(struct file * file,struct dir_context * ctx)270 static int hostfs_readdir(struct file *file, struct dir_context *ctx)
271 {
272 	void *dir;
273 	char *name;
274 	unsigned long long next, ino;
275 	int error, len;
276 	unsigned int type;
277 
278 	name = dentry_name(file->f_path.dentry);
279 	if (name == NULL)
280 		return -ENOMEM;
281 	dir = open_dir(name, &error);
282 	__putname(name);
283 	if (dir == NULL)
284 		return -error;
285 	next = ctx->pos;
286 	seek_dir(dir, next);
287 	while ((name = read_dir(dir, &next, &ino, &len, &type)) != NULL) {
288 		if (!dir_emit(ctx, name, len, ino, type))
289 			break;
290 		ctx->pos = next;
291 	}
292 	close_dir(dir);
293 	return 0;
294 }
295 
hostfs_open(struct inode * ino,struct file * file)296 static int hostfs_open(struct inode *ino, struct file *file)
297 {
298 	char *name;
299 	fmode_t mode;
300 	int err;
301 	int r, w, fd;
302 
303 	mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
304 	if ((mode & HOSTFS_I(ino)->mode) == mode)
305 		return 0;
306 
307 	mode |= HOSTFS_I(ino)->mode;
308 
309 retry:
310 	r = w = 0;
311 
312 	if (mode & FMODE_READ)
313 		r = 1;
314 	if (mode & FMODE_WRITE)
315 		r = w = 1;
316 
317 	name = dentry_name(file->f_path.dentry);
318 	if (name == NULL)
319 		return -ENOMEM;
320 
321 	fd = open_file(name, r, w, append);
322 	__putname(name);
323 	if (fd < 0)
324 		return fd;
325 
326 	mutex_lock(&HOSTFS_I(ino)->open_mutex);
327 	/* somebody else had handled it first? */
328 	if ((mode & HOSTFS_I(ino)->mode) == mode) {
329 		mutex_unlock(&HOSTFS_I(ino)->open_mutex);
330 		close_file(&fd);
331 		return 0;
332 	}
333 	if ((mode | HOSTFS_I(ino)->mode) != mode) {
334 		mode |= HOSTFS_I(ino)->mode;
335 		mutex_unlock(&HOSTFS_I(ino)->open_mutex);
336 		close_file(&fd);
337 		goto retry;
338 	}
339 	if (HOSTFS_I(ino)->fd == -1) {
340 		HOSTFS_I(ino)->fd = fd;
341 	} else {
342 		err = replace_file(fd, HOSTFS_I(ino)->fd);
343 		close_file(&fd);
344 		if (err < 0) {
345 			mutex_unlock(&HOSTFS_I(ino)->open_mutex);
346 			return err;
347 		}
348 	}
349 	HOSTFS_I(ino)->mode = mode;
350 	mutex_unlock(&HOSTFS_I(ino)->open_mutex);
351 
352 	return 0;
353 }
354 
hostfs_file_release(struct inode * inode,struct file * file)355 static int hostfs_file_release(struct inode *inode, struct file *file)
356 {
357 	filemap_write_and_wait(inode->i_mapping);
358 
359 	return 0;
360 }
361 
hostfs_fsync(struct file * file,loff_t start,loff_t end,int datasync)362 static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
363 			int datasync)
364 {
365 	struct inode *inode = file->f_mapping->host;
366 	int ret;
367 
368 	ret = file_write_and_wait_range(file, start, end);
369 	if (ret)
370 		return ret;
371 
372 	inode_lock(inode);
373 	ret = fsync_file(HOSTFS_I(inode)->fd, datasync);
374 	inode_unlock(inode);
375 
376 	return ret;
377 }
378 
379 static const struct file_operations hostfs_file_fops = {
380 	.llseek		= generic_file_llseek,
381 	.splice_read	= generic_file_splice_read,
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 
390 static 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 
hostfs_writepage(struct page * page,struct writeback_control * wbc)398 static 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(page);
412 
413 	err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
414 	if (err != count) {
415 		ClearPageUptodate(page);
416 		goto out;
417 	}
418 
419 	if (base > inode->i_size)
420 		inode->i_size = base;
421 
422 	if (PageError(page))
423 		ClearPageError(page);
424 	err = 0;
425 
426  out:
427 	kunmap(page);
428 
429 	unlock_page(page);
430 	return err;
431 }
432 
hostfs_readpage(struct file * file,struct page * page)433 static int hostfs_readpage(struct file *file, struct page *page)
434 {
435 	char *buffer;
436 	loff_t start = page_offset(page);
437 	int bytes_read, ret = 0;
438 
439 	buffer = kmap(page);
440 	bytes_read = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
441 			PAGE_SIZE);
442 	if (bytes_read < 0) {
443 		ClearPageUptodate(page);
444 		SetPageError(page);
445 		ret = bytes_read;
446 		goto out;
447 	}
448 
449 	memset(buffer + bytes_read, 0, PAGE_SIZE - bytes_read);
450 
451 	ClearPageError(page);
452 	SetPageUptodate(page);
453 
454  out:
455 	flush_dcache_page(page);
456 	kunmap(page);
457 	unlock_page(page);
458 	return ret;
459 }
460 
hostfs_write_begin(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,unsigned flags,struct page ** pagep,void ** fsdata)461 static int hostfs_write_begin(struct file *file, struct address_space *mapping,
462 			      loff_t pos, unsigned len, unsigned flags,
463 			      struct page **pagep, void **fsdata)
464 {
465 	pgoff_t index = pos >> PAGE_SHIFT;
466 
467 	*pagep = grab_cache_page_write_begin(mapping, index, flags);
468 	if (!*pagep)
469 		return -ENOMEM;
470 	return 0;
471 }
472 
hostfs_write_end(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,unsigned copied,struct page * page,void * fsdata)473 static int hostfs_write_end(struct file *file, struct address_space *mapping,
474 			    loff_t pos, unsigned len, unsigned copied,
475 			    struct page *page, void *fsdata)
476 {
477 	struct inode *inode = mapping->host;
478 	void *buffer;
479 	unsigned from = pos & (PAGE_SIZE - 1);
480 	int err;
481 
482 	buffer = kmap(page);
483 	err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
484 	kunmap(page);
485 
486 	if (!PageUptodate(page) && err == PAGE_SIZE)
487 		SetPageUptodate(page);
488 
489 	/*
490 	 * If err > 0, write_file has added err to pos, so we are comparing
491 	 * i_size against the last byte written.
492 	 */
493 	if (err > 0 && (pos > inode->i_size))
494 		inode->i_size = pos;
495 	unlock_page(page);
496 	put_page(page);
497 
498 	return err;
499 }
500 
501 static const struct address_space_operations hostfs_aops = {
502 	.writepage 	= hostfs_writepage,
503 	.readpage	= hostfs_readpage,
504 	.set_page_dirty = __set_page_dirty_nobuffers,
505 	.write_begin	= hostfs_write_begin,
506 	.write_end	= hostfs_write_end,
507 };
508 
read_name(struct inode * ino,char * name)509 static int read_name(struct inode *ino, char *name)
510 {
511 	dev_t rdev;
512 	struct hostfs_stat st;
513 	int err = stat_file(name, &st, -1);
514 	if (err)
515 		return err;
516 
517 	/* Reencode maj and min with the kernel encoding.*/
518 	rdev = MKDEV(st.maj, st.min);
519 
520 	switch (st.mode & S_IFMT) {
521 	case S_IFLNK:
522 		ino->i_op = &hostfs_link_iops;
523 		break;
524 	case S_IFDIR:
525 		ino->i_op = &hostfs_dir_iops;
526 		ino->i_fop = &hostfs_dir_fops;
527 		break;
528 	case S_IFCHR:
529 	case S_IFBLK:
530 	case S_IFIFO:
531 	case S_IFSOCK:
532 		init_special_inode(ino, st.mode & S_IFMT, rdev);
533 		ino->i_op = &hostfs_iops;
534 		break;
535 	case S_IFREG:
536 		ino->i_op = &hostfs_iops;
537 		ino->i_fop = &hostfs_file_fops;
538 		ino->i_mapping->a_ops = &hostfs_aops;
539 		break;
540 	default:
541 		return -EIO;
542 	}
543 
544 	ino->i_ino = st.ino;
545 	ino->i_mode = st.mode;
546 	set_nlink(ino, st.nlink);
547 	i_uid_write(ino, st.uid);
548 	i_gid_write(ino, st.gid);
549 	ino->i_atime = (struct timespec64){ st.atime.tv_sec, st.atime.tv_nsec };
550 	ino->i_mtime = (struct timespec64){ st.mtime.tv_sec, st.mtime.tv_nsec };
551 	ino->i_ctime = (struct timespec64){ st.ctime.tv_sec, st.ctime.tv_nsec };
552 	ino->i_size = st.size;
553 	ino->i_blocks = st.blocks;
554 	return 0;
555 }
556 
hostfs_create(struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)557 static int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
558 			 bool excl)
559 {
560 	struct inode *inode;
561 	char *name;
562 	int error, fd;
563 
564 	inode = hostfs_iget(dir->i_sb);
565 	if (IS_ERR(inode)) {
566 		error = PTR_ERR(inode);
567 		goto out;
568 	}
569 
570 	error = -ENOMEM;
571 	name = dentry_name(dentry);
572 	if (name == NULL)
573 		goto out_put;
574 
575 	fd = file_create(name, mode & 0777);
576 	if (fd < 0)
577 		error = fd;
578 	else
579 		error = read_name(inode, name);
580 
581 	__putname(name);
582 	if (error)
583 		goto out_put;
584 
585 	HOSTFS_I(inode)->fd = fd;
586 	HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
587 	d_instantiate(dentry, inode);
588 	return 0;
589 
590  out_put:
591 	iput(inode);
592  out:
593 	return error;
594 }
595 
hostfs_lookup(struct inode * ino,struct dentry * dentry,unsigned int flags)596 static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
597 				    unsigned int flags)
598 {
599 	struct inode *inode;
600 	char *name;
601 	int err;
602 
603 	inode = hostfs_iget(ino->i_sb);
604 	if (IS_ERR(inode))
605 		goto out;
606 
607 	err = -ENOMEM;
608 	name = dentry_name(dentry);
609 	if (name) {
610 		err = read_name(inode, name);
611 		__putname(name);
612 	}
613 	if (err) {
614 		iput(inode);
615 		inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
616 	}
617  out:
618 	return d_splice_alias(inode, dentry);
619 }
620 
hostfs_link(struct dentry * to,struct inode * ino,struct dentry * from)621 static int hostfs_link(struct dentry *to, struct inode *ino,
622 		       struct dentry *from)
623 {
624 	char *from_name, *to_name;
625 	int err;
626 
627 	if ((from_name = dentry_name(from)) == NULL)
628 		return -ENOMEM;
629 	to_name = dentry_name(to);
630 	if (to_name == NULL) {
631 		__putname(from_name);
632 		return -ENOMEM;
633 	}
634 	err = link_file(to_name, from_name);
635 	__putname(from_name);
636 	__putname(to_name);
637 	return err;
638 }
639 
hostfs_unlink(struct inode * ino,struct dentry * dentry)640 static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
641 {
642 	char *file;
643 	int err;
644 
645 	if (append)
646 		return -EPERM;
647 
648 	if ((file = dentry_name(dentry)) == NULL)
649 		return -ENOMEM;
650 
651 	err = unlink_file(file);
652 	__putname(file);
653 	return err;
654 }
655 
hostfs_symlink(struct inode * ino,struct dentry * dentry,const char * to)656 static int hostfs_symlink(struct inode *ino, struct dentry *dentry,
657 			  const char *to)
658 {
659 	char *file;
660 	int err;
661 
662 	if ((file = dentry_name(dentry)) == NULL)
663 		return -ENOMEM;
664 	err = make_symlink(file, to);
665 	__putname(file);
666 	return err;
667 }
668 
hostfs_mkdir(struct inode * ino,struct dentry * dentry,umode_t mode)669 static int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
670 {
671 	char *file;
672 	int err;
673 
674 	if ((file = dentry_name(dentry)) == NULL)
675 		return -ENOMEM;
676 	err = do_mkdir(file, mode);
677 	__putname(file);
678 	return err;
679 }
680 
hostfs_rmdir(struct inode * ino,struct dentry * dentry)681 static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
682 {
683 	char *file;
684 	int err;
685 
686 	if ((file = dentry_name(dentry)) == NULL)
687 		return -ENOMEM;
688 	err = hostfs_do_rmdir(file);
689 	__putname(file);
690 	return err;
691 }
692 
hostfs_mknod(struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)693 static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
694 {
695 	struct inode *inode;
696 	char *name;
697 	int err;
698 
699 	inode = hostfs_iget(dir->i_sb);
700 	if (IS_ERR(inode)) {
701 		err = PTR_ERR(inode);
702 		goto out;
703 	}
704 
705 	err = -ENOMEM;
706 	name = dentry_name(dentry);
707 	if (name == NULL)
708 		goto out_put;
709 
710 	init_special_inode(inode, mode, dev);
711 	err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
712 	if (err)
713 		goto out_free;
714 
715 	err = read_name(inode, name);
716 	__putname(name);
717 	if (err)
718 		goto out_put;
719 
720 	d_instantiate(dentry, inode);
721 	return 0;
722 
723  out_free:
724 	__putname(name);
725  out_put:
726 	iput(inode);
727  out:
728 	return err;
729 }
730 
hostfs_rename2(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)731 static int hostfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
732 			  struct inode *new_dir, struct dentry *new_dentry,
733 			  unsigned int flags)
734 {
735 	char *old_name, *new_name;
736 	int err;
737 
738 	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
739 		return -EINVAL;
740 
741 	old_name = dentry_name(old_dentry);
742 	if (old_name == NULL)
743 		return -ENOMEM;
744 	new_name = dentry_name(new_dentry);
745 	if (new_name == NULL) {
746 		__putname(old_name);
747 		return -ENOMEM;
748 	}
749 	if (!flags)
750 		err = rename_file(old_name, new_name);
751 	else
752 		err = rename2_file(old_name, new_name, flags);
753 
754 	__putname(old_name);
755 	__putname(new_name);
756 	return err;
757 }
758 
hostfs_permission(struct inode * ino,int desired)759 static int hostfs_permission(struct inode *ino, int desired)
760 {
761 	char *name;
762 	int r = 0, w = 0, x = 0, err;
763 
764 	if (desired & MAY_NOT_BLOCK)
765 		return -ECHILD;
766 
767 	if (desired & MAY_READ) r = 1;
768 	if (desired & MAY_WRITE) w = 1;
769 	if (desired & MAY_EXEC) x = 1;
770 	name = inode_name(ino);
771 	if (name == NULL)
772 		return -ENOMEM;
773 
774 	if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
775 	    S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
776 		err = 0;
777 	else
778 		err = access_file(name, r, w, x);
779 	__putname(name);
780 	if (!err)
781 		err = generic_permission(ino, desired);
782 	return err;
783 }
784 
hostfs_setattr(struct dentry * dentry,struct iattr * attr)785 static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
786 {
787 	struct inode *inode = d_inode(dentry);
788 	struct hostfs_iattr attrs;
789 	char *name;
790 	int err;
791 
792 	int fd = HOSTFS_I(inode)->fd;
793 
794 	err = setattr_prepare(dentry, attr);
795 	if (err)
796 		return err;
797 
798 	if (append)
799 		attr->ia_valid &= ~ATTR_SIZE;
800 
801 	attrs.ia_valid = 0;
802 	if (attr->ia_valid & ATTR_MODE) {
803 		attrs.ia_valid |= HOSTFS_ATTR_MODE;
804 		attrs.ia_mode = attr->ia_mode;
805 	}
806 	if (attr->ia_valid & ATTR_UID) {
807 		attrs.ia_valid |= HOSTFS_ATTR_UID;
808 		attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
809 	}
810 	if (attr->ia_valid & ATTR_GID) {
811 		attrs.ia_valid |= HOSTFS_ATTR_GID;
812 		attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
813 	}
814 	if (attr->ia_valid & ATTR_SIZE) {
815 		attrs.ia_valid |= HOSTFS_ATTR_SIZE;
816 		attrs.ia_size = attr->ia_size;
817 	}
818 	if (attr->ia_valid & ATTR_ATIME) {
819 		attrs.ia_valid |= HOSTFS_ATTR_ATIME;
820 		attrs.ia_atime = (struct hostfs_timespec)
821 			{ attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec };
822 	}
823 	if (attr->ia_valid & ATTR_MTIME) {
824 		attrs.ia_valid |= HOSTFS_ATTR_MTIME;
825 		attrs.ia_mtime = (struct hostfs_timespec)
826 			{ attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec };
827 	}
828 	if (attr->ia_valid & ATTR_CTIME) {
829 		attrs.ia_valid |= HOSTFS_ATTR_CTIME;
830 		attrs.ia_ctime = (struct hostfs_timespec)
831 			{ attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec };
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 
856 static const struct inode_operations hostfs_iops = {
857 	.permission	= hostfs_permission,
858 	.setattr	= hostfs_setattr,
859 };
860 
861 static 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 
hostfs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)875 static 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 
904 static const struct inode_operations hostfs_link_iops = {
905 	.get_link	= hostfs_get_link,
906 };
907 
hostfs_fill_sb_common(struct super_block * sb,void * d,int silent)908 static 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 printf(): avoid that. */
922 	if (req_root == NULL)
923 		req_root = "";
924 
925 	err = -ENOMEM;
926 	sb->s_fs_info = host_root_path =
927 		kasprintf(GFP_KERNEL, "%s/%s", root_ino, req_root);
928 	if (host_root_path == NULL)
929 		goto out;
930 
931 	root_inode = new_inode(sb);
932 	if (!root_inode)
933 		goto out;
934 
935 	err = read_name(root_inode, host_root_path);
936 	if (err)
937 		goto out_put;
938 
939 	if (S_ISLNK(root_inode->i_mode)) {
940 		char *name = follow_link(host_root_path);
941 		if (IS_ERR(name)) {
942 			err = PTR_ERR(name);
943 			goto out_put;
944 		}
945 		err = read_name(root_inode, name);
946 		kfree(name);
947 		if (err)
948 			goto out_put;
949 	}
950 
951 	err = -ENOMEM;
952 	sb->s_root = d_make_root(root_inode);
953 	if (sb->s_root == NULL)
954 		goto out;
955 
956 	return 0;
957 
958 out_put:
959 	iput(root_inode);
960 out:
961 	return err;
962 }
963 
hostfs_read_sb(struct file_system_type * type,int flags,const char * dev_name,void * data)964 static struct dentry *hostfs_read_sb(struct file_system_type *type,
965 			  int flags, const char *dev_name,
966 			  void *data)
967 {
968 	return mount_nodev(type, flags, data, hostfs_fill_sb_common);
969 }
970 
hostfs_kill_sb(struct super_block * s)971 static void hostfs_kill_sb(struct super_block *s)
972 {
973 	kill_anon_super(s);
974 	kfree(s->s_fs_info);
975 }
976 
977 static struct file_system_type hostfs_type = {
978 	.owner 		= THIS_MODULE,
979 	.name 		= "hostfs",
980 	.mount	 	= hostfs_read_sb,
981 	.kill_sb	= hostfs_kill_sb,
982 	.fs_flags 	= 0,
983 };
984 MODULE_ALIAS_FS("hostfs");
985 
init_hostfs(void)986 static int __init init_hostfs(void)
987 {
988 	return register_filesystem(&hostfs_type);
989 }
990 
exit_hostfs(void)991 static void __exit exit_hostfs(void)
992 {
993 	unregister_filesystem(&hostfs_type);
994 }
995 
996 module_init(init_hostfs)
997 module_exit(exit_hostfs)
998 MODULE_LICENSE("GPL");
999