VBoxVFS-utils.cpp@ 62523

Last change on this file since 62523 was 62523, checked in by vboxsync, 8 years ago
(C) 2016
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.5 KB

Line
1	/* $Id: VBoxVFS-utils.cpp 62523 2016-07-22 19:17:44Z vboxsync $ */
2	/** @file
3	* VBoxVFS - helper functions.
4	*/
5
6	/*
7	* Copyright (C) 2013-2016 Oracle Corporation
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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	#include <mach/kmod.h>
28	#include <libkern/libkern.h>
29	#include <mach/mach_types.h>
30
31	#include <sys/mount.h>
32	#include <sys/vnode.h>
33	#include <sys/errno.h>
34	#include <sys/fcntl.h>
35
36	#include <iprt/assert.h>
37	#include <iprt/mem.h>
38
39	#include "vboxvfs.h"
40
41	/**
42	* Helper function to create XNU VFS vnode object.
43	*
44	* @param mp Mount data structure
45	* @param type vnode type (directory, regular file, etc)
46	* @param pParent Parent vnode object (NULL for VBoxVFS root vnode)
47	* @param fIsRoot Flag that indicates if created vnode object is
48	* VBoxVFS root vnode (TRUE for VBoxVFS root vnode, FALSE
49	* for all aother vnodes)
50	* @param Path within Shared Folder
51	* @param ret Returned newly created vnode
52	*
53	* @return 0 on success, error code otherwise
54	*/
55	int
56	vboxvfs_create_vnode_internal(struct mount mp, enum vtype type, vnode_t pParent, int fIsRoot, PSHFLSTRING Path, vnode_t ret)
57	{
58	int rc;
59	vnode_t vnode;
60
61	vboxvfs_vnode_t *pVnodeData;
62	vboxvfs_mount_t *pMount;
63
64	AssertReturn(mp, EINVAL);
65
66	pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp);
67	AssertReturn(pMount, EINVAL);
68	AssertReturn(pMount->pLockGroup, EINVAL);
69
70	AssertReturn(Path, EINVAL);
71
72	pVnodeData = (vboxvfs_vnode_t *)RTMemAllocZ(sizeof(vboxvfs_vnode_t));
73	AssertReturn(pVnodeData, ENOMEM);
74
75	/* Initialize private data */
76	pVnodeData->pHandle = SHFL_HANDLE_NIL;
77	pVnodeData->pPath = Path;
78
79	pVnodeData->pLockAttr = lck_attr_alloc_init();
80	if (pVnodeData->pLockAttr)
81	{
82	pVnodeData->pLock = lck_rw_alloc_init(pMount->pLockGroup, pVnodeData->pLockAttr);
83	if (pVnodeData->pLock)
84	{
85	struct vnode_fsparam vnode_params;
86
87	vnode_params.vnfs_mp = mp;
88	vnode_params.vnfs_vtype = type;
89	vnode_params.vnfs_str = NULL;
90	vnode_params.vnfs_dvp = pParent;
91	vnode_params.vnfs_fsnode = pVnodeData; /** Private data attached per xnu's vnode object */
92	vnode_params.vnfs_vops = g_VBoxVFSVnodeDirOpsVector;
93
94	vnode_params.vnfs_markroot = fIsRoot;
95	vnode_params.vnfs_marksystem = FALSE;
96	vnode_params.vnfs_rdev = 0;
97	vnode_params.vnfs_filesize = 0;
98	vnode_params.vnfs_cnp = NULL;
99
100	vnode_params.vnfs_flags = VNFS_ADDFSREF \| VNFS_NOCACHE;
101
102	rc = vnode_create(VNCREATE_FLAVOR, sizeof(vnode_params), &vnode_params, &vnode);
103	if (rc == 0)
104	*ret = vnode;
105
106	return 0;
107	}
108	else
109	{
110	PDEBUG("Unable to allocate lock");
111	rc = ENOMEM;
112	}
113
114	lck_attr_free(pVnodeData->pLockAttr);
115	}
116	else
117	{
118	PDEBUG("Unable to allocate lock attr");
119	rc = ENOMEM;
120	}
121
122	return rc;
123	}
124
125	/**
126	* Convert guest absolute VFS path (starting from VFS root) to a host path
127	* within mounted shared folder (returning it as a char *).
128	*
129	* @param mp Mount data structure
130	* @param pszGuestPath Guest absolute VFS path (starting from VFS root)
131	* @param cbGuestPath Size of pszGuestPath
132	* @param pszHostPath Returned char * wich contains host path
133	* @param cbHostPath Returned pszHostPath size
134	*
135	* @return 0 on success, error code otherwise
136	*/
137	int
138	vboxvfs_guest_path_to_char_path_internal(mount_t mp, char pszGuestPath, int cbGuestPath, char pszHostPath, int cbHostPath)
139	{
140	vboxvfs_mount_t *pMount;
141
142	/* Guest side: mount point path buffer and its size */
143	char *pszMntPointPath;
144	int cbMntPointPath = MAXPATHLEN;
145
146	/* Host side: path within mounted shared folder and its size */
147	char *pszHostPathInternal;
148	size_t cbHostPathInternal;
149
150	int rc;
151
152	AssertReturn(mp, EINVAL);
153	AssertReturn(pszGuestPath, EINVAL); AssertReturn(cbGuestPath >= 0, EINVAL);
154	AssertReturn(pszHostPath, EINVAL); AssertReturn(cbHostPath, EINVAL);
155
156	pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL); AssertReturn(pMount->pRootVnode, EINVAL);
157
158	/* Get mount point path */
159	pszMntPointPath = (char *)RTMemAllocZ(cbMntPointPath);
160	if (pszMntPointPath)
161	{
162	rc = vn_getpath(pMount->pRootVnode, pszMntPointPath, &cbMntPointPath);
163	if (rc == 0 && cbGuestPath >= cbMntPointPath)
164	{
165	cbHostPathInternal = cbGuestPath - cbMntPointPath + 1;
166	pszHostPathInternal = (char *)RTMemAllocZ(cbHostPathInternal);
167	if (pszHostPathInternal)
168	{
169	memcpy(pszHostPathInternal, pszGuestPath + cbMntPointPath, cbGuestPath - cbMntPointPath);
170	PDEBUG("guest<->host path converion result: '%s' mounted to '%s'", pszHostPathInternal, pszMntPointPath);
171
172	RTMemFree(pszMntPointPath);
173
174	*pszHostPath = pszHostPathInternal;
175	*cbHostPath = cbGuestPath - cbMntPointPath;
176
177	return 0;
178
179	}
180	else
181	{
182	PDEBUG("No memory to allocate buffer for guest<->host path conversion (cbHostPathInternal)");
183	rc = ENOMEM;
184	}
185
186	}
187	else
188	{
189	PDEBUG("Unable to get guest vnode path: %d", rc);
190	}
191
192	RTMemFree(pszMntPointPath);
193	}
194	else
195	{
196	PDEBUG("No memory to allocate buffer for guest<->host path conversion (pszMntPointPath)");
197	rc = ENOMEM;
198	}
199
200	return rc;
201	}
202
203	/**
204	* Convert guest absolute VFS path (starting from VFS root) to a host path
205	* within mounted shared folder.
206	*
207	* @param mp Mount data structure
208	* @param pszGuestPath Guest absolute VFS path (starting from VFS root)
209	* @param cbGuestPath Size of pszGuestPath
210	* @param ppResult Returned PSHFLSTRING object wich contains host path
211	*
212	* @return 0 on success, error code otherwise
213	*/
214	int
215	vboxvfs_guest_path_to_shflstring_path_internal(mount_t mp, char pszGuestPath, int cbGuestPath, PSHFLSTRING ppResult)
216	{
217	vboxvfs_mount_t *pMount;
218
219	/* Guest side: mount point path buffer and its size */
220	char *pszMntPointPath;
221	int cbMntPointPath = MAXPATHLEN;
222
223	/* Host side: path within mounted shared folder and its size */
224	PSHFLSTRING pSFPath;
225	size_t cbSFPath;
226
227	int rc;
228
229	AssertReturn(mp, EINVAL);
230	AssertReturn(pszGuestPath, EINVAL);
231	AssertReturn(cbGuestPath >= 0, EINVAL);
232
233	char *pszHostPath;
234	int cbHostPath;
235
236	rc = vboxvfs_guest_path_to_char_path_internal(mp, pszGuestPath, cbGuestPath, &pszHostPath, &cbHostPath);
237	if (rc == 0)
238	{
239	cbSFPath = offsetof(SHFLSTRING, String.utf8) + (size_t)cbHostPath + 1;
240	pSFPath = (PSHFLSTRING)RTMemAllocZ(cbSFPath);
241	if (pSFPath)
242	{
243	pSFPath->u16Length = cbHostPath;
244	pSFPath->u16Size = cbHostPath + 1;
245	memcpy(pSFPath->String.utf8, pszHostPath, cbHostPath);
246	vboxvfs_put_path_internal((void **)&pszHostPath);
247
248	*ppResult = pSFPath;
249	}
250	}
251
252	return rc;
253	}
254
255	/**
256	* Wrapper function for vboxvfs_guest_path_to_char_path_internal() which
257	* converts guest path to host path using vnode object information.
258	*
259	* @param vnode Guest's VFS object
260	* @param ppHostPath Allocated char * which contain a path
261	* @param pcbPath Size of ppPath
262	*
263	* @return 0 on success, error code otherwise.
264	*/
265	int
266	vboxvfs_guest_vnode_to_char_path_internal(vnode_t vnode, char *ppHostPath, int pcbHostPath)
267	{
268	mount_t mp;
269	int rc;
270
271	char *pszPath;
272	int cbPath = MAXPATHLEN;
273
274	AssertReturn(ppHostPath, EINVAL);
275	AssertReturn(pcbHostPath, EINVAL);
276	AssertReturn(vnode, EINVAL);
277	mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
278
279	pszPath = (char *)RTMemAllocZ(cbPath);
280	if (pszPath)
281	{
282	rc = vn_getpath(vnode, pszPath, &cbPath);
283	if (rc == 0)
284	{
285	return vboxvfs_guest_path_to_char_path_internal(mp, pszPath, cbPath, ppHostPath, pcbHostPath);
286	}
287	}
288	else
289	{
290	rc = ENOMEM;
291	}
292
293	return rc;
294	}
295
296	/**
297	* Wrapper function for vboxvfs_guest_path_to_shflstring_path_internal() which
298	* converts guest path to host path using vnode object information.
299	*
300	* @param vnode Guest's VFS object
301	* @param ppResult Allocated PSHFLSTRING object which contain a path
302	*
303	* @return 0 on success, error code otherwise.
304	*/
305	int
306	vboxvfs_guest_vnode_to_shflstring_path_internal(vnode_t vnode, PSHFLSTRING *ppResult)
307	{
308	mount_t mp;
309	int rc;
310
311	char *pszPath;
312	int cbPath = MAXPATHLEN;
313
314	AssertReturn(ppResult, EINVAL);
315	AssertReturn(vnode, EINVAL);
316	mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
317
318	pszPath = (char *)RTMemAllocZ(cbPath);
319	if (pszPath)
320	{
321	rc = vn_getpath(vnode, pszPath, &cbPath);
322	if (rc == 0)
323	{
324	return vboxvfs_guest_path_to_shflstring_path_internal(mp, pszPath, cbPath, ppResult);
325	}
326	}
327	else
328	{
329	rc = ENOMEM;
330	}
331
332	return rc;
333	}
334
335
336	/**
337	* Free resources allocated by vboxvfs_path_internal() and vboxvfs_guest_vnode_to_shflstring_path_internal().
338	*
339	* @param ppHandle Reference to object to be freed.
340	*/
341	void
342	vboxvfs_put_path_internal(void **ppHandle)
343	{
344	AssertReturnVoid(ppHandle);
345	AssertReturnVoid(*ppHandle);
346	RTMemFree(*ppHandle);
347	}
348
349	static void
350	vboxvfs_g2h_mode_dump_inernal(uint32_t fHostMode)
351	{
352	PDEBUG("Host VFS object flags (0x%X) dump:", (int)fHostMode);
353
354	if (fHostMode & SHFL_CF_ACCESS_READ) PDEBUG("SHFL_CF_ACCESS_READ");
355	if (fHostMode & SHFL_CF_ACCESS_WRITE) PDEBUG("SHFL_CF_ACCESS_WRITE");
356	if (fHostMode & SHFL_CF_ACCESS_APPEND) PDEBUG("SHFL_CF_ACCESS_APPEND");
357
358	if ((fHostMode & (SHFL_CF_ACT_FAIL_IF_EXISTS \|
359	SHFL_CF_ACT_REPLACE_IF_EXISTS \|
360	SHFL_CF_ACT_OVERWRITE_IF_EXISTS)) == 0)
361	PDEBUG("SHFL_CF_ACT_OPEN_IF_EXISTS");
362
363	if (fHostMode & SHFL_CF_ACT_CREATE_IF_NEW) PDEBUG("SHFL_CF_ACT_CREATE_IF_NEW");
364	if (fHostMode & SHFL_CF_ACT_FAIL_IF_NEW) PDEBUG("SHFL_CF_ACT_FAIL_IF_NEW");
365	if (fHostMode & SHFL_CF_ACT_OVERWRITE_IF_EXISTS) PDEBUG("SHFL_CF_ACT_OVERWRITE_IF_EXISTS");
366	if (fHostMode & SHFL_CF_DIRECTORY) PDEBUG("SHFL_CF_DIRECTORY");
367
368	PDEBUG("Done");
369	}
370
371
372	/**
373	* Open existing VBoxVFS object and return its handle.
374	*
375	* @param pMount Mount session data.
376	* @param pPath VFS path to the object relative to mount point.
377	* @param fFlags For directory object it should be
378	* SHFL_CF_DIRECTORY and 0 for any other object.
379	* @param pHandle Returned handle.
380	*
381	* @return 0 on success, error code otherwise.
382	*/
383	int
384	vboxvfs_open_internal(vboxvfs_mount_t pMount, PSHFLSTRING pPath, uint32_t fFlags, SHFLHANDLE pHandle)
385	{
386	SHFLCREATEPARMS parms;
387
388	int rc;
389
390	AssertReturn(pMount, EINVAL);
391	AssertReturn(pPath, EINVAL);
392	AssertReturn(pHandle, EINVAL);
393
394	bzero(&parms, sizeof(parms));
395
396	vboxvfs_g2h_mode_dump_inernal(fFlags);
397
398	parms.Handle = SHFL_HANDLE_NIL;
399	parms.Info.cbObject = 0;
400	parms.CreateFlags = fFlags;
401
402	rc = VbglR0SfCreate(&g_vboxSFClient, &pMount->pMap, pPath, &parms);
403	if (RT_SUCCESS(rc))
404	{
405	*pHandle = parms.Handle;
406	}
407	else
408	{
409	PDEBUG("vboxvfs_open_internal() failed: %d", rc);
410	}
411
412	return rc;
413	}
414
415	/**
416	* Release VBoxVFS object handle openned by vboxvfs_open_internal().
417	*
418	* @param pMount Mount session data.
419	* @param pHandle Handle to close.
420	*
421	* @return 0 on success, IPRT error code otherwise.
422	*/
423	int
424	vboxvfs_close_internal(vboxvfs_mount_t *pMount, SHFLHANDLE pHandle)
425	{
426	AssertReturn(pMount, EINVAL);
427	return VbglR0SfClose(&g_vboxSFClient, &pMount->pMap, pHandle);
428	}
429
430	/**
431	* Get information about host VFS object.
432	*
433	* @param mp Mount point data
434	* @param pSHFLDPath Path to VFS object within mounted shared folder
435	* @param Info Returned info
436	*
437	* @return 0 on success, error code otherwise.
438	*/
439	int
440	vboxvfs_get_info_internal(mount_t mp, PSHFLSTRING pSHFLDPath, PSHFLFSOBJINFO Info)
441	{
442	vboxvfs_mount_t *pMount;
443	SHFLCREATEPARMS parms;
444
445	int rc;
446
447	AssertReturn(mp, EINVAL);
448	AssertReturn(pSHFLDPath, EINVAL);
449	AssertReturn(Info, EINVAL);
450
451	pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
452
453	parms.Handle = 0;
454	parms.Info.cbObject = 0;
455	parms.CreateFlags = SHFL_CF_LOOKUP \| SHFL_CF_ACT_FAIL_IF_NEW;
456
457	rc = VbglR0SfCreate(&g_vboxSFClient, &pMount->pMap, pSHFLDPath, &parms);
458	if (rc == 0)
459	*Info = parms.Info;
460
461	return rc;
462	}
463
464	/**
465	* Check if VFS object exists on a host side.
466	*
467	* @param vnode Guest VFS vnode that corresponds to host VFS object
468	*
469	* @return 1 if exists, 0 otherwise.
470	*/
471	int
472	vboxvfs_exist_internal(vnode_t vnode)
473	{
474	int rc;
475
476	PSHFLSTRING pSFPath = NULL;
477	SHFLHANDLE handle;
478	uint32_t fFlags;
479
480	vboxvfs_mount_t *pMount;
481	mount_t mp;
482
483	/* Return FALSE if invalid parameter given */
484	AssertReturn(vnode, 0);
485
486	mp = vnode_mount(vnode); AssertReturn(mp, EINVAL);
487	pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp); AssertReturn(pMount, EINVAL);
488
489	fFlags = (vnode_isdir(vnode)) ? SHFL_CF_DIRECTORY : 0;
490	fFlags \|= SHFL_CF_ACCESS_READ \| SHFL_CF_ACT_OPEN_IF_EXISTS \| SHFL_CF_ACT_FAIL_IF_NEW;
491
492	rc = vboxvfs_guest_vnode_to_shflstring_path_internal(vnode, &pSFPath); AssertReturn(rc == 0, rc);
493	if (rc == 0)
494	{
495	rc = vboxvfs_open_internal(pMount, pSFPath, fFlags, &handle);
496	if (rc == 0)
497	{
498	rc = vboxvfs_close_internal(pMount, handle);
499	if (rc != 0)
500	{
501	PDEBUG("Unable to close() VBoxVFS object handle while checking if object exist on host: %d", rc);
502	}
503	}
504	}
505
506	vboxvfs_put_path_internal((void **)&pSFPath);
507
508	return (rc == 0);
509	}
510
511	/**
512	* Convert host VFS object mode flags into guest ones.
513	*
514	* @param fHostMode Host flags
515	*
516	* @return Guest flags
517	*/
518	mode_t
519	vboxvfs_h2g_mode_inernal(RTFMODE fHostMode)
520	{
521	mode_t fGuestMode = 0;
522
523	fGuestMode = /* Owner */
524	((fHostMode & RTFS_UNIX_IRUSR) ? S_IRUSR : 0 ) \|
525	((fHostMode & RTFS_UNIX_IWUSR) ? S_IWUSR : 0 ) \|
526	((fHostMode & RTFS_UNIX_IXUSR) ? S_IXUSR : 0 ) \|
527	/* Group */
528	((fHostMode & RTFS_UNIX_IRGRP) ? S_IRGRP : 0 ) \|
529	((fHostMode & RTFS_UNIX_IWGRP) ? S_IWGRP : 0 ) \|
530	((fHostMode & RTFS_UNIX_IXGRP) ? S_IXGRP : 0 ) \|
531	/* Other */
532	((fHostMode & RTFS_UNIX_IROTH) ? S_IROTH : 0 ) \|
533	((fHostMode & RTFS_UNIX_IWOTH) ? S_IWOTH : 0 ) \|
534	((fHostMode & RTFS_UNIX_IXOTH) ? S_IXOTH : 0 ) \|
535	/* SUID, SGID, SVTXT */
536	((fHostMode & RTFS_UNIX_ISUID) ? S_ISUID : 0 ) \|
537	((fHostMode & RTFS_UNIX_ISGID) ? S_ISGID : 0 ) \|
538	((fHostMode & RTFS_UNIX_ISTXT) ? S_ISVTX : 0 ) \|
539	/* VFS object types */
540	((RTFS_IS_FIFO(fHostMode)) ? S_IFIFO : 0 ) \|
541	((RTFS_IS_DEV_CHAR(fHostMode)) ? S_IFCHR : 0 ) \|
542	((RTFS_IS_DIRECTORY(fHostMode)) ? S_IFDIR : 0 ) \|
543	((RTFS_IS_DEV_BLOCK(fHostMode)) ? S_IFBLK : 0 ) \|
544	((RTFS_IS_FILE(fHostMode)) ? S_IFREG : 0 ) \|
545	((RTFS_IS_SYMLINK(fHostMode)) ? S_IFLNK : 0 ) \|
546	((RTFS_IS_SOCKET(fHostMode)) ? S_IFSOCK : 0 );
547
548	return fGuestMode;
549	}
550
551	/**
552	* Convert guest VFS object mode flags into host ones.
553	*
554	* @param fGuestMode Host flags
555	*
556	* @return Host flags
557	*/
558	uint32_t
559	vboxvfs_g2h_mode_inernal(mode_t fGuestMode)
560	{
561	uint32_t fHostMode = 0;
562
563	fHostMode = ((fGuestMode & FREAD) ? SHFL_CF_ACCESS_READ : 0 ) \|
564	((fGuestMode & FWRITE) ? SHFL_CF_ACCESS_WRITE : 0 ) \|
565	/* skipped: O_NONBLOCK */
566	((fGuestMode & O_APPEND) ? SHFL_CF_ACCESS_APPEND : 0 ) \|
567	/* skipped: O_SYNC */
568	/* skipped: O_SHLOCK */
569	/* skipped: O_EXLOCK */
570	/* skipped: O_ASYNC */
571	/* skipped: O_FSYNC */
572	/* skipped: O_NOFOLLOW */
573	((fGuestMode & O_CREAT) ? SHFL_CF_ACT_CREATE_IF_NEW \| (!(fGuestMode & O_TRUNC) ? SHFL_CF_ACT_OPEN_IF_EXISTS : 0) : SHFL_CF_ACT_OPEN_IF_EXISTS \| SHFL_CF_ACT_FAIL_IF_NEW ) \|
574	((fGuestMode & O_TRUNC) ? SHFL_CF_ACT_OVERWRITE_IF_EXISTS \| SHFL_CF_ACCESS_WRITE : 0 );
575	/* skipped: O_EXCL */
576
577	return fHostMode;
578	}
579
580	/**
581	* Mount helper: Contruct SHFLSTRING which contains VBox share name or path.
582	*
583	* @param szName Char * string containing share name.
584	* @param cbName Length of pShareName.
585	*
586	* @return Allocated SHFLSTRING which contains VBox share name or path, NULL otherwise.
587	*/
588	SHFLSTRING *
589	vboxvfs_construct_shflstring(char *szName, size_t cbName)
590	{
591	size_t cbSHFLString;
592	SHFLSTRING *pSHFLString;
593
594	AssertReturn(szName, NULL);
595
596	cbSHFLString = offsetof(SHFLSTRING, String.utf8) + cbName + 1;
597	pSHFLString = (SHFLSTRING *)RTMemAllocZ(cbSHFLString);
598
599	if (pSHFLString)
600	{
601	pSHFLString->u16Length = cbSHFLString;
602	pSHFLString->u16Size = cbSHFLString + 1;
603
604	/* Do not do that for empty strings */
605	if (cbName > 0)
606	memcpy(pSHFLString->String.utf8, szName, cbName + 1);
607
608	return pSHFLString;
609	}
610
611	return NULL;
612	}
613

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

source: vbox/trunk/src/VBox/Additions/darwin/vboxfs/VBoxVFS-utils.cpp@ 62523

Download in other formats: