VirtualBox

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

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

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette