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