VirtualBox

source: vbox/trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.c@ 47551

Last change on this file since 47551 was 44528, checked in by vboxsync, 12 years ago

header (C) fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 13.6 KB
Line 
1/** @file
2 * VirtualBox File System for Solaris Guests, VFS implementation.
3 */
4
5/*
6 * Copyright (C) 2009-2011 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#include <VBox/log.h>
27#include <VBox/version.h>
28
29#include <sys/types.h>
30#include <sys/mntent.h>
31#include <sys/param.h>
32#include <sys/modctl.h>
33#include <sys/mount.h>
34#include <sys/policy.h>
35#include <sys/atomic.h>
36#include <sys/sysmacros.h>
37#include <sys/ddi.h>
38#include <sys/sunddi.h>
39#include <sys/vfs.h>
40#if !defined(VBOX_VFS_SOLARIS_10U6)
41#include <sys/vfs_opreg.h>
42#endif
43#include <sys/pathname.h>
44#include "vboxfs_prov.h"
45#include "vboxfs_vnode.h"
46#include "vboxfs_vfs.h"
47#include "vboxfs.h"
48
49#ifdef u
50#undef u
51#endif
52
53#define VBOXSOLQUOTE2(x) #x
54#define VBOXSOLQUOTE(x) VBOXSOLQUOTE2(x)
55/** The module name. */
56#define DEVICE_NAME "vboxfs"
57/** The module description as seen in 'modinfo'. */
58#define DEVICE_DESC "VirtualBox ShrdFS"
59
60
61/*
62 * Shared Folders filesystem implementation of the Solaris VFS interfaces.
63 * Much of this is cookie cutter code for Solaris filesystem implementation.
64 */
65
66/* forward declarations */
67static int sffs_init(int fstype, char *name);
68static int sffs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
69static int sffs_unmount(vfs_t *vfsp, int flag, cred_t *cr);
70static int sffs_root(vfs_t *vfsp, vnode_t **vpp);
71static int sffs_statvfs(vfs_t *vfsp, statvfs64_t *sbp);
72
73static mntopt_t sffs_options[] = {
74 /* Option Cancels Opt Arg Flags Data */
75 {"uid", NULL, NULL, MO_HASVALUE, NULL},
76 {"gid", NULL, NULL, MO_HASVALUE, NULL},
77 {"dmode", NULL, NULL, MO_HASVALUE, NULL},
78 {"fmode", NULL, NULL, MO_HASVALUE, NULL},
79 {"dmask", NULL, NULL, MO_HASVALUE, NULL},
80 {"fmask", NULL, NULL, MO_HASVALUE, NULL},
81 {"stat_ttl", NULL, NULL, MO_HASVALUE, NULL},
82 {"fsync", NULL, NULL, 0, NULL}
83};
84
85static mntopts_t sffs_options_table = {
86 sizeof (sffs_options) / sizeof (mntopt_t),
87 sffs_options
88};
89
90static vfsdef_t sffs_vfsdef = {
91 VFSDEF_VERSION,
92 DEVICE_NAME,
93 sffs_init,
94 VSW_HASPROTO,
95 &sffs_options_table
96};
97
98static int sffs_fstype;
99static int sffs_major; /* major number for device */
100
101kmutex_t sffs_minor_lock;
102int sffs_minor; /* minor number for device */
103
104/*
105 * Module linkage information
106 */
107static struct modlfs modlfs = {
108 &mod_fsops,
109 DEVICE_DESC " " VBOX_VERSION_STRING "r" VBOXSOLQUOTE(VBOX_SVN_REV),
110 &sffs_vfsdef
111};
112
113static struct modlinkage modlinkage = {
114 MODREV_1, &modlfs, NULL
115};
116
117static sfp_connection_t *sfprov = NULL;
118
119int
120_init()
121{
122 return (mod_install(&modlinkage));
123}
124
125int
126_info(struct modinfo *modinfop)
127{
128 return (mod_info(&modlinkage, modinfop));
129}
130
131
132int
133_fini()
134{
135 int error;
136
137 error = mod_remove(&modlinkage);
138 if (error)
139 return (error);
140
141 /*
142 * Tear down the operations vectors
143 */
144 sffs_vnode_fini();
145 (void) vfs_freevfsops_by_type(sffs_fstype);
146
147 /*
148 * close connection to the provider
149 */
150 sfprov_disconnect(sfprov);
151 return (0);
152}
153
154
155static int
156sffs_init(int fstype, char *name)
157{
158#if defined(VBOX_VFS_SOLARIS_10U6)
159 static const fs_operation_def_t sffs_vfsops_template[] = {
160 VFSNAME_MOUNT, sffs_mount,
161 VFSNAME_UNMOUNT, sffs_unmount,
162 VFSNAME_ROOT, sffs_root,
163 VFSNAME_STATVFS, sffs_statvfs,
164 NULL, NULL
165 };
166#else
167 static const fs_operation_def_t sffs_vfsops_template[] = {
168 VFSNAME_MOUNT, { .vfs_mount = sffs_mount },
169 VFSNAME_UNMOUNT, { .vfs_unmount = sffs_unmount },
170 VFSNAME_ROOT, { .vfs_root = sffs_root },
171 VFSNAME_STATVFS, { .vfs_statvfs = sffs_statvfs },
172 NULL, NULL
173 };
174#endif
175 int error;
176
177 ASSERT(fstype != 0);
178 sffs_fstype = fstype;
179 LogFlowFunc(("sffs_init() name=%s\n", name));
180
181 /*
182 * This may seem a silly way to do things for now. But the code
183 * is structured to easily allow it to be used on other hypervisors
184 * which would have a different implementation of the provider.
185 * Hopefully that'll never happen. :)
186 */
187 sfprov = sfprov_connect(SFPROV_VERSION);
188 if (sfprov == NULL) {
189 cmn_err(CE_WARN, "sffs_init: couldn't init sffs provider");
190 return (ENODEV);
191 }
192
193 error = sfprov_set_show_symlinks();
194 if (error != 0) {
195 cmn_err(CE_WARN, "sffs_init: host unable to show symlinks, "
196 "rc=%d\n", error);
197 }
198
199 error = vfs_setfsops(fstype, sffs_vfsops_template, NULL);
200 if (error != 0) {
201 cmn_err(CE_WARN, "sffs_init: bad vfs ops template");
202 return (error);
203 }
204
205 error = sffs_vnode_init();
206 if (error != 0) {
207 (void) vfs_freevfsops_by_type(fstype);
208 cmn_err(CE_WARN, "sffs_init: bad vnode ops template");
209 return (error);
210 }
211
212 if ((sffs_major = getudev()) == (major_t)-1) {
213 cmn_err(CE_WARN, "sffs_init: Can't get unique device number.");
214 sffs_major = 0;
215 }
216 mutex_init(&sffs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
217 return (0);
218}
219
220/*
221 * wrapper for pn_get
222 */
223static int
224sf_pn_get(char *rawpath, struct mounta *uap, char **outpath)
225{
226 pathname_t path;
227 int error;
228
229 error = pn_get(rawpath, (uap->flags & MS_SYSSPACE) ? UIO_SYSSPACE :
230 UIO_USERSPACE, &path);
231 if (error) {
232 LogFlowFunc(("pn_get(%s) failed\n", rawpath));
233 return (error);
234 }
235 *outpath = kmem_alloc(path.pn_pathlen + 1, KM_SLEEP);
236 strcpy(*outpath, path.pn_path);
237 pn_free(&path);
238 return (0);
239}
240
241static int
242sffs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
243{
244 sffs_data_t *sffs;
245 char *mount_point = NULL;
246 char *share_name = NULL;
247 int error;
248 dev_t dev;
249 uid_t uid = 0;
250 gid_t gid = 0;
251 mode_t dmode = ~0;
252 mode_t fmode = ~0;
253 mode_t dmask = 0;
254 mode_t fmask = 0;
255 int stat_ttl = DEF_STAT_TTL_MS;
256 int fsync = 0;
257 char *optval;
258 long val;
259 char *path;
260 sfp_mount_t *handle;
261 sfnode_t *sfnode;
262
263 /*
264 * check we have permission to do the mount
265 */
266 LogFlowFunc(("sffs_mount() started\n"));
267 error = secpolicy_fs_mount(cr, mvp, vfsp);
268 if (error != 0)
269 return (error);
270
271 /*
272 * Mount point must be a directory
273 */
274 if (mvp->v_type != VDIR)
275 return (ENOTDIR);
276
277 /*
278 * no support for remount (what is it?)
279 */
280 if (uap->flags & MS_REMOUNT)
281 return (ENOTSUP);
282
283 /*
284 * Ensure that nothing else is actively in/under the mount point
285 */
286 mutex_enter(&mvp->v_lock);
287 if ((uap->flags & MS_OVERLAY) == 0 &&
288 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
289 mutex_exit(&mvp->v_lock);
290 return (EBUSY);
291 }
292 mutex_exit(&mvp->v_lock);
293
294 /*
295 * check for read only has to be done early
296 */
297 if (uap->flags & MS_RDONLY) {
298 vfsp->vfs_flag |= VFS_RDONLY;
299 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
300 }
301
302 /*
303 * UID to use for all files
304 */
305 if (vfs_optionisset(vfsp, "uid", &optval) &&
306 ddi_strtol(optval, NULL, 10, &val) == 0 &&
307 (uid_t)val == val)
308 uid = val;
309
310 /*
311 * GID to use for all files
312 */
313 if (vfs_optionisset(vfsp, "gid", &optval) &&
314 ddi_strtol(optval, NULL, 10, &val) == 0 &&
315 (gid_t)val == val)
316 gid = val;
317
318 /*
319 * dmode to use for all directories
320 */
321 if (vfs_optionisset(vfsp, "dmode", &optval) &&
322 ddi_strtol(optval, NULL, 8, &val) == 0 &&
323 (mode_t)val == val)
324 dmode = val;
325
326 /*
327 * fmode to use for all files
328 */
329 if (vfs_optionisset(vfsp, "fmode", &optval) &&
330 ddi_strtol(optval, NULL, 8, &val) == 0 &&
331 (mode_t)val == val)
332 fmode = val;
333
334 /*
335 * dmask to use for all directories
336 */
337 if (vfs_optionisset(vfsp, "dmask", &optval) &&
338 ddi_strtol(optval, NULL, 8, &val) == 0 &&
339 (mode_t)val == val)
340 dmask = val;
341
342 /*
343 * fmask to use for all files
344 */
345 if (vfs_optionisset(vfsp, "fmask", &optval) &&
346 ddi_strtol(optval, NULL, 8, &val) == 0 &&
347 (mode_t)val == val)
348 fmask = val;
349
350 /*
351 * umask to use for all directories & files
352 */
353 if (vfs_optionisset(vfsp, "umask", &optval) &&
354 ddi_strtol(optval, NULL, 8, &val) == 0 &&
355 (mode_t)val == val)
356 dmask = fmask = val;
357
358 /*
359 * ttl to use for stat caches
360 */
361 if (vfs_optionisset(vfsp, "stat_ttl", &optval) &&
362 ddi_strtol(optval, NULL, 10, &val) == 0 &&
363 (int)val == val)
364 {
365 stat_ttl = val;
366 }
367 else
368 vfs_setmntopt(vfsp, "stat_ttl", VBOXSOLQUOTE(DEF_STAT_TTL_MS), 0);
369
370 /*
371 * whether to honor fsync
372 */
373 if (vfs_optionisset(vfsp, "fsync", &optval))
374 fsync = 1;
375
376 /*
377 * Any unknown options are an error
378 */
379 if ((uap->flags & MS_DATA) && uap->datalen > 0) {
380 cmn_err(CE_WARN, "sffs: unknown mount options specified");
381 return (EINVAL);
382 }
383
384 /*
385 * get the mount point pathname
386 */
387 error = sf_pn_get(uap->dir, uap, &mount_point);
388 if (error)
389 return (error);
390
391 /*
392 * find what we are mounting
393 */
394 error = sf_pn_get(uap->spec, uap, &share_name);
395 if (error) {
396 kmem_free(mount_point, strlen(mount_point) + 1);
397 return (error);
398 }
399
400 /*
401 * Invoke Hypervisor mount interface before proceeding
402 */
403 error = sfprov_mount(sfprov, share_name, &handle);
404 if (error) {
405 kmem_free(share_name, strlen(share_name) + 1);
406 kmem_free(mount_point, strlen(mount_point) + 1);
407 return (error);
408 }
409
410 /*
411 * find an available minor device number for this mount
412 */
413 mutex_enter(&sffs_minor_lock);
414 do {
415 sffs_minor = (sffs_minor + 1) & L_MAXMIN32;
416 dev = makedevice(sffs_major, sffs_minor);
417 } while (vfs_devismounted(dev));
418 mutex_exit(&sffs_minor_lock);
419
420 /*
421 * allocate and fill in the sffs structure
422 */
423 sffs = kmem_alloc(sizeof (*sffs), KM_SLEEP);
424 sffs->sf_vfsp = vfsp;
425 sffs->sf_uid = uid;
426 sffs->sf_gid = gid;
427 sffs->sf_dmode = dmode;
428 sffs->sf_fmode = fmode;
429 sffs->sf_dmask = dmask;
430 sffs->sf_fmask = fmask;
431 sffs->sf_stat_ttl = stat_ttl;
432 sffs->sf_fsync = fsync;
433 sffs->sf_share_name = share_name;
434 sffs->sf_mntpath = mount_point;
435 sffs->sf_handle = handle;
436 sffs->sf_ino = 3; /* root mount point is always '3' */
437
438 /*
439 * fill in the vfs structure
440 */
441 vfsp->vfs_data = (caddr_t)sffs;
442 vfsp->vfs_fstype = sffs_fstype;
443 vfsp->vfs_dev = dev;
444 vfsp->vfs_bsize = PAGESIZE; /* HERE JOE ??? */
445 vfsp->vfs_flag |= VFS_NOTRUNC; /* HERE JOE ???? */
446 vfs_make_fsid(&vfsp->vfs_fsid, dev, sffs_fstype);
447
448 /*
449 * create the root vnode.
450 * XXX JOE What should the path be here? is "/" really right?
451 * other options?
452 */
453 path = kmem_alloc(2, KM_SLEEP);
454 strcpy(path, ".");
455 mutex_enter(&sffs_lock);
456 sfnode = sfnode_make(sffs, path, VDIR, NULL, NULL, NULL, 0);
457 sffs->sf_rootnode = sfnode_get_vnode(sfnode);
458 sffs->sf_rootnode->v_flag |= VROOT;
459 sffs->sf_rootnode->v_vfsp = vfsp;
460 mutex_exit(&sffs_lock);
461
462 LogFlowFunc(("sffs_mount() success sffs=0x%p\n", sffs));
463 return (error);
464}
465
466static int
467sffs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
468{
469 sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
470 int error;
471
472 /*
473 * generic security check
474 */
475 LogFlowFunc(("sffs_unmount() of sffs=0x%p\n", sffs));
476 if ((error = secpolicy_fs_unmount(cr, vfsp)) != 0)
477 return (error);
478
479 /*
480 * forced unmount is not supported by this file system
481 * and thus, ENOTSUP, is being returned.
482 */
483 if (flag & MS_FORCE)
484 return (ENOTSUP);
485
486 /*
487 * Make sure nothing is still in use.
488 */
489 if (sffs_purge(sffs) != 0)
490 return (EBUSY);
491
492 /*
493 * Invoke Hypervisor unmount interface before proceeding
494 */
495 error = sfprov_unmount(sffs->sf_handle);
496 if (error != 0) {
497 /* TBD anything here? */
498 }
499
500 kmem_free(sffs->sf_share_name, strlen(sffs->sf_share_name) + 1);
501 kmem_free(sffs->sf_mntpath, strlen(sffs->sf_mntpath) + 1);
502 kmem_free(sffs, sizeof(*sffs));
503 LogFlowFunc(("sffs_unmount() done\n"));
504 return (0);
505}
506
507/*
508 * return the vnode for the root of the mounted file system
509 */
510static int
511sffs_root(vfs_t *vfsp, vnode_t **vpp)
512{
513 sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
514 vnode_t *vp = sffs->sf_rootnode;
515
516 VN_HOLD(vp);
517 *vpp = vp;
518 return (0);
519}
520
521/*
522 * get some stats.. fake up the rest
523 */
524static int
525sffs_statvfs(vfs_t *vfsp, statvfs64_t *sbp)
526{
527 sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
528 sffs_fsinfo_t fsinfo;
529 dev32_t d32;
530 int error;
531
532 bzero(sbp, sizeof(*sbp));
533 error = sfprov_get_fsinfo(sffs->sf_handle, &fsinfo);
534 if (error != 0)
535 return (error);
536
537 sbp->f_bsize = fsinfo.blksize;
538 sbp->f_frsize = fsinfo.blksize;
539
540 sbp->f_bfree = fsinfo.blksavail;
541 sbp->f_bavail = fsinfo.blksavail;
542 sbp->f_files = fsinfo.blksavail / 4; /* some kind of reasonable value */
543 sbp->f_ffree = fsinfo.blksavail / 4;
544 sbp->f_favail = fsinfo.blksavail / 4;
545
546 sbp->f_blocks = fsinfo.blksused + sbp->f_bavail;
547
548 (void) cmpldev(&d32, vfsp->vfs_dev);
549 sbp->f_fsid = d32;
550 strcpy(&sbp->f_basetype[0], "sffs");
551 sbp->f_flag |= ST_NOSUID;
552
553 if (fsinfo.readonly)
554 sbp->f_flag |= ST_RDONLY;
555
556 sbp->f_namemax = fsinfo.maxnamesize;
557 return (0);
558}
559
560static void sffs_print(sffs_data_t *sffs)
561{
562 Log(("sffs_data_t at 0x%p\n", sffs));
563 Log((" vfs_t *sf_vfsp = 0x%p\n", sffs->sf_vfsp));
564 Log((" vnode_t *sf_rootnode = 0x%p\n", sffs->sf_rootnode));
565 Log((" uid_t sf_uid = 0x%l\n", (ulong_t)sffs->sf_uid));
566 Log((" gid_t sf_gid = 0x%l\n", (ulong_t)sffs->sf_gid));
567 Log((" mode_t sf_dmode = 0x%l\n", (ulong_t)sffs->sf_dmode));
568 Log((" mode_t sf_fmode = 0x%l\n", (ulong_t)sffs->sf_fmode));
569 Log((" mode_t sf_dmask = 0x%l\n", (ulong_t)sffs->sf_dmask));
570 Log((" mode_t sf_fmask = 0x%l\n", (ulong_t)sffs->sf_fmask));
571 Log((" char *sf_share_name = %s\n", sffs->sf_share_name));
572 Log((" char *sf_mntpath = %s\n", sffs->sf_mntpath));
573 Log((" sfp_mount_t *sf_handle = 0x%p\n", sffs->sf_handle));
574}
575
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