Changeset 77529 in vbox for trunk

Timestamp:

Mar 1, 2019 2:13:40 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

129132

Message:

linux/vboxsf: Use vbxsf as prefix here - part I. bugref:9172

Location:

trunk/src/VBox/Additions/linux/sharedfolders

Files:

• dirops.c (modified) (43 diffs)
• lnkops.c (modified) (6 diffs)
• regops.c (modified) (64 diffs)
• utils.c (modified) (57 diffs)
• vfsmod.c (modified) (37 diffs)
• vfsmod.h (modified) (12 diffs)

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

@@ -39 +39 @@
  *       reading in the whole directory on open.
  */
-static int sf_dir_open_worker(struct vbsf_super_info *sf_g, struct sf_dir_info *sf_d,
-                              struct sf_inode_info *sf_i, const char *pszCaller)
+static int vbsf_dir_open_worker(struct vbsf_super_info *sf_g, struct sf_dir_info *sf_d,
+                                struct sf_inode_info *sf_i, const char *pszCaller)
 {
     int rc;
@@ -84 +84 @@
             /** @todo Reading all entries upon opening the directory doesn't seem like
              * a good idea. */
-            sf_dir_info_empty(sf_d);
-            err = sf_dir_read_all(sf_g, sf_i, sf_d, pCreateParms->Handle);
+            vbsf_dir_info_empty(sf_d);
+            err = vbsf_dir_read_all(sf_g, sf_i, sf_d, pCreateParms->Handle);
         } else
             err = -ENOENT;
@@ -111 +111 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_dir_open(struct inode *inode, struct file *file)
+static int vbsf_dir_open(struct inode *inode, struct file *file)
 {
     struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
@@ -127 +127 @@
     }
 
-    sf_d = sf_dir_info_alloc();
+    sf_d = vbsf_dir_info_alloc();
     if (!sf_d) {
         LogRelFunc(("could not allocate directory info for '%s'\n", sf_i->path->String.ach));
@@ -133 +133 @@
     }
 
-    err = sf_dir_open_worker(sf_g, sf_d, sf_i, "sf_dir_open");
+    err = vbsf_dir_open_worker(sf_g, sf_d, sf_i, "vbsf_dir_open");
     if (!err)
         file->private_data = sf_d;
     else
-        sf_dir_info_free(sf_d);
+        vbsf_dir_info_free(sf_d);
 
     return err;
@@ -151 +151 @@
  * returns 0 on success, Linux error code otherwise
  */
-static int sf_dir_release(struct inode *inode, struct file *file)
+static int vbsf_dir_release(struct inode *inode, struct file *file)
 {
     TRACE();
 
     if (file->private_data)
-        sf_dir_info_free(file->private_data);
+        vbsf_dir_info_free(file->private_data);
 
     return 0;
@@ -166 +166 @@
  * returns d_type
  */
-static int sf_get_d_type(RTFMODE fMode)
+static int vbsf_get_d_type(RTFMODE fMode)
 {
     int d_type;
@@ -206 +206 @@
  * @returns 0 for success, 1 for end reached, Linux error code otherwise.
  */
-static int sf_getdent(struct file *dir, char d_name[NAME_MAX], int *d_type)
+static int vbsf_getdent(struct file *dir, char d_name[NAME_MAX], int *d_type)
 {
     loff_t cur;
@@ -227 +227 @@
 
     if (sf_i->force_reread) {
-        int err = sf_dir_open_worker(sf_g, sf_d, sf_i, "sf_getdent");
+        int err = vbsf_dir_open_worker(sf_g, sf_d, sf_i, "vbsf_getdent");
         if (!err) {
             sf_i->force_reread = 0;
         } else {
             if (err == -ENOENT) {
-                sf_dir_info_free(sf_d);
+                vbsf_dir_info_free(sf_d);
                 dir->private_data = NULL;
             }
@@ -260 +260 @@
         }
 
-        *d_type = sf_get_d_type(info->Info.Attr.fMode);
-
-        return sf_nlscpy(sf_g, d_name, NAME_MAX,
+        *d_type = vbsf_get_d_type(info->Info.Attr.fMode);
+
+        return vbsf_nlscpy(sf_g, d_name, NAME_MAX,
                  info->name.String.utf8, info->name.u16Length);
     }
@@ -274 +274 @@
  * [filldir]. [filldir] magically modifies it's argument - [opaque]
  * and takes following additional arguments (which i in turn get from
- * the host via sf_getdent):
+ * the host via vbsf_getdent):
  *
  * name : name of the entry (i must also supply it's length huh?)
@@ -288 +288 @@
  * along the way) and feed them to [filldir] until:
  *
- * a. there are no more entries (i.e. sf_getdent set done to 1)
+ * a. there are no more entries (i.e. vbsf_getdent set done to 1)
  * b. failure to compute fake inode number
  * c. filldir returns an error (see comment on that)
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-static int sf_dir_iterate(struct file *dir, struct dir_context *ctx)
+static int vbsf_dir_iterate(struct file *dir, struct dir_context *ctx)
 #else
-static int sf_dir_read(struct file *dir, void *opaque, filldir_t filldir)
+static int vbsf_dir_read(struct file *dir, void *opaque, filldir_t filldir)
 #endif
 {
@@ -306 +306 @@
         int d_type = DT_UNKNOWN;
 
-        err = sf_getdent(dir, d_name, &d_type);
+        err = vbsf_getdent(dir, d_name, &d_type);
         switch (err) {
         case 1:
@@ -317 +317 @@
         default:
             /* skip erroneous entry and proceed */
-            LogFunc(("sf_getdent error %d\n", err));
+            LogFunc(("vbsf_getdent error %d\n", err));
             dir->f_pos += 1;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
@@ -362 +362 @@
 }
 
-struct file_operations sf_dir_fops = {
-    .open = sf_dir_open,
+struct file_operations vbsf_dir_fops = {
+    .open = vbsf_dir_open,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-    .iterate = sf_dir_iterate,
+    .iterate = vbsf_dir_iterate,
 #else
-    .readdir = sf_dir_read,
-#endif
-    .release = sf_dir_release,
+    .readdir = vbsf_dir_read,
+#endif
+    .release = vbsf_dir_release,
     .read = generic_read_dir
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
@@ -379 +379 @@
 
 /**
- * Worker for sf_lookup() and sf_instantiate().
- */
-static struct inode *sf_create_inode(struct inode *parent, struct dentry *dentry, PSHFLSTRING path,
-                                     PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g, bool fInstantiate)
+ * Worker for vbsf_inode_lookup() and vbsf_inode_instantiate().
+ */
+static struct inode *vbsf_create_inode(struct inode *parent, struct dentry *dentry, PSHFLSTRING path,
+                                       PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g, bool fInstantiate)
 {
     /*
@@ -410 +410 @@
 
             SET_INODE_INFO(pInode, sf_new_i);
-            sf_init_inode(pInode, sf_new_i, pObjInfo, sf_g);
+            vbsf_init_inode(pInode, sf_new_i, pObjInfo, sf_g);
 
             /*
@@ -439 +439 @@
  * returned in case of success and "negative" pointer on error
  */
-static struct dentry *sf_lookup(struct inode *parent, struct dentry *dentry
+static struct dentry *vbsf_inode_lookup(struct inode *parent, struct dentry *dentry
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
-                                , unsigned int flags
+                                        , unsigned int flags
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-                                , struct nameidata *nd
-#endif
-                                )
+                                        , struct nameidata *nd
+#endif
+                                        )
 {
     struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(parent->i_sb);
@@ -454 +454 @@
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
-    SFLOGFLOW(("sf_lookup: parent=%p dentry=%p flags=%#x\n", parent, dentry, flags));
+    SFLOGFLOW(("vbsf_inode_lookup: parent=%p dentry=%p flags=%#x\n", parent, dentry, flags));
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    SFLOGFLOW(("sf_lookup: parent=%p dentry=%p nd=%p{.flags=%#x}\n", parent, dentry, nd, nd ? nd->flags : 0));
+    SFLOGFLOW(("vbsf_inode_lookup: parent=%p dentry=%p nd=%p{.flags=%#x}\n", parent, dentry, nd, nd ? nd->flags : 0));
 #else
-    SFLOGFLOW(("sf_lookup: parent=%p dentry=%p\n", parent, dentry));
+    SFLOGFLOW(("vbsf_inode_lookup: parent=%p dentry=%p\n", parent, dentry));
 #endif
 
@@ -467 +467 @@
      * Build the path.  We'll associate the path with dret's inode on success.
      */
-    rc = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+    rc = vbsf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
     if (rc == 0) {
         /*
@@ -489 +489 @@
                      * the existence of all parent dentries, we increase their TTL.
                      */
-                    pInode = sf_create_inode(parent, dentry, path, &pReq->CreateParms.Info, sf_g, false /*fInstantiate*/);
+                    pInode = vbsf_create_inode(parent, dentry, path, &pReq->CreateParms.Info, sf_g, false /*fInstantiate*/);
                     if (rc == 0) {
                         path = NULL; /* given to the inode */
@@ -495 +495 @@
                     } else
                         dret = (struct dentry *)ERR_PTR(-ENOMEM);
-                    sf_dentry_chain_increase_parent_ttl(dentry);
+                    vbsf_dentry_chain_increase_parent_ttl(dentry);
                 } else if (   pReq->CreateParms.Result == SHFL_FILE_NOT_FOUND
                        || pReq->CreateParms.Result == SHFL_PATH_NOT_FOUND /*this probably should happen*/) {
@@ -516 +516 @@
              */
             if (dret == dentry) {
-                sf_dentry_set_update_jiffies(dentry, jiffies);
+                vbsf_dentry_set_update_jiffies(dentry, jiffies);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
-                Assert(dentry->d_op == &sf_dentry_ops); /* (taken from the superblock) */
+                Assert(dentry->d_op == &vbsf_dentry_ops); /* (taken from the superblock) */
 #else
-                dentry->d_op = &sf_dentry_ops;
+                dentry->d_op = &vbsf_dentry_ops;
 #endif
                 d_add(dentry, pInode);
@@ -546 +546 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_instantiate(struct inode *parent, struct dentry *dentry, PSHFLSTRING path, PSHFLFSOBJINFO info, SHFLHANDLE handle)
+static int vbsf_inode_instantiate(struct inode *parent, struct dentry *dentry, PSHFLSTRING path,
+                                  PSHFLFSOBJINFO info, SHFLHANDLE handle)
 {
     struct vbsf_super_info *sf_g   = VBSF_GET_SUPER_INFO(parent->i_sb);
-    struct inode           *pInode = sf_create_inode(parent, dentry, path, info, sf_g, true /*fInstantiate*/);
+    struct inode           *pInode = vbsf_create_inode(parent, dentry, path, info, sf_g, true /*fInstantiate*/);
     if (pInode) {
         /* Store this handle if we leave the handle open. */
@@ -568 +569 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_create_aux(struct inode *parent, struct dentry *dentry, umode_t mode, int fDirectory)
+static int vbsf_create_worker(struct inode *parent, struct dentry *dentry, umode_t mode, int fDirectory)
 {
     int rc, err;
@@ -585 +586 @@
     BUG_ON(!sf_g);
 
-    err = sf_path_from_dentry(__func__, sf_g, sf_parent_i, dentry, &path);
+    err = vbsf_path_from_dentry(__func__, sf_g, sf_parent_i, dentry, &path);
     if (err)
         goto fail0;
 
-    /** @todo combine with sf_path_from_dentry? */
+    /** @todo combine with vbsf_path_from_dentry? */
     pReq = (union CreateAuxReq *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFCREATEREQ, StrPath.String) + path->u16Size);
     if (pReq) {
@@ -629 +630 @@
     }
 
-    sf_dentry_chain_increase_parent_ttl(dentry);
-
-    err = sf_instantiate(parent, dentry, path, &pCreateParms->Info,
+    vbsf_dentry_chain_increase_parent_ttl(dentry);
+
+    err = vbsf_inode_instantiate(parent, dentry, path, &pCreateParms->Info,
                  fDirectory ? SHFL_HANDLE_NIL : pCreateParms->Handle);
     if (err) {
@@ -640 +641 @@
     /*
      * Don't close this handle right now. We assume that the same file is
-     * opened with sf_reg_open() and later closed with sf_reg_close(). Save
+     * opened with vbsf_reg_open() and later closed with sf_reg_close(). Save
      * the handle in between. Does not apply to directories. True?
      */
@@ -677 +678 @@
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0) || defined(DOXYGEN_RUNNING)
-static int sf_create(struct inode *parent, struct dentry *dentry, umode_t mode, bool excl)
+static int vbsf_inode_create(struct inode *parent, struct dentry *dentry, umode_t mode, bool excl)
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)
-static int sf_create(struct inode *parent, struct dentry *dentry, umode_t mode, struct nameidata *nd)
+static int vbsf_inode_create(struct inode *parent, struct dentry *dentry, umode_t mode, struct nameidata *nd)
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-static int sf_create(struct inode *parent, struct dentry *dentry, int mode, struct nameidata *nd)
+static int vbsf_inode_create(struct inode *parent, struct dentry *dentry, int mode, struct nameidata *nd)
 #else
-static int sf_create(struct inode *parent, struct dentry *dentry, int mode)
+static int vbsf_inode_create(struct inode *parent, struct dentry *dentry, int mode)
 #endif
 {
@@ -690 +691 @@
  *        changed (investigate)... */
     TRACE();
-    return sf_create_aux(parent, dentry, mode, 0 /*fDirectory*/);
+    return vbsf_create_worker(parent, dentry, mode, 0 /*fDirectory*/);
 }
 
@@ -702 +703 @@
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)
-static int sf_mkdir(struct inode *parent, struct dentry *dentry, umode_t mode)
+static int vbsf_inode_mkdir(struct inode *parent, struct dentry *dentry, umode_t mode)
 #else
-static int sf_mkdir(struct inode *parent, struct dentry *dentry, int mode)
-#endif
-{
-    TRACE();
-    return sf_create_aux(parent, dentry, mode, 1 /*fDirectory*/);
+static int vbsf_inode_mkdir(struct inode *parent, struct dentry *dentry, int mode)
+#endif
+{
+    TRACE();
+    return vbsf_create_worker(parent, dentry, mode, 1 /*fDirectory*/);
 }
 
@@ -719 +720 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_unlink_aux(struct inode *parent, struct dentry *dentry, int fDirectory)
+static int vbsf_unlink_worker(struct inode *parent, struct dentry *dentry, int fDirectory)
 {
     int rc, err;
@@ -729 +730 @@
     BUG_ON(!sf_g);
 
-    err = sf_path_from_dentry(__func__, sf_g, sf_parent_i, dentry, &path);
+    err = vbsf_path_from_dentry(__func__, sf_g, sf_parent_i, dentry, &path);
     if (!err) {
         VBOXSFREMOVEREQ *pReq = (VBOXSFREMOVEREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String)
@@ -777 +778 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_unlink(struct inode *parent, struct dentry *dentry)
-{
-    TRACE();
-    return sf_unlink_aux(parent, dentry, 0 /*fDirectory*/);
+static int vbsf_inode_unlink(struct inode *parent, struct dentry *dentry)
+{
+    TRACE();
+    return vbsf_unlink_worker(parent, dentry, false /*fDirectory*/);
 }
 
@@ -790 +791 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_rmdir(struct inode *parent, struct dentry *dentry)
-{
-    TRACE();
-    return sf_unlink_aux(parent, dentry, 1 /*fDirectory*/);
+static int vbsf_inode_rmdir(struct inode *parent, struct dentry *dentry)
+{
+    TRACE();
+    return vbsf_unlink_worker(parent, dentry, true /*fDirectory*/);
 }
 
@@ -806 +807 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_rename(struct inode *old_parent, struct dentry *old_dentry,
-                     struct inode *new_parent, struct dentry *new_dentry
+static int vbsf_inode_rename(struct inode *old_parent, struct dentry *old_dentry,
+                             struct inode *new_parent, struct dentry *new_dentry
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
-                     , unsigned flags
-#endif
-                     )
+                             , unsigned flags
+#endif
+                             )
 {
     int err = 0, rc = VINF_SUCCESS;
@@ -842 +843 @@
 
         old_path = sf_file_i->path;
-        err = sf_path_from_dentry(__func__, sf_g, sf_new_i,
-                      new_dentry, &new_path);
+        err = vbsf_path_from_dentry(__func__, sf_g, sf_new_i, new_dentry, &new_path);
         if (err)
             LogFunc(("failed to create new path\n"));
         else {
             VBOXSFRENAMEWITHSRCBUFREQ *pReq;
-            pReq = (VBOXSFRENAMEWITHSRCBUFREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ,
-                                                 StrDstPath.String)
-                                        + new_path->u16Size);
+            pReq = (VBOXSFRENAMEWITHSRCBUFREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, StrDstPath.String)
+                                                                    + new_path->u16Size);
             if (pReq) {
                 memcpy(&pReq->StrDstPath, new_path, SHFLSTRING_HEADER_SIZE + new_path->u16Size);
                 rc = VbglR0SfHostReqRenameWithSrcContig(sf_g->map.root, pReq,
-                                    old_path, virt_to_phys(old_path),
-                                    old_dentry->d_inode->i_mode & S_IFDIR ? SHFL_RENAME_DIR
-                                    : SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
+                                                        old_path, virt_to_phys(old_path),
+                                                        old_dentry->d_inode->i_mode & S_IFDIR ? SHFL_RENAME_DIR
+                                                        : SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
                 VbglR0PhysHeapFree(pReq);
             } else
@@ -867 +866 @@
                 /* Set the new relative path in the inode. */
                 sf_file_i->path = new_path;
-
             } else {
                 LogFunc(("VbglR0SfRename failed rc=%Rrc\n",
@@ -880 +878 @@
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-static int sf_symlink(struct inode *parent, struct dentry *dentry, const char *symname)
+static int vbsf_ino_symlink(struct inode *parent, struct dentry *dentry, const char *symname)
 {
     int err;
@@ -897 +895 @@
     BUG_ON(!sf_i);
 
-    err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+    err = vbsf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
     if (err)
         goto fail0;
 
-    ssymname =
-        kmalloc(offsetof(SHFLSTRING, String.utf8) + symname_len,
-            GFP_KERNEL);
+    ssymname = kmalloc(offsetof(SHFLSTRING, String.utf8) + symname_len, GFP_KERNEL);
     if (!ssymname) {
         LogRelFunc(("kmalloc failed, caller=sf_symlink\n"));
@@ -914 +910 @@
     memcpy(ssymname->String.utf8, symname, symname_len);
 
-    rc = VbglR0SfSymlink(&client_handle, &sf_g->map, path, ssymname, &info);
+    rc = VbglR0SfSymlink(&g_SfClient, &sf_g->map, path, ssymname, &info);
     kfree(ssymname);
 
@@ -922 +918 @@
             goto fail1;
         }
-        LogFunc(("VbglR0SfSymlink(%s) failed rc=%Rrc\n",
-             sf_i->path->String.utf8, rc));
+        LogFunc(("VbglR0SfSymlink(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
         err = -EPROTO;
         goto fail1;
     }
 
-    err = sf_instantiate(parent, dentry, path, &info, SHFL_HANDLE_NIL);
+    err = vbsf_inode_instantiate(parent, dentry, path, &info, SHFL_HANDLE_NIL);
     if (err) {
-        LogFunc(("could not instantiate dentry for %s err=%d\n",
-             sf_i->path->String.utf8, err));
+        LogFunc(("could not instantiate dentry for %s err=%d\n", sf_i->path->String.utf8, err));
         goto fail1;
     }
@@ -945 +939 @@
 #endif /* LINUX_VERSION_CODE >= 2.6.0 */
 
-struct inode_operations sf_dir_iops = {
-    .lookup = sf_lookup,
-    .create = sf_create,
-    .mkdir = sf_mkdir,
-    .rmdir = sf_rmdir,
-    .unlink = sf_unlink,
-    .rename = sf_rename,
+struct inode_operations vbsf_dir_iops = {
+    .lookup = vbsf_inode_lookup,
+    .create = vbsf_inode_create,
+    .mkdir = vbsf_inode_mkdir,
+    .rmdir = vbsf_inode_rmdir,
+    .unlink = vbsf_inode_unlink,
+    .rename = vbsf_inode_rename,
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-    .revalidate = sf_inode_revalidate
+    .revalidate = vbsf_inode_revalidate
 #else
-    .getattr = sf_getattr,
-    .setattr = sf_setattr,
-    .symlink = sf_symlink
+    .getattr = vbsf_inode_getattr,
+    .setattr = vbsf_inode_setattr,
+    .symlink = vbsf_ino_symlink
 #endif
 };

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

@@ -34 +34 @@
 
 # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
+
 #  if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
-static const char *sf_follow_link(struct dentry *dentry, void **cookie)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
-static void *sf_follow_link(struct dentry *dentry, struct nameidata *nd)
-#else
-static int sf_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *vbsf_follow_link(struct dentry *dentry, void **cookie)
+#  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+static void       *vbsf_follow_link(struct dentry *dentry, struct nameidata *nd)
+#  else
+static int         vbsf_follow_link(struct dentry *dentry, struct nameidata *nd)
 #  endif
 {
@@ -51 +52 @@
     if (path) {
         error = 0;
-        rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path,
+        rc = VbglR0SfReadLink(&g_SfClient, &sf_g->map, sf_i->path,
                       PATH_MAX, path);
         if (RT_FAILURE(rc)) {
@@ -63 +64 @@
 #  else
     nd_set_link(nd, error ? ERR_PTR(error) : path);
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
     return NULL;
-# else
+#   else
     return 0;
-# endif
-#endif
+#   endif
+#  endif
 }
 
 #  if LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
-static void sf_put_link(struct dentry *dentry, struct nameidata *nd,
-            void *cookie)
-#else
-static void sf_put_link(struct dentry *dentry, struct nameidata *nd)
-#endif
+#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+static void vbsf_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+#   else
+static void vbsf_put_link(struct dentry *dentry, struct nameidata *nd)
+#   endif
 {
     char *page = nd_get_link(nd);
@@ -83 +83 @@
         free_page((unsigned long)page);
 }
-#  endif
+#  endif /* < 4.2.0 */
 
-# else  /* LINUX_VERSION_CODE >= 4.5.0 */
-static const char *sf_get_link(struct dentry *dentry, struct inode *inode,
-                               struct delayed_call *done)
+# else  /* >= 4.5.0 */
+
+static const char *vbsf_get_link(struct dentry *dentry, struct inode *inode, struct delayed_call *done)
 {
     struct vbsf_super_info *sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
@@ -99 +99 @@
     if (!path)
         return ERR_PTR(-ENOMEM);
-    rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path, PATH_MAX,
-                  path);
+    rc = VbglR0SfReadLink(&g_SfClient, &sf_g->map, sf_i->path, PATH_MAX, path);
     if (RT_FAILURE(rc)) {
-        LogFunc(("VbglR0SfReadLink failed, caller=%s, rc=%Rrc\n",
-             __func__, rc));
+        LogFunc(("VbglR0SfReadLink failed, rc=%Rrc\n", rc));
         kfree(path);
         return ERR_PTR(-EPROTO);
@@ -110 +108 @@
     return path;
 }
-# endif /* LINUX_VERSION_CODE >= 4.5.0 */
 
-struct inode_operations sf_lnk_iops = {
+# endif /* >= 4.5.0 */
+
+struct inode_operations vbsf_lnk_iops = {
 # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
     .readlink = generic_readlink,
 # endif
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
-    .get_link = sf_get_link
+    .get_link = vbsf_get_link
 # elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
-    .follow_link = sf_follow_link,
+    .follow_link = vbsf_follow_link,
     .put_link = free_page_put_link,
 # else
-    .follow_link = sf_follow_link,
-    .put_link = sf_put_link
+    .follow_link = vbsf_follow_link,
+    .put_link = vbsf_put_link
 # endif
 };

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

@@ -58 +58 @@
  * @param   pInodeInfo  The inode which handles to drop.
  */
-void sf_handle_drop_chain(struct sf_inode_info *pInodeInfo)
+void vbsf_handle_drop_chain(struct sf_inode_info *pInodeInfo)
 {
     struct sf_handle *pCur, *pNext;
     unsigned long     fSavedFlags;
-    SFLOGFLOW(("sf_handle_drop_chain: %p\n", pInodeInfo));
+    SFLOGFLOW(("vbsf_handle_drop_chain: %p\n", pInodeInfo));
     spin_lock_irqsave(&g_SfHandleLock, fSavedFlags);
 
@@ -79 +79 @@
  * Locates a handle that matches all the flags in @a fFlags.
  *
- * @returns Pointer to handle on success (retained), use sf_handle_release() to
+ * @returns Pointer to handle on success (retained), use vbsf_handle_release() to
  *          release it.  NULL if no suitable handle was found.
  * @param   pInodeInfo  The inode info to search.
@@ -85 +85 @@
  * @param   fFlagsClear The flags that must be clear.
  */
-struct sf_handle *sf_handle_find(struct sf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear)
+struct sf_handle *vbsf_handle_find(struct sf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear)
 {
     struct sf_handle *pCur;
@@ -98 +98 @@
             if (cRefs > 1) {
                 spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
-                SFLOGFLOW(("sf_handle_find: returns %p\n", pCur));
+                SFLOGFLOW(("vbsf_handle_find: returns %p\n", pCur));
                 return pCur;
             }
@@ -107 +107 @@
 
     spin_unlock_irqrestore(&g_SfHandleLock, fSavedFlags);
-    SFLOGFLOW(("sf_handle_find: returns NULL!\n"));
+    SFLOGFLOW(("vbsf_handle_find: returns NULL!\n"));
     return NULL;
 }
@@ -113 +113 @@
 
 /**
- * Slow worker for sf_handle_release() that does the freeing.
+ * Slow worker for vbsf_handle_release() that does the freeing.
  *
  * @returns 0 (ref count).
@@ -121 +121 @@
  * @param   pszCaller       The caller name (for logging failures).
  */
-uint32_t sf_handle_release_slow(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
+uint32_t vbsf_handle_release_slow(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
 {
     int rc;
     unsigned long fSavedFlags;
 
-    SFLOGFLOW(("sf_handle_release_slow: %p (%s)\n", pHandle, pszCaller));
+    SFLOGFLOW(("vbsf_handle_release_slow: %p (%s)\n", pHandle, pszCaller));
 
     /*
@@ -163 +163 @@
  * @param   pHandle             The handle to add.
  */
-void sf_handle_append(struct sf_inode_info *pInodeInfo, struct sf_handle *pHandle)
+void vbsf_handle_append(struct sf_inode_info *pInodeInfo, struct sf_handle *pHandle)
 {
 #ifdef VBOX_STRICT
@@ -170 +170 @@
     unsigned long fSavedFlags;
 
-    SFLOGFLOW(("sf_handle_append: %p (to %p)\n", pHandle, pInodeInfo));
+    SFLOGFLOW(("vbsf_handle_append: %p (to %p)\n", pHandle, pInodeInfo));
     AssertMsg((pHandle->fFlags & (SF_HANDLE_F_MAGIC_MASK | SF_HANDLE_F_ON_LIST)) == SF_HANDLE_F_MAGIC,
           ("%p %#x\n", pHandle, pHandle->fFlags));
@@ -198 +198 @@
  && LINUX_VERSION_CODE <  KERNEL_VERSION(2, 6, 31)
 
-void free_pipebuf(struct page *kpage)
+/*
+ * Some pipe stuff we apparently need for 2.6.23-2.6.30.
+ */
+
+static void vbsf_free_pipebuf(struct page *kpage)
 {
     kunmap(kpage);
@@ -204 +208 @@
 }
 
-void *sf_pipe_buf_map(struct pipe_inode_info *pipe,
-              struct pipe_buffer *pipe_buf, int atomic)
+static void *vbsf_pipe_buf_map(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf, int atomic)
 {
     return 0;
 }
 
-void sf_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf)
-{
-}
-
-void sf_pipe_buf_unmap(struct pipe_inode_info *pipe,
-               struct pipe_buffer *pipe_buf, void *map_data)
-{
-}
-
-int sf_pipe_buf_steal(struct pipe_inode_info *pipe,
-              struct pipe_buffer *pipe_buf)
+static void vbsf_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf)
+{
+}
+
+static void vbsf_pipe_buf_unmap(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf, void *map_data)
+{
+}
+
+static int vbsf_pipe_buf_steal(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf)
 {
     return 0;
 }
 
-static void sf_pipe_buf_release(struct pipe_inode_info *pipe,
-                struct pipe_buffer *pipe_buf)
-{
-    free_pipebuf(pipe_buf->page);
-}
-
-int sf_pipe_buf_confirm(struct pipe_inode_info *info,
-            struct pipe_buffer *pipe_buf)
+static void vbsf_pipe_buf_release(struct pipe_inode_info *pipe, struct pipe_buffer *pipe_buf)
+{
+    vbsf_free_pipebuf(pipe_buf->page);
+}
+
+static int vbsf_pipe_buf_confirm(struct pipe_inode_info *info, struct pipe_buffer *pipe_buf)
 {
     return 0;
 }
 
-static struct pipe_buf_operations sf_pipe_buf_ops = {
+static struct pipe_buf_operations vbsf_pipe_buf_ops = {
     .can_merge = 0,
-    .map = sf_pipe_buf_map,
-    .unmap = sf_pipe_buf_unmap,
-    .confirm = sf_pipe_buf_confirm,
-    .release = sf_pipe_buf_release,
-    .steal = sf_pipe_buf_steal,
-    .get = sf_pipe_buf_get,
+    .map = vbsf_pipe_buf_map,
+    .unmap = vbsf_pipe_buf_unmap,
+    .confirm = vbsf_pipe_buf_confirm,
+    .release = vbsf_pipe_buf_release,
+    .steal = vbsf_pipe_buf_steal,
+    .get = vbsf_pipe_buf_get,
 };
 
-static int sf_reg_read_aux(const char *caller, struct vbsf_super_info *sf_g,
-               struct sf_reg_info *sf_r, void *buf,
-               uint32_t * nread, uint64_t pos)
-{
-    int rc = VbglR0SfRead(&client_handle, &sf_g->map, sf_r->Handle.hHost,
-                  pos, nread, buf, false /* already locked? */ );
+static int vbsf_reg_read_aux(const char *caller, struct vbsf_super_info *sf_g, struct sf_reg_info *sf_r,
+                             void *buf, uint32_t *nread, uint64_t pos)
+{
+    int rc = VbglR0SfRead(&g_SfClient, &sf_g->map, sf_r->Handle.hHost, pos, nread, buf, false /* already locked? */ );
     if (RT_FAILURE(rc)) {
         LogFunc(("VbglR0SfRead failed. caller=%s, rc=%Rrc\n", caller,
@@ -264 +261 @@
 # define UNLOCK_PIPE(pipe) do { if (pipe->inode) mutex_unlock(&pipe->inode->i_mutex); } while (0)
 
-ssize_t
-sf_splice_read(struct file *in, loff_t * poffset,
-           struct pipe_inode_info *pipe, size_t len, unsigned int flags)
+ssize_t vbsf_splice_read(struct file *in, loff_t * poffset, struct pipe_inode_info *pipe, size_t len, unsigned int flags)
 {
     size_t bytes_remaining = len;
@@ -298 +293 @@
         }
         req_size = 0;
-        uint32_t nread = req_size =
-            (uint32_t) min(bytes_remaining, (size_t) PAGE_SIZE);
+        uint32_t nread = req_size = (uint32_t) min(bytes_remaining, (size_t) PAGE_SIZE);
         uint32_t chunk = 0;
         void *kbuf = kmap(kpage);
         while (chunk < req_size) {
-            retval =
-                sf_reg_read_aux(__func__, sf_g, sf_r, kbuf + chunk,
-                        &nread, offset);
+            retval = vbsf_reg_read_aux(__func__, sf_g, sf_r, kbuf + chunk, &nread, offset);
             if (retval < 0)
                 goto err;
@@ -320 +312 @@
         }
         if (pipe->nrbufs < PIPE_BUFFERS) {
-            struct pipe_buffer *pipebuf =
-                pipe->bufs +
-                ((pipe->curbuf + pipe->nrbufs) & (PIPE_BUFFERS -
-                                  1));
+            struct pipe_buffer *pipebuf = pipe->bufs + ((pipe->curbuf + pipe->nrbufs) & (PIPE_BUFFERS - 1));
             pipebuf->page = kpage;
-            pipebuf->ops = &sf_pipe_buf_ops;
+            pipebuf->ops = &vbsf_pipe_buf_ops;
             pipebuf->len = req_size;
             pipebuf->offset = 0;
@@ -341 +330 @@
                 goto err;
             }
-            free_pipebuf(kpage);
+            vbsf_free_pipebuf(kpage);
             break;
         }
@@ -353 +342 @@
  err:
     UNLOCK_PIPE(pipe);
-    free_pipebuf(kpage);
+    vbsf_free_pipebuf(kpage);
     return retval;
 }
@@ -360 +349 @@
 
 
-/** Companion to sf_lock_user_pages(). */
-DECLINLINE(void) sf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty)
+/** Companion to vbsf_lock_user_pages(). */
+DECLINLINE(void) vbsf_unlock_user_pages(struct page **papPages, size_t cPages, bool fSetDirty)
 {
     while (cPages-- > 0)
@@ -378 +367 @@
 
 /** Wrapper around get_user_pages. */
-DECLINLINE(int) sf_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)
 {
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
@@ -400 +389 @@
         return cPagesLocked;
 
-    sf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/);
+    vbsf_unlock_user_pages(papPages, cPagesLocked, false /*fSetDirty*/);
 
     /* We could use uPtrFrom + cPagesLocked to get the correct status here... */
@@ -413 +402 @@
  * the file content.
  */
-static ssize_t sf_reg_read_mapped(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
+static ssize_t vbsf_reg_read_mapped(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
@@ -452 +441 @@
 
 /**
- * Fallback case of sf_reg_read() that locks the user buffers and let the host
+ * Fallback case of vbsf_reg_read() that locks the user buffers and let the host
  * write directly to them.
  */
-static ssize_t sf_reg_read_fallback(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off,
-                                    struct vbsf_super_info *sf_g, struct sf_reg_info *sf_r)
+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 sf_reg_info *sf_r)
 {
     /*
@@ -497 +486 @@
             }
 
-            rc = sf_lock_user_pages((uintptr_t)buf, cPages, true /*fWrite*/, papPages);
+            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, true /*fWrite*/, papPages);
             if (rc == 0) {
                 size_t iPage = cPages;
@@ -512 +501 @@
             rc = VbglR0SfHostReqReadPgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
 
-            sf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/);
+            vbsf_unlock_user_pages(papPages, cPages, true /*fSetDirty*/);
 
             if (RT_SUCCESS(rc)) {
@@ -569 +558 @@
  * @returns the number of read bytes on success, Linux error code otherwise
  */
-static ssize_t sf_reg_read(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
+static ssize_t vbsf_reg_read(struct file *file, char /*__user*/ *buf, size_t size, loff_t *off)
 {
     struct inode *inode = GET_F_DENTRY(file)->d_inode;
@@ -576 +565 @@
     struct address_space *mapping = inode->i_mapping;
 
-    SFLOGFLOW(("sf_reg_read: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
+    SFLOGFLOW(("vbsf_reg_read: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
 
     if (!S_ISREG(inode->i_mode)) {
@@ -599 +588 @@
         && !(file->f_flags & O_DIRECT)
         && 1 /** @todo make this behaviour configurable */ )
-        return sf_reg_read_mapped(file, buf, size, off);
+        return vbsf_reg_read_mapped(file, buf, size, off);
 
     /*
@@ -658 +647 @@
 #endif
 
-    return sf_reg_read_fallback(file, buf, size, off, sf_g, sf_r);
+    return vbsf_reg_read_fallback(file, buf, size, off, sf_g, sf_r);
 }
 
@@ -664 +653 @@
 /**
  * Wrapper around invalidate_mapping_pages() for page cache invalidation so that
- * the changes written via sf_reg_write are made visible to mmap users.
- */
-DECLINLINE(void) sf_reg_write_invalidate_mapping_range(struct address_space *mapping, loff_t offStart, loff_t offEnd)
+ * the changes written via vbsf_reg_write are made visible to mmap users.
+ */
+DECLINLINE(void) vbsf_reg_write_invalidate_mapping_range(struct address_space *mapping, loff_t offStart, loff_t offEnd)
 {
     /*
@@ -691 +680 @@
 
 /**
- * Fallback case of sf_reg_write() that locks the user buffers and let the host
+ * Fallback case of vbsf_reg_write() that locks the user buffers and let the host
  * write directly to them.
  */
-static ssize_t sf_reg_write_fallback(struct file *file, const char /*__user*/ *buf, size_t size, loff_t *off, loff_t offFile,
-                                     struct inode *inode, struct sf_inode_info *sf_i,
-                                     struct vbsf_super_info *sf_g, struct sf_reg_info *sf_r)
+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 sf_inode_info *sf_i,
+                                       struct vbsf_super_info *sf_g, struct sf_reg_info *sf_r)
 {
     /*
@@ -736 +725 @@
             }
 
-            rc = sf_lock_user_pages((uintptr_t)buf, cPages, false /*fWrite*/, papPages);
+            rc = vbsf_lock_user_pages((uintptr_t)buf, cPages, false /*fWrite*/, papPages);
             if (rc == 0) {
                 size_t iPage = cPages;
@@ -751 +740 @@
             rc = VbglR0SfHostReqWritePgLst(sf_g->map.root, pReq, sf_r->Handle.hHost, offFile, cbChunk, cPages);
 
-            sf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/);
+            vbsf_unlock_user_pages(papPages, cPages, false /*fSetDirty*/);
 
             if (RT_SUCCESS(rc)) {
@@ -765 +754 @@
                 if (offFile > i_size_read(inode))
                     i_size_write(inode, offFile);
-                sf_reg_write_invalidate_mapping_range(inode->i_mapping, offFile - cbActual, offFile);
+                vbsf_reg_write_invalidate_mapping_range(inode->i_mapping, offFile - cbActual, offFile);
 
                 /*
@@ -812 +801 @@
  * @returns the number of written bytes on success, Linux error code otherwise
  */
-static ssize_t sf_reg_write(struct file *file, const char *buf, size_t size,
-                loff_t * off)
+static ssize_t vbsf_reg_write(struct file *file, const char *buf, size_t size, loff_t * off)
 {
     struct inode           *inode   = GET_F_DENTRY(file)->d_inode;
@@ -822 +810 @@
     loff_t                  pos;
 
-    SFLOGFLOW(("sf_reg_write: inode=%p file=%p buf=%p size=%#zx off=%#llx\n", inode, file, buf, size, *off));
+    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);
@@ -882 +870 @@
                     if (pos > i_size_read(inode))
                         i_size_write(inode, pos);
-                    sf_reg_write_invalidate_mapping_range(mapping, pos - cbRet, pos);
+                    vbsf_reg_write_invalidate_mapping_range(mapping, pos - cbRet, pos);
                 } else
                     cbRet = -EPROTO;
@@ -916 +904 @@
                         if (pos > i_size_read(inode))
                             i_size_write(inode, pos);
-                        sf_reg_write_invalidate_mapping_range(mapping, pos - cbRet, pos);
+                        vbsf_reg_write_invalidate_mapping_range(mapping, pos - cbRet, pos);
                     } else
                         cbRet = -EPROTO;
@@ -933 +921 @@
 #endif
 
-    return sf_reg_write_fallback(file, buf, size, off, pos, inode, sf_i, sf_g, sf_r);
+    return vbsf_reg_write_fallback(file, buf, size, off, pos, inode, sf_i, sf_g, sf_r);
 }
 
@@ -944 +932 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_reg_open(struct inode *inode, struct file *file)
+static int vbsf_reg_open(struct inode *inode, struct file *file)
 {
     int rc, rc_linux = 0;
@@ -960 +948 @@
     SHFLCREATEPARMS *pCreateParms;  /* temp glue */
 
-    SFLOGFLOW(("sf_reg_open: inode=%p file=%p flags=%#x %s\n",
+    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);
@@ -979 +967 @@
     if (sf_i->handle != SHFL_HANDLE_NIL) {
         /*
-         * This inode was created with sf_create_aux(). Check the CreateFlags:
+         * This inode was created with vbsf_create_worker(). Check the CreateFlags:
          * O_CREAT, O_TRUNC: inherent true (file was just created). Not sure
          * about the access flags (SHFL_CF_ACCESS_*).
@@ -989 +977 @@
 
         sf_r->Handle.fFlags |= SF_HANDLE_F_READ | SF_HANDLE_F_WRITE; /** @todo check */
-        sf_handle_append(sf_i, &sf_r->Handle);
-        SFLOGFLOW(("sf_reg_open: returns 0 (#1) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
+        vbsf_handle_append(sf_i, &sf_r->Handle);
+        SFLOGFLOW(("vbsf_reg_open: returns 0 (#1) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
         return 0;
     }
@@ -1057 +1045 @@
 
     pCreateParms->Info.Attr.fMode = inode->i_mode;
-    LogFunc(("sf_reg_open: calling VbglR0SfHostReqCreate, file %s, flags=%#x, %#x\n", sf_i->path->String.utf8, file->f_flags, pCreateParms->CreateFlags));
+    LogFunc(("vbsf_reg_open: calling VbglR0SfHostReqCreate, file %s, flags=%#x, %#x\n", sf_i->path->String.utf8, file->f_flags, pCreateParms->CreateFlags));
     rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
     if (RT_FAILURE(rc)) {
@@ -1067 +1055 @@
 
     if (pCreateParms->Handle != SHFL_HANDLE_NIL) {
-        sf_dentry_chain_increase_ttl(dentry);
+        vbsf_dentry_chain_increase_ttl(dentry);
         rc_linux = 0;
     } else {
@@ -1079 +1067 @@
             break;
         case SHFL_FILE_EXISTS:
-            sf_dentry_chain_increase_ttl(dentry);
+            vbsf_dentry_chain_increase_ttl(dentry);
             rc_linux = -EEXIST;
             break;
         default:
-            sf_dentry_chain_increase_parent_ttl(dentry);
+            vbsf_dentry_chain_increase_parent_ttl(dentry);
             rc_linux = 0;
             break;
@@ -1092 +1080 @@
     sf_r->Handle.hHost = pCreateParms->Handle;
     file->private_data = sf_r;
-    sf_handle_append(sf_i, &sf_r->Handle);
+    vbsf_handle_append(sf_i, &sf_r->Handle);
     VbglR0PhysHeapFree(pReq);
-    SFLOGFLOW(("sf_reg_open: returns 0 (#2) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
+    SFLOGFLOW(("vbsf_reg_open: returns 0 (#2) - sf_i=%p hHost=%#llx\n", sf_i, sf_r->Handle.hHost));
     return rc_linux;
 }
@@ -1106 +1094 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_reg_release(struct inode *inode, struct file *file)
+static int vbsf_reg_release(struct inode *inode, struct file *file)
 {
     struct sf_reg_info *sf_r;
@@ -1112 +1100 @@
     struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
 
-    SFLOGFLOW(("sf_reg_release: inode=%p file=%p\n", inode, file));
+    SFLOGFLOW(("vbsf_reg_release: inode=%p file=%p\n", inode, file));
     sf_g = VBSF_GET_SUPER_INFO(inode->i_sb);
     sf_r = file->private_data;
@@ -1132 +1120 @@
     /* Release sf_r, closing the handle if we're the last user. */
     file->private_data = NULL;
-    sf_handle_release(&sf_r->Handle, sf_g, "sf_reg_release");
+    vbsf_handle_release(&sf_r->Handle, sf_g, "vbsf_reg_release");
 
     sf_i->handle = SHFL_HANDLE_NIL;
@@ -1147 +1135 @@
  * relative seeks.
  */
-static loff_t sf_reg_llseek(struct file *file, loff_t off, int whence)
-{
-    SFLOGFLOW(("sf_reg_llseek: file=%p off=%lld whence=%d\n", file, off, whence));
+static loff_t vbsf_reg_llseek(struct file *file, loff_t off, int whence)
+{
+    SFLOGFLOW(("vbsf_reg_llseek: file=%p off=%lld whence=%d\n", file, off, whence));
 
     switch (whence) {
@@ -1158 +1146 @@
         case SEEK_END: {
             struct sf_reg_info *sf_r = file->private_data;
-            int rc = sf_inode_revalidate_with_handle(GET_F_DENTRY(file), sf_r->Handle.hHost, true /*fForce*/,
+            int rc = vbsf_inode_revalidate_with_handle(GET_F_DENTRY(file), sf_r->Handle.hHost, true /*fForce*/,
                                  false /*fInodeLocked*/);
             if (rc == 0)
@@ -1182 +1170 @@
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
-static int sf_reg_fsync(struct file *file, loff_t start, loff_t end, int datasync)
+static int vbsf_reg_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
@@ -1191 +1179 @@
 }
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
-static int sf_reg_fsync(struct file *file, int datasync)
+static int vbsf_reg_fsync(struct file *file, int datasync)
 {
     return generic_file_fsync(file, datasync);
 }
 #else /* < 2.6.35 */
-static int sf_reg_fsync(struct file *file, struct dentry *dentry, int datasync)
+static int vbsf_reg_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
@@ -1232 +1220 @@
 
 
-struct file_operations sf_reg_fops = {
-    .read = sf_reg_read,
-    .open = sf_reg_open,
-    .write = sf_reg_write,
-    .release = sf_reg_release,
+/**
+ * File operations for regular files.
+ */
+struct file_operations vbsf_reg_fops = {
+    .read = vbsf_reg_read,
+    .open = vbsf_reg_open,
+    .write = vbsf_reg_write,
+    .release = vbsf_reg_release,
     .mmap = generic_file_mmap,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
@@ -1243 +1234 @@
  * cached.  Investigate. */
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
-    .splice_read = sf_splice_read,
+    .splice_read = vbsf_splice_read,
 # else
     .sendfile = generic_file_sendfile,
@@ -1251 +1242 @@
 # endif
 #endif
-    .llseek = sf_reg_llseek,
-    .fsync = sf_reg_fsync,
+    .llseek = vbsf_reg_llseek,
+    .fsync = vbsf_reg_fsync,
 };
 
-struct inode_operations sf_reg_iops = {
+struct inode_operations vbsf_reg_iops = {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-    .revalidate = sf_inode_revalidate
+    .revalidate = vbsf_inode_revalidate
 #else
-    .getattr = sf_getattr,
-    .setattr = sf_setattr
+    .getattr = vbsf_inode_getattr,
+    .setattr = vbsf_inode_setattr
 #endif
 };
+
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
@@ -1272 +1264 @@
  * shared+writeable fashion.
  */
-static int sf_readpage(struct file *file, struct page *page)
+static int vbsf_readpage(struct file *file, struct page *page)
 {
     struct inode *inode = GET_F_DENTRY(file)->d_inode;
     int           err;
 
-    SFLOGFLOW(("sf_readpage: inode=%p file=%p page=%p off=%#llx\n", inode, file, page, (uint64_t)page->index << PAGE_SHIFT));
+    SFLOGFLOW(("vbsf_readpage: inode=%p file=%p page=%p off=%#llx\n", inode, file, page, (uint64_t)page->index << PAGE_SHIFT));
 
     if (!is_bad_inode(inode)) {
@@ -1330 +1322 @@
  * fashion.
  */
-static int sf_writepage(struct page *page, struct writeback_control *wbc)
+static int vbsf_writepage(struct page *page, struct writeback_control *wbc)
 {
     struct address_space *mapping   = page->mapping;
     struct inode         *inode     = mapping->host;
     struct sf_inode_info *sf_i      = GET_INODE_INFO(inode);
-    struct sf_handle     *pHandle   = sf_handle_find(sf_i, SF_HANDLE_F_WRITE, SF_HANDLE_F_APPEND);
+    struct sf_handle     *pHandle   = vbsf_handle_find(sf_i, SF_HANDLE_F_WRITE, SF_HANDLE_F_APPEND);
     int                   err;
 
-    SFLOGFLOW(("sf_writepage: inode=%p page=%p off=%#llx pHandle=%p (%#llx)\n",
+    SFLOGFLOW(("vbsf_writepage: inode=%p page=%p off=%#llx pHandle=%p (%#llx)\n",
            inode, page,(uint64_t)page->index << PAGE_SHIFT, pHandle, pHandle->hHost));
 
@@ -1382 +1374 @@
         } else
             err = -ENOMEM;
-        sf_handle_release(pHandle, sf_g, "sf_writepage");
+        vbsf_handle_release(pHandle, sf_g, "vbsf_writepage");
     } else {
         static uint64_t volatile s_cCalls = 0;
         if (s_cCalls++ < 16)
-            printk("sf_writepage: no writable handle for %s..\n", sf_i->path->String.ach);
+            printk("vbsf_writepage: no writable handle for %s..\n", sf_i->path->String.ach);
         err = -EPROTO;
     }
@@ -1397 +1389 @@
  * Called when writing thru the page cache (which we shouldn't be doing).
  */
-int sf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
-           unsigned len, unsigned flags, struct page **pagep,
-           void **fsdata)
+int vbsf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
+                     unsigned len, unsigned flags, struct page **pagep, void **fsdata)
 {
     /** @todo r=bird: We shouldn't ever get here, should we?  Because we don't use
@@ -1407 +1398 @@
     static uint64_t volatile s_cCalls = 0;
     if (s_cCalls++ < 16) {
-        printk("vboxsf: Unexpected call to sf_write_begin(pos=%#llx len=%#x flags=%#x)! Please report.\n",
+        printk("vboxsf: Unexpected call to vbsf_write_begin(pos=%#llx len=%#x flags=%#x)! Please report.\n",
                (unsigned long long)pos, len, flags);
-        RTLogBackdoorPrintf("vboxsf: Unexpected call to sf_write_begin(pos=%#llx len=%#x flags=%#x)!  Please report.\n",
+        RTLogBackdoorPrintf("vboxsf: Unexpected call to vbsf_write_begin(pos=%#llx len=%#x flags=%#x)!  Please report.\n",
                     (unsigned long long)pos, len, flags);
 #  ifdef WARN_ON
@@ -1425 +1416 @@
  */
 #  if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)
-static ssize_t sf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+static ssize_t vbsf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
-static ssize_t sf_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
+static ssize_t vbsf_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
-static ssize_t sf_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
+static ssize_t vbsf_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 6)
-static ssize_t sf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
+static ssize_t vbsf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 55)
-static int sf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
+static int vbsf_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
-static int sf_direct_IO(int rw, struct file *file, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
+static int vbsf_direct_IO(int rw, struct file *file, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 35)
-static int sf_direct_IO(int rw, struct inode *inode, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
+static int vbsf_direct_IO(int rw, struct inode *inode, const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 #  elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 26)
-static int sf_direct_IO(int rw, struct inode *inode, char *buf, loff_t offset, size_t count)
+static int vbsf_direct_IO(int rw, struct inode *inode, char *buf, loff_t offset, size_t count)
 #  else
-static int sf_direct_IO(int rw, struct inode *inode, struct kiobuf *, unsigned long, int)
+static int vbsf_direct_IO(int rw, struct inode *inode, struct kiobuf *, unsigned long, int)
 #  endif
 {
@@ -1449 +1440 @@
 # endif
 
-struct address_space_operations sf_reg_aops = {
-    .readpage = sf_readpage,
-    .writepage = sf_writepage,
+/**
+ * Address space (for the page cache) operations for regular files.
+ */
+struct address_space_operations vbsf_reg_aops = {
+    .readpage = vbsf_readpage,
+    .writepage = vbsf_writepage,
     /** @todo Need .writepages if we want msync performance...  */
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 12)
@@ -1457 +1451 @@
 # endif
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
-    .write_begin = sf_write_begin,
+    .write_begin = vbsf_write_begin,
     .write_end = simple_write_end,
 # else
@@ -1464 +1458 @@
 # endif
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 10)
-    .direct_IO = sf_direct_IO,
+    .direct_IO = vbsf_direct_IO,
 # endif
 };

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

@@ -41 +41 @@
  */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-DECLINLINE(void) sf_ftime_from_timespec(time_t *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
+DECLINLINE(void) vbsf_time_to_linux(time_t *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
 {
     int64_t t = RTTimeSpecGetNano(pVBoxSrc);
@@ -49 +49 @@
 #else   /* >= 2.6.0 */
 # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
-DECLINLINE(void) sf_ftime_from_timespec(struct timespec *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
+DECLINLINE(void) vbsf_time_to_linux(struct timespec *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
 # else
-DECLINLINE(void) sf_ftime_from_timespec(struct timespec64 *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
+DECLINLINE(void) vbsf_time_to_linux(struct timespec64 *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
 # endif
 {
@@ -65 +65 @@
  */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-DECLINLINE(void) sf_timespec_from_ftime(PRTTIMESPEC pVBoxDst, time_t *pLinuxSrc)
+DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, time_t *pLinuxSrc)
 {
     RTTimeSpecSetNano(pVBoxDst, RT_NS_1SEC_64 * *pLinuxSrc);
@@ -71 +71 @@
 #else   /* >= 2.6.0 */
 # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
-DECLINLINE(void) sf_timespec_from_ftime(PRTTIMESPEC pVBoxDst, struct timespec const *pLinuxSrc)
+DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, struct timespec const *pLinuxSrc)
 # else
-DECLINLINE(void) sf_timespec_from_ftime(PRTTIMESPEC pVBoxDst, struct timespec64 const *pLinuxSrc)
+DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, struct timespec64 const *pLinuxSrc)
 # endif
 {
@@ -82 +82 @@
 
 /**
- * Converts VBox access permissions  to Linux ones (mode & 0777).
+ * Converts Linux access permissions to VBox ones (mode & 0777).
  *
  * @note Currently identical.
  */
-DECLINLINE(int) sf_convert_access_perms(uint32_t fAttr)
+DECLINLINE(uint32_t) sf_access_permissions_to_vbox(int fAttr)
 {
     /* Access bits should be the same: */
@@ -104 +104 @@
 
 /**
+ * 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.
  */
-DECLINLINE(int) sf_convert_file_mode(uint32_t fVBoxMode, int fFixedMode, int fClearMask, int fType)
-{
-    int fLnxMode = sf_convert_access_perms(fVBoxMode);
+DECLINLINE(int) sf_file_mode_to_linux(uint32_t fVBoxMode, int fFixedMode, int fClearMask, int fType)
+{
+    int fLnxMode = sf_access_permissions_to_linux(fVBoxMode);
     if (fFixedMode != ~0)
         fLnxMode = fFixedMode & 0777;
@@ -120 +142 @@
  * Initializes the @a inode attributes based on @a pObjInfo and @a sf_g options.
  */
-void sf_init_inode(struct inode *inode, struct sf_inode_info *sf_i, PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g)
+void vbsf_init_inode(struct inode *inode, struct sf_inode_info *sf_i, PSHFLFSOBJINFO pObjInfo, struct vbsf_super_info *sf_g)
 {
     PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
@@ -130 +152 @@
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    inode->i_mapping->a_ops = &sf_reg_aops;
+    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. */
@@ -136 +158 @@
 #endif
     if (RTFS_IS_DIRECTORY(pAttr->fMode)) {
-        inode->i_mode = sf_convert_file_mode(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
-        inode->i_op = &sf_dir_iops;
-        inode->i_fop = &sf_dir_fops;
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
+        inode->i_op = &vbsf_dir_iops;
+        inode->i_fop = &vbsf_dir_fops;
 
         /* XXX: this probably should be set to the number of entries
@@ -148 +170 @@
         /** @todo r=bird: Aren't System V symlinks w/o any mode mask? IIRC there is
          *        no lchmod on Linux. */
-        inode->i_mode = sf_convert_file_mode(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
-        inode->i_op = &sf_lnk_iops;
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
+        inode->i_op = &vbsf_lnk_iops;
         set_nlink(inode, 1);
     }
 #endif
     else {
-        inode->i_mode = sf_convert_file_mode(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
-        inode->i_op = &sf_reg_iops;
-        inode->i_fop = &sf_reg_fops;
+        inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
+        inode->i_op = &vbsf_reg_iops;
+        inode->i_fop = &vbsf_reg_fops;
         set_nlink(inode, 1);
     }
@@ -178 +200 @@
     inode->i_blocks = (pObjInfo->cbAllocated + 511) / 512;
 
-    sf_ftime_from_timespec(&inode->i_atime, &pObjInfo->AccessTime);
-    sf_ftime_from_timespec(&inode->i_ctime, &pObjInfo->ChangeTime);
-    sf_ftime_from_timespec(&inode->i_mtime, &pObjInfo->ModificationTime);
+    vbsf_time_to_linux(&inode->i_atime, &pObjInfo->AccessTime);
+    vbsf_time_to_linux(&inode->i_ctime, &pObjInfo->ChangeTime);
+    vbsf_time_to_linux(&inode->i_mtime, &pObjInfo->ModificationTime);
     sf_i->BirthTime = pObjInfo->BirthTime;
 }
@@ -192 +214 @@
  * @todo sort out the inode locking situation.
  */
-static void sf_update_inode(struct inode *pInode, struct sf_inode_info *pInodeInfo, PSHFLFSOBJINFO pObjInfo,
-                            struct vbsf_super_info *sf_g, bool fInodeLocked)
+static void vbsf_update_inode(struct inode *pInode, struct sf_inode_info *pInodeInfo, PSHFLFSOBJINFO pObjInfo,
+                              struct vbsf_super_info *sf_g, bool fInodeLocked)
 {
     PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
@@ -209 +231 @@
      */
     if (RTFS_IS_DIRECTORY(pAttr->fMode))
-        fMode = sf_convert_file_mode(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->dmode, sf_g->dmask, S_IFDIR);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 8)
     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_convert_file_mode(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFLNK);
 #endif
     else
-        fMode = sf_convert_file_mode(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
+        fMode = sf_file_mode_to_linux(pAttr->fMode, sf_g->fmode, sf_g->fmask, S_IFREG);
 
     if (fMode == pInode->i_mode) {
@@ -225 +247 @@
             pInode->i_mode = fMode;
         else {
-            SFLOGFLOW(("sf_update_inode: Changed from %o to %o (%s)\n",
-                   pInode->i_mode & S_IFMT, fMode & S_IFMT, pInodeInfo->path->String.ach));
+            SFLOGFLOW(("vbsf_update_inode: Changed from %o to %o (%s)\n",
+                       pInode->i_mode & S_IFMT, fMode & S_IFMT, pInodeInfo->path->String.ach));
             /** @todo we probably need to be more drastic... */
-            sf_init_inode(pInode, pInodeInfo, pObjInfo, sf_g);
+            vbsf_init_inode(pInode, pInodeInfo, pObjInfo, sf_g);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
@@ -248 +270 @@
      * Update the timestamps.
      */
-    sf_ftime_from_timespec(&pInode->i_atime, &pObjInfo->AccessTime);
-    sf_ftime_from_timespec(&pInode->i_ctime, &pObjInfo->ChangeTime);
-    sf_ftime_from_timespec(&pInode->i_mtime, &pObjInfo->ModificationTime);
+    vbsf_time_to_linux(&pInode->i_atime, &pObjInfo->AccessTime);
+    vbsf_time_to_linux(&pInode->i_ctime, &pObjInfo->ChangeTime);
+    vbsf_time_to_linux(&pInode->i_mtime, &pObjInfo->ModificationTime);
     pInodeInfo->BirthTime = pObjInfo->BirthTime;
 
@@ -267 +289 @@
 
 /** @note Currently only used for the root directory during (re-)mount.  */
-int sf_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 *sf_g, SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
 {
     int rc;
@@ -313 +334 @@
  * @sa sf_inode_revalidate()
  */
-int sf_inode_revalidate_worker(struct dentry *dentry, bool fForced)
+int vbsf_inode_revalidate_worker(struct dentry *dentry, bool fForced)
 {
     int rc;
@@ -335 +356 @@
              * Try get a handle we can query, any kind of handle will do here.
              */
-            struct sf_handle *pHandle = sf_handle_find(sf_i, 0, 0);
+            struct sf_handle *pHandle = vbsf_handle_find(sf_i, 0, 0);
             if (pHandle) {
                 /* Query thru pHandle. */
@@ -346 +367 @@
                          * Reset the TTL and copy the info over into the inode structure.
                          */
-                        sf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, true /*fInodeLocked??*/);
+                        vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, true /*fInodeLocked??*/);
                     } else if (rc == VERR_INVALID_HANDLE) {
                         rc = -ENOENT; /* Restore.*/
@@ -356 +377 @@
                 } else
                     rc = -ENOMEM;
-                sf_handle_release(pHandle, sf_g, "sf_inode_revalidate_worker");
+                vbsf_handle_release(pHandle, sf_g, "vbsf_inode_revalidate_worker");
 
             } else {
@@ -374 +395 @@
                              * Reset the TTL and copy the info over into the inode structure.
                              */
-                            sf_update_inode(pInode, sf_i, &pReq->CreateParms.Info,
+                            vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info,
                                     sf_g, true /*fInodeLocked??*/);
                             rc = 0;
@@ -404 +425 @@
  *
  * This is called directly as inode-op on 2.4, indirectly as dir-op
- * sf_dentry_revalidate() on 2.4/2.6.  The job is to find out whether
+ * vbsf_dentry_revalidate() on 2.4/2.6.  The job is to find out whether
  * dentry/inode is still valid.  The test fails if @a dentry does not have an
- * inode or sf_stat() is unsuccessful, otherwise we return success and update
+ * inode or vbsf_stat() is unsuccessful, otherwise we return success and update
  * inode attributes.
  */
-int sf_inode_revalidate(struct dentry *dentry)
-{
-    return sf_inode_revalidate_worker(dentry, false /*fForced*/);
+int vbsf_inode_revalidate(struct dentry *dentry)
+{
+    return vbsf_inode_revalidate_worker(dentry, false /*fForced*/);
 }
 
@@ -419 +440 @@
  * is quite a bit faster.
  */
-int sf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked)
+int vbsf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked)
 {
     int err;
@@ -451 +472 @@
                      * Reset the TTL and copy the info over into the inode structure.
                      */
-                    sf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, fInodeLocked);
+                    vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, sf_g, fInodeLocked);
                 } else {
                     LogFunc(("VbglR0SfHostReqQueryObjInfo failed on %#RX64: %Rrc\n", hHostFile, err));
@@ -471 +492 @@
 
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
-int sf_getattr(const struct path *path, struct kstat *kstat, u32 request_mask, unsigned int flags)
+int vbsf_inode_getattr(const struct path *path, struct kstat *kstat, u32 request_mask, unsigned int flags)
 # else
-int sf_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
+int vbsf_inode_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
 # endif
 {
@@ -482 +503 @@
 
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
-    SFLOGFLOW(("sf_getattr: dentry=%p request_mask=%#x flags=%#x\n", dentry, request_mask, flags));
+    SFLOGFLOW(("vbsf_inode_setattr: dentry=%p request_mask=%#x flags=%#x\n", dentry, request_mask, flags));
 # else
-    SFLOGFLOW(("sf_getattr: dentry=%p\n", dentry));
+    SFLOGFLOW(("vbsf_inode_setattr: dentry=%p\n", dentry));
 # endif
 
@@ -494 +515 @@
     switch (flags & AT_STATX_SYNC_TYPE) {
         default:
-            rc = sf_inode_revalidate_worker(dentry, false /*fForced*/);
+            rc = vbsf_inode_revalidate_worker(dentry, false /*fForced*/);
             break;
 
         case AT_STATX_FORCE_SYNC:
-            rc = sf_inode_revalidate_worker(dentry, true /*fForced*/);
+            rc = vbsf_inode_revalidate_worker(dentry, true /*fForced*/);
             break;
 
@@ -506 +527 @@
     }
 # else
-    rc = sf_inode_revalidate_worker(dentry, false /*fForced*/);
+    rc = vbsf_inode_revalidate_worker(dentry, false /*fForced*/);
 # endif
     if (rc == 0) {
@@ -517 +538 @@
             struct sf_inode_info *pInodeInfo = GET_INODE_INFO(dentry->d_inode);
             if (pInodeInfo) {
-                sf_ftime_from_timespec(&kstat->btime, &pInodeInfo->BirthTime);
+                vbsf_time_to_linux(&kstat->btime, &pInodeInfo->BirthTime);
                 kstat->result_mask |= STATX_BTIME;
             }
@@ -551 +572 @@
 }
 
-int sf_setattr(struct dentry *dentry, struct iattr *iattr)
+int vbsf_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 {
     struct vbsf_super_info *sf_g;
@@ -611 +632 @@
      * vbsf.cpp */
     if (iattr->ia_valid & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME)) {
-# define mode_set(r) ((iattr->ia_mode & (S_##r)) ? RTFS_UNIX_##r : 0)
-
         RT_ZERO(*pInfo);
+
         if (iattr->ia_valid & ATTR_MODE) {
-/** @todo we've got code for this elsewhere...   */
-            pInfo->Attr.fMode = mode_set(IRUSR);
-            pInfo->Attr.fMode |= mode_set(IWUSR);
-            pInfo->Attr.fMode |= mode_set(IXUSR);
-            pInfo->Attr.fMode |= mode_set(IRGRP);
-            pInfo->Attr.fMode |= mode_set(IWGRP);
-            pInfo->Attr.fMode |= mode_set(IXGRP);
-            pInfo->Attr.fMode |= mode_set(IROTH);
-            pInfo->Attr.fMode |= mode_set(IWOTH);
-            pInfo->Attr.fMode |= mode_set(IXOTH);
-
+            pInfo->Attr.fMode = sf_access_permissions_to_vbox(iattr->ia_mode);
             if (iattr->ia_mode & S_IFDIR)
                 pInfo->Attr.fMode |= RTFS_TYPE_DIRECTORY;
+            else if (iattr->ia_mode & S_IFLNK)
+                pInfo->Attr.fMode |= RTFS_TYPE_SYMLINK;
             else
                 pInfo->Attr.fMode |= RTFS_TYPE_FILE;
@@ -633 +645 @@
 
         if (iattr->ia_valid & ATTR_ATIME)
-            sf_timespec_from_ftime(&pInfo->AccessTime, &iattr->ia_atime);
+            vbsf_time_to_vbox(&pInfo->AccessTime, &iattr->ia_atime);
         if (iattr->ia_valid & ATTR_MTIME)
-            sf_timespec_from_ftime(&pInfo->ModificationTime, &iattr->ia_mtime);
+            vbsf_time_to_vbox(&pInfo->ModificationTime, &iattr->ia_mtime);
         /* ignore ctime (inode change time) as it can't be set from userland anyway */
 
@@ -652 +664 @@
             err = -RTErrConvertToErrno(vrc);
             LogFunc(("VbglR0SfHostReqSetFileSize(%s, %#llx) failed vrc=%Rrc err=%d\n",
-                 sf_i->path->String.ach, (unsigned long long)iattr->ia_size, vrc, err));
+                     sf_i->path->String.ach, (unsigned long long)iattr->ia_size, vrc, err));
             goto fail1;
         }
@@ -672 +684 @@
      * dentry and all its parent entries are valid and could touch their timestamps
      * extending their TTL (CIFS does that). */
-    return sf_inode_revalidate_worker(dentry, true /*fForced*/);
+    return vbsf_inode_revalidate_worker(dentry, true /*fForced*/);
 
  fail1:
@@ -686 +698 @@
 #endif /* >= 2.6.0 */
 
-static int sf_make_path(const char *caller, struct sf_inode_info *sf_i,
-                        const char *d_name, size_t d_len, SHFLSTRING **result)
+static int vbsf_make_path(const char *caller, struct sf_inode_info *sf_i,
+                          const char *d_name, size_t d_len, SHFLSTRING **result)
 {
     size_t path_len, shflstring_len;
@@ -737 +749 @@
  * [dentry] contains string encoded in coding system that corresponds
  * to [sf_g]->nls, we must convert it to UTF8 here and pass down to
- * [sf_make_path] which will allocate SHFLSTRING and fill it in
- */
-int sf_path_from_dentry(const char *caller, struct vbsf_super_info *sf_g,
-                        struct sf_inode_info *sf_i, struct dentry *dentry,
-                        SHFLSTRING **result)
+ * [vbsf_make_path] which will allocate SHFLSTRING and fill it in
+ */
+int vbsf_path_from_dentry(const char *caller, struct vbsf_super_info *sf_g, struct sf_inode_info *sf_i,
+                          struct dentry *dentry, SHFLSTRING **result)
 {
     int err;
@@ -808 +819 @@
     }
 
-    err = sf_make_path(caller, sf_i, name, len, result);
+    err = vbsf_make_path(caller, sf_i, name, len, result);
     if (name != d_name)
         kfree(name);
@@ -819 +830 @@
 }
 
-int sf_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 *sf_g, char *name, size_t name_bound_len, const unsigned char *utf8_name, size_t utf8_len)
 {
     if (sf_g->nls) {
@@ -878 +887 @@
 }
 
-static struct sf_dir_buf *sf_dir_buf_alloc(void)
+static struct sf_dir_buf *vbsf_dir_buf_alloc(void)
 {
     struct sf_dir_buf *b;
@@ -902 +911 @@
 }
 
-static void sf_dir_buf_free(struct sf_dir_buf *b)
+static void vbsf_dir_buf_free(struct sf_dir_buf *b)
 {
     BUG_ON(!b || !b->buf);
@@ -915 +924 @@
  * Free the directory buffer.
  */
-void sf_dir_info_free(struct sf_dir_info *p)
+void vbsf_dir_info_free(struct sf_dir_info *p)
 {
     struct list_head *list, *pos, *tmp;
@@ -925 +934 @@
 
         b = list_entry(pos, struct sf_dir_buf, head);
-        sf_dir_buf_free(b);
+        vbsf_dir_buf_free(b);
     }
     kfree(p);
@@ -933 +942 @@
  * Empty (but not free) the directory buffer.
  */
-void sf_dir_info_empty(struct sf_dir_info *p)
+void vbsf_dir_info_empty(struct sf_dir_info *p)
 {
     struct list_head *list, *pos, *tmp;
@@ -950 +959 @@
  * Create a new directory buffer descriptor.
  */
-struct sf_dir_info *sf_dir_info_alloc(void)
+struct sf_dir_info *vbsf_dir_info_alloc(void)
 {
     struct sf_dir_info *p;
@@ -968 +977 @@
  * Search for an empty directory content buffer.
  */
-static struct sf_dir_buf *sf_get_empty_dir_buf(struct sf_dir_info *sf_d)
+static struct sf_dir_buf *vbsf_get_empty_dir_buf(struct sf_dir_info *sf_d)
 {
     struct list_head *list, *pos;
@@ -990 +999 @@
 /** @todo r=bird: Why on earth do we read in the entire directory???  This
  *        cannot be healthy for like big directory and such... */
-int sf_dir_read_all(struct vbsf_super_info *sf_g, struct sf_inode_info *sf_i,
-                    struct sf_dir_info *sf_d, SHFLHANDLE handle)
+int vbsf_dir_read_all(struct vbsf_super_info *sf_g, struct sf_inode_info *sf_i, struct sf_dir_info *sf_d, SHFLHANDLE handle)
 {
     int err;
@@ -998 +1006 @@
 
     TRACE();
-    err = sf_make_path(__func__, sf_i, "*", 1, &mask);
+    err = vbsf_make_path(__func__, sf_i, "*", 1, &mask);
     if (err)
         goto fail0;
@@ -1009 +1017 @@
         struct sf_dir_buf *b;
 
-        b = sf_get_empty_dir_buf(sf_d);
+        b = vbsf_get_empty_dir_buf(sf_d);
         if (!b) {
-            b = sf_dir_buf_alloc();
+            b = vbsf_dir_buf_alloc();
             if (!b) {
                 err = -ENOMEM;
@@ -1049 +1057 @@
  * This is called during name resolution/lookup to check if the @a dentry in the
  * cache is still valid.  The actual validation is job is handled by
- * sf_inode_revalidate_worker().
- */
-static int
+ * vbsf_inode_revalidate_worker().
+ */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
-sf_dentry_revalidate(struct dentry *dentry, unsigned flags)
+static int vbsf_dentry_revalidate(struct dentry *dentry, unsigned flags)
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-sf_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int vbsf_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
 #else
-sf_dentry_revalidate(struct dentry *dentry, int flags)
+static int vbsf_dentry_revalidate(struct dentry *dentry, int flags)
 #endif
 {
@@ -1067 +1074 @@
 
     Assert(dentry);
-    SFLOGFLOW(("sf_dentry_revalidate: %p %#x %s\n", dentry, flags, dentry->d_inode ? GET_INODE_INFO(dentry->d_inode)->path->String.ach : "<negative>"));
+    SFLOGFLOW(("vbsf_dentry_revalidate: %p %#x %s\n", dentry, flags, dentry->d_inode ? GET_INODE_INFO(dentry->d_inode)->path->String.ach : "<negative>"));
 
     /*
@@ -1080 +1087 @@
     if (flags & LOOKUP_RCU) {
         rc = -ECHILD;
-        SFLOGFLOW(("sf_dentry_revalidate: RCU -> -ECHILD\n"));
+        SFLOGFLOW(("vbsf_dentry_revalidate: RCU -> -ECHILD\n"));
     } else
 #endif
@@ -1098 +1105 @@
              */
             //struct sf_inode_info *sf_i = GET_INODE_INFO(pInode);
-            unsigned long const     cJiffiesAge = sf_dentry_get_update_jiffies(dentry) - jiffies;
+            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(("sf_dentry_revalidate: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
+                SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
                 rc = 1;
-            } else if (!sf_inode_revalidate_worker(dentry, true /*fForced*/)) {
-                sf_dentry_set_update_jiffies(dentry, jiffies); /** @todo get jiffies from inode. */
-                SFLOGFLOW(("sf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 1\n", cJiffiesAge, sf_g->ttl));
+            } else if (!vbsf_inode_revalidate_worker(dentry, true /*fForced*/)) {
+                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));
                 rc = 1;
             } else {
-                SFLOGFLOW(("sf_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, sf_g->ttl));
                 rc = 0;
             }
@@ -1128 +1135 @@
 #endif
             {
-                SFLOGFLOW(("sf_dentry_revalidate: negative: create or rename target -> 0\n"));
+                SFLOGFLOW(("vbsf_dentry_revalidate: negative: create or rename target -> 0\n"));
                 rc = 0;
             } else {
                 /* Can we skip revalidation based on TTL? */
-                unsigned long const     cJiffiesAge = sf_dentry_get_update_jiffies(dentry) - jiffies;
+                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(("sf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
+                    SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, sf_g->ttl));
                     rc = 1;
                 } else {
@@ -1141 +1148 @@
                        have the caller kick it out. */
                     /** @todo stat the direntry and see if it exists now. */
-                    SFLOGFLOW(("sf_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, sf_g->ttl));
                     rc = 0;
                 }
@@ -1154 +1161 @@
 /** For logging purposes only. */
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
-static int sf_dentry_delete(const struct dentry *pDirEntry)
+static int vbsf_dentry_delete(const struct dentry *pDirEntry)
 # else
-static int sf_dentry_delete(struct dentry *pDirEntry)
+static int vbsf_dentry_delete(struct dentry *pDirEntry)
 # endif
 {
-    SFLOGFLOW(("sf_dentry_delete: %p\n", pDirEntry));
+    SFLOGFLOW(("vbsf_dentry_delete: %p\n", pDirEntry));
     return 0;
 }
@@ -1165 +1172 @@
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
 /** For logging purposes only. */
-static int sf_dentry_init(struct dentry *pDirEntry)
-{
-    SFLOGFLOW(("sf_dentry_init: %p\n", pDirEntry));
+static int vbsf_dentry_init(struct dentry *pDirEntry)
+{
+    SFLOGFLOW(("vbsf_dentry_init: %p\n", pDirEntry));
     return 0;
 }
@@ -1179 +1186 @@
  * Since 2.6.38 this is used via the super_block::s_d_op member.
  */
-struct dentry_operations sf_dentry_ops = {
-    .d_revalidate = sf_dentry_revalidate,
+struct dentry_operations vbsf_dentry_ops = {
+    .d_revalidate = vbsf_dentry_revalidate,
 #ifdef SFLOG_ENABLED
-    .d_delete = sf_dentry_delete,
+    .d_delete = vbsf_dentry_delete,
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
-    .d_init = sf_dentry_init,
+    .d_init = vbsf_dentry_init,
 # endif
 #endif

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

@@ -58 +58 @@
 *   Global Variables                                                                                                             *
 *********************************************************************************************************************************/
-VBGLSFCLIENT client_handle;
-VBGLSFCLIENT g_SfClient;      /* temporary? */
-
-uint32_t g_fHostFeatures = 0; /* temporary? */
+VBGLSFCLIENT g_SfClient;
+uint32_t     g_fHostFeatures = 0;
 
 /** Protects all the sf_inode_info::HandleList lists. */
-spinlock_t g_SfHandleLock;
+spinlock_t   g_SfHandleLock;
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 52)
-static int g_fFollowSymlinks = 0;
+static int   g_fFollowSymlinks = 0;
 #endif
 
@@ -78 +76 @@
  * Copies options from the mount info structure into @a sf_g.
  *
- * This is used both by sf_super_info_alloc() and sf_remount_fs().
- */
-static void sf_super_info_copy_remount_options(struct vbsf_super_info *sf_g, struct vbsf_mount_info_new *info)
+ * This is used both by vbsf_super_info_alloc() 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;
@@ -132 +130 @@
 
 /* allocate super info, try to map host share */
-static int sf_super_info_alloc(struct vbsf_mount_info_new *info, struct vbsf_super_info **sf_gp)
+static int vbsf_super_info_alloc(struct vbsf_mount_info_new *info, struct vbsf_super_info **sf_gp)
 {
     int err, rc;
@@ -218 +216 @@
 
     /* The rest is shared with remount. */
-    sf_super_info_copy_remount_options(sf_g, info);
+    vbsf_super_info_copy_remount_options(sf_g, info);
 
     *sf_gp = sf_g;
@@ -235 +233 @@
 
 /* unmap the share and free super info [sf_g] */
-static void sf_super_info_free(struct vbsf_super_info *sf_g)
+static void vbsf_super_info_free(struct vbsf_super_info *sf_g)
 {
     int rc;
@@ -254 +252 @@
  * Initialize backing device related matters.
  */
-static int sf_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 *sf_g)
 {
     int rc = 0;
@@ -320 +318 @@
 
 /**
- * Undoes what sf_init_backing_dev did.
- */
-static void sf_done_backing_dev(struct super_block *sb, struct vbsf_super_info *sf_g)
+ * Undoes what vbsf_init_backing_dev did.
+ */
+static void vbsf_done_backing_dev(struct super_block *sb, struct vbsf_super_info *sf_g)
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
@@ -331 +329 @@
 
 /**
- * This is called by sf_read_super_24() and sf_read_super_26() when vfs mounts
+ * This is called by vbsf_read_super_24() and vbsf_read_super_26() when vfs mounts
  * the fs and wants to read super_block.
  *
- * Calls sf_super_info_alloc() to map the folder and allocate super information
+ * Calls vbsf_super_info_alloc() to map the folder and allocate super information
  * structure.
  *
@@ -341 +339 @@
  * Should respect @a flags.
  */
-static int sf_read_super_aux(struct super_block *sb, void *data, int flags)
+static int vbsf_read_super_aux(struct super_block *sb, void *data, int flags)
 {
     int err;
@@ -365 +363 @@
     }
 
-    err = sf_super_info_alloc(info, &sf_g);
+    err = vbsf_super_info_alloc(info, &sf_g);
     if (err)
         goto fail0;
@@ -394 +392 @@
 #endif
 
-    err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+    err = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
     if (err) {
         LogFunc(("could not stat root of share\n"));
@@ -414 +412 @@
     sb->s_op = &sf_super_ops;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
-    sb->s_d_op = &sf_dentry_ops;
+    sb->s_d_op = &vbsf_dentry_ops;
 #endif
 
@@ -428 +426 @@
     }
 
-    if (sf_init_backing_dev(sb, sf_g)) {
+    if (vbsf_init_backing_dev(sb, sf_g)) {
         err = -EINVAL;
         LogFunc(("could not init bdi\n"));
@@ -437 +435 @@
     }
 
-    sf_init_inode(iroot, sf_i, &fsinfo, sf_g);
+    vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
     SET_INODE_INFO(iroot, sf_i);
 
@@ -463 +461 @@
 
  fail5:
-    sf_done_backing_dev(sb, sf_g);
+    vbsf_done_backing_dev(sb, sf_g);
 
  fail4:
@@ -476 +474 @@
 
  fail1:
-    sf_super_info_free(sf_g);
+    vbsf_super_info_free(sf_g);
 
  fail0:
@@ -489 +487 @@
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
-static void sf_evict_inode(struct inode *inode)
+static void vbsf_evict_inode(struct inode *inode)
 #else
-static void sf_clear_inode(struct inode *inode)
+static void vbsf_clear_inode(struct inode *inode)
 #endif
 {
@@ -519 +517 @@
         BUG_ON(!sf_i->path);
         kfree(sf_i->path);
-        sf_handle_drop_chain(sf_i);
+        vbsf_handle_drop_chain(sf_i);
 # ifdef VBOX_STRICT
         sf_i->u32Magic = SF_INODE_INFO_MAGIC_DEAD;
@@ -533 +531 @@
    job to properly fill then [inode] */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
-static void sf_read_inode(struct inode *inode)
-{
-}
-#endif
-
-
-/* vfs is done with [sb] (umount called) call [sf_super_info_free] to unmap
+static void vbsf_read_inode(struct inode *inode)
+{
+}
+#endif
+
+
+/* vfs is done with [sb] (umount called) call [vbsf_super_info_free] to unmap
    the folder and free [sf_g] */
-static void sf_put_super(struct super_block *sb)
+static void vbsf_put_super(struct super_block *sb)
 {
     struct vbsf_super_info *sf_g;
@@ -547 +545 @@
     sf_g = VBSF_GET_SUPER_INFO(sb);
     BUG_ON(!sf_g);
-    sf_done_backing_dev(sb, sf_g);
-    sf_super_info_free(sf_g);
+    vbsf_done_backing_dev(sb, sf_g);
+    vbsf_super_info_free(sf_g);
 }
 
@@ -556 +554 @@
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
-static int sf_statfs(struct dentry *dentry, struct kstatfs *stat)
+static int vbsf_statfs(struct dentry *dentry, struct kstatfs *stat)
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 73)
-static int sf_statfs(struct super_block *sb, struct kstatfs *stat)
+static int vbsf_statfs(struct super_block *sb, struct kstatfs *stat)
 #else
-static int sf_statfs(struct super_block *sb, struct statfs *stat)
+static int vbsf_statfs(struct super_block *sb, struct statfs *stat)
 #endif
 {
@@ -603 +601 @@
 }
 
-static int sf_remount_fs(struct super_block *sb, int *flags, char *data)
+static int vbsf_remount_fs(struct super_block *sb, int *flags, char *data)
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 23)
@@ -620 +618 @@
             && info->signature[1] == VBSF_MOUNT_SIGNATURE_BYTE_1
             && info->signature[2] == VBSF_MOUNT_SIGNATURE_BYTE_2) {
-            sf_super_info_copy_remount_options(sf_g, info);
+            vbsf_super_info_copy_remount_options(sf_g, info);
         }
     }
@@ -629 +627 @@
 
     sf_i = GET_INODE_INFO(iroot);
-    err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+    err = vbsf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
     BUG_ON(err != 0);
-    sf_init_inode(iroot, sf_i, &fsinfo, sf_g);
+    vbsf_init_inode(iroot, sf_i, &fsinfo, sf_g);
     /*unlock_new_inode(iroot); */
     return 0;
@@ -647 +645 @@
  */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
-static int sf_show_options(struct seq_file *m, struct vfsmount *mnt)
+static int vbsf_show_options(struct seq_file *m, struct vfsmount *mnt)
 #else
-static int sf_show_options(struct seq_file *m, struct dentry *root)
+static int vbsf_show_options(struct seq_file *m, struct dentry *root)
 #endif
 {
@@ -676 +674 @@
 static struct super_operations sf_super_ops = {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
-    .clear_inode = sf_clear_inode,
+    .clear_inode = vbsf_clear_inode,
 #else
-    .evict_inode = sf_evict_inode,
+    .evict_inode = vbsf_evict_inode,
 #endif
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
-    .read_inode = sf_read_inode,
-#endif
-    .put_super = sf_put_super,
-    .statfs = sf_statfs,
-    .remount_fs = sf_remount_fs,
-    .show_options = sf_show_options
+    .read_inode = vbsf_read_inode,
+#endif
+    .put_super = vbsf_put_super,
+    .statfs = vbsf_statfs,
+    .remount_fs = vbsf_remount_fs,
+    .show_options = vbsf_show_options
 };
 
@@ -696 +694 @@
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 4)
 
-static int sf_read_super_26(struct super_block *sb, void *data, int flags)
+static int vbsf_read_super_26(struct super_block *sb, void *data, int flags)
 {
     int err;
 
     TRACE();
-    err = sf_read_super_aux(sb, data, flags);
+    err = vbsf_read_super_aux(sb, data, flags);
     if (err)
-        printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
+        printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
 
     return err;
@@ -709 +707 @@
 
 # if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-static struct super_block *sf_get_sb(struct file_system_type *fs_type,
-                     int flags, const char *dev_name,
-                     void *data)
-{
-    TRACE();
-    return get_sb_nodev(fs_type, flags, data, sf_read_super_26);
+static struct super_block *vbsf_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
+{
+    TRACE();
+    return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26);
 }
 # elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
-static int sf_get_sb(struct file_system_type *fs_type, int flags,
-             const char *dev_name, void *data, struct vfsmount *mnt)
-{
-    TRACE();
-    return get_sb_nodev(fs_type, flags, data, sf_read_super_26, mnt);
+static int vbsf_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+{
+    TRACE();
+    return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26, mnt);
 }
 # else /* LINUX_VERSION_CODE >= 2.6.39 */
-static struct dentry *sf_mount(struct file_system_type *fs_type, int flags,
-                   const char *dev_name, void *data)
-{
-    TRACE();
-    return mount_nodev(fs_type, flags, data, sf_read_super_26);
+static struct dentry *sf_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
+{
+    TRACE();
+    return mount_nodev(fs_type, flags, data, vbsf_read_super_26);
 }
 # endif /* LINUX_VERSION_CODE >= 2.6.39 */
@@ -736 +730 @@
     .name = "vboxsf",
 # if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
-    .get_sb = sf_get_sb,
+    .get_sb = vbsf_get_sb,
 # else
     .mount = sf_mount,
@@ -745 +739 @@
 #else  /* LINUX_VERSION_CODE < 2.5.4 */
 
-static struct super_block *sf_read_super_24(struct super_block *sb, void *data,
-                        int flags)
+static struct super_block *vbsf_read_super_24(struct super_block *sb, void *data, int flags)
 {
     int err;
 
     TRACE();
-    err = sf_read_super_aux(sb, data, flags);
+    err = vbsf_read_super_aux(sb, data, flags);
     if (err) {
-        printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
+        printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
         return NULL;
     }
@@ -760 +753 @@
 }
 
-static DECLARE_FSTYPE(vboxsf_fs_type, "vboxsf", sf_read_super_24, 0);
+static DECLARE_FSTYPE(vboxsf_fs_type, "vboxsf", vbsf_read_super_24, 0);
 
 #endif /* LINUX_VERSION_CODE < 2.5.4 */
@@ -768 +761 @@
 static int __init init(void)
 {
+    int rcRet = 0;
     int vrc;
-    int rcRet = 0;
     int err;
 
     TRACE();
 
+    AssertCompile(sizeof(struct vbsf_mount_info_new) <= PAGE_SIZE);
     if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE) {
         printk(KERN_ERR
@@ -799 +793 @@
     }
 
-    vrc = VbglR0SfConnect(&client_handle);
-    g_SfClient = client_handle; /* temporary */
+    vrc = VbglR0SfConnect(&g_SfClient);
     if (RT_FAILURE(vrc)) {
         LogRelFunc(("VbglR0SfConnect failed, vrc=%Rrc\n", vrc));
@@ -815 +808 @@
     LogRelFunc(("g_fHostFeatures=%#x\n", g_fHostFeatures));
 
-    vrc = VbglR0SfSetUtf8(&client_handle);
+    vrc = VbglR0SfSetUtf8(&g_SfClient);
     if (RT_FAILURE(vrc)) {
         LogRelFunc(("VbglR0SfSetUtf8 failed, vrc=%Rrc\n", vrc));
@@ -823 +816 @@
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
     if (!g_fFollowSymlinks) {
-        vrc = VbglR0SfSetSymlinks(&client_handle);
+        vrc = VbglR0SfSetSymlinks(&g_SfClient);
         if (RT_FAILURE(vrc)) {
             printk(KERN_WARNING
@@ -839 +832 @@
 
  fail2:
-    VbglR0SfDisconnect(&client_handle);
-    g_SfClient = client_handle; /* temporary */
+    VbglR0SfDisconnect(&g_SfClient);
 
  fail1:
@@ -854 +846 @@
     TRACE();
 
-    VbglR0SfDisconnect(&client_handle);
-    g_SfClient = client_handle; /* temporary */
+    VbglR0SfDisconnect(&g_SfClient);
     VbglR0SfTerm();
     unregister_filesystem(&vboxsf_fs_type);

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

@@ -127 +127 @@
  * For associating inodes with host handles.
  *
- * This is necessary for address_space_operations::sf_writepage and allows
+ * This is necessary for address_space_operations::vbsf_writepage and allows
  * optimizing stat, lookups and other operations on open files and directories.
  */
@@ -166 +166 @@
     /** Some information was changed, update data on next revalidate */
     bool force_restat;
-    /** directory content changed, update the whole directory on next sf_getdent */
+    /** directory content changed, update the whole directory on next vbsf_getdent */
     bool force_reread;
     /** The timestamp (jiffies) where the inode info was last updated. */
@@ -173 +173 @@
     RTTIMESPEC              BirthTime;
 
-    /** handle valid if a file was created with sf_create_aux until it will
-     * be opened with sf_reg_open()
+    /** handle valid if a file was created with vbsf_create_worker until it will
+     * be opened with vbsf_reg_open()
      * @todo r=bird: figure this one out...  */
     SHFLHANDLE handle;
@@ -187 +187 @@
 };
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) || defined(KERNEL_FC6)
+/* FC6 kernel 2.6.18, vanilla kernel 2.6.19+ */
+# define GET_INODE_INFO(i)       ((struct sf_inode_info *) (i)->i_private)
+# define SET_INODE_INFO(i, sf_i) (i)->i_private = sf_i
+#else
+/* vanilla kernel up to 2.6.18 */
+# define GET_INODE_INFO(i)       ((struct sf_inode_info *) (i)->u.generic_ip)
+# define SET_INODE_INFO(i, sf_i) (i)->u.generic_ip = sf_i
+#endif
+
 struct sf_dir_info {
     /** @todo sf_handle. */
@@ -219 +229 @@
  * specific code (at least going back to 2.4.0).
  */
-DECLINLINE(void) sf_dentry_set_update_jiffies(struct dentry *pDirEntry, unsigned long uToSet)
+DECLINLINE(void) vbsf_dentry_set_update_jiffies(struct dentry *pDirEntry, unsigned long uToSet)
 {
     pDirEntry->d_fsdata = (void *)uToSet;
@@ -227 +237 @@
  * Get the update-jiffies value for a dentry.
  */
-DECLINLINE(unsigned long) sf_dentry_get_update_jiffies(struct dentry *pDirEntry)
+DECLINLINE(unsigned long) vbsf_dentry_get_update_jiffies(struct dentry *pDirEntry)
 {
     return (unsigned long)pDirEntry->d_fsdata;
@@ -237 +247 @@
  *                  we should increase the TTL for.
  */
-DECLINLINE(void) sf_dentry_chain_increase_ttl(struct dentry *pDirEntry)
+DECLINLINE(void) vbsf_dentry_chain_increase_ttl(struct dentry *pDirEntry)
 {
 #ifdef VBOX_STRICT
@@ -245 +255 @@
     do {
         Assert(pDirEntry->d_sb == pSuper);
-        sf_dentry_set_update_jiffies(pDirEntry, uToSet);
+        vbsf_dentry_set_update_jiffies(pDirEntry, uToSet);
         pDirEntry = pDirEntry->d_parent;
     } while (!IS_ROOT(pDirEntry));
@@ -255 +265 @@
  *                  we should increase the TTL for.
  */
-DECLINLINE(void) sf_dentry_chain_increase_parent_ttl(struct dentry *pDirEntry)
+DECLINLINE(void) vbsf_dentry_chain_increase_parent_ttl(struct dentry *pDirEntry)
 {
     Assert(!pDirEntry->d_parent || pDirEntry->d_parent->d_sb == pDirEntry->d_sb);
     pDirEntry = pDirEntry->d_parent;
     if (pDirEntry)
-        sf_dentry_chain_increase_ttl(pDirEntry);
+        vbsf_dentry_chain_increase_ttl(pDirEntry);
 }
 
 
 /* globals */
-extern VBGLSFCLIENT client_handle;
+extern VBGLSFCLIENT g_SfClient;
 extern spinlock_t g_SfHandleLock;
 
 
 /* forward declarations */
-extern struct inode_operations sf_dir_iops;
-extern struct inode_operations sf_lnk_iops;
-extern struct inode_operations sf_reg_iops;
-extern struct file_operations sf_dir_fops;
-extern struct file_operations sf_reg_fops;
-extern struct dentry_operations sf_dentry_ops;
-extern struct address_space_operations sf_reg_aops;
-
-extern void              sf_handle_drop_chain(struct sf_inode_info *pInodeInfo);
-extern struct sf_handle *sf_handle_find(struct sf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear);
-extern uint32_t          sf_handle_release_slow(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller);
-extern void              sf_handle_append(struct sf_inode_info *pInodeInfo, struct sf_handle *pHandle);
+extern struct inode_operations         vbsf_dir_iops;
+extern struct inode_operations         vbsf_lnk_iops;
+extern struct inode_operations         vbsf_reg_iops;
+extern struct file_operations          vbsf_dir_fops;
+extern struct file_operations          vbsf_reg_fops;
+extern struct dentry_operations        vbsf_dentry_ops;
+extern struct address_space_operations vbsf_reg_aops;
+
+extern void              vbsf_handle_drop_chain(struct sf_inode_info *pInodeInfo);
+extern struct sf_handle *vbsf_handle_find(struct sf_inode_info *pInodeInfo, uint32_t fFlagsSet, uint32_t fFlagsClear);
+extern uint32_t          vbsf_handle_release_slow(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller);
+extern void              vbsf_handle_append(struct sf_inode_info *pInodeInfo, struct sf_handle *pHandle);
 
 /**
@@ -289 +299 @@
  * @param   pHandle         The handle to release.
  * @param   sf_g            The info structure for the shared folder associated
- *                  with the handle.
+ *                          with the handle.
  * @param   pszCaller       The caller name (for logging failures).
  */
-DECLINLINE(uint32_t) sf_handle_release(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
+DECLINLINE(uint32_t) vbsf_handle_release(struct sf_handle *pHandle, struct vbsf_super_info *sf_g, const char *pszCaller)
 {
     uint32_t cRefs;
@@ -304 +314 @@
     if (cRefs)
         return cRefs;
-    return sf_handle_release_slow(pHandle, sf_g, pszCaller);
-}
-
-extern void sf_init_inode(struct inode *inode, struct sf_inode_info *sf_i, PSHFLFSOBJINFO info, struct vbsf_super_info *sf_g);
-extern int sf_stat(const char *caller, struct vbsf_super_info *sf_g,
-           SHFLSTRING * path, PSHFLFSOBJINFO result, int ok_to_fail);
-extern int sf_inode_revalidate(struct dentry *dentry);
-extern int sf_inode_revalidate_worker(struct dentry *dentry, bool fForced);
-extern int sf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked);
+    return vbsf_handle_release_slow(pHandle, sf_g, pszCaller);
+}
+
+extern void vbsf_init_inode(struct inode *inode, struct sf_inode_info *sf_i, PSHFLFSOBJINFO info, struct vbsf_super_info *sf_g);
+extern int  vbsf_stat(const char *caller, struct vbsf_super_info *sf_g, SHFLSTRING * path, PSHFLFSOBJINFO result, int ok_to_fail);
+extern int  vbsf_inode_revalidate(struct dentry *dentry);
+extern int  vbsf_inode_revalidate_worker(struct dentry *dentry, bool fForced);
+extern int  vbsf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
-extern int sf_getattr(const struct path *path, struct kstat *kstat,
-              u32 request_mask, unsigned int query_flags);
+extern int  vbsf_inode_getattr(const struct path *path, struct kstat *kstat, u32 request_mask, unsigned int query_flags);
 # else
-extern int sf_getattr(struct vfsmount *mnt, struct dentry *dentry,
-              struct kstat *kstat);
+extern int  vbsf_inode_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat);
 # endif
-extern int sf_setattr(struct dentry *dentry, struct iattr *iattr);
-#endif
-extern int sf_path_from_dentry(const char *caller, struct vbsf_super_info *sf_g,
-                   struct sf_inode_info *sf_i,
-                   struct dentry *dentry, SHFLSTRING ** result);
-extern int sf_nlscpy(struct vbsf_super_info *sf_g, char *name,
-             size_t name_bound_len, const unsigned char *utf8_name,
-             size_t utf8_len);
-extern void sf_dir_info_free(struct sf_dir_info *p);
-extern void sf_dir_info_empty(struct sf_dir_info *p);
-extern struct sf_dir_info *sf_dir_info_alloc(void);
-extern int sf_dir_read_all(struct vbsf_super_info *sf_g,
-               struct sf_inode_info *sf_i, struct sf_dir_info *sf_d,
-               SHFLHANDLE handle);
-
-#ifdef __cplusplus
-# define CMC_API __attribute__ ((cdecl, regparm (0)))
-#else
-# define CMC_API __attribute__ ((regparm (0)))
-#endif
+extern int  vbsf_inode_setattr(struct dentry *dentry, struct iattr *iattr);
+#endif
+extern int  vbsf_path_from_dentry(const char *caller, struct vbsf_super_info *sf_g, struct sf_inode_info *sf_i,
+                                  struct dentry *dentry, SHFLSTRING ** result);
+extern 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);
+extern void vbsf_dir_info_free(struct sf_dir_info *p);
+extern void vbsf_dir_info_empty(struct sf_dir_info *p);
+extern struct sf_dir_info *vbsf_dir_info_alloc(void);
+extern int  vbsf_dir_read_all(struct vbsf_super_info *sf_g, struct sf_inode_info *sf_i,
+                              struct sf_dir_info *sf_d, SHFLHANDLE handle);
 
 #if 1
@@ -354 +352 @@
 #endif
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) || defined(KERNEL_FC6)
-/* FC6 kernel 2.6.18, vanilla kernel 2.6.19+ */
-# define GET_INODE_INFO(i)       ((struct sf_inode_info *) (i)->i_private)
-# define SET_INODE_INFO(i, sf_i) (i)->i_private = sf_i
-#else
-/* vanilla kernel up to 2.6.18 */
-# define GET_INODE_INFO(i)       ((struct sf_inode_info *) (i)->u.generic_ip)
-# define SET_INODE_INFO(i, sf_i) (i)->u.generic_ip = sf_i
-#endif
-
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0)
 # define GET_F_DENTRY(f)        (f->f_path.dentry)