Changeset 77951 in vbox for trunk

Timestamp:

Mar 29, 2019 1:26:53 PM (6 years ago)

Author:

vboxsync

Message:

linux/vboxsf: sf_g -> pSuperInfo. bugref:9172

Location:

trunk/src/VBox/Additions/linux/sharedfolders

Files:

• dirops.c (modified) (39 diffs)
• lnkops.c (modified) (3 diffs)
• regops.c (modified) (47 diffs)
• utils.c (modified) (36 diffs)
• vfsmod.c (modified) (25 diffs)
• vfsmod.h (modified) (6 diffs)

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

@@ -51 +51 @@
 static int vbsf_dir_open(struct inode *inode, struct file *file)
 {
-    struct vbsf_super_info *sf_g   = VBSF_GET_SUPER_INFO(inode->i_sb);
-    struct vbsf_inode_info *sf_i   = VBSF_GET_INODE_INFO(inode);
-    struct dentry          *dentry = VBSF_GET_F_DENTRY(file);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+    struct dentry          *dentry     = VBSF_GET_F_DENTRY(file);
     struct vbsf_dir_info   *sf_d;
     int                     rc;
 
     SFLOGFLOW(("vbsf_dir_open: inode=%p file=%p %s\n", inode, file, sf_i && sf_i->path ? sf_i->path->String.ach : NULL));
-    AssertReturn(sf_g, -EINVAL);
+    AssertReturn(pSuperInfo, -EINVAL);
     AssertReturn(sf_i, -EINVAL);
     AssertReturn(!file->private_data, 0);
@@ -88 +88 @@
             LogFunc(("calling VbglR0SfHostReqCreate on folder %s, flags %#x\n",
                      sf_i->path->String.utf8, pReq->CreateParms.CreateFlags));
-            rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
+            rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
             if (RT_SUCCESS(rc)) {
                 if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
@@ -97 +97 @@
                      * dentry cache chain that got us here.
                      */
-                    vbsf_update_inode(inode, sf_i, &pReq->CreateParms.Info, sf_g, true /*fLocked*/ /** @todo inode locking */);
+                    vbsf_update_inode(inode, sf_i, &pReq->CreateParms.Info, pSuperInfo, true /*fLocked*/ /** @todo inode locking */);
                     vbsf_dentry_chain_increase_ttl(dentry);
 
@@ -154 +154 @@
 
     if (sf_d) {
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
 
         /* Invalidate the non-handle part. */
@@ -168 +168 @@
 
         /* Closes the handle and frees the structure when the last reference is released. */
-        vbsf_handle_release(&sf_d->Handle, sf_g, "vbsf_dir_release");
+        vbsf_handle_release(&sf_d->Handle, pSuperInfo, "vbsf_dir_release");
     }
 
@@ -201 +201 @@
  * @returns 0 on success, negative errno on error,
  */
-static int vbsf_dir_read_more(struct vbsf_dir_info *sf_d, struct vbsf_super_info *sf_g, bool fRestart)
+static int vbsf_dir_read_more(struct vbsf_dir_info *sf_d, struct vbsf_super_info *pSuperInfo, bool fRestart)
 {
     int               rc;
@@ -224 +224 @@
         /* Likely, except for the first time. */
     } else {
-        sf_d->pBuf = (PSHFLDIRINFO)kmalloc(sf_g->cbDirBuf, GFP_KERNEL);
+        sf_d->pBuf = (PSHFLDIRINFO)kmalloc(pSuperInfo->cbDirBuf, GFP_KERNEL);
         if (sf_d->pBuf)
-            sf_d->cbBuf = sf_g->cbDirBuf;
+            sf_d->cbBuf = pSuperInfo->cbDirBuf;
         else {
             sf_d->pBuf = (PSHFLDIRINFO)kmalloc(_4K, GFP_KERNEL);
@@ -242 +242 @@
     pReq = (VBOXSFLISTDIRREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
     if (pReq) {
-        rc = VbglR0SfHostReqListDirContig2x(sf_g->map.root, pReq, sf_d->Handle.hHost, NULL, NIL_RTGCPHYS64,
+        rc = VbglR0SfHostReqListDirContig2x(pSuperInfo->map.root, pReq, sf_d->Handle.hHost, NULL, NIL_RTGCPHYS64,
                                             fRestart ? SHFL_LIST_RESTART : SHFL_LIST_NONE,
                                             sf_d->pBuf, virt_to_phys(sf_d->pBuf), sf_d->cbBuf);
@@ -285 +285 @@
 # endif
                                                const char *pszSrcName, uint16_t cchSrcName, ino_t d_ino, int d_type,
-                                               struct vbsf_super_info *sf_g)
+                                               struct vbsf_super_info *pSuperInfo)
 {
     char szDstName[NAME_MAX];
-    int rc = vbsf_nlscpy(sf_g, szDstName, sizeof(szDstName), pszSrcName, cchSrcName);
+    int rc = vbsf_nlscpy(pSuperInfo, szDstName, sizeof(szDstName), pszSrcName, cchSrcName);
     if (rc == 0) {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
@@ -337 +337 @@
     loff_t                  offPos = dir->f_pos;
 #endif
-    struct vbsf_dir_info   *sf_d   = (struct vbsf_dir_info *)dir->private_data;
-    struct vbsf_super_info *sf_g   = VBSF_GET_SUPER_INFO(VBSF_GET_F_DENTRY(dir)->d_sb);
+    struct vbsf_dir_info   *sf_d       = (struct vbsf_dir_info *)dir->private_data;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(VBSF_GET_F_DENTRY(dir)->d_sb);
     int                     rc;
 
@@ -358 +358 @@
         loff_t offCurEntry = sf_d->offPos;
         if (offPos < offCurEntry) {
-            rc = vbsf_dir_read_more(sf_d, sf_g, true /*fRestart*/);
+            rc = vbsf_dir_read_more(sf_d, pSuperInfo, true /*fRestart*/);
             if (rc == 0)
                 offCurEntry = 0;
@@ -375 +375 @@
                 sf_d->offPos       = offCurEntry;
                 sf_d->cEntriesLeft = 0;
-                rc = vbsf_dir_read_more(sf_d, sf_g, false /*fRestart*/);
+                rc = vbsf_dir_read_more(sf_d, pSuperInfo, false /*fRestart*/);
                 if (rc != 0 || sf_d->cEntriesLeft == 0) {
                     up(&sf_d->Lock);
@@ -459 +459 @@
         uint32_t cEntriesLeft = sf_d->cEntriesLeft;
         if (!cEntriesLeft) {
-            rc = vbsf_dir_read_more(sf_d, sf_g, false /*fRestart*/);
+            rc = vbsf_dir_read_more(sf_d, pSuperInfo, false /*fRestart*/);
             if (rc == 0) {
                 cEntriesLeft = sf_d->cEntriesLeft;
@@ -504 +504 @@
                 ino_t const d_ino  = (ino_t)offPos + 0xbeef; /* very fake */
                 bool        fContinue;
-                if (sf_g->fNlsIsUtf8) {
+                if (pSuperInfo->fNlsIsUtf8) {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
                     fContinue = dir_emit(ctx, pEntry->name.String.ach, cchSrcName, d_ino, d_type);
@@ -512 +512 @@
                 } else {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-                    fContinue = vbsf_dir_emit_nls(ctx, pEntry->name.String.ach, cchSrcName, d_ino, d_type, sf_g);
+                    fContinue = vbsf_dir_emit_nls(ctx, pEntry->name.String.ach, cchSrcName, d_ino, d_type, pSuperInfo);
 #else
                     fContinue = vbsf_dir_emit_nls(opaque, filldir, offPos, pEntry->name.String.ach, cchSrcName,
-                                                  d_ino, d_type, sf_g);
+                                                  d_ino, d_type, pSuperInfo);
 #endif
                 }
@@ -579 +579 @@
  */
 static struct inode *vbsf_create_inode(struct inode *parent, struct dentry *dentry, PSHFLSTRING path,
-                                       PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g, bool fInstantiate)
+                                       PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *pSuperInfo, bool fInstantiate)
 {
     /*
@@ -606 +606 @@
 
             VBSF_SET_INODE_INFO(pInode, sf_new_i);
-            vbsf_init_inode(pInode, sf_new_i, pObjInfo, sf_g);
+            vbsf_init_inode(pInode, sf_new_i, pObjInfo, pSuperInfo);
 
             /*
@@ -657 +657 @@
                                         )
 {
-    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(parent->i_sb);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(parent->i_sb);
     struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(parent);
     SHFLSTRING             *path;
@@ -671 +671 @@
 #endif
 
-    Assert(sf_g);
+    Assert(pSuperInfo);
     Assert(sf_i && sf_i->u32Magic == SF_INODE_INFO_MAGIC);
 
@@ -677 +677 @@
      * Build the path.  We'll associate the path with dret's inode on success.
      */
-    rc = vbsf_path_from_dentry(sf_g, sf_i, dentry, &path, __func__);
+    rc = vbsf_path_from_dentry(pSuperInfo, sf_i, dentry, &path, __func__);
     if (rc == 0) {
         /*
@@ -692 +692 @@
 
             LogFunc(("Calling VbglR0SfHostReqCreate on %s\n", path->String.utf8));
-            rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
+            rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
             if (RT_SUCCESS(rc)) {
                 if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
@@ -699 +699 @@
                      * the existence of all parent dentries, we increase their TTL.
                      */
-                    pInode = vbsf_create_inode(parent, dentry, path, &pReq->CreateParms.Info, sf_g, false /*fInstantiate*/);
+                    pInode = vbsf_create_inode(parent, dentry, path, &pReq->CreateParms.Info, pSuperInfo, false /*fInstantiate*/);
                     if (rc == 0) {
                         path = NULL; /* given to the inode */
@@ -755 +755 @@
                                   PSHFLFSOBJINFO info, SHFLHANDLE handle)
 {
-    struct vbsf_super_info *sf_g   = VBSF_GET_SUPER_INFO(parent->i_sb);
-    struct inode           *pInode = vbsf_create_inode(parent, dentry, path, info, sf_g, true /*fInstantiate*/);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(parent->i_sb);
+    struct inode           *pInode     = vbsf_create_inode(parent, dentry, path, info, pSuperInfo, true /*fInstantiate*/);
     if (pInode) {
         /* Store this handle if we leave the handle open. */
@@ -791 +791 @@
 #endif
     struct vbsf_inode_info *sf_parent_i = VBSF_GET_INODE_INFO(parent);
-    struct vbsf_super_info *sf_g        = VBSF_GET_SUPER_INFO(parent->i_sb);
+    struct vbsf_super_info *pSuperInfo  = VBSF_GET_SUPER_INFO(parent->i_sb);
     PSHFLSTRING             path;
     int                     rc;
 
     AssertReturn(sf_parent_i, -EINVAL);
-    AssertReturn(sf_g, -EINVAL);
+    AssertReturn(pSuperInfo, -EINVAL);
 
     /*
      * Build a path.  We'll donate this to the inode on success.
      */
-    rc = vbsf_path_from_dentry(sf_g, sf_parent_i, dentry, &path, __func__);
+    rc = vbsf_path_from_dentry(pSuperInfo, sf_parent_i, dentry, &path, __func__);
     if (rc == 0) {
         /*
@@ -822 +822 @@
 
             SFLOGFLOW(("%s calling VbglR0SfHostReqCreate(%s, %#x)\n", pszPrefix, path->String.ach, pReq->Create.CreateParms.CreateFlags));
-            rc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
+            rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, &pReq->Create);
             if (RT_SUCCESS(rc)) {
                 SFLOGFLOW(("%s VbglR0SfHostReqCreate returned %Rrc Result=%d Handle=%#llx\n",
@@ -842 +842 @@
                  */
                 if (pReq->Create.CreateParms.Handle != SHFL_HANDLE_NIL) {
-                    struct inode *pNewInode = vbsf_create_inode(parent, dentry, path, &pReq->Create.CreateParms.Info, sf_g,
+                    struct inode *pNewInode = vbsf_create_inode(parent, dentry, path, &pReq->Create.CreateParms.Info, pSuperInfo,
                                                                 !fDoLookup /*fInstantiate*/);
                     if (pNewInode) {
@@ -868 +868 @@
                     if (fDoLookup) {
                         struct inode *pNewInode = vbsf_create_inode(parent, dentry, path, &pReq->Create.CreateParms.Info,
-                                                                    sf_g, false /*fInstantiate*/);
+                                                                    pSuperInfo, false /*fInstantiate*/);
                         if (pNewInode)
                             vbsf_d_add_inode(dentry, pNewInode);
@@ -893 +893 @@
             if (pReq->Create.CreateParms.Handle != SHFL_HANDLE_NIL) {
                 AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
-                int rc2 = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, pReq->Create.CreateParms.Handle);
+                int rc2 = VbglR0SfHostReqClose(pSuperInfo->map.root, &pReq->Close, pReq->Create.CreateParms.Handle);
                 if (RT_FAILURE(rc2))
                     SFLOGFLOW(("%s VbglR0SfHostReqCloseSimple failed rc=%Rrc\n", pszPrefix, rc2));
@@ -989 +989 @@
                     sf_r = NULL; /* don't free it */
                 } else {
-                    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(pDirInode->i_sb);
+                    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pDirInode->i_sb);
                     SFLOGFLOW(("vbsf_inode_atomic_open: finish_open failed: %d (path='%s'\n", rc, sf_i->path->String.ach));
-                    VbglR0SfHostReqCloseSimple(sf_g->map.root, sf_r->Handle.hHost);
+                    VbglR0SfHostReqCloseSimple(pSuperInfo->map.root, sf_r->Handle.hHost);
                     sf_r->Handle.hHost = SHFL_HANDLE_NIL;
                 }
@@ -1096 +1096 @@
 static int vbsf_unlink_worker(struct inode *parent, struct dentry *dentry, int fDirectory)
 {
-    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(parent->i_sb);
+    struct vbsf_super_info *pSuperInfo  = VBSF_GET_SUPER_INFO(parent->i_sb);
     struct vbsf_inode_info *sf_parent_i = VBSF_GET_INODE_INFO(parent);
     SHFLSTRING *path;
@@ -1103 +1103 @@
     TRACE();
 
-    rc = vbsf_path_from_dentry(sf_g, sf_parent_i, dentry, &path, __func__);
+    rc = vbsf_path_from_dentry(pSuperInfo, sf_parent_i, dentry, &path, __func__);
     if (!rc) {
         VBOXSFREMOVEREQ *pReq = (VBOXSFREMOVEREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String)
@@ -1113 +1113 @@
                 fFlags |= SHFL_REMOVE_SYMLINK;
 
-            rc = VbglR0SfHostReqRemove(sf_g->map.root, pReq, fFlags);
+            rc = VbglR0SfHostReqRemove(pSuperInfo->map.root, pReq, fFlags);
 
             if (dentry->d_inode) {
@@ -1198 +1198 @@
          * Check that they are on the same mount.
          */
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(old_parent->i_sb);
-        if (sf_g == VBSF_GET_SUPER_INFO(new_parent->i_sb)) {
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(old_parent->i_sb);
+        if (pSuperInfo == VBSF_GET_SUPER_INFO(new_parent->i_sb)) {
             /*
              * Build the new path.
@@ -1205 +1205 @@
             struct vbsf_inode_info *sf_new_parent_i = VBSF_GET_INODE_INFO(new_parent);
             PSHFLSTRING             pNewPath;
-            rc = vbsf_path_from_dentry(sf_g, sf_new_parent_i, new_dentry, &pNewPath, __func__);
+            rc = vbsf_path_from_dentry(pSuperInfo, sf_new_parent_i, new_dentry, &pNewPath, __func__);
             if (rc == 0) {
                 /*
@@ -1218 +1218 @@
 
                     memcpy(&pReq->StrDstPath, pNewPath, SHFLSTRING_HEADER_SIZE + pNewPath->u16Size);
-                    rc = VbglR0SfHostReqRenameWithSrcContig(sf_g->map.root, pReq, pOldPath, virt_to_phys(pOldPath), fRename);
+                    rc = VbglR0SfHostReqRenameWithSrcContig(pSuperInfo->map.root, pReq, pOldPath, virt_to_phys(pOldPath), fRename);
                     VbglR0PhysHeapFree(pReq);
                     if (RT_SUCCESS(rc)) {
@@ -1257 +1257 @@
         } else {
             SFLOGFLOW(("vbsf_inode_rename: rename with different roots (%#x vs %#x)\n",
-                       sf_g->map.root, VBSF_GET_SUPER_INFO(new_parent->i_sb)->map.root));
+                       pSuperInfo->map.root, VBSF_GET_SUPER_INFO(new_parent->i_sb)->map.root));
             rc = -EXDEV;
         }
@@ -1294 +1294 @@
     /** @todo we can save a kmalloc here if we switch to embedding the target rather
      * than the symlink path into the request.  Will require more NLS helpers. */
-    struct vbsf_super_info *sf_g    = VBSF_GET_SUPER_INFO(parent->i_sb);
-    PSHFLSTRING             pTarget = NULL;
-    int rc = vbsf_nls_to_shflstring(sf_g, target, &pTarget);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(parent->i_sb);
+    PSHFLSTRING             pTarget    = NULL;
+    int rc = vbsf_nls_to_shflstring(pSuperInfo, target, &pTarget);
     if (rc == 0) {
         /*
@@ -1303 +1303 @@
         struct vbsf_inode_info *sf_i  = VBSF_GET_INODE_INFO(parent);
         PSHFLSTRING             pPath = NULL;
-        rc = vbsf_path_from_dentry(sf_g, sf_i, dentry, &pPath, __func__);
+        rc = vbsf_path_from_dentry(pSuperInfo, sf_i, dentry, &pPath, __func__);
         if (rc == 0) {
             /*
@@ -1314 +1314 @@
                 memcpy(&pReq->StrSymlinkPath, pPath, SHFLSTRING_HEADER_SIZE + pPath->u16Size);
 
-                rc = VbglR0SfHostReqCreateSymlinkContig(sf_g->map.root, pTarget, virt_to_phys(pTarget), pReq);
+                rc = VbglR0SfHostReqCreateSymlinkContig(pSuperInfo->map.root, pTarget, virt_to_phys(pTarget), pReq);
                 if (RT_SUCCESS(rc)) {
                     sf_i->force_restat = 1;

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

@@ -119 +119 @@
         pszTarget = (char *)kzalloc(PAGE_SIZE, GFP_KERNEL);
         if (pszTarget) {
-            struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-            struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
-            int rc = VbglR0SfHostReqReadLinkContigSimple(sf_g->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
+            struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+            struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+            int rc = VbglR0SfHostReqReadLinkContigSimple(pSuperInfo->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
                                                          pszTarget, virt_to_phys(pszTarget), RT_MIN(PATH_MAX, PAGE_SIZE - 1));
             if (RT_SUCCESS(rc)) {
                 pszTarget[PAGE_SIZE - 1] = '\0';
                 SFLOGFLOW(("vbsf_get_link: %s -> %s\n", sf_i->path->String.ach, pszTarget));
-                rc = vbsf_symlink_nls_convert(sf_g, pszTarget, PAGE_SIZE);
+                rc = vbsf_symlink_nls_convert(pSuperInfo, pszTarget, PAGE_SIZE);
                 if (rc == 0) {
                     vbsf_dentry_chain_increase_ttl(dentry);
@@ -157 +157 @@
     if (pszTarget) {
         struct inode           *inode = dentry->d_inode;
-        struct vbsf_super_info *sf_g  = VBSF_GET_SUPER_INFO(inode->i_sb);
-        struct vbsf_inode_info *sf_i  = VBSF_GET_INODE_INFO(inode);
-        rc = VbglR0SfHostReqReadLinkContigSimple(sf_g->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+        struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+        rc = VbglR0SfHostReqReadLinkContigSimple(pSuperInfo->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
                                                  pszTarget, virt_to_phys(pszTarget), RT_MIN(PATH_MAX, PAGE_SIZE - 1));
         if (RT_SUCCESS(rc)) {
             pszTarget[PAGE_SIZE - 1] = '\0';
             SFLOGFLOW(("vbsf_readlink: %s -> %*s\n", sf_i->path->String.ach, pszTarget));
-            rc = vbsf_symlink_nls_convert(sf_g, pszTarget, PAGE_SIZE);
+            rc = vbsf_symlink_nls_convert(pSuperInfo, pszTarget, PAGE_SIZE);
             if (rc == 0) {
                 vbsf_dentry_chain_increase_ttl(dentry);
@@ -195 +195 @@
     if (pszTarget) {
         struct inode           *inode = dentry->d_inode;
-        struct vbsf_super_info *sf_g  = VBSF_GET_SUPER_INFO(inode->i_sb);
-        struct vbsf_inode_info *sf_i  = VBSF_GET_INODE_INFO(inode);
-
-        rc = VbglR0SfHostReqReadLinkContigSimple(sf_g->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+        struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+
+        rc = VbglR0SfHostReqReadLinkContigSimple(pSuperInfo->map.root, sf_i->path->String.ach, sf_i->path->u16Length,
                                                  pszTarget, virt_to_phys(pszTarget), RT_MIN(PATH_MAX, PAGE_SIZE - 1));
         if (RT_SUCCESS(rc)) {
             pszTarget[PAGE_SIZE - 1] = '\0';
             SFLOGFLOW(("vbsf_follow_link: %s -> %s\n", sf_i->path->String.ach, pszTarget));
-            rc = vbsf_symlink_nls_convert(sf_g, pszTarget, PAGE_SIZE);
+            rc = vbsf_symlink_nls_convert(pSuperInfo, pszTarget, PAGE_SIZE);
             if (rc == 0) {
                 /*

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

@@ -447 +447 @@
  *
  * @returns 0 (ref count).
- * @param   pHandle         The handle to release.
- * @param   sf_g            The info structure for the shared folder associated
- *                  with the handle.
- * @param   pszCaller       The caller name (for logging failures).
- */
-uint32_t vbsf_handle_release_slow(struct vbsf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
+ * @param   pHandle     The handle to release.
+ * @param   pSuperInfo  The info structure for the shared folder associated with
+ *                      the handle.
+ * @param   pszCaller   The caller name (for logging failures).
+ */
+uint32_t vbsf_handle_release_slow(struct vbsf_handle *pHandle, struct vbsf_super_info *pSuperInfo, const char *pszCaller)
 {
     int rc;
@@ -478 +478 @@
      * Actually destroy it.
      */
-    rc = VbglR0SfHostReqCloseSimple(sf_g->map.root, pHandle->hHost);
+    rc = VbglR0SfHostReqCloseSimple(pSuperInfo->map.root, pHandle->hHost);
     if (RT_FAILURE(rc))
         LogFunc(("Caller %s: VbglR0SfHostReqCloseSimple %#RX64 failed with rc=%Rrc\n", pszCaller, pHandle->hHost, rc));
@@ -537 +537 @@
  * already.
  */
-DECLINLINE(bool) vbsf_should_use_cached_read(struct file *file, struct address_space *mapping, struct vbsf_super_info *sf_g)
+DECLINLINE(bool) vbsf_should_use_cached_read(struct file *file, struct address_space *mapping, struct vbsf_super_info *pSuperInfo)
 {
     return mapping
@@ -543 +543 @@
         && mapping_writably_mapped(mapping)
         && !(file->f_flags & O_DIRECT)
-        && 1 /** @todo make this behaviour configurable at mount time (sf_g) */;
+        && 1 /** @todo make this behaviour configurable at mount time (pSuperInfo) */;
 }
 
@@ -757 +757 @@
 static ssize_t vbsf_splice_read(struct file *file, loff_t *poffset, struct pipe_inode_info *pipe, size_t len, unsigned int flags)
 {
-    struct inode           *inode = VBSF_GET_F_DENTRY(file)->d_inode;
-    struct vbsf_super_info *sf_g  = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct inode           *inode      = VBSF_GET_F_DENTRY(file)->d_inode;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
     ssize_t                 cbRet;
 
     SFLOGFLOW(("vbsf_splice_read: file=%p poffset=%p{%#RX64} pipe=%p len=%#zx flags=%#x\n", file, poffset, *poffset, pipe, len, flags));
-    if (vbsf_should_use_cached_read(file, inode->i_mapping, sf_g)) {
+    if (vbsf_should_use_cached_read(file, inode->i_mapping, pSuperInfo)) {
         cbRet = generic_file_splice_read(file, poffset, pipe, len, flags);
     } else {
@@ -801 +801 @@
                 uint32_t const          cbToRead = RT_MIN((cPages << PAGE_SHIFT) - (offFile & PAGE_OFFSET_MASK), len);
                 struct vbsf_reg_info   *sf_r     = (struct vbsf_reg_info *)file->private_data;
-                int vrc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbToRead, cPages);
+                int vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbToRead, cPages);
                 if (RT_SUCCESS(vrc)) {
                     /*
@@ -853 +853 @@
 static ssize_t vbsf_splice_write(struct pipe_inode_info *pPipe, struct file *file, loff_t *poffset, size_t len, unsigned int flags)
 {
-    struct inode           *inode = VBSF_GET_F_DENTRY(file)->d_inode;
-    struct vbsf_super_info *sf_g  = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct inode           *inode      = VBSF_GET_F_DENTRY(file)->d_inode;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
     ssize_t                 cbRet;
 
@@ -923 +923 @@
                        we'll only end up having to cancel the HGCM request 99% of the time: */
                     if (!signal_pending(current))
-                        vrc = VbglR0SfHostReqWritePgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbToWrite, cPagesToWrite);
+                        vrc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile,
+                                                        cbToWrite, cPagesToWrite);
                     else
                         vrc = VERR_INTERRUPTED;
@@ -1050 +1051 @@
                                 )
 {
-    struct inode           *inode = VBSF_GET_F_DENTRY(pFile)->d_inode;
-    struct vbsf_super_info *sf_g  = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct inode           *inode      = VBSF_GET_F_DENTRY(pFile)->d_inode;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
     ssize_t                 cbRet;
     SFLOGFLOW(("vbsf_reg_sendfile: pFile=%p poffFile=%p{%#RX64} cbToSend=%#zx pfnActor=%p pvUser=%p\n",
                pFile, poffFile, poffFile ? *poffFile : 0, cbToSend, pfnActor, pvUser));
-    Assert(sf_g);
+    Assert(pSuperInfo);
 
     /*
@@ -1067 +1068 @@
      * the page cache in some cases or configs.
      */
-    if (vbsf_should_use_cached_read(pFile, inode->i_mapping, sf_g)) {
+    if (vbsf_should_use_cached_read(pFile, inode->i_mapping, pSuperInfo)) {
         cbRet = generic_file_sendfile(pFile, poffFile, cbToSend, pfnActor, pvUser);
         SFLOGFLOW(("vbsf_reg_sendfile: returns %#zx *poffFile=%#RX64 [generic_file_sendfile]\n", cbRet, poffFile ? *poffFile : UINT64_MAX));
@@ -1127 +1128 @@
                     pReq->PgLst.offFirstPage = (uint16_t)offPg0;
                     if (!signal_pending(current))
-                        vrc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbToRead, cPagesToRead);
+                        vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile,
+                                                       cbToRead, cPagesToRead);
                     else
                         vrc = VERR_INTERRUPTED;
@@ -1453 +1455 @@
  */
 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)
+                                     struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
 {
     /*
@@ -1468 +1470 @@
     ssize_t             cbRet        = -ENOMEM;
     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);
+    size_t              cMaxPages    = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 1), cPages);
     bool                fLockPgHack;
 
@@ -1508 +1510 @@
              * Issue the request and unlock the pages.
              */
-            rc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
+            rc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
 
             vbsf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/, fLockPgHack);
@@ -1569 +1571 @@
 static ssize_t vbsf_reg_read(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
 {
-    struct inode *inode = VBSF_GET_F_DENTRY(file)->d_inode;
-    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-    struct vbsf_reg_info *sf_r = file->private_data;
-    struct address_space *mapping = inode->i_mapping;
+    struct inode            *inode     = VBSF_GET_F_DENTRY(file)->d_inode;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_reg_info   *sf_r       = file->private_data;
+    struct address_space   *mapping    = inode->i_mapping;
 
     SFLOGFLOW(("vbsf_reg_read: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
@@ -1592 +1594 @@
      * mappings around with any kind of pages loaded.
      */
-    if (vbsf_should_use_cached_read(file, mapping, sf_g))
+    if (vbsf_should_use_cached_read(file, mapping, pSuperInfo))
         return vbsf_reg_read_mapped(file, buf, size, off);
 
@@ -1605 +1607 @@
             if ((PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
                 ssize_t cbRet;
-                int vrc = VbglR0SfHostReqReadEmbedded(sf_g->map.root, pReq, sf_r->Handle.hHost, *off, (uint32_t)size);
+                int vrc = VbglR0SfHostReqReadEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, *off, (uint32_t)size);
                 if (RT_SUCCESS(vrc)) {
                     cbRet = pReq->Parms.cb32Read.u.value32;
@@ -1632 +1634 @@
             if (pReq) {
                 ssize_t cbRet;
-                int vrc = VbglR0SfHostReqReadContig(sf_g->map.root, pReq, sf_r->Handle.hHost, *off,
+                int vrc = VbglR0SfHostReqReadContig(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, *off,
                                                     (uint32_t)size, pvBounce, virt_to_phys(pvBounce));
                 if (RT_SUCCESS(vrc)) {
@@ -1652 +1654 @@
 #endif
 
-    return vbsf_reg_read_locking(file, buf, size, off, sf_g, sf_r);
+    return vbsf_reg_read_locking(file, buf, size, off, pSuperInfo, sf_r);
 }
 
@@ -1749 +1751 @@
 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)
+                                      struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
 {
     /*
@@ -1763 +1765 @@
     ssize_t              cbRet        = -ENOMEM;
     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);
+    size_t               cMaxPages    = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 1), cPages);
     bool                 fLockPgHack;
 
@@ -1803 +1805 @@
              * Issue the request and unlock the pages.
              */
-            rc = VbglR0SfHostReqWritePgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
+            rc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
             if (RT_SUCCESS(rc)) {
                 /*
@@ -1872 +1874 @@
 static ssize_t vbsf_reg_write(struct file *file, const char *buf, size_t size, loff_t * off)
 {
-    struct inode           *inode   = VBSF_GET_F_DENTRY(file)->d_inode;
-    struct vbsf_inode_info *sf_i    = VBSF_GET_INODE_INFO(inode);
-    struct vbsf_super_info *sf_g    = VBSF_GET_SUPER_INFO(inode->i_sb);
-    struct vbsf_reg_info   *sf_r    = file->private_data;
-    struct address_space   *mapping = inode->i_mapping;
+    struct inode           *inode      = VBSF_GET_F_DENTRY(file)->d_inode;
+    struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_reg_info   *sf_r       = file->private_data;
+    struct address_space   *mapping    = inode->i_mapping;
     loff_t                  pos;
 
     SFLOGFLOW(("vbsf_reg_write: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
-    BUG_ON(!sf_i);
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_r);
+    Assert(sf_i);
+    Assert(pSuperInfo);
+    Assert(sf_r);
     AssertReturn(S_ISREG(inode->i_mode), -EINVAL);
 
@@ -1926 +1928 @@
             ssize_t cbRet;
             if (copy_from_user(pReq->abData, buf, size) == 0) {
-                int vrc = VbglR0SfHostReqWriteEmbedded(sf_g->map.root, pReq, sf_r->Handle.hHost,
+                int vrc = VbglR0SfHostReqWriteEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
                                                        pos, (uint32_t)size);
                 if (RT_SUCCESS(vrc)) {
@@ -1961 +1963 @@
                 if (pReq) {
                     ssize_t cbRet;
-                    int vrc = VbglR0SfHostReqWriteContig(sf_g->map.root, pReq, sf_r->handle, pos,
+                    int vrc = VbglR0SfHostReqWriteContig(pSuperInfo->map.root, pReq, sf_r->handle, pos,
                                          (uint32_t)size, pvBounce, virt_to_phys(pvBounce));
                     if (RT_SUCCESS(vrc)) {
@@ -1988 +1990 @@
 #endif
 
-    return vbsf_reg_write_locking(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, pSuperInfo, sf_r);
 }
 
@@ -2359 +2361 @@
  */
 static ssize_t vbsf_reg_read_iter_locking(struct kiocb *kio, struct iov_iter *iter, size_t cbToRead,
-                                          struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r)
+                                          struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r)
 {
     /*
@@ -2371 +2373 @@
     ssize_t             cbRet        = 0;
     size_t              cMaxPages    = vbsf_iter_max_span_of_pages(iter);
-    cMaxPages = RT_MIN(RT_MAX(sf_g->cMaxIoPages, 2), cMaxPages);
+    cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 2), cMaxPages);
 
     pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFREADPGLSTREQ, PgLst.aPages[cMaxPages]));
@@ -2410 +2412 @@
              * Issue the request and unlock the pages.
              */
-            rc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, kio->ki_pos, cbChunk, cPages);
+            rc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, kio->ki_pos, cbChunk, cPages);
             SFLOGFLOW(("vbsf_reg_read_iter_locking: VbglR0SfHostReqReadPgLst -> %d (cbActual=%#x cbChunk=%#zx of %#zx cPages=%#zx offPage0=%#x\n",
                        rc, pReq->Parms.cb32Read.u.value32, cbChunk, cbToRead, cPages, offPage0));
@@ -2487 +2489 @@
 {
 # if LINUX_VERSION_CODE < KERNEL_VERSION(3, 16, 0)
-    struct vbsf_iov_iter    fake_iter = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 0 /*write*/);
-    struct vbsf_iov_iter   *iter      = &fake_iter;
-# endif
-    size_t                  cbToRead = iov_iter_count(iter);
-    struct inode           *inode    = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
-    struct address_space   *mapping  = inode->i_mapping;
-
-    struct vbsf_reg_info   *sf_r     = kio->ki_filp->private_data;
-    struct vbsf_super_info *sf_g     = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_iov_iter    fake_iter  = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 0 /*write*/);
+    struct vbsf_iov_iter   *iter       = &fake_iter;
+# endif
+    size_t                  cbToRead   = iov_iter_count(iter);
+    struct inode           *inode      = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
+    struct address_space   *mapping    = inode->i_mapping;
+
+    struct vbsf_reg_info   *sf_r       = kio->ki_filp->private_data;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
 
     SFLOGFLOW(("vbsf_reg_read_iter: inode=%p file=%p size=%#zx off=%#llx type=%#x\n",
@@ -2513 +2515 @@
      * mappings around with any kind of pages loaded.
      */
-    if (vbsf_should_use_cached_read(kio->ki_filp, mapping, sf_g)) {
+    if (vbsf_should_use_cached_read(kio->ki_filp, mapping, pSuperInfo)) {
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
         return generic_file_read_iter(kio, iter);
@@ -2539 +2541 @@
             if ((PAGE_SIZE - ((uintptr_t)pReq & PAGE_OFFSET_MASK)) >= cbReq) {
                 ssize_t cbRet;
-                int vrc = VbglR0SfHostReqReadEmbedded(sf_g->map.root, pReq, sf_r->Handle.hHost, kio->ki_pos, (uint32_t)cbToRead);
+                int vrc = VbglR0SfHostReqReadEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
+                                                      kio->ki_pos, (uint32_t)cbToRead);
                 if (RT_SUCCESS(vrc)) {
                     cbRet = pReq->Parms.cb32Read.u.value32;
@@ -2562 +2565 @@
      * Otherwise do the page locking thing.
      */
-    return vbsf_reg_read_iter_locking(kio, iter, cbToRead, sf_g, sf_r);
+    return vbsf_reg_read_iter_locking(kio, iter, cbToRead, pSuperInfo, sf_r);
 }
 
@@ -2571 +2574 @@
  */
 static ssize_t vbsf_reg_write_iter_locking(struct kiocb *kio, struct iov_iter *iter, size_t cbToWrite, loff_t offFile,
-                                           struct vbsf_super_info *sf_g, struct vbsf_reg_info *sf_r,
+                                           struct vbsf_super_info *pSuperInfo, struct vbsf_reg_info *sf_r,
                                            struct inode *inode, struct vbsf_inode_info *sf_i, struct address_space *mapping)
 {
@@ -2584 +2587 @@
     ssize_t              cbRet        = 0;
     size_t               cMaxPages    = vbsf_iter_max_span_of_pages(iter);
-    cMaxPages = RT_MIN(RT_MAX(sf_g->cMaxIoPages, 2), cMaxPages);
+    cMaxPages = RT_MIN(RT_MAX(pSuperInfo->cMaxIoPages, 2), cMaxPages);
 
     pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF_DYN(VBOXSFWRITEPGLSTREQ, PgLst.aPages[cMaxPages]));
@@ -2623 +2626 @@
              * Issue the request and unlock the pages.
              */
-            rc = VbglR0SfHostReqWritePgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
+            rc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
             SFLOGFLOW(("vbsf_reg_write_iter_locking: VbglR0SfHostReqWritePgLst -> %d (cbActual=%#x cbChunk=%#zx of %#zx cPages=%#zx offPage0=%#x\n",
                        rc, pReq->Parms.cb32Write.u.value32, cbChunk, cbToWrite, cPages, offPage0));
@@ -2707 +2710 @@
 {
 # if LINUX_VERSION_CODE < KERNEL_VERSION(3, 16, 0)
-    struct vbsf_iov_iter    fake_iter = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 1 /*write*/);
-    struct vbsf_iov_iter   *iter      = &fake_iter;
-# endif
-    size_t                  cbToWrite = iov_iter_count(iter);
-    struct inode           *inode     = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
-    struct vbsf_inode_info *sf_i      = VBSF_GET_INODE_INFO(inode);
-    struct address_space   *mapping   = inode->i_mapping;
-
-    struct vbsf_reg_info   *sf_r      = kio->ki_filp->private_data;
-    struct vbsf_super_info *sf_g      = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_iov_iter    fake_iter  = VBSF_IOV_ITER_INITIALIZER(cSegs, iov, 1 /*write*/);
+    struct vbsf_iov_iter   *iter       = &fake_iter;
+# endif
+    size_t                  cbToWrite  = iov_iter_count(iter);
+    struct inode           *inode      = VBSF_GET_F_DENTRY(kio->ki_filp)->d_inode;
+    struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+    struct address_space   *mapping    = inode->i_mapping;
+
+    struct vbsf_reg_info   *sf_r       = kio->ki_filp->private_data;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
-    loff_t                  offFile   = kio->ki_pos;
+    loff_t                  offFile    = kio->ki_pos;
 # endif
 
@@ -2778 +2781 @@
                 ssize_t cbRet;
                 if (copy_from_iter(pReq->abData, cbToWrite, iter) == cbToWrite) {
-                    int vrc = VbglR0SfHostReqWriteEmbedded(sf_g->map.root, pReq, sf_r->Handle.hHost,
+                    int vrc = VbglR0SfHostReqWriteEmbedded(pSuperInfo->map.root, pReq, sf_r->Handle.hHost,
                                                            offFile, (uint32_t)cbToWrite);
                     if (RT_SUCCESS(vrc)) {
@@ -2808 +2811 @@
      * Otherwise do the page locking thing.
      */
-    return vbsf_reg_write_iter_locking(kio, iter, cbToWrite, offFile, sf_g, sf_r, inode, sf_i, mapping);
+    return vbsf_reg_write_iter_locking(kio, iter, cbToWrite, offFile, pSuperInfo, sf_r, inode, sf_i, mapping);
 }
 
@@ -2898 +2901 @@
 {
     int rc, rc_linux = 0;
-    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-    struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(inode);
-    struct dentry          *dentry = VBSF_GET_F_DENTRY(file);
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+    struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(inode);
+    struct dentry          *dentry     = VBSF_GET_F_DENTRY(file);
     struct vbsf_reg_info   *sf_r;
     VBOXSFCREATEREQ        *pReq;
 
     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));
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
+    Assert(pSuperInfo);
+    Assert(sf_i);
 
     sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
@@ -2960 +2963 @@
     LogFunc(("vbsf_reg_open: calling VbglR0SfHostReqCreate, file %s, flags=%#x, %#x\n",
              sf_i->path->String.utf8, file->f_flags, pReq->CreateParms.CreateFlags));
-    rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
+    rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
     if (RT_FAILURE(rc)) {
         LogFunc(("VbglR0SfHostReqCreate failed flags=%d,%#x rc=%Rrc\n", file->f_flags, pReq->CreateParms.CreateFlags, rc));
@@ -3015 +3018 @@
     SFLOGFLOW(("vbsf_reg_release: inode=%p file=%p\n", inode, file));
     if (sf_r) {
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-        Assert(sf_g);
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+        Assert(pSuperInfo);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
@@ -3031 +3034 @@
         /* Release sf_r, closing the handle if we're the last user. */
         file->private_data = NULL;
-        vbsf_handle_release(&sf_r->Handle, sf_g, "vbsf_reg_release");
+        vbsf_handle_release(&sf_r->Handle, pSuperInfo, "vbsf_reg_release");
 
         sf_i->handle = SHFL_HANDLE_NIL;
@@ -3456 +3459 @@
         VBOXSFREADPGLSTREQ *pReq = (VBOXSFREADPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
         if (pReq) {
-            struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-            struct vbsf_reg_info   *sf_r = file->private_data;
+            struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+            struct vbsf_reg_info   *sf_r       = file->private_data;
             uint32_t                cbRead;
             int                     vrc;
@@ -3463 +3466 @@
             pReq->PgLst.offFirstPage = 0;
             pReq->PgLst.aPages[0]    = page_to_phys(page);
-            vrc = VbglR0SfHostReqReadPgLst(sf_g->map.root,
+            vrc = VbglR0SfHostReqReadPgLst(pSuperInfo->map.root,
                                            pReq,
                                            sf_r->Handle.hHost,
@@ -3518 +3521 @@
 
     if (pHandle) {
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
-        VBOXSFWRITEPGLSTREQ    *pReq = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(inode->i_sb);
+        VBOXSFWRITEPGLSTREQ    *pReq       = (VBOXSFWRITEPGLSTREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
         if (pReq) {
-            uint64_t const cbFile    = i_size_read(inode);
-            uint64_t const offInFile = (uint64_t)page->index << PAGE_SHIFT;
-            uint32_t const cbToWrite = page->index != (cbFile >> PAGE_SHIFT) ? PAGE_SIZE
-                                     : (uint32_t)cbFile & (uint32_t)PAGE_OFFSET_MASK;
+            uint64_t const cbFile          = i_size_read(inode);
+            uint64_t const offInFile       = (uint64_t)page->index << PAGE_SHIFT;
+            uint32_t const cbToWrite       = page->index != (cbFile >> PAGE_SHIFT) ? PAGE_SIZE
+                                           : (uint32_t)cbFile & (uint32_t)PAGE_OFFSET_MASK;
             int            vrc;
 
             pReq->PgLst.offFirstPage = 0;
             pReq->PgLst.aPages[0]    = page_to_phys(page);
-            vrc = VbglR0SfHostReqWritePgLst(sf_g->map.root,
+            vrc = VbglR0SfHostReqWritePgLst(pSuperInfo->map.root,
                                             pReq,
                                             pHandle->hHost,
@@ -3558 +3561 @@
         } else
             err = -ENOMEM;
-        vbsf_handle_release(pHandle, sf_g, "vbsf_writepage");
+        vbsf_handle_release(pHandle, pSuperInfo, "vbsf_writepage");
     } else {
         static uint64_t volatile s_cCalls = 0;

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)
+int vbsf_nlscpy(struct vbsf_super_info *pSuperInfo, char *name, size_t name_bound_len,
+                const unsigned char *utf8_name, size_t utf8_len)
 {
     Assert(name_bound_len > 1);
     Assert(RTStrNLen(utf8_name, utf8_len) == utf8_len);
 
-    if (sf_g->nls) {
+    if (pSuperInfo->nls) {
         const char *in              = utf8_name;
         size_t      in_bound_len    = utf8_len;
@@ -58 +59 @@
 #endif
             if (cbInEnc >= 0) {
-                int cbOutEnc = sf_g->nls->uni2char(uni, out, out_bound_len);
+                int cbOutEnc = pSuperInfo->nls->uni2char(uni, out, out_bound_len);
                 if (cbOutEnc >= 0) {
                     /*SFLOG3(("vbsf_nlscpy: cbOutEnc=%d cbInEnc=%d uni=%#x in_bound_len=%u\n", cbOutEnc, cbInEnc, uni, in_bound_len));*/
@@ -94 +95 @@
  * the output buffer (use kfree on result).
  */
-int vbsf_nls_to_shflstring(struct vbsf_super_info *sf_g, const char *pszNls, PSHFLSTRING *ppString)
+int vbsf_nls_to_shflstring(struct vbsf_super_info *pSuperInfo, const char *pszNls, PSHFLSTRING *ppString)
 {
     int          rc;
     size_t const cchNls = strlen(pszNls);
     PSHFLSTRING  pString = NULL;
-    if (sf_g->nls) {
+    if (pSuperInfo->nls) {
         /*
          * NLS -> UTF-8 w/ SHLF string header.
@@ -108 +109 @@
         while (offNls < cchNls) {
             linux_wchar_t uc; /* Note! We renamed the type due to clashes. */
-            int const cbNlsCodepoint = sf_g->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
+            int const cbNlsCodepoint = pSuperInfo->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
             if (cbNlsCodepoint >= 0) {
                 char achTmp[16];
@@ -142 +143 @@
                 while (offNls < cchNls) {
                     linux_wchar_t uc; /* Note! We renamed the type due to clashes. */
-                    int const cbNlsCodepoint = sf_g->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
+                    int const cbNlsCodepoint = pSuperInfo->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
                     if (cbNlsCodepoint >= 0) {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
@@ -293 +294 @@
 
 /**
- * Initializes the @a inode attributes based on @a pObjInfo and @a sf_g options.
- */
-void vbsf_init_inode(struct inode *inode, struct vbsf_inode_info *sf_i, PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g)
+ * Initializes the @a inode attributes based on @a pObjInfo and @a pSuperInfo
+ * options.
+ */
+void vbsf_init_inode(struct inode *inode, struct vbsf_inode_info *sf_i, PSHFLFSOBJINFO pObjInfo,
+                     struct vbsf_super_info *pSuperInfo)
 {
     PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
@@ -307 +310 @@
     inode->i_mapping->a_ops = &vbsf_reg_aops;
 # if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
-    inode->i_mapping->backing_dev_info = &sf_g->bdi; /* This is needed for mmap. */
+    inode->i_mapping->backing_dev_info = &pSuperInfo->bdi; /* This is needed for mmap. */
 # endif
 #endif
     if (RTFS_IS_DIRECTORY(pAttr->fMode)) {
-        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->dmode, pSuperInfo->dmask, S_IFDIR);
         inode->i_op = &vbsf_dir_iops;
         inode->i_fop = &vbsf_dir_fops;
@@ -322 +325 @@
         /** @todo r=bird: Aren't System V symlinks w/o any mode mask? IIRC there is
          *        no lchmod on Linux. */
-        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFLNK);
         inode->i_op = &vbsf_lnk_iops;
         set_nlink(inode, 1);
     } else {
-        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFREG);
         inode->i_op = &vbsf_reg_iops;
         inode->i_fop = &vbsf_reg_fops;
@@ -333 +336 @@
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
-    inode->i_uid = make_kuid(current_user_ns(), sf_g->uid);
-    inode->i_gid = make_kgid(current_user_ns(), sf_g->gid);
+    inode->i_uid = make_kuid(current_user_ns(), pSuperInfo->uid);
+    inode->i_gid = make_kgid(current_user_ns(), pSuperInfo->gid);
 #else
-    inode->i_uid = sf_g->uid;
-    inode->i_gid = sf_g->gid;
+    inode->i_uid = pSuperInfo->uid;
+    inode->i_gid = pSuperInfo->gid;
 #endif
 
@@ -363 +366 @@
  */
 void vbsf_update_inode(struct inode *pInode, struct vbsf_inode_info *pInodeInfo, PSHFLFSOBJINFO pObjInfo,
-                       struct vbsf_super_info *sf_g, bool fInodeLocked)
+                       struct vbsf_super_info *pSuperInfo, bool fInodeLocked)
 {
     PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
@@ -379 +382 @@
      */
     if (RTFS_IS_DIRECTORY(pAttr->fMode))
-        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->dmode, pSuperInfo->dmask, S_IFDIR);
     else if (RTFS_IS_SYMLINK(pAttr->fMode))
         /** @todo r=bird: Aren't System V symlinks w/o any mode mask? IIRC there is
          *        no lchmod on Linux. */
-        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFLNK);
     else
-        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFREG);
 
     if (fMode == pInode->i_mode) {
@@ -396 +399 @@
                        pInode->i_mode & S_IFMT, fMode & S_IFMT, pInodeInfo->path->String.ach));
             /** @todo we probably need to be more drastic... */
-            vbsf_init_inode(pInode, pInodeInfo, pObjInfo, sf_g);
+            vbsf_init_inode(pInode, pInodeInfo, pObjInfo, pSuperInfo);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
@@ -435 +438 @@
 
 /** @note Currently only used for the root directory during (re-)mount.  */
-int vbsf_stat(const char *caller, struct vbsf_super_info *sf_g, SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
+int vbsf_stat(const char *caller, struct vbsf_super_info *pSuperInfo, SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
 {
     int rc;
@@ -451 +454 @@
 
         LogFunc(("Calling VbglR0SfHostReqCreate on %s\n", path->String.utf8));
-        rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
+        rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
         if (RT_SUCCESS(rc)) {
             if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
@@ -486 +489 @@
     struct inode *pInode = dentry ? dentry->d_inode : NULL;
     if (pInode) {
-        struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(pInode->i_sb);
+        struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(pInode);
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
         AssertReturn(sf_i, -EINVAL);
-        AssertReturn(sf_g, -EINVAL);
+        AssertReturn(pSuperInfo, -EINVAL);
 
         /*
@@ -496 +499 @@
         if (   !fForced
             && !sf_i->force_restat
-            && jiffies - sf_i->ts_up_to_date < sf_g->ttl)
+            && jiffies - sf_i->ts_up_to_date < pSuperInfo->ttl)
             rc = 0;
         else {
@@ -509 +512 @@
                 if (pReq) {
                     RT_ZERO(*pReq);
-                    rc = VbglR0SfHostReqQueryObjInfo(sf_g->map.root, pReq, pHandle->hHost);
+                    rc = VbglR0SfHostReqQueryObjInfo(pSuperInfo->map.root, pReq, pHandle->hHost);
                     if (RT_SUCCESS(rc)) {
                         /*
                          * Reset the TTL and copy the info over into the inode structure.
                          */
-                        vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, fInodeLocked);
+                        vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, pSuperInfo, fInodeLocked);
                     } else if (rc == VERR_INVALID_HANDLE) {
                         rc = -ENOENT; /* Restore.*/
@@ -524 +527 @@
                 } else
                     rc = -ENOMEM;
-                vbsf_handle_release(pHandle, sf_g, "vbsf_inode_revalidate_worker");
+                vbsf_handle_release(pHandle, pSuperInfo, "vbsf_inode_revalidate_worker");
 
             } else {
@@ -536 +539 @@
                     pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
 
-                    rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
+                    rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
                     if (RT_SUCCESS(rc)) {
                         if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
@@ -542 +545 @@
                              * Reset the TTL and copy the info over into the inode structure.
                              */
-                            vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info, sf_g, fInodeLocked);
+                            vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info, pSuperInfo, fInodeLocked);
                             rc = 0;
                         } else {
@@ -598 +601 @@
         err = -EINVAL;
     } else {
-        struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
-        struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(pInode->i_sb);
+        struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(pInode);
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
         AssertReturn(sf_i, -EINVAL);
-        AssertReturn(sf_g, -EINVAL);
+        AssertReturn(pSuperInfo, -EINVAL);
 
         /*
@@ -608 +611 @@
         if (   !fForced
             && !sf_i->force_restat
-            && jiffies - sf_i->ts_up_to_date < sf_g->ttl)
+            && jiffies - sf_i->ts_up_to_date < pSuperInfo->ttl)
             err = 0;
         else {
@@ -617 +620 @@
             if (pReq) {
                 RT_ZERO(*pReq);
-                err = VbglR0SfHostReqQueryObjInfo(sf_g->map.root, pReq, hHostFile);
+                err = VbglR0SfHostReqQueryObjInfo(pSuperInfo->map.root, pReq, hHostFile);
                 if (RT_SUCCESS(err)) {
                     /*
                      * Reset the TTL and copy the info over into the inode structure.
                      */
-                    vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, fInodeLocked);
+                    vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, pSuperInfo, fInodeLocked);
                 } else {
                     LogFunc(("VbglR0SfHostReqQueryObjInfo failed on %#RX64: %Rrc\n", hHostFile, err));
@@ -730 +733 @@
 int vbsf_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-    struct inode           *pInode = dentry->d_inode;
-    struct vbsf_super_info *sf_g   = VBSF_GET_SUPER_INFO(pInode->i_sb);
-    struct vbsf_inode_info *sf_i   = VBSF_GET_INODE_INFO(pInode);
+    struct inode           *pInode     = dentry->d_inode;
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
+    struct vbsf_inode_info *sf_i       = VBSF_GET_INODE_INFO(pInode);
     int vrc;
     int rc;
@@ -791 +794 @@
                         pReq->Create.CreateParms.CreateFlags |= SHFL_CF_ACCESS_WRITE;
                     memcpy(&pReq->Create.StrPath, sf_i->path, SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
-                    vrc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
+                    vrc = VbglR0SfHostReqCreate(pSuperInfo->map.root, &pReq->Create);
                     if (RT_SUCCESS(vrc)) {
                         if (pReq->Create.CreateParms.Result == SHFL_FILE_EXISTS) {
@@ -835 +838 @@
 
                     /* Make the change. */
-                    vrc = VbglR0SfHostReqSetObjInfo(sf_g->map.root, &pReq->Info, hHostFile);
+                    vrc = VbglR0SfHostReqSetObjInfo(pSuperInfo->map.root, &pReq->Info, hHostFile);
                     if (RT_SUCCESS(vrc)) {
-                        vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, sf_g, true /*fLocked*/);
+                        vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, pSuperInfo, true /*fLocked*/);
                     } else {
                         rc = -RTErrConvertToErrno(vrc);
@@ -850 +853 @@
                  */
                 if ((iattr->ia_valid & ATTR_SIZE) && rc == 0) {
-                    /*vrc = VbglR0SfHostReqSetFileSize(sf_g->map.root, &pReq->SetSize, hHostFile, iattr->ia_size);
+                    /*vrc = VbglR0SfHostReqSetFileSize(pSuperInfo->map.root, &pReq->SetSize, hHostFile, iattr->ia_size);
                     if (RT_SUCCESS(vrc)) {
                         i_size_write(pInode, iattr->ia_size);
@@ -857 +860 @@
                         RT_ZERO(pReq->Info.ObjInfo);
                         pReq->Info.ObjInfo.cbObject = iattr->ia_size;
-                        vrc = VbglR0SfHostReqSetFileSizeOld(sf_g->map.root, &pReq->Info, hHostFile);
+                        vrc = VbglR0SfHostReqSetFileSizeOld(pSuperInfo->map.root, &pReq->Info, hHostFile);
                         if (RT_SUCCESS(vrc))
-                            vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, sf_g, true /*fLocked*/);
+                            vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, pSuperInfo, true /*fLocked*/);
                     }
                     if (RT_SUCCESS(vrc)) {
@@ -875 +878 @@
                  */
                 if (!pHandle) {
-                    vrc = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, hHostFile);
+                    vrc = VbglR0SfHostReqClose(pSuperInfo->map.root, &pReq->Close, hHostFile);
                     if (RT_FAILURE(vrc))
                         LogFunc(("VbglR0SfHostReqClose(%s [%#llx]) failed vrc=%Rrc\n", sf_i->path->String.utf8, hHostFile, vrc));
@@ -883 +886 @@
                 VbglR0PhysHeapFree(pReq);
             if (pHandle)
-                vbsf_handle_release(pHandle, sf_g, "vbsf_inode_setattr");
+                vbsf_handle_release(pHandle, pSuperInfo, "vbsf_inode_setattr");
         } else
             SFLOGFLOW(("vbsf_inode_setattr: Notthing to do here (%#x).\n", iattr->ia_valid));
@@ -942 +945 @@
 /**
  * [dentry] contains string encoded in coding system that corresponds
- * to [sf_g]->nls, we must convert it to UTF8 here and pass down to
+ * to [pSuperInfo]->nls, we must convert it to UTF8 here and pass down to
  * [vbsf_make_path] which will allocate SHFLSTRING and fill it in
  */
-int vbsf_path_from_dentry(struct vbsf_super_info *sf_g, struct vbsf_inode_info *sf_i, struct dentry *dentry, SHFLSTRING **result,
-                          const char *caller)
+int vbsf_path_from_dentry(struct vbsf_super_info *pSuperInfo, struct vbsf_inode_info *sf_i, struct dentry *dentry,
+                          SHFLSTRING **result, const char *caller)
 {
     int err;
@@ -958 +961 @@
     d_len = dentry->d_name.len;
 
-    if (sf_g->nls) {
+    if (pSuperInfo->nls) {
         size_t in_len, i, out_bound_len;
         const char *in;
@@ -976 +979 @@
             int nb;
 
-            nb = sf_g->nls->char2uni(in, in_len, &uni);
+            nb = pSuperInfo->nls->char2uni(in, in_len, &uni);
             if (nb < 0) {
                 LogFunc(("nls->char2uni failed %x %d\n",
@@ -1080 +1083 @@
             //struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
             unsigned long const     cJiffiesAge = jiffies - vbsf_dentry_get_update_jiffies(dentry);
-            struct vbsf_super_info *sf_g        = VBSF_GET_SUPER_INFO(dentry->d_sb);
-            if (cJiffiesAge < sf_g->ttl) {
-                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
+            struct vbsf_super_info *pSuperInfo  = VBSF_GET_SUPER_INFO(dentry->d_sb);
+            if (cJiffiesAge < pSuperInfo->ttl) {
+                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, pSuperInfo->ttl));
                 rc = 1;
             } else if (!vbsf_inode_revalidate_worker(dentry, true /*fForced*/, false /*fInodeLocked*/)) {
                 vbsf_dentry_set_update_jiffies(dentry, jiffies); /** @todo get jiffies from inode. */
-                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 1\n", cJiffiesAge, sf_g->ttl));
+                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 1\n", cJiffiesAge, pSuperInfo->ttl));
                 rc = 1;
             } else {
-                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 0\n", cJiffiesAge, sf_g->ttl));
+                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 0\n", cJiffiesAge, pSuperInfo->ttl));
                 rc = 0;
             }
@@ -1114 +1117 @@
                 /* Can we skip revalidation based on TTL? */
                 unsigned long const     cJiffiesAge = vbsf_dentry_get_update_jiffies(dentry) - jiffies;
-                struct vbsf_super_info *sf_g        = VBSF_GET_SUPER_INFO(dentry->d_sb);
-                if (cJiffiesAge < sf_g->ttl) {
-                    SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
+                struct vbsf_super_info *pSuperInfo  = VBSF_GET_SUPER_INFO(dentry->d_sb);
+                if (cJiffiesAge < pSuperInfo->ttl) {
+                    SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, pSuperInfo->ttl));
                     rc = 1;
                 } else {
@@ -1122 +1125 @@
                        have the caller kick it out. */
                     /** @todo stat the direntry and see if it exists now. */
-                    SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 0\n", cJiffiesAge, sf_g->ttl));
+                    SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 0\n", cJiffiesAge, pSuperInfo->ttl));
                     rc = 0;
                 }

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

@@ -80 +80 @@
 
 /**
- * Copies options from the mount info structure into @a sf_g.
+ * Copies options from the mount info structure into @a pSuperInfo.
  *
  * This is used both by vbsf_super_info_alloc_and_map_it() and
  * vbsf_remount_fs().
  */
-static void vbsf_super_info_copy_remount_options(struct vbsf_super_info *sf_g, struct vbsf_mount_info_new *info)
-{
-    sf_g->ttl_msec = info->ttl;
+static void vbsf_super_info_copy_remount_options(struct vbsf_super_info *pSuperInfo, struct vbsf_mount_info_new *info)
+{
+    pSuperInfo->ttl_msec = info->ttl;
     if (info->ttl > 0)
-        sf_g->ttl = msecs_to_jiffies(info->ttl);
+        pSuperInfo->ttl = msecs_to_jiffies(info->ttl);
     else if (info->ttl == 0 || info->ttl != -1)
-        sf_g->ttl = sf_g->ttl_msec = 0;
+        pSuperInfo->ttl = pSuperInfo->ttl_msec = 0;
     else
-        sf_g->ttl = msecs_to_jiffies(VBSF_DEFAULT_TTL_MS);
-
-    sf_g->uid = info->uid;
-    sf_g->gid = info->gid;
+        pSuperInfo->ttl = msecs_to_jiffies(VBSF_DEFAULT_TTL_MS);
+
+    pSuperInfo->uid = info->uid;
+    pSuperInfo->gid = info->gid;
 
     if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, tag)) {
         /* new fields */
-        sf_g->dmode = info->dmode;
-        sf_g->fmode = info->fmode;
-        sf_g->dmask = info->dmask;
-        sf_g->fmask = info->fmask;
+        pSuperInfo->dmode = info->dmode;
+        pSuperInfo->fmode = info->fmode;
+        pSuperInfo->dmask = info->dmask;
+        pSuperInfo->fmask = info->fmask;
     } else {
-        sf_g->dmode = ~0;
-        sf_g->fmode = ~0;
+        pSuperInfo->dmode = ~0;
+        pSuperInfo->fmode = ~0;
     }
 
     if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, cMaxIoPages)) {
-        AssertCompile(sizeof(sf_g->tag) >= sizeof(info->tag));
-        memcpy(sf_g->tag, info->tag, sizeof(info->tag));
-        sf_g->tag[sizeof(sf_g->tag) - 1] = '\0';
+        AssertCompile(sizeof(pSuperInfo->tag) >= sizeof(info->tag));
+        memcpy(pSuperInfo->tag, info->tag, sizeof(info->tag));
+        pSuperInfo->tag[sizeof(pSuperInfo->tag) - 1] = '\0';
     } else {
-        sf_g->tag[0] = '\0';
+        pSuperInfo->tag[0] = '\0';
     }
 
@@ -124 +124 @@
        too hard as we'd have to retry with smaller requests when this
        happens, which isn't too efficient. */
-    sf_g->cMaxIoPages = RT_MIN(_16K / sizeof(RTGCPHYS64) /* => 8MB buffer */,
-                               VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT);
+    pSuperInfo->cMaxIoPages = RT_MIN(_16K / sizeof(RTGCPHYS64) /* => 8MB buffer */,
+                                     VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT);
     if (   (unsigned)info->length >= sizeof(struct vbsf_mount_info_new)
         && info->cMaxIoPages > 0) {
         if (info->cMaxIoPages <= VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT)
-            sf_g->cMaxIoPages = RT_MAX(info->cMaxIoPages, 2); /* read_iter/write_iter requires a minimum of 2. */
+            pSuperInfo->cMaxIoPages = RT_MAX(info->cMaxIoPages, 2); /* read_iter/write_iter requires a minimum of 2. */
         else
             printk(KERN_WARNING "vboxsf: max I/O page count (%#x) is out of range, using default (%#x) instead.\n",
-                   info->cMaxIoPages, sf_g->cMaxIoPages);
-    }
-
-    sf_g->cbDirBuf = _64K; /** @todo make configurable. */
+                   info->cMaxIoPages, pSuperInfo->cMaxIoPages);
+    }
+
+    pSuperInfo->cbDirBuf = _64K; /** @todo make configurable. */
 }
 
@@ -146 +146 @@
     SHFLSTRING *str_name;
     size_t name_len, str_len;
-    struct vbsf_super_info *sf_g;
+    struct vbsf_super_info *pSuperInfo;
 
     TRACE();
@@ -174 +174 @@
      * Allocate memory.
      */
-    str_len  = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
-    str_name = kmalloc(str_len, GFP_KERNEL);
-    sf_g     = kmalloc(sizeof(*sf_g), GFP_KERNEL);
-    if (sf_g && str_name) {
-        RT_ZERO(*sf_g);
+    str_len    = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
+    str_name   = (PSHFLSTRING)kmalloc(str_len, GFP_KERNEL);
+    pSuperInfo = (struct vbsf_super_info *)kmalloc(sizeof(*pSuperInfo), GFP_KERNEL);
+    if (pSuperInfo && str_name) {
+        RT_ZERO(*pSuperInfo);
 
         str_name->u16Length = name_len;
@@ -192 +192 @@
 
         /* Check if NLS charset is valid and not points to UTF8 table */
-        sf_g->fNlsIsUtf8 = true;
+        pSuperInfo->fNlsIsUtf8 = true;
         if (info->nls_name[0]) {
             if (_IS_UTF8(info->nls_name)) {
                 SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8\n"));
-                sf_g->nls = NULL;
+                pSuperInfo->nls = NULL;
             } else {
-                sf_g->fNlsIsUtf8 = false;
-                sf_g->nls = load_nls(info->nls_name);
-                if (sf_g->nls) {
-                    SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=%s -> %p\n", info->nls_name, sf_g->nls));
+                pSuperInfo->fNlsIsUtf8 = false;
+                pSuperInfo->nls = load_nls(info->nls_name);
+                if (pSuperInfo->nls) {
+                    SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=%s -> %p\n", info->nls_name, pSuperInfo->nls));
                 } else {
                     SFLOGRELBOTH(("vboxsf: Failed to load nls '%s'!\n", info->nls_name));
@@ -213 +213 @@
             if (!_IS_UTF8(CONFIG_NLS_DEFAULT)
                 && !_IS_EMPTY(CONFIG_NLS_DEFAULT)) {
-                sf_g->fNlsIsUtf8 = false;
-                sf_g->nls = load_nls_default();
-                SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: CONFIG_NLS_DEFAULT=%s -> %p\n", CONFIG_NLS_DEFAULT, sf_g->nls));
+                pSuperInfo->fNlsIsUtf8 = false;
+                pSuperInfo->nls = load_nls_default();
+                SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: CONFIG_NLS_DEFAULT=%s -> %p\n", CONFIG_NLS_DEFAULT, pSuperInfo->nls));
             } else {
                 SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (default %s)\n", CONFIG_NLS_DEFAULT));
-                sf_g->nls = NULL;
+                pSuperInfo->nls = NULL;
             }
 #else
             SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (no default)\n"));
-            sf_g->nls = NULL;
+            pSuperInfo->nls = NULL;
 #endif
         }
@@ -232 +232 @@
              */
             rc = VbglR0SfHostReqMapFolderWithContigSimple(str_name, virt_to_phys(str_name), RTPATH_DELIMITER,
-                                                          true /*fCaseSensitive*/, &sf_g->map.root);
+                                                          true /*fCaseSensitive*/, &pSuperInfo->map.root);
             if (RT_SUCCESS(rc)) {
                 kfree(str_name);
 
                 /* The rest is shared with remount. */
-                vbsf_super_info_copy_remount_options(sf_g, info);
-
-                *sf_gp = sf_g;
+                vbsf_super_info_copy_remount_options(pSuperInfo, info);
+
+                *sf_gp = pSuperInfo;
                 return 0;
             }
@@ -253 +253 @@
                 rc = -EPROTO;
             }
-            if (sf_g->nls)
-                unload_nls(sf_g->nls);
+            if (pSuperInfo->nls)
+                unload_nls(pSuperInfo->nls);
         }
     } else {
@@ -262 +262 @@
     if (str_name)
         kfree(str_name);
-    if (sf_g)
-        kfree(sf_g);
+    if (pSuperInfo)
+        kfree(pSuperInfo);
     return rc;
 }
 
-/* unmap the share and free super info [sf_g] */
-static void vbsf_super_info_free(struct vbsf_super_info *sf_g)
+/* unmap the share and free super info [pSuperInfo] */
+static void vbsf_super_info_free(struct vbsf_super_info *pSuperInfo)
 {
     int rc;
 
     TRACE();
-    rc = VbglR0SfHostReqUnmapFolderSimple(sf_g->map.root);
+    rc = VbglR0SfHostReqUnmapFolderSimple(pSuperInfo->map.root);
     if (RT_FAILURE(rc))
         LogFunc(("VbglR0SfHostReqUnmapFolderSimple failed rc=%Rrc\n", rc));
 
-    if (sf_g->nls)
-        unload_nls(sf_g->nls);
-
-    kfree(sf_g);
+    if (pSuperInfo->nls)
+        unload_nls(pSuperInfo->nls);
+
+    kfree(pSuperInfo);
 }
 
@@ -287 +287 @@
  * Initialize backing device related matters.
  */
-static int vbsf_init_backing_dev(struct super_block *sb, struct vbsf_super_info *sf_g)
+static int vbsf_init_backing_dev(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
 {
     int rc = 0;
@@ -307 +307 @@
         return rc;
 #  else
-    bdi = &sf_g->bdi;
+    bdi = &pSuperInfo->bdi;
 #  endif
 
@@ -346 +346 @@
 
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE < KERNEL_VERSION(4, 11, 0)
-    rc = bdi_init(&sf_g->bdi);
+    rc = bdi_init(&pSuperInfo->bdi);
 #  if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
     if (!rc)
-        rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%llu", (unsigned long long)u64CurrentSequence);
+        rc = bdi_register(&pSuperInfo->bdi, NULL, "vboxsf-%llu", (unsigned long long)u64CurrentSequence);
 #  endif /* >= 2.6.26 */
 # endif  /* 4.11.0 > version >= 2.6.24 */
@@ -360 +360 @@
  * Undoes what vbsf_init_backing_dev did.
  */
-static void vbsf_done_backing_dev(struct super_block *sb, struct vbsf_super_info *sf_g)
+static void vbsf_done_backing_dev(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
-    bdi_destroy(&sf_g->bdi);    /* includes bdi_unregister() */
+    bdi_destroy(&pSuperInfo->bdi);    /* includes bdi_unregister() */
 #endif
 }
@@ -372 +372 @@
  *
  * @returns 0 on success, negative errno on failure.
- * @param   sb      The super block.
- * @param   sf_g    Our super block info.
- */
-static int vbsf_create_root_inode(struct super_block *sb, struct vbsf_super_info *sf_g)
+ * @param   sb          The super block.
+ * @param   pSuperInfo  Our super block info.
+ */
+static int vbsf_create_root_inode(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
 {
     SHFLFSOBJINFO fsinfo;
@@ -402 +402 @@
          * Stat the root directory (for inode info).
          */
-        rc = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+        rc = vbsf_stat(__func__, pSuperInfo, sf_i->path, &fsinfo, 0);
         if (rc == 0) {
             /*
@@ -414 +414 @@
 #endif
             if (iroot) {
-                vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
+                vbsf_init_inode(iroot, sf_i, &fsinfo, pSuperInfo);
                 VBSF_SET_INODE_INFO(iroot, sf_i);
 
@@ -475 +475 @@
 {
     int rc;
-    struct vbsf_super_info *sf_g;
+    struct vbsf_super_info *pSuperInfo;
 
     TRACE();
@@ -491 +491 @@
      * Create our super info structure and map the shared folder.
      */
-    rc = vbsf_super_info_alloc_and_map_it((struct vbsf_mount_info_new *)data, &sf_g);
+    rc = vbsf_super_info_alloc_and_map_it((struct vbsf_mount_info_new *)data, &pSuperInfo);
     if (rc == 0) {
         /*
@@ -518 +518 @@
          * files among other things.
          */
-        rc = vbsf_init_backing_dev(sb, sf_g);
+        rc = vbsf_init_backing_dev(sb, pSuperInfo);
         if (rc == 0) {
             /*
              * Create the root inode and we're done.
              */
-            rc = vbsf_create_root_inode(sb, sf_g);
+            rc = vbsf_create_root_inode(sb, pSuperInfo);
             if (rc == 0) {
-                VBSF_SET_SUPER_INFO(sb, sf_g);
+                VBSF_SET_SUPER_INFO(sb, pSuperInfo);
                 SFLOGFLOW(("vbsf_read_super_aux: returns successfully\n"));
                 return 0;
             }
-            vbsf_done_backing_dev(sb, sf_g);
+            vbsf_done_backing_dev(sb, pSuperInfo);
         } else
             SFLOGRELBOTH(("vboxsf: backing device information initialization failed: %d\n", rc));
-        vbsf_super_info_free(sf_g);
+        vbsf_super_info_free(pSuperInfo);
     }
     return rc;
@@ -595 +595 @@
 
 /* vfs is done with [sb] (umount called) call [vbsf_super_info_free] to unmap
-   the folder and free [sf_g] */
+   the folder and free [pSuperInfo] */
 static void vbsf_put_super(struct super_block *sb)
 {
-    struct vbsf_super_info *sf_g;
-
-    sf_g = VBSF_GET_SUPER_INFO(sb);
-    BUG_ON(!sf_g);
-    vbsf_done_backing_dev(sb, sf_g);
-    vbsf_super_info_free(sf_g);
+    struct vbsf_super_info *pSuperInfo;
+
+    pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+    BUG_ON(!pSuperInfo);
+    vbsf_done_backing_dev(sb, pSuperInfo);
+    vbsf_super_info_free(pSuperInfo);
 }
 
@@ -624 +624 @@
     VBOXSFVOLINFOREQ *pReq = (VBOXSFVOLINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
     if (pReq) {
-        SHFLVOLINFO            *pVolInfo = &pReq->VolInfo;
-        struct vbsf_super_info *sf_g     = VBSF_GET_SUPER_INFO(sb);
-        rc = VbglR0SfHostReqQueryVolInfo(sf_g->map.root, pReq, SHFL_HANDLE_ROOT);
+        SHFLVOLINFO            *pVolInfo   = &pReq->VolInfo;
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+        rc = VbglR0SfHostReqQueryVolInfo(pSuperInfo->map.root, pReq, SHFL_HANDLE_ROOT);
         if (RT_SUCCESS(rc)) {
             stat->f_type   = UINT32_C(0x786f4256); /* 'VBox' little endian */
@@ -661 +661 @@
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 23)
-    struct vbsf_super_info *sf_g;
+    struct vbsf_super_info *pSuperInfo = pSuperInfo = VBSF_GET_SUPER_INFO(sb);
     struct vbsf_inode_info *sf_i;
     struct inode *iroot;
     SHFLFSOBJINFO fsinfo;
     int err;
-
-    sf_g = VBSF_GET_SUPER_INFO(sb);
-    BUG_ON(!sf_g);
+    Assert(pSuperInfo);
+
     if (data && data[0] != 0) {
         struct vbsf_mount_info_new *info = (struct vbsf_mount_info_new *)data;
@@ -675 +674 @@
             && info->signature[1] == VBSF_MOUNT_SIGNATURE_BYTE_1
             && info->signature[2] == VBSF_MOUNT_SIGNATURE_BYTE_2) {
-            vbsf_super_info_copy_remount_options(sf_g, info);
+            vbsf_super_info_copy_remount_options(pSuperInfo, info);
         }
     }
@@ -684 +683 @@
 
     sf_i = VBSF_GET_INODE_INFO(iroot);
-    err = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+    err = vbsf_stat(__func__, pSuperInfo, sf_i->path, &fsinfo, 0);
     BUG_ON(err != 0);
-    vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
+    vbsf_init_inode(iroot, sf_i, &fsinfo, pSuperInfo);
     /*unlock_new_inode(iroot); */
     return 0;
@@ -708 +707 @@
 {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
-    struct super_block *sb = mnt->mnt_sb;
+    struct super_block     *sb         = mnt->mnt_sb;
 #else
-    struct super_block *sb = root->d_sb;
-#endif
-    struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(sb);
-    if (sf_g) {
+    struct super_block     *sb         = root->d_sb;
+#endif
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+    if (pSuperInfo) {
         seq_printf(m, ",uid=%u,gid=%u,ttl=%d,maxiopages=%u,iocharset=%s",
-                   sf_g->uid, sf_g->gid, sf_g->ttl_msec, sf_g->cMaxIoPages, sf_g->nls ? sf_g->nls->charset : "utf8");
-        if (sf_g->dmode != ~0)
-            seq_printf(m, ",dmode=0%o", sf_g->dmode);
-        if (sf_g->fmode != ~0)
-            seq_printf(m, ",fmode=0%o", sf_g->fmode);
-        if (sf_g->dmask != 0)
-            seq_printf(m, ",dmask=0%o", sf_g->dmask);
-        if (sf_g->fmask != 0)
-            seq_printf(m, ",fmask=0%o", sf_g->fmask);
-        if (sf_g->tag[0] != '\0') {
+                   pSuperInfo->uid, pSuperInfo->gid, pSuperInfo->ttl_msec, pSuperInfo->cMaxIoPages,
+                   pSuperInfo->nls ? pSuperInfo->nls->charset : "utf8");
+        if (pSuperInfo->dmode != ~0)
+            seq_printf(m, ",dmode=0%o", pSuperInfo->dmode);
+        if (pSuperInfo->fmode != ~0)
+            seq_printf(m, ",fmode=0%o", pSuperInfo->fmode);
+        if (pSuperInfo->dmask != 0)
+            seq_printf(m, ",dmask=0%o", pSuperInfo->dmask);
+        if (pSuperInfo->fmask != 0)
+            seq_printf(m, ",fmask=0%o", pSuperInfo->fmask);
+        if (pSuperInfo->tag[0] != '\0') {
             seq_puts(m, ",tag=");
-            seq_escape(m, sf_g->tag, " \t\n\\");
+            seq_escape(m, pSuperInfo->tag, " \t\n\\");
         }
     }

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

@@ -157 +157 @@
    pointers of arbitrary type */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-# define VBSF_GET_SUPER_INFO(sb)       ((struct vbsf_super_info *)(sb)->u.generic_sbp)
-# define VBSF_SET_SUPER_INFO(sb, sf_g) do { (sb)->u.generic_sbp = sf_g; } while (0)
+# define VBSF_GET_SUPER_INFO(sb)                ((struct vbsf_super_info *)(sb)->u.generic_sbp)
+# define VBSF_SET_SUPER_INFO(sb, a_pSuperInfo)  do { (sb)->u.generic_sbp = a_pSuperInfo; } while (0)
 #else
-# define VBSF_GET_SUPER_INFO(sb)       ((struct vbsf_super_info *)(sb)->s_fs_info)
-# define VBSF_SET_SUPER_INFO(sb, sf_g) do { (sb)->s_fs_info = sf_g;} while (0)
+# define VBSF_GET_SUPER_INFO(sb)                ((struct vbsf_super_info *)(sb)->s_fs_info)
+# define VBSF_SET_SUPER_INFO(sb, a_pSuperInfo)  do { (sb)->s_fs_info = a_pSuperInfo;} while (0)
 #endif
 
@@ -238 +238 @@
 #endif
 
-extern void vbsf_init_inode(struct inode *inode, struct vbsf_inode_info *sf_i, PSHFLFSOBJINFO info, struct vbsf_super_info *sf_g);
+extern void vbsf_init_inode(struct inode *inode, struct vbsf_inode_info *sf_i, PSHFLFSOBJINFO info,
+                            struct vbsf_super_info *pSuperInfo);
 extern void vbsf_update_inode(struct inode *pInode, struct vbsf_inode_info *pInodeInfo, PSHFLFSOBJINFO pObjInfo,
-                              struct vbsf_super_info *sf_g, bool fInodeLocked);
+                              struct vbsf_super_info *pSuperInfo, bool fInodeLocked);
 extern int  vbsf_inode_revalidate_worker(struct dentry *dentry, bool fForced, bool fInodeLocked);
 extern int  vbsf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked);
@@ -257 +258 @@
 extern void              vbsf_handle_drop_chain(struct vbsf_inode_info *pInodeInfo);
 extern struct vbsf_handle *vbsf_handle_find(struct vbsf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear);
-extern uint32_t          vbsf_handle_release_slow(struct vbsf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller);
+extern uint32_t          vbsf_handle_release_slow(struct vbsf_handle *pHandle, struct vbsf_super_info *pSuperInfo,
+                                                  const char *pszCaller);
 extern void              vbsf_handle_append(struct vbsf_inode_info *pInodeInfo, struct vbsf_handle *pHandle);
 
@@ -265 +267 @@
  * @returns New reference count.
  * @param   pHandle         The handle to release.
- * @param   sf_g            The info structure for the shared folder associated
+ * @param   pSuperInfo      The info structure for the shared folder associated
  *                          with the handle.
  * @param   pszCaller       The caller name (for logging failures).
  */
-DECLINLINE(uint32_t) vbsf_handle_release(struct vbsf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
+DECLINLINE(uint32_t) vbsf_handle_release(struct vbsf_handle *pHandle, struct vbsf_super_info *pSuperInfo, const char *pszCaller)
 {
     uint32_t cRefs;
@@ -281 +283 @@
     if (cRefs)
         return cRefs;
-    return vbsf_handle_release_slow(pHandle, sf_g, pszCaller);
+    return vbsf_handle_release_slow(pHandle, pSuperInfo, pszCaller);
 }
 
@@ -405 +407 @@
 #endif
 
-extern int  vbsf_stat(const char *caller, struct vbsf_super_info *sf_g, SHFLSTRING * path, PSHFLFSOBJINFO result, int ok_to_fail);
-extern int  vbsf_path_from_dentry(struct vbsf_super_info *sf_g, struct vbsf_inode_info *sf_i, struct dentry *dentry,
+extern int  vbsf_stat(const char *caller, struct vbsf_super_info *pSuperInfo, SHFLSTRING * path, PSHFLFSOBJINFO result,
+                      int ok_to_fail);
+extern int  vbsf_path_from_dentry(struct vbsf_super_info *pSuperInfo, struct vbsf_inode_info *sf_i, struct dentry *dentry,
                                   SHFLSTRING ** result, const char *caller);
-extern int  vbsf_nlscpy(struct vbsf_super_info *sf_g, char *name, size_t name_bound_len,
+extern int  vbsf_nlscpy(struct vbsf_super_info *pSuperInfo, char *name, size_t name_bound_len,
                         const unsigned char *utf8_name, size_t utf8_len);
-extern int  vbsf_nls_to_shflstring(struct vbsf_super_info *sf_g, const char *pszNls, PSHFLSTRING *ppString);
+extern int  vbsf_nls_to_shflstring(struct vbsf_super_info *pSuperInfo, const char *pszNls, PSHFLSTRING *ppString);