xref: /openbmc/linux/fs/hostfs/hostfs_kern.c (revision ea4f7794)
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 
24 struct 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 
HOSTFS_I(struct inode * inode)32 static 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 
39 static struct kmem_cache *hostfs_inode_cache;
40 
41 /* Changed in hostfs_args before the kernel starts running */
42 static char *root_ino = "";
43 static int append = 0;
44 
45 static const struct inode_operations hostfs_iops;
46 static const struct inode_operations hostfs_dir_iops;
47 static const struct inode_operations hostfs_link_iops;
48 
49 #ifndef MODULE
hostfs_args(char * options,int * add)50 static 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 
__dentry_name(struct dentry * dentry,char * name)88 static 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 
dentry_name(struct dentry * dentry)119 static 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 
inode_name(struct inode * ino)128 static 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 
follow_link(char * link)144 static 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 
hostfs_statfs(struct dentry * dentry,struct kstatfs * sf)186 static 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 
hostfs_alloc_inode(struct super_block * sb)215 static 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 
hostfs_evict_inode(struct inode * inode)230 static 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 
hostfs_free_inode(struct inode * inode)241 static void hostfs_free_inode(struct inode *inode)
242 {
243 	kmem_cache_free(hostfs_inode_cache, HOSTFS_I(inode));
244 }
245 
hostfs_show_options(struct seq_file * seq,struct dentry * root)246 static 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 
260 static 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 
hostfs_readdir(struct file * file,struct dir_context * ctx)269 static 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 
hostfs_open(struct inode * ino,struct file * file)295 static 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 
308 retry:
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 
hostfs_file_release(struct inode * inode,struct file * file)354 static 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 
hostfs_fsync(struct file * file,loff_t start,loff_t end,int datasync)361 static 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 
378 static 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 
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_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 
hostfs_read_folio(struct file * file,struct folio * folio)433 static 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 
hostfs_write_begin(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,struct page ** pagep,void ** fsdata)463 static 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 
hostfs_write_end(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,unsigned copied,struct page * page,void * fsdata)475 static 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 
503 static 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 
hostfs_inode_update(struct inode * ino,const struct hostfs_stat * st)511 static 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 	ino->i_atime =
517 		(struct timespec64){ st->atime.tv_sec, st->atime.tv_nsec };
518 	ino->i_mtime =
519 		(struct timespec64){ st->mtime.tv_sec, st->mtime.tv_nsec };
520 	inode_set_ctime(ino, st->ctime.tv_sec, st->ctime.tv_nsec);
521 	ino->i_size = st->size;
522 	ino->i_blocks = st->blocks;
523 	return 0;
524 }
525 
hostfs_inode_set(struct inode * ino,void * data)526 static int hostfs_inode_set(struct inode *ino, void *data)
527 {
528 	struct hostfs_stat *st = data;
529 	dev_t dev, rdev;
530 
531 	/* Reencode maj and min with the kernel encoding.*/
532 	rdev = MKDEV(st->rdev.maj, st->rdev.min);
533 	dev = MKDEV(st->dev.maj, st->dev.min);
534 
535 	switch (st->mode & S_IFMT) {
536 	case S_IFLNK:
537 		ino->i_op = &hostfs_link_iops;
538 		break;
539 	case S_IFDIR:
540 		ino->i_op = &hostfs_dir_iops;
541 		ino->i_fop = &hostfs_dir_fops;
542 		break;
543 	case S_IFCHR:
544 	case S_IFBLK:
545 	case S_IFIFO:
546 	case S_IFSOCK:
547 		init_special_inode(ino, st->mode & S_IFMT, rdev);
548 		ino->i_op = &hostfs_iops;
549 		break;
550 	case S_IFREG:
551 		ino->i_op = &hostfs_iops;
552 		ino->i_fop = &hostfs_file_fops;
553 		ino->i_mapping->a_ops = &hostfs_aops;
554 		break;
555 	default:
556 		return -EIO;
557 	}
558 
559 	HOSTFS_I(ino)->dev = dev;
560 	ino->i_ino = st->ino;
561 	ino->i_mode = st->mode;
562 	return hostfs_inode_update(ino, st);
563 }
564 
hostfs_inode_test(struct inode * inode,void * data)565 static int hostfs_inode_test(struct inode *inode, void *data)
566 {
567 	const struct hostfs_stat *st = data;
568 	dev_t dev = MKDEV(st->dev.maj, st->dev.min);
569 
570 	return inode->i_ino == st->ino && HOSTFS_I(inode)->dev == dev;
571 }
572 
hostfs_iget(struct super_block * sb,char * name)573 static struct inode *hostfs_iget(struct super_block *sb, char *name)
574 {
575 	struct inode *inode;
576 	struct hostfs_stat st;
577 	int err = stat_file(name, &st, -1);
578 
579 	if (err)
580 		return ERR_PTR(err);
581 
582 	inode = iget5_locked(sb, st.ino, hostfs_inode_test, hostfs_inode_set,
583 			     &st);
584 	if (!inode)
585 		return ERR_PTR(-ENOMEM);
586 
587 	if (inode->i_state & I_NEW) {
588 		unlock_new_inode(inode);
589 	} else {
590 		spin_lock(&inode->i_lock);
591 		hostfs_inode_update(inode, &st);
592 		spin_unlock(&inode->i_lock);
593 	}
594 
595 	return inode;
596 }
597 
hostfs_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)598 static int hostfs_create(struct mnt_idmap *idmap, struct inode *dir,
599 			 struct dentry *dentry, umode_t mode, bool excl)
600 {
601 	struct inode *inode;
602 	char *name;
603 	int fd;
604 
605 	name = dentry_name(dentry);
606 	if (name == NULL)
607 		return -ENOMEM;
608 
609 	fd = file_create(name, mode & 0777);
610 	if (fd < 0) {
611 		__putname(name);
612 		return fd;
613 	}
614 
615 	inode = hostfs_iget(dir->i_sb, name);
616 	__putname(name);
617 	if (IS_ERR(inode))
618 		return PTR_ERR(inode);
619 
620 	HOSTFS_I(inode)->fd = fd;
621 	HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
622 	d_instantiate(dentry, inode);
623 	return 0;
624 }
625 
hostfs_lookup(struct inode * ino,struct dentry * dentry,unsigned int flags)626 static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
627 				    unsigned int flags)
628 {
629 	struct inode *inode = NULL;
630 	char *name;
631 
632 	name = dentry_name(dentry);
633 	if (name == NULL)
634 		return ERR_PTR(-ENOMEM);
635 
636 	inode = hostfs_iget(ino->i_sb, name);
637 	__putname(name);
638 	if (IS_ERR(inode)) {
639 		if (PTR_ERR(inode) == -ENOENT)
640 			inode = NULL;
641 		else
642 			return ERR_CAST(inode);
643 	}
644 
645 	return d_splice_alias(inode, dentry);
646 }
647 
hostfs_link(struct dentry * to,struct inode * ino,struct dentry * from)648 static int hostfs_link(struct dentry *to, struct inode *ino,
649 		       struct dentry *from)
650 {
651 	char *from_name, *to_name;
652 	int err;
653 
654 	if ((from_name = dentry_name(from)) == NULL)
655 		return -ENOMEM;
656 	to_name = dentry_name(to);
657 	if (to_name == NULL) {
658 		__putname(from_name);
659 		return -ENOMEM;
660 	}
661 	err = link_file(to_name, from_name);
662 	__putname(from_name);
663 	__putname(to_name);
664 	return err;
665 }
666 
hostfs_unlink(struct inode * ino,struct dentry * dentry)667 static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
668 {
669 	char *file;
670 	int err;
671 
672 	if (append)
673 		return -EPERM;
674 
675 	if ((file = dentry_name(dentry)) == NULL)
676 		return -ENOMEM;
677 
678 	err = unlink_file(file);
679 	__putname(file);
680 	return err;
681 }
682 
hostfs_symlink(struct mnt_idmap * idmap,struct inode * ino,struct dentry * dentry,const char * to)683 static int hostfs_symlink(struct mnt_idmap *idmap, struct inode *ino,
684 			  struct dentry *dentry, const char *to)
685 {
686 	char *file;
687 	int err;
688 
689 	if ((file = dentry_name(dentry)) == NULL)
690 		return -ENOMEM;
691 	err = make_symlink(file, to);
692 	__putname(file);
693 	return err;
694 }
695 
hostfs_mkdir(struct mnt_idmap * idmap,struct inode * ino,struct dentry * dentry,umode_t mode)696 static int hostfs_mkdir(struct mnt_idmap *idmap, struct inode *ino,
697 			struct dentry *dentry, umode_t mode)
698 {
699 	char *file;
700 	int err;
701 
702 	if ((file = dentry_name(dentry)) == NULL)
703 		return -ENOMEM;
704 	err = do_mkdir(file, mode);
705 	__putname(file);
706 	return err;
707 }
708 
hostfs_rmdir(struct inode * ino,struct dentry * dentry)709 static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
710 {
711 	char *file;
712 	int err;
713 
714 	if ((file = dentry_name(dentry)) == NULL)
715 		return -ENOMEM;
716 	err = hostfs_do_rmdir(file);
717 	__putname(file);
718 	return err;
719 }
720 
hostfs_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)721 static int hostfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
722 			struct dentry *dentry, umode_t mode, dev_t dev)
723 {
724 	struct inode *inode;
725 	char *name;
726 	int err;
727 
728 	name = dentry_name(dentry);
729 	if (name == NULL)
730 		return -ENOMEM;
731 
732 	err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
733 	if (err) {
734 		__putname(name);
735 		return err;
736 	}
737 
738 	inode = hostfs_iget(dir->i_sb, name);
739 	__putname(name);
740 	if (IS_ERR(inode))
741 		return PTR_ERR(inode);
742 
743 	d_instantiate(dentry, inode);
744 	return 0;
745 }
746 
hostfs_rename2(struct mnt_idmap * idmap,struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)747 static int hostfs_rename2(struct mnt_idmap *idmap,
748 			  struct inode *old_dir, struct dentry *old_dentry,
749 			  struct inode *new_dir, struct dentry *new_dentry,
750 			  unsigned int flags)
751 {
752 	char *old_name, *new_name;
753 	int err;
754 
755 	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
756 		return -EINVAL;
757 
758 	old_name = dentry_name(old_dentry);
759 	if (old_name == NULL)
760 		return -ENOMEM;
761 	new_name = dentry_name(new_dentry);
762 	if (new_name == NULL) {
763 		__putname(old_name);
764 		return -ENOMEM;
765 	}
766 	if (!flags)
767 		err = rename_file(old_name, new_name);
768 	else
769 		err = rename2_file(old_name, new_name, flags);
770 
771 	__putname(old_name);
772 	__putname(new_name);
773 	return err;
774 }
775 
hostfs_permission(struct mnt_idmap * idmap,struct inode * ino,int desired)776 static int hostfs_permission(struct mnt_idmap *idmap,
777 			     struct inode *ino, int desired)
778 {
779 	char *name;
780 	int r = 0, w = 0, x = 0, err;
781 
782 	if (desired & MAY_NOT_BLOCK)
783 		return -ECHILD;
784 
785 	if (desired & MAY_READ) r = 1;
786 	if (desired & MAY_WRITE) w = 1;
787 	if (desired & MAY_EXEC) x = 1;
788 	name = inode_name(ino);
789 	if (name == NULL)
790 		return -ENOMEM;
791 
792 	if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
793 	    S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
794 		err = 0;
795 	else
796 		err = access_file(name, r, w, x);
797 	__putname(name);
798 	if (!err)
799 		err = generic_permission(&nop_mnt_idmap, ino, desired);
800 	return err;
801 }
802 
hostfs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)803 static int hostfs_setattr(struct mnt_idmap *idmap,
804 			  struct dentry *dentry, struct iattr *attr)
805 {
806 	struct inode *inode = d_inode(dentry);
807 	struct hostfs_iattr attrs;
808 	char *name;
809 	int err;
810 
811 	int fd = HOSTFS_I(inode)->fd;
812 
813 	err = setattr_prepare(&nop_mnt_idmap, dentry, attr);
814 	if (err)
815 		return err;
816 
817 	if (append)
818 		attr->ia_valid &= ~ATTR_SIZE;
819 
820 	attrs.ia_valid = 0;
821 	if (attr->ia_valid & ATTR_MODE) {
822 		attrs.ia_valid |= HOSTFS_ATTR_MODE;
823 		attrs.ia_mode = attr->ia_mode;
824 	}
825 	if (attr->ia_valid & ATTR_UID) {
826 		attrs.ia_valid |= HOSTFS_ATTR_UID;
827 		attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
828 	}
829 	if (attr->ia_valid & ATTR_GID) {
830 		attrs.ia_valid |= HOSTFS_ATTR_GID;
831 		attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
832 	}
833 	if (attr->ia_valid & ATTR_SIZE) {
834 		attrs.ia_valid |= HOSTFS_ATTR_SIZE;
835 		attrs.ia_size = attr->ia_size;
836 	}
837 	if (attr->ia_valid & ATTR_ATIME) {
838 		attrs.ia_valid |= HOSTFS_ATTR_ATIME;
839 		attrs.ia_atime = (struct hostfs_timespec)
840 			{ attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec };
841 	}
842 	if (attr->ia_valid & ATTR_MTIME) {
843 		attrs.ia_valid |= HOSTFS_ATTR_MTIME;
844 		attrs.ia_mtime = (struct hostfs_timespec)
845 			{ attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec };
846 	}
847 	if (attr->ia_valid & ATTR_CTIME) {
848 		attrs.ia_valid |= HOSTFS_ATTR_CTIME;
849 		attrs.ia_ctime = (struct hostfs_timespec)
850 			{ attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec };
851 	}
852 	if (attr->ia_valid & ATTR_ATIME_SET) {
853 		attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
854 	}
855 	if (attr->ia_valid & ATTR_MTIME_SET) {
856 		attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
857 	}
858 	name = dentry_name(dentry);
859 	if (name == NULL)
860 		return -ENOMEM;
861 	err = set_attr(name, &attrs, fd);
862 	__putname(name);
863 	if (err)
864 		return err;
865 
866 	if ((attr->ia_valid & ATTR_SIZE) &&
867 	    attr->ia_size != i_size_read(inode))
868 		truncate_setsize(inode, attr->ia_size);
869 
870 	setattr_copy(&nop_mnt_idmap, inode, attr);
871 	mark_inode_dirty(inode);
872 	return 0;
873 }
874 
875 static const struct inode_operations hostfs_iops = {
876 	.permission	= hostfs_permission,
877 	.setattr	= hostfs_setattr,
878 };
879 
880 static const struct inode_operations hostfs_dir_iops = {
881 	.create		= hostfs_create,
882 	.lookup		= hostfs_lookup,
883 	.link		= hostfs_link,
884 	.unlink		= hostfs_unlink,
885 	.symlink	= hostfs_symlink,
886 	.mkdir		= hostfs_mkdir,
887 	.rmdir		= hostfs_rmdir,
888 	.mknod		= hostfs_mknod,
889 	.rename		= hostfs_rename2,
890 	.permission	= hostfs_permission,
891 	.setattr	= hostfs_setattr,
892 };
893 
hostfs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)894 static const char *hostfs_get_link(struct dentry *dentry,
895 				   struct inode *inode,
896 				   struct delayed_call *done)
897 {
898 	char *link;
899 	if (!dentry)
900 		return ERR_PTR(-ECHILD);
901 	link = kmalloc(PATH_MAX, GFP_KERNEL);
902 	if (link) {
903 		char *path = dentry_name(dentry);
904 		int err = -ENOMEM;
905 		if (path) {
906 			err = hostfs_do_readlink(path, link, PATH_MAX);
907 			if (err == PATH_MAX)
908 				err = -E2BIG;
909 			__putname(path);
910 		}
911 		if (err < 0) {
912 			kfree(link);
913 			return ERR_PTR(err);
914 		}
915 	} else {
916 		return ERR_PTR(-ENOMEM);
917 	}
918 
919 	set_delayed_call(done, kfree_link, link);
920 	return link;
921 }
922 
923 static const struct inode_operations hostfs_link_iops = {
924 	.get_link	= hostfs_get_link,
925 };
926 
hostfs_fill_sb_common(struct super_block * sb,void * d,int silent)927 static 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 	err = super_setup_bdi(sb);
940 	if (err)
941 		return err;
942 
943 	/* NULL is printed as '(null)' by printf(): avoid that. */
944 	if (req_root == NULL)
945 		req_root = "";
946 
947 	sb->s_fs_info = host_root_path =
948 		kasprintf(GFP_KERNEL, "%s/%s", root_ino, req_root);
949 	if (host_root_path == NULL)
950 		return -ENOMEM;
951 
952 	root_inode = hostfs_iget(sb, host_root_path);
953 	if (IS_ERR(root_inode))
954 		return PTR_ERR(root_inode);
955 
956 	if (S_ISLNK(root_inode->i_mode)) {
957 		char *name;
958 
959 		iput(root_inode);
960 		name = follow_link(host_root_path);
961 		if (IS_ERR(name))
962 			return PTR_ERR(name);
963 
964 		root_inode = hostfs_iget(sb, name);
965 		kfree(name);
966 		if (IS_ERR(root_inode))
967 			return PTR_ERR(root_inode);
968 	}
969 
970 	sb->s_root = d_make_root(root_inode);
971 	if (sb->s_root == NULL)
972 		return -ENOMEM;
973 
974 	return 0;
975 }
976 
hostfs_read_sb(struct file_system_type * type,int flags,const char * dev_name,void * data)977 static struct dentry *hostfs_read_sb(struct file_system_type *type,
978 			  int flags, const char *dev_name,
979 			  void *data)
980 {
981 	return mount_nodev(type, flags, data, hostfs_fill_sb_common);
982 }
983 
hostfs_kill_sb(struct super_block * s)984 static void hostfs_kill_sb(struct super_block *s)
985 {
986 	kill_anon_super(s);
987 	kfree(s->s_fs_info);
988 }
989 
990 static struct file_system_type hostfs_type = {
991 	.owner 		= THIS_MODULE,
992 	.name 		= "hostfs",
993 	.mount	 	= hostfs_read_sb,
994 	.kill_sb	= hostfs_kill_sb,
995 	.fs_flags 	= 0,
996 };
997 MODULE_ALIAS_FS("hostfs");
998 
init_hostfs(void)999 static int __init init_hostfs(void)
1000 {
1001 	hostfs_inode_cache = KMEM_CACHE(hostfs_inode_info, 0);
1002 	if (!hostfs_inode_cache)
1003 		return -ENOMEM;
1004 	return register_filesystem(&hostfs_type);
1005 }
1006 
exit_hostfs(void)1007 static void __exit exit_hostfs(void)
1008 {
1009 	unregister_filesystem(&hostfs_type);
1010 	kmem_cache_destroy(hostfs_inode_cache);
1011 }
1012 
1013 module_init(init_hostfs)
1014 module_exit(exit_hostfs)
1015 MODULE_LICENSE("GPL");
1016