1// SPDX-License-Identifier: MIT
2/*
3 * VirtualBox Guest Shared Folders support: Virtual File System.
4 *
5 * Module initialization/finalization
6 * File system registration/deregistration
7 * Superblock reading
8 * Few utility functions
9 *
10 * Copyright (C) 2006-2018 Oracle Corporation
11 */
12
13#include <linux/idr.h>
14#include <linux/fs_parser.h>
15#include <linux/magic.h>
16#include <linux/module.h>
17#include <linux/nls.h>
18#include <linux/statfs.h>
19#include <linux/vbox_utils.h>
20#include "vfsmod.h"
21
22#define VBOXSF_SUPER_MAGIC 0x786f4256 /* 'VBox' little endian */
23
24static const unsigned char VBSF_MOUNT_SIGNATURE[4] = "\000\377\376\375";
25
26static int follow_symlinks;
27module_param(follow_symlinks, int, 0444);
28MODULE_PARM_DESC(follow_symlinks,
29		 "Let host resolve symlinks rather than showing them");
30
31static DEFINE_IDA(vboxsf_bdi_ida);
32static DEFINE_MUTEX(vboxsf_setup_mutex);
33static bool vboxsf_setup_done;
34static struct super_operations vboxsf_super_ops; /* forward declaration */
35static struct kmem_cache *vboxsf_inode_cachep;
36
37static char * const vboxsf_default_nls = CONFIG_NLS_DEFAULT;
38
39enum  { opt_nls, opt_uid, opt_gid, opt_ttl, opt_dmode, opt_fmode,
40	opt_dmask, opt_fmask };
41
42static const struct fs_parameter_spec vboxsf_fs_parameters[] = {
43	fsparam_string	("nls",		opt_nls),
44	fsparam_u32	("uid",		opt_uid),
45	fsparam_u32	("gid",		opt_gid),
46	fsparam_u32	("ttl",		opt_ttl),
47	fsparam_u32oct	("dmode",	opt_dmode),
48	fsparam_u32oct	("fmode",	opt_fmode),
49	fsparam_u32oct	("dmask",	opt_dmask),
50	fsparam_u32oct	("fmask",	opt_fmask),
51	{}
52};
53
54static int vboxsf_parse_param(struct fs_context *fc, struct fs_parameter *param)
55{
56	struct vboxsf_fs_context *ctx = fc->fs_private;
57	struct fs_parse_result result;
58	kuid_t uid;
59	kgid_t gid;
60	int opt;
61
62	opt = fs_parse(fc, vboxsf_fs_parameters, param, &result);
63	if (opt < 0)
64		return opt;
65
66	switch (opt) {
67	case opt_nls:
68		if (ctx->nls_name || fc->purpose != FS_CONTEXT_FOR_MOUNT) {
69			vbg_err("vboxsf: Cannot reconfigure nls option\n");
70			return -EINVAL;
71		}
72		ctx->nls_name = param->string;
73		param->string = NULL;
74		break;
75	case opt_uid:
76		uid = make_kuid(current_user_ns(), result.uint_32);
77		if (!uid_valid(uid))
78			return -EINVAL;
79		ctx->o.uid = uid;
80		break;
81	case opt_gid:
82		gid = make_kgid(current_user_ns(), result.uint_32);
83		if (!gid_valid(gid))
84			return -EINVAL;
85		ctx->o.gid = gid;
86		break;
87	case opt_ttl:
88		ctx->o.ttl = msecs_to_jiffies(result.uint_32);
89		break;
90	case opt_dmode:
91		if (result.uint_32 & ~0777)
92			return -EINVAL;
93		ctx->o.dmode = result.uint_32;
94		ctx->o.dmode_set = true;
95		break;
96	case opt_fmode:
97		if (result.uint_32 & ~0777)
98			return -EINVAL;
99		ctx->o.fmode = result.uint_32;
100		ctx->o.fmode_set = true;
101		break;
102	case opt_dmask:
103		if (result.uint_32 & ~07777)
104			return -EINVAL;
105		ctx->o.dmask = result.uint_32;
106		break;
107	case opt_fmask:
108		if (result.uint_32 & ~07777)
109			return -EINVAL;
110		ctx->o.fmask = result.uint_32;
111		break;
112	default:
113		return -EINVAL;
114	}
115
116	return 0;
117}
118
119static int vboxsf_fill_super(struct super_block *sb, struct fs_context *fc)
120{
121	struct vboxsf_fs_context *ctx = fc->fs_private;
122	struct shfl_string *folder_name, root_path;
123	struct vboxsf_sbi *sbi;
124	struct dentry *droot;
125	struct inode *iroot;
126	char *nls_name;
127	size_t size;
128	int err;
129
130	if (!fc->source)
131		return -EINVAL;
132
133	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
134	if (!sbi)
135		return -ENOMEM;
136
137	sbi->o = ctx->o;
138	idr_init(&sbi->ino_idr);
139	spin_lock_init(&sbi->ino_idr_lock);
140	sbi->next_generation = 1;
141	sbi->bdi_id = -1;
142
143	/* Load nls if not utf8 */
144	nls_name = ctx->nls_name ? ctx->nls_name : vboxsf_default_nls;
145	if (strcmp(nls_name, "utf8") != 0) {
146		if (nls_name == vboxsf_default_nls)
147			sbi->nls = load_nls_default();
148		else
149			sbi->nls = load_nls(nls_name);
150
151		if (!sbi->nls) {
152			vbg_err("vboxsf: Count not load '%s' nls\n", nls_name);
153			err = -EINVAL;
154			goto fail_destroy_idr;
155		}
156	}
157
158	sbi->bdi_id = ida_alloc(&vboxsf_bdi_ida, GFP_KERNEL);
159	if (sbi->bdi_id < 0) {
160		err = sbi->bdi_id;
161		goto fail_free;
162	}
163
164	err = super_setup_bdi_name(sb, "vboxsf-%d", sbi->bdi_id);
165	if (err)
166		goto fail_free;
167	sb->s_bdi->ra_pages = 0;
168	sb->s_bdi->io_pages = 0;
169
170	/* Turn source into a shfl_string and map the folder */
171	size = strlen(fc->source) + 1;
172	folder_name = kmalloc(SHFLSTRING_HEADER_SIZE + size, GFP_KERNEL);
173	if (!folder_name) {
174		err = -ENOMEM;
175		goto fail_free;
176	}
177	folder_name->size = size;
178	folder_name->length = size - 1;
179	strscpy(folder_name->string.utf8, fc->source, size);
180	err = vboxsf_map_folder(folder_name, &sbi->root);
181	kfree(folder_name);
182	if (err) {
183		vbg_err("vboxsf: Host rejected mount of '%s' with error %d\n",
184			fc->source, err);
185		goto fail_free;
186	}
187
188	root_path.length = 1;
189	root_path.size = 2;
190	root_path.string.utf8[0] = '/';
191	root_path.string.utf8[1] = 0;
192	err = vboxsf_stat(sbi, &root_path, &sbi->root_info);
193	if (err)
194		goto fail_unmap;
195
196	sb->s_magic = VBOXSF_SUPER_MAGIC;
197	sb->s_blocksize = 1024;
198	sb->s_maxbytes = MAX_LFS_FILESIZE;
199	sb->s_op = &vboxsf_super_ops;
200	sb->s_d_op = &vboxsf_dentry_ops;
201
202	iroot = iget_locked(sb, 0);
203	if (!iroot) {
204		err = -ENOMEM;
205		goto fail_unmap;
206	}
207	vboxsf_init_inode(sbi, iroot, &sbi->root_info, false);
208	unlock_new_inode(iroot);
209
210	droot = d_make_root(iroot);
211	if (!droot) {
212		err = -ENOMEM;
213		goto fail_unmap;
214	}
215
216	sb->s_root = droot;
217	sb->s_fs_info = sbi;
218	return 0;
219
220fail_unmap:
221	vboxsf_unmap_folder(sbi->root);
222fail_free:
223	if (sbi->bdi_id >= 0)
224		ida_free(&vboxsf_bdi_ida, sbi->bdi_id);
225	if (sbi->nls)
226		unload_nls(sbi->nls);
227fail_destroy_idr:
228	idr_destroy(&sbi->ino_idr);
229	kfree(sbi);
230	return err;
231}
232
233static void vboxsf_inode_init_once(void *data)
234{
235	struct vboxsf_inode *sf_i = data;
236
237	mutex_init(&sf_i->handle_list_mutex);
238	inode_init_once(&sf_i->vfs_inode);
239}
240
241static struct inode *vboxsf_alloc_inode(struct super_block *sb)
242{
243	struct vboxsf_inode *sf_i;
244
245	sf_i = alloc_inode_sb(sb, vboxsf_inode_cachep, GFP_NOFS);
246	if (!sf_i)
247		return NULL;
248
249	sf_i->force_restat = 0;
250	INIT_LIST_HEAD(&sf_i->handle_list);
251
252	return &sf_i->vfs_inode;
253}
254
255static void vboxsf_free_inode(struct inode *inode)
256{
257	struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
258	unsigned long flags;
259
260	spin_lock_irqsave(&sbi->ino_idr_lock, flags);
261	idr_remove(&sbi->ino_idr, inode->i_ino);
262	spin_unlock_irqrestore(&sbi->ino_idr_lock, flags);
263	kmem_cache_free(vboxsf_inode_cachep, VBOXSF_I(inode));
264}
265
266static void vboxsf_put_super(struct super_block *sb)
267{
268	struct vboxsf_sbi *sbi = VBOXSF_SBI(sb);
269
270	vboxsf_unmap_folder(sbi->root);
271	if (sbi->bdi_id >= 0)
272		ida_free(&vboxsf_bdi_ida, sbi->bdi_id);
273	if (sbi->nls)
274		unload_nls(sbi->nls);
275
276	/*
277	 * vboxsf_free_inode uses the idr, make sure all delayed rcu free
278	 * inodes are flushed.
279	 */
280	rcu_barrier();
281	idr_destroy(&sbi->ino_idr);
282	kfree(sbi);
283}
284
285static int vboxsf_statfs(struct dentry *dentry, struct kstatfs *stat)
286{
287	struct super_block *sb = dentry->d_sb;
288	struct shfl_volinfo shfl_volinfo;
289	struct vboxsf_sbi *sbi;
290	u32 buf_len;
291	int err;
292
293	sbi = VBOXSF_SBI(sb);
294	buf_len = sizeof(shfl_volinfo);
295	err = vboxsf_fsinfo(sbi->root, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
296			    &buf_len, &shfl_volinfo);
297	if (err)
298		return err;
299
300	stat->f_type = VBOXSF_SUPER_MAGIC;
301	stat->f_bsize = shfl_volinfo.bytes_per_allocation_unit;
302
303	do_div(shfl_volinfo.total_allocation_bytes,
304	       shfl_volinfo.bytes_per_allocation_unit);
305	stat->f_blocks = shfl_volinfo.total_allocation_bytes;
306
307	do_div(shfl_volinfo.available_allocation_bytes,
308	       shfl_volinfo.bytes_per_allocation_unit);
309	stat->f_bfree  = shfl_volinfo.available_allocation_bytes;
310	stat->f_bavail = shfl_volinfo.available_allocation_bytes;
311
312	stat->f_files = 1000;
313	/*
314	 * Don't return 0 here since the guest may then think that it is not
315	 * possible to create any more files.
316	 */
317	stat->f_ffree = 1000000;
318	stat->f_fsid.val[0] = 0;
319	stat->f_fsid.val[1] = 0;
320	stat->f_namelen = 255;
321	return 0;
322}
323
324static struct super_operations vboxsf_super_ops = {
325	.alloc_inode	= vboxsf_alloc_inode,
326	.free_inode	= vboxsf_free_inode,
327	.put_super	= vboxsf_put_super,
328	.statfs		= vboxsf_statfs,
329};
330
331static int vboxsf_setup(void)
332{
333	int err;
334
335	mutex_lock(&vboxsf_setup_mutex);
336
337	if (vboxsf_setup_done)
338		goto success;
339
340	vboxsf_inode_cachep =
341		kmem_cache_create("vboxsf_inode_cache",
342				  sizeof(struct vboxsf_inode), 0,
343				  SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
344				  vboxsf_inode_init_once);
345	if (!vboxsf_inode_cachep) {
346		err = -ENOMEM;
347		goto fail_nomem;
348	}
349
350	err = vboxsf_connect();
351	if (err) {
352		vbg_err("vboxsf: err %d connecting to guest PCI-device\n", err);
353		vbg_err("vboxsf: make sure you are inside a VirtualBox VM\n");
354		vbg_err("vboxsf: and check dmesg for vboxguest errors\n");
355		goto fail_free_cache;
356	}
357
358	err = vboxsf_set_utf8();
359	if (err) {
360		vbg_err("vboxsf_setutf8 error %d\n", err);
361		goto fail_disconnect;
362	}
363
364	if (!follow_symlinks) {
365		err = vboxsf_set_symlinks();
366		if (err)
367			vbg_warn("vboxsf: Unable to show symlinks: %d\n", err);
368	}
369
370	vboxsf_setup_done = true;
371success:
372	mutex_unlock(&vboxsf_setup_mutex);
373	return 0;
374
375fail_disconnect:
376	vboxsf_disconnect();
377fail_free_cache:
378	kmem_cache_destroy(vboxsf_inode_cachep);
379fail_nomem:
380	mutex_unlock(&vboxsf_setup_mutex);
381	return err;
382}
383
384static int vboxsf_parse_monolithic(struct fs_context *fc, void *data)
385{
386	if (data && !memcmp(data, VBSF_MOUNT_SIGNATURE, 4)) {
387		vbg_err("vboxsf: Old binary mount data not supported, remove obsolete mount.vboxsf and/or update your VBoxService.\n");
388		return -EINVAL;
389	}
390
391	return generic_parse_monolithic(fc, data);
392}
393
394static int vboxsf_get_tree(struct fs_context *fc)
395{
396	int err;
397
398	err = vboxsf_setup();
399	if (err)
400		return err;
401
402	return get_tree_nodev(fc, vboxsf_fill_super);
403}
404
405static int vboxsf_reconfigure(struct fs_context *fc)
406{
407	struct vboxsf_sbi *sbi = VBOXSF_SBI(fc->root->d_sb);
408	struct vboxsf_fs_context *ctx = fc->fs_private;
409	struct inode *iroot = fc->root->d_sb->s_root->d_inode;
410
411	/* Apply changed options to the root inode */
412	sbi->o = ctx->o;
413	vboxsf_init_inode(sbi, iroot, &sbi->root_info, true);
414
415	return 0;
416}
417
418static void vboxsf_free_fc(struct fs_context *fc)
419{
420	struct vboxsf_fs_context *ctx = fc->fs_private;
421
422	kfree(ctx->nls_name);
423	kfree(ctx);
424}
425
426static const struct fs_context_operations vboxsf_context_ops = {
427	.free			= vboxsf_free_fc,
428	.parse_param		= vboxsf_parse_param,
429	.parse_monolithic	= vboxsf_parse_monolithic,
430	.get_tree		= vboxsf_get_tree,
431	.reconfigure		= vboxsf_reconfigure,
432};
433
434static int vboxsf_init_fs_context(struct fs_context *fc)
435{
436	struct vboxsf_fs_context *ctx;
437
438	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
439	if (!ctx)
440		return -ENOMEM;
441
442	current_uid_gid(&ctx->o.uid, &ctx->o.gid);
443
444	fc->fs_private = ctx;
445	fc->ops = &vboxsf_context_ops;
446	return 0;
447}
448
449static struct file_system_type vboxsf_fs_type = {
450	.owner			= THIS_MODULE,
451	.name			= "vboxsf",
452	.init_fs_context	= vboxsf_init_fs_context,
453	.kill_sb		= kill_anon_super
454};
455
456/* Module initialization/finalization handlers */
457static int __init vboxsf_init(void)
458{
459	return register_filesystem(&vboxsf_fs_type);
460}
461
462static void __exit vboxsf_fini(void)
463{
464	unregister_filesystem(&vboxsf_fs_type);
465
466	mutex_lock(&vboxsf_setup_mutex);
467	if (vboxsf_setup_done) {
468		vboxsf_disconnect();
469		/*
470		 * Make sure all delayed rcu free inodes are flushed
471		 * before we destroy the cache.
472		 */
473		rcu_barrier();
474		kmem_cache_destroy(vboxsf_inode_cachep);
475	}
476	mutex_unlock(&vboxsf_setup_mutex);
477}
478
479module_init(vboxsf_init);
480module_exit(vboxsf_fini);
481
482MODULE_DESCRIPTION("Oracle VM VirtualBox Module for Host File System Access");
483MODULE_AUTHOR("Oracle Corporation");
484MODULE_LICENSE("GPL v2");
485MODULE_ALIAS_FS("vboxsf");
486