vboxvfs_vfsops.c@ 16684

Last change on this file since 16684 was 13835, checked in by vboxsync, 16 years ago
s/VBOX_SUCCESS/RT_SUCCESS/g s/VBOX_FAILURE/RT_FAILURE/g - VBOX_SUCCESS and VBOX_FAILURE have NOT been retired (because old habbits die hard) just sligtly deprecated.
Property svn:eol-style set to `native` Property svn:keyword set to `Id` Property svn:keywords set to `Id`
File size: 19.2 KB

Line
1	/* $Id: vboxvfs_vfsops.c 13835 2008-11-05 02:34:43Z vboxsync $ */
2	/** @file
3	* VirtualBox File System Driver for Solaris Guests. VFS operations.
4	*/
5
6	/*
7	* Copyright (C) 2008 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#include <sys/types.h>
27	#include <sys/mntent.h>
28	#include <sys/param.h>
29	#include <sys/modctl.h>
30	#include <sys/mount.h>
31	#include <sys/policy.h>
32	#include <sys/atomic.h>
33	#include <sys/sysmacros.h>
34	#include <sys/ddi.h>
35	#include <sys/sunddi.h>
36	#ifdef u
37	#undef u
38	#endif
39	#include "vboxvfs.h"
40
41	#if defined(DEBUG_ramshankar) && !defined(LOG_ENABLED)
42	# define LOG_ENABLED
43	# define LOG_TO_BACKDOOR
44	#endif
45	#include <VBox/log.h>
46	#include <iprt/string.h>
47	#include <iprt/mem.h>
48	#include <iprt/err.h>
49	#if defined(DEBUG_ramshankar)
50	# undef LogFlow
51	# define LogFlow LogRel
52	# undef Log
53	# define Log LogRel
54	#endif
55
56	/*******************************************************************************
57	* Defined Constants And Macros *
58	*******************************************************************************/
59	/** Mount Options */
60	#define MNTOPT_VBOXVFS_UID "uid"
61	#define MNTOPT_VBOXVFS_GID "gid"
62
63
64	/*******************************************************************************
65	* Internal Functions *
66	*******************************************************************************/
67	static int VBoxVFS_Init(int fType, char *pszName);
68	static int VBoxVFS_Mount(vfs_t pVFS, vnode_t pVNode, struct mounta pMount, cred_t pCred);
69	static int VBoxVFS_Unmount(vfs_t pVFS, int fFlags, cred_t pCred);
70	static int VBoxVFS_Root(vfs_t pVFS, vnode_t *ppVNode);
71	static int VBoxVFS_Statfs(register vfs_t pVFS, struct statvfs64 pStat);
72	static int VBoxVFS_VGet(vfs_t pVFS, vnode_t ppVNode, struct fid pFid);
73	static void VBoxVFS_FreeVFS(vfs_t *pVFS);
74
75	static int vboxvfs_CheckMountPerm(vfs_t pVFS, struct mounta pMount, vnode_t pVNodeSpec, cred_t pCred);
76	static int vboxvfs_GetIntOpt(vfs_t pVFS, char pszOpt, int *pValue);
77
78
79	/*******************************************************************************
80	* Structures and Typedefs *
81	*******************************************************************************/
82	/**
83	* mntopts_t: mount options table array
84	*/
85	static mntopt_t g_VBoxVFSMountOptions[] =
86	{
87	/* Option Name Cancel Opt. Default Arg Flags Data */
88	{ MNTOPT_VBOXVFS_UID, NULL, NULL, MO_HASVALUE, NULL },
89	{ MNTOPT_VBOXVFS_GID, NULL, NULL, MO_HASVALUE, NULL }
90	};
91
92	/**
93	* mntopts_t: mount options table prototype
94	*/
95	static mntopts_t g_VBoxVFSMountTableProt =
96	{
97	sizeof(g_VBoxVFSMountOptions) / sizeof(mntopt_t),
98	g_VBoxVFSMountOptions
99	};
100
101	/**
102	* vfsdef_t: driver specific mount options
103	*/
104	static vfsdef_t g_VBoxVFSDef =
105	{
106	VFSDEF_VERSION,
107	DEVICE_NAME,
108	VBoxVFS_Init,
109	VSW_HASPROTO,
110	&g_VBoxVFSMountTableProt
111	};
112
113	/**
114	* modlfs: loadable file system
115	*/
116	static struct modlfs g_VBoxVFSLoadMod =
117	{
118	&mod_fsops, /* extern from kernel */
119	DEVICE_DESC,
120	&g_VBoxVFSDef
121	};
122
123	/**
124	* modlinkage: export install/remove/info to the kernel
125	*/
126	static struct modlinkage g_VBoxVFSModLinkage =
127	{
128	MODREV_1, /* loadable module system revision */
129	&g_VBoxVFSLoadMod,
130	NULL /* terminate array of linkage structures */
131	};
132
133
134	/*******************************************************************************
135	* Global Variables *
136	*******************************************************************************/
137	/** GCC C++ hack. */
138	unsigned __gxx_personality_v0 = 0xdecea5ed;
139	/** Global connection to the client. */
140	VBSFCLIENT g_VBoxVFSClient;
141	/** Global VFS Operations pointer. */
142	vfsops_t *g_pVBoxVFS_vfsops;
143	/** The file system type identifier. */
144	static int g_VBoxVFSType;
145	/** Major number of this module */
146	static major_t g_VBoxVFSMajor;
147	/** Minor instance number */
148	static minor_t g_VBoxVFSMinor;
149	/** Minor lock mutex protection */
150	static kmutex_t g_VBoxVFSMinorMtx;
151
152
153	/**
154	* Kernel entry points
155	*/
156	int _init(void)
157	{
158	LogFlow((DEVICE_NAME ":_init\n"));
159
160	return mod_install(&g_VBoxVFSModLinkage);;
161	}
162
163
164	int _fini(void)
165	{
166	LogFlow((DEVICE_NAME ":_fini\n"));
167
168	int rc = mod_remove(&g_VBoxVFSModLinkage);
169	if (rc)
170	return rc;
171
172	/* Blow away the operation vectors*/
173	vfs_freevfsops_by_type(g_VBoxVFSType);
174	vn_freevnodeops(g_pVBoxVFS_vnodeops);
175	}
176
177
178	int _info(struct modinfo *pModInfo)
179	{
180	LogFlow((DEVICE_NAME ":_info\n"));
181
182	return mod_info(&g_VBoxVFSModLinkage, pModInfo);
183	}
184
185
186	static int VBoxVFS_Init(int fType, char *pszName)
187	{
188	int rc;
189
190	LogFlow((DEVICE_NAME ":VBoxVFS_Init\n"));
191
192	g_VBoxVFSType = fType;
193
194	/* Initialize the R0 guest library. */
195	rc = vboxInit();
196	if (RT_SUCCESS(rc))
197	{
198	/* Connect to the host service. */
199	rc = vboxConnect(&g_VBoxVFSClient);
200	if (RT_SUCCESS(rc))
201	{
202	/* Use UTF-8 encoding. */
203	rc = vboxCallSetUtf8 (&g_VBoxVFSClient);
204	if (RT_SUCCESS(rc))
205	{
206	/* Fill up VFS user entry points. */
207	static const fs_operation_def_t s_VBoxVFS_vfsops_template[] =
208	{
209	VFSNAME_MOUNT, { .vfs_mount = VBoxVFS_Mount },
210	VFSNAME_UNMOUNT, { .vfs_unmount = VBoxVFS_Unmount },
211	VFSNAME_ROOT, { .vfs_root = VBoxVFS_Root },
212	VFSNAME_STATVFS, { .vfs_statvfs = VBoxVFS_Statfs },
213	VFSNAME_VGET, { .vfs_vget = VBoxVFS_VGet },
214	VFSNAME_FREEVFS, { .vfs_freevfs = VBoxVFS_FreeVFS },
215	NULL, NULL
216	};
217
218	rc = vfs_setfsops(fType, s_VBoxVFS_vfsops_template, &g_pVBoxVFS_vfsops);
219	if (!rc)
220	{
221	/* Set VNode operations. */
222	rc = vn_make_ops(pszName, g_VBoxVFS_vnodeops_template, &g_pVBoxVFS_vnodeops);
223	if (!rc)
224	{
225	/* Get a free major number. */
226	g_VBoxVFSMajor = getudev();
227	if (g_VBoxVFSMajor != (major_t)-1)
228	{
229	/* Initialize minor mutex here. */
230	mutex_init(&g_VBoxVFSMinorMtx, "VBoxVFSMinorMtx", MUTEX_DEFAULT, NULL);
231	LogFlow((DEVICE_NAME ":Successfully loaded vboxvfs.\n"));
232	return 0;
233	}
234	else
235	{
236	LogRel((DEVICE_NAME ":getudev failed.\n"));
237	rc = EMFILE;
238	}
239	}
240	else
241	LogRel((DEVICE_NAME ":vn_make_ops failed. rc=%d\n", rc));
242	}
243	else
244	LogRel((DEVICE_NAME ":vfs_setfsops failed. rc=%d\n", rc));
245	}
246	else
247	{
248	LogRel((DEVICE_NAME ":vboxCallSetUtf8 failed. rc=%d\n", rc));
249	rc = EPROTO;
250	}
251	vboxDisconnect(&g_VBoxVFSClient);
252	}
253	else
254	{
255	LogRel((DEVICE_NAME ":Failed to connect to host! rc=%d\n", rc));
256	rc = ENXIO;
257	}
258	vboxUninit();
259	}
260	else
261	{
262	LogRel((DEVICE_NAME ":Failed to initialize R0 lib. rc=%d\n", rc));
263	rc = ENXIO;
264	}
265	return rc;
266	}
267
268	static int VBoxVFS_Mount(vfs_t pVFS, vnode_t pVNode, struct mounta pMount, cred_t pCred)
269	{
270	int rc = 0;
271	int Uid = 0;
272	int Gid = 0;
273	char *pszShare = NULL;
274	size_t cbShare = NULL;
275	pathname_t PathName;
276	vboxvfs_vnode_t *pVNodeRoot = NULL;
277	vnode_t *pVNodeSpec = NULL;
278	vnode_t *pVNodeDev = NULL;
279	dev_t Dev = 0;
280	SHFLSTRING *pShflShareName = NULL;
281	RTFSOBJINFO FSInfo;
282	size_t cbShflShareName = 0;
283	vboxvfs_globinfo_t *pVBoxVFSGlobalInfo = NULL;
284	int AddrSpace = (pMount->flags & MS_SYSSPACE) ? UIO_SYSSPACE : UIO_USERSPACE;
285
286	LogFlow((DEVICE_NAME ":VBoxVFS_Mount\n"));
287
288	/* Check user credentials for mounting in the specified target. */
289	rc = secpolicy_fs_mount(pCred, pVNode, pVFS);
290	if (rc)
291	{
292	LogRel((DEVICE_NAME ":VBoxVFS_Mount: secpolicy_fs_mount failed! invalid credentials.rc=%d\n", rc));
293	return EPERM;
294	}
295
296	/* We can mount to only directories. */
297	if (pVNode->v_type != VDIR)
298	return ENOTDIR;
299
300	/* We don't support remounting. */
301	if (pMount->flags & MS_REMOUNT)
302	return ENOTSUP;
303
304	mutex_enter(&pVNode->v_lock);
305	if ( !(pMount->flags & MS_OVERLAY)
306	&& (pVNode->v_count > 1 \|\| (pVNode->v_flag & VROOT)))
307	{
308	LogRel((DEVICE_NAME ":VBoxVFS_Mount: device busy.\n"));
309	mutex_exit(&pVNode->v_lock);
310	return EBUSY;
311	}
312	mutex_exit(&pVNode->v_lock);
313
314	/* From what I understood the options are already parsed at a higher level */
315	if ( (pMount->flags & MS_DATA)
316	&& pMount->datalen > 0)
317	{
318	LogRel((DEVICE_NAME ":VBoxVFS_Mount: unparsed options not supported.\n"));
319	return EINVAL;
320	}
321
322	/* Get UID argument (optional). */
323	rc = vboxvfs_GetIntOpt(pVFS, MNTOPT_VBOXVFS_UID, &Uid);
324	if (rc < 0)
325	{
326	LogRel((DEVICE_NAME ":VBoxVFS_Mount: invalid uid value.\n"));
327	return EINVAL;
328	}
329
330	/* Get GID argument (optional). */
331	rc = vboxvfs_GetIntOpt(pVFS, MNTOPT_VBOXVFS_GID, &Gid);
332	if (rc < 0)
333	{
334	LogRel((DEVICE_NAME ":VBoxVFS_Mount: invalid gid value.\n"));
335	return EINVAL;
336	}
337
338	/* Get special (sharename). */
339	rc = pn_get(pMount->spec, AddrSpace, &PathName);
340	if (!rc)
341	{
342	/* Get an available minor instance number for this mount. */
343	mutex_enter(&g_VBoxVFSMinorMtx);
344	do
345	{
346	atomic_add_32_nv(&g_VBoxVFSMinor, 1) & L_MAXMIN32;
347	Dev = makedevice(g_VBoxVFSMajor, g_VBoxVFSMinor);
348	} while (vfs_devismounted(Dev));
349	mutex_exit(&g_VBoxVFSMinorMtx);
350
351	cbShare = strlen(PathName.pn_path);
352	pszShare = RTMemAlloc(cbShare);
353	if (pszShare)
354	memcpy(pszShare, PathName.pn_path, cbShare);
355	else
356	{
357	LogRel((DEVICE_NAME ":VBoxVFS_Mount: failed to alloc %d bytes for sharename.\n", cbShare));
358	rc = ENOMEM;
359	}
360	}
361	else
362	{
363	LogRel((DEVICE_NAME ":VBoxVFS_Mount: failed to get sharename.rc=%d\n", rc));
364	rc = EINVAL;
365	}
366	pn_free(&PathName);
367
368	if (rc)
369	{
370	if (pszShare)
371	RTMemFree(pszShare);
372	return rc;
373	}
374
375	/* Allocate the global info. structure. */
376	pVBoxVFSGlobalInfo = RTMemAlloc(sizeof(*pVBoxVFSGlobalInfo));
377	if (pVBoxVFSGlobalInfo)
378	{
379	cbShflShareName = offsetof(SHFLSTRING, String.utf8) + cbShare + 1;
380	pShflShareName = RTMemAllocZ(cbShflShareName);
381	if (pShflShareName)
382	{
383	pShflShareName->u16Length = cbShflShareName;
384	pShflShareName->u16Size = cbShflShareName + 1;
385	memcpy (pShflShareName->String.utf8, pszShare, cbShare + 1);
386
387	rc = vboxCallMapFolder(&g_VBoxVFSClient, pShflShareName, &pVBoxVFSGlobalInfo->Map);
388	RTMemFree(pShflShareName);
389	if (RT_SUCCESS(rc))
390	rc = 0;
391	else
392	{
393	LogRel((DEVICE_NAME ":VBoxVFS_Mount: vboxCallMapFolder failed rc=%d\n", rc));
394	rc = EPROTO;
395	}
396	}
397	else
398	{
399	LogRel((DEVICE_NAME ":VBoxVFS_Mount: RTMemAllocZ failed to alloc %d bytes for ShFlShareName.\n", cbShflShareName));
400	rc = ENOMEM;
401	}
402	RTMemFree(pVBoxVFSGlobalInfo);
403	}
404	else
405	{
406	LogRel((DEVICE_NAME ":VBoxVFS_Mount: RTMemAlloc failed to alloc %d bytes for global struct.\n", sizeof(*pVBoxVFSGlobalInfo)));
407	rc = ENOMEM;
408	}
409
410	/* Undo work on failure. */
411	if (rc)
412	goto mntError1;
413
414	/* Initialize the per-filesystem mutex */
415	mutex_init(&pVBoxVFSGlobalInfo->MtxFS, "VBoxVFS_FSMtx", MUTEX_DEFAULT, NULL);
416
417	pVBoxVFSGlobalInfo->Uid = Uid;
418	pVBoxVFSGlobalInfo->Gid = Gid;
419	pVBoxVFSGlobalInfo->pVFS = pVFS;
420	pVFS->vfs_data = pVBoxVFSGlobalInfo;
421	pVFS->vfs_fstype = g_VBoxVFSType;
422	pVFS->vfs_dev = Dev;
423	vfs_make_fsid(&pVFS->vfs_fsid, Dev, g_VBoxVFSType);
424
425	/* Allocate root vboxvfs_vnode_t object */
426	pVNodeRoot = RTMemAlloc(sizeof(*pVNodeRoot));
427	if (pVNodeRoot)
428	{
429	/* Initialize vnode protection mutex */
430	mutex_init(&pVNodeRoot->MtxContents, "VBoxVFS_VNodeMtx", MUTEX_DEFAULT, NULL);
431
432	pVBoxVFSGlobalInfo->pVNodeRoot = pVNodeRoot;
433
434	/* Allocate root path */
435	pVNodeRoot->pPath = RTMemAllocZ(sizeof(SHFLSTRING) + 1);
436	if (pVNodeRoot->pPath)
437	{
438	/* Initialize root path */
439	pVNodeRoot->pPath->u16Length = 1;
440	pVNodeRoot->pPath->u16Size = 2;
441	pVNodeRoot->pPath->String.utf8[0] = '/';
442	pVNodeRoot->pPath->String.utf8[1] = '\0';
443
444	/* Stat root node info from host */
445	rc = vboxvfs_Stat(__func__, pVBoxVFSGlobalInfo, pVNodeRoot->pPath, &FSInfo, B_FALSE);
446	if (!rc)
447	{
448	/* Initialize the root vboxvfs_node_t object */
449	vboxvfs_InitVNode(pVBoxVFSGlobalInfo, pVNodeRoot, &FSInfo);
450
451	/* Success! */
452	LogFlow((DEVICE_NAME ":VBoxVFS_Mount: success!\n", rc));
453	return 0;
454	}
455	else
456	LogRel((DEVICE_NAME ":VBoxVFS_Mount: vboxvfs_Stat failed rc(errno)=%d\n", rc));
457	RTMemFree(pVNodeRoot->pPath);
458	}
459	else
460	{
461	LogRel((DEVICE_NAME ":VBoxVFS_Mount: failed to alloc memory for root node path.\n"));
462	rc = ENOMEM;
463	}
464	RTMemFree(pVNodeRoot);
465	}
466	else
467	{
468	LogRel((DEVICE_NAME ":VBoxVFS_Mount: failed to alloc memory for root node.\n"));
469	rc = ENOMEM;
470	}
471
472	/* Undo work in reverse. */
473	mntError1:
474	RTMemFree(pszShare);
475	return rc;
476	}
477
478	static int VBoxVFS_Unmount(vfs_t pVFS, int fUnmount, cred_t pCred)
479	{
480	int rc;
481	vboxvfs_globinfo_t *pVBoxVFSGlobalInfo;
482
483	LogFlow((DEVICE_NAME ":VBoxVFS_Unmount.\n"));
484
485	/* Check if user can unmount. */
486	rc = secpolicy_fs_unmount(pCred, pVFS);
487	if (rc)
488	{
489	LogRel((DEVICE_NAME ":VBoxVFS_Unmount: insufficient privileges to unmount.rc=%d\n", rc));
490	return EPERM;
491	}
492
493	/* @todo -XXX - Not sure of supporting force unmounts. What this means is that a failed force mount could bring down
494	* the entire system as hanging about vnode releases would no longer be valid after unloading ourselves...
495	*/
496	if (fUnmount & MS_FORCE)
497	pVFS->vfs_flag \|= VFS_UNMOUNTED;
498
499	/* @todo implement ref-counting of active vnodes & check for busy state here. */
500	/* @todo mutex protection needed here */
501	pVBoxVFSGlobalInfo = VFS_TO_VBOXVFS(pVFS);
502
503	rc = vboxCallUnmapFolder(&g_VBoxVFSClient, &pVBoxVFSGlobalInfo->Map);
504	if (RT_FAILURE(rc))
505	LogRel((DEVICE_NAME ":VBoxVFS_Unmount: failed to unmap shared folder. rc=%d\n", rc));
506
507	VN_RELE(VBOXVN_TO_VN(pVBoxVFSGlobalInfo->pVNodeRoot));
508
509	RTMemFree(pVBoxVFSGlobalInfo->pVNodeRoot->pPath);
510	RTMemFree(pVBoxVFSGlobalInfo->pVNodeRoot);
511	RTMemFree(pVBoxVFSGlobalInfo);
512	pVBoxVFSGlobalInfo = NULL;
513	pVFS->vfs_data = NULL;
514
515	return 0;
516	}
517
518	static int VBoxVFS_Root(vfs_t pVFS, vnode_t *ppVNode)
519	{
520	vboxvfs_globinfo_t *pVBoxVFSGlobalInfo = VFS_TO_VBOXVFS(pVFS);
521	*ppVNode = VBOXVN_TO_VN(pVBoxVFSGlobalInfo->pVNodeRoot);
522	VN_HOLD(*ppVNode);
523
524	return 0;
525	}
526
527	static int VBoxVFS_Statfs(register vfs_t pVFS, struct statvfs64 pStat)
528	{
529	SHFLVOLINFO VolumeInfo;
530	uint32_t cbBuffer;
531	vboxvfs_globinfo_t *pVBoxVFSGlobalInfo;
532	dev32_t Dev32;
533	int rc;
534
535	pVBoxVFSGlobalInfo = VFS_TO_VBOXVFS(pVFS);
536	cbBuffer = sizeof(VolumeInfo);
537	rc = vboxCallFSInfo(&g_VBoxVFSClient, &pVBoxVFSGlobalInfo->Map, 0, SHFL_INFO_GET \| SHFL_INFO_VOLUME, &cbBuffer,
538	(PSHFLDIRINFO)&VolumeInfo);
539	if (RT_FAILURE(rc))
540	return RTErrConvertToErrno(rc);
541
542	bzero(pStat, sizeof(*pStat));
543	cmpldev(&Dev32, pVFS->vfs_dev);
544	pStat->f_fsid = Dev32;
545	pStat->f_flag = vf_to_stf(pVFS->vfs_flag);
546	pStat->f_bsize = VolumeInfo.ulBytesPerAllocationUnit;
547	pStat->f_frsize = VolumeInfo.ulBytesPerAllocationUnit;
548	pStat->f_bfree = VolumeInfo.ullAvailableAllocationBytes / VolumeInfo.ulBytesPerAllocationUnit;
549	pStat->f_bavail = VolumeInfo.ullAvailableAllocationBytes / VolumeInfo.ulBytesPerAllocationUnit;
550	pStat->f_blocks = VolumeInfo.ullTotalAllocationBytes / VolumeInfo.ulBytesPerAllocationUnit;
551	pStat->f_files = 1000;
552	pStat->f_ffree = 1000; /* don't return 0 here since the guest may think that it is not possible to create any more files */
553	pStat->f_namemax = 255; /* @todo is this correct?? */
554
555	strlcpy(pStat->f_basetype, vfssw[pVFS->vfs_fstype].vsw_name, sizeof(pStat->f_basetype));
556	strlcpy(pStat->f_fstr, DEVICE_NAME, sizeof(pStat->f_fstr));
557
558	return 0;
559	}
560
561	static int VBoxVFS_VGet(vfs_t pVFS, vnode_t ppVNode, struct fid pFid)
562	{
563	/* -- TODO -- */
564	return 0;
565	}
566
567	static void VBoxVFS_FreeVFS(vfs_t *pVFS)
568	{
569	vboxDisconnect(&g_VBoxVFSClient);
570	vboxUninit();
571	}
572
573	static int vboxvfs_CheckMountPerm(vfs_t pVFS, struct mounta pMount, vnode_t pVNodeSpec, cred_t pCred)
574	{
575	/* Check if user has the rights to mount the special file. */
576	int fOpen = FREAD \| FWRITE;
577	int fAccess = VREAD \| VWRITE;
578	int rc;
579
580	if (pVNodeSpec->v_type != VBLK)
581	return ENOTBLK;
582
583	if ( (pVFS->vfs_flag & VFS_RDONLY)
584	\|\| (pMount->flags & MS_RDONLY))
585	{
586	fOpen = FREAD;
587	fAccess = VREAD;
588	}
589
590	rc = VOP_ACCESS(pVNodeSpec, fAccess, 0, pCred, NULL /* caller_context */);
591	if (!rc)
592	rc = secpolicy_spec_open(pCred, pVNodeSpec, fOpen);
593
594	return rc;
595	}
596
597	static int vboxvfs_GetIntOpt(vfs_t pVFS, char pszOpt, int *pValue)
598	{
599	int rc;
600	long Val;
601	char *pchOpt = NULL;
602	char *pchEnd = NULL;
603
604	rc = vfs_optionisset(pVFS, pszOpt, &pchOpt);
605	if (rc)
606	{
607	rc = ddi_strtol(pchOpt, &pchEnd, 10 /* base */, &Val);
608	if ( !rc
609	&& Val > INT_MIN
610	&& Val < INT_MAX
611	&& pchEnd == pchOpt + strlen(pchOpt))
612	{
613	*pValue = (int)Val;
614	return 0;
615	}
616	return -1;
617	}
618	return 1;
619	}
620

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/solaris/SharedFolders/vboxvfs_vfsops.c@ 16684

Download in other formats: