[mirror_ubuntu-jammy-kernel.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/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] */
void vboxsf_init_inode(struct vboxsf_sbi *sbi, struct inode *inode,
		       const struct shfl_fsobjinfo *info)
{
	const struct shfl_fsobjattr *attr;
	s64 allocated;
	int 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)) {
		inode->i_mode = sbi->o.dmode_set ? sbi->o.dmode : mode;
		inode->i_mode &= ~sbi->o.dmask;
		inode->i_mode |= S_IFDIR;
		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 (SHFL_IS_SYMLINK(attr->mode)) {
		inode->i_mode = sbi->o.fmode_set ? sbi->o.fmode : mode;
		inode->i_mode &= ~sbi->o.fmask;
		inode->i_mode |= S_IFLNK;
		inode->i_op = &vboxsf_lnk_iops;
		set_nlink(inode, 1);
	} else {
		inode->i_mode = sbi->o.fmode_set ? sbi->o.fmode : mode;
		inode->i_mode &= ~sbi->o.fmask;
		inode->i_mode |= S_IFREG;
		inode->i_op = &vboxsf_reg_iops;
		inode->i_fop = &vboxsf_reg_fops;
		set_nlink(inode, 1);
	}

	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);
}

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;
	vboxsf_init_inode(sbi, inode, &info);

	/*
	 * 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 user_namespace *mnt_userns, 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(&init_user_ns, d_inode(dentry), kstat);
	return 0;
}

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