Changeset 77549 in vbox for trunk/src/VBox/Additions

Timestamp:

Mar 4, 2019 10:00:34 AM (6 years ago)

Author:

vboxsync

Message:

linux/vboxsf: Workaround for kernel_read/write calls (get_user_pages fails), fixing issue with sporadic ENOEXEC from execve(). The workaround requires rtR0MemObjLinuxVirtToPage() from memobj-r0drv-linux.c. Various cleanups and adjustments. bugref:9172

Location:

trunk/src/VBox/Additions/linux/sharedfolders

Files:

• dirops.c (modified) (4 diffs)
• regops.c (modified) (24 diffs)
• utils.c (modified) (10 diffs)
• vfsmod.h (modified) (2 diffs)

trunk/src/VBox/Additions/linux/sharedfolders/dirops.c

@@ -29 +29 @@
  */
 
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
 #include "vfsmod.h"
 #include <iprt/err.h>
@@ -780 +784 @@
 
     RT_ZERO(pReq->Create.CreateParms);
-    pReq->Create.CreateParms.Handle      = SHFL_HANDLE_NIL;
-    pReq->Create.CreateParms.CreateFlags = SHFL_CF_ACT_CREATE_IF_NEW
-                                         | SHFL_CF_ACT_FAIL_IF_EXISTS
-                                         | SHFL_CF_ACCESS_READWRITE
-                                         | (fDirectory ? SHFL_CF_DIRECTORY : 0);
-/** @todo use conversion function from utils.c here!   */
-    pReq->Create.CreateParms.Info.Attr.fMode = (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE) | (mode & S_IRWXUGO);
+    pReq->Create.CreateParms.Handle                  = SHFL_HANDLE_NIL;
+    pReq->Create.CreateParms.CreateFlags             = SHFL_CF_ACT_CREATE_IF_NEW
+                                                     | SHFL_CF_ACT_FAIL_IF_EXISTS
+                                                     | SHFL_CF_ACCESS_READWRITE
+                                                     | (fDirectory ? SHFL_CF_DIRECTORY : 0);
+    pReq->Create.CreateParms.Info.Attr.fMode         = (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE)
+                                                     | sf_access_permissions_to_vbox(mode);
     pReq->Create.CreateParms.Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
 
@@ -792 +796 @@
     rc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
     if (RT_FAILURE(rc)) {
-        if (rc == VERR_WRITE_PROTECT) {
-            err = -EROFS;
-            goto fail2;
-        }
-        err = -EPROTO;
-        LogFunc(("(%d): SHFL_FN_CREATE(%s) failed rc=%Rrc\n",
-             fDirectory, sf_parent_i->path->String.utf8, rc));
+        err = -RTErrConvertToErrno(rc);
+        LogFunc(("(%d): SHFL_FN_CREATE(%s) failed rc=%Rrc err=%d\n", fDirectory, sf_parent_i->path->String.utf8, rc, err));
         goto fail2;
     }
@@ -1088 +1087 @@
 
     if (RT_FAILURE(rc)) {
-        if (rc == VERR_WRITE_PROTECT) {
-            err = -EROFS;
-            goto fail1;
-        }
+        err = RTErrConvertFromErrno(rc);
         LogFunc(("VbglR0SfSymlink(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
-        err = -EPROTO;
         goto fail1;
     }

trunk/src/VBox/Additions/linux/sharedfolders/regops.c

@@ -66 +66 @@
 
     RTListForEachSafe(&pInodeInfo->HandleList, pCur, pNext, struct vbsf_handle, Entry) {
-        AssertMsg((pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | vbSF_HANDLE_F_ON_LIST)) == (VBSF_HANDLE_F_MAGIC | vbSF_HANDLE_F_ON_LIST),
-                  ("%p %#x\n", pCur, pCur->fFlags));
-        pCur->fFlags |= vbSF_HANDLE_F_ON_LIST;
+        AssertMsg(   (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
+                  ==                 (VBSF_HANDLE_F_MAGIC      | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
+        pCur->fFlags |= VBSF_HANDLE_F_ON_LIST;
         RTListNodeRemove(&pCur->Entry);
     }
@@ -92 +92 @@
 
     RTListForEach(&pInodeInfo->HandleList, pCur, struct vbsf_handle, Entry) {
-        AssertMsg((pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | vbSF_HANDLE_F_ON_LIST)) == (VBSF_HANDLE_F_MAGIC | vbSF_HANDLE_F_ON_LIST),
-                  ("%p %#x\n", pCur, pCur->fFlags));
+        AssertMsg(   (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
+                  ==                 (VBSF_HANDLE_F_MAGIC      | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
         if ((pCur->fFlags & (fFlagsSet | fFlagsClear)) == fFlagsSet) {
             uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
@@ -137 +137 @@
     Assert(pHandle->pInodeInfo && pHandle->pInodeInfo->u32Magic == SF_INODE_INFO_MAGIC);
 
-    if (pHandle->fFlags & vbSF_HANDLE_F_ON_LIST) {
-        pHandle->fFlags &= ~vbSF_HANDLE_F_ON_LIST;
+    if (pHandle->fFlags & VBSF_HANDLE_F_ON_LIST) {
+        pHandle->fFlags &= ~VBSF_HANDLE_F_ON_LIST;
         RTListNodeRemove(&pHandle->Entry);
     }
@@ -171 +171 @@
 
     SFLOGFLOW(("vbsf_handle_append: %p (to %p)\n", pHandle, pInodeInfo));
-    AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | vbSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
-          ("%p %#x\n", pHandle, pHandle->fFlags));
+    AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
+              ("%p %#x\n", pHandle, pHandle->fFlags));
     Assert(pInodeInfo->u32Magic == SF_INODE_INFO_MAGIC);
 
     spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
 
-    AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | vbSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
+    AssertMsg((pHandle->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST)) == VBSF_HANDLE_F_MAGIC,
           ("%p %#x\n", pHandle, pHandle->fFlags));
 #ifdef VBOX_STRICT
     RTListForEach(&pInodeInfo->HandleList, pCur, struct vbsf_handle, Entry) {
         Assert(pCur != pHandle);
-        AssertMsg((pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | vbSF_HANDLE_F_ON_LIST)) == (VBSF_HANDLE_F_MAGIC | vbSF_HANDLE_F_ON_LIST),
-              ("%p %#x\n", pCur, pCur->fFlags));
+        AssertMsg(   (pCur->fFlags & (VBSF_HANDLE_F_MAGIC_MASK | VBSF_HANDLE_F_ON_LIST))
+                  ==                  (VBSF_HANDLE_F_MAGIC     | VBSF_HANDLE_F_ON_LIST), ("%p %#x\n", pCur, pCur->fFlags));
     }
     pHandle->pInodeInfo = pInodeInfo;
 #endif
 
-    pHandle->fFlags |= vbSF_HANDLE_F_ON_LIST;
+    pHandle->fFlags |= VBSF_HANDLE_F_ON_LIST;
     RTListAppend(&pInodeInfo->HandleList, &pHandle->Entry);
 
@@ -348 +348 @@
 #endif /* 2.6.23 <= LINUX_VERSION_CODE < 2.6.31 */
 
-
-/** Companion to vbsf_lock_user_pages(). */
-DECLINLINE(void) vbsf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty)
-{
-    while (cPages-- > 0)
-    {
-    struct page *pPage = papPages[cPages];
-    if (fSetDirty && !PageReserved(pPage))
-        SetPageDirty(pPage);
+/** Wrapper around put_page / page_cache_release.  */
+DECLINLINE(void) vbsf_put_page(struct page *pPage)
+{
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 6, 0)
     put_page(pPage);
@@ -362 +356 @@
     page_cache_release(pPage);
 #endif
-    }
+}
+
+
+/** Wrapper around get_page / page_cache_get.  */
+DECLINLINE(void) vbsf_get_page(struct page *pPage)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 6, 0)
+    get_page(pPage);
+#else
+    page_cache_get(pPage);
+#endif
+}
+
+
+/** Companion to vbsf_lock_user_pages(). */
+DECLINLINE(void) vbsf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty, bool fLockPgHack)
+{
+    /* We don't mark kernel pages dirty: */
+    if (fLockPgHack)
+        fSetDirty = false;
+
+    while (cPages-- > 0)
+    {
+        struct page *pPage = papPages[cPages];
+        if (fSetDirty && !PageReserved(pPage))
+            SetPageDirty(pPage);
+        vbsf_put_page(pPage);
+    }
+}
+
+
+/**
+ * Catches kernel_read() and kernel_write() calls and works around them.
+ *
+ * The file_operations::read and file_operations::write callbacks supposedly
+ * hands us the user buffers to read into and write out of.  To allow the kernel
+ * to read and write without allocating buffers in userland, they kernel_read()
+ * and kernel_write() increases the user space address limit before calling us
+ * so that copyin/copyout won't reject it.  Our problem is that get_user_pages()
+ * works on the userspace address space structures and will not be fooled by an
+ * increased addr_limit.
+ *
+ * This code tries to detect this situation and fake get_user_lock() for the
+ * kernel buffer.
+ */
+static int vbsf_lock_user_pages_failed_check_kernel(uintptr_t uPtrFrom, size_t cPages, bool fWrite, int rcFailed,
+                                                    struct page **papPages, bool *pfLockPgHack)
+{
+    /*
+     * Check that this is valid user memory that is actually in the kernel range.
+     */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
+    if (   access_ok((void *)uPtrFrom, cPages << PAGE_SHIFT)
+        && uPtrFrom >= USER_DS.seg)
+#else
+    if (   access_ok(fWrite ? VERIFY_WRITE : VERIFY_READ, (void *)uPtrFrom, cPages << PAGE_SHIFT)
+        && uPtrFrom >= USER_DS.seg)
+#endif
+    {
+        uintptr_t const uPtrLast = (uPtrFrom & ~(uintptr_t)PAGE_OFFSET_MASK) + (cPages << PAGE_SHIFT) - 1;
+        uint8_t        *pbPage   = (uint8_t *)uPtrLast;
+        size_t          iPage    = cPages;
+
+        /*
+         * Touch the pages first (paranoia^2).
+         */
+        if (fWrite) {
+            uint8_t volatile *pbProbe = (uint8_t volatile *)uPtrFrom;
+            while (iPage-- > 0) {
+                *pbProbe = *pbProbe;
+                pbProbe += PAGE_SIZE;
+            }
+        } else {
+            uint8_t const *pbProbe = (uint8_t const *)uPtrFrom;
+            while (iPage-- > 0) {
+                ASMProbeReadByte(pbProbe);
+                pbProbe += PAGE_SIZE;
+            }
+        }
+
+        /*
+         * Get the pages.
+         * Note! Fixes here probably applies to rtR0MemObjNativeLockKernel as well.
+         */
+        iPage = cPages;
+        if (   uPtrFrom >= (unsigned long)__va(0)
+            && uPtrLast <  (unsigned long)high_memory)
+        {
+            /* The physical page mapping area: */
+            while (iPage-- > 0)
+            {
+                struct page *pPage = papPages[iPage] = virt_to_page(pbPage);
+                vbsf_get_page(pPage);
+                pbPage -= PAGE_SIZE;
+            }
+        }
+        else
+        {
+            /* This is vmalloc or some such thing, so go thru page tables: */
+            while (iPage-- > 0)
+            {
+                struct page *pPage = rtR0MemObjLinuxVirtToPage(pbPage);
+                if (pPage) {
+                    papPages[iPage] = pPage;
+                    vbsf_get_page(pPage);
+                    pbPage -= PAGE_SIZE;
+                } else {
+                    while (++iPage < cPages) {
+                        pPage = papPages[iPage];
+                        vbsf_put_page(pPage);
+                    }
+                    return rcFailed;
+                }
+            }
+        }
+        *pfLockPgHack = true;
+        return 0;
+    }
+
+    return rcFailed;
 }
 
 
 /** Wrapper around get_user_pages. */
-DECLINLINE(int) vbsf_lock_user_pages(uintptr_t uPtrFrom, size_t cPages, bool fWrite, struct page **papPages)
+DECLINLINE(int) vbsf_lock_user_pages(uintptr_t uPtrFrom, size_t cPages, bool fWrite, struct page **papPages, bool *pfLockPgHack)
 {
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
@@ -375 +488 @@
     ssize_t cPagesLocked = get_user_pages_unlocked(uPtrFrom, cPages, fWrite, 1 /*force*/, papPages);
 # elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 0, 0)
-    ssize_t cPagesLocked = get_user_pages_unlocked(current, current->mm, uPtrFrom, cPages,
-                               fWrite, 1 /*force*/, papPages);
+    ssize_t cPagesLocked = get_user_pages_unlocked(current, current->mm, uPtrFrom, cPages, fWrite, 1 /*force*/, papPages);
 # else
     struct task_struct *pTask = current;
@@ -384 +496 @@
     up_read(&pTask->mm->mmap_sem);
 # endif
+    *pfLockPgHack = false;
     if (cPagesLocked == cPages)
         return 0;
+
+    /*
+     * It failed.
+     */
     if (cPagesLocked < 0)
-        return cPagesLocked;
-
-    vbsf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/);
+        return vbsf_lock_user_pages_failed_check_kernel(uPtrFrom, cPages, fWrite, (int)cPagesLocked, papPages, pfLockPgHack);
+
+    vbsf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/, false /*fLockPgHack*/);
 
     /* We could use uPtrFrom + cPagesLocked to get the correct status here... */
@@ -444 +561 @@
  * write directly to them.
  */
-static ssize_t vbsf_reg_read_fallback(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off,
-                                      struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r)
+static ssize_t vbsf_reg_read_locking(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off,
+                                     struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r)
 {
     /*
@@ -461 +578 @@
     size_t              cPages       = (((uintptr_t)buf & PAGE_OFFSET_MASK) + size + PAGE_OFFSET_MASK) >> PAGE_SHIFT;
     size_t              cMaxPages    = RT_MIN(RT_MAX(sf_g->cMaxIoPages, 1), cPages);
+    bool                fLockPgHack;
 
     pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
@@ -486 +604 @@
             }
 
-            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, true /*fWrite*/, papPages);
+            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, true /*fWrite*/, papPages, &fLockPgHack);
             if (rc == 0) {
                 size_t iPage = cPages;
@@ -492 +610 @@
                     pReq->PgLst.aPages[iPage] = page_to_phys(papPages[iPage]);
             } else {
+                /** @todo may need fallback here for kernel addresses during exec. sigh.   */
                 cbRet = rc;
                 break;
@@ -501 +620 @@
             rc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
 
-            vbsf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/);
+            vbsf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/, fLockPgHack);
 
             if (RT_SUCCESS(rc)) {
@@ -647 +766 @@
 #endif
 
-    return vbsf_reg_read_fallback(file, buf, size, off, sf_g, sf_r);
+    return vbsf_reg_read_locking(file, buf, size, off, sf_g, sf_r);
 }
 
@@ -683 +802 @@
  * write directly to them.
  */
-static ssize_t vbsf_reg_write_fallback(struct file *file, const char /*__user*/ *buf, size_t size, loff_t *off, loff_t offFile,
-                                       struct inode *inode, struct vbsf_inode_info *sf_i,
-                                       struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r)
+static ssize_t vbsf_reg_write_locking(struct file *file, const char /*__user*/ *buf, size_t size, loff_t *off, loff_t offFile,
+                                      struct inode *inode, struct vbsf_inode_info *sf_i,
+                                      struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r)
 {
     /*
@@ -700 +819 @@
     size_t               cPages       = (((uintptr_t)buf & PAGE_OFFSET_MASK) + size + PAGE_OFFSET_MASK) >> PAGE_SHIFT;
     size_t               cMaxPages    = RT_MIN(RT_MAX(sf_g->cMaxIoPages, 1), cPages);
+    bool                 fLockPgHack;
 
     pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
@@ -725 +845 @@
             }
 
-            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, false /*fWrite*/, papPages);
+            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, false /*fWrite*/, papPages, &fLockPgHack);
             if (rc == 0) {
                 size_t iPage = cPages;
@@ -740 +860 @@
             rc = VbglR0SfHostReqWritePgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
 
-            vbsf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/);
+            vbsf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/, fLockPgHack);
 
             if (RT_SUCCESS(rc)) {
@@ -921 +1041 @@
 #endif
 
-    return vbsf_reg_write_fallback(file, buf, size, off, pos, inode, sf_i, sf_g, sf_r);
+    return vbsf_reg_write_locking(file, buf, size, off, pos, inode, sf_i, sf_g, sf_r);
 }
 
@@ -1262 +1382 @@
 
     SFLOGFLOW(("vbsf_readpage: inode=%p file=%p page=%p off=%#llx\n", inode, file, page, (uint64_t)page->index << PAGE_SHIFT));
+    Assert(PageLocked(page));
+
+    if (PageUptodate(page)) {
+        unlock_page(page);
+        return 0;
+    }
 
     if (!is_bad_inode(inode)) {
@@ -1267 +1393 @@
         if (pReq) {
             struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-            struct vbsf_reg_info     *sf_r = file->private_data;
-            uint32_t            cbRead;
+            struct vbsf_reg_info   *sf_r = file->private_data;
+            uint32_t                cbRead;
             int                     vrc;
 
@@ -1296 +1422 @@
                 flush_dcache_page(page);
                 SetPageUptodate(page);
-                err = 0;
-            } else
-                err = -EPROTO;
+                unlock_page(page);
+                return 0;
+            }
+            err = -RTErrConvertToErrno(vrc);
         } else
             err = -ENOMEM;
     } else
         err = -EIO;
+    SetPageError(page);
     unlock_page(page);
     return err;
@@ -1319 +1447 @@
     struct inode           *inode   = mapping->host;
     struct vbsf_inode_info *sf_i    = VBSF_GET_INODE_INFO(inode);
-    struct vbsf_handle       *pHandle = vbsf_handle_find(sf_i, VBSF_HANDLE_F_WRITE, VBSF_HANDLE_F_APPEND);
+    struct vbsf_handle     *pHandle = vbsf_handle_find(sf_i, VBSF_HANDLE_F_WRITE, VBSF_HANDLE_F_APPEND);
     int                     err;
 
     SFLOGFLOW(("vbsf_writepage: inode=%p page=%p off=%#llx pHandle=%p (%#llx)\n",
-           inode, page,(uint64_t)page->index << PAGE_SHIFT, pHandle, pHandle->hHost));
+               inode, page,(uint64_t)page->index << PAGE_SHIFT, pHandle, pHandle->hHost));
 
     if (pHandle) {
@@ -1338 +1466 @@
             pReq->PgLst.aPages[0]    = page_to_phys(page);
             vrc = VbglR0SfHostReqWritePgLst(sf_g->map.root,
-                            pReq,
-                            pHandle->hHost,
-                            offInFile,
-                            cbToWrite,
-                            1 /*cPages*/);
+                                            pReq,
+                                            pHandle->hHost,
+                                            offInFile,
+                                            cbToWrite,
+                                            1 /*cPages*/);
             AssertMsgStmt(pReq->Parms.cb32Write.u.value32 == cbToWrite || RT_FAILURE(vrc), /* lazy bird */
-                      ("%#x vs %#x\n", pReq->Parms.cb32Write, cbToWrite),
-                      vrc = VERR_WRITE_ERROR);
+                          ("%#x vs %#x\n", pReq->Parms.cb32Write, cbToWrite),
+                          vrc = VERR_WRITE_ERROR);
             VbglR0PhysHeapFree(pReq);
 

trunk/src/VBox/Additions/linux/sharedfolders/utils.c

@@ -37 +37 @@
 
 
+int vbsf_nlscpy(struct vbsf_super_info *sf_g, char *name, size_t name_bound_len, const unsigned char *utf8_name, size_t utf8_len)
+{
+    if (sf_g->nls) {
+        const char *in;
+        char *out;
+        size_t out_len;
+        size_t out_bound_len;
+        size_t in_bound_len;
+
+        in = utf8_name;
+        in_bound_len = utf8_len;
+
+        out = name;
+        out_len = 0;
+        out_bound_len = name_bound_len;
+
+        while (in_bound_len) {
+            int nb;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
+            unicode_t uni;
+
+            nb = utf8_to_utf32(in, in_bound_len, &uni);
+#else
+            linux_wchar_t uni;
+
+            nb = utf8_mbtowc(&uni, in, in_bound_len);
+#endif
+            if (nb < 0) {
+                LogFunc(("utf8_mbtowc failed(%s) %x:%d\n", (const char *)utf8_name, *in, in_bound_len));
+                return -EINVAL;
+            }
+            in += nb;
+            in_bound_len -= nb;
+
+            nb = sf_g->nls->uni2char(uni, out, out_bound_len);
+            if (nb < 0) {
+                LogFunc(("nls->uni2char failed(%s) %x:%d\n", utf8_name, uni, out_bound_len));
+                return nb;
+            }
+            out += nb;
+            out_bound_len -= nb;
+            out_len += nb;
+        }
+
+        *out = 0;
+    } else {
+        if (utf8_len + 1 > name_bound_len)
+            return -ENAMETOOLONG;
+
+        memcpy(name, utf8_name, utf8_len + 1);
+    }
+    return 0;
+}
+
+
 /**
  * Convert from VBox to linux time.
@@ -82 +137 @@
 
 /**
- * Converts Linux access permissions to VBox ones (mode & 0777).
+ * Converts VBox access permissions  to Linux ones (mode & 0777).
  *
  * @note Currently identical.
- */
-DECLINLINE(uint32_t) sf_access_permissions_to_vbox(int fAttr)
+ * @sa   sf_access_permissions_to_vbox
+ */
+DECLINLINE(int) sf_access_permissions_to_linux(uint32_t fAttr)
 {
     /* Access bits should be the same: */
@@ -104 +160 @@
 
 /**
- * Converts VBox access permissions  to Linux ones (mode & 0777).
- *
- * @note Currently identical.
- */
-DECLINLINE(int) sf_access_permissions_to_linux(uint32_t fAttr)
-{
-    /* Access bits should be the same: */
-    AssertCompile(RTFS_UNIX_IRUSR == S_IRUSR);
-    AssertCompile(RTFS_UNIX_IWUSR == S_IWUSR);
-    AssertCompile(RTFS_UNIX_IXUSR == S_IXUSR);
-    AssertCompile(RTFS_UNIX_IRGRP == S_IRGRP);
-    AssertCompile(RTFS_UNIX_IWGRP == S_IWGRP);
-    AssertCompile(RTFS_UNIX_IXGRP == S_IXGRP);
-    AssertCompile(RTFS_UNIX_IROTH == S_IROTH);
-    AssertCompile(RTFS_UNIX_IWOTH == S_IWOTH);
-    AssertCompile(RTFS_UNIX_IXOTH == S_IXOTH);
-
-    return fAttr & RTFS_UNIX_ALL_ACCESS_PERMS;
-}
-
-
-/**
  * Produce the Linux mode mask, given VBox, mount options and file type.
  */
@@ -205 +239 @@
     sf_i->BirthTime = pObjInfo->BirthTime;
 }
+
 
 /**
@@ -328 +363 @@
     return rc;
 }
+
 
 /**
@@ -395 +431 @@
                              * Reset the TTL and copy the info over into the inode structure.
                              */
-                            vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info,
-                                    sf_g, true /*fInodeLocked??*/);
+                            vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info, sf_g, true /*fInodeLocked??*/);
                             rc = 0;
                         } else {
@@ -485 +520 @@
 }
 
+
 /* on 2.6 this is a proxy for [sf_inode_revalidate] which (as a side
    effect) updates inode attributes for [dentry] (given that [dentry]
@@ -572 +608 @@
 }
 
+
 int vbsf_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 {
@@ -742 +779 @@
 }
 
+
 /**
  * [dentry] contains string encoded in coding system that corresponds
@@ -824 +862 @@
     kfree(name);
     return err;
-}
-
-int vbsf_nlscpy(struct vbsf_super_info *sf_g, char *name, size_t name_bound_len, const unsigned char *utf8_name, size_t utf8_len)
-{
-    if (sf_g->nls) {
-        const char *in;
-        char *out;
-        size_t out_len;
-        size_t out_bound_len;
-        size_t in_bound_len;
-
-        in = utf8_name;
-        in_bound_len = utf8_len;
-
-        out = name;
-        out_len = 0;
-        out_bound_len = name_bound_len;
-
-        while (in_bound_len) {
-            int nb;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
-            unicode_t uni;
-
-            nb = utf8_to_utf32(in, in_bound_len, &uni);
-#else
-            linux_wchar_t uni;
-
-            nb = utf8_mbtowc(&uni, in, in_bound_len);
-#endif
-            if (nb < 0) {
-                LogFunc(("utf8_mbtowc failed(%s) %x:%d\n", (const char *)utf8_name, *in, in_bound_len));
-                return -EINVAL;
-            }
-            in += nb;
-            in_bound_len -= nb;
-
-            nb = sf_g->nls->uni2char(uni, out, out_bound_len);
-            if (nb < 0) {
-                LogFunc(("nls->uni2char failed(%s) %x:%d\n", utf8_name, uni, out_bound_len));
-                return nb;
-            }
-            out += nb;
-            out_bound_len -= nb;
-            out_len += nb;
-        }
-
-        *out = 0;
-    } else {
-        if (utf8_len + 1 > name_bound_len)
-            return -ENAMETOOLONG;
-
-        memcpy(name, utf8_name, utf8_len + 1);
-    }
-    return 0;
 }
 

trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h

@@ -166 +166 @@
 #define VBSF_HANDLE_F_FILE        UINT32_C(0x00000010)
 #define VBSF_HANDLE_F_DIR         UINT32_C(0x00000020)
-#define vbSF_HANDLE_F_ON_LIST     UINT32_C(0x00000080)
+#define VBSF_HANDLE_F_ON_LIST     UINT32_C(0x00000080)
 #define VBSF_HANDLE_F_MAGIC_MASK  UINT32_C(0xffffff00)
 #define VBSF_HANDLE_F_MAGIC       UINT32_C(0x75030700) /**< Maurice Ravel (1875-03-07). */
@@ -370 +370 @@
 
 
+/**
+ * Converts Linux access permissions to VBox ones (mode & 0777).
+ *
+ * @note Currently identical.
+ * @sa   sf_access_permissions_to_linux
+ */
+DECLINLINE(uint32_t) sf_access_permissions_to_vbox(int fAttr)
+{
+    /* Access bits should be the same: */
+    AssertCompile(RTFS_UNIX_IRUSR == S_IRUSR);
+    AssertCompile(RTFS_UNIX_IWUSR == S_IWUSR);
+    AssertCompile(RTFS_UNIX_IXUSR == S_IXUSR);
+    AssertCompile(RTFS_UNIX_IRGRP == S_IRGRP);
+    AssertCompile(RTFS_UNIX_IWGRP == S_IWGRP);
+    AssertCompile(RTFS_UNIX_IXGRP == S_IXGRP);
+    AssertCompile(RTFS_UNIX_IROTH == S_IROTH);
+    AssertCompile(RTFS_UNIX_IWOTH == S_IWOTH);
+    AssertCompile(RTFS_UNIX_IXOTH == S_IXOTH);
+
+    return fAttr & RTFS_UNIX_ALL_ACCESS_PERMS;
+}
+
 #if 1
 # define TRACE()          LogFunc(("tracepoint\n"))