[linux-block.git] / fs / vboxsf / utils.c

// SPDX-License-Identifier: MIT
/*
 * VirtualBox Guest Shared Folders support: Utility functions.
 * Mainly conversion from/to VirtualBox/Linux data structures.
 *
 * Copyright (C) 2006-2018 Oracle Corporation
 */

#include <linux/namei.h>
#include <linux/nls.h>
#include <linux/sizes.h>
#include <linux/pagemap.h>
#include <linux/vfs.h>
#include "vfsmod.h"

struct inode *vboxsf_new_inode(struct super_block *sb)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(sb);
	struct inode *inode;
	unsigned long flags;
	int cursor, ret;
	u32 gen;

	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

	idr_preload(GFP_KERNEL);
	spin_lock_irqsave(&sbi->ino_idr_lock, flags);
	cursor = idr_get_cursor(&sbi->ino_idr);
	ret = idr_alloc_cyclic(&sbi->ino_idr, inode, 1, 0, GFP_ATOMIC);
	if (ret >= 0 && ret < cursor)
		sbi->next_generation++;
	gen = sbi->next_generation;
	spin_unlock_irqrestore(&sbi->ino_idr_lock, flags);
	idr_preload_end();

	if (ret < 0) {
		iput(inode);
		return ERR_PTR(ret);
	}

	inode->i_ino = ret;
	inode->i_generation = gen;
	return inode;
}

/* set [inode] attributes based on [info], uid/gid based on [sbi] */
int vboxsf_init_inode(struct vboxsf_sbi *sbi, struct inode *inode,
		       const struct shfl_fsobjinfo *info, bool reinit)
{
	const struct shfl_fsobjattr *attr;
	s64 allocated;
	umode_t mode;

	attr = &info->attr;

#define mode_set(r) ((attr->mode & (SHFL_UNIX_##r)) ? (S_##r) : 0)

	mode = mode_set(IRUSR);
	mode |= mode_set(IWUSR);
	mode |= mode_set(IXUSR);

	mode |= mode_set(IRGRP);
	mode |= mode_set(IWGRP);
	mode |= mode_set(IXGRP);

	mode |= mode_set(IROTH);
	mode |= mode_set(IWOTH);
	mode |= mode_set(IXOTH);

#undef mode_set

	/* We use the host-side values for these */
	inode->i_flags |= S_NOATIME | S_NOCMTIME;
	inode->i_mapping->a_ops = &vboxsf_reg_aops;

	if (SHFL_IS_DIRECTORY(attr->mode)) {
		if (sbi->o.dmode_set)
			mode = sbi->o.dmode;
		mode &= ~sbi->o.dmask;
		mode |= S_IFDIR;
		if (!reinit) {
			inode->i_op = &vboxsf_dir_iops;
			inode->i_fop = &vboxsf_dir_fops;
			/*
			 * XXX: this probably should be set to the number of entries
			 * in the directory plus two (. ..)
			 */
			set_nlink(inode, 1);
		} else if (!S_ISDIR(inode->i_mode))
			return -ESTALE;
		inode->i_mode = mode;
	} else if (SHFL_IS_SYMLINK(attr->mode)) {
		if (sbi->o.fmode_set)
			mode = sbi->o.fmode;
		mode &= ~sbi->o.fmask;
		mode |= S_IFLNK;
		if (!reinit) {
			inode->i_op = &vboxsf_lnk_iops;
			set_nlink(inode, 1);
		} else if (!S_ISLNK(inode->i_mode))
			return -ESTALE;
		inode->i_mode = mode;
	} else {
		if (sbi->o.fmode_set)
			mode = sbi->o.fmode;
		mode &= ~sbi->o.fmask;
		mode |= S_IFREG;
		if (!reinit) {
			inode->i_op = &vboxsf_reg_iops;
			inode->i_fop = &vboxsf_reg_fops;
			set_nlink(inode, 1);
		} else if (!S_ISREG(inode->i_mode))
			return -ESTALE;
		inode->i_mode = mode;
	}

	inode->i_uid = sbi->o.uid;
	inode->i_gid = sbi->o.gid;

	inode->i_size = info->size;
	inode->i_blkbits = 12;
	/* i_blocks always in units of 512 bytes! */
	allocated = info->allocated + 511;
	do_div(allocated, 512);
	inode->i_blocks = allocated;

	inode->i_atime = ns_to_timespec64(
				 info->access_time.ns_relative_to_unix_epoch);
	inode->i_ctime = ns_to_timespec64(
				 info->change_time.ns_relative_to_unix_epoch);
	inode->i_mtime = ns_to_timespec64(
			   info->modification_time.ns_relative_to_unix_epoch);
	return 0;
}

int vboxsf_create_at_dentry(struct dentry *dentry,
			    struct shfl_createparms *params)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	struct shfl_string *path;
	int err;

	path = vboxsf_path_from_dentry(sbi, dentry);
	if (IS_ERR(path))
		return PTR_ERR(path);

	err = vboxsf_create(sbi->root, path, params);
	__putname(path);

	return err;
}

int vboxsf_stat(struct vboxsf_sbi *sbi, struct shfl_string *path,
		struct shfl_fsobjinfo *info)
{
	struct shfl_createparms params = {};
	int err;

	params.handle = SHFL_HANDLE_NIL;
	params.create_flags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;

	err = vboxsf_create(sbi->root, path, &params);
	if (err)
		return err;

	if (params.result != SHFL_FILE_EXISTS)
		return -ENOENT;

	if (info)
		*info = params.info;

	return 0;
}

int vboxsf_stat_dentry(struct dentry *dentry, struct shfl_fsobjinfo *info)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	struct shfl_string *path;
	int err;

	path = vboxsf_path_from_dentry(sbi, dentry);
	if (IS_ERR(path))
		return PTR_ERR(path);

	err = vboxsf_stat(sbi, path, info);
	__putname(path);
	return err;
}

int vboxsf_inode_revalidate(struct dentry *dentry)
{
	struct vboxsf_sbi *sbi;
	struct vboxsf_inode *sf_i;
	struct shfl_fsobjinfo info;
	struct timespec64 prev_mtime;
	struct inode *inode;
	int err;

	if (!dentry || !d_really_is_positive(dentry))
		return -EINVAL;

	inode = d_inode(dentry);
	prev_mtime = inode->i_mtime;
	sf_i = VBOXSF_I(inode);
	sbi = VBOXSF_SBI(dentry->d_sb);
	if (!sf_i->force_restat) {
		if (time_before(jiffies, dentry->d_time + sbi->o.ttl))
			return 0;
	}

	err = vboxsf_stat_dentry(dentry, &info);
	if (err)
		return err;

	dentry->d_time = jiffies;
	sf_i->force_restat = 0;
	err = vboxsf_init_inode(sbi, inode, &info, true);
	if (err)
		return err;

	/*
	 * If the file was changed on the host side we need to invalidate the
	 * page-cache for it.  Note this also gets triggered by our own writes,
	 * this is unavoidable.
	 */
	if (timespec64_compare(&inode->i_mtime, &prev_mtime) > 0)
		invalidate_inode_pages2(inode->i_mapping);

	return 0;
}

int vboxsf_getattr(struct mnt_idmap *idmap, const struct path *path,
		   struct kstat *kstat, u32 request_mask, unsigned int flags)
{
	int err;
	struct dentry *dentry = path->dentry;
	struct inode *inode = d_inode(dentry);
	struct vboxsf_inode *sf_i = VBOXSF_I(inode);

	switch (flags & AT_STATX_SYNC_TYPE) {
	case AT_STATX_DONT_SYNC:
		err = 0;
		break;
	case AT_STATX_FORCE_SYNC:
		sf_i->force_restat = 1;
		fallthrough;
	default:
		err = vboxsf_inode_revalidate(dentry);
	}
	if (err)
		return err;

	generic_fillattr(&nop_mnt_idmap, d_inode(dentry), kstat);
	return 0;
}

int vboxsf_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
		   struct iattr *iattr)
{
	struct vboxsf_inode *sf_i = VBOXSF_I(d_inode(dentry));
	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	struct shfl_createparms params = {};
	struct shfl_fsobjinfo info = {};
	u32 buf_len;
	int err;

	params.handle = SHFL_HANDLE_NIL;
	params.create_flags = SHFL_CF_ACT_OPEN_IF_EXISTS |
			      SHFL_CF_ACT_FAIL_IF_NEW |
			      SHFL_CF_ACCESS_ATTR_WRITE;

	/* this is at least required for Posix hosts */
	if (iattr->ia_valid & ATTR_SIZE)
		params.create_flags |= SHFL_CF_ACCESS_WRITE;

	err = vboxsf_create_at_dentry(dentry, &params);
	if (err || params.result != SHFL_FILE_EXISTS)
		return err ? err : -ENOENT;

#define mode_set(r) ((iattr->ia_mode & (S_##r)) ? SHFL_UNIX_##r : 0)

	/*
	 * Setting the file size and setting the other attributes has to
	 * be handled separately.
	 */
	if (iattr->ia_valid & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME)) {
		if (iattr->ia_valid & ATTR_MODE) {
			info.attr.mode = mode_set(IRUSR);
			info.attr.mode |= mode_set(IWUSR);
			info.attr.mode |= mode_set(IXUSR);
			info.attr.mode |= mode_set(IRGRP);
			info.attr.mode |= mode_set(IWGRP);
			info.attr.mode |= mode_set(IXGRP);
			info.attr.mode |= mode_set(IROTH);
			info.attr.mode |= mode_set(IWOTH);
			info.attr.mode |= mode_set(IXOTH);

			if (iattr->ia_mode & S_IFDIR)
				info.attr.mode |= SHFL_TYPE_DIRECTORY;
			else
				info.attr.mode |= SHFL_TYPE_FILE;
		}

		if (iattr->ia_valid & ATTR_ATIME)
			info.access_time.ns_relative_to_unix_epoch =
					    timespec64_to_ns(&iattr->ia_atime);

		if (iattr->ia_valid & ATTR_MTIME)
			info.modification_time.ns_relative_to_unix_epoch =
					    timespec64_to_ns(&iattr->ia_mtime);

		/*
		 * Ignore ctime (inode change time) as it can't be set
		 * from userland anyway.
		 */

		buf_len = sizeof(info);
		err = vboxsf_fsinfo(sbi->root, params.handle,
				    SHFL_INFO_SET | SHFL_INFO_FILE, &buf_len,
				    &info);
		if (err) {
			vboxsf_close(sbi->root, params.handle);
			return err;
		}

		/* the host may have given us different attr then requested */
		sf_i->force_restat = 1;
	}

#undef mode_set

	if (iattr->ia_valid & ATTR_SIZE) {
		memset(&info, 0, sizeof(info));
		info.size = iattr->ia_size;
		buf_len = sizeof(info);
		err = vboxsf_fsinfo(sbi->root, params.handle,
				    SHFL_INFO_SET | SHFL_INFO_SIZE, &buf_len,
				    &info);
		if (err) {
			vboxsf_close(sbi->root, params.handle);
			return err;
		}

		/* the host may have given us different attr then requested */
		sf_i->force_restat = 1;
	}

	vboxsf_close(sbi->root, params.handle);

	/* Update the inode with what the host has actually given us. */
	if (sf_i->force_restat)
		vboxsf_inode_revalidate(dentry);

	return 0;
}

/*
 * [dentry] contains string encoded in coding system that corresponds
 * to [sbi]->nls, we must convert it to UTF8 here.
 * Returns a shfl_string allocated through __getname (must be freed using
 * __putname), or an ERR_PTR on error.
 */
struct shfl_string *vboxsf_path_from_dentry(struct vboxsf_sbi *sbi,
					    struct dentry *dentry)
{
	struct shfl_string *shfl_path;
	int path_len, out_len, nb;
	char *buf, *path;
	wchar_t uni;
	u8 *out;

	buf = __getname();
	if (!buf)
		return ERR_PTR(-ENOMEM);

	path = dentry_path_raw(dentry, buf, PATH_MAX);
	if (IS_ERR(path)) {
		__putname(buf);
		return ERR_CAST(path);
	}
	path_len = strlen(path);

	if (sbi->nls) {
		shfl_path = __getname();
		if (!shfl_path) {
			__putname(buf);
			return ERR_PTR(-ENOMEM);
		}

		out = shfl_path->string.utf8;
		out_len = PATH_MAX - SHFLSTRING_HEADER_SIZE - 1;

		while (path_len) {
			nb = sbi->nls->char2uni(path, path_len, &uni);
			if (nb < 0) {
				__putname(shfl_path);
				__putname(buf);
				return ERR_PTR(-EINVAL);
			}
			path += nb;
			path_len -= nb;

			nb = utf32_to_utf8(uni, out, out_len);
			if (nb < 0) {
				__putname(shfl_path);
				__putname(buf);
				return ERR_PTR(-ENAMETOOLONG);
			}
			out += nb;
			out_len -= nb;
		}
		*out = 0;
		shfl_path->length = out - shfl_path->string.utf8;
		shfl_path->size = shfl_path->length + 1;
		__putname(buf);
	} else {
		if ((SHFLSTRING_HEADER_SIZE + path_len + 1) > PATH_MAX) {
			__putname(buf);
			return ERR_PTR(-ENAMETOOLONG);
		}
		/*
		 * dentry_path stores the name at the end of buf, but the
		 * shfl_string string we return must be properly aligned.
		 */
		shfl_path = (struct shfl_string *)buf;
		memmove(shfl_path->string.utf8, path, path_len);
		shfl_path->string.utf8[path_len] = 0;
		shfl_path->length = path_len;
		shfl_path->size = path_len + 1;
	}

	return shfl_path;
}

int vboxsf_nlscpy(struct vboxsf_sbi *sbi, char *name, size_t name_bound_len,
		  const unsigned char *utf8_name, size_t utf8_len)
{
	const char *in;
	char *out;
	size_t out_len;
	size_t out_bound_len;
	size_t in_bound_len;

	in = utf8_name;
	in_bound_len = utf8_len;

	out = name;
	out_len = 0;
	/* Reserve space for terminating 0 */
	out_bound_len = name_bound_len - 1;

	while (in_bound_len) {
		int nb;
		unicode_t uni;

		nb = utf8_to_utf32(in, in_bound_len, &uni);
		if (nb < 0)
			return -EINVAL;

		in += nb;
		in_bound_len -= nb;

		nb = sbi->nls->uni2char(uni, out, out_bound_len);
		if (nb < 0)
			return nb;

		out += nb;
		out_bound_len -= nb;
		out_len += nb;
	}

	*out = 0;

	return 0;
}

static struct vboxsf_dir_buf *vboxsf_dir_buf_alloc(struct list_head *list)
{
	struct vboxsf_dir_buf *b;

	b = kmalloc(sizeof(*b), GFP_KERNEL);
	if (!b)
		return NULL;

	b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
	if (!b->buf) {
		kfree(b);
		return NULL;
	}

	b->entries = 0;
	b->used = 0;
	b->free = DIR_BUFFER_SIZE;
	list_add(&b->head, list);

	return b;
}

static void vboxsf_dir_buf_free(struct vboxsf_dir_buf *b)
{
	list_del(&b->head);
	kfree(b->buf);
	kfree(b);
}

struct vboxsf_dir_info *vboxsf_dir_info_alloc(void)
{
	struct vboxsf_dir_info *p;

	p = kmalloc(sizeof(*p), GFP_KERNEL);
	if (!p)
		return NULL;

	INIT_LIST_HEAD(&p->info_list);
	return p;
}

void vboxsf_dir_info_free(struct vboxsf_dir_info *p)
{
	struct list_head *list, *pos, *tmp;

	list = &p->info_list;
	list_for_each_safe(pos, tmp, list) {
		struct vboxsf_dir_buf *b;

		b = list_entry(pos, struct vboxsf_dir_buf, head);
		vboxsf_dir_buf_free(b);
	}
	kfree(p);
}

int vboxsf_dir_read_all(struct vboxsf_sbi *sbi, struct vboxsf_dir_info *sf_d,
			u64 handle)
{
	struct vboxsf_dir_buf *b;
	u32 entries, size;
	int err = 0;
	void *buf;

	/* vboxsf_dirinfo returns 1 on end of dir */
	while (err == 0) {
		b = vboxsf_dir_buf_alloc(&sf_d->info_list);
		if (!b) {
			err = -ENOMEM;
			break;
		}

		buf = b->buf;
		size = b->free;

		err = vboxsf_dirinfo(sbi->root, handle, NULL, 0, 0,
				     &size, buf, &entries);
		if (err < 0)
			break;

		b->entries += entries;
		b->free -= size;
		b->used += size;
	}

	if (b && b->used == 0)
		vboxsf_dir_buf_free(b);

	/* -EILSEQ means the host could not translate a filename, ignore */
	if (err > 0 || err == -EILSEQ)
		err = 0;

	return err;
}
Commit	Line	Data
0fd16957 HG	1	// SPDX-License-Identifier: MIT
	2	/*
	3	* VirtualBox Guest Shared Folders support: Utility functions.
	4	* Mainly conversion from/to VirtualBox/Linux data structures.
	5	*
	6	* Copyright (C) 2006-2018 Oracle Corporation
	7	*/
	8
	9	#include <linux/namei.h>
	10	#include <linux/nls.h>
	11	#include <linux/sizes.h>
cbcc268b	12	#include <linux/pagemap.h>
0fd16957 HG	13	#include <linux/vfs.h>
	14	#include "vfsmod.h"
	15
	16	struct inode vboxsf_new_inode(struct super_block sb)
	17	{
	18	struct vboxsf_sbi *sbi = VBOXSF_SBI(sb);
	19	struct inode *inode;
	20	unsigned long flags;
	21	int cursor, ret;
	22	u32 gen;
	23
	24	inode = new_inode(sb);
	25	if (!inode)
	26	return ERR_PTR(-ENOMEM);
	27
	28	idr_preload(GFP_KERNEL);
	29	spin_lock_irqsave(&sbi->ino_idr_lock, flags);
	30	cursor = idr_get_cursor(&sbi->ino_idr);
	31	ret = idr_alloc_cyclic(&sbi->ino_idr, inode, 1, 0, GFP_ATOMIC);
	32	if (ret >= 0 && ret < cursor)
	33	sbi->next_generation++;
	34	gen = sbi->next_generation;
	35	spin_unlock_irqrestore(&sbi->ino_idr_lock, flags);
	36	idr_preload_end();
	37
	38	if (ret < 0) {
	39	iput(inode);
	40	return ERR_PTR(ret);
	41	}
	42
	43	inode->i_ino = ret;
	44	inode->i_generation = gen;
	45	return inode;
	46	}
	47
	48	/* set [inode] attributes based on [info], uid/gid based on [sbi] */
e98f93e7 AV	49	int vboxsf_init_inode(struct vboxsf_sbi sbi, struct inode inode,
e98f93e7 AV	50	const struct shfl_fsobjinfo *info, bool reinit)
0fd16957 HG	51	{
	52	const struct shfl_fsobjattr *attr;
	53	s64 allocated;
e98f93e7	54	umode_t mode;
0fd16957 HG	55
	56	attr = &info->attr;
	57
	58	#define mode_set(r) ((attr->mode & (SHFL_UNIX_##r)) ? (S_##r) : 0)
	59
	60	mode = mode_set(IRUSR);
	61	mode \|= mode_set(IWUSR);
	62	mode \|= mode_set(IXUSR);
	63
	64	mode \|= mode_set(IRGRP);
	65	mode \|= mode_set(IWGRP);
	66	mode \|= mode_set(IXGRP);
	67
	68	mode \|= mode_set(IROTH);
	69	mode \|= mode_set(IWOTH);
	70	mode \|= mode_set(IXOTH);
	71
	72	#undef mode_set
	73
	74	/* We use the host-side values for these */
	75	inode->i_flags \|= S_NOATIME \| S_NOCMTIME;
	76	inode->i_mapping->a_ops = &vboxsf_reg_aops;
	77
	78	if (SHFL_IS_DIRECTORY(attr->mode)) {
e98f93e7 AV	79	if (sbi->o.dmode_set)
	80	mode = sbi->o.dmode;
	81	mode &= ~sbi->o.dmask;
	82	mode \|= S_IFDIR;
	83	if (!reinit) {
	84	inode->i_op = &vboxsf_dir_iops;
	85	inode->i_fop = &vboxsf_dir_fops;
	86	/*
	87	* XXX: this probably should be set to the number of entries
	88	* in the directory plus two (. ..)
	89	*/
	90	set_nlink(inode, 1);
	91	} else if (!S_ISDIR(inode->i_mode))
	92	return -ESTALE;
	93	inode->i_mode = mode;
0fd16957	94	} else if (SHFL_IS_SYMLINK(attr->mode)) {
e98f93e7 AV	95	if (sbi->o.fmode_set)
	96	mode = sbi->o.fmode;
	97	mode &= ~sbi->o.fmask;
	98	mode \|= S_IFLNK;
	99	if (!reinit) {
	100	inode->i_op = &vboxsf_lnk_iops;
	101	set_nlink(inode, 1);
	102	} else if (!S_ISLNK(inode->i_mode))
	103	return -ESTALE;
	104	inode->i_mode = mode;
0fd16957	105	} else {
e98f93e7 AV	106	if (sbi->o.fmode_set)
	107	mode = sbi->o.fmode;
	108	mode &= ~sbi->o.fmask;
	109	mode \|= S_IFREG;
	110	if (!reinit) {
	111	inode->i_op = &vboxsf_reg_iops;
	112	inode->i_fop = &vboxsf_reg_fops;
	113	set_nlink(inode, 1);
	114	} else if (!S_ISREG(inode->i_mode))
	115	return -ESTALE;
	116	inode->i_mode = mode;
0fd16957 HG	117	}
	118
	119	inode->i_uid = sbi->o.uid;
	120	inode->i_gid = sbi->o.gid;
	121
	122	inode->i_size = info->size;
	123	inode->i_blkbits = 12;
	124	/* i_blocks always in units of 512 bytes! */
	125	allocated = info->allocated + 511;
	126	do_div(allocated, 512);
	127	inode->i_blocks = allocated;
	128
	129	inode->i_atime = ns_to_timespec64(
	130	info->access_time.ns_relative_to_unix_epoch);
	131	inode->i_ctime = ns_to_timespec64(
	132	info->change_time.ns_relative_to_unix_epoch);
	133	inode->i_mtime = ns_to_timespec64(
	134	info->modification_time.ns_relative_to_unix_epoch);
e98f93e7	135	return 0;
0fd16957 HG	136	}
	137
	138	int vboxsf_create_at_dentry(struct dentry *dentry,
	139	struct shfl_createparms *params)
	140	{
	141	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	142	struct shfl_string *path;
	143	int err;
	144
	145	path = vboxsf_path_from_dentry(sbi, dentry);
	146	if (IS_ERR(path))
	147	return PTR_ERR(path);
	148
	149	err = vboxsf_create(sbi->root, path, params);
	150	__putname(path);
	151
	152	return err;
	153	}
	154
	155	int vboxsf_stat(struct vboxsf_sbi sbi, struct shfl_string path,
	156	struct shfl_fsobjinfo *info)
	157	{
	158	struct shfl_createparms params = {};
	159	int err;
	160
	161	params.handle = SHFL_HANDLE_NIL;
	162	params.create_flags = SHFL_CF_LOOKUP \| SHFL_CF_ACT_FAIL_IF_NEW;
	163
	164	err = vboxsf_create(sbi->root, path, &params);
	165	if (err)
	166	return err;
	167
	168	if (params.result != SHFL_FILE_EXISTS)
	169	return -ENOENT;
	170
	171	if (info)
	172	*info = params.info;
	173
	174	return 0;
	175	}
	176
	177	int vboxsf_stat_dentry(struct dentry dentry, struct shfl_fsobjinfo info)
	178	{
	179	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	180	struct shfl_string *path;
	181	int err;
	182
	183	path = vboxsf_path_from_dentry(sbi, dentry);
	184	if (IS_ERR(path))
	185	return PTR_ERR(path);
	186
	187	err = vboxsf_stat(sbi, path, info);
	188	__putname(path);
	189	return err;
	190	}
	191
	192	int vboxsf_inode_revalidate(struct dentry *dentry)
	193	{
	194	struct vboxsf_sbi *sbi;
	195	struct vboxsf_inode *sf_i;
	196	struct shfl_fsobjinfo info;
	197	struct timespec64 prev_mtime;
	198	struct inode *inode;
	199	int err;
200
201	if (!dentry \|\| !d_really_is_positive(dentry))
202	return -EINVAL;
203
204	inode = d_inode(dentry);
205	prev_mtime = inode->i_mtime;
206	sf_i = VBOXSF_I(inode);
207	sbi = VBOXSF_SBI(dentry->d_sb);
208	if (!sf_i->force_restat) {
209	if (time_before(jiffies, dentry->d_time + sbi->o.ttl))
210	return 0;
211	}
212
213	err = vboxsf_stat_dentry(dentry, &info);
214	if (err)
215	return err;
216
217	dentry->d_time = jiffies;
218	sf_i->force_restat = 0;
e98f93e7 AV	219	err = vboxsf_init_inode(sbi, inode, &info, true);
	220	if (err)
	221	return err;
0fd16957 HG	222
	223	/*
	224	* If the file was changed on the host side we need to invalidate the
	225	* page-cache for it. Note this also gets triggered by our own writes,
	226	* this is unavoidable.
	227	*/
	228	if (timespec64_compare(&inode->i_mtime, &prev_mtime) > 0)
	229	invalidate_inode_pages2(inode->i_mapping);
	230
	231	return 0;
	232	}
	233
b74d24f7	234	int vboxsf_getattr(struct mnt_idmap idmap, const struct path path,
549c7297	235	struct kstat *kstat, u32 request_mask, unsigned int flags)
0fd16957 HG	236	{
	237	int err;
	238	struct dentry *dentry = path->dentry;
	239	struct inode *inode = d_inode(dentry);
	240	struct vboxsf_inode *sf_i = VBOXSF_I(inode);
	241
	242	switch (flags & AT_STATX_SYNC_TYPE) {
	243	case AT_STATX_DONT_SYNC:
	244	err = 0;
	245	break;
	246	case AT_STATX_FORCE_SYNC:
	247	sf_i->force_restat = 1;
df561f66	248	fallthrough;
0fd16957 HG	249	default:
	250	err = vboxsf_inode_revalidate(dentry);
	251	}
	252	if (err)
	253	return err;
	254
b74d24f7	255	generic_fillattr(&nop_mnt_idmap, d_inode(dentry), kstat);
0fd16957 HG	256	return 0;
	257	}
	258
c1632a0f	259	int vboxsf_setattr(struct mnt_idmap idmap, struct dentry dentry,
549c7297	260	struct iattr *iattr)
0fd16957 HG	261	{
	262	struct vboxsf_inode *sf_i = VBOXSF_I(d_inode(dentry));
	263	struct vboxsf_sbi *sbi = VBOXSF_SBI(dentry->d_sb);
	264	struct shfl_createparms params = {};
	265	struct shfl_fsobjinfo info = {};
	266	u32 buf_len;
	267	int err;
	268
	269	params.handle = SHFL_HANDLE_NIL;
	270	params.create_flags = SHFL_CF_ACT_OPEN_IF_EXISTS \|
	271	SHFL_CF_ACT_FAIL_IF_NEW \|
	272	SHFL_CF_ACCESS_ATTR_WRITE;
	273
	274	/* this is at least required for Posix hosts */
	275	if (iattr->ia_valid & ATTR_SIZE)
	276	params.create_flags \|= SHFL_CF_ACCESS_WRITE;
	277
	278	err = vboxsf_create_at_dentry(dentry, &params);
	279	if (err \|\| params.result != SHFL_FILE_EXISTS)
	280	return err ? err : -ENOENT;
	281
	282	#define mode_set(r) ((iattr->ia_mode & (S_##r)) ? SHFL_UNIX_##r : 0)
	283
	284	/*
	285	* Setting the file size and setting the other attributes has to
	286	* be handled separately.
	287	*/
	288	if (iattr->ia_valid & (ATTR_MODE \| ATTR_ATIME \| ATTR_MTIME)) {
	289	if (iattr->ia_valid & ATTR_MODE) {
	290	info.attr.mode = mode_set(IRUSR);
	291	info.attr.mode \|= mode_set(IWUSR);
	292	info.attr.mode \|= mode_set(IXUSR);
	293	info.attr.mode \|= mode_set(IRGRP);
	294	info.attr.mode \|= mode_set(IWGRP);
	295	info.attr.mode \|= mode_set(IXGRP);
	296	info.attr.mode \|= mode_set(IROTH);
	297	info.attr.mode \|= mode_set(IWOTH);
	298	info.attr.mode \|= mode_set(IXOTH);
	299
	300	if (iattr->ia_mode & S_IFDIR)
	301	info.attr.mode \|= SHFL_TYPE_DIRECTORY;
	302	else
	303	info.attr.mode \|= SHFL_TYPE_FILE;
	304	}
	305
	306	if (iattr->ia_valid & ATTR_ATIME)
	307	info.access_time.ns_relative_to_unix_epoch =
	308	timespec64_to_ns(&iattr->ia_atime);
	309
	310	if (iattr->ia_valid & ATTR_MTIME)
	311	info.modification_time.ns_relative_to_unix_epoch =
	312	timespec64_to_ns(&iattr->ia_mtime);
	313
	314	/*
	315	* Ignore ctime (inode change time) as it can't be set
	316	* from userland anyway.
	317	*/
	318
	319	buf_len = sizeof(info);
	320	err = vboxsf_fsinfo(sbi->root, params.handle,
	321	SHFL_INFO_SET \| SHFL_INFO_FILE, &buf_len,
	322	&info);
	323	if (err) {
	324	vboxsf_close(sbi->root, params.handle);
325	return err;
326	}
327
328	/* the host may have given us different attr then requested */
329	sf_i->force_restat = 1;
330	}
331
332	#undef mode_set
333
334	if (iattr->ia_valid & ATTR_SIZE) {
335	memset(&info, 0, sizeof(info));
336	info.size = iattr->ia_size;
337	buf_len = sizeof(info);
338	err = vboxsf_fsinfo(sbi->root, params.handle,
339	SHFL_INFO_SET \| SHFL_INFO_SIZE, &buf_len,
340	&info);
341	if (err) {
342	vboxsf_close(sbi->root, params.handle);
343	return err;
344	}
345
346	/* the host may have given us different attr then requested */
347	sf_i->force_restat = 1;
348	}
349
350	vboxsf_close(sbi->root, params.handle);
351
352	/* Update the inode with what the host has actually given us. */
353	if (sf_i->force_restat)
354	vboxsf_inode_revalidate(dentry);
355
356	return 0;
357	}
358
359	/*
360	* [dentry] contains string encoded in coding system that corresponds
361	* to [sbi]->nls, we must convert it to UTF8 here.
362	* Returns a shfl_string allocated through __getname (must be freed using
363	* __putname), or an ERR_PTR on error.
364	*/
365	struct shfl_string vboxsf_path_from_dentry(struct vboxsf_sbi sbi,
366	struct dentry *dentry)
367	{
368	struct shfl_string *shfl_path;
369	int path_len, out_len, nb;
370	char buf, path;
371	wchar_t uni;
372	u8 *out;
373
374	buf = __getname();
375	if (!buf)
376	return ERR_PTR(-ENOMEM);
377
378	path = dentry_path_raw(dentry, buf, PATH_MAX);
379	if (IS_ERR(path)) {
380	__putname(buf);
381	return ERR_CAST(path);
382	}
383	path_len = strlen(path);
384
385	if (sbi->nls) {
386	shfl_path = __getname();
387	if (!shfl_path) {
388	__putname(buf);
389	return ERR_PTR(-ENOMEM);
390	}
391
392	out = shfl_path->string.utf8;
393	out_len = PATH_MAX - SHFLSTRING_HEADER_SIZE - 1;
394
395	while (path_len) {
396	nb = sbi->nls->char2uni(path, path_len, &uni);
397	if (nb < 0) {
398	__putname(shfl_path);
399	__putname(buf);
400	return ERR_PTR(-EINVAL);
401	}
402	path += nb;
403	path_len -= nb;
404
405	nb = utf32_to_utf8(uni, out, out_len);
406	if (nb < 0) {
407	__putname(shfl_path);
408	__putname(buf);
409	return ERR_PTR(-ENAMETOOLONG);
410	}
411	out += nb;
412	out_len -= nb;
413	}
414	*out = 0;
415	shfl_path->length = out - shfl_path->string.utf8;
416	shfl_path->size = shfl_path->length + 1;
417	__putname(buf);
418	} else {
419	if ((SHFLSTRING_HEADER_SIZE + path_len + 1) > PATH_MAX) {
420	__putname(buf);
421	return ERR_PTR(-ENAMETOOLONG);
422	}
423	/*
424	* dentry_path stores the name at the end of buf, but the
425	* shfl_string string we return must be properly aligned.
426	*/
427	shfl_path = (struct shfl_string *)buf;
428	memmove(shfl_path->string.utf8, path, path_len);
429	shfl_path->string.utf8[path_len] = 0;
430	shfl_path->length = path_len;
431	shfl_path->size = path_len + 1;
432	}
433
434	return shfl_path;
435	}
436
437	int vboxsf_nlscpy(struct vboxsf_sbi sbi, char name, size_t name_bound_len,
438	const unsigned char *utf8_name, size_t utf8_len)
439	{
440	const char *in;
441	char *out;
442	size_t out_len;
443	size_t out_bound_len;
444	size_t in_bound_len;
445
446	in = utf8_name;
447	in_bound_len = utf8_len;
448
449	out = name;
450	out_len = 0;
451	/* Reserve space for terminating 0 */
452	out_bound_len = name_bound_len - 1;
453
454	while (in_bound_len) {
455	int nb;
456	unicode_t uni;
457
458	nb = utf8_to_utf32(in, in_bound_len, &uni);
459	if (nb < 0)
460	return -EINVAL;
461
462	in += nb;
463	in_bound_len -= nb;
464
465	nb = sbi->nls->uni2char(uni, out, out_bound_len);
466	if (nb < 0)
467	return nb;
468
469	out += nb;
470	out_bound_len -= nb;
471	out_len += nb;
472	}
473
474	*out = 0;
475
476	return 0;
477	}
478
479	static struct vboxsf_dir_buf vboxsf_dir_buf_alloc(struct list_head list)
480	{
481	struct vboxsf_dir_buf *b;
482
483	b = kmalloc(sizeof(*b), GFP_KERNEL);
484	if (!b)
485	return NULL;
486
487	b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
488	if (!b->buf) {
489	kfree(b);
490	return NULL;
491	}
492
493	b->entries = 0;
494	b->used = 0;
495	b->free = DIR_BUFFER_SIZE;
496	list_add(&b->head, list);
497
498	return b;
499	}
500
501	static void vboxsf_dir_buf_free(struct vboxsf_dir_buf *b)
502	{
503	list_del(&b->head);
504	kfree(b->buf);
505	kfree(b);
506	}
507
508	struct vboxsf_dir_info *vboxsf_dir_info_alloc(void)
509	{
510	struct vboxsf_dir_info *p;
511
512	p = kmalloc(sizeof(*p), GFP_KERNEL);
513	if (!p)
514	return NULL;
515
516	INIT_LIST_HEAD(&p->info_list);
517	return p;
518	}
519
520	void vboxsf_dir_info_free(struct vboxsf_dir_info *p)
521	{
522	struct list_head list, pos, *tmp;
523
524	list = &p->info_list;
525	list_for_each_safe(pos, tmp, list) {
526	struct vboxsf_dir_buf *b;
527
528	b = list_entry(pos, struct vboxsf_dir_buf, head);
529	vboxsf_dir_buf_free(b);
530	}
531	kfree(p);
532	}
533
534	int vboxsf_dir_read_all(struct vboxsf_sbi sbi, struct vboxsf_dir_info sf_d,
535	u64 handle)
536	{
537	struct vboxsf_dir_buf *b;
538	u32 entries, size;
539	int err = 0;
540	void *buf;
541
542	/* vboxsf_dirinfo returns 1 on end of dir */
543	while (err == 0) {
544	b = vboxsf_dir_buf_alloc(&sf_d->info_list);
545	if (!b) {
546	err = -ENOMEM;
547	break;
548	}
549
550	buf = b->buf;
551	size = b->free;
552
553	err = vboxsf_dirinfo(sbi->root, handle, NULL, 0, 0,
554	&size, buf, &entries);
555	if (err < 0)
556	break;
557
558	b->entries += entries;
559	b->free -= size;
560	b->used += size;
561	}
562
563	if (b && b->used == 0)
564	vboxsf_dir_buf_free(b);
565
566	/* -EILSEQ means the host could not translate a filename, ignore */
567	if (err > 0 \|\| err == -EILSEQ)
568	err = 0;
569
570	return err;
571	}