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