VirtualBox

source: vbox/trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c@ 36638

Last change on this file since 36638 was 36471, checked in by vboxsync, 14 years ago

Linux 2.6.39-rc1 compile fixes

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 14.0 KB
Line 
1/** @file
2 *
3 * vboxsf -- VirtualBox Guest Additions for Linux:
4 * Virtual File System for VirtualBox Shared Folders
5 *
6 * Module initialization/finalization
7 * File system registration/deregistration
8 * Superblock reading
9 * Few utility functions
10 */
11
12/*
13 * Copyright (C) 2006-2010 Oracle Corporation
14 *
15 * This file is part of VirtualBox Open Source Edition (OSE), as
16 * available from http://www.virtualbox.org. This file is free software;
17 * you can redistribute it and/or modify it under the terms of the GNU
18 * General Public License (GPL) as published by the Free Software
19 * Foundation, in version 2 as it comes in the "COPYING" file of the
20 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
21 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
22 */
23
24/**
25 * @note Anyone wishing to make changes here might wish to take a look at
26 * http://www.atnf.csiro.au/people/rgooch/linux/vfs.txt
27 * which seems to be the closest there is to official documentation on
28 * writing filesystem drivers for Linux.
29 */
30
31#include "vfsmod.h"
32
33MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access");
34MODULE_AUTHOR(VBOX_VENDOR);
35MODULE_LICENSE("GPL");
36#ifdef MODULE_VERSION
37MODULE_VERSION(VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")");
38#endif
39
40/* globals */
41VBSFCLIENT client_handle;
42
43/* forward declarations */
44static struct super_operations sf_super_ops;
45
46/* allocate global info, try to map host share */
47static int sf_glob_alloc(struct vbsf_mount_info_new *info, struct sf_glob_info **sf_gp)
48{
49 int err, rc;
50 SHFLSTRING *str_name;
51 size_t name_len, str_len;
52 struct sf_glob_info *sf_g;
53
54 TRACE();
55 sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL);
56 if (!sf_g)
57 {
58 err = -ENOMEM;
59 LogRelFunc(("could not allocate memory for global info\n"));
60 goto fail0;
61 }
62
63 RT_ZERO(*sf_g);
64
65 if ( info->nullchar != '\0'
66 || info->signature[0] != VBSF_MOUNT_SIGNATURE_BYTE_0
67 || info->signature[1] != VBSF_MOUNT_SIGNATURE_BYTE_1
68 || info->signature[2] != VBSF_MOUNT_SIGNATURE_BYTE_2)
69 {
70 /* An old version of mount.vboxsf made the syscall. Translate the
71 * old parameters to the new structure. */
72 struct vbsf_mount_info_old *info_old = (struct vbsf_mount_info_old *)info;
73 static struct vbsf_mount_info_new info_compat;
74
75 info = &info_compat;
76 memset(info, 0, sizeof(*info));
77 memcpy(&info->name, &info_old->name, MAX_HOST_NAME);
78 memcpy(&info->nls_name, &info_old->nls_name, MAX_NLS_NAME);
79 info->length = offsetof(struct vbsf_mount_info_new, dmode);
80 info->uid = info_old->uid;
81 info->gid = info_old->gid;
82 info->ttl = info_old->ttl;
83 }
84
85 info->name[sizeof(info->name) - 1] = 0;
86 info->nls_name[sizeof(info->nls_name) - 1] = 0;
87
88 name_len = strlen(info->name);
89 if (name_len > 0xfffe)
90 {
91 err = -ENAMETOOLONG;
92 LogFunc(("map name too big\n"));
93 goto fail1;
94 }
95
96 str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
97 str_name = kmalloc(str_len, GFP_KERNEL);
98 if (!str_name)
99 {
100 err = -ENOMEM;
101 LogRelFunc(("could not allocate memory for host name\n"));
102 goto fail1;
103 }
104
105 str_name->u16Length = name_len;
106 str_name->u16Size = name_len + 1;
107 memcpy(str_name->String.utf8, info->name, name_len + 1);
108
109 if (info->nls_name[0] && strcmp(info->nls_name, "utf8"))
110 {
111 sf_g->nls = load_nls(info->nls_name);
112 if (!sf_g->nls)
113 {
114 err = -EINVAL;
115 LogFunc(("failed to load nls %s\n", info->nls_name));
116 goto fail1;
117 }
118 }
119 else
120 sf_g->nls = NULL;
121
122 rc = vboxCallMapFolder(&client_handle, str_name, &sf_g->map);
123 kfree(str_name);
124
125 if (RT_FAILURE(rc))
126 {
127 err = -EPROTO;
128 LogFunc(("vboxCallMapFolder failed rc=%d\n", rc));
129 goto fail2;
130 }
131
132 sf_g->ttl = info->ttl;
133 sf_g->uid = info->uid;
134 sf_g->gid = info->gid;
135
136 if ((unsigned)info->length >= sizeof(struct vbsf_mount_info_new))
137 {
138 /* new fields */
139 sf_g->dmode = info->dmode;
140 sf_g->fmode = info->fmode;
141 sf_g->dmask = info->dmask;
142 sf_g->fmask = info->fmask;
143 }
144 else
145 {
146 sf_g->dmode = ~0;
147 sf_g->fmode = ~0;
148 }
149
150 *sf_gp = sf_g;
151 return 0;
152
153fail2:
154 if (sf_g->nls)
155 unload_nls(sf_g->nls);
156
157fail1:
158 kfree(sf_g);
159
160fail0:
161 return err;
162}
163
164/* unmap the share and free global info [sf_g] */
165static void
166sf_glob_free(struct sf_glob_info *sf_g)
167{
168 int rc;
169
170 TRACE();
171 rc = vboxCallUnmapFolder(&client_handle, &sf_g->map);
172 if (RT_FAILURE(rc))
173 LogFunc(("vboxCallUnmapFolder failed rc=%d\n", rc));
174
175 if (sf_g->nls)
176 unload_nls(sf_g->nls);
177
178 kfree(sf_g);
179}
180
181/**
182 * This is called (by sf_read_super_[24|26] when vfs mounts the fs and
183 * wants to read super_block.
184 *
185 * calls [sf_glob_alloc] to map the folder and allocate global
186 * information structure.
187 *
188 * initializes [sb], initializes root inode and dentry.
189 *
190 * should respect [flags]
191 */
192static int sf_read_super_aux(struct super_block *sb, void *data, int flags)
193{
194 int err;
195 struct dentry *droot;
196 struct inode *iroot;
197 struct sf_inode_info *sf_i;
198 struct sf_glob_info *sf_g;
199 SHFLFSOBJINFO fsinfo;
200 struct vbsf_mount_info_new *info;
201
202 TRACE();
203 if (!data)
204 {
205 LogFunc(("no mount info specified\n"));
206 return -EINVAL;
207 }
208
209 info = data;
210
211 if (flags & MS_REMOUNT)
212 {
213 LogFunc(("remounting is not supported\n"));
214 return -ENOSYS;
215 }
216
217 err = sf_glob_alloc(info, &sf_g);
218 if (err)
219 goto fail0;
220
221 sf_i = kmalloc(sizeof (*sf_i), GFP_KERNEL);
222 if (!sf_i)
223 {
224 err = -ENOMEM;
225 LogRelFunc(("could not allocate memory for root inode info\n"));
226 goto fail1;
227 }
228
229 sf_i->handle = SHFL_HANDLE_NIL;
230 sf_i->path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL);
231 if (!sf_i->path)
232 {
233 err = -ENOMEM;
234 LogRelFunc(("could not allocate memory for root inode path\n"));
235 goto fail2;
236 }
237
238 sf_i->path->u16Length = 1;
239 sf_i->path->u16Size = 2;
240 sf_i->path->String.utf8[0] = '/';
241 sf_i->path->String.utf8[1] = 0;
242
243 err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
244 if (err)
245 {
246 LogFunc(("could not stat root of share\n"));
247 goto fail3;
248 }
249
250 sb->s_magic = 0xface;
251 sb->s_blocksize = 1024;
252#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 3)
253 /* Required for seek/sendfile.
254 *
255 * Must by less than or equal to INT64_MAX despite the fact that the
256 * declaration of this variable is unsigned long long. See determination
257 * of 'loff_t max' in fs/read_write.c / do_sendfile(). I don't know the
258 * correct limit but MAX_LFS_FILESIZE (8TB-1 on 32-bit boxes) takes the
259 * page cache into account and is the suggested limit. */
260# if defined MAX_LFS_FILESIZE
261 sb->s_maxbytes = MAX_LFS_FILESIZE;
262# else
263 sb->s_maxbytes = 0x7fffffffffffffffULL;
264# endif
265#endif
266 sb->s_op = &sf_super_ops;
267
268#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
269 iroot = iget_locked(sb, 0);
270#else
271 iroot = iget(sb, 0);
272#endif
273 if (!iroot)
274 {
275 err = -ENOMEM; /* XXX */
276 LogFunc(("could not get root inode\n"));
277 goto fail3;
278 }
279
280 if (sf_init_backing_dev(sf_g, info->name))
281 {
282 err = -EINVAL;
283 LogFunc(("could not init bdi\n"));
284 goto fail4;
285 }
286
287 sf_init_inode(sf_g, iroot, &fsinfo);
288 SET_INODE_INFO(iroot, sf_i);
289
290#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
291 unlock_new_inode(iroot);
292#endif
293
294 droot = d_alloc_root(iroot);
295 if (!droot)
296 {
297 err = -ENOMEM; /* XXX */
298 LogFunc(("d_alloc_root failed\n"));
299 goto fail5;
300 }
301
302 sb->s_root = droot;
303 SET_GLOB_INFO(sb, sf_g);
304 return 0;
305
306fail5:
307 sf_done_backing_dev(sf_g);
308
309fail4:
310 iput(iroot);
311
312fail3:
313 kfree(sf_i->path);
314
315fail2:
316 kfree(sf_i);
317
318fail1:
319 sf_glob_free(sf_g);
320
321fail0:
322 return err;
323}
324
325#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
326static struct super_block *
327sf_read_super_24(struct super_block *sb, void *data, int flags)
328{
329 int err;
330
331 TRACE();
332 err = sf_read_super_aux(sb, data, flags);
333 if (err)
334 return NULL;
335
336 return sb;
337}
338#endif
339
340/* this is called when vfs is about to destroy the [inode]. all
341 resources associated with this [inode] must be cleared here */
342#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
343static void sf_clear_inode(struct inode *inode)
344{
345 struct sf_inode_info *sf_i;
346
347 TRACE();
348 sf_i = GET_INODE_INFO(inode);
349 if (!sf_i)
350 return;
351
352 BUG_ON(!sf_i->path);
353 kfree(sf_i->path);
354 kfree(sf_i);
355 SET_INODE_INFO(inode, NULL);
356}
357#else
358static void sf_evict_inode(struct inode *inode)
359{
360 struct sf_inode_info *sf_i;
361
362 TRACE();
363 truncate_inode_pages(&inode->i_data, 0);
364 end_writeback(inode);
365
366 sf_i = GET_INODE_INFO(inode);
367 if (!sf_i)
368 return;
369
370 BUG_ON(!sf_i->path);
371 kfree(sf_i->path);
372 kfree(sf_i);
373 SET_INODE_INFO(inode, NULL);
374}
375#endif
376
377/* this is called by vfs when it wants to populate [inode] with data.
378 the only thing that is known about inode at this point is its index
379 hence we can't do anything here, and let lookup/whatever with the
380 job to properly fill then [inode] */
381#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
382static void sf_read_inode(struct inode *inode)
383{
384}
385#endif
386
387/* vfs is done with [sb] (umount called) call [sf_glob_free] to unmap
388 the folder and free [sf_g] */
389static void sf_put_super(struct super_block *sb)
390{
391 struct sf_glob_info *sf_g;
392
393 sf_g = GET_GLOB_INFO(sb);
394 BUG_ON(!sf_g);
395 sf_done_backing_dev(sf_g);
396 sf_glob_free(sf_g);
397}
398
399#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
400static int sf_statfs(struct super_block *sb, STRUCT_STATFS *stat)
401{
402 return sf_get_volume_info(sb, stat);
403}
404#else
405static int sf_statfs(struct dentry *dentry, STRUCT_STATFS *stat)
406{
407 struct super_block *sb = dentry->d_inode->i_sb;
408 return sf_get_volume_info(sb, stat);
409}
410#endif
411
412static int sf_remount_fs(struct super_block *sb, int *flags, char *data)
413{
414 TRACE();
415 return -ENOSYS;
416}
417
418static struct super_operations sf_super_ops =
419{
420#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
421 .clear_inode = sf_clear_inode,
422#else
423 .evict_inode = sf_evict_inode,
424#endif
425#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
426 .read_inode = sf_read_inode,
427#endif
428 .put_super = sf_put_super,
429 .statfs = sf_statfs,
430 .remount_fs = sf_remount_fs
431};
432
433#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
434static DECLARE_FSTYPE(vboxsf_fs_type, "vboxsf", sf_read_super_24, 0);
435#else
436static int
437sf_read_super_26(struct super_block *sb, void *data, int flags)
438{
439 int err;
440
441 TRACE();
442 err = sf_read_super_aux(sb, data, flags);
443 if (err)
444 printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
445
446 return err;
447}
448
449# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
450static struct super_block *sf_get_sb(struct file_system_type *fs_type, int flags,
451 const char *dev_name, void *data)
452{
453 TRACE();
454 return get_sb_nodev(fs_type, flags, data, sf_read_super_26);
455}
456# elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
457static int sf_get_sb(struct file_system_type *fs_type, int flags,
458 const char *dev_name, void *data, struct vfsmount *mnt)
459{
460 TRACE();
461 return get_sb_nodev(fs_type, flags, data, sf_read_super_26, mnt);
462}
463# else
464static struct dentry *sf_mount(struct file_system_type *fs_type, int flags,
465 const char *dev_name, void *data)
466{
467 TRACE();
468 return mount_nodev(fs_type, flags, data, sf_read_super_26);
469}
470# endif
471
472static struct file_system_type vboxsf_fs_type =
473{
474 .owner = THIS_MODULE,
475 .name = "vboxsf",
476# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
477 .get_sb = sf_get_sb,
478# else
479 .mount = sf_mount,
480# endif
481 .kill_sb = kill_anon_super
482};
483#endif
484
485#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
486static int follow_symlinks = 0;
487module_param(follow_symlinks, bool, 0);
488MODULE_PARM_DESC(follow_symlinks, "Let host resolve symlinks rather than showing them");
489#endif
490
491/* Module initialization/finalization handlers */
492static int __init init(void)
493{
494 int rcVBox;
495 int rcRet = 0;
496 int err;
497
498 TRACE();
499
500 if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE)
501 {
502 printk(KERN_ERR
503 "Mount information structure is too large %lu\n"
504 "Must be less than or equal to %lu\n",
505 (unsigned long)sizeof (struct vbsf_mount_info_new),
506 (unsigned long)PAGE_SIZE);
507 return -EINVAL;
508 }
509
510 err = register_filesystem(&vboxsf_fs_type);
511 if (err)
512 {
513 LogFunc(("register_filesystem err=%d\n", err));
514 return err;
515 }
516
517 rcVBox = vboxInit();
518 if (RT_FAILURE(rcVBox))
519 {
520 LogRelFunc(("vboxInit failed, rc=%d\n", rcVBox));
521 rcRet = -EPROTO;
522 goto fail0;
523 }
524
525 rcVBox = vboxConnect(&client_handle);
526 if (RT_FAILURE(rcVBox))
527 {
528 LogRelFunc(("vboxConnect failed, rc=%d\n", rcVBox));
529 rcRet = -EPROTO;
530 goto fail1;
531 }
532
533 rcVBox = vboxCallSetUtf8(&client_handle);
534 if (RT_FAILURE(rcVBox))
535 {
536 LogRelFunc(("vboxCallSetUtf8 failed, rc=%d\n", rcVBox));
537 rcRet = -EPROTO;
538 goto fail2;
539 }
540
541#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
542 if (!follow_symlinks)
543 {
544 rcVBox = vboxCallSetSymlinks(&client_handle);
545 if (RT_FAILURE(rcVBox))
546 {
547 printk(KERN_WARNING
548 "vboxsf: Host unable to show symlinks, rc=%d\n",
549 rcVBox);
550 }
551 }
552#endif
553
554 printk(KERN_DEBUG
555 "vboxsf: Successfully loaded version " VBOX_VERSION_STRING
556 " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
557
558 return 0;
559
560fail2:
561 vboxDisconnect(&client_handle);
562
563fail1:
564 vboxUninit();
565
566fail0:
567 unregister_filesystem(&vboxsf_fs_type);
568 return rcRet;
569}
570
571static void __exit fini(void)
572{
573 TRACE();
574
575 vboxDisconnect(&client_handle);
576 vboxUninit();
577 unregister_filesystem(&vboxsf_fs_type);
578}
579
580module_init(init);
581module_exit(fini);
582
583/* C++ hack */
584int __gxx_personality_v0 = 0xdeadbeef;
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette