xref: /openbmc/linux/fs/vboxsf/super.c (revision 93ac74cd) 
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 
24 static const unsigned char VBSF_MOUNT_SIGNATURE[4] = "\000\377\376\375";
25 
26 static int follow_symlinks;
27 module_param(follow_symlinks, int, 0444);
28 MODULE_PARM_DESC(follow_symlinks,
29 		 "Let host resolve symlinks rather than showing them");
30 
31 static DEFINE_IDA(vboxsf_bdi_ida);
32 static DEFINE_MUTEX(vboxsf_setup_mutex);
33 static bool vboxsf_setup_done;
34 static struct super_operations vboxsf_super_ops; /* forward declaration */
35 static struct kmem_cache *vboxsf_inode_cachep;
36 
37 static char * const vboxsf_default_nls = CONFIG_NLS_DEFAULT;
38 
39 enum  { opt_nls, opt_uid, opt_gid, opt_ttl, opt_dmode, opt_fmode,
40 	opt_dmask, opt_fmask };
41 
42 static 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 
54 static 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 
119 static 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_simple_get(&vboxsf_bdi_ida, 0, 0, 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 
220 fail_unmap:
221 	vboxsf_unmap_folder(sbi->root);
222 fail_free:
223 	if (sbi->bdi_id >= 0)
224 		ida_simple_remove(&vboxsf_bdi_ida, sbi->bdi_id);
225 	if (sbi->nls)
226 		unload_nls(sbi->nls);
227 fail_destroy_idr:
228 	idr_destroy(&sbi->ino_idr);
229 	kfree(sbi);
230 	return err;
231 }
232 
233 static 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 
241 static 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 
255 static 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 
266 static 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_simple_remove(&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 
285 static 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 
324 static 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 
331 static 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_MEM_SPREAD |
344 				   SLAB_ACCOUNT),
345 				  vboxsf_inode_init_once);
346 	if (!vboxsf_inode_cachep) {
347 		err = -ENOMEM;
348 		goto fail_nomem;
349 	}
350 
351 	err = vboxsf_connect();
352 	if (err) {
353 		vbg_err("vboxsf: err %d connecting to guest PCI-device\n", err);
354 		vbg_err("vboxsf: make sure you are inside a VirtualBox VM\n");
355 		vbg_err("vboxsf: and check dmesg for vboxguest errors\n");
356 		goto fail_free_cache;
357 	}
358 
359 	err = vboxsf_set_utf8();
360 	if (err) {
361 		vbg_err("vboxsf_setutf8 error %d\n", err);
362 		goto fail_disconnect;
363 	}
364 
365 	if (!follow_symlinks) {
366 		err = vboxsf_set_symlinks();
367 		if (err)
368 			vbg_warn("vboxsf: Unable to show symlinks: %d\n", err);
369 	}
370 
371 	vboxsf_setup_done = true;
372 success:
373 	mutex_unlock(&vboxsf_setup_mutex);
374 	return 0;
375 
376 fail_disconnect:
377 	vboxsf_disconnect();
378 fail_free_cache:
379 	kmem_cache_destroy(vboxsf_inode_cachep);
380 fail_nomem:
381 	mutex_unlock(&vboxsf_setup_mutex);
382 	return err;
383 }
384 
385 static int vboxsf_parse_monolithic(struct fs_context *fc, void *data)
386 {
387 	if (data && !memcmp(data, VBSF_MOUNT_SIGNATURE, 4)) {
388 		vbg_err("vboxsf: Old binary mount data not supported, remove obsolete mount.vboxsf and/or update your VBoxService.\n");
389 		return -EINVAL;
390 	}
391 
392 	return generic_parse_monolithic(fc, data);
393 }
394 
395 static int vboxsf_get_tree(struct fs_context *fc)
396 {
397 	int err;
398 
399 	err = vboxsf_setup();
400 	if (err)
401 		return err;
402 
403 	return get_tree_nodev(fc, vboxsf_fill_super);
404 }
405 
406 static int vboxsf_reconfigure(struct fs_context *fc)
407 {
408 	struct vboxsf_sbi *sbi = VBOXSF_SBI(fc->root->d_sb);
409 	struct vboxsf_fs_context *ctx = fc->fs_private;
410 	struct inode *iroot = fc->root->d_sb->s_root->d_inode;
411 
412 	/* Apply changed options to the root inode */
413 	sbi->o = ctx->o;
414 	vboxsf_init_inode(sbi, iroot, &sbi->root_info, true);
415 
416 	return 0;
417 }
418 
419 static void vboxsf_free_fc(struct fs_context *fc)
420 {
421 	struct vboxsf_fs_context *ctx = fc->fs_private;
422 
423 	kfree(ctx->nls_name);
424 	kfree(ctx);
425 }
426 
427 static const struct fs_context_operations vboxsf_context_ops = {
428 	.free			= vboxsf_free_fc,
429 	.parse_param		= vboxsf_parse_param,
430 	.parse_monolithic	= vboxsf_parse_monolithic,
431 	.get_tree		= vboxsf_get_tree,
432 	.reconfigure		= vboxsf_reconfigure,
433 };
434 
435 static int vboxsf_init_fs_context(struct fs_context *fc)
436 {
437 	struct vboxsf_fs_context *ctx;
438 
439 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
440 	if (!ctx)
441 		return -ENOMEM;
442 
443 	current_uid_gid(&ctx->o.uid, &ctx->o.gid);
444 
445 	fc->fs_private = ctx;
446 	fc->ops = &vboxsf_context_ops;
447 	return 0;
448 }
449 
450 static struct file_system_type vboxsf_fs_type = {
451 	.owner			= THIS_MODULE,
452 	.name			= "vboxsf",
453 	.init_fs_context	= vboxsf_init_fs_context,
454 	.kill_sb		= kill_anon_super
455 };
456 
457 /* Module initialization/finalization handlers */
458 static int __init vboxsf_init(void)
459 {
460 	return register_filesystem(&vboxsf_fs_type);
461 }
462 
463 static void __exit vboxsf_fini(void)
464 {
465 	unregister_filesystem(&vboxsf_fs_type);
466 
467 	mutex_lock(&vboxsf_setup_mutex);
468 	if (vboxsf_setup_done) {
469 		vboxsf_disconnect();
470 		/*
471 		 * Make sure all delayed rcu free inodes are flushed
472 		 * before we destroy the cache.
473 		 */
474 		rcu_barrier();
475 		kmem_cache_destroy(vboxsf_inode_cachep);
476 	}
477 	mutex_unlock(&vboxsf_setup_mutex);
478 }
479 
480 module_init(vboxsf_init);
481 module_exit(vboxsf_fini);
482 
483 MODULE_DESCRIPTION("Oracle VM VirtualBox Module for Host File System Access");
484 MODULE_AUTHOR("Oracle Corporation");
485 MODULE_LICENSE("GPL v2");
486 MODULE_ALIAS_FS("vboxsf");
487