VirtualBox

source: vbox/trunk/src/VBox/Additions/linux/sharedfolders/regops.c

Last change on this file was 103767, checked in by vboxsync, 2 months ago

Additions: Linux: vboxsf: Few more fixes for UBSAN, bugref:10585.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 150.3 KB
Line 
1/* $Id: regops.c 103767 2024-03-11 14:23:25Z vboxsync $ */
2/** @file
3 * vboxsf - VBox Linux Shared Folders VFS, regular file inode and file operations.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
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#include "vfsmod.h"
36#include <linux/uio.h>
37#if RTLNX_VER_MIN(2,5,32)
38# include <linux/aio.h> /* struct kiocb before 4.1 */
39#endif
40#if RTLNX_VER_MIN(2,5,12)
41# include <linux/buffer_head.h>
42#endif
43#if RTLNX_VER_RANGE(2,5,12, 2,6,31)
44# include <linux/writeback.h>
45#endif
46#if RTLNX_VER_RANGE(2,6,23, 3,16,0)
47# include <linux/splice.h>
48#endif
49#if RTLNX_VER_RANGE(2,6,17, 2,6,23)
50# include <linux/pipe_fs_i.h>
51#endif
52#if RTLNX_VER_MIN(2,4,10)
53# include <linux/swap.h> /* for mark_page_accessed */
54#endif
55#include <iprt/err.h>
56
57#if RTLNX_VER_MAX(2,6,18)
58# define SEEK_END 2
59#endif
60
61#if RTLNX_VER_MIN(6,4,0)
62# define VBOX_ITER_IOV_ADDR(a_iter) iter_iov_addr(a_iter)
63#elif RTLNX_VER_MIN(3,19,0)
64# define VBOX_ITER_IOV_ADDR(a_iter) (a_iter->kvec->iov_base + a_iter->iov_offset)
65#else
66# define VBOX_ITER_IOV_ADDR(a_iter) (a_iter->iov->iov_base + a_iter->iov_offset)
67#endif
68
69#if RTLNX_VER_MAX(3,16,0)
70# define iter_is_iovec(a_pIter) ( !((a_pIter)->type & ITER_KVEC) )
71#elif RTLNX_VER_MAX(3,19,0)
72# define iter_is_iovec(a_pIter) ( !((a_pIter)->type & (ITER_KVEC | ITER_BVEC)) )
73#endif
74
75#if RTLNX_VER_MAX(4,17,0)
76# define vm_fault_t int
77#endif
78
79#if RTLNX_VER_MAX(2,5,20)
80# define pgoff_t unsigned long
81#endif
82
83#if RTLNX_VER_MAX(2,5,12)
84# define PageUptodate(a_pPage) Page_Uptodate(a_pPage)
85#endif
86
87
88/*********************************************************************************************************************************
89* Defined Constants And Macros *
90*********************************************************************************************************************************/
91/** @def VBSF_GET_ITER_TYPE
92 * Accessor for getting iov iter type member which changed name in 5.14. */
93#if RTLNX_VER_MIN(5,14,0)
94# define VBSF_GET_ITER_TYPE(a_pIter) ((a_pIter)->iter_type)
95#else
96# define VBSF_GET_ITER_TYPE(a_pIter) ((a_pIter)->type)
97#endif
98
99/** Starting from 6.4.0, iter_iov() macro should be used in order to access to iov field
100 * of struct iov_iter. */
101#if RTLNX_VER_MIN(6,4,0) || RTLNX_RHEL_RANGE(9,4, 9,99)
102# define VBSF_GET_ITER_IOV(_iter) iter_iov(_iter)
103#else
104# define VBSF_GET_ITER_IOV(_iter) iter->iov
105#endif
106
107/** @def VBOX_IOV_ITER_IS_KVEC
108 * Test if iov iter type is ITER_KVEC. */
109#if RTLNX_VER_MIN(4,20,0)
110# define VBOX_IOV_ITER_IS_KVEC(a_iter) iov_iter_is_kvec(a_iter)
111#else
112# define VBOX_IOV_ITER_IS_KVEC(a_iter) (VBSF_GET_ITER_TYPE(iter) & ITER_KVEC)
113#endif
114
115
116/*********************************************************************************************************************************
117* Structures and Typedefs *
118*********************************************************************************************************************************/
119#if RTLNX_VER_MAX(3,16,0)
120struct vbsf_iov_iter {
121 unsigned int type;
122 unsigned int v_write : 1;
123 size_t iov_offset;
124 size_t nr_segs;
125 struct iovec const *iov;
126# ifdef VBOX_STRICT
127 struct iovec const *iov_org;
128 size_t nr_segs_org;
129# endif
130};
131# ifdef VBOX_STRICT
132# define VBSF_IOV_ITER_INITIALIZER(a_cSegs, a_pIov, a_fWrite) \
133 { vbsf_iov_iter_detect_type(a_pIov, a_cSegs), a_fWrite, 0, a_cSegs, a_pIov, a_pIov, a_cSegs }
134# else
135# define VBSF_IOV_ITER_INITIALIZER(a_cSegs, a_pIov, a_fWrite) \
136 { vbsf_iov_iter_detect_type(a_pIov, a_cSegs), a_fWrite, 0, a_cSegs, a_pIov }
137# endif
138# define ITER_KVEC 1
139# define iov_iter vbsf_iov_iter
140#endif
141
142#if RTLNX_VER_MIN(2,6,19)
143/** Used by vbsf_iter_lock_pages() to keep the first page of the next segment. */
144struct vbsf_iter_stash {
145 struct page *pPage;
146 size_t off;
147 size_t cb;
148# if RTLNX_VER_MAX(4,11,0)
149 size_t offFromEnd;
150 struct iov_iter Copy;
151# endif
152};
153#endif /* >= 3.16.0 */
154/** Initializer for struct vbsf_iter_stash. */
155#if RTLNX_VER_MIN(4,11,0)
156# define VBSF_ITER_STASH_INITIALIZER { NULL, 0 }
157#else
158# define VBSF_ITER_STASH_INITIALIZER { NULL, 0, ~(size_t)0 }
159#endif
160
161
162/*********************************************************************************************************************************
163* Internal Functions *
164*********************************************************************************************************************************/
165DECLINLINE(void) vbsf_put_page(struct page *pPage);
166static void vbsf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty, bool fLockPgHack);
167static void vbsf_reg_write_sync_page_cache(struct address_space *mapping, loff_t offFile, uint32_t cbRange,
168 uint8_t const *pbSrcBuf, struct page **papSrcPages,
169 uint32_t offSrcPage, size_t cSrcPages);
170
171
172/*********************************************************************************************************************************
173* Provide more recent uio.h functionality to older kernels. *
174*********************************************************************************************************************************/
175#if RTLNX_VER_RANGE(2,6,19, 3,16,0)
176
177/**
178 * Detects the vector type.
179 */
180static int vbsf_iov_iter_detect_type(struct iovec const *paIov, size_t cSegs)
181{
182 /* Check the first segment with a non-zero length. */
183 while (cSegs-- > 0) {
184 if (paIov->iov_len > 0) {
185 if (access_ok(VERIFY_READ, paIov->iov_base, paIov->iov_len))
186#if RTLNX_VER_MIN(5,10,0)
187 return (uintptr_t)paIov->iov_base >= TASK_SIZE_MAX ? ITER_KVEC : 0;
188#else
189 return (uintptr_t)paIov->iov_base >= USER_DS.seg ? ITER_KVEC : 0;
190#endif
191 AssertMsgFailed(("%p LB %#zx\n", paIov->iov_base, paIov->iov_len));
192 break;
193 }
194 paIov++;
195 }
196 return 0;
197}
198
199
200# undef iov_iter_count
201# define iov_iter_count(a_pIter) vbsf_iov_iter_count(a_pIter)
202static size_t vbsf_iov_iter_count(struct vbsf_iov_iter const *iter)
203{
204 size_t cbRet = 0;
205 size_t cLeft = iter->nr_segs;
206 struct iovec const *iov = iter->iov;
207 while (cLeft-- > 0) {
208 cbRet += iov->iov_len;
209 iov++;
210 }
211 return cbRet - iter->iov_offset;
212}
213
214
215# undef iov_iter_single_seg_count
216# define iov_iter_single_seg_count(a_pIter) vbsf_iov_iter_single_seg_count(a_pIter)
217static size_t vbsf_iov_iter_single_seg_count(struct vbsf_iov_iter const *iter)
218{
219 if (iter->nr_segs > 0)
220 return iter->iov->iov_len - iter->iov_offset;
221 return 0;
222}
223
224
225# undef iov_iter_advance
226# define iov_iter_advance(a_pIter, a_cbSkip) vbsf_iov_iter_advance(a_pIter, a_cbSkip)
227static void vbsf_iov_iter_advance(struct vbsf_iov_iter *iter, size_t cbSkip)
228{
229 SFLOG2(("vbsf_iov_iter_advance: cbSkip=%#zx\n", cbSkip));
230 if (iter->nr_segs > 0) {
231 size_t const cbLeftCur = iter->iov->iov_len - iter->iov_offset;
232 Assert(iter->iov_offset <= iter->iov->iov_len);
233 if (cbLeftCur > cbSkip) {
234 iter->iov_offset += cbSkip;
235 } else {
236 cbSkip -= cbLeftCur;
237 iter->iov_offset = 0;
238 iter->iov++;
239 iter->nr_segs--;
240 while (iter->nr_segs > 0) {
241 size_t const cbSeg = iter->iov->iov_len;
242 if (cbSeg > cbSkip) {
243 iter->iov_offset = cbSkip;
244 break;
245 }
246 cbSkip -= cbSeg;
247 iter->iov++;
248 iter->nr_segs--;
249 }
250 }
251 }
252}
253
254
255# undef iov_iter_get_pages
256# define iov_iter_get_pages(a_pIter, a_papPages, a_cbMax, a_cMaxPages, a_poffPg0) \
257 vbsf_iov_iter_get_pages(a_pIter, a_papPages, a_cbMax, a_cMaxPages, a_poffPg0)
258static ssize_t vbsf_iov_iter_get_pages(struct vbsf_iov_iter *iter, struct page **papPages,
259 size_t cbMax, unsigned cMaxPages, size_t *poffPg0)
260{
261 while (iter->nr_segs > 0) {
262 size_t const cbLeft = iter->iov->iov_len - iter->iov_offset;
263 Assert(iter->iov->iov_len >= iter->iov_offset);
264 if (cbLeft > 0) {
265 uintptr_t uPtrFrom = (uintptr_t)iter->iov->iov_base + iter->iov_offset;
266 size_t offPg0 = *poffPg0 = uPtrFrom & PAGE_OFFSET_MASK;
267 size_t cPagesLeft = RT_ALIGN_Z(offPg0 + cbLeft, PAGE_SIZE) >> PAGE_SHIFT;
268 size_t cPages = RT_MIN(cPagesLeft, cMaxPages);
269 struct task_struct *pTask = current;
270 size_t cPagesLocked;
271
272 down_read(&pTask->mm->mmap_sem);
273 cPagesLocked = get_user_pages(pTask, pTask->mm, uPtrFrom, cPages, iter->v_write, 1 /*force*/, papPages, NULL);
274 up_read(&pTask->mm->mmap_sem);
275 if (cPagesLocked == cPages) {
276 size_t cbRet = (cPages << PAGE_SHIFT) - offPg0;
277 if (cPages == cPagesLeft) {
278 size_t offLastPg = (uPtrFrom + cbLeft) & PAGE_OFFSET_MASK;
279 if (offLastPg)
280 cbRet -= PAGE_SIZE - offLastPg;
281 }
282 Assert(cbRet <= cbLeft);
283 return cbRet;
284 }
285 if (cPagesLocked > 0)
286 vbsf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/, false /*fLockPgHack*/);
287 return -EFAULT;
288 }
289 iter->iov_offset = 0;
290 iter->iov++;
291 iter->nr_segs--;
292 }
293 AssertFailed();
294 return 0;
295}
296
297
298# undef iov_iter_truncate
299# define iov_iter_truncate(iter, cbNew) vbsf_iov_iter_truncate(iter, cbNew)
300static void vbsf_iov_iter_truncate(struct vbsf_iov_iter *iter, size_t cbNew)
301{
302 /* we have no counter or stuff, so it's a no-op. */
303 RT_NOREF(iter, cbNew);
304}
305
306
307# undef iov_iter_revert
308# define iov_iter_revert(a_pIter, a_cbRewind) vbsf_iov_iter_revert(a_pIter, a_cbRewind)
309void vbsf_iov_iter_revert(struct vbsf_iov_iter *iter, size_t cbRewind)
310{
311 SFLOG2(("vbsf_iov_iter_revert: cbRewind=%#zx\n", cbRewind));
312 if (iter->iov_offset > 0) {
313 if (cbRewind <= iter->iov_offset) {
314 iter->iov_offset -= cbRewind;
315 return;
316 }
317 cbRewind -= iter->iov_offset;
318 iter->iov_offset = 0;
319 }
320
321 while (cbRewind > 0) {
322 struct iovec const *pIov = --iter->iov;
323 size_t const cbSeg = pIov->iov_len;
324 iter->nr_segs++;
325
326 Assert((uintptr_t)pIov >= (uintptr_t)iter->iov_org);
327 Assert(iter->nr_segs <= iter->nr_segs_org);
328
329 if (cbRewind <= cbSeg) {
330 iter->iov_offset = cbSeg - cbRewind;
331 break;
332 }
333 cbRewind -= cbSeg;
334 }
335}
336
337#endif /* 2.6.19 <= linux < 3.16.0 */
338#if RTLNX_VER_RANGE(3,16,0, 3,16,35)
339
340/** This is for implementing cMaxPage on 3.16 which doesn't have it. */
341static ssize_t vbsf_iov_iter_get_pages_3_16(struct iov_iter *iter, struct page **papPages,
342 size_t cbMax, unsigned cMaxPages, size_t *poffPg0)
343{
344 if (!(iter->type & ITER_BVEC)) {
345 size_t const offPg0 = iter->iov_offset & PAGE_OFFSET_MASK;
346 size_t const cbMaxPages = ((size_t)cMaxPages << PAGE_SHIFT) - offPg0;
347 if (cbMax > cbMaxPages)
348 cbMax = cbMaxPages;
349 }
350 /* else: BVEC works a page at a time and shouldn't have much of a problem here. */
351 return iov_iter_get_pages(iter, papPages, cbMax, poffPg0);
352}
353# undef iov_iter_get_pages
354# define iov_iter_get_pages(a_pIter, a_papPages, a_cbMax, a_cMaxPages, a_poffPg0) \
355 vbsf_iov_iter_get_pages_3_16(a_pIter, a_papPages, a_cbMax, a_cMaxPages, a_poffPg0)
356
357#endif /* 3.16.0-3.16.34 */
358#if RTLNX_VER_RANGE(2,6,19, 3,18,0)
359
360static size_t copy_from_iter(uint8_t *pbDst, size_t cbToCopy, struct iov_iter *pSrcIter)
361{
362 size_t const cbTotal = cbToCopy;
363 Assert(iov_iter_count(pSrcIter) >= cbToCopy);
364# if RTLNX_VER_MIN(3,16,0)
365 if (pSrcIter->type & ITER_BVEC) {
366 while (cbToCopy > 0) {
367 size_t const offPage = (uintptr_t)pbDst & PAGE_OFFSET_MASK;
368 size_t const cbThisCopy = RT_MIN(PAGE_SIZE - offPage, cbToCopy);
369 struct page *pPage = rtR0MemObjLinuxVirtToPage(pbDst);
370 size_t cbCopied = copy_page_from_iter(pPage, offPage, cbThisCopy, pSrcIter);
371 AssertStmt(cbCopied <= cbThisCopy, cbCopied = cbThisCopy);
372 pbDst += cbCopied;
373 cbToCopy -= cbCopied;
374 if (cbCopied != cbToCopy)
375 break;
376 }
377 } else
378# endif
379 {
380 while (cbToCopy > 0) {
381 size_t cbThisCopy = iov_iter_single_seg_count(pSrcIter);
382 if (cbThisCopy > 0) {
383 if (cbThisCopy > cbToCopy)
384 cbThisCopy = cbToCopy;
385 if (pSrcIter->type & ITER_KVEC)
386 memcpy(pbDst, (void *)VBOX_ITER_IOV_ADDR(pSrcIter), cbThisCopy);
387 else if (copy_from_user(pbDst, VBOX_ITER_IOV_ADDR(pSrcIter), cbThisCopy) != 0)
388 break;
389 pbDst += cbThisCopy;
390 cbToCopy -= cbThisCopy;
391 }
392 iov_iter_advance(pSrcIter, cbThisCopy);
393 }
394 }
395 return cbTotal - cbToCopy;
396}
397
398
399static size_t copy_to_iter(uint8_t const *pbSrc, size_t cbToCopy, struct iov_iter *pDstIter)
400{
401 size_t const cbTotal = cbToCopy;
402 Assert(iov_iter_count(pDstIter) >= cbToCopy);
403# if RTLNX_VER_MIN(3,16,0)
404 if (pDstIter->type & ITER_BVEC) {
405 while (cbToCopy > 0) {
406 size_t const offPage = (uintptr_t)pbSrc & PAGE_OFFSET_MASK;
407 size_t const cbThisCopy = RT_MIN(PAGE_SIZE - offPage, cbToCopy);
408 struct page *pPage = rtR0MemObjLinuxVirtToPage((void *)pbSrc);
409 size_t cbCopied = copy_page_to_iter(pPage, offPage, cbThisCopy, pDstIter);
410 AssertStmt(cbCopied <= cbThisCopy, cbCopied = cbThisCopy);
411 pbSrc += cbCopied;
412 cbToCopy -= cbCopied;
413 if (cbCopied != cbToCopy)
414 break;
415 }
416 } else
417# endif
418 {
419 while (cbToCopy > 0) {
420 size_t cbThisCopy = iov_iter_single_seg_count(pDstIter);
421 if (cbThisCopy > 0) {
422 if (cbThisCopy > cbToCopy)
423 cbThisCopy = cbToCopy;
424 if (pDstIter->type & ITER_KVEC)
425 memcpy((void *)VBOX_ITER_IOV_ADDR(pDstIter), pbSrc, cbThisCopy);
426 else if (copy_to_user(VBOX_ITER_IOV_ADDR(pDstIter), pbSrc, cbThisCopy) != 0) {
427 break;
428 }
429 pbSrc += cbThisCopy;
430 cbToCopy -= cbThisCopy;
431 }
432 iov_iter_advance(pDstIter, cbThisCopy);
433 }
434 }
435 return cbTotal - cbToCopy;
436}
437
438#endif /* 3.16.0 <= linux < 3.18.0 */
439
440
441
442/*********************************************************************************************************************************
443* Handle management *
444*********************************************************************************************************************************/
445
446/**
447 * Called when an inode is released to unlink all handles that might impossibly
448 * still be associated with it.
449 *
450 * @param pInodeInfo The inode which handles to drop.
451 */
452void vbsf_handle_drop_chain(struct vbsf_inode_info *pInodeInfo)
453{
454 struct vbsf_handle *pCur, *pNext;
455 unsigned long fSavedFlags;
456 SFLOGFLOW(("vbsf_handle_drop_chain: %p\n", pInodeInfo));
457 spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
458
459 RTListForEachSafe(&pInodeInfo->HandleList, pCur, pNext, struct vbsf_handle, Entry) {
460 AssertMsg( (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
461 == (VBSF_HANDLE_F_MAGIC | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
462 pCur->fFlags |= VBSF_HANDLE_F_ON_LIST;
463 RTListNodeRemove(&pCur->Entry);
464 }
465
466 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
467}
468
469
470/**
471 * Locates a handle that matches all the flags in @a fFlags.
472 *
473 * @returns Pointer to handle on success (retained), use vbsf_handle_release() to
474 * release it. NULL if no suitable handle was found.
475 * @param pInodeInfo The inode info to search.
476 * @param fFlagsSet The flags that must be set.
477 * @param fFlagsClear The flags that must be clear.
478 */
479struct vbsf_handle *vbsf_handle_find(struct vbsf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear)
480{
481 struct vbsf_handle *pCur;
482 unsigned long fSavedFlags;
483 spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
484
485 RTListForEach(&pInodeInfo->HandleList, pCur, struct vbsf_handle, Entry) {
486 AssertMsg( (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
487 == (VBSF_HANDLE_F_MAGIC | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
488 if ((pCur->fFlags & (fFlagsSet | fFlagsClear)) == fFlagsSet) {
489 uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
490 if (cRefs > 1) {
491 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
492 SFLOGFLOW(("vbsf_handle_find: returns %p\n", pCur));
493 return pCur;
494 }
495 /* Oops, already being closed (safe as it's only ever increased here). */
496 ASMAtomicDecU32(&pCur->cRefs);
497 }
498 }
499
500 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
501 SFLOGFLOW(("vbsf_handle_find: returns NULL!\n"));
502 return NULL;
503}
504
505
506/**
507 * Slow worker for vbsf_handle_release() that does the freeing.
508 *
509 * @returns 0 (ref count).
510 * @param pHandle The handle to release.
511 * @param pSuperInfo The info structure for the shared folder associated with
512 * the handle.
513 * @param pszCaller The caller name (for logging failures).
514 */
515uint32_t vbsf_handle_release_slow(struct vbsf_handle *pHandle, struct vbsf_super_info *pSuperInfo, const char *pszCaller)
516{
517 int rc;
518 unsigned long fSavedFlags;
519
520 SFLOGFLOW(("vbsf_handle_release_slow: %p (%s)\n", pHandle, pszCaller));
521
522 /*
523 * Remove from the list.
524 */
525 spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
526
527 AssertMsg((pHandle->fFlags & VBSF_HANDLE_F_MAGIC_MASK) == VBSF_HANDLE_F_MAGIC, ("%p %#x\n", pHandle, pHandle->fFlags));
528 Assert(pHandle->pInodeInfo);
529 Assert(pHandle->pInodeInfo && pHandle->pInodeInfo->u32Magic == SF_INODE_INFO_MAGIC);
530
531 if (pHandle->fFlags & VBSF_HANDLE_F_ON_LIST) {
532 pHandle->fFlags &= ~VBSF_HANDLE_F_ON_LIST;
533 RTListNodeRemove(&pHandle->Entry);
534 }
535
536 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
537
538 /*
539 * Actually destroy it.
540 */
541 rc = VbglR0SfHostReqCloseSimple(pSuperInfo->map.root, pHandle->hHost);
542 if (RT_FAILURE(rc))
543 LogFunc(("Caller %s: VbglR0SfHostReqCloseSimple %#RX64 failed with rc=%Rrc\n", pszCaller, pHandle->hHost, rc));
544 pHandle->hHost = SHFL_HANDLE_NIL;
545 pHandle->fFlags = VBSF_HANDLE_F_MAGIC_DEAD;
546 kfree(pHandle);
547 return 0;
548}
549
550
551/**
552 * Appends a handle to a handle list.
553 *
554 * @param pInodeInfo The inode to add it to.
555 * @param pHandle The handle to add.
556 */
557void vbsf_handle_append(struct vbsf_inode_info *pInodeInfo, struct vbsf_handle *pHandle)
558{
559#ifdef VBOX_STRICT
560 struct vbsf_handle *pCur;
561#endif
562 unsigned long fSavedFlags;
563
564 SFLOGFLOW(("vbsf_handle_append: %p (to %p)\n", pHandle, pInodeInfo));
565 AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
566 ("%p %#x\n", pHandle, pHandle->fFlags));
567 Assert(pInodeInfo->u32Magic == SF_INODE_INFO_MAGIC);
568
569 spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
570
571 AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
572 ("%p %#x\n", pHandle, pHandle->fFlags));
573#ifdef VBOX_STRICT
574 RTListForEach(&pInodeInfo->HandleList, pCur, struct vbsf_handle, Entry) {
575 Assert(pCur != pHandle);
576 AssertMsg( (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
577 == (VBSF_HANDLE_F_MAGIC | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
578 }
579 pHandle->pInodeInfo = pInodeInfo;
580#endif
581
582 pHandle->fFlags |= VBSF_HANDLE_F_ON_LIST;
583 RTListAppend(&pInodeInfo->HandleList, &pHandle->Entry);
584
585 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
586}
587
588
589
590/*********************************************************************************************************************************
591* Misc *
592*********************************************************************************************************************************/
593
594#if RTLNX_VER_MAX(2,6,6)
595/** Any writable mappings? */
596DECLINLINE(bool) mapping_writably_mapped(struct address_space const *mapping)
597{
598# if RTLNX_VER_MIN(2,5,6)
599 return !list_empty(&mapping->i_mmap_shared);
600# else
601 return mapping->i_mmap_shared != NULL;
602# endif
603}
604#endif
605
606
607#if RTLNX_VER_MAX(2,5,12)
608/** Missing in 2.4.x, so just stub it for now. */
609DECLINLINE(bool) PageWriteback(struct page const *page)
610{
611 return false;
612}
613#endif
614
615
616/**
617 * Helper for deciding wheter we should do a read via the page cache or not.
618 *
619 * By default we will only use the page cache if there is a writable memory
620 * mapping of the file with a chance that it may have modified any of the pages
621 * already.
622 */
623DECLINLINE(bool) vbsf_should_use_cached_read(struct file *file, struct address_space *mapping, struct vbsf_super_info *pSuperInfo)
624{
625 if ( (file->f_flags & O_DIRECT)
626 || pSuperInfo->enmCacheMode == kVbsfCacheMode_None)
627 return false;
628 if ( pSuperInfo->enmCacheMode == kVbsfCacheMode_Read
629 || pSuperInfo->enmCacheMode == kVbsfCacheMode_ReadWrite)
630 return true;
631 Assert(pSuperInfo->enmCacheMode == kVbsfCacheMode_Strict);
632 return mapping
633 && mapping->nrpages > 0
634 && mapping_writably_mapped(mapping);
635}
636
637
638
639/*********************************************************************************************************************************
640* Pipe / splice stuff mainly for 2.6.17 >= linux < 2.6.31 (where no fallbacks were available) *
641*********************************************************************************************************************************/
642
643#if RTLNX_VER_RANGE(2,6,17, 3,16,0)
644
645# if RTLNX_VER_MAX(2,6,30)
646# define LOCK_PIPE(a_pPipe) do { if ((a_pPipe)->inode) mutex_lock(&(a_pPipe)->inode->i_mutex); } while (0)
647# define UNLOCK_PIPE(a_pPipe) do { if ((a_pPipe)->inode) mutex_unlock(&(a_pPipe)->inode->i_mutex); } while (0)
648# else
649# define LOCK_PIPE(a_pPipe) pipe_lock(a_pPipe)
650# define UNLOCK_PIPE(a_pPipe) pipe_unlock(a_pPipe)
651# endif
652
653
654/** Waits for the pipe buffer status to change. */
655static void vbsf_wait_pipe(struct pipe_inode_info *pPipe)
656{
657 DEFINE_WAIT(WaitStuff);
658# ifdef TASK_NONINTERACTIVE
659 prepare_to_wait(&pPipe->wait, &WaitStuff, TASK_INTERRUPTIBLE | TASK_NONINTERACTIVE);
660# else
661 prepare_to_wait(&pPipe->wait, &WaitStuff, TASK_INTERRUPTIBLE);
662# endif
663 UNLOCK_PIPE(pPipe);
664
665 schedule();
666
667 finish_wait(&pPipe->wait, &WaitStuff);
668 LOCK_PIPE(pPipe);
669}
670
671
672/** Worker for vbsf_feed_pages_to_pipe that wakes up readers. */
673static void vbsf_wake_up_pipe(struct pipe_inode_info *pPipe, bool fReaders)
674{
675 smp_mb();
676 if (waitqueue_active(&pPipe->wait))
677 wake_up_interruptible_sync(&pPipe->wait);
678 if (fReaders)
679 kill_fasync(&pPipe->fasync_readers, SIGIO, POLL_IN);
680 else
681 kill_fasync(&pPipe->fasync_writers, SIGIO, POLL_OUT);
682}
683
684#endif
685#if RTLNX_VER_RANGE(2,6,17, 2,6,31)
686
687/** Verify pipe buffer content (needed for page-cache to ensure idle page). */
688static int vbsf_pipe_buf_confirm(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf)
689{
690 /*SFLOG3(("vbsf_pipe_buf_confirm: %p\n", pPipeBuf));*/
691 return 0;
692}
693
694
695/** Maps the buffer page. */
696static void *vbsf_pipe_buf_map(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf, int atomic)
697{
698 void *pvRet;
699 if (!atomic)
700 pvRet = kmap(pPipeBuf->page);
701 else {
702 pPipeBuf->flags |= PIPE_BUF_FLAG_ATOMIC;
703 pvRet = kmap_atomic(pPipeBuf->page, KM_USER0);
704 }
705 /*SFLOG3(("vbsf_pipe_buf_map: %p -> %p\n", pPipeBuf, pvRet));*/
706 return pvRet;
707}
708
709
710/** Unmaps the buffer page. */
711static void vbsf_pipe_buf_unmap(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf, void *pvMapping)
712{
713 /*SFLOG3(("vbsf_pipe_buf_unmap: %p/%p\n", pPipeBuf, pvMapping)); */
714 if (!(pPipeBuf->flags & PIPE_BUF_FLAG_ATOMIC))
715 kunmap(pPipeBuf->page);
716 else {
717 pPipeBuf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
718 kunmap_atomic(pvMapping, KM_USER0);
719 }
720}
721
722
723/** Gets a reference to the page. */
724static void vbsf_pipe_buf_get(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf)
725{
726 page_cache_get(pPipeBuf->page);
727 /*SFLOG3(("vbsf_pipe_buf_get: %p (return count=%d)\n", pPipeBuf, page_count(pPipeBuf->page)));*/
728}
729
730
731/** Release the buffer page (counter to vbsf_pipe_buf_get). */
732static void vbsf_pipe_buf_release(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf)
733{
734 /*SFLOG3(("vbsf_pipe_buf_release: %p (incoming count=%d)\n", pPipeBuf, page_count(pPipeBuf->page)));*/
735 page_cache_release(pPipeBuf->page);
736}
737
738
739/** Attempt to steal the page.
740 * @returns 0 success, 1 on failure. */
741static int vbsf_pipe_buf_steal(struct pipe_inode_info *pPipe, struct pipe_buffer *pPipeBuf)
742{
743 if (page_count(pPipeBuf->page) == 1) {
744 lock_page(pPipeBuf->page);
745 SFLOG3(("vbsf_pipe_buf_steal: %p -> 0\n", pPipeBuf));
746 return 0;
747 }
748 SFLOG3(("vbsf_pipe_buf_steal: %p -> 1\n", pPipeBuf));
749 return 1;
750}
751
752
753/**
754 * Pipe buffer operations for used by vbsf_feed_pages_to_pipe.
755 */
756static struct pipe_buf_operations vbsf_pipe_buf_ops = {
757 .can_merge = 0,
758# if RTLNX_VER_MIN(2,6,23)
759 .confirm = vbsf_pipe_buf_confirm,
760# else
761 .pin = vbsf_pipe_buf_confirm,
762# endif
763 .map = vbsf_pipe_buf_map,
764 .unmap = vbsf_pipe_buf_unmap,
765 .get = vbsf_pipe_buf_get,
766 .release = vbsf_pipe_buf_release,
767 .steal = vbsf_pipe_buf_steal,
768};
769
770
771/**
772 * Feeds the pages to the pipe.
773 *
774 * Pages given to the pipe are set to NULL in papPages.
775 */
776static ssize_t vbsf_feed_pages_to_pipe(struct pipe_inode_info *pPipe, struct page **papPages, size_t cPages, uint32_t offPg0,
777 uint32_t cbActual, unsigned fFlags)
778{
779 ssize_t cbRet = 0;
780 size_t iPage = 0;
781 bool fNeedWakeUp = false;
782
783 LOCK_PIPE(pPipe);
784 for (;;) {
785 if ( pPipe->readers > 0
786 && pPipe->nrbufs < PIPE_BUFFERS) {
787 struct pipe_buffer *pPipeBuf = &pPipe->bufs[(pPipe->curbuf + pPipe->nrbufs) % PIPE_BUFFERS];
788 uint32_t const cbThisPage = RT_MIN(cbActual, PAGE_SIZE - offPg0);
789 pPipeBuf->len = cbThisPage;
790 pPipeBuf->offset = offPg0;
791# if RTLNX_VER_MIN(2,6,23)
792 pPipeBuf->private = 0;
793# endif
794 pPipeBuf->ops = &vbsf_pipe_buf_ops;
795 pPipeBuf->flags = fFlags & SPLICE_F_GIFT ? PIPE_BUF_FLAG_GIFT : 0;
796 pPipeBuf->page = papPages[iPage];
797
798 papPages[iPage++] = NULL;
799 pPipe->nrbufs++;
800 fNeedWakeUp |= pPipe->inode != NULL;
801 offPg0 = 0;
802 cbRet += cbThisPage;
803
804 /* done? */
805 cbActual -= cbThisPage;
806 if (!cbActual)
807 break;
808 } else if (pPipe->readers == 0) {
809 SFLOGFLOW(("vbsf_feed_pages_to_pipe: no readers!\n"));
810 send_sig(SIGPIPE, current, 0);
811 if (cbRet == 0)
812 cbRet = -EPIPE;
813 break;
814 } else if (fFlags & SPLICE_F_NONBLOCK) {
815 if (cbRet == 0)
816 cbRet = -EAGAIN;
817 break;
818 } else if (signal_pending(current)) {
819 if (cbRet == 0)
820 cbRet = -ERESTARTSYS;
821 SFLOGFLOW(("vbsf_feed_pages_to_pipe: pending signal! (%zd)\n", cbRet));
822 break;
823 } else {
824 if (fNeedWakeUp) {
825 vbsf_wake_up_pipe(pPipe, true /*fReaders*/);
826 fNeedWakeUp = 0;
827 }
828 pPipe->waiting_writers++;
829 vbsf_wait_pipe(pPipe);
830 pPipe->waiting_writers--;
831 }
832 }
833 UNLOCK_PIPE(pPipe);
834
835 if (fNeedWakeUp)
836 vbsf_wake_up_pipe(pPipe, true /*fReaders*/);
837
838 return cbRet;
839}
840
841
842/**
843 * For splicing from a file to a pipe.
844 */
845static ssize_t vbsf_splice_read(struct file *file, loff_t *poffset, struct pipe_inode_info *pipe, size_t len, unsigned int flags)
846{
847 struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
848 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
849 ssize_t cbRet;
850
851 SFLOGFLOW(("vbsf_splice_read: file=%p poffset=%p{%#RX64} pipe=%p len=%#zx flags=%#x\n", file, poffset, *poffset, pipe, len, flags));
852 if (vbsf_should_use_cached_read(file, inode->i_mapping, pSuperInfo)) {
853 cbRet = generic_file_splice_read(file, poffset, pipe, len, flags);
854 } else {
855 /*
856 * Create a read request.
857 */
858 loff_t offFile = *poffset;
859 size_t cPages = RT_MIN(RT_ALIGN_Z((offFile & ~PAGE_CACHE_MASK) + len, PAGE_CACHE_SIZE) >> PAGE_CACHE_SHIFT,
860 PIPE_BUFFERS);
861 VBOXSFREADPGLSTREQ *pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ,
862 PgLst.aPages[cPages]));
863 if (pReq) {
864 /*
865 * Allocate pages.
866 */
867 struct page *apPages[PIPE_BUFFERS];
868 size_t i;
869 pReq->PgLst.offFirstPage = (uint16_t)offFile & (uint16_t)PAGE_OFFSET_MASK;
870 cbRet = 0;
871 for (i = 0; i < cPages; i++) {
872 struct page *pPage;
873 apPages[i] = pPage = alloc_page(GFP_USER);
874 if (pPage) {
875 pReq->PgLst.aPages[i] = page_to_phys(pPage);
876# ifdef VBOX_STRICT
877 ASMMemFill32(kmap(pPage), PAGE_SIZE, UINT32_C(0xdeadbeef));
878 kunmap(pPage);
879# endif
880 } else {
881 cbRet = -ENOMEM;
882 break;
883 }
884 }
885 if (cbRet == 0) {
886 /*
887 * Do the reading.
888 */
889 uint32_t const cbToRead = RT_MIN((cPages << PAGE_SHIFT) - (offFile & PAGE_OFFSET_MASK), len);
890 struct vbsf_reg_info *sf_r = (struct vbsf_reg_info *)file->private_data;
891 int vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbToRead, cPages);
892 if (RT_SUCCESS(vrc)) {
893 /*
894 * Get the number of bytes read, jettison the request
895 * and, in case of EOF, any unnecessary pages.
896 */
897 uint32_t cbActual = pReq->Parms.cb32Read.u.value32;
898 AssertStmt(cbActual <= cbToRead, cbActual = cbToRead);
899 SFLOG2(("vbsf_splice_read: read -> %#x bytes @ %#RX64\n", cbActual, offFile));
900
901 VbglR0PhysHeapFree(pReq);
902 pReq = NULL;
903
904 /*
905 * Now, feed it to the pipe thingy.
906 * This will take ownership of the all pages no matter what happens.
907 */
908 cbRet = vbsf_feed_pages_to_pipe(pipe, apPages, cPages, offFile & PAGE_OFFSET_MASK, cbActual, flags);
909 if (cbRet > 0)
910 *poffset = offFile + cbRet;
911 } else {
912 cbRet = -RTErrConvertToErrno(vrc);
913 SFLOGFLOW(("vbsf_splice_read: Read failed: %Rrc -> %zd\n", vrc, cbRet));
914 }
915 i = cPages;
916 }
917
918 while (i-- > 0)
919 if (apPages[i])
920 __free_pages(apPages[i], 0);
921 if (pReq)
922 VbglR0PhysHeapFree(pReq);
923 } else {
924 cbRet = -ENOMEM;
925 }
926 }
927 SFLOGFLOW(("vbsf_splice_read: returns %zd (%#zx), *poffset=%#RX64\n", cbRet, cbRet, *poffset));
928 return cbRet;
929}
930
931#endif /* 2.6.17 <= LINUX_VERSION_CODE < 2.6.31 */
932#if RTLNX_VER_RANGE(2,6,17, 3,16,0)
933
934/**
935 * For splicing from a pipe to a file.
936 *
937 * Since we can combine buffers and request allocations, this should be faster
938 * than the default implementation.
939 */
940static ssize_t vbsf_splice_write(struct pipe_inode_info *pPipe, struct file *file, loff_t *poffset, size_t len, unsigned int flags)
941{
942 struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
943 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
944 ssize_t cbRet;
945
946 SFLOGFLOW(("vbsf_splice_write: pPipe=%p file=%p poffset=%p{%#RX64} len=%#zx flags=%#x\n", pPipe, file, poffset, *poffset, len, flags));
947 /** @todo later if (false) {
948 cbRet = generic_file_splice_write(pPipe, file, poffset, len, flags);
949 } else */ {
950 /*
951 * Prepare a write request.
952 */
953# ifdef PIPE_BUFFERS
954 uint32_t const cMaxPages = RT_MIN(PIPE_BUFFERS, RT_ALIGN_Z(len, PAGE_SIZE) >> PAGE_SHIFT);
955# else
956 uint32_t const cMaxPages = RT_MIN(RT_MAX(RT_MIN(pPipe->buffers, 256), PIPE_DEF_BUFFERS),
957 RT_ALIGN_Z(len, PAGE_SIZE) >> PAGE_SHIFT);
958# endif
959 VBOXSFWRITEPGLSTREQ *pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ,
960 PgLst.aPages[cMaxPages]));
961 if (pReq) {
962 /*
963 * Feed from the pipe.
964 */
965 struct vbsf_reg_info *sf_r = (struct vbsf_reg_info *)file->private_data;
966 struct address_space *mapping = inode->i_mapping;
967 loff_t offFile = *poffset;
968 bool fNeedWakeUp = false;
969 cbRet = 0;
970
971 LOCK_PIPE(pPipe);
972
973 for (;;) {
974 unsigned cBufs = pPipe->nrbufs;
975 /*SFLOG2(("vbsf_splice_write: nrbufs=%#x curbuf=%#x\n", cBufs, pPipe->curbuf));*/
976 if (cBufs) {
977 /*
978 * There is data available. Write it to the file.
979 */
980 int vrc;
981 struct pipe_buffer *pPipeBuf = &pPipe->bufs[pPipe->curbuf];
982 uint32_t cPagesToWrite = 1;
983 uint32_t cbToWrite = pPipeBuf->len;
984
985 Assert(pPipeBuf->offset < PAGE_SIZE);
986 Assert(pPipeBuf->offset + pPipeBuf->len <= PAGE_SIZE);
987
988 pReq->PgLst.offFirstPage = pPipeBuf->offset & PAGE_OFFSET;
989 pReq->PgLst.aPages[0] = page_to_phys(pPipeBuf->page);
990
991 /* Add any adjacent page buffers: */
992 while ( cPagesToWrite < cBufs
993 && cPagesToWrite < cMaxPages
994 && ((pReq->PgLst.offFirstPage + cbToWrite) & PAGE_OFFSET_MASK) == 0) {
995# ifdef PIPE_BUFFERS
996 struct pipe_buffer *pPipeBuf2 = &pPipe->bufs[(pPipe->curbuf + cPagesToWrite) % PIPE_BUFFERS];
997# else
998 struct pipe_buffer *pPipeBuf2 = &pPipe->bufs[(pPipe->curbuf + cPagesToWrite) % pPipe->buffers];
999# endif
1000 Assert(pPipeBuf2->len <= PAGE_SIZE);
1001 Assert(pPipeBuf2->offset < PAGE_SIZE);
1002 if (pPipeBuf2->offset != 0)
1003 break;
1004 pReq->PgLst.aPages[cPagesToWrite] = page_to_phys(pPipeBuf2->page);
1005 cbToWrite += pPipeBuf2->len;
1006 cPagesToWrite += 1;
1007 }
1008
1009 /* Check that we don't have signals pending before we issue the write, as
1010 we'll only end up having to cancel the HGCM request 99% of the time: */
1011 if (!signal_pending(current)) {
1012 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
1013 vrc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile,
1014 cbToWrite, cPagesToWrite);
1015 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
1016 } else
1017 vrc = VERR_INTERRUPTED;
1018 if (RT_SUCCESS(vrc)) {
1019 /*
1020 * Get the number of bytes actually written, update file position
1021 * and return value, and advance the pipe buffer.
1022 */
1023 uint32_t cbActual = pReq->Parms.cb32Write.u.value32;
1024 AssertStmt(cbActual <= cbToWrite, cbActual = cbToWrite);
1025 SFLOG2(("vbsf_splice_write: write -> %#x bytes @ %#RX64\n", cbActual, offFile));
1026
1027 cbRet += cbActual;
1028
1029 while (cbActual > 0) {
1030 uint32_t cbAdvance = RT_MIN(pPipeBuf->len, cbActual);
1031
1032 vbsf_reg_write_sync_page_cache(mapping, offFile, cbAdvance, NULL,
1033 &pPipeBuf->page, pPipeBuf->offset, 1);
1034
1035 offFile += cbAdvance;
1036 cbActual -= cbAdvance;
1037 pPipeBuf->offset += cbAdvance;
1038 pPipeBuf->len -= cbAdvance;
1039
1040 if (!pPipeBuf->len) {
1041 struct pipe_buf_operations const *pOps = pPipeBuf->ops;
1042 pPipeBuf->ops = NULL;
1043 pOps->release(pPipe, pPipeBuf);
1044
1045# ifdef PIPE_BUFFERS
1046 pPipe->curbuf = (pPipe->curbuf + 1) % PIPE_BUFFERS;
1047# else
1048 pPipe->curbuf = (pPipe->curbuf + 1) % pPipe->buffers;
1049# endif
1050 pPipe->nrbufs -= 1;
1051 pPipeBuf = &pPipe->bufs[pPipe->curbuf];
1052
1053# if RTLNX_VER_MAX(2,6,30)
1054 fNeedWakeUp |= pPipe->inode != NULL;
1055# else
1056 fNeedWakeUp = true;
1057# endif
1058 } else {
1059 Assert(cbActual == 0);
1060 break;
1061 }
1062 }
1063
1064 *poffset = offFile;
1065 } else {
1066 if (cbRet == 0)
1067 cbRet = vrc == VERR_INTERRUPTED ? -ERESTARTSYS : -RTErrConvertToErrno(vrc);
1068 SFLOGFLOW(("vbsf_splice_write: Write failed: %Rrc -> %zd (cbRet=%#zx)\n",
1069 vrc, -RTErrConvertToErrno(vrc), cbRet));
1070 break;
1071 }
1072 } else {
1073 /*
1074 * Wait for data to become available, if there is chance that'll happen.
1075 */
1076 /* Quit if there are no writers (think EOF): */
1077 if (pPipe->writers == 0) {
1078 SFLOGFLOW(("vbsf_splice_write: No buffers. No writers. The show is done!\n"));
1079 break;
1080 }
1081
1082 /* Quit if if we've written some and no writers waiting on the lock: */
1083 if (cbRet > 0 && pPipe->waiting_writers == 0) {
1084 SFLOGFLOW(("vbsf_splice_write: No waiting writers, returning what we've got.\n"));
1085 break;
1086 }
1087
1088 /* Quit with EAGAIN if non-blocking: */
1089 if (flags & SPLICE_F_NONBLOCK) {
1090 if (cbRet == 0)
1091 cbRet = -EAGAIN;
1092 break;
1093 }
1094
1095 /* Quit if we've got pending signals: */
1096 if (signal_pending(current)) {
1097 if (cbRet == 0)
1098 cbRet = -ERESTARTSYS;
1099 SFLOGFLOW(("vbsf_splice_write: pending signal! (%zd)\n", cbRet));
1100 break;
1101 }
1102
1103 /* Wake up writers before we start waiting: */
1104 if (fNeedWakeUp) {
1105 vbsf_wake_up_pipe(pPipe, false /*fReaders*/);
1106 fNeedWakeUp = false;
1107 }
1108 vbsf_wait_pipe(pPipe);
1109 }
1110 } /* feed loop */
1111
1112 if (fNeedWakeUp)
1113 vbsf_wake_up_pipe(pPipe, false /*fReaders*/);
1114
1115 UNLOCK_PIPE(pPipe);
1116
1117 VbglR0PhysHeapFree(pReq);
1118 } else {
1119 cbRet = -ENOMEM;
1120 }
1121 }
1122 SFLOGFLOW(("vbsf_splice_write: returns %zd (%#zx), *poffset=%#RX64\n", cbRet, cbRet, *poffset));
1123 return cbRet;
1124}
1125
1126#endif /* 2.6.17 <= LINUX_VERSION_CODE < 3.16.0 */
1127
1128#if RTLNX_VER_RANGE(2,5,30, 2,6,23)
1129/**
1130 * Our own senfile implementation that does not go via the page cache like
1131 * generic_file_sendfile() does.
1132 */
1133static ssize_t vbsf_reg_sendfile(struct file *pFile, loff_t *poffFile, size_t cbToSend, read_actor_t pfnActor,
1134# if RTLNX_VER_MIN(2,6,8)
1135 void *pvUser
1136# else
1137 void __user *pvUser
1138# endif
1139 )
1140{
1141 struct inode *inode = VBSF_GET_F_DENTRY(pFile)->d_inode;
1142 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
1143 ssize_t cbRet;
1144 SFLOGFLOW(("vbsf_reg_sendfile: pFile=%p poffFile=%p{%#RX64} cbToSend=%#zx pfnActor=%p pvUser=%p\n",
1145 pFile, poffFile, poffFile ? *poffFile : 0, cbToSend, pfnActor, pvUser));
1146 Assert(pSuperInfo);
1147
1148 /*
1149 * Return immediately if asked to send nothing.
1150 */
1151 if (cbToSend == 0)
1152 return 0;
1153
1154 /*
1155 * Like for vbsf_reg_read() and vbsf_reg_read_iter(), we allow going via
1156 * the page cache in some cases or configs.
1157 */
1158 if (vbsf_should_use_cached_read(pFile, inode->i_mapping, pSuperInfo)) {
1159 cbRet = generic_file_sendfile(pFile, poffFile, cbToSend, pfnActor, pvUser);
1160 SFLOGFLOW(("vbsf_reg_sendfile: returns %#zx *poffFile=%#RX64 [generic_file_sendfile]\n", cbRet, poffFile ? *poffFile : UINT64_MAX));
1161 } else {
1162 /*
1163 * Allocate a request and a bunch of pages for reading from the file.
1164 */
1165 struct page *apPages[16];
1166 loff_t offFile = poffFile ? *poffFile : 0;
1167 size_t const cPages = cbToSend + ((size_t)offFile & PAGE_OFFSET_MASK) >= RT_ELEMENTS(apPages) * PAGE_SIZE
1168 ? RT_ELEMENTS(apPages)
1169 : RT_ALIGN_Z(cbToSend + ((size_t)offFile & PAGE_OFFSET_MASK), PAGE_SIZE) >> PAGE_SHIFT;
1170 size_t iPage;
1171 VBOXSFREADPGLSTREQ *pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ,
1172 PgLst.aPages[cPages]));
1173 if (pReq) {
1174 Assert(cPages > 0);
1175 cbRet = 0;
1176 for (iPage = 0; iPage < cPages; iPage++) {
1177 struct page *pPage;
1178 apPages[iPage] = pPage = alloc_page(GFP_USER);
1179 if (pPage) {
1180 Assert(page_count(pPage) == 1);
1181 pReq->PgLst.aPages[iPage] = page_to_phys(pPage);
1182 } else {
1183 while (iPage-- > 0)
1184 vbsf_put_page(apPages[iPage]);
1185 cbRet = -ENOMEM;
1186 break;
1187 }
1188 }
1189 if (cbRet == 0) {
1190 /*
1191 * Do the job.
1192 */
1193 struct vbsf_reg_info *sf_r = (struct vbsf_reg_info *)pFile->private_data;
1194 read_descriptor_t RdDesc;
1195 RdDesc.count = cbToSend;
1196# if RTLNX_VER_MIN(2,6,8)
1197 RdDesc.arg.data = pvUser;
1198# else
1199 RdDesc.buf = pvUser;
1200# endif
1201 RdDesc.written = 0;
1202 RdDesc.error = 0;
1203
1204 Assert(sf_r);
1205 Assert((sf_r->Handle.fFlags & VBSF_HANDLE_F_MAGIC_MASK) == VBSF_HANDLE_F_MAGIC);
1206
1207 while (cbToSend > 0) {
1208 /*
1209 * Read another chunk. For paranoid reasons, we keep data where the page cache
1210 * would keep it, i.e. page offset bits corresponds to the file offset bits.
1211 */
1212 uint32_t const offPg0 = (uint32_t)offFile & (uint32_t)PAGE_OFFSET_MASK;
1213 uint32_t const cbToRead = RT_MIN((cPages << PAGE_SHIFT) - offPg0, cbToSend);
1214 uint32_t const cPagesToRead = RT_ALIGN_Z(cbToRead + offPg0, PAGE_SIZE) >> PAGE_SHIFT;
1215 int vrc;
1216 pReq->PgLst.offFirstPage = (uint16_t)offPg0;
1217 if (!signal_pending(current))
1218 vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile,
1219 cbToRead, cPagesToRead);
1220 else
1221 vrc = VERR_INTERRUPTED;
1222 if (RT_SUCCESS(vrc)) {
1223 /*
1224 * Pass what we read to the actor.
1225 */
1226 uint32_t off = offPg0;
1227 uint32_t cbActual = pReq->Parms.cb32Read.u.value32;
1228 bool const fIsEof = cbActual < cbToRead;
1229 AssertStmt(cbActual <= cbToRead, cbActual = cbToRead);
1230 SFLOG3(("vbsf_reg_sendfile: Read %#x bytes (offPg0=%#x), wanted %#x ...\n", cbActual, offPg0, cbToRead));
1231
1232 iPage = 0;
1233 while (cbActual > 0) {
1234 uint32_t const cbPage = RT_MIN(cbActual, PAGE_SIZE - off);
1235 int const cbRetActor = pfnActor(&RdDesc, apPages[iPage], off, cbPage);
1236 Assert(cbRetActor >= 0); /* Returns zero on failure, with RdDesc.error holding the status code. */
1237
1238 AssertMsg(iPage < cPages && iPage < cPagesToRead, ("iPage=%#x cPages=%#x cPagesToRead=%#x\n", iPage, cPages, cPagesToRead));
1239
1240 offFile += cbRetActor;
1241 if ((uint32_t)cbRetActor == cbPage && RdDesc.count > 0) {
1242 cbActual -= cbPage;
1243 cbToSend -= cbPage;
1244 iPage++;
1245 } else {
1246 SFLOG3(("vbsf_reg_sendfile: cbRetActor=%#x (%d) cbPage=%#x RdDesc{count=%#lx error=%d} iPage=%#x/%#x/%#x cbToSend=%#zx\n",
1247 cbRetActor, cbRetActor, cbPage, RdDesc.count, RdDesc.error, iPage, cPagesToRead, cPages, cbToSend));
1248 vrc = VERR_CALLBACK_RETURN;
1249 break;
1250 }
1251 off = 0;
1252 }
1253
1254 /*
1255 * Are we done yet?
1256 */
1257 if (RT_FAILURE_NP(vrc) || cbToSend == 0 || RdDesc.error != 0 || fIsEof) {
1258 break;
1259 }
1260
1261 /*
1262 * Replace pages held by the actor.
1263 */
1264 vrc = VINF_SUCCESS;
1265 for (iPage = 0; iPage < cPages; iPage++) {
1266 struct page *pPage = apPages[iPage];
1267 if (page_count(pPage) != 1) {
1268 struct page *pNewPage = alloc_page(GFP_USER);
1269 if (pNewPage) {
1270 SFLOGFLOW(("vbsf_reg_sendfile: Replacing page #%x: %p -> %p\n", iPage, pPage, pNewPage));
1271 vbsf_put_page(pPage);
1272 apPages[iPage] = pNewPage;
1273 } else {
1274 SFLOGFLOW(("vbsf_reg_sendfile: Failed to allocate a replacement page.\n"));
1275 vrc = VERR_NO_MEMORY;
1276 break;
1277 }
1278 }
1279 }
1280 if (RT_FAILURE(vrc))
1281 break; /* RdDesc.written should be non-zero, so don't bother with setting error. */
1282 } else {
1283 RdDesc.error = vrc == VERR_INTERRUPTED ? -ERESTARTSYS : -RTErrConvertToErrno(vrc);
1284 SFLOGFLOW(("vbsf_reg_sendfile: Read failed: %Rrc -> %zd (RdDesc.error=%#d)\n",
1285 vrc, -RTErrConvertToErrno(vrc), RdDesc.error));
1286 break;
1287 }
1288 }
1289
1290 /*
1291 * Free memory.
1292 */
1293 for (iPage = 0; iPage < cPages; iPage++)
1294 vbsf_put_page(apPages[iPage]);
1295
1296 /*
1297 * Set the return values.
1298 */
1299 if (RdDesc.written) {
1300 cbRet = RdDesc.written;
1301 if (poffFile)
1302 *poffFile = offFile;
1303 } else {
1304 cbRet = RdDesc.error;
1305 }
1306 }
1307 VbglR0PhysHeapFree(pReq);
1308 } else {
1309 cbRet = -ENOMEM;
1310 }
1311 SFLOGFLOW(("vbsf_reg_sendfile: returns %#zx offFile=%#RX64\n", cbRet, offFile));
1312 }
1313 return cbRet;
1314}
1315#endif /* 2.5.30 <= LINUX_VERSION_CODE < 2.6.23 */
1316
1317
1318/*********************************************************************************************************************************
1319* File operations on regular files *
1320*********************************************************************************************************************************/
1321
1322/** Wrapper around put_page / page_cache_release. */
1323DECLINLINE(void) vbsf_put_page(struct page *pPage)
1324{
1325#if RTLNX_VER_MIN(4,6,0)
1326 put_page(pPage);
1327#else
1328 page_cache_release(pPage);
1329#endif
1330}
1331
1332
1333/** Wrapper around get_page / page_cache_get. */
1334DECLINLINE(void) vbsf_get_page(struct page *pPage)
1335{
1336#if RTLNX_VER_MIN(4,6,0)
1337 get_page(pPage);
1338#else
1339 page_cache_get(pPage);
1340#endif
1341}
1342
1343
1344/** Companion to vbsf_lock_user_pages(). */
1345static void vbsf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty, bool fLockPgHack)
1346{
1347 /* We don't mark kernel pages dirty: */
1348 if (fLockPgHack)
1349 fSetDirty = false;
1350
1351 while (cPages-- > 0)
1352 {
1353 struct page *pPage = papPages[cPages];
1354 Assert((ssize_t)cPages >= 0);
1355 if (fSetDirty && !PageReserved(pPage))
1356 set_page_dirty(pPage);
1357 vbsf_put_page(pPage);
1358 }
1359}
1360
1361
1362/**
1363 * Worker for vbsf_lock_user_pages_failed_check_kernel() and
1364 * vbsf_iter_lock_pages().
1365 */
1366static int vbsf_lock_kernel_pages(uint8_t *pbStart, bool fWrite, size_t cPages, struct page **papPages)
1367{
1368 uintptr_t const uPtrFrom = (uintptr_t)pbStart;
1369 uintptr_t const uPtrLast = (uPtrFrom & ~(uintptr_t)PAGE_OFFSET_MASK) + (cPages << PAGE_SHIFT) - 1;
1370 uint8_t *pbPage = (uint8_t *)uPtrLast;
1371 size_t iPage = cPages;
1372
1373 /*
1374 * Touch the pages first (paranoia^2).
1375 */
1376 if (fWrite) {
1377 uint8_t volatile *pbProbe = (uint8_t volatile *)uPtrFrom;
1378 while (iPage-- > 0) {
1379 *pbProbe = *pbProbe;
1380 pbProbe += PAGE_SIZE;
1381 }
1382 } else {
1383 uint8_t const *pbProbe = (uint8_t const *)uPtrFrom;
1384 while (iPage-- > 0) {
1385 ASMProbeReadByte(pbProbe);
1386 pbProbe += PAGE_SIZE;
1387 }
1388 }
1389
1390 /*
1391 * Get the pages.
1392 * Note! Fixes here probably applies to rtR0MemObjNativeLockKernel as well.
1393 */
1394 iPage = cPages;
1395 if ( uPtrFrom >= (unsigned long)__va(0)
1396 && uPtrLast < (unsigned long)high_memory) {
1397 /* The physical page mapping area: */
1398 while (iPage-- > 0) {
1399 struct page *pPage = papPages[iPage] = virt_to_page(pbPage);
1400 vbsf_get_page(pPage);
1401 pbPage -= PAGE_SIZE;
1402 }
1403 } else {
1404 /* This is vmalloc or some such thing, so go thru page tables: */
1405 while (iPage-- > 0) {
1406 struct page *pPage = rtR0MemObjLinuxVirtToPage(pbPage);
1407 if (pPage) {
1408 papPages[iPage] = pPage;
1409 vbsf_get_page(pPage);
1410 pbPage -= PAGE_SIZE;
1411 } else {
1412 while (++iPage < cPages) {
1413 pPage = papPages[iPage];
1414 vbsf_put_page(pPage);
1415 }
1416 return -EFAULT;
1417 }
1418 }
1419 }
1420 return 0;
1421}
1422
1423
1424/**
1425 * Catches kernel_read() and kernel_write() calls and works around them.
1426 *
1427 * The file_operations::read and file_operations::write callbacks supposedly
1428 * hands us the user buffers to read into and write out of. To allow the kernel
1429 * to read and write without allocating buffers in userland, they kernel_read()
1430 * and kernel_write() increases the user space address limit before calling us
1431 * so that copyin/copyout won't reject it. Our problem is that get_user_pages()
1432 * works on the userspace address space structures and will not be fooled by an
1433 * increased addr_limit.
1434 *
1435 * This code tries to detect this situation and fake get_user_lock() for the
1436 * kernel buffer.
1437 */
1438static int vbsf_lock_user_pages_failed_check_kernel(uintptr_t uPtrFrom, size_t cPages, bool fWrite, int rcFailed,
1439 struct page **papPages, bool *pfLockPgHack)
1440{
1441 /*
1442 * Check that this is valid user memory that is actually in the kernel range.
1443 */
1444#if RTLNX_VER_MIN(5,10,0)
1445 if ( access_ok((void *)uPtrFrom, cPages << PAGE_SHIFT)
1446 && uPtrFrom >= TASK_SIZE_MAX)
1447#elif RTLNX_VER_MIN(5,0,0) || RTLNX_RHEL_MIN(8,1)
1448 if ( access_ok((void *)uPtrFrom, cPages << PAGE_SHIFT)
1449 && uPtrFrom >= USER_DS.seg)
1450#else
1451 if ( access_ok(fWrite ? VERIFY_WRITE : VERIFY_READ, (void *)uPtrFrom, cPages << PAGE_SHIFT)
1452 && uPtrFrom >= USER_DS.seg)
1453#endif
1454 {
1455 int rc = vbsf_lock_kernel_pages((uint8_t *)uPtrFrom, fWrite, cPages, papPages);
1456 if (rc == 0) {
1457 *pfLockPgHack = true;
1458 return 0;
1459 }
1460 }
1461
1462 return rcFailed;
1463}
1464
1465
1466/** Wrapper around get_user_pages. */
1467DECLINLINE(int) vbsf_lock_user_pages(uintptr_t uPtrFrom, size_t cPages, bool fWrite, struct page **papPages, bool *pfLockPgHack)
1468{
1469# if RTLNX_VER_MIN(4,9,0) \
1470 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,73, 4,4,74) /** @todo Figure out when & what exactly. */) \
1471 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,75, 4,4,90) /** @todo Figure out when & what exactly. */) \
1472 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,92, 4,5,0) /** @todo Figure out when & what exactly. */)
1473 ssize_t cPagesLocked = get_user_pages_unlocked(uPtrFrom, cPages, papPages,
1474 fWrite ? FOLL_WRITE | FOLL_FORCE : FOLL_FORCE);
1475# elif RTLNX_VER_MIN(4,6,0)
1476 ssize_t cPagesLocked = get_user_pages_unlocked(uPtrFrom, cPages, fWrite, 1 /*force*/, papPages);
1477# elif RTLNX_VER_RANGE(4,4,168, 4,5,0)
1478 ssize_t cPagesLocked = get_user_pages_unlocked(current, current->mm, uPtrFrom, cPages, papPages,
1479 fWrite ? FOLL_WRITE | FOLL_FORCE : FOLL_FORCE);
1480# elif RTLNX_VER_MIN(4,0,0)
1481 ssize_t cPagesLocked = get_user_pages_unlocked(current, current->mm, uPtrFrom, cPages, fWrite, 1 /*force*/, papPages);
1482# else
1483 struct task_struct *pTask = current;
1484 ssize_t cPagesLocked;
1485 down_read(&pTask->mm->mmap_sem);
1486 cPagesLocked = get_user_pages(pTask, pTask->mm, uPtrFrom, cPages, fWrite, 1 /*force*/, papPages, NULL);
1487 up_read(&pTask->mm->mmap_sem);
1488# endif
1489 *pfLockPgHack = false;
1490 if (cPagesLocked == cPages)
1491 return 0;
1492
1493 /*
1494 * It failed.
1495 */
1496 if (cPagesLocked < 0)
1497 return vbsf_lock_user_pages_failed_check_kernel(uPtrFrom, cPages, fWrite, (int)cPagesLocked, papPages, pfLockPgHack);
1498
1499 vbsf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/, false /*fLockPgHack*/);
1500
1501 /* We could use uPtrFrom + cPagesLocked to get the correct status here... */
1502 return -EFAULT;
1503}
1504
1505#if RTLNX_VER_MAX(5,10,0) /* No regular .read/.write for 5.10, only .read_iter/.write_iter or in-kernel reads/writes fail. */
1506
1507/**
1508 * Read function used when accessing files that are memory mapped.
1509 *
1510 * We read from the page cache here to present the a cohertent picture of the
1511 * the file content.
1512 */
1513static ssize_t vbsf_reg_read_mapped(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
1514{
1515# if RTLNX_VER_MIN(3,16,0)
1516 struct iovec iov = { .iov_base = buf, .iov_len = size };
1517 struct iov_iter iter;
1518 struct kiocb kiocb;
1519 ssize_t cbRet;
1520
1521 init_sync_kiocb(&kiocb, file);
1522 kiocb.ki_pos = *off;
1523 iov_iter_init(&iter, READ, &iov, 1, size);
1524
1525 cbRet = generic_file_read_iter(&kiocb, &iter);
1526
1527 *off = kiocb.ki_pos;
1528 return cbRet;
1529
1530# elif RTLNX_VER_MIN(2,6,19)
1531 struct iovec iov = { .iov_base = buf, .iov_len = size };
1532 struct kiocb kiocb;
1533 ssize_t cbRet;
1534
1535 init_sync_kiocb(&kiocb, file);
1536 kiocb.ki_pos = *off;
1537
1538 cbRet = generic_file_aio_read(&kiocb, &iov, 1, *off);
1539 if (cbRet == -EIOCBQUEUED)
1540 cbRet = wait_on_sync_kiocb(&kiocb);
1541
1542 *off = kiocb.ki_pos;
1543 return cbRet;
1544
1545# else /* 2.6.18 or earlier: */
1546 return generic_file_read(file, buf, size, off);
1547# endif
1548}
1549
1550
1551/**
1552 * Fallback case of vbsf_reg_read() that locks the user buffers and let the host
1553 * write directly to them.
1554 */
1555static ssize_t vbsf_reg_read_locking(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off,
1556 struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
1557{
1558 /*
1559 * Lock pages and execute the read, taking care not to pass the host
1560 * more than it can handle in one go or more than we care to allocate
1561 * page arrays for. The latter limit is set at just short of 32KB due
1562 * to how the physical heap works.
1563 */
1564 struct page *apPagesStack[16];
1565 struct page **papPages = &apPagesStack[0];
1566 struct page **papPagesFree = NULL;
1567 VBOXSFREADPGLSTREQ *pReq;
1568 loff_t offFile = *off;
1569 ssize_t cbRet = -ENOMEM;
1570 size_t cPages = (((uintptr_t)buf & PAGE_OFFSET_MASK) + size + PAGE_OFFSET_MASK) >> PAGE_SHIFT;
1571 size_t cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 1), cPages);
1572 bool fLockPgHack;
1573
1574 pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
1575 while (!pReq && cMaxPages > 4) {
1576 cMaxPages /= 2;
1577 pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
1578 }
1579 if (pReq && cMaxPages > RT_ELEMENTS(apPagesStack))
1580 papPagesFree = papPages = kmalloc(cMaxPages * sizeof(sizeof(papPages[0])), GFP_KERNEL);
1581 if (pReq && papPages) {
1582 cbRet = 0;
1583 for (;;) {
1584 /*
1585 * Figure out how much to process now and lock the user pages.
1586 */
1587 int rc;
1588 size_t cbChunk = (uintptr_t)buf & PAGE_OFFSET_MASK;
1589 pReq->PgLst.offFirstPage = (uint16_t)cbChunk;
1590 cPages = RT_ALIGN_Z(cbChunk + size, PAGE_SIZE) >> PAGE_SHIFT;
1591 if (cPages <= cMaxPages)
1592 cbChunk = size;
1593 else {
1594 cPages = cMaxPages;
1595 cbChunk = (cMaxPages << PAGE_SHIFT) - cbChunk;
1596 }
1597
1598 rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, true /*fWrite*/, papPages, &fLockPgHack);
1599 if (rc == 0) {
1600 size_t iPage = cPages;
1601 while (iPage-- > 0)
1602 pReq->PgLst.aPages[iPage] = page_to_phys(papPages[iPage]);
1603 } else {
1604 cbRet = rc;
1605 break;
1606 }
1607
1608 /*
1609 * Issue the request and unlock the pages.
1610 */
1611 rc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
1612
1613 Assert(cPages <= cMaxPages);
1614 vbsf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/, fLockPgHack);
1615
1616 if (RT_SUCCESS(rc)) {
1617 /*
1618 * Success, advance position and buffer.
1619 */
1620 uint32_t cbActual = pReq->Parms.cb32Read.u.value32;
1621 AssertStmt(cbActual <= cbChunk, cbActual = cbChunk);
1622 cbRet += cbActual;
1623 offFile += cbActual;
1624 buf = (uint8_t *)buf + cbActual;
1625 size -= cbActual;
1626
1627 /*
1628 * Are we done already? If so commit the new file offset.
1629 */
1630 if (!size || cbActual < cbChunk) {
1631 *off = offFile;
1632 break;
1633 }
1634 } else if (rc == VERR_NO_MEMORY && cMaxPages > 4) {
1635 /*
1636 * The host probably doesn't have enough heap to handle the
1637 * request, reduce the page count and retry.
1638 */
1639 cMaxPages /= 4;
1640 Assert(cMaxPages > 0);
1641 } else {
1642 /*
1643 * If we've successfully read stuff, return it rather than
1644 * the error. (Not sure if this is such a great idea...)
1645 */
1646 if (cbRet > 0) {
1647 SFLOGFLOW(("vbsf_reg_read: read at %#RX64 -> %Rrc; got cbRet=%#zx already\n", offFile, rc, cbRet));
1648 *off = offFile;
1649 } else {
1650 SFLOGFLOW(("vbsf_reg_read: read at %#RX64 -> %Rrc\n", offFile, rc));
1651 cbRet = -EPROTO;
1652 }
1653 break;
1654 }
1655 }
1656 }
1657 if (papPagesFree)
1658 kfree(papPages);
1659 if (pReq)
1660 VbglR0PhysHeapFree(pReq);
1661 SFLOGFLOW(("vbsf_reg_read: returns %zd (%#zx), *off=%RX64 [lock]\n", cbRet, cbRet, *off));
1662 return cbRet;
1663}
1664
1665
1666/**
1667 * Read from a regular file.
1668 *
1669 * @param file the file
1670 * @param buf the buffer
1671 * @param size length of the buffer
1672 * @param off offset within the file (in/out).
1673 * @returns the number of read bytes on success, Linux error code otherwise
1674 */
1675static ssize_t vbsf_reg_read(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
1676{
1677 struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
1678 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
1679 struct vbsf_reg_info *sf_r = file->private_data;
1680 struct address_space *mapping = inode->i_mapping;
1681
1682 SFLOGFLOW(("vbsf_reg_read: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
1683
1684 if (!S_ISREG(inode->i_mode)) {
1685 LogFunc(("read from non regular file %d\n", inode->i_mode));
1686 return -EINVAL;
1687 }
1688
1689 /** @todo XXX Check read permission according to inode->i_mode! */
1690
1691 if (!size)
1692 return 0;
1693
1694 /*
1695 * If there is a mapping and O_DIRECT isn't in effect, we must at a
1696 * heed dirty pages in the mapping and read from them. For simplicity
1697 * though, we just do page cache reading when there are writable
1698 * mappings around with any kind of pages loaded.
1699 */
1700 if (vbsf_should_use_cached_read(file, mapping, pSuperInfo))
1701 return vbsf_reg_read_mapped(file, buf, size, off);
1702
1703 /*
1704 * For small requests, try use an embedded buffer provided we get a heap block
1705 * that does not cross page boundraries (see host code).
1706 */
1707 if (size <= PAGE_SIZE / 4 * 3 - RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) /* see allocator */) {
1708 uint32_t const cbReq = RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) + size;
1709 VBOXSFREADEMBEDDEDREQ *pReq = (VBOXSFREADEMBEDDEDREQ *)VbglR0PhysHeapAlloc(cbReq);
1710 if (pReq) {
1711 if ((PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
1712 ssize_t cbRet;
1713 int vrc = VbglR0SfHostReqReadEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, *off, (uint32_t)size);
1714 if (RT_SUCCESS(vrc)) {
1715 cbRet = pReq->Parms.cb32Read.u.value32;
1716 AssertStmt(cbRet <= (ssize_t)size, cbRet = size);
1717 if (copy_to_user(buf, pReq->abData, cbRet) == 0)
1718 *off += cbRet;
1719 else
1720 cbRet = -EFAULT;
1721 } else
1722 cbRet = -EPROTO;
1723 VbglR0PhysHeapFree(pReq);
1724 SFLOGFLOW(("vbsf_reg_read: returns %zd (%#zx), *off=%RX64 [embed]\n", cbRet, cbRet, *off));
1725 return cbRet;
1726 }
1727 VbglR0PhysHeapFree(pReq);
1728 }
1729 }
1730
1731# if 0 /* Turns out this is slightly slower than locking the pages even for 4KB reads (4.19/amd64). */
1732 /*
1733 * For medium sized requests try use a bounce buffer.
1734 */
1735 if (size <= _64K /** @todo make this configurable? */) {
1736 void *pvBounce = kmalloc(size, GFP_KERNEL);
1737 if (pvBounce) {
1738 VBOXSFREADPGLSTREQ *pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
1739 if (pReq) {
1740 ssize_t cbRet;
1741 int vrc = VbglR0SfHostReqReadContig(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, *off,
1742 (uint32_t)size, pvBounce, virt_to_phys(pvBounce));
1743 if (RT_SUCCESS(vrc)) {
1744 cbRet = pReq->Parms.cb32Read.u.value32;
1745 AssertStmt(cbRet <= (ssize_t)size, cbRet = size);
1746 if (copy_to_user(buf, pvBounce, cbRet) == 0)
1747 *off += cbRet;
1748 else
1749 cbRet = -EFAULT;
1750 } else
1751 cbRet = -EPROTO;
1752 VbglR0PhysHeapFree(pReq);
1753 kfree(pvBounce);
1754 SFLOGFLOW(("vbsf_reg_read: returns %zd (%#zx), *off=%RX64 [bounce]\n", cbRet, cbRet, *off));
1755 return cbRet;
1756 }
1757 kfree(pvBounce);
1758 }
1759 }
1760# endif
1761
1762 return vbsf_reg_read_locking(file, buf, size, off, pSuperInfo, sf_r);
1763}
1764
1765#endif /* < 5.10.0 */
1766
1767/**
1768 * Helper the synchronizes the page cache content with something we just wrote
1769 * to the host.
1770 */
1771static void vbsf_reg_write_sync_page_cache(struct address_space *mapping, loff_t offFile, uint32_t cbRange,
1772 uint8_t const *pbSrcBuf, struct page **papSrcPages,
1773 uint32_t offSrcPage, size_t cSrcPages)
1774{
1775 Assert(offSrcPage < PAGE_SIZE);
1776 if (mapping && mapping->nrpages > 0) {
1777 /*
1778 * Work the pages in the write range.
1779 */
1780 while (cbRange > 0) {
1781 /*
1782 * Lookup the page at offFile. We're fine if there aren't
1783 * any there. We're skip if it's dirty or is being written
1784 * back, at least for now.
1785 */
1786 size_t const offDstPage = offFile & PAGE_OFFSET_MASK;
1787 size_t const cbToCopy = RT_MIN(PAGE_SIZE - offDstPage, cbRange);
1788 pgoff_t const idxPage = offFile >> PAGE_SHIFT;
1789 struct page *pDstPage = find_lock_page(mapping, idxPage);
1790 if (pDstPage) {
1791 if ( pDstPage->mapping == mapping /* ignore if re-purposed (paranoia) */
1792 && pDstPage->index == idxPage
1793 && !PageDirty(pDstPage) /* ignore if dirty */
1794 && !PageWriteback(pDstPage) /* ignore if being written back */ ) {
1795 /*
1796 * Map the page and do the copying.
1797 */
1798 uint8_t *pbDst = (uint8_t *)kmap(pDstPage);
1799 if (pbSrcBuf)
1800 memcpy(&pbDst[offDstPage], pbSrcBuf, cbToCopy);
1801 else {
1802 uint32_t const cbSrc0 = PAGE_SIZE - offSrcPage;
1803 uint8_t const *pbSrc = (uint8_t const *)kmap(papSrcPages[0]);
1804 AssertMsg(cSrcPages >= 1, ("offFile=%#llx cbRange=%#zx cbToCopy=%#zx\n", offFile, cbRange, cbToCopy));
1805 memcpy(&pbDst[offDstPage], &pbSrc[offSrcPage], RT_MIN(cbToCopy, cbSrc0));
1806 kunmap(papSrcPages[0]);
1807 if (cbToCopy > cbSrc0) {
1808 AssertMsg(cSrcPages >= 2, ("offFile=%#llx cbRange=%#zx cbToCopy=%#zx\n", offFile, cbRange, cbToCopy));
1809 pbSrc = (uint8_t const *)kmap(papSrcPages[1]);
1810 memcpy(&pbDst[offDstPage + cbSrc0], pbSrc, cbToCopy - cbSrc0);
1811 kunmap(papSrcPages[1]);
1812 }
1813 }
1814 kunmap(pDstPage);
1815 flush_dcache_page(pDstPage);
1816 if (cbToCopy == PAGE_SIZE)
1817 SetPageUptodate(pDstPage);
1818# if RTLNX_VER_MIN(2,4,10)
1819 mark_page_accessed(pDstPage);
1820# endif
1821 } else
1822 SFLOGFLOW(("vbsf_reg_write_sync_page_cache: Skipping page %p: mapping=%p (vs %p) writeback=%d offset=%#lx (vs%#lx)\n",
1823 pDstPage, pDstPage->mapping, mapping, PageWriteback(pDstPage), pDstPage->index, idxPage));
1824 unlock_page(pDstPage);
1825 vbsf_put_page(pDstPage);
1826 }
1827
1828 /*
1829 * Advance.
1830 */
1831 if (pbSrcBuf)
1832 pbSrcBuf += cbToCopy;
1833 else
1834 {
1835 offSrcPage += cbToCopy;
1836 Assert(offSrcPage < PAGE_SIZE * 2);
1837 if (offSrcPage >= PAGE_SIZE) {
1838 offSrcPage &= PAGE_OFFSET_MASK;
1839 papSrcPages++;
1840# ifdef VBOX_STRICT
1841 Assert(cSrcPages > 0);
1842 cSrcPages--;
1843# endif
1844 }
1845 }
1846 offFile += cbToCopy;
1847 cbRange -= cbToCopy;
1848 }
1849 }
1850 RT_NOREF(cSrcPages);
1851}
1852
1853#if RTLNX_VER_MAX(5,10,0) /* No regular .read/.write for 5.10, only .read_iter/.write_iter or in-kernel reads/writes fail. */
1854
1855/**
1856 * Fallback case of vbsf_reg_write() that locks the user buffers and let the host
1857 * write directly to them.
1858 */
1859static ssize_t vbsf_reg_write_locking(struct file *file, const char /*__user*/ *buf, size_t size, loff_t *off, loff_t offFile,
1860 struct inode *inode, struct vbsf_inode_info *sf_i,
1861 struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
1862{
1863 /*
1864 * Lock pages and execute the write, taking care not to pass the host
1865 * more than it can handle in one go or more than we care to allocate
1866 * page arrays for. The latter limit is set at just short of 32KB due
1867 * to how the physical heap works.
1868 */
1869 struct page *apPagesStack[16];
1870 struct page **papPages = &apPagesStack[0];
1871 struct page **papPagesFree = NULL;
1872 VBOXSFWRITEPGLSTREQ *pReq;
1873 ssize_t cbRet = -ENOMEM;
1874 size_t cPages = (((uintptr_t)buf & PAGE_OFFSET_MASK) + size + PAGE_OFFSET_MASK) >> PAGE_SHIFT;
1875 size_t cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 1), cPages);
1876 bool fLockPgHack;
1877
1878 pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
1879 while (!pReq && cMaxPages > 4) {
1880 cMaxPages /= 2;
1881 pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
1882 }
1883 if (pReq && cMaxPages > RT_ELEMENTS(apPagesStack))
1884 papPagesFree = papPages = kmalloc(cMaxPages * sizeof(sizeof(papPages[0])), GFP_KERNEL);
1885 if (pReq && papPages) {
1886 cbRet = 0;
1887 for (;;) {
1888 /*
1889 * Figure out how much to process now and lock the user pages.
1890 */
1891 int rc;
1892 size_t cbChunk = (uintptr_t)buf & PAGE_OFFSET_MASK;
1893 pReq->PgLst.offFirstPage = (uint16_t)cbChunk;
1894 cPages = RT_ALIGN_Z(cbChunk + size, PAGE_SIZE) >> PAGE_SHIFT;
1895 if (cPages <= cMaxPages)
1896 cbChunk = size;
1897 else {
1898 cPages = cMaxPages;
1899 cbChunk = (cMaxPages << PAGE_SHIFT) - cbChunk;
1900 }
1901
1902 rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, false /*fWrite*/, papPages, &fLockPgHack);
1903 if (rc == 0) {
1904 size_t iPage = cPages;
1905 while (iPage-- > 0)
1906 pReq->PgLst.aPages[iPage] = page_to_phys(papPages[iPage]);
1907 } else {
1908 cbRet = rc;
1909 break;
1910 }
1911
1912 /*
1913 * Issue the request and unlock the pages.
1914 */
1915 rc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
1916 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
1917 if (RT_SUCCESS(rc)) {
1918 /*
1919 * Success, advance position and buffer.
1920 */
1921 uint32_t cbActual = pReq->Parms.cb32Write.u.value32;
1922 AssertStmt(cbActual <= cbChunk, cbActual = cbChunk);
1923
1924 vbsf_reg_write_sync_page_cache(inode->i_mapping, offFile, cbActual, NULL /*pbKrnlBuf*/,
1925 papPages, (uintptr_t)buf & PAGE_OFFSET_MASK, cPages);
1926 Assert(cPages <= cMaxPages);
1927 vbsf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/, fLockPgHack);
1928
1929 cbRet += cbActual;
1930 buf = (uint8_t *)buf + cbActual;
1931 size -= cbActual;
1932
1933 offFile += cbActual;
1934 if ((file->f_flags & O_APPEND) && (g_fSfFeatures & SHFL_FEATURE_WRITE_UPDATES_OFFSET))
1935 offFile = pReq->Parms.off64Write.u.value64;
1936 if (offFile > i_size_read(inode))
1937 i_size_write(inode, offFile);
1938
1939 sf_i->force_restat = 1; /* mtime (and size) may have changed */
1940
1941 /*
1942 * Are we done already? If so commit the new file offset.
1943 */
1944 if (!size || cbActual < cbChunk) {
1945 *off = offFile;
1946 break;
1947 }
1948 } else {
1949 vbsf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/, fLockPgHack);
1950 if (rc == VERR_NO_MEMORY && cMaxPages > 4) {
1951 /*
1952 * The host probably doesn't have enough heap to handle the
1953 * request, reduce the page count and retry.
1954 */
1955 cMaxPages /= 4;
1956 Assert(cMaxPages > 0);
1957 } else {
1958 /*
1959 * If we've successfully written stuff, return it rather than
1960 * the error. (Not sure if this is such a great idea...)
1961 */
1962 if (cbRet > 0) {
1963 SFLOGFLOW(("vbsf_reg_write: write at %#RX64 -> %Rrc; got cbRet=%#zx already\n", offFile, rc, cbRet));
1964 *off = offFile;
1965 } else {
1966 SFLOGFLOW(("vbsf_reg_write: write at %#RX64 -> %Rrc\n", offFile, rc));
1967 cbRet = -EPROTO;
1968 }
1969 break;
1970 }
1971 }
1972 }
1973 }
1974 if (papPagesFree)
1975 kfree(papPages);
1976 if (pReq)
1977 VbglR0PhysHeapFree(pReq);
1978 SFLOGFLOW(("vbsf_reg_write: returns %zd (%#zx), *off=%RX64 [lock]\n", cbRet, cbRet, *off));
1979 return cbRet;
1980}
1981
1982
1983/**
1984 * Write to a regular file.
1985 *
1986 * @param file the file
1987 * @param buf the buffer
1988 * @param size length of the buffer
1989 * @param off offset within the file
1990 * @returns the number of written bytes on success, Linux error code otherwise
1991 */
1992static ssize_t vbsf_reg_write(struct file *file, const char *buf, size_t size, loff_t * off)
1993{
1994 struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
1995 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
1996 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
1997 struct vbsf_reg_info *sf_r = file->private_data;
1998 struct address_space *mapping = inode->i_mapping;
1999 loff_t pos;
2000
2001 SFLOGFLOW(("vbsf_reg_write: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
2002 Assert(sf_i);
2003 Assert(pSuperInfo);
2004 Assert(sf_r);
2005 AssertReturn(S_ISREG(inode->i_mode), -EINVAL);
2006
2007 pos = *off;
2008 if (file->f_flags & O_APPEND)
2009 pos = i_size_read(inode);
2010
2011 /** @todo XXX Check write permission according to inode->i_mode! */
2012
2013 if (!size) {
2014 if (file->f_flags & O_APPEND) /** @todo check if this is the consensus behavior... */
2015 *off = pos;
2016 return 0;
2017 }
2018
2019 /** @todo Implement the read-write caching mode. */
2020
2021 /*
2022 * If there are active writable mappings, coordinate with any
2023 * pending writes via those.
2024 */
2025 if ( mapping
2026 && mapping->nrpages > 0
2027 && mapping_writably_mapped(mapping)) {
2028# if RTLNX_VER_MIN(2,6,32)
2029 int err = filemap_fdatawait_range(mapping, pos, pos + size - 1);
2030 if (err)
2031 return err;
2032# else
2033 /** @todo ... */
2034# endif
2035 }
2036
2037 /*
2038 * For small requests, try use an embedded buffer provided we get a heap block
2039 * that does not cross page boundraries (see host code).
2040 */
2041 if (size <= PAGE_SIZE / 4 * 3 - RT_UOFFSETOF(VBOXSFWRITEEMBEDDEDREQ, abData[0]) /* see allocator */) {
2042 uint32_t const cbReq = RT_UOFFSETOF(VBOXSFWRITEEMBEDDEDREQ, abData[0]) + size;
2043 VBOXSFWRITEEMBEDDEDREQ *pReq = (VBOXSFWRITEEMBEDDEDREQ *)VbglR0PhysHeapAlloc(cbReq);
2044 if ( pReq
2045 && (PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
2046 ssize_t cbRet;
2047 if (copy_from_user(pReq->abData, buf, size) == 0) {
2048 int vrc = VbglR0SfHostReqWriteEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
2049 pos, (uint32_t)size);
2050 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
2051 if (RT_SUCCESS(vrc)) {
2052 cbRet = pReq->Parms.cb32Write.u.value32;
2053 AssertStmt(cbRet <= (ssize_t)size, cbRet = size);
2054 vbsf_reg_write_sync_page_cache(mapping, pos, (uint32_t)cbRet, pReq->abData,
2055 NULL /*papSrcPages*/, 0 /*offSrcPage0*/, 0 /*cSrcPages*/);
2056 pos += cbRet;
2057 if ((file->f_flags & O_APPEND) && (g_fSfFeatures & SHFL_FEATURE_WRITE_UPDATES_OFFSET))
2058 pos = pReq->Parms.off64Write.u.value64;
2059 *off = pos;
2060 if (pos > i_size_read(inode))
2061 i_size_write(inode, pos);
2062 } else
2063 cbRet = -EPROTO;
2064 sf_i->force_restat = 1; /* mtime (and size) may have changed */
2065 } else
2066 cbRet = -EFAULT;
2067
2068 VbglR0PhysHeapFree(pReq);
2069 SFLOGFLOW(("vbsf_reg_write: returns %zd (%#zx), *off=%RX64 [embed]\n", cbRet, cbRet, *off));
2070 return cbRet;
2071 }
2072 if (pReq)
2073 VbglR0PhysHeapFree(pReq);
2074 }
2075
2076# if 0 /* Turns out this is slightly slower than locking the pages even for 4KB reads (4.19/amd64). */
2077 /*
2078 * For medium sized requests try use a bounce buffer.
2079 */
2080 if (size <= _64K /** @todo make this configurable? */) {
2081 void *pvBounce = kmalloc(size, GFP_KERNEL);
2082 if (pvBounce) {
2083 if (copy_from_user(pvBounce, buf, size) == 0) {
2084 VBOXSFWRITEPGLSTREQ *pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
2085 if (pReq) {
2086 ssize_t cbRet;
2087 int vrc = VbglR0SfHostReqWriteContig(pSuperInfo->map.root, pReq, sf_r->handle, pos,
2088 (uint32_t)size, pvBounce, virt_to_phys(pvBounce));
2089 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
2090 if (RT_SUCCESS(vrc)) {
2091 cbRet = pReq->Parms.cb32Write.u.value32;
2092 AssertStmt(cbRet <= (ssize_t)size, cbRet = size);
2093 vbsf_reg_write_sync_page_cache(mapping, pos, (uint32_t)cbRet, (uint8_t const *)pvBounce,
2094 NULL /*papSrcPages*/, 0 /*offSrcPage0*/, 0 /*cSrcPages*/);
2095 pos += cbRet;
2096 *off = pos;
2097 if (pos > i_size_read(inode))
2098 i_size_write(inode, pos);
2099 } else
2100 cbRet = -EPROTO;
2101 sf_i->force_restat = 1; /* mtime (and size) may have changed */
2102 VbglR0PhysHeapFree(pReq);
2103 kfree(pvBounce);
2104 SFLOGFLOW(("vbsf_reg_write: returns %zd (%#zx), *off=%RX64 [bounce]\n", cbRet, cbRet, *off));
2105 return cbRet;
2106 }
2107 kfree(pvBounce);
2108 } else {
2109 kfree(pvBounce);
2110 SFLOGFLOW(("vbsf_reg_write: returns -EFAULT, *off=%RX64 [bounce]\n", *off));
2111 return -EFAULT;
2112 }
2113 }
2114 }
2115# endif
2116
2117 return vbsf_reg_write_locking(file, buf, size, off, pos, inode, sf_i, pSuperInfo, sf_r);
2118}
2119
2120#endif /* < 5.10.0 */
2121#if RTLNX_VER_MIN(2,6,19)
2122/* See kernel 6.0.0 change eba2d3d798295dc43cae8fade102f9d083a2a741. */
2123# if RTLNX_VER_MIN(6,0,0) || RTLNX_RHEL_RANGE(9,4, 9,99)
2124# define VBOX_IOV_GET_PAGES iov_iter_get_pages2
2125# else
2126# define VBOX_IOV_GET_PAGES iov_iter_get_pages
2127# endif
2128
2129/**
2130 * Companion to vbsf_iter_lock_pages().
2131 */
2132DECLINLINE(void) vbsf_iter_unlock_pages(struct iov_iter *iter, struct page **papPages, size_t cPages, bool fSetDirty)
2133{
2134 /* We don't mark kernel pages dirty (KVECs, BVECs, PIPEs): */
2135 if (!iter_is_iovec(iter))
2136 fSetDirty = false;
2137
2138 while (cPages-- > 0)
2139 {
2140 struct page *pPage = papPages[cPages];
2141 if (fSetDirty && !PageReserved(pPage))
2142 set_page_dirty(pPage);
2143 vbsf_put_page(pPage);
2144 }
2145}
2146
2147
2148/**
2149 * Locks up to @a cMaxPages from the I/O vector iterator, advancing the
2150 * iterator.
2151 *
2152 * @returns 0 on success, negative errno value on failure.
2153 * @param iter The iterator to lock pages from.
2154 * @param fWrite Whether to write (true) or read (false) lock the pages.
2155 * @param pStash Where we stash peek results.
2156 * @param cMaxPages The maximum number of pages to get.
2157 * @param papPages Where to return the locked pages.
2158 * @param pcPages Where to return the number of pages.
2159 * @param poffPage0 Where to return the offset into the first page.
2160 * @param pcbChunk Where to return the number of bytes covered.
2161 */
2162static int vbsf_iter_lock_pages(struct iov_iter *iter, bool fWrite, struct vbsf_iter_stash *pStash, size_t cMaxPages,
2163 struct page **papPages, size_t *pcPages, size_t *poffPage0, size_t *pcbChunk)
2164{
2165 size_t cbChunk = 0;
2166 size_t cPages = 0;
2167 size_t offPage0 = 0;
2168 int rc = 0;
2169
2170 Assert(iov_iter_count(iter) + pStash->cb > 0);
2171 if (!VBOX_IOV_ITER_IS_KVEC(iter))
2172 {
2173 /*
2174 * Do we have a stashed page?
2175 */
2176 if (pStash->pPage) {
2177 papPages[0] = pStash->pPage;
2178 offPage0 = pStash->off;
2179 cbChunk = pStash->cb;
2180 cPages = 1;
2181 pStash->pPage = NULL;
2182 pStash->off = 0;
2183 pStash->cb = 0;
2184 if ( offPage0 + cbChunk < PAGE_SIZE
2185 || iov_iter_count(iter) == 0) {
2186 *poffPage0 = offPage0;
2187 *pcbChunk = cbChunk;
2188 *pcPages = cPages;
2189 SFLOGFLOW(("vbsf_iter_lock_pages: returns %d - cPages=%#zx offPage0=%#zx cbChunk=%zx (stashed)\n",
2190 rc, cPages, offPage0, cbChunk));
2191 return 0;
2192 }
2193 cMaxPages -= 1;
2194 SFLOG3(("vbsf_iter_lock_pages: Picked up stashed page: %#zx LB %#zx\n", offPage0, cbChunk));
2195 } else {
2196# if RTLNX_VER_MAX(4,11,0)
2197 /*
2198 * Copy out our starting point to assist rewinding.
2199 */
2200 pStash->offFromEnd = iov_iter_count(iter);
2201 pStash->Copy = *iter;
2202# endif
2203 }
2204
2205 /*
2206 * Get pages segment by segment.
2207 */
2208 do {
2209 /*
2210 * Make a special case of the first time thru here, since that's
2211 * the most typical scenario.
2212 */
2213 ssize_t cbSegRet;
2214 if (cPages == 0) {
2215# if RTLNX_VER_MAX(3,19,0)
2216 while (!iov_iter_single_seg_count(iter)) /* Old code didn't skip empty segments which caused EFAULTs. */
2217 iov_iter_advance(iter, 0);
2218# endif
2219 cbSegRet = VBOX_IOV_GET_PAGES(iter, papPages, iov_iter_count(iter), cMaxPages, &offPage0);
2220 if (cbSegRet > 0) {
2221# if RTLNX_VER_MAX(6,0,0)
2222 iov_iter_advance(iter, cbSegRet);
2223#endif
2224 cbChunk = (size_t)cbSegRet;
2225 cPages = RT_ALIGN_Z(offPage0 + cbSegRet, PAGE_SIZE) >> PAGE_SHIFT;
2226 cMaxPages -= cPages;
2227 SFLOG3(("vbsf_iter_lock_pages: iov_iter_get_pages -> %#zx @ %#zx; %#zx pages [first]\n", cbSegRet, offPage0, cPages));
2228 if ( cMaxPages == 0
2229 || ((offPage0 + (size_t)cbSegRet) & PAGE_OFFSET_MASK))
2230 break;
2231 } else {
2232 AssertStmt(cbSegRet < 0, cbSegRet = -EFAULT);
2233 rc = (int)cbSegRet;
2234 break;
2235 }
2236 } else {
2237 /*
2238 * Probe first page of new segment to check that we've got a zero offset and
2239 * can continue on the current chunk. Stash the page if the offset isn't zero.
2240 */
2241 size_t offPgProbe;
2242 size_t cbSeg = iov_iter_single_seg_count(iter);
2243 while (!cbSeg) {
2244 iov_iter_advance(iter, 0);
2245 cbSeg = iov_iter_single_seg_count(iter);
2246 }
2247 cbSegRet = VBOX_IOV_GET_PAGES(iter, &papPages[cPages], iov_iter_count(iter), 1, &offPgProbe);
2248 if (cbSegRet > 0) {
2249# if RTLNX_VER_MAX(6,0,0)
2250 iov_iter_advance(iter, cbSegRet); /** @todo maybe not do this if we stash the page? */
2251#endif
2252 Assert(offPgProbe + cbSegRet <= PAGE_SIZE);
2253 if (offPgProbe == 0) {
2254 cbChunk += cbSegRet;
2255 cPages += 1;
2256 cMaxPages -= 1;
2257 SFLOG3(("vbsf_iter_lock_pages: iov_iter_get_pages(1) -> %#zx @ %#zx\n", cbSegRet, offPgProbe));
2258 if ( cMaxPages == 0
2259 || cbSegRet != PAGE_SIZE)
2260 break;
2261
2262 /*
2263 * Get the rest of the segment (if anything remaining).
2264 */
2265 cbSeg -= cbSegRet;
2266 if (cbSeg > 0) {
2267 cbSegRet = VBOX_IOV_GET_PAGES(iter, &papPages[cPages], iov_iter_count(iter), cMaxPages, &offPgProbe);
2268 if (cbSegRet > 0) {
2269 size_t const cPgRet = RT_ALIGN_Z((size_t)cbSegRet, PAGE_SIZE) >> PAGE_SHIFT;
2270 Assert(offPgProbe == 0);
2271# if RTLNX_VER_MAX(6,0,0)
2272 iov_iter_advance(iter, cbSegRet);
2273# endif
2274 SFLOG3(("vbsf_iter_lock_pages: iov_iter_get_pages() -> %#zx; %#zx pages\n", cbSegRet, cPgRet));
2275 cPages += cPgRet;
2276 cMaxPages -= cPgRet;
2277 cbChunk += cbSegRet;
2278 if ( cMaxPages == 0
2279 || ((size_t)cbSegRet & PAGE_OFFSET_MASK))
2280 break;
2281 } else {
2282 AssertStmt(cbSegRet < 0, cbSegRet = -EFAULT);
2283 rc = (int)cbSegRet;
2284 break;
2285 }
2286 }
2287 } else {
2288 /* The segment didn't start at a page boundrary, so stash it for
2289 the next round: */
2290 SFLOGFLOW(("vbsf_iter_lock_pages: iov_iter_get_pages(1) -> %#zx @ %#zx; stashed\n", cbSegRet, offPgProbe));
2291 Assert(papPages[cPages]);
2292 pStash->pPage = papPages[cPages];
2293 pStash->off = offPgProbe;
2294 pStash->cb = cbSegRet;
2295 break;
2296 }
2297 } else {
2298 AssertStmt(cbSegRet < 0, cbSegRet = -EFAULT);
2299 rc = (int)cbSegRet;
2300 break;
2301 }
2302 }
2303 Assert(cMaxPages > 0);
2304 } while (iov_iter_count(iter) > 0);
2305
2306 } else {
2307 /*
2308 * The silly iov_iter_get_pages_alloc() function doesn't handle KVECs,
2309 * so everyone needs to do that by themselves.
2310 *
2311 * Note! Fixes here may apply to rtR0MemObjNativeLockKernel()
2312 * and vbsf_lock_user_pages_failed_check_kernel() as well.
2313 */
2314# if RTLNX_VER_MAX(4,11,0)
2315 pStash->offFromEnd = iov_iter_count(iter);
2316 pStash->Copy = *iter;
2317# endif
2318 do {
2319 uint8_t *pbBuf;
2320 size_t offStart;
2321 size_t cPgSeg;
2322
2323 size_t cbSeg = iov_iter_single_seg_count(iter);
2324 while (!cbSeg) {
2325 iov_iter_advance(iter, 0);
2326 cbSeg = iov_iter_single_seg_count(iter);
2327 }
2328
2329 pbBuf = VBOX_ITER_IOV_ADDR(iter);
2330 offStart = (uintptr_t)pbBuf & PAGE_OFFSET_MASK;
2331 if (!cPages)
2332 offPage0 = offStart;
2333 else if (offStart)
2334 break;
2335
2336 cPgSeg = RT_ALIGN_Z(cbSeg, PAGE_SIZE) >> PAGE_SHIFT;
2337 if (cPgSeg > cMaxPages) {
2338 cPgSeg = cMaxPages;
2339 cbSeg = (cPgSeg << PAGE_SHIFT) - offStart;
2340 }
2341
2342 rc = vbsf_lock_kernel_pages(pbBuf, fWrite, cPgSeg, &papPages[cPages]);
2343 if (rc == 0) {
2344 iov_iter_advance(iter, cbSeg);
2345 cbChunk += cbSeg;
2346 cPages += cPgSeg;
2347 cMaxPages -= cPgSeg;
2348 if ( cMaxPages == 0
2349 || ((offStart + cbSeg) & PAGE_OFFSET_MASK) != 0)
2350 break;
2351 } else
2352 break;
2353 } while (iov_iter_count(iter) > 0);
2354 }
2355
2356 /*
2357 * Clean up if we failed; set return values.
2358 */
2359 if (rc == 0) {
2360 /* likely */
2361 } else {
2362 if (cPages > 0)
2363 vbsf_iter_unlock_pages(iter, papPages, cPages, false /*fSetDirty*/);
2364 offPage0 = cbChunk = cPages = 0;
2365 }
2366 *poffPage0 = offPage0;
2367 *pcbChunk = cbChunk;
2368 *pcPages = cPages;
2369 SFLOGFLOW(("vbsf_iter_lock_pages: returns %d - cPages=%#zx offPage0=%#zx cbChunk=%zx\n", rc, cPages, offPage0, cbChunk));
2370 return rc;
2371}
2372
2373
2374/**
2375 * Rewinds the I/O vector.
2376 */
2377static bool vbsf_iter_rewind(struct iov_iter *iter, struct vbsf_iter_stash *pStash, size_t cbToRewind, size_t cbChunk)
2378{
2379 size_t cbExtra;
2380 if (!pStash->pPage) {
2381 cbExtra = 0;
2382 } else {
2383 cbExtra = pStash->cb;
2384 vbsf_put_page(pStash->pPage);
2385 pStash->pPage = NULL;
2386 pStash->cb = 0;
2387 pStash->off = 0;
2388 }
2389
2390# if RTLNX_VER_MIN(4,11,0) || RTLNX_VER_MAX(3,16,0)
2391 iov_iter_revert(iter, cbToRewind + cbExtra);
2392 return true;
2393# else
2394 /** @todo impl this */
2395 return false;
2396# endif
2397}
2398
2399
2400/**
2401 * Cleans up the page locking stash.
2402 */
2403DECLINLINE(void) vbsf_iter_cleanup_stash(struct iov_iter *iter, struct vbsf_iter_stash *pStash)
2404{
2405 if (pStash->pPage)
2406 vbsf_iter_rewind(iter, pStash, 0, 0);
2407}
2408
2409
2410/**
2411 * Calculates the longest span of pages we could transfer to the host in a
2412 * single request.
2413 *
2414 * @returns Page count, non-zero.
2415 * @param iter The I/O vector iterator to inspect.
2416 */
2417static size_t vbsf_iter_max_span_of_pages(struct iov_iter *iter)
2418{
2419 size_t cPages;
2420# if RTLNX_VER_MIN(3,16,0)
2421 if (iter_is_iovec(iter) || (VBSF_GET_ITER_TYPE(iter) & ITER_KVEC)) {
2422# endif
2423 const struct iovec *pCurIov = VBSF_GET_ITER_IOV(iter);
2424 size_t cLeft = iter->nr_segs;
2425 size_t cPagesSpan = 0;
2426
2427 /* iovect and kvec are identical, except for the __user tagging of iov_base. */
2428 AssertCompileMembersSameSizeAndOffset(struct iovec, iov_base, struct kvec, iov_base);
2429 AssertCompileMembersSameSizeAndOffset(struct iovec, iov_len, struct kvec, iov_len);
2430 AssertCompile(sizeof(struct iovec) == sizeof(struct kvec));
2431
2432 cPages = 1;
2433 AssertReturn(cLeft > 0, cPages);
2434
2435 /* Special case: segment offset. */
2436 if (iter->iov_offset > 0) {
2437 if (iter->iov_offset < pCurIov->iov_len) {
2438 size_t const cbSegLeft = pCurIov->iov_len - iter->iov_offset;
2439 size_t const offPage0 = ((uintptr_t)pCurIov->iov_base + iter->iov_offset) & PAGE_OFFSET_MASK;
2440 cPages = cPagesSpan = RT_ALIGN_Z(offPage0 + cbSegLeft, PAGE_SIZE) >> PAGE_SHIFT;
2441 if ((offPage0 + cbSegLeft) & PAGE_OFFSET_MASK)
2442 cPagesSpan = 0;
2443 }
2444 SFLOGFLOW(("vbsf_iter: seg[0]= %p LB %#zx\n", pCurIov->iov_base, pCurIov->iov_len));
2445 pCurIov++;
2446 cLeft--;
2447 }
2448
2449 /* Full segments. */
2450 while (cLeft-- > 0) {
2451 if (pCurIov->iov_len > 0) {
2452 size_t const offPage0 = (uintptr_t)pCurIov->iov_base & PAGE_OFFSET_MASK;
2453 if (offPage0 == 0) {
2454 if (!(pCurIov->iov_len & PAGE_OFFSET_MASK)) {
2455 cPagesSpan += pCurIov->iov_len >> PAGE_SHIFT;
2456 } else {
2457 cPagesSpan += RT_ALIGN_Z(pCurIov->iov_len, PAGE_SIZE) >> PAGE_SHIFT;
2458 if (cPagesSpan > cPages)
2459 cPages = cPagesSpan;
2460 cPagesSpan = 0;
2461 }
2462 } else {
2463 if (cPagesSpan > cPages)
2464 cPages = cPagesSpan;
2465 if (!((offPage0 + pCurIov->iov_len) & PAGE_OFFSET_MASK)) {
2466 cPagesSpan = pCurIov->iov_len >> PAGE_SHIFT;
2467 } else {
2468 cPagesSpan += RT_ALIGN_Z(offPage0 + pCurIov->iov_len, PAGE_SIZE) >> PAGE_SHIFT;
2469 if (cPagesSpan > cPages)
2470 cPages = cPagesSpan;
2471 cPagesSpan = 0;
2472 }
2473 }
2474 }
2475 SFLOGFLOW(("vbsf_iter: seg[%u]= %p LB %#zx\n", iter->nr_segs - cLeft, pCurIov->iov_base, pCurIov->iov_len));
2476 pCurIov++;
2477 }
2478 if (cPagesSpan > cPages)
2479 cPages = cPagesSpan;
2480# if RTLNX_VER_MIN(3,16,0)
2481 } else {
2482 /* Won't bother with accurate counts for the next two types, just make
2483 some rough estimates (does pipes have segments?): */
2484 size_t cSegs = VBSF_GET_ITER_TYPE(iter) & ITER_BVEC ? RT_MAX(1, iter->nr_segs) : 1;
2485 cPages = (iov_iter_count(iter) + (PAGE_SIZE * 2 - 2) * cSegs) >> PAGE_SHIFT;
2486 }
2487# endif
2488 SFLOGFLOW(("vbsf_iter_max_span_of_pages: returns %#zx\n", cPages));
2489 return cPages;
2490}
2491
2492
2493/**
2494 * Worker for vbsf_reg_read_iter() that deals with larger reads using page
2495 * locking.
2496 */
2497static ssize_t vbsf_reg_read_iter_locking(struct kiocb *kio, struct iov_iter *iter, size_t cbToRead,
2498 struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
2499{
2500 /*
2501 * Estimate how many pages we may possible submit in a single request so
2502 * that we can allocate matching request buffer and page array.
2503 */
2504 struct page *apPagesStack[16];
2505 struct page **papPages = &apPagesStack[0];
2506 struct page **papPagesFree = NULL;
2507 VBOXSFREADPGLSTREQ *pReq;
2508 ssize_t cbRet = 0;
2509 size_t cMaxPages = vbsf_iter_max_span_of_pages(iter);
2510 cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 2), cMaxPages);
2511
2512 pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
2513 while (!pReq && cMaxPages > 4) {
2514 cMaxPages /= 2;
2515 pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
2516 }
2517 if (pReq && cMaxPages > RT_ELEMENTS(apPagesStack))
2518 papPagesFree = papPages = kmalloc(cMaxPages * sizeof(sizeof(papPages[0])), GFP_KERNEL);
2519 if (pReq && papPages) {
2520
2521 /*
2522 * The read loop.
2523 */
2524 struct vbsf_iter_stash Stash = VBSF_ITER_STASH_INITIALIZER;
2525 do {
2526 /*
2527 * Grab as many pages as we can. This means that if adjacent
2528 * segments both starts and ends at a page boundrary, we can
2529 * do them both in the same transfer from the host.
2530 */
2531 size_t cPages = 0;
2532 size_t cbChunk = 0;
2533 size_t offPage0 = 0;
2534 int rc = vbsf_iter_lock_pages(iter, true /*fWrite*/, &Stash, cMaxPages, papPages, &cPages, &offPage0, &cbChunk);
2535 if (rc == 0) {
2536 size_t iPage = cPages;
2537 while (iPage-- > 0)
2538 {
2539 RTGCPHYS64 * paDstPages = pReq->PgLst.aPages;
2540 paDstPages[iPage] = page_to_phys(papPages[iPage]);
2541 }
2542
2543 pReq->PgLst.offFirstPage = (uint16_t)offPage0;
2544 AssertStmt(cbChunk <= cbToRead, cbChunk = cbToRead);
2545 } else {
2546 cbRet = rc;
2547 break;
2548 }
2549
2550 /*
2551 * Issue the request and unlock the pages.
2552 */
2553 rc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, kio->ki_pos, cbChunk, cPages);
2554 SFLOGFLOW(("vbsf_reg_read_iter_locking: VbglR0SfHostReqReadPgLst -> %d (cbActual=%#x cbChunk=%#zx of %#zx cPages=%#zx offPage0=%#x\n",
2555 rc, pReq->Parms.cb32Read.u.value32, cbChunk, cbToRead, cPages, offPage0));
2556
2557 vbsf_iter_unlock_pages(iter, papPages, cPages, true /*fSetDirty*/);
2558
2559 if (RT_SUCCESS(rc)) {
2560 /*
2561 * Success, advance position and buffer.
2562 */
2563 uint32_t cbActual = pReq->Parms.cb32Read.u.value32;
2564 AssertStmt(cbActual <= cbChunk, cbActual = cbChunk);
2565 cbRet += cbActual;
2566 kio->ki_pos += cbActual;
2567 cbToRead -= cbActual;
2568
2569 /*
2570 * Are we done already?
2571 */
2572 if (!cbToRead)
2573 break;
2574 if (cbActual < cbChunk) { /* We ASSUME end-of-file here. */
2575 if (vbsf_iter_rewind(iter, &Stash, cbChunk - cbActual, cbActual))
2576 iov_iter_truncate(iter, 0);
2577 break;
2578 }
2579 } else {
2580 /*
2581 * Try rewind the iter structure.
2582 */
2583 bool const fRewindOkay = vbsf_iter_rewind(iter, &Stash, cbChunk, cbChunk);
2584 if (rc == VERR_NO_MEMORY && cMaxPages > 4 && fRewindOkay) {
2585 /*
2586 * The host probably doesn't have enough heap to handle the
2587 * request, reduce the page count and retry.
2588 */
2589 cMaxPages /= 4;
2590 Assert(cMaxPages > 0);
2591 } else {
2592 /*
2593 * If we've successfully read stuff, return it rather than
2594 * the error. (Not sure if this is such a great idea...)
2595 */
2596 if (cbRet <= 0)
2597 cbRet = -EPROTO;
2598 break;
2599 }
2600 }
2601 } while (cbToRead > 0);
2602
2603 vbsf_iter_cleanup_stash(iter, &Stash);
2604 }
2605 else
2606 cbRet = -ENOMEM;
2607 if (papPagesFree)
2608 kfree(papPages);
2609 if (pReq)
2610 VbglR0PhysHeapFree(pReq);
2611 SFLOGFLOW(("vbsf_reg_read_iter_locking: returns %#zx (%zd)\n", cbRet, cbRet));
2612 return cbRet;
2613}
2614
2615
2616/**
2617 * Read into I/O vector iterator.
2618 *
2619 * @returns Number of bytes read on success, negative errno on error.
2620 * @param kio The kernel I/O control block (or something like that).
2621 * @param iter The I/O vector iterator describing the buffer.
2622 */
2623# if RTLNX_VER_MIN(3,16,0)
2624static ssize_t vbsf_reg_read_iter(struct kiocb *kio, struct iov_iter *iter)
2625# else
2626static ssize_t vbsf_reg_aio_read(struct kiocb *kio, const struct iovec *iov, unsigned long cSegs, loff_t offFile)
2627# endif
2628{
2629# if RTLNX_VER_MAX(3,16,0)
2630 struct vbsf_iov_iter fake_iter = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 0 /*write*/);
2631 struct vbsf_iov_iter *iter = &fake_iter;
2632# endif
2633 size_t cbToRead = iov_iter_count(iter);
2634 struct inode *inode = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
2635 struct address_space *mapping = inode->i_mapping;
2636
2637 struct vbsf_reg_info *sf_r = kio->ki_filp->private_data;
2638 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
2639
2640 SFLOGFLOW(("vbsf_reg_read_iter: inode=%p file=%p size=%#zx off=%#llx type=%#x\n",
2641 inode, kio->ki_filp, cbToRead, kio->ki_pos, VBSF_GET_ITER_TYPE(iter) ));
2642 AssertReturn(S_ISREG(inode->i_mode), -EINVAL);
2643
2644 /*
2645 * Do we have anything at all to do here?
2646 */
2647 if (!cbToRead)
2648 return 0;
2649
2650 /*
2651 * If there is a mapping and O_DIRECT isn't in effect, we must at a
2652 * heed dirty pages in the mapping and read from them. For simplicity
2653 * though, we just do page cache reading when there are writable
2654 * mappings around with any kind of pages loaded.
2655 */
2656 if (vbsf_should_use_cached_read(kio->ki_filp, mapping, pSuperInfo)) {
2657# if RTLNX_VER_MIN(3,16,0)
2658 return generic_file_read_iter(kio, iter);
2659# else
2660 return generic_file_aio_read(kio, iov, cSegs, offFile);
2661# endif
2662 }
2663
2664 /*
2665 * Now now we reject async I/O requests.
2666 */
2667 if (!is_sync_kiocb(kio)) {
2668 SFLOGFLOW(("vbsf_reg_read_iter: async I/O not yet supported\n")); /** @todo extend FsPerf with AIO tests. */
2669 return -EOPNOTSUPP;
2670 }
2671
2672 /*
2673 * For small requests, try use an embedded buffer provided we get a heap block
2674 * that does not cross page boundraries (see host code).
2675 */
2676 if (cbToRead <= PAGE_SIZE / 4 * 3 - RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) /* see allocator */) {
2677 uint32_t const cbReq = RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) + cbToRead;
2678 VBOXSFREADEMBEDDEDREQ *pReq = (VBOXSFREADEMBEDDEDREQ *)VbglR0PhysHeapAlloc(cbReq);
2679 if (pReq) {
2680 if ((PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
2681 ssize_t cbRet;
2682 int vrc = VbglR0SfHostReqReadEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
2683 kio->ki_pos, (uint32_t)cbToRead);
2684 if (RT_SUCCESS(vrc)) {
2685 cbRet = pReq->Parms.cb32Read.u.value32;
2686 AssertStmt(cbRet <= (ssize_t)cbToRead, cbRet = cbToRead);
2687 if (copy_to_iter(pReq->abData, cbRet, iter) == cbRet) {
2688 kio->ki_pos += cbRet;
2689 if (cbRet < cbToRead)
2690 iov_iter_truncate(iter, 0);
2691 } else
2692 cbRet = -EFAULT;
2693 } else
2694 cbRet = -EPROTO;
2695 VbglR0PhysHeapFree(pReq);
2696 SFLOGFLOW(("vbsf_reg_read_iter: returns %#zx (%zd)\n", cbRet, cbRet));
2697 return cbRet;
2698 }
2699 VbglR0PhysHeapFree(pReq);
2700 }
2701 }
2702
2703 /*
2704 * Otherwise do the page locking thing.
2705 */
2706 return vbsf_reg_read_iter_locking(kio, iter, cbToRead, pSuperInfo, sf_r);
2707}
2708
2709
2710/**
2711 * Worker for vbsf_reg_write_iter() that deals with larger writes using page
2712 * locking.
2713 */
2714static ssize_t vbsf_reg_write_iter_locking(struct kiocb *kio, struct iov_iter *iter, size_t cbToWrite, loff_t offFile,
2715 struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r, struct inode *inode,
2716 struct vbsf_inode_info *sf_i, struct address_space *mapping, bool fAppend)
2717{
2718 /*
2719 * Estimate how many pages we may possible submit in a single request so
2720 * that we can allocate matching request buffer and page array.
2721 */
2722 struct page *apPagesStack[16];
2723 struct page **papPages = &apPagesStack[0];
2724 struct page **papPagesFree = NULL;
2725 VBOXSFWRITEPGLSTREQ *pReq;
2726 ssize_t cbRet = 0;
2727 size_t cMaxPages = vbsf_iter_max_span_of_pages(iter);
2728 cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 2), cMaxPages);
2729
2730 pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
2731 while (!pReq && cMaxPages > 4) {
2732 cMaxPages /= 2;
2733 pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
2734 }
2735 if (pReq && cMaxPages > RT_ELEMENTS(apPagesStack))
2736 papPagesFree = papPages = kmalloc(cMaxPages * sizeof(sizeof(papPages[0])), GFP_KERNEL);
2737 if (pReq && papPages) {
2738
2739 /*
2740 * The write loop.
2741 */
2742 struct vbsf_iter_stash Stash = VBSF_ITER_STASH_INITIALIZER;
2743 do {
2744 /*
2745 * Grab as many pages as we can. This means that if adjacent
2746 * segments both starts and ends at a page boundrary, we can
2747 * do them both in the same transfer from the host.
2748 */
2749 size_t cPages = 0;
2750 size_t cbChunk = 0;
2751 size_t offPage0 = 0;
2752 int rc = vbsf_iter_lock_pages(iter, false /*fWrite*/, &Stash, cMaxPages, papPages, &cPages, &offPage0, &cbChunk);
2753 if (rc == 0) {
2754 size_t iPage = cPages;
2755 while (iPage-- > 0)
2756 {
2757 RTGCPHYS64 * paDstPages = pReq->PgLst.aPages;
2758 paDstPages[iPage] = page_to_phys(papPages[iPage]);
2759 }
2760 pReq->PgLst.offFirstPage = (uint16_t)offPage0;
2761 AssertStmt(cbChunk <= cbToWrite, cbChunk = cbToWrite);
2762 } else {
2763 cbRet = rc;
2764 break;
2765 }
2766
2767 /*
2768 * Issue the request and unlock the pages.
2769 */
2770 rc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
2771 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
2772 SFLOGFLOW(("vbsf_reg_write_iter_locking: VbglR0SfHostReqWritePgLst -> %d (cbActual=%#x cbChunk=%#zx of %#zx cPages=%#zx offPage0=%#x\n",
2773 rc, pReq->Parms.cb32Write.u.value32, cbChunk, cbToWrite, cPages, offPage0));
2774 if (RT_SUCCESS(rc)) {
2775 /*
2776 * Success, advance position and buffer.
2777 */
2778 uint32_t cbActual = pReq->Parms.cb32Write.u.value32;
2779 AssertStmt(cbActual <= cbChunk, cbActual = cbChunk);
2780
2781 vbsf_reg_write_sync_page_cache(mapping, offFile, cbActual, NULL /*pbSrcBuf*/, papPages, offPage0, cPages);
2782 vbsf_iter_unlock_pages(iter, papPages, cPages, false /*fSetDirty*/);
2783
2784 cbRet += cbActual;
2785 cbToWrite -= cbActual;
2786
2787 offFile += cbActual;
2788 if (fAppend && (g_fSfFeatures & SHFL_FEATURE_WRITE_UPDATES_OFFSET))
2789 offFile = pReq->Parms.off64Write.u.value64;
2790 kio->ki_pos = offFile;
2791 if (offFile > i_size_read(inode))
2792 i_size_write(inode, offFile);
2793
2794 sf_i->force_restat = 1; /* mtime (and size) may have changed */
2795
2796 /*
2797 * Are we done already?
2798 */
2799 if (!cbToWrite)
2800 break;
2801 if (cbActual < cbChunk) { /* We ASSUME end-of-file here. */
2802 if (vbsf_iter_rewind(iter, &Stash, cbChunk - cbActual, cbActual))
2803 iov_iter_truncate(iter, 0);
2804 break;
2805 }
2806 } else {
2807 /*
2808 * Try rewind the iter structure.
2809 */
2810 bool fRewindOkay;
2811 vbsf_iter_unlock_pages(iter, papPages, cPages, false /*fSetDirty*/);
2812 fRewindOkay = vbsf_iter_rewind(iter, &Stash, cbChunk, cbChunk);
2813 if (rc == VERR_NO_MEMORY && cMaxPages > 4 && fRewindOkay) {
2814 /*
2815 * The host probably doesn't have enough heap to handle the
2816 * request, reduce the page count and retry.
2817 */
2818 cMaxPages /= 4;
2819 Assert(cMaxPages > 0);
2820 } else {
2821 /*
2822 * If we've successfully written stuff, return it rather than
2823 * the error. (Not sure if this is such a great idea...)
2824 */
2825 if (cbRet <= 0)
2826 cbRet = -EPROTO;
2827 break;
2828 }
2829 }
2830 } while (cbToWrite > 0);
2831
2832 vbsf_iter_cleanup_stash(iter, &Stash);
2833 }
2834 else
2835 cbRet = -ENOMEM;
2836 if (papPagesFree)
2837 kfree(papPages);
2838 if (pReq)
2839 VbglR0PhysHeapFree(pReq);
2840 SFLOGFLOW(("vbsf_reg_write_iter_locking: returns %#zx (%zd)\n", cbRet, cbRet));
2841 return cbRet;
2842}
2843
2844
2845/**
2846 * Write from I/O vector iterator.
2847 *
2848 * @returns Number of bytes written on success, negative errno on error.
2849 * @param kio The kernel I/O control block (or something like that).
2850 * @param iter The I/O vector iterator describing the buffer.
2851 */
2852# if RTLNX_VER_MIN(3,16,0)
2853static ssize_t vbsf_reg_write_iter(struct kiocb *kio, struct iov_iter *iter)
2854# else
2855static ssize_t vbsf_reg_aio_write(struct kiocb *kio, const struct iovec *iov, unsigned long cSegs, loff_t offFile)
2856# endif
2857{
2858# if RTLNX_VER_MAX(3,16,0)
2859 struct vbsf_iov_iter fake_iter = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 1 /*write*/);
2860 struct vbsf_iov_iter *iter = &fake_iter;
2861# endif
2862 size_t cbToWrite = iov_iter_count(iter);
2863 struct inode *inode = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
2864 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
2865 struct address_space *mapping = inode->i_mapping;
2866
2867 struct vbsf_reg_info *sf_r = kio->ki_filp->private_data;
2868 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
2869# if RTLNX_VER_MIN(3,16,0)
2870 loff_t offFile = kio->ki_pos;
2871# endif
2872# if RTLNX_VER_MIN(4,1,0)
2873 bool const fAppend = RT_BOOL(kio->ki_flags & IOCB_APPEND);
2874# else
2875 bool const fAppend = RT_BOOL(kio->ki_filp->f_flags & O_APPEND);
2876# endif
2877
2878
2879 SFLOGFLOW(("vbsf_reg_write_iter: inode=%p file=%p size=%#zx off=%#llx type=%#x\n",
2880 inode, kio->ki_filp, cbToWrite, offFile, VBSF_GET_ITER_TYPE(iter) ));
2881 AssertReturn(S_ISREG(inode->i_mode), -EINVAL);
2882
2883 /*
2884 * Enforce APPEND flag (more later).
2885 */
2886 if (fAppend)
2887 kio->ki_pos = offFile = i_size_read(inode);
2888
2889 /*
2890 * Do we have anything at all to do here?
2891 */
2892 if (!cbToWrite)
2893 return 0;
2894
2895 /** @todo Implement the read-write caching mode. */
2896
2897 /*
2898 * Now now we reject async I/O requests.
2899 */
2900 if (!is_sync_kiocb(kio)) {
2901 SFLOGFLOW(("vbsf_reg_write_iter: async I/O not yet supported\n")); /** @todo extend FsPerf with AIO tests. */
2902 return -EOPNOTSUPP;
2903 }
2904
2905 /*
2906 * If there are active writable mappings, coordinate with any
2907 * pending writes via those.
2908 */
2909 if ( mapping
2910 && mapping->nrpages > 0
2911 && mapping_writably_mapped(mapping)) {
2912# if RTLNX_VER_MIN(2,6,32)
2913 int err = filemap_fdatawait_range(mapping, offFile, offFile + cbToWrite - 1);
2914 if (err)
2915 return err;
2916# else
2917 /** @todo ... */
2918# endif
2919 }
2920
2921 /*
2922 * For small requests, try use an embedded buffer provided we get a heap block
2923 * that does not cross page boundraries (see host code).
2924 */
2925 if (cbToWrite <= PAGE_SIZE / 4 * 3 - RT_UOFFSETOF(VBOXSFWRITEEMBEDDEDREQ, abData[0]) /* see allocator */) {
2926 uint32_t const cbReq = RT_UOFFSETOF(VBOXSFWRITEEMBEDDEDREQ, abData[0]) + cbToWrite;
2927 VBOXSFWRITEEMBEDDEDREQ *pReq = (VBOXSFWRITEEMBEDDEDREQ *)VbglR0PhysHeapAlloc(cbReq);
2928 if (pReq) {
2929 if ((PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
2930 ssize_t cbRet;
2931 if (copy_from_iter(pReq->abData, cbToWrite, iter) == cbToWrite) {
2932 int vrc = VbglR0SfHostReqWriteEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
2933 offFile, (uint32_t)cbToWrite);
2934 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
2935 if (RT_SUCCESS(vrc)) {
2936 cbRet = pReq->Parms.cb32Write.u.value32;
2937 AssertStmt(cbRet <= (ssize_t)cbToWrite, cbRet = cbToWrite);
2938 vbsf_reg_write_sync_page_cache(mapping, offFile, (uint32_t)cbRet, pReq->abData,
2939 NULL /*papSrcPages*/, 0 /*offSrcPage0*/, 0 /*cSrcPages*/);
2940
2941 offFile += cbRet;
2942 if (fAppend && (g_fSfFeatures & SHFL_FEATURE_WRITE_UPDATES_OFFSET))
2943 offFile = pReq->Parms.off64Write.u.value64;
2944 kio->ki_pos = offFile;
2945 if (offFile > i_size_read(inode))
2946 i_size_write(inode, offFile);
2947
2948# if RTLNX_VER_MIN(4,11,0)
2949 if ((size_t)cbRet < cbToWrite)
2950 iov_iter_revert(iter, cbToWrite - cbRet);
2951# endif
2952 } else
2953 cbRet = -EPROTO;
2954 sf_i->force_restat = 1; /* mtime (and size) may have changed */
2955 } else
2956 cbRet = -EFAULT;
2957 VbglR0PhysHeapFree(pReq);
2958 SFLOGFLOW(("vbsf_reg_write_iter: returns %#zx (%zd)\n", cbRet, cbRet));
2959 return cbRet;
2960 }
2961 VbglR0PhysHeapFree(pReq);
2962 }
2963 }
2964
2965 /*
2966 * Otherwise do the page locking thing.
2967 */
2968 return vbsf_reg_write_iter_locking(kio, iter, cbToWrite, offFile, pSuperInfo, sf_r, inode, sf_i, mapping, fAppend);
2969}
2970
2971#endif /* >= 2.6.19 */
2972
2973/**
2974 * Used by vbsf_reg_open() and vbsf_inode_atomic_open() to
2975 *
2976 * @returns shared folders create flags.
2977 * @param fLnxOpen The linux O_XXX flags to convert.
2978 * @param pfHandle Pointer to vbsf_handle::fFlags.
2979 * @param pszCaller Caller, for logging purposes.
2980 */
2981uint32_t vbsf_linux_oflags_to_vbox(unsigned fLnxOpen, uint32_t *pfHandle, const char *pszCaller)
2982{
2983 uint32_t fVBoxFlags = SHFL_CF_ACCESS_DENYNONE;
2984
2985 /*
2986 * Disposition.
2987 */
2988 if (fLnxOpen & O_CREAT) {
2989 Log(("%s: O_CREAT set\n", pszCaller));
2990 fVBoxFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
2991 if (fLnxOpen & O_EXCL) {
2992 Log(("%s: O_EXCL set\n", pszCaller));
2993 fVBoxFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
2994 } else if (fLnxOpen & O_TRUNC) {
2995 Log(("%s: O_TRUNC set\n", pszCaller));
2996 fVBoxFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
2997 } else
2998 fVBoxFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
2999 } else {
3000 fVBoxFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
3001 if (fLnxOpen & O_TRUNC) {
3002 Log(("%s: O_TRUNC set\n", pszCaller));
3003 fVBoxFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
3004 }
3005 }
3006
3007 /*
3008 * Access.
3009 */
3010 switch (fLnxOpen & O_ACCMODE) {
3011 case O_RDONLY:
3012 fVBoxFlags |= SHFL_CF_ACCESS_READ;
3013 *pfHandle |= VBSF_HANDLE_F_READ;
3014 break;
3015
3016 case O_WRONLY:
3017 fVBoxFlags |= SHFL_CF_ACCESS_WRITE;
3018 *pfHandle |= VBSF_HANDLE_F_WRITE;
3019 break;
3020
3021 case O_RDWR:
3022 fVBoxFlags |= SHFL_CF_ACCESS_READWRITE;
3023 *pfHandle |= VBSF_HANDLE_F_READ | VBSF_HANDLE_F_WRITE;
3024 break;
3025
3026 default:
3027 BUG();
3028 }
3029
3030 if (fLnxOpen & O_APPEND) {
3031 Log(("%s: O_APPEND set\n", pszCaller));
3032 fVBoxFlags |= SHFL_CF_ACCESS_APPEND;
3033 *pfHandle |= VBSF_HANDLE_F_APPEND;
3034 }
3035
3036 /*
3037 * Only directories?
3038 */
3039 if (fLnxOpen & O_DIRECTORY) {
3040 Log(("%s: O_DIRECTORY set\n", pszCaller));
3041 fVBoxFlags |= SHFL_CF_DIRECTORY;
3042 }
3043
3044 return fVBoxFlags;
3045}
3046
3047
3048/**
3049 * Open a regular file.
3050 *
3051 * @param inode the inode
3052 * @param file the file
3053 * @returns 0 on success, Linux error code otherwise
3054 */
3055static int vbsf_reg_open(struct inode *inode, struct file *file)
3056{
3057 int rc, rc_linux = 0;
3058 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
3059 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
3060 struct dentry *dentry = VBSF_GET_F_DENTRY(file);
3061 struct vbsf_reg_info *sf_r;
3062 VBOXSFCREATEREQ *pReq;
3063
3064 SFLOGFLOW(("vbsf_reg_open: inode=%p file=%p flags=%#x %s\n", inode, file, file->f_flags, sf_i ? sf_i->path->String.ach : NULL));
3065 Assert(pSuperInfo);
3066 Assert(sf_i);
3067
3068 sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
3069 if (!sf_r) {
3070 LogRelFunc(("could not allocate reg info\n"));
3071 return -ENOMEM;
3072 }
3073
3074 RTListInit(&sf_r->Handle.Entry);
3075 sf_r->Handle.cRefs = 1;
3076 sf_r->Handle.fFlags = VBSF_HANDLE_F_FILE | VBSF_HANDLE_F_MAGIC;
3077 sf_r->Handle.hHost = SHFL_HANDLE_NIL;
3078
3079 /* Already open? */
3080 if (sf_i->handle != SHFL_HANDLE_NIL) {
3081 /*
3082 * This inode was created with vbsf_create_worker(). Check the CreateFlags:
3083 * O_CREAT, O_TRUNC: inherent true (file was just created). Not sure
3084 * about the access flags (SHFL_CF_ACCESS_*).
3085 */
3086 sf_i->force_restat = 1;
3087 sf_r->Handle.hHost = sf_i->handle;
3088 sf_i->handle = SHFL_HANDLE_NIL;
3089 file->private_data = sf_r;
3090
3091 sf_r->Handle.fFlags |= VBSF_HANDLE_F_READ | VBSF_HANDLE_F_WRITE; /** @todo fix */
3092 vbsf_handle_append(sf_i, &sf_r->Handle);
3093 SFLOGFLOW(("vbsf_reg_open: returns 0 (#1) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
3094 return 0;
3095 }
3096
3097 pReq = (VBOXSFCREATEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq) + sf_i->path->u16Size);
3098 if (!pReq) {
3099 kfree(sf_r);
3100 LogRelFunc(("Failed to allocate a VBOXSFCREATEREQ buffer!\n"));
3101 return -ENOMEM;
3102 }
3103 RT_BCOPY_UNFORTIFIED(&pReq->StrPath, sf_i->path, SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
3104 RT_ZERO(pReq->CreateParms);
3105 pReq->CreateParms.Handle = SHFL_HANDLE_NIL;
3106
3107 /* We check the value of pReq->CreateParms.Handle afterwards to
3108 * find out if the call succeeded or failed, as the API does not seem
3109 * to cleanly distinguish error and informational messages.
3110 *
3111 * Furthermore, we must set pReq->CreateParms.Handle to SHFL_HANDLE_NIL
3112 * to make the shared folders host service use our fMode parameter */
3113
3114 /* We ignore O_EXCL, as the Linux kernel seems to call create
3115 beforehand itself, so O_EXCL should always fail. */
3116 pReq->CreateParms.CreateFlags = vbsf_linux_oflags_to_vbox(file->f_flags & ~O_EXCL, &sf_r->Handle.fFlags, __FUNCTION__);
3117 pReq->CreateParms.Info.Attr.fMode = inode->i_mode;
3118 LogFunc(("vbsf_reg_open: calling VbglR0SfHostReqCreate, file %s, flags=%#x, %#x\n",
3119 sf_i->path->String.utf8, file->f_flags, pReq->CreateParms.CreateFlags));
3120 rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
3121 if (RT_FAILURE(rc)) {
3122 LogFunc(("VbglR0SfHostReqCreate failed flags=%d,%#x rc=%Rrc\n", file->f_flags, pReq->CreateParms.CreateFlags, rc));
3123 kfree(sf_r);
3124 VbglR0PhysHeapFree(pReq);
3125 return -RTErrConvertToErrno(rc);
3126 }
3127
3128 if (pReq->CreateParms.Handle != SHFL_HANDLE_NIL) {
3129 vbsf_dentry_chain_increase_ttl(dentry);
3130 vbsf_update_inode(inode, sf_i, &pReq->CreateParms.Info, pSuperInfo, false /*fInodeLocked*/, 0 /*fSetAttrs*/);
3131 rc_linux = 0;
3132 } else {
3133 switch (pReq->CreateParms.Result) {
3134 case SHFL_PATH_NOT_FOUND:
3135 vbsf_dentry_invalidate_ttl(dentry);
3136 rc_linux = -ENOENT;
3137 break;
3138 case SHFL_FILE_NOT_FOUND:
3139 vbsf_dentry_invalidate_ttl(dentry);
3140 /** @todo sf_dentry_increase_parent_ttl(file->f_dentry); if we can trust it. */
3141 rc_linux = -ENOENT;
3142 break;
3143 case SHFL_FILE_EXISTS:
3144 vbsf_dentry_chain_increase_ttl(dentry);
3145 vbsf_update_inode(inode, sf_i, &pReq->CreateParms.Info, pSuperInfo, false /*fInodeLocked*/, 0 /*fSetAttrs*/);
3146 rc_linux = -EEXIST;
3147 break;
3148 default:
3149 vbsf_dentry_chain_increase_parent_ttl(dentry);
3150 rc_linux = 0;
3151 break;
3152 }
3153 }
3154
3155 sf_r->Handle.hHost = pReq->CreateParms.Handle;
3156 file->private_data = sf_r;
3157 vbsf_handle_append(sf_i, &sf_r->Handle);
3158 VbglR0PhysHeapFree(pReq);
3159 SFLOGFLOW(("vbsf_reg_open: returns 0 (#2) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
3160 return rc_linux;
3161}
3162
3163
3164/**
3165 * Close a regular file.
3166 *
3167 * @param inode the inode
3168 * @param file the file
3169 * @returns 0 on success, Linux error code otherwise
3170 */
3171static int vbsf_reg_release(struct inode *inode, struct file *file)
3172{
3173 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
3174 struct vbsf_reg_info *sf_r = file->private_data;
3175
3176 SFLOGFLOW(("vbsf_reg_release: inode=%p file=%p\n", inode, file));
3177 if (sf_r) {
3178 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
3179 struct address_space *mapping = inode->i_mapping;
3180 Assert(pSuperInfo);
3181
3182 /* If we're closing the last handle for this inode, make sure the flush
3183 the mapping or we'll end up in vbsf_writepage without a handle. */
3184 if ( mapping
3185 && mapping->nrpages > 0
3186 /** @todo && last writable handle */ ) {
3187#if RTLNX_VER_MIN(2,4,25)
3188 if (filemap_fdatawrite(mapping) != -EIO)
3189#else
3190 if ( filemap_fdatasync(mapping) == 0
3191 && fsync_inode_data_buffers(inode) == 0)
3192#endif
3193 filemap_fdatawait(inode->i_mapping);
3194 }
3195
3196 /* Release sf_r, closing the handle if we're the last user. */
3197 file->private_data = NULL;
3198 vbsf_handle_release(&sf_r->Handle, pSuperInfo, "vbsf_reg_release");
3199
3200 sf_i->handle = SHFL_HANDLE_NIL;
3201 }
3202 return 0;
3203}
3204
3205
3206/**
3207 * Wrapper around generic/default seek function that ensures that we've got
3208 * the up-to-date file size when doing anything relative to EOF.
3209 *
3210 * The issue is that the host may extend the file while we weren't looking and
3211 * if the caller wishes to append data, it may end up overwriting existing data
3212 * if we operate with a stale size. So, we always retrieve the file size on EOF
3213 * relative seeks.
3214 */
3215static loff_t vbsf_reg_llseek(struct file *file, loff_t off, int whence)
3216{
3217 SFLOGFLOW(("vbsf_reg_llseek: file=%p off=%lld whence=%d\n", file, off, whence));
3218
3219 switch (whence) {
3220#ifdef SEEK_HOLE
3221 case SEEK_HOLE:
3222 case SEEK_DATA:
3223#endif
3224 case SEEK_END: {
3225 struct vbsf_reg_info *sf_r = file->private_data;
3226 int rc = vbsf_inode_revalidate_with_handle(VBSF_GET_F_DENTRY(file), sf_r->Handle.hHost,
3227 true /*fForce*/, false /*fInodeLocked*/);
3228 if (rc == 0)
3229 break;
3230 return rc;
3231 }
3232 }
3233
3234#if RTLNX_VER_MIN(2,4,8)
3235 return generic_file_llseek(file, off, whence);
3236#else
3237 return default_llseek(file, off, whence);
3238#endif
3239}
3240
3241
3242/**
3243 * Flush region of file - chiefly mmap/msync.
3244 *
3245 * We cannot use the noop_fsync / simple_sync_file here as that means
3246 * msync(,,MS_SYNC) will return before the data hits the host, thereby
3247 * causing coherency issues with O_DIRECT access to the same file as
3248 * well as any host interaction with the file.
3249 */
3250#if RTLNX_VER_MIN(3,1,0) \
3251 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_MIN(3,0,101) /** @todo figure when exactly */)
3252static int vbsf_reg_fsync(struct file *file, loff_t start, loff_t end, int datasync)
3253{
3254# if RTLNX_VER_MIN(3,16,0)
3255 return __generic_file_fsync(file, start, end, datasync);
3256# else
3257 return generic_file_fsync(file, start, end, datasync);
3258# endif
3259}
3260#elif RTLNX_VER_MIN(2,6,35)
3261static int vbsf_reg_fsync(struct file *file, int datasync)
3262{
3263 return generic_file_fsync(file, datasync);
3264}
3265#else /* < 2.6.35 */
3266static int vbsf_reg_fsync(struct file *file, struct dentry *dentry, int datasync)
3267{
3268# if RTLNX_VER_MIN(2,6,31)
3269 return simple_fsync(file, dentry, datasync);
3270# else
3271 int rc;
3272 struct inode *inode = dentry->d_inode;
3273 AssertReturn(inode, -EINVAL);
3274
3275 /** @todo What about file_fsync()? (<= 2.5.11) */
3276
3277# if RTLNX_VER_MIN(2,5,12)
3278 rc = sync_mapping_buffers(inode->i_mapping);
3279 if ( rc == 0
3280 && (inode->i_state & I_DIRTY)
3281 && ((inode->i_state & I_DIRTY_DATASYNC) || !datasync)
3282 ) {
3283 struct writeback_control wbc = {
3284 .sync_mode = WB_SYNC_ALL,
3285 .nr_to_write = 0
3286 };
3287 rc = sync_inode(inode, &wbc);
3288 }
3289# else /* < 2.5.12 */
3290 /** @todo
3291 * Somethings is buggy here or in the 2.4.21-27.EL kernel I'm testing on.
3292 *
3293 * In theory we shouldn't need to do anything here, since msync will call
3294 * writepage() on each dirty page and we write them out synchronously. So, the
3295 * problem is elsewhere... Doesn't happen all the time either. Sigh.
3296 */
3297 rc = fsync_inode_buffers(inode);
3298# if RTLNX_VER_MIN(2,4,10)
3299 if (rc == 0 && datasync)
3300 rc = fsync_inode_data_buffers(inode);
3301# endif
3302
3303# endif /* < 2.5.12 */
3304 return rc;
3305# endif
3306}
3307#endif /* < 2.6.35 */
3308
3309
3310#if RTLNX_VER_MIN(4,5,0)
3311/**
3312 * Copy a datablock from one file to another on the host side.
3313 */
3314static ssize_t vbsf_reg_copy_file_range(struct file *pFileSrc, loff_t offSrc, struct file *pFileDst, loff_t offDst,
3315 size_t cbRange, unsigned int fFlags)
3316{
3317 ssize_t cbRet;
3318 if (g_uSfLastFunction >= SHFL_FN_COPY_FILE_PART) {
3319 struct inode *pInodeSrc = pFileSrc->f_inode;
3320 struct vbsf_inode_info *pInodeInfoSrc = VBSF_GET_INODE_INFO(pInodeSrc);
3321 struct vbsf_super_info *pSuperInfoSrc = VBSF_GET_SUPER_INFO(pInodeSrc->i_sb);
3322 struct vbsf_reg_info *pFileInfoSrc = (struct vbsf_reg_info *)pFileSrc->private_data;
3323 struct inode *pInodeDst = pInodeSrc;
3324 struct vbsf_inode_info *pInodeInfoDst = VBSF_GET_INODE_INFO(pInodeDst);
3325 struct vbsf_super_info *pSuperInfoDst = VBSF_GET_SUPER_INFO(pInodeDst->i_sb);
3326 struct vbsf_reg_info *pFileInfoDst = (struct vbsf_reg_info *)pFileDst->private_data;
3327 VBOXSFCOPYFILEPARTREQ *pReq;
3328
3329 /*
3330 * Some extra validation.
3331 */
3332 AssertPtrReturn(pInodeInfoSrc, -EOPNOTSUPP);
3333 Assert(pInodeInfoSrc->u32Magic == SF_INODE_INFO_MAGIC);
3334 AssertPtrReturn(pInodeInfoDst, -EOPNOTSUPP);
3335 Assert(pInodeInfoDst->u32Magic == SF_INODE_INFO_MAGIC);
3336
3337# if RTLNX_VER_MAX(4,11,0)
3338 if (!S_ISREG(pInodeSrc->i_mode) || !S_ISREG(pInodeDst->i_mode))
3339 return S_ISDIR(pInodeSrc->i_mode) || S_ISDIR(pInodeDst->i_mode) ? -EISDIR : -EINVAL;
3340# endif
3341
3342 /*
3343 * Allocate the request and issue it.
3344 */
3345 pReq = (VBOXSFCOPYFILEPARTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
3346 if (pReq) {
3347 int vrc = VbglR0SfHostReqCopyFilePart(pSuperInfoSrc->map.root, pFileInfoSrc->Handle.hHost, offSrc,
3348 pSuperInfoDst->map.root, pFileInfoDst->Handle.hHost, offDst,
3349 cbRange, 0 /*fFlags*/, pReq);
3350 if (RT_SUCCESS(vrc))
3351 cbRet = pReq->Parms.cb64ToCopy.u.value64;
3352 else if (vrc == VERR_NOT_IMPLEMENTED)
3353 cbRet = -EOPNOTSUPP;
3354 else
3355 cbRet = -RTErrConvertToErrno(vrc);
3356
3357 VbglR0PhysHeapFree(pReq);
3358 } else
3359 cbRet = -ENOMEM;
3360 } else {
3361 cbRet = -EOPNOTSUPP;
3362 }
3363 SFLOGFLOW(("vbsf_reg_copy_file_range: returns %zd\n", cbRet));
3364 return cbRet;
3365}
3366#endif /* > 4.5 */
3367
3368
3369#ifdef SFLOG_ENABLED
3370/*
3371 * This is just for logging page faults and such.
3372 */
3373
3374/** Pointer to the ops generic_file_mmap returns the first time it's called. */
3375static struct vm_operations_struct const *g_pGenericFileVmOps = NULL;
3376/** Merge of g_LoggingVmOpsTemplate and g_pGenericFileVmOps. */
3377static struct vm_operations_struct g_LoggingVmOps;
3378
3379
3380/* Generic page fault callback: */
3381# if RTLNX_VER_MIN(4,11,0)
3382static vm_fault_t vbsf_vmlog_fault(struct vm_fault *vmf)
3383{
3384 vm_fault_t rc;
3385 SFLOGFLOW(("vbsf_vmlog_fault: vmf=%p flags=%#x addr=%p\n", vmf, vmf->flags, vmf->address));
3386 rc = g_pGenericFileVmOps->fault(vmf);
3387 SFLOGFLOW(("vbsf_vmlog_fault: returns %d\n", rc));
3388 return rc;
3389}
3390# elif RTLNX_VER_MIN(2,6,23)
3391static int vbsf_vmlog_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
3392{
3393 int rc;
3394# if RTLNX_VER_MIN(4,10,0)
3395 SFLOGFLOW(("vbsf_vmlog_fault: vma=%p vmf=%p flags=%#x addr=%p\n", vma, vmf, vmf->flags, vmf->address));
3396# else
3397 SFLOGFLOW(("vbsf_vmlog_fault: vma=%p vmf=%p flags=%#x addr=%p\n", vma, vmf, vmf->flags, vmf->virtual_address));
3398# endif
3399 rc = g_pGenericFileVmOps->fault(vma, vmf);
3400 SFLOGFLOW(("vbsf_vmlog_fault: returns %d\n", rc));
3401 return rc;
3402}
3403# endif
3404
3405
3406/* Special/generic page fault handler: */
3407# if RTLNX_VER_MIN(2,6,26)
3408# elif RTLNX_VER_MIN(2,6,1)
3409static struct page *vbsf_vmlog_nopage(struct vm_area_struct *vma, unsigned long address, int *type)
3410{
3411 struct page *page;
3412 SFLOGFLOW(("vbsf_vmlog_nopage: vma=%p address=%p type=%p:{%#x}\n", vma, address, type, type ? *type : 0));
3413 page = g_pGenericFileVmOps->nopage(vma, address, type);
3414 SFLOGFLOW(("vbsf_vmlog_nopage: returns %p\n", page));
3415 return page;
3416}
3417# else
3418static struct page *vbsf_vmlog_nopage(struct vm_area_struct *vma, unsigned long address, int write_access_or_unused)
3419{
3420 struct page *page;
3421 SFLOGFLOW(("vbsf_vmlog_nopage: vma=%p address=%p wau=%d\n", vma, address, write_access_or_unused));
3422 page = g_pGenericFileVmOps->nopage(vma, address, write_access_or_unused);
3423 SFLOGFLOW(("vbsf_vmlog_nopage: returns %p\n", page));
3424 return page;
3425}
3426# endif /* < 2.6.26 */
3427
3428
3429/* Special page fault callback for making something writable: */
3430# if RTLNX_VER_MIN(4,11,0)
3431static vm_fault_t vbsf_vmlog_page_mkwrite(struct vm_fault *vmf)
3432{
3433 vm_fault_t rc;
3434 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: vmf=%p flags=%#x addr=%p\n", vmf, vmf->flags, vmf->address));
3435 rc = g_pGenericFileVmOps->page_mkwrite(vmf);
3436 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: returns %d\n", rc));
3437 return rc;
3438}
3439# elif RTLNX_VER_MIN(2,6,30)
3440static int vbsf_vmlog_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3441{
3442 int rc;
3443# if RTLNX_VER_MIN(4,10,0)
3444 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: vma=%p vmf=%p flags=%#x addr=%p\n", vma, vmf, vmf->flags, vmf->address));
3445# else
3446 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: vma=%p vmf=%p flags=%#x addr=%p\n", vma, vmf, vmf->flags, vmf->virtual_address));
3447# endif
3448 rc = g_pGenericFileVmOps->page_mkwrite(vma, vmf);
3449 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: returns %d\n", rc));
3450 return rc;
3451}
3452# elif RTLNX_VER_MIN(2,6,18)
3453static int vbsf_vmlog_page_mkwrite(struct vm_area_struct *vma, struct page *page)
3454{
3455 int rc;
3456 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: vma=%p page=%p\n", vma, page));
3457 rc = g_pGenericFileVmOps->page_mkwrite(vma, page);
3458 SFLOGFLOW(("vbsf_vmlog_page_mkwrite: returns %d\n", rc));
3459 return rc;
3460}
3461# endif
3462
3463
3464/* Special page fault callback for mapping pages: */
3465# if RTLNX_VER_MIN(5,12,0)
3466static vm_fault_t vbsf_vmlog_map_pages(struct vm_fault *vmf, pgoff_t start, pgoff_t end)
3467{
3468 vm_fault_t rc;
3469 SFLOGFLOW(("vbsf_vmlog_map_pages: vmf=%p (flags=%#x addr=%p) start=%p end=%p\n", vmf, vmf->flags, vmf->address, start, end));
3470 rc = g_pGenericFileVmOps->map_pages(vmf, start, end);
3471 SFLOGFLOW(("vbsf_vmlog_map_pages: returns\n"));
3472 return rc;
3473}
3474# elif RTLNX_VER_MIN(4,10,0)
3475static void vbsf_vmlog_map_pages(struct vm_fault *vmf, pgoff_t start, pgoff_t end)
3476{
3477 SFLOGFLOW(("vbsf_vmlog_map_pages: vmf=%p (flags=%#x addr=%p) start=%p end=%p\n", vmf, vmf->flags, vmf->address, start, end));
3478 g_pGenericFileVmOps->map_pages(vmf, start, end);
3479 SFLOGFLOW(("vbsf_vmlog_map_pages: returns\n"));
3480}
3481# elif RTLNX_VER_MIN(4,8,0)
3482static void vbsf_vmlog_map_pages(struct fault_env *fenv, pgoff_t start, pgoff_t end)
3483{
3484 SFLOGFLOW(("vbsf_vmlog_map_pages: fenv=%p (flags=%#x addr=%p) start=%p end=%p\n", fenv, fenv->flags, fenv->address, start, end));
3485 g_pGenericFileVmOps->map_pages(fenv, start, end);
3486 SFLOGFLOW(("vbsf_vmlog_map_pages: returns\n"));
3487}
3488# elif RTLNX_VER_MIN(3,15,0)
3489static void vbsf_vmlog_map_pages(struct vm_area_struct *vma, struct vm_fault *vmf)
3490{
3491 SFLOGFLOW(("vbsf_vmlog_map_pages: vma=%p vmf=%p (flags=%#x addr=%p)\n", vma, vmf, vmf->flags, vmf->virtual_address));
3492 g_pGenericFileVmOps->map_pages(vma, vmf);
3493 SFLOGFLOW(("vbsf_vmlog_map_pages: returns\n"));
3494}
3495# endif
3496
3497
3498/** Overload template. */
3499static struct vm_operations_struct const g_LoggingVmOpsTemplate = {
3500# if RTLNX_VER_MIN(2,6,23)
3501 .fault = vbsf_vmlog_fault,
3502# endif
3503# if RTLNX_VER_MAX(2,6,26)
3504 .nopage = vbsf_vmlog_nopage,
3505# endif
3506# if RTLNX_VER_MIN(2,6,18)
3507 .page_mkwrite = vbsf_vmlog_page_mkwrite,
3508# endif
3509# if RTLNX_VER_MIN(3,15,0)
3510 .map_pages = vbsf_vmlog_map_pages,
3511# endif
3512};
3513
3514/** file_operations::mmap wrapper for logging purposes. */
3515static int vbsf_reg_mmap(struct file *file, struct vm_area_struct *vma)
3516{
3517 int rc;
3518 SFLOGFLOW(("vbsf_reg_mmap: file=%p vma=%p\n", file, vma));
3519 rc = generic_file_mmap(file, vma);
3520 if (rc == 0) {
3521 /* Merge the ops and template the first time thru (there's a race here). */
3522 if (g_pGenericFileVmOps == NULL) {
3523 uintptr_t const *puSrc1 = (uintptr_t *)vma->vm_ops;
3524 uintptr_t const *puSrc2 = (uintptr_t *)&g_LoggingVmOpsTemplate;
3525 uintptr_t volatile *puDst = (uintptr_t *)&g_LoggingVmOps;
3526 size_t cbLeft = sizeof(g_LoggingVmOps) / sizeof(*puDst);
3527 while (cbLeft-- > 0) {
3528 *puDst = *puSrc2 && *puSrc1 ? *puSrc2 : *puSrc1;
3529 puSrc1++;
3530 puSrc2++;
3531 puDst++;
3532 }
3533 g_pGenericFileVmOps = vma->vm_ops;
3534 vma->vm_ops = &g_LoggingVmOps;
3535 } else if (g_pGenericFileVmOps == vma->vm_ops)
3536 vma->vm_ops = &g_LoggingVmOps;
3537 else
3538 SFLOGFLOW(("vbsf_reg_mmap: Warning: vm_ops=%p, expected %p!\n", vma->vm_ops, g_pGenericFileVmOps));
3539 }
3540 SFLOGFLOW(("vbsf_reg_mmap: returns %d\n", rc));
3541 return rc;
3542}
3543
3544#endif /* SFLOG_ENABLED */
3545
3546
3547/**
3548 * File operations for regular files.
3549 *
3550 * Note on splice_read/splice_write/sendfile:
3551 * - Splice was introduced in 2.6.17. The generic_file_splice_read/write
3552 * methods go thru the page cache, which is undesirable and is why we
3553 * need to cook our own versions of the code as long as we cannot track
3554 * host-side writes and correctly invalidate the guest page-cache.
3555 * - Sendfile reimplemented using splice in 2.6.23.
3556 * - The default_file_splice_read/write no-page-cache fallback functions,
3557 * were introduced in 2.6.31. The write one work in page units.
3558 * - Since linux 3.16 there is iter_file_splice_write that uses iter_write.
3559 * - Since linux 4.9 the generic_file_splice_read function started using
3560 * read_iter.
3561 */
3562struct file_operations vbsf_reg_fops = {
3563 .open = vbsf_reg_open,
3564#if RTLNX_VER_MAX(5,10,0) /* No regular .read/.write for 5.10, only .read_iter/.write_iter or in-kernel reads/writes fail. */
3565 .read = vbsf_reg_read,
3566 .write = vbsf_reg_write,
3567#endif
3568#if RTLNX_VER_MIN(3,16,0)
3569 .read_iter = vbsf_reg_read_iter,
3570 .write_iter = vbsf_reg_write_iter,
3571#elif RTLNX_VER_MIN(2,6,19)
3572 .aio_read = vbsf_reg_aio_read,
3573 .aio_write = vbsf_reg_aio_write,
3574#endif
3575 .release = vbsf_reg_release,
3576#ifdef SFLOG_ENABLED
3577 .mmap = vbsf_reg_mmap,
3578#else
3579 .mmap = generic_file_mmap,
3580#endif
3581#if RTLNX_VER_RANGE(2,6,17, 2,6,31)
3582 .splice_read = vbsf_splice_read,
3583#endif
3584#if RTLNX_VER_MIN(3,16,0)
3585 .splice_write = iter_file_splice_write,
3586#elif RTLNX_VER_MIN(2,6,17)
3587 .splice_write = vbsf_splice_write,
3588#endif
3589#if RTLNX_VER_RANGE(2,5,30, 2,6,23)
3590 .sendfile = vbsf_reg_sendfile,
3591#endif
3592 .llseek = vbsf_reg_llseek,
3593 .fsync = vbsf_reg_fsync,
3594#if RTLNX_VER_MIN(4,5,0)
3595 .copy_file_range = vbsf_reg_copy_file_range,
3596#endif
3597};
3598
3599
3600/**
3601 * Inodes operations for regular files.
3602 */
3603struct inode_operations vbsf_reg_iops = {
3604#if RTLNX_VER_MIN(2,5,18)
3605 .getattr = vbsf_inode_getattr,
3606#else
3607 .revalidate = vbsf_inode_revalidate,
3608#endif
3609 .setattr = vbsf_inode_setattr,
3610};
3611
3612
3613
3614/*********************************************************************************************************************************
3615* Address Space Operations on Regular Files (for mmap, sendfile, direct I/O) *
3616*********************************************************************************************************************************/
3617
3618/**
3619 * Used to read the content of a page into the page cache.
3620 *
3621 * Needed for mmap and reads+writes when the file is mmapped in a
3622 * shared+writeable fashion.
3623 */
3624#if RTLNX_VER_MIN(5,19,0)|| RTLNX_RHEL_RANGE(9,3, 9,99)
3625static int vbsf_read_folio(struct file *file, struct folio *folio)
3626{
3627 struct page *page = &folio->page;
3628#else
3629static int vbsf_readpage(struct file *file, struct page *page)
3630{
3631#endif
3632 struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
3633 int err;
3634
3635 SFLOGFLOW(("vbsf_readpage: inode=%p file=%p page=%p off=%#llx\n", inode, file, page, (uint64_t)page->index << PAGE_SHIFT));
3636 Assert(PageLocked(page));
3637
3638 if (PageUptodate(page)) {
3639 unlock_page(page);
3640 return 0;
3641 }
3642
3643 if (!is_bad_inode(inode)) {
3644 VBOXSFREADPGLSTREQ *pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
3645 if (pReq) {
3646 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
3647 struct vbsf_reg_info *sf_r = file->private_data;
3648 uint32_t cbRead;
3649 int vrc;
3650
3651 pReq->PgLst.offFirstPage = 0;
3652 pReq->PgLst.aPages[0] = page_to_phys(page);
3653 vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root,
3654 pReq,
3655 sf_r->Handle.hHost,
3656 (uint64_t)page->index << PAGE_SHIFT,
3657 PAGE_SIZE,
3658 1 /*cPages*/);
3659
3660 cbRead = pReq->Parms.cb32Read.u.value32;
3661 AssertStmt(cbRead <= PAGE_SIZE, cbRead = PAGE_SIZE);
3662 VbglR0PhysHeapFree(pReq);
3663
3664 if (RT_SUCCESS(vrc)) {
3665 if (cbRead == PAGE_SIZE) {
3666 /* likely */
3667 } else {
3668 uint8_t *pbMapped = (uint8_t *)kmap(page);
3669 RT_BZERO(&pbMapped[cbRead], PAGE_SIZE - cbRead);
3670 kunmap(page);
3671 /** @todo truncate the inode file size? */
3672 }
3673
3674 flush_dcache_page(page);
3675 SetPageUptodate(page);
3676 unlock_page(page);
3677 return 0;
3678 }
3679 err = -RTErrConvertToErrno(vrc);
3680 } else
3681 err = -ENOMEM;
3682 } else
3683 err = -EIO;
3684 SetPageError(page);
3685 unlock_page(page);
3686 return err;
3687}
3688
3689
3690/**
3691 * Used to write out the content of a dirty page cache page to the host file.
3692 *
3693 * Needed for mmap and writes when the file is mmapped in a shared+writeable
3694 * fashion.
3695 */
3696#if RTLNX_VER_MIN(2,5,52)
3697static int vbsf_writepage(struct page *page, struct writeback_control *wbc)
3698#else
3699static int vbsf_writepage(struct page *page)
3700#endif
3701{
3702 struct address_space *mapping = page->mapping;
3703 struct inode *inode = mapping->host;
3704 struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
3705 struct vbsf_handle *pHandle = vbsf_handle_find(sf_i, VBSF_HANDLE_F_WRITE, VBSF_HANDLE_F_APPEND);
3706 int err;
3707
3708 SFLOGFLOW(("vbsf_writepage: inode=%p page=%p off=%#llx pHandle=%p (%#llx)\n",
3709 inode, page, (uint64_t)page->index << PAGE_SHIFT, pHandle, pHandle ? pHandle->hHost : 0));
3710
3711 if (pHandle) {
3712 struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
3713 VBOXSFWRITEPGLSTREQ *pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
3714 if (pReq) {
3715 uint64_t const cbFile = i_size_read(inode);
3716 uint64_t const offInFile = (uint64_t)page->index << PAGE_SHIFT;
3717 uint32_t const cbToWrite = page->index != (cbFile >> PAGE_SHIFT) ? PAGE_SIZE
3718 : (uint32_t)cbFile & (uint32_t)PAGE_OFFSET_MASK;
3719 int vrc;
3720
3721 pReq->PgLst.offFirstPage = 0;
3722 pReq->PgLst.aPages[0] = page_to_phys(page);
3723 vrc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root,
3724 pReq,
3725 pHandle->hHost,
3726 offInFile,
3727 cbToWrite,
3728 1 /*cPages*/);
3729 sf_i->ModificationTimeAtOurLastWrite = sf_i->ModificationTime;
3730 AssertMsgStmt(pReq->Parms.cb32Write.u.value32 == cbToWrite || RT_FAILURE(vrc), /* lazy bird */
3731 ("%#x vs %#x\n", pReq->Parms.cb32Write, cbToWrite),
3732 vrc = VERR_WRITE_ERROR);
3733 VbglR0PhysHeapFree(pReq);
3734
3735 if (RT_SUCCESS(vrc)) {
3736 /* Update the inode if we've extended the file. */
3737 /** @todo is this necessary given the cbToWrite calc above? */
3738 uint64_t const offEndOfWrite = offInFile + cbToWrite;
3739 if ( offEndOfWrite > cbFile
3740 && offEndOfWrite > i_size_read(inode))
3741 i_size_write(inode, offEndOfWrite);
3742
3743 /* Update and unlock the page. */
3744 if (PageError(page))
3745 ClearPageError(page);
3746 SetPageUptodate(page);
3747 unlock_page(page);
3748
3749 vbsf_handle_release(pHandle, pSuperInfo, "vbsf_writepage");
3750 return 0;
3751 }
3752
3753 /*
3754 * We failed.
3755 */
3756 err = -EIO;
3757 } else
3758 err = -ENOMEM;
3759 vbsf_handle_release(pHandle, pSuperInfo, "vbsf_writepage");
3760 } else {
3761 /** @todo we could re-open the file here and deal with this... */
3762 static uint64_t volatile s_cCalls = 0;
3763 if (s_cCalls++ < 16)
3764 printk("vbsf_writepage: no writable handle for %s..\n", sf_i->path->String.ach);
3765 err = -EIO;
3766 }
3767 SetPageError(page);
3768 unlock_page(page);
3769 return err;
3770}
3771
3772
3773#if RTLNX_VER_MIN(2,6,24)
3774/**
3775 * Called when writing thru the page cache (which we shouldn't be doing).
3776 */
3777static inline void vbsf_write_begin_warn(loff_t pos, unsigned len, unsigned flags)
3778{
3779 /** @todo r=bird: We shouldn't ever get here, should we? Because we don't use
3780 * the page cache for any writes AFAIK. We could just as well use
3781 * simple_write_begin & simple_write_end here if we think we really
3782 * need to have non-NULL function pointers in the table... */
3783 static uint64_t volatile s_cCalls = 0;
3784 if (s_cCalls++ < 16) {
3785 printk("vboxsf: Unexpected call to vbsf_write_begin(pos=%#llx len=%#x flags=%#x)! Please report.\n",
3786 (unsigned long long)pos, len, flags);
3787 RTLogBackdoorPrintf("vboxsf: Unexpected call to vbsf_write_begin(pos=%#llx len=%#x flags=%#x)! Please report.\n",
3788 (unsigned long long)pos, len, flags);
3789# ifdef WARN_ON
3790 WARN_ON(1);
3791# endif
3792 }
3793}
3794
3795# if RTLNX_VER_MIN(5,19,0) || RTLNX_RHEL_RANGE(9,3, 9,99)
3796static int vbsf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
3797 unsigned len, struct page **pagep, void **fsdata)
3798{
3799 vbsf_write_begin_warn(pos, len, 0);
3800 return simple_write_begin(file, mapping, pos, len, pagep, fsdata);
3801}
3802# else
3803static int vbsf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
3804 unsigned len, unsigned flags, struct page **pagep, void **fsdata)
3805{
3806 vbsf_write_begin_warn(pos, len, flags);
3807 return simple_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
3808}
3809# endif
3810
3811#endif /* KERNEL_VERSION >= 2.6.24 */
3812
3813#if RTLNX_VER_MIN(5,14,0)
3814/**
3815 * Companion to vbsf_write_begin (i.e. shouldn't be called).
3816 */
3817static int vbsf_write_end(struct file *file, struct address_space *mapping,
3818 loff_t pos, unsigned int len, unsigned int copied,
3819 struct page *page, void *fsdata)
3820{
3821 static uint64_t volatile s_cCalls = 0;
3822 if (s_cCalls++ < 16)
3823 {
3824 printk("vboxsf: Unexpected call to vbsf_write_end(pos=%#llx len=%#x)! Please report.\n",
3825 (unsigned long long)pos, len);
3826 RTLogBackdoorPrintf("vboxsf: Unexpected call to vbsf_write_end(pos=%#llx len=%#x)! Please report.\n",
3827 (unsigned long long)pos, len);
3828# ifdef WARN_ON
3829 WARN_ON(1);
3830# endif
3831 }
3832 return -ENOTSUPP;
3833}
3834#endif /* KERNEL_VERSION >= 5.14.0 */
3835
3836
3837#if RTLNX_VER_MIN(2,4,10)
3838
3839# ifdef VBOX_UEK
3840# undef iov_iter /* HACK ALERT! Don't put anything needing vbsf_iov_iter after this fun! */
3841# endif
3842
3843/**
3844 * This is needed to make open accept O_DIRECT as well as dealing with direct
3845 * I/O requests if we don't intercept them earlier.
3846 */
3847# if RTLNX_VER_MIN(4, 7, 0) \
3848 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,73, 4,4,74) /** @todo Figure out when exactly. */) \
3849 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,75, 4,4,90) /** @todo Figure out when exactly. */) \
3850 || (defined(CONFIG_SUSE_KERNEL) && RTLNX_VER_RANGE(4,4,92, 4,5,0) /** @todo Figure out when exactly. */)
3851static ssize_t vbsf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
3852# elif RTLNX_VER_MIN(4, 1, 0)
3853static ssize_t vbsf_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
3854# elif RTLNX_VER_MIN(3, 16, 0) || defined(VBOX_UEK)
3855static ssize_t vbsf_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
3856# elif RTLNX_VER_MIN(2, 6, 6)
3857static ssize_t vbsf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
3858# elif RTLNX_VER_MIN(2, 5, 55)
3859static int vbsf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
3860# elif RTLNX_VER_MIN(2, 5, 41)
3861static int vbsf_direct_IO(int rw, struct file *file, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
3862# elif RTLNX_VER_MIN(2, 5, 35)
3863static int vbsf_direct_IO(int rw, struct inode *inode, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
3864# elif RTLNX_VER_MIN(2, 5, 26)
3865static int vbsf_direct_IO(int rw, struct inode *inode, char *buf, loff_t offset, size_t count)
3866# elif LINUX_VERSION_CODE == KERNEL_VERSION(2, 4, 21) && defined(I_NEW) /* RHEL3 Frankenkernel. */
3867static int vbsf_direct_IO(int rw, struct file *file, struct kiobuf *buf, unsigned long whatever1, int whatever2)
3868# else
3869static int vbsf_direct_IO(int rw, struct inode *inode, struct kiobuf *buf, unsigned long whatever1, int whatever2)
3870# endif
3871{
3872 TRACE();
3873 return -EINVAL;
3874}
3875
3876#endif
3877
3878/**
3879 * Address space (for the page cache) operations for regular files.
3880 *
3881 * @todo the FsPerf touch/flush (mmap) test fails on 4.4.0 (ubuntu 16.04 lts).
3882 */
3883struct address_space_operations vbsf_reg_aops = {
3884#if RTLNX_VER_MIN(5,19,0) || RTLNX_RHEL_RANGE(9,3, 9,99)
3885 .read_folio = vbsf_read_folio,
3886#else
3887 .readpage = vbsf_readpage,
3888#endif
3889 .writepage = vbsf_writepage,
3890 /** @todo Need .writepages if we want msync performance... */
3891#if RTLNX_VER_MIN(5,18,0) || RTLNX_RHEL_RANGE(9,2, 9,99)
3892 .dirty_folio = filemap_dirty_folio,
3893#elif RTLNX_VER_MIN(2,5,12)
3894 .set_page_dirty = __set_page_dirty_buffers,
3895#endif
3896#if RTLNX_VER_MIN(5,14,0)
3897 .write_begin = vbsf_write_begin,
3898 .write_end = vbsf_write_end,
3899#elif RTLNX_VER_MIN(2,6,24)
3900 .write_begin = vbsf_write_begin,
3901 .write_end = simple_write_end,
3902#elif RTLNX_VER_MIN(2,5,45)
3903 .prepare_write = simple_prepare_write,
3904 .commit_write = simple_commit_write,
3905#endif
3906#if RTLNX_VER_MIN(2,4,10)
3907 .direct_IO = vbsf_direct_IO,
3908#endif
3909};
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use