regops.c@ 97658

最後變更在這個檔案從97658是 97571,由 vboxsync 提交於 2 年前
Additions: Linux: vboxfs: Fix for Fedora 5.17.7-300 kernel, bugref:10209.
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 149.4 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: