VirtualBox

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

Last change on this file since 77854 was 77854, checked in by vboxsync, 6 years ago

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