regops.c@ 100068

Last change on this file since 100068 was 99667, checked in by vboxsync, 22 months ago
Additions: Linux: vboxsf: Introduce initial support for kernel 6.4 (rename macro), bugref:10441.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 149.7 KB

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

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

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

Download in other formats: