VBoxGuestR0LibSharedFolders.c@ 69149

Last change on this file since 69149 was 69149, checked in by vboxsync, 7 years ago

Additions/linux/shfl: stop supporting old host/mount.vboxsf versions.
bugref:4567: Linux kernel driver maintenance

Based on [PATCH] Remove support for old hosts and userspace mount.vboxsf
Signed-off-by: Hans de Goede <hdegoede@…>

Versions of VirtualBox many years ago used a different host/guest protocol
for accessing shared folders, as well as a different guest kernel to
user-space mount helper protocol. While we try to support old Additions
versions on the host side, we only aim to support old host versions in the
Additions to a limited extent, and the guest kernel interface is also only
fixed for a defined range of releases.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 26.7 KB

Line
1	/* $Id: VBoxGuestR0LibSharedFolders.c 69149 2017-10-20 14:53:19Z vboxsync $ */
2	/** @file
3	* VBoxGuestR0LibSharedFolders - Ring 0 Shared Folders calls.
4	*/
5
6	/*
7	* Copyright (C) 2006-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	/*********************************************************************************************************************************
28	* Header Files *
29	*********************************************************************************************************************************/
30	#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
31	#include "VBoxGuestR0LibInternal.h"
32	#include <VBox/VBoxGuestLibSharedFolders.h>
33	#include <VBox/log.h>
34	#include <iprt/time.h>
35	#include <iprt/mem.h>
36	#include <iprt/path.h>
37	#include <iprt/string.h>
38
39	#ifdef VBGL_VBOXGUEST
40	# error "This file shouldn't be part of the VBoxGuestR0LibBase library that is linked into VBoxGuest. It's client code."
41	#endif
42
43
44	/*********************************************************************************************************************************
45	* Defined Constants And Macros *
46	*********************************************************************************************************************************/
47	#define SHFL_CPARMS_SET_UTF8 0
48	#define SHFL_CPARMS_SET_SYMLINKS 0
49
50	#define VBOX_INIT_CALL(a, b, c) \
51	LogFunc(("%s, idClient=%d\n", "SHFL_FN_" # b, (c)->idClient)); \
52	VBGL_HGCM_HDR_INIT(a, (c)->idClient, SHFL_FN_##b, SHFL_CPARMS_##b); \
53	(a)->fInterruptible = false /* Currently we do like nfs with -o hard (default). */
54
55	#define VBOX_INIT_CALL_EX(a, b, c, a_cbReq) \
56	LogFunc(("%s, idClient=%d\n", "SHFL_FN_" # b, (c)->idClient)); \
57	VBGL_HGCM_HDR_INIT_EX(a, (c)->idClient, SHFL_FN_##b, SHFL_CPARMS_##b, a_cbReq); \
58	(a)->fInterruptible = false /* Currently we do like nfs with -o hard (default). */
59
60
61
62	/** @todo We only need HGCM, not physical memory, so other guests should also
63	* switch to calling vbglR0HGCMInit() and vbglR0HGCMTerminate() instead
64	* of VbglR0SfInit() and VbglR0SfTerm(). */
65	#ifndef RT_OS_LINUX
66	DECLVBGL(int) VbglR0SfInit(void)
67	{
68	return VbglR0InitClient();
69	}
70
71	DECLVBGL(void) VbglR0SfTerm(void)
72	{
73	VbglR0TerminateClient();
74	}
75	#endif
76
77	DECLVBGL(int) VbglR0SfConnect(PVBGLSFCLIENT pClient)
78	{
79	int rc = VbglR0HGCMConnect(&pClient->handle, "VBoxSharedFolders", &pClient->idClient);
80	if (RT_SUCCESS(rc))
81	LogFunc(("idClient=%d\n", pClient->idClient));
82	else
83	LogFunc(("VbglR0HGCMConnect failed -> rc=%Rrc\n", rc));
84	return rc;
85	}
86
87	DECLVBGL(void) VbglR0SfDisconnect(PVBGLSFCLIENT pClient)
88	{
89	int rc;
90	LogFunc(("u32ClientID=%d\n", pClient->idClient));
91	if (pClient->handle == NULL)
92	return; /* not connected */
93
94	rc = VbglR0HGCMDisconnect(pClient->handle, pClient->idClient);
95	NOREF(rc);
96	/* Log(("VBOXSF: VbglR0SfDisconnect: VbglR0HGCMDisconnect -> %#x\n", rc)); */
97	pClient->idClient = 0;
98	pClient->handle = NULL;
99	return;
100	}
101
102	DECLVBGL(int) VbglR0SfQueryMappings(PVBGLSFCLIENT pClient, SHFLMAPPING paMappings[], uint32_t *pcMappings)
103	{
104	int rc;
105	VBoxSFQueryMappings data;
106
107	VBOX_INIT_CALL(&data.callInfo, QUERY_MAPPINGS, pClient);
108
109	data.flags.type = VMMDevHGCMParmType_32bit;
110	data.flags.u.value32 = SHFL_MF_UCS2;
111
112	data.numberOfMappings.type = VMMDevHGCMParmType_32bit;
113	data.numberOfMappings.u.value32 = *pcMappings;
114
115	data.mappings.type = VMMDevHGCMParmType_LinAddr;
116	data.mappings.u.Pointer.size = sizeof(SHFLMAPPING) * *pcMappings;
117	data.mappings.u.Pointer.u.linearAddr = (uintptr_t)&paMappings[0];
118
119	/* Log(("VBOXSF: in ifs difference %d\n", (char )&data.flags.type - (char )&data.callInfo.cParms)); */
120	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
121	/* Log(("VBOXSF: VbglR0SfQueryMappings: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
122	if (RT_SUCCESS(rc))
123	*pcMappings = data.numberOfMappings.u.value32;
124
125	return rc;
126	}
127
128	DECLVBGL(int) VbglR0SfQueryMapName(PVBGLSFCLIENT pClient, SHFLROOT root, SHFLSTRING *pString, uint32_t size)
129	{
130	int rc;
131	VBoxSFQueryMapName data;
132
133	VBOX_INIT_CALL(&data.callInfo, QUERY_MAP_NAME, pClient);
134
135	data.root.type = VMMDevHGCMParmType_32bit;
136	data.root.u.value32 = root;
137
138	data.name.type = VMMDevHGCMParmType_LinAddr;
139	data.name.u.Pointer.size = size;
140	data.name.u.Pointer.u.linearAddr = (uintptr_t)pString;
141
142	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
143	/* Log(("VBOXSF: VbglR0SfQueryMapName: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
144	return rc;
145	}
146
147	DECLVBGL(int) VbglR0SfMapFolder(PVBGLSFCLIENT pClient, PSHFLSTRING szFolderName, PVBGLSFMAP pMap)
148	{
149	int rc;
150	VBoxSFMapFolder data;
151
152	VBOX_INIT_CALL(&data.callInfo, MAP_FOLDER, pClient);
153
154	data.path.type = VMMDevHGCMParmType_LinAddr;
155	data.path.u.Pointer.size = ShflStringSizeOfBuffer(szFolderName);
156	data.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
157
158	data.root.type = VMMDevHGCMParmType_32bit;
159	data.root.u.value32 = 0;
160
161	data.delimiter.type = VMMDevHGCMParmType_32bit;
162	data.delimiter.u.value32 = RTPATH_DELIMITER;
163
164	data.fCaseSensitive.type = VMMDevHGCMParmType_32bit;
165	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
166	data.fCaseSensitive.u.value32 = 0;
167	#else
168	data.fCaseSensitive.u.value32 = 1;
169	#endif
170
171	rc = VbglR0HGCMCallRaw(pClient->handle, &data.callInfo, sizeof(data));
172	/* Log(("VBOXSF: VbglR0SfMapFolder: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
173	if (RT_SUCCESS(rc))
174	{
175	pMap->root = data.root.u.value32;
176	rc = data.callInfo.Hdr.rc;
177	}
178	return rc;
179	}
180
181	DECLVBGL(int) VbglR0SfUnmapFolder(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap)
182	{
183	int rc;
184	VBoxSFUnmapFolder data;
185
186	VBOX_INIT_CALL(&data.callInfo, UNMAP_FOLDER, pClient);
187
188	data.root.type = VMMDevHGCMParmType_32bit;
189	data.root.u.value32 = pMap->root;
190
191	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
192	/* Log(("VBOXSF: VbglR0SfUnmapFolder: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
193	return rc;
194	}
195
196	DECLVBGL(int) VbglR0SfCreate(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, PSHFLCREATEPARMS pCreateParms)
197	{
198	/** @todo copy buffers to physical or mapped memory. */
199	int rc;
200	VBoxSFCreate data;
201
202	VBOX_INIT_CALL(&data.callInfo, CREATE, pClient);
203
204	data.root.type = VMMDevHGCMParmType_32bit;
205	data.root.u.value32 = pMap->root;
206
207	data.path.type = VMMDevHGCMParmType_LinAddr;
208	data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
209	data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
210
211	data.parms.type = VMMDevHGCMParmType_LinAddr;
212	data.parms.u.Pointer.size = sizeof(SHFLCREATEPARMS);
213	data.parms.u.Pointer.u.linearAddr = (uintptr_t)pCreateParms;
214
215	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
216	/* Log(("VBOXSF: VbglR0SfCreate: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
217	return rc;
218	}
219
220	DECLVBGL(int) VbglR0SfClose(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE Handle)
221	{
222	int rc;
223	VBoxSFClose data;
224
225	VBOX_INIT_CALL(&data.callInfo, CLOSE, pClient);
226
227	data.root.type = VMMDevHGCMParmType_32bit;
228	data.root.u.value32 = pMap->root;
229
230	data.handle.type = VMMDevHGCMParmType_64bit;
231	data.handle.u.value64 = Handle;
232
233	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
234	/* Log(("VBOXSF: VbglR0SfClose: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
235	return rc;
236	}
237
238	DECLVBGL(int) VbglR0SfRemove(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, uint32_t flags)
239	{
240	int rc = VINF_SUCCESS;
241
242	VBoxSFRemove data;
243
244	VBOX_INIT_CALL(&data.callInfo, REMOVE, pClient);
245
246	data.root.type = VMMDevHGCMParmType_32bit;
247	data.root.u.value32 = pMap->root;
248
249	data.path.type = VMMDevHGCMParmType_LinAddr_In;
250	data.path.u.Pointer.size = ShflStringSizeOfBuffer(pParsedPath);
251	data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
252
253	data.flags.type = VMMDevHGCMParmType_32bit;
254	data.flags.u.value32 = flags;
255
256	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
257	/* Log(("VBOXSF: VbglR0SfRemove: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
258	return rc;
259	}
260
261	DECLVBGL(int) VbglR0SfRename(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pSrcPath, PSHFLSTRING pDestPath, uint32_t flags)
262	{
263	int rc;
264	VBoxSFRename data;
265
266	VBOX_INIT_CALL(&data.callInfo, RENAME, pClient);
267
268	data.root.type = VMMDevHGCMParmType_32bit;
269	data.root.u.value32 = pMap->root;
270
271	data.src.type = VMMDevHGCMParmType_LinAddr_In;
272	data.src.u.Pointer.size = ShflStringSizeOfBuffer(pSrcPath);
273	data.src.u.Pointer.u.linearAddr = (uintptr_t)pSrcPath;
274
275	data.dest.type = VMMDevHGCMParmType_LinAddr_In;
276	data.dest.u.Pointer.size = ShflStringSizeOfBuffer(pDestPath);
277	data.dest.u.Pointer.u.linearAddr = (uintptr_t)pDestPath;
278
279	data.flags.type = VMMDevHGCMParmType_32bit;
280	data.flags.u.value32 = flags;
281
282	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
283	/* Log(("VBOXSF: VbglR0SfRename: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
284	return rc;
285	}
286
287	DECLVBGL(int) VbglR0SfRead(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
288	uint64_t offset, uint32_t pcbBuffer, uint8_t pBuffer, bool fLocked)
289	{
290	int rc;
291	VBoxSFRead data;
292
293	VBOX_INIT_CALL(&data.callInfo, READ, pClient);
294
295	data.root.type = VMMDevHGCMParmType_32bit;
296	data.root.u.value32 = pMap->root;
297
298	data.handle.type = VMMDevHGCMParmType_64bit;
299	data.handle.u.value64 = hFile;
300	data.offset.type = VMMDevHGCMParmType_64bit;
301	data.offset.u.value64 = offset;
302	data.cb.type = VMMDevHGCMParmType_32bit;
303	data.cb.u.value32 = *pcbBuffer;
304	data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_Out : VMMDevHGCMParmType_LinAddr_Out;
305	data.buffer.u.Pointer.size = *pcbBuffer;
306	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
307
308	rc = VbglR0HGCMCallRaw(pClient->handle, &data.callInfo, sizeof(data));
309	/* Log(("VBOXSF: VbglR0SfRead: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
310	if (RT_SUCCESS(rc))
311	{
312	rc = data.callInfo.Hdr.rc;
313	*pcbBuffer = data.cb.u.value32;
314	}
315	return rc;
316	}
317
318	DECLVBGL(int) VbglR0SfReadPageList(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer,
319	uint16_t offFirstPage, uint16_t cPages, RTGCPHYS64 *paPages)
320	{
321	uint32_t cbToRead = *pcbBuffer;
322	uint32_t cbData = (uint32_t)(sizeof(VBoxSFRead) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
323	VBoxSFRead pData = (VBoxSFRead )RTMemTmpAlloc(cbData);
324	HGCMPageListInfo pPgLst = (HGCMPageListInfo )(pData + 1);
325	uint16_t iPage;
326	int rc;
327
328	if (RT_UNLIKELY(!pData))
329	return VERR_NO_TMP_MEMORY;
330
331	VBOX_INIT_CALL_EX(&pData->callInfo, READ, pClient, cbData);
332
333	pData->root.type = VMMDevHGCMParmType_32bit;
334	pData->root.u.value32 = pMap->root;
335
336	pData->handle.type = VMMDevHGCMParmType_64bit;
337	pData->handle.u.value64 = hFile;
338	pData->offset.type = VMMDevHGCMParmType_64bit;
339	pData->offset.u.value64 = offset;
340	pData->cb.type = VMMDevHGCMParmType_32bit;
341	pData->cb.u.value32 = cbToRead;
342	pData->buffer.type = VMMDevHGCMParmType_PageList;
343	pData->buffer.u.PageList.size = cbToRead;
344	pData->buffer.u.PageList.offset = sizeof(VBoxSFRead);
345
346	pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_FROM_HOST;
347	pPgLst->offFirstPage = offFirstPage;
348	pPgLst->cPages = cPages;
349	for (iPage = 0; iPage < cPages; iPage++)
350	pPgLst->aPages[iPage] = paPages[iPage];
351
352	rc = VbglR0HGCMCallRaw(pClient->handle, &pData->callInfo, cbData);
353	/* Log(("VBOXSF: VbglR0SfReadPageList: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
354	if (RT_SUCCESS(rc))
355	{
356	rc = pData->callInfo.Hdr.rc;
357	*pcbBuffer = pData->cb.u.value32;
358	}
359
360	RTMemTmpFree(pData);
361	return rc;
362	}
363
364	DECLVBGL(int) VbglR0SfWrite(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
365	uint64_t offset, uint32_t pcbBuffer, uint8_t pBuffer, bool fLocked)
366	{
367	int rc;
368	VBoxSFWrite data;
369
370	VBOX_INIT_CALL(&data.callInfo, WRITE, pClient);
371
372	data.root.type = VMMDevHGCMParmType_32bit;
373	data.root.u.value32 = pMap->root;
374
375	data.handle.type = VMMDevHGCMParmType_64bit;
376	data.handle.u.value64 = hFile;
377	data.offset.type = VMMDevHGCMParmType_64bit;
378	data.offset.u.value64 = offset;
379	data.cb.type = VMMDevHGCMParmType_32bit;
380	data.cb.u.value32 = *pcbBuffer;
381	data.buffer.type = fLocked ? VMMDevHGCMParmType_LinAddr_Locked_In : VMMDevHGCMParmType_LinAddr_In;
382	data.buffer.u.Pointer.size = *pcbBuffer;
383	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
384
385	rc = VbglR0HGCMCallRaw(pClient->handle, &data.callInfo, sizeof(data));
386	/* Log(("VBOXSF: VbglR0SfWrite: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
387	if (RT_SUCCESS(rc))
388	{
389	rc = data.callInfo.Hdr.rc;
390	*pcbBuffer = data.cb.u.value32;
391	}
392	return rc;
393	}
394
395	DECLVBGL(int) VbglR0SfWritePhysCont(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset,
396	uint32_t *pcbBuffer, RTCCPHYS PhysBuffer)
397	{
398	uint32_t cbToWrite = *pcbBuffer;
399	uint32_t cPages = RT_ALIGN_32((PhysBuffer & PAGE_OFFSET_MASK) + cbToWrite, PAGE_SIZE) >> PAGE_SHIFT;
400	uint32_t cbData = (uint32_t)(sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
401	VBoxSFWrite pData = (VBoxSFWrite )RTMemTmpAlloc(cbData);
402	HGCMPageListInfo pPgLst = (HGCMPageListInfo )(pData + 1);
403	uint32_t iPage;
404	int rc;
405
406	if (RT_UNLIKELY(!pData))
407	return VERR_NO_TMP_MEMORY;
408
409	VBOX_INIT_CALL_EX(&pData->callInfo, WRITE, pClient, cbData);
410
411	pData->root.type = VMMDevHGCMParmType_32bit;
412	pData->root.u.value32 = pMap->root;
413
414	pData->handle.type = VMMDevHGCMParmType_64bit;
415	pData->handle.u.value64 = hFile;
416	pData->offset.type = VMMDevHGCMParmType_64bit;
417	pData->offset.u.value64 = offset;
418	pData->cb.type = VMMDevHGCMParmType_32bit;
419	pData->cb.u.value32 = cbToWrite;
420	pData->buffer.type = VMMDevHGCMParmType_PageList;
421	pData->buffer.u.PageList.size = cbToWrite;
422	pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
423
424	pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
425	pPgLst->offFirstPage = (uint16_t)(PhysBuffer & PAGE_OFFSET_MASK);
426	pPgLst->cPages = cPages;
427	PhysBuffer &= ~(RTCCPHYS)PAGE_OFFSET_MASK;
428	for (iPage = 0; iPage < cPages; iPage++, PhysBuffer += PAGE_SIZE)
429	pPgLst->aPages[iPage] = PhysBuffer;
430
431	rc = VbglR0HGCMCallRaw(pClient->handle, &pData->callInfo, cbData);
432	/* Log(("VBOXSF: VbglR0SfWritePhysCont: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
433	if (RT_SUCCESS(rc))
434	{
435	rc = pData->callInfo.Hdr.rc;
436	*pcbBuffer = pData->cb.u.value32;
437	}
438
439	RTMemTmpFree(pData);
440	return rc;
441
442	}
443
444	DECLVBGL(int) VbglR0SfWritePageList(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer,
445	uint16_t offFirstPage, uint16_t cPages, RTGCPHYS64 *paPages)
446	{
447	uint32_t cbToWrite = *pcbBuffer;
448	uint32_t cbData = (uint32_t)(sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
449	VBoxSFWrite pData = (VBoxSFWrite )RTMemTmpAlloc(cbData);
450	HGCMPageListInfo pPgLst = (HGCMPageListInfo )(pData + 1);
451	uint16_t iPage;
452	int rc;
453
454	if (RT_UNLIKELY(!pData))
455	return VERR_NO_TMP_MEMORY;
456
457	VBOX_INIT_CALL_EX(&pData->callInfo, WRITE, pClient, cbData);
458
459	pData->root.type = VMMDevHGCMParmType_32bit;
460	pData->root.u.value32 = pMap->root;
461
462	pData->handle.type = VMMDevHGCMParmType_64bit;
463	pData->handle.u.value64 = hFile;
464	pData->offset.type = VMMDevHGCMParmType_64bit;
465	pData->offset.u.value64 = offset;
466	pData->cb.type = VMMDevHGCMParmType_32bit;
467	pData->cb.u.value32 = cbToWrite;
468	pData->buffer.type = VMMDevHGCMParmType_PageList;
469	pData->buffer.u.PageList.size = cbToWrite;
470	pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
471
472	pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
473	pPgLst->offFirstPage = offFirstPage;
474	pPgLst->cPages = cPages;
475	for (iPage = 0; iPage < cPages; iPage++)
476	pPgLst->aPages[iPage] = paPages[iPage];
477
478	rc = VbglR0HGCMCallRaw(pClient->handle, &pData->callInfo, cbData);
479	/* Log(("VBOXSF: VbglR0SfWritePageList: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
480	if (RT_SUCCESS(rc))
481	{
482	rc = pData->callInfo.Hdr.rc;
483	*pcbBuffer = pData->cb.u.value32;
484	}
485
486	RTMemTmpFree(pData);
487	return rc;
488	}
489
490	DECLVBGL(int) VbglR0SfFlush(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile)
491	{
492	int rc;
493	VBoxSFFlush data;
494
495	VBOX_INIT_CALL(&data.callInfo, FLUSH, pClient);
496
497	data.root.type = VMMDevHGCMParmType_32bit;
498	data.root.u.value32 = pMap->root;
499
500	data.handle.type = VMMDevHGCMParmType_64bit;
501	data.handle.u.value64 = hFile;
502
503	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
504	/* Log(("VBOXSF: VbglR0SfFlush: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
505	return rc;
506	}
507
508	DECLVBGL(int) VbglR0SfDirInfo(
509	PVBGLSFCLIENT pClient,
510	PVBGLSFMAP pMap,
511	SHFLHANDLE hFile,
512	PSHFLSTRING ParsedPath,
513	uint32_t flags,
514	uint32_t index,
515	uint32_t *pcbBuffer,
516	PSHFLDIRINFO pBuffer,
517	uint32_t *pcFiles)
518	{
519	int rc;
520	VBoxSFList data;
521
522	VBOX_INIT_CALL(&data.callInfo, LIST, pClient);
523
524	data.root.type = VMMDevHGCMParmType_32bit;
525	data.root.u.value32 = pMap->root;
526
527	data.handle.type = VMMDevHGCMParmType_64bit;
528	data.handle.u.value64 = hFile;
529	data.flags.type = VMMDevHGCMParmType_32bit;
530	data.flags.u.value32 = flags;
531	data.cb.type = VMMDevHGCMParmType_32bit;
532	data.cb.u.value32 = *pcbBuffer;
533	data.path.type = VMMDevHGCMParmType_LinAddr_In;
534	data.path.u.Pointer.size = ParsedPath ? ShflStringSizeOfBuffer(ParsedPath) : 0;
535	data.path.u.Pointer.u.linearAddr = (uintptr_t) ParsedPath;
536
537	data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
538	data.buffer.u.Pointer.size = *pcbBuffer;
539	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
540
541	data.resumePoint.type = VMMDevHGCMParmType_32bit;
542	data.resumePoint.u.value32 = index;
543	data.cFiles.type = VMMDevHGCMParmType_32bit;
544	data.cFiles.u.value32 = 0; /* out parameters only */
545
546	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
547	/* Log(("VBOXSF: VbglR0SfDirInfo: rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
548	*pcbBuffer = data.cb.u.value32;
549	*pcFiles = data.cFiles.u.value32;
550	return rc;
551	}
552
553	DECLVBGL(int) VbglR0SfFsInfo(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
554	uint32_t flags, uint32_t *pcbBuffer, PSHFLDIRINFO pBuffer)
555	{
556	int rc;
557	VBoxSFInformation data;
558
559	VBOX_INIT_CALL(&data.callInfo, INFORMATION, pClient);
560
561	data.root.type = VMMDevHGCMParmType_32bit;
562	data.root.u.value32 = pMap->root;
563
564	data.handle.type = VMMDevHGCMParmType_64bit;
565	data.handle.u.value64 = hFile;
566	data.flags.type = VMMDevHGCMParmType_32bit;
567	data.flags.u.value32 = flags;
568	data.cb.type = VMMDevHGCMParmType_32bit;
569	data.cb.u.value32 = *pcbBuffer;
570	data.info.type = VMMDevHGCMParmType_LinAddr;
571	data.info.u.Pointer.size = *pcbBuffer;
572	data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
573
574	rc = VbglR0HGCMCallRaw(pClient->handle, &data.callInfo, sizeof(data));
575	/* Log(("VBOXSF: VbglR0SfFsInfo: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
576	if (RT_SUCCESS(rc))
577	{
578	rc = data.callInfo.Hdr.rc;
579	*pcbBuffer = data.cb.u.value32;
580	}
581	return rc;
582	}
583
584	DECLVBGL(int) VbglR0SfLock(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
585	uint64_t offset, uint64_t cbSize, uint32_t fLock)
586	{
587	int rc;
588	VBoxSFLock data;
589
590	VBOX_INIT_CALL(&data.callInfo, LOCK, pClient);
591
592	data.root.type = VMMDevHGCMParmType_32bit;
593	data.root.u.value32 = pMap->root;
594
595	data.handle.type = VMMDevHGCMParmType_64bit;
596	data.handle.u.value64 = hFile;
597	data.offset.type = VMMDevHGCMParmType_64bit;
598	data.offset.u.value64 = offset;
599	data.length.type = VMMDevHGCMParmType_64bit;
600	data.length.u.value64 = cbSize;
601
602	data.flags.type = VMMDevHGCMParmType_32bit;
603	data.flags.u.value32 = fLock;
604
605	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
606	/* Log(("VBOXSF: VbglR0SfLock: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
607	return rc;
608	}
609
610	DECLVBGL(int) VbglR0SfSetUtf8(PVBGLSFCLIENT pClient)
611	{
612	int rc;
613	VBGLIOCHGCMCALL callInfo;
614
615	VBOX_INIT_CALL(&callInfo, SET_UTF8, pClient);
616	rc = VbglR0HGCMCall(pClient->handle, &callInfo, sizeof(callInfo));
617	/* Log(("VBOXSF: VbglR0SfSetUtf8: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
618	return rc;
619	}
620
621	DECLVBGL(int) VbglR0SfReadLink(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, uint32_t cbBuffer, uint8_t *pBuffer)
622	{
623	int rc;
624	VBoxSFReadLink data;
625
626	VBOX_INIT_CALL(&data.callInfo, READLINK, pClient);
627
628	data.root.type = VMMDevHGCMParmType_32bit;
629	data.root.u.value32 = pMap->root;
630
631	data.path.type = VMMDevHGCMParmType_LinAddr_In;
632	data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
633	data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
634
635	data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
636	data.buffer.u.Pointer.size = cbBuffer;
637	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
638
639	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
640	/* Log(("VBOXSF: VbglR0SfReadLink: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
641	return rc;
642	}
643
644	DECLVBGL(int) VbglR0SfSymlink(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pNewPath, PSHFLSTRING pOldPath,
645	PSHFLFSOBJINFO pBuffer)
646	{
647	int rc;
648	VBoxSFSymlink data;
649
650	VBOX_INIT_CALL(&data.callInfo, SYMLINK, pClient);
651
652	data.root.type = VMMDevHGCMParmType_32bit;
653	data.root.u.value32 = pMap->root;
654
655	data.newPath.type = VMMDevHGCMParmType_LinAddr_In;
656	data.newPath.u.Pointer.size = ShflStringSizeOfBuffer (pNewPath);
657	data.newPath.u.Pointer.u.linearAddr = (uintptr_t)pNewPath;
658
659	data.oldPath.type = VMMDevHGCMParmType_LinAddr_In;
660	data.oldPath.u.Pointer.size = ShflStringSizeOfBuffer (pOldPath);
661	data.oldPath.u.Pointer.u.linearAddr = (uintptr_t)pOldPath;
662
663	data.info.type = VMMDevHGCMParmType_LinAddr_Out;
664	data.info.u.Pointer.size = sizeof(SHFLFSOBJINFO);
665	data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
666
667	rc = VbglR0HGCMCall(pClient->handle, &data.callInfo, sizeof(data));
668	/* Log(("VBOXSF: VbglR0SfSymlink: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
669	return rc;
670	}
671
672	DECLVBGL(int) VbglR0SfSetSymlinks(PVBGLSFCLIENT pClient)
673	{
674	int rc;
675	VBGLIOCHGCMCALL callInfo;
676
677	VBOX_INIT_CALL(&callInfo, SET_SYMLINKS, pClient);
678	rc = VbglR0HGCMCall(pClient->handle, &callInfo, sizeof(callInfo));
679	/* Log(("VBOXSF: VbglR0SfSetSymlinks: VbglR0HGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.Hdr.rc)); */
680	return rc;
681	}
682

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibSharedFolders.c@ 69149

Download in other formats: