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