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

// SPDX-License-Identifier: MIT
/*
 * VirtualBox Guest Shared Folders support: Directory inode and file operations
 *
 * Copyright (C) 2006-2018 Oracle Corporation
 */

#include <linux/namei.h>
#include <linux/vbox_utils.h>
#include "vfsmod.h"

static int vboxsf_dir_open(struct inode *inode, struct file *file)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
	struct shfl_createparms params = {};
	struct vboxsf_dir_info *sf_d;
	int err;

	sf_d = vboxsf_dir_info_alloc();
	if (!sf_d)
		return -ENOMEM;

	params.handle = SHFL_HANDLE_NIL;
	params.create_flags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS |
			      SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;

	err = vboxsf_create_at_dentry(file_dentry(file), &params);
	if (err)
		goto err_free_dir_info;

	if (params.result != SHFL_FILE_EXISTS) {
		err = -ENOENT;
		goto err_close;
	}

	err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
	if (err)
		goto err_close;

	vboxsf_close(sbi->root, params.handle);
	file->private_data = sf_d;
	return 0;

err_close:
	vboxsf_close(sbi->root, params.handle);
err_free_dir_info:
	vboxsf_dir_info_free(sf_d);
	return err;
}

static int vboxsf_dir_release(struct inode *inode, struct file *file)
{
	if (file->private_data)
		vboxsf_dir_info_free(file->private_data);

	return 0;
}

static unsigned int vboxsf_get_d_type(u32 mode)
{
	unsigned int d_type;

	switch (mode & SHFL_TYPE_MASK) {
	case SHFL_TYPE_FIFO:
		d_type = DT_FIFO;
		break;
	case SHFL_TYPE_DEV_CHAR:
		d_type = DT_CHR;
		break;
	case SHFL_TYPE_DIRECTORY:
		d_type = DT_DIR;
		break;
	case SHFL_TYPE_DEV_BLOCK:
		d_type = DT_BLK;
		break;
	case SHFL_TYPE_FILE:
		d_type = DT_REG;
		break;
	case SHFL_TYPE_SYMLINK:
		d_type = DT_LNK;
		break;
	case SHFL_TYPE_SOCKET:
		d_type = DT_SOCK;
		break;
	case SHFL_TYPE_WHITEOUT:
		d_type = DT_WHT;
		break;
	default:
		d_type = DT_UNKNOWN;
		break;
	}
	return d_type;
}

static bool vboxsf_dir_emit(struct file *dir, struct dir_context *ctx)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
	struct vboxsf_dir_info *sf_d = dir->private_data;
	struct shfl_dirinfo *info;
	struct vboxsf_dir_buf *b;
	unsigned int d_type;
	loff_t i, cur = 0;
	ino_t fake_ino;
	void *end;
	int err;

	list_for_each_entry(b, &sf_d->info_list, head) {
try_next_entry:
		if (ctx->pos >= cur + b->entries) {
			cur += b->entries;
			continue;
		}

		/*
		 * Note the vboxsf_dir_info objects we are iterating over here
		 * are variable sized, so the info pointer may end up being
		 * unaligned. This is how we get the data from the host.
		 * Since vboxsf is only supported on x86 machines this is not
		 * a problem.
		 */
		for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
			end = &info->name.string.utf8[info->name.size];
			/* Only happens if the host gives us corrupt data */
			if (WARN_ON(end > (b->buf + b->used)))
				return false;
			info = end;
		}

		end = &info->name.string.utf8[info->name.size];
		if (WARN_ON(end > (b->buf + b->used)))
			return false;

		/* Info now points to the right entry, emit it. */
		d_type = vboxsf_get_d_type(info->info.attr.mode);

		/*
		 * On 32-bit systems pos is 64-bit signed, while ino is 32-bit
		 * unsigned so fake_ino may overflow, check for this.
		 */
		if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
			vbg_err("vboxsf: fake ino overflow, truncating dir\n");
			return false;
		}
		fake_ino = ctx->pos + 1;

		if (sbi->nls) {
			char d_name[NAME_MAX];

			err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
					    info->name.string.utf8,
					    info->name.length);
			if (err) {
				/* skip erroneous entry and proceed */
				ctx->pos += 1;
				goto try_next_entry;
			}

			return dir_emit(ctx, d_name, strlen(d_name),
					fake_ino, d_type);
		}

		return dir_emit(ctx, info->name.string.utf8, info->name.length,
				fake_ino, d_type);
	}

	return false;
}

static int vboxsf_dir_iterate(struct file *dir, struct dir_context *ctx)
{
	bool emitted;

	do {
		emitted = vboxsf_dir_emit(dir, ctx);
		if (emitted)
			ctx->pos += 1;
	} while (emitted);

	return 0;
}

const struct file_operations vboxsf_dir_fops = {
	.open = vboxsf_dir_open,
	.iterate = vboxsf_dir_iterate,
	.release = vboxsf_dir_release,
	.read = generic_read_dir,
	.llseek = generic_file_llseek,
};

/*
 * This is called during name resolution/lookup to check if the @dentry in
 * the cache is still valid. the job is handled by vboxsf_inode_revalidate.
 */
static int vboxsf_dentry_revalidate(struct dentry *dentry, unsigned int flags)
{
	if (flags & LOOKUP_RCU)
		return -ECHILD;

	if (d_really_is_positive(dentry))
		return vboxsf_inode_revalidate(dentry) == 0;
	else
		return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
}

const struct dentry_operations vboxsf_dentry_ops = {
	.d_revalidate = vboxsf_dentry_revalidate
};

/* iops */

static struct dentry *vboxsf_dir_lookup(struct inode *parent,
					struct dentry *dentry,
					unsigned int flags)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	struct shfl_fsobjinfo fsinfo;
	struct inode *inode;
	int err;

	dentry->d_time = jiffies;

	err = vboxsf_stat_dentry(dentry, &fsinfo);
	if (err) {
		inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
	} else {
		inode = vboxsf_new_inode(parent->i_sb);
		if (!IS_ERR(inode))
			vboxsf_init_inode(sbi, inode, &fsinfo, false);
	}

	return d_splice_alias(inode, dentry);
}

static int vboxsf_dir_instantiate(struct inode *parent, struct dentry *dentry,
				  struct shfl_fsobjinfo *info)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	struct vboxsf_inode *sf_i;
	struct inode *inode;

	inode = vboxsf_new_inode(parent->i_sb);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	sf_i = VBOXSF_I(inode);
	/* The host may have given us different attr then requested */
	sf_i->force_restat = 1;
	vboxsf_init_inode(sbi, inode, info, false);

	d_instantiate(dentry, inode);

	return 0;
}

static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
			     umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
{
	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	struct shfl_createparms params = {};
	int err;

	params.handle = SHFL_HANDLE_NIL;
	params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW | SHFL_CF_ACCESS_READWRITE;
	if (is_dir)
		params.create_flags |= SHFL_CF_DIRECTORY;
	if (excl)
		params.create_flags |= SHFL_CF_ACT_FAIL_IF_EXISTS;

	params.info.attr.mode = (mode & 0777) |
				(is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
	params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;

	err = vboxsf_create_at_dentry(dentry, &params);
	if (err)
		return err;

	if (params.result != SHFL_FILE_CREATED)
		return -EPERM;

	err = vboxsf_dir_instantiate(parent, dentry, &params.info);
	if (err)
		goto out;

	/* parent directory access/change time changed */
	sf_parent_i->force_restat = 1;

out:
	if (err == 0 && handle_ret)
		*handle_ret = params.handle;
	else
		vboxsf_close(sbi->root, params.handle);

	return err;
}

static int vboxsf_dir_mkfile(struct mnt_idmap *idmap,
			     struct inode *parent, struct dentry *dentry,
			     umode_t mode, bool excl)
{
	return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
}

static int vboxsf_dir_mkdir(struct mnt_idmap *idmap,
			    struct inode *parent, struct dentry *dentry,
			    umode_t mode)
{
	return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
}

static int vboxsf_dir_atomic_open(struct inode *parent, struct dentry *dentry,
				  struct file *file, unsigned int flags, umode_t mode)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	struct vboxsf_handle *sf_handle;
	struct dentry *res = NULL;
	u64 handle;
	int err;

	if (d_in_lookup(dentry)) {
		res = vboxsf_dir_lookup(parent, dentry, 0);
		if (IS_ERR(res))
			return PTR_ERR(res);

		if (res)
			dentry = res;
	}

	/* Only creates */
	if (!(flags & O_CREAT) || d_really_is_positive(dentry))
		return finish_no_open(file, res);

	err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
	if (err)
		goto out;

	sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
	if (IS_ERR(sf_handle)) {
		vboxsf_close(sbi->root, handle);
		err = PTR_ERR(sf_handle);
		goto out;
	}

	err = finish_open(file, dentry, generic_file_open);
	if (err) {
		/* This also closes the handle passed to vboxsf_create_sf_handle() */
		vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
		goto out;
	}

	file->private_data = sf_handle;
	file->f_mode |= FMODE_CREATED;
out:
	dput(res);
	return err;
}

static int vboxsf_dir_unlink(struct inode *parent, struct dentry *dentry)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	struct inode *inode = d_inode(dentry);
	struct shfl_string *path;
	u32 flags;
	int err;

	if (S_ISDIR(inode->i_mode))
		flags = SHFL_REMOVE_DIR;
	else
		flags = SHFL_REMOVE_FILE;

	if (S_ISLNK(inode->i_mode))
		flags |= SHFL_REMOVE_SYMLINK;

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

	err = vboxsf_remove(sbi->root, path, flags);
	__putname(path);
	if (err)
		return err;

	/* parent directory access/change time changed */
	sf_parent_i->force_restat = 1;

	return 0;
}

static int vboxsf_dir_rename(struct mnt_idmap *idmap,
			     struct inode *old_parent,
			     struct dentry *old_dentry,
			     struct inode *new_parent,
			     struct dentry *new_dentry,
			     unsigned int flags)
{
	struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
	struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
	struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
	u32 shfl_flags = SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS;
	struct shfl_string *old_path, *new_path;
	int err;

	if (flags)
		return -EINVAL;

	old_path = vboxsf_path_from_dentry(sbi, old_dentry);
	if (IS_ERR(old_path))
		return PTR_ERR(old_path);

	new_path = vboxsf_path_from_dentry(sbi, new_dentry);
	if (IS_ERR(new_path)) {
		err = PTR_ERR(new_path);
		goto err_put_old_path;
	}

	if (d_inode(old_dentry)->i_mode & S_IFDIR)
		shfl_flags = 0;

	err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
	if (err == 0) {
		/* parent directories access/change time changed */
		sf_new_parent_i->force_restat = 1;
		sf_old_parent_i->force_restat = 1;
	}

	__putname(new_path);
err_put_old_path:
	__putname(old_path);
	return err;
}

static int vboxsf_dir_symlink(struct mnt_idmap *idmap,
			      struct inode *parent, struct dentry *dentry,
			      const char *symname)
{
	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	int symname_size = strlen(symname) + 1;
	struct shfl_string *path, *ssymname;
	struct shfl_fsobjinfo info;
	int err;

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

	ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
	if (!ssymname) {
		__putname(path);
		return -ENOMEM;
	}
	ssymname->length = symname_size - 1;
	ssymname->size = symname_size;
	memcpy(ssymname->string.utf8, symname, symname_size);

	err = vboxsf_symlink(sbi->root, path, ssymname, &info);
	kfree(ssymname);
	__putname(path);
	if (err) {
		/* -EROFS means symlinks are note support -> -EPERM */
		return (err == -EROFS) ? -EPERM : err;
	}

	err = vboxsf_dir_instantiate(parent, dentry, &info);
	if (err)
		return err;

	/* parent directory access/change time changed */
	sf_parent_i->force_restat = 1;
	return 0;
}

const struct inode_operations vboxsf_dir_iops = {
	.lookup  = vboxsf_dir_lookup,
	.create  = vboxsf_dir_mkfile,
	.mkdir   = vboxsf_dir_mkdir,
	.atomic_open = vboxsf_dir_atomic_open,
	.rmdir   = vboxsf_dir_unlink,
	.unlink  = vboxsf_dir_unlink,
	.rename  = vboxsf_dir_rename,
	.symlink = vboxsf_dir_symlink,
	.getattr = vboxsf_getattr,
	.setattr = vboxsf_setattr,
};
Commit	Line	Data
0fd16957 HG	1	// SPDX-License-Identifier: MIT
	2	/*
	3	* VirtualBox Guest Shared Folders support: Directory inode and file operations
	4	*
	5	* Copyright (C) 2006-2018 Oracle Corporation
	6	*/
	7
	8	#include <linux/namei.h>
	9	#include <linux/vbox_utils.h>
	10	#include "vfsmod.h"
	11
	12	static int vboxsf_dir_open(struct inode inode, struct file file)
	13	{
	14	struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
	15	struct shfl_createparms params = {};
	16	struct vboxsf_dir_info *sf_d;
	17	int err;
	18
	19	sf_d = vboxsf_dir_info_alloc();
	20	if (!sf_d)
	21	return -ENOMEM;
	22
	23	params.handle = SHFL_HANDLE_NIL;
	24	params.create_flags = SHFL_CF_DIRECTORY \| SHFL_CF_ACT_OPEN_IF_EXISTS \|
	25	SHFL_CF_ACT_FAIL_IF_NEW \| SHFL_CF_ACCESS_READ;
	26
	27	err = vboxsf_create_at_dentry(file_dentry(file), &params);
	28	if (err)
	29	goto err_free_dir_info;
	30
	31	if (params.result != SHFL_FILE_EXISTS) {
	32	err = -ENOENT;
	33	goto err_close;
	34	}
	35
	36	err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
	37	if (err)
	38	goto err_close;
	39
	40	vboxsf_close(sbi->root, params.handle);
	41	file->private_data = sf_d;
	42	return 0;
	43
	44	err_close:
	45	vboxsf_close(sbi->root, params.handle);
	46	err_free_dir_info:
	47	vboxsf_dir_info_free(sf_d);
	48	return err;
	49	}
	50
	51	static int vboxsf_dir_release(struct inode inode, struct file file)
	52	{
	53	if (file->private_data)
	54	vboxsf_dir_info_free(file->private_data);
	55
	56	return 0;
	57	}
	58
	59	static unsigned int vboxsf_get_d_type(u32 mode)
	60	{
	61	unsigned int d_type;
	62
	63	switch (mode & SHFL_TYPE_MASK) {
	64	case SHFL_TYPE_FIFO:
65	d_type = DT_FIFO;
66	break;
67	case SHFL_TYPE_DEV_CHAR:
68	d_type = DT_CHR;
69	break;
70	case SHFL_TYPE_DIRECTORY:
71	d_type = DT_DIR;
72	break;
73	case SHFL_TYPE_DEV_BLOCK:
74	d_type = DT_BLK;
75	break;
76	case SHFL_TYPE_FILE:
77	d_type = DT_REG;
78	break;
79	case SHFL_TYPE_SYMLINK:
80	d_type = DT_LNK;
81	break;
82	case SHFL_TYPE_SOCKET:
83	d_type = DT_SOCK;
84	break;
85	case SHFL_TYPE_WHITEOUT:
86	d_type = DT_WHT;
87	break;
88	default:
89	d_type = DT_UNKNOWN;
90	break;
91	}
92	return d_type;
93	}
94
95	static bool vboxsf_dir_emit(struct file dir, struct dir_context ctx)
96	{
97	struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
98	struct vboxsf_dir_info *sf_d = dir->private_data;
99	struct shfl_dirinfo *info;
100	struct vboxsf_dir_buf *b;
101	unsigned int d_type;
102	loff_t i, cur = 0;
103	ino_t fake_ino;
104	void *end;
105	int err;
106
107	list_for_each_entry(b, &sf_d->info_list, head) {
108	try_next_entry:
109	if (ctx->pos >= cur + b->entries) {
110	cur += b->entries;
111	continue;
112	}
113
114	/*
115	* Note the vboxsf_dir_info objects we are iterating over here
116	* are variable sized, so the info pointer may end up being
117	* unaligned. This is how we get the data from the host.
118	* Since vboxsf is only supported on x86 machines this is not
119	* a problem.
120	*/
121	for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
122	end = &info->name.string.utf8[info->name.size];
123	/* Only happens if the host gives us corrupt data */
124	if (WARN_ON(end > (b->buf + b->used)))
125	return false;
126	info = end;
127	}
128
129	end = &info->name.string.utf8[info->name.size];
130	if (WARN_ON(end > (b->buf + b->used)))
131	return false;
132
133	/* Info now points to the right entry, emit it. */
134	d_type = vboxsf_get_d_type(info->info.attr.mode);
135
136	/*
15f9f63f	137	* On 32-bit systems pos is 64-bit signed, while ino is 32-bit
0fd16957 HG	138	* unsigned so fake_ino may overflow, check for this.
	139	*/
	140	if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
	141	vbg_err("vboxsf: fake ino overflow, truncating dir\n");
	142	return false;
	143	}
	144	fake_ino = ctx->pos + 1;
	145
	146	if (sbi->nls) {
	147	char d_name[NAME_MAX];
	148
	149	err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
	150	info->name.string.utf8,
	151	info->name.length);
	152	if (err) {
	153	/* skip erroneous entry and proceed */
	154	ctx->pos += 1;
	155	goto try_next_entry;
	156	}
	157
	158	return dir_emit(ctx, d_name, strlen(d_name),
	159	fake_ino, d_type);
	160	}
	161
	162	return dir_emit(ctx, info->name.string.utf8, info->name.length,
	163	fake_ino, d_type);
	164	}
	165
	166	return false;
	167	}
	168
	169	static int vboxsf_dir_iterate(struct file dir, struct dir_context ctx)
	170	{
	171	bool emitted;
	172
	173	do {
	174	emitted = vboxsf_dir_emit(dir, ctx);
	175	if (emitted)
	176	ctx->pos += 1;
	177	} while (emitted);
	178
	179	return 0;
	180	}
	181
	182	const struct file_operations vboxsf_dir_fops = {
	183	.open = vboxsf_dir_open,
	184	.iterate = vboxsf_dir_iterate,
	185	.release = vboxsf_dir_release,
	186	.read = generic_read_dir,
	187	.llseek = generic_file_llseek,
	188	};
	189
	190	/*
	191	* This is called during name resolution/lookup to check if the @dentry in
	192	* the cache is still valid. the job is handled by vboxsf_inode_revalidate.
	193	*/
	194	static int vboxsf_dentry_revalidate(struct dentry *dentry, unsigned int flags)
	195	{
	196	if (flags & LOOKUP_RCU)
	197	return -ECHILD;
	198
	199	if (d_really_is_positive(dentry))
	200	return vboxsf_inode_revalidate(dentry) == 0;
	201	else
202	return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
203	}
204
205	const struct dentry_operations vboxsf_dentry_ops = {
206	.d_revalidate = vboxsf_dentry_revalidate
207	};
208
209	/* iops */
210
211	static struct dentry vboxsf_dir_lookup(struct inode parent,
212	struct dentry *dentry,
213	unsigned int flags)
214	{
215	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
216	struct shfl_fsobjinfo fsinfo;
217	struct inode *inode;
218	int err;
219
220	dentry->d_time = jiffies;
221
222	err = vboxsf_stat_dentry(dentry, &fsinfo);
223	if (err) {
224	inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
225	} else {
226	inode = vboxsf_new_inode(parent->i_sb);
227	if (!IS_ERR(inode))
e98f93e7	228	vboxsf_init_inode(sbi, inode, &fsinfo, false);
0fd16957 HG	229	}
	230
	231	return d_splice_alias(inode, dentry);
	232	}
	233
	234	static int vboxsf_dir_instantiate(struct inode parent, struct dentry dentry,
	235	struct shfl_fsobjinfo *info)
	236	{
	237	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	238	struct vboxsf_inode *sf_i;
	239	struct inode *inode;
	240
	241	inode = vboxsf_new_inode(parent->i_sb);
	242	if (IS_ERR(inode))
	243	return PTR_ERR(inode);
	244
	245	sf_i = VBOXSF_I(inode);
	246	/* The host may have given us different attr then requested */
	247	sf_i->force_restat = 1;
e98f93e7	248	vboxsf_init_inode(sbi, inode, info, false);
0fd16957 HG	249
	250	d_instantiate(dentry, inode);
	251
	252	return 0;
	253	}
	254
	255	static int vboxsf_dir_create(struct inode parent, struct dentry dentry,
ab0c2968	256	umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
0fd16957 HG	257	{
	258	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	259	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	260	struct shfl_createparms params = {};
	261	int err;
	262
	263	params.handle = SHFL_HANDLE_NIL;
cc3ddee9 HG	264	params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW \| SHFL_CF_ACCESS_READWRITE;
	265	if (is_dir)
	266	params.create_flags \|= SHFL_CF_DIRECTORY;
	267	if (excl)
	268	params.create_flags \|= SHFL_CF_ACT_FAIL_IF_EXISTS;
	269
0fd16957 HG	270	params.info.attr.mode = (mode & 0777) \|
	271	(is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
	272	params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;
	273
	274	err = vboxsf_create_at_dentry(dentry, &params);
	275	if (err)
	276	return err;
	277
	278	if (params.result != SHFL_FILE_CREATED)
	279	return -EPERM;
	280
0fd16957 HG	281	err = vboxsf_dir_instantiate(parent, dentry, &params.info);
0fd16957 HG	282	if (err)
ab0c2968	283	goto out;
0fd16957 HG	284
	285	/* parent directory access/change time changed */
	286	sf_parent_i->force_restat = 1;
	287
ab0c2968 HG	288	out:
	289	if (err == 0 && handle_ret)
	290	*handle_ret = params.handle;
	291	else
	292	vboxsf_close(sbi->root, params.handle);
	293
	294	return err;
0fd16957 HG	295	}
0fd16957 HG	296
6c960e68	297	static int vboxsf_dir_mkfile(struct mnt_idmap *idmap,
549c7297	298	struct inode parent, struct dentry dentry,
0fd16957 HG	299	umode_t mode, bool excl)
0fd16957 HG	300	{
ab0c2968	301	return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
0fd16957 HG	302	}
0fd16957 HG	303
c54bd91e	304	static int vboxsf_dir_mkdir(struct mnt_idmap *idmap,
549c7297	305	struct inode parent, struct dentry dentry,
0fd16957 HG	306	umode_t mode)
0fd16957 HG	307	{
ab0c2968	308	return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
0fd16957 HG	309	}
0fd16957 HG	310
52dfd86a HG	311	static int vboxsf_dir_atomic_open(struct inode parent, struct dentry dentry,
	312	struct file *file, unsigned int flags, umode_t mode)
	313	{
	314	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	315	struct vboxsf_handle *sf_handle;
	316	struct dentry *res = NULL;
	317	u64 handle;
	318	int err;
	319
	320	if (d_in_lookup(dentry)) {
	321	res = vboxsf_dir_lookup(parent, dentry, 0);
	322	if (IS_ERR(res))
	323	return PTR_ERR(res);
	324
	325	if (res)
	326	dentry = res;
	327	}
	328
	329	/* Only creates */
	330	if (!(flags & O_CREAT) \|\| d_really_is_positive(dentry))
	331	return finish_no_open(file, res);
	332
	333	err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
	334	if (err)
	335	goto out;
	336
	337	sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
	338	if (IS_ERR(sf_handle)) {
	339	vboxsf_close(sbi->root, handle);
	340	err = PTR_ERR(sf_handle);
	341	goto out;
	342	}
	343
	344	err = finish_open(file, dentry, generic_file_open);
	345	if (err) {
	346	/* This also closes the handle passed to vboxsf_create_sf_handle() */
	347	vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
	348	goto out;
	349	}
	350
	351	file->private_data = sf_handle;
	352	file->f_mode \|= FMODE_CREATED;
	353	out:
	354	dput(res);
	355	return err;
	356	}
	357
0fd16957 HG	358	static int vboxsf_dir_unlink(struct inode parent, struct dentry dentry)
	359	{
	360	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	361	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	362	struct inode *inode = d_inode(dentry);
	363	struct shfl_string *path;
	364	u32 flags;
	365	int err;
	366
	367	if (S_ISDIR(inode->i_mode))
	368	flags = SHFL_REMOVE_DIR;
	369	else
	370	flags = SHFL_REMOVE_FILE;
	371
	372	if (S_ISLNK(inode->i_mode))
	373	flags \|= SHFL_REMOVE_SYMLINK;
	374
	375	path = vboxsf_path_from_dentry(sbi, dentry);
	376	if (IS_ERR(path))
	377	return PTR_ERR(path);
	378
	379	err = vboxsf_remove(sbi->root, path, flags);
	380	__putname(path);
	381	if (err)
	382	return err;
	383
	384	/* parent directory access/change time changed */
	385	sf_parent_i->force_restat = 1;
	386
	387	return 0;
	388	}
	389
e18275ae	390	static int vboxsf_dir_rename(struct mnt_idmap *idmap,
549c7297	391	struct inode *old_parent,
0fd16957 HG	392	struct dentry *old_dentry,
	393	struct inode *new_parent,
	394	struct dentry *new_dentry,
	395	unsigned int flags)
	396	{
	397	struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
	398	struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
	399	struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
	400	u32 shfl_flags = SHFL_RENAME_FILE \| SHFL_RENAME_REPLACE_IF_EXISTS;
	401	struct shfl_string old_path, new_path;
	402	int err;
	403
	404	if (flags)
	405	return -EINVAL;
	406
	407	old_path = vboxsf_path_from_dentry(sbi, old_dentry);
	408	if (IS_ERR(old_path))
	409	return PTR_ERR(old_path);
	410
	411	new_path = vboxsf_path_from_dentry(sbi, new_dentry);
	412	if (IS_ERR(new_path)) {
	413	err = PTR_ERR(new_path);
	414	goto err_put_old_path;
	415	}
	416
	417	if (d_inode(old_dentry)->i_mode & S_IFDIR)
	418	shfl_flags = 0;
	419
	420	err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
	421	if (err == 0) {
	422	/* parent directories access/change time changed */
	423	sf_new_parent_i->force_restat = 1;
	424	sf_old_parent_i->force_restat = 1;
	425	}
	426
	427	__putname(new_path);
	428	err_put_old_path:
	429	__putname(old_path);
	430	return err;
	431	}
	432
7a77db95	433	static int vboxsf_dir_symlink(struct mnt_idmap *idmap,
549c7297	434	struct inode parent, struct dentry dentry,
0fd16957 HG	435	const char *symname)
	436	{
	437	struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
	438	struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
	439	int symname_size = strlen(symname) + 1;
	440	struct shfl_string path, ssymname;
	441	struct shfl_fsobjinfo info;
	442	int err;
	443
	444	path = vboxsf_path_from_dentry(sbi, dentry);
	445	if (IS_ERR(path))
	446	return PTR_ERR(path);
	447
	448	ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
	449	if (!ssymname) {
	450	__putname(path);
	451	return -ENOMEM;
	452	}
	453	ssymname->length = symname_size - 1;
	454	ssymname->size = symname_size;
	455	memcpy(ssymname->string.utf8, symname, symname_size);
	456
	457	err = vboxsf_symlink(sbi->root, path, ssymname, &info);
	458	kfree(ssymname);
	459	__putname(path);
	460	if (err) {
	461	/* -EROFS means symlinks are note support -> -EPERM */
	462	return (err == -EROFS) ? -EPERM : err;
	463	}
	464
	465	err = vboxsf_dir_instantiate(parent, dentry, &info);
	466	if (err)
	467	return err;
	468
	469	/* parent directory access/change time changed */
	470	sf_parent_i->force_restat = 1;
	471	return 0;
	472	}
	473
	474	const struct inode_operations vboxsf_dir_iops = {
	475	.lookup = vboxsf_dir_lookup,
	476	.create = vboxsf_dir_mkfile,
	477	.mkdir = vboxsf_dir_mkdir,
52dfd86a	478	.atomic_open = vboxsf_dir_atomic_open,
0fd16957 HG	479	.rmdir = vboxsf_dir_unlink,
	480	.unlink = vboxsf_dir_unlink,
	481	.rename = vboxsf_dir_rename,
	482	.symlink = vboxsf_dir_symlink,
	483	.getattr = vboxsf_getattr,
	484	.setattr = vboxsf_setattr,
	485	};