Changeset 70786 in vbox for trunk/src/VBox/Additions/linux/sharedfolders

Timestamp:

Jan 29, 2018 10:57:10 AM (7 years ago)

Author:

vboxsync

Message:

linux/shared folders: use indent to switch Linux-only files to kernel style.
bugref:9109: Shared folders: update to match in-kernel code more closely

Location:

trunk/src/VBox/Additions/linux/sharedfolders

Files:

• dirops.c (modified) (14 diffs)
• lnkops.c (modified) (1 diff)
• regops.c (modified) (10 diffs)
• utils.c (modified) (10 diffs)
• vbsfmount.h (modified) (1 diff)
• vfsmod.c (modified) (9 diffs)
• vfsmod.h (modified) (4 diffs)

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

@@ -28 +28 @@
 static int sf_dir_open(struct inode *inode, struct file *file)
 {
-    int rc;
-    int err;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_dir_info *sf_d;
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    SHFLCREATEPARMS params;
-
-    TRACE();
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
-
-    if (file->private_data)
-    {
-        LogFunc(("sf_dir_open() called on already opened directory '%s'\n",
-                sf_i->path->String.utf8));
-        return 0;
-    }
-
-    sf_d = sf_dir_info_alloc();
-    if (!sf_d)
-    {
-        LogRelFunc(("could not allocate directory info for '%s'\n",
-                    sf_i->path->String.utf8));
-        return -ENOMEM;
-    }
-
-    RT_ZERO(params);
-    params.Handle = SHFL_HANDLE_NIL;
-    params.CreateFlags = 0
-                       | SHFL_CF_DIRECTORY
-                       | SHFL_CF_ACT_OPEN_IF_EXISTS
-                       | SHFL_CF_ACT_FAIL_IF_NEW
-                       | SHFL_CF_ACCESS_READ
-                       ;
-
-    LogFunc(("sf_dir_open(): calling VbglR0SfCreate, folder %s, flags %#x\n",
-             sf_i->path->String.utf8, params.CreateFlags));
-    rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
-    if (RT_SUCCESS(rc))
-    {
-        if (params.Result == SHFL_FILE_EXISTS)
-        {
-            err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
-            if (!err)
-                file->private_data = sf_d;
-        }
-        else
-            err = -ENOENT;
-
-        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE(rc))
-            LogFunc(("sf_dir_open(): VbglR0SfClose(%s) after err=%d failed rc=%Rrc\n",
-                     sf_i->path->String.utf8, err, rc));
-    }
-    else
-        err = -EPERM;
-
-    if (err)
-        sf_dir_info_free(sf_d);
-
-    return err;
-}
-
+        int rc;
+        int err;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_dir_info *sf_d;
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        SHFLCREATEPARMS params;
+
+        TRACE();
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
+
+        if (file->private_data) {
+                LogFunc(("sf_dir_open() called on already opened directory '%s'\n", sf_i->path->String.utf8));
+                return 0;
+        }
+
+        sf_d = sf_dir_info_alloc();
+        if (!sf_d) {
+                LogRelFunc(("could not allocate directory info for '%s'\n",
+                            sf_i->path->String.utf8));
+                return -ENOMEM;
+        }
+
+        RT_ZERO(params);
+        params.Handle = SHFL_HANDLE_NIL;
+        params.CreateFlags = 0
+            | SHFL_CF_DIRECTORY
+            | SHFL_CF_ACT_OPEN_IF_EXISTS
+            | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
+
+        LogFunc(("sf_dir_open(): calling VbglR0SfCreate, folder %s, flags %#x\n", sf_i->path->String.utf8, params.CreateFlags));
+        rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+        if (RT_SUCCESS(rc)) {
+                if (params.Result == SHFL_FILE_EXISTS) {
+                        err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
+                        if (!err)
+                                file->private_data = sf_d;
+                } else
+                        err = -ENOENT;
+
+                rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc))
+                        LogFunc(("sf_dir_open(): VbglR0SfClose(%s) after err=%d failed rc=%Rrc\n", sf_i->path->String.utf8, err, rc));
+        } else
+                err = -EPERM;
+
+        if (err)
+                sf_dir_info_free(sf_d);
+
+        return err;
+}
 
 /**
@@ -103 +91 @@
 static int sf_dir_release(struct inode *inode, struct file *file)
 {
-    TRACE();
-
-    if (file->private_data)
-        sf_dir_info_free(file->private_data);
-
-    return 0;
+        TRACE();
+
+        if (file->private_data)
+                sf_dir_info_free(file->private_data);
+
+        return 0;
 }
 
@@ -118 +106 @@
 static int sf_get_d_type(RTFMODE fMode)
 {
-    int d_type;
-    switch (fMode & RTFS_TYPE_MASK)
-    {
-        case RTFS_TYPE_FIFO:      d_type = DT_FIFO;    break;
-        case RTFS_TYPE_DEV_CHAR:  d_type = DT_CHR;     break;
-        case RTFS_TYPE_DIRECTORY: d_type = DT_DIR;     break;
-        case RTFS_TYPE_DEV_BLOCK: d_type = DT_BLK;     break;
-        case RTFS_TYPE_FILE:      d_type = DT_REG;     break;
-        case RTFS_TYPE_SYMLINK:   d_type = DT_LNK;     break;
-        case RTFS_TYPE_SOCKET:    d_type = DT_SOCK;    break;
-        case RTFS_TYPE_WHITEOUT:  d_type = DT_WHT;     break;
-        default:                  d_type = DT_UNKNOWN; break;
-    }
-    return d_type;
+        int d_type;
+        switch (fMode & RTFS_TYPE_MASK) {
+        case RTFS_TYPE_FIFO:
+                d_type = DT_FIFO;
+                break;
+        case RTFS_TYPE_DEV_CHAR:
+                d_type = DT_CHR;
+                break;
+        case RTFS_TYPE_DIRECTORY:
+                d_type = DT_DIR;
+                break;
+        case RTFS_TYPE_DEV_BLOCK:
+                d_type = DT_BLK;
+                break;
+        case RTFS_TYPE_FILE:
+                d_type = DT_REG;
+                break;
+        case RTFS_TYPE_SYMLINK:
+                d_type = DT_LNK;
+                break;
+        case RTFS_TYPE_SOCKET:
+                d_type = DT_SOCK;
+                break;
+        case RTFS_TYPE_WHITEOUT:
+                d_type = DT_WHT;
+                break;
+        default:
+                d_type = DT_UNKNOWN;
+                break;
+        }
+        return d_type;
 }
 
@@ -141 +146 @@
 static int sf_getdent(struct file *dir, char d_name[NAME_MAX], int *d_type)
 {
-    loff_t cur;
-    struct sf_glob_info *sf_g;
-    struct sf_dir_info *sf_d;
-    struct sf_inode_info *sf_i;
-    struct inode *inode;
-    struct list_head *pos, *list;
-
-    TRACE();
-
-    inode = GET_F_DENTRY(dir)->d_inode;
-    sf_i = GET_INODE_INFO(inode);
-    sf_g = GET_GLOB_INFO(inode->i_sb);
-    sf_d = dir->private_data;
-
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_d);
-    BUG_ON(!sf_i);
-
-    if (sf_i->force_reread)
-    {
-        int rc;
-        int err;
-        SHFLCREATEPARMS params;
-
-        RT_ZERO(params);
-        params.Handle = SHFL_HANDLE_NIL;
-        params.CreateFlags = 0
-                           | SHFL_CF_DIRECTORY
-                           | SHFL_CF_ACT_OPEN_IF_EXISTS
-                           | SHFL_CF_ACT_FAIL_IF_NEW
-                           | SHFL_CF_ACCESS_READ
-                           ;
-
-        LogFunc(("sf_getdent: calling VbglR0SfCreate, folder %s, flags %#x\n",
-                  sf_i->path->String.utf8, params.CreateFlags));
-        rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
-        if (RT_FAILURE(rc))
-        {
-            LogFunc(("VbglR0SfCreate(%s) failed rc=%Rrc\n",
-                        sf_i->path->String.utf8, rc));
-            return -EPERM;
-        }
-
-        if (params.Result != SHFL_FILE_EXISTS)
-        {
-            LogFunc(("directory %s does not exist\n", sf_i->path->String.utf8));
-            sf_dir_info_free(sf_d);
-            return -ENOENT;
-        }
-
-        sf_dir_info_empty(sf_d);
-        err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
-        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE(rc))
-            LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
-        if (err)
-            return err;
-
-        sf_i->force_reread = 0;
-    }
-
-    cur = 0;
-    list = &sf_d->info_list;
-    list_for_each(pos, list)
-    {
-        struct sf_dir_buf *b;
-        SHFLDIRINFO *info;
-        loff_t i;
-
-        b = list_entry(pos, struct sf_dir_buf, head);
-        if (dir->f_pos >= cur + b->cEntries)
-        {
-            cur += b->cEntries;
-            continue;
-        }
-
-        for (i = 0, info = b->buf; i < dir->f_pos - cur; ++i)
-        {
-            size_t size;
-
-            size = offsetof(SHFLDIRINFO, name.String) + info->name.u16Size;
-            info = (SHFLDIRINFO *) ((uintptr_t) info + size);
-        }
-
-        *d_type = sf_get_d_type(info->Info.Attr.fMode);
-
-        return sf_nlscpy(sf_g, d_name, NAME_MAX,
-                         info->name.String.utf8, info->name.u16Length);
-    }
-
-    return 1;
+        loff_t cur;
+        struct sf_glob_info *sf_g;
+        struct sf_dir_info *sf_d;
+        struct sf_inode_info *sf_i;
+        struct inode *inode;
+        struct list_head *pos, *list;
+
+        TRACE();
+
+        inode = GET_F_DENTRY(dir)->d_inode;
+        sf_i = GET_INODE_INFO(inode);
+        sf_g = GET_GLOB_INFO(inode->i_sb);
+        sf_d = dir->private_data;
+
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_d);
+        BUG_ON(!sf_i);
+
+        if (sf_i->force_reread) {
+                int rc;
+                int err;
+                SHFLCREATEPARMS params;
+
+                RT_ZERO(params);
+                params.Handle = SHFL_HANDLE_NIL;
+                params.CreateFlags = 0
+                    | SHFL_CF_DIRECTORY
+                    | SHFL_CF_ACT_OPEN_IF_EXISTS
+                    | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
+
+                LogFunc(("sf_getdent: calling VbglR0SfCreate, folder %s, flags %#x\n", sf_i->path->String.utf8, params.CreateFlags));
+                rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path,
+                                    &params);
+                if (RT_FAILURE(rc)) {
+                        LogFunc(("VbglR0SfCreate(%s) failed rc=%Rrc\n",
+                                 sf_i->path->String.utf8, rc));
+                        return -EPERM;
+                }
+
+                if (params.Result != SHFL_FILE_EXISTS) {
+                        LogFunc(("directory %s does not exist\n",
+                                 sf_i->path->String.utf8));
+                        sf_dir_info_free(sf_d);
+                        return -ENOENT;
+                }
+
+                sf_dir_info_empty(sf_d);
+                err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
+                rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc))
+                        LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n",
+                                 sf_i->path->String.utf8, rc));
+                if (err)
+                        return err;
+
+                sf_i->force_reread = 0;
+        }
+
+        cur = 0;
+        list = &sf_d->info_list;
+        list_for_each(pos, list) {
+                struct sf_dir_buf *b;
+                SHFLDIRINFO *info;
+                loff_t i;
+
+                b = list_entry(pos, struct sf_dir_buf, head);
+                if (dir->f_pos >= cur + b->cEntries) {
+                        cur += b->cEntries;
+                        continue;
+                }
+
+                for (i = 0, info = b->buf; i < dir->f_pos - cur; ++i) {
+                        size_t size;
+
+                        size =
+                            offsetof(SHFLDIRINFO,
+                                     name.String) + info->name.u16Size;
+                        info = (SHFLDIRINFO *) ((uintptr_t) info + size);
+                }
+
+                *d_type = sf_get_d_type(info->Info.Attr.fMode);
+
+                return sf_nlscpy(sf_g, d_name, NAME_MAX,
+                                 info->name.String.utf8, info->name.u16Length);
+        }
+
+        return 1;
 }
 
@@ -263 +264 @@
 #endif
 {
-    TRACE();
-    for (;;)
-    {
-        int err;
-        ino_t fake_ino;
-        loff_t sanity;
-        char d_name[NAME_MAX];
-        int d_type = DT_UNKNOWN;
-
-        err = sf_getdent(dir, d_name, &d_type);
-        switch (err)
-        {
-            case 1:
-                return 0;
-
-            case 0:
-                break;
-
-            case -1:
-            default:
-                /* skip erroneous entry and proceed */
-                LogFunc(("sf_getdent error %d\n", err));
-                dir->f_pos += 1;
+        TRACE();
+        for (;;) {
+                int err;
+                ino_t fake_ino;
+                loff_t sanity;
+                char d_name[NAME_MAX];
+                int d_type = DT_UNKNOWN;
+
+                err = sf_getdent(dir, d_name, &d_type);
+                switch (err) {
+                case 1:
+                        return 0;
+
+                case 0:
+                        break;
+
+                case -1:
+                default:
+                        /* skip erroneous entry and proceed */
+                        LogFunc(("sf_getdent error %d\n", err));
+                        dir->f_pos += 1;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-                ctx->pos += 1;
-#endif
-                continue;
-        }
-
-        /* d_name now contains a valid entry name */
+                        ctx->pos += 1;
+#endif
+                        continue;
+                }
+
+                /* d_name now contains a valid entry name */
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-        sanity = ctx->pos + 0xbeef;
-#else
-        sanity = dir->f_pos + 0xbeef;
-#endif
-        fake_ino = sanity;
-        if (sanity - fake_ino)
-        {
-            LogRelFunc(("can not compute ino\n"));
-            return -EINVAL;
-        }
-
+                sanity = ctx->pos + 0xbeef;
+#else
+                sanity = dir->f_pos + 0xbeef;
+#endif
+                fake_ino = sanity;
+                if (sanity - fake_ino) {
+                        LogRelFunc(("can not compute ino\n"));
+                        return -EINVAL;
+                }
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-        if (!dir_emit(ctx, d_name, strlen(d_name), fake_ino, d_type))
-        {
-            LogFunc(("dir_emit failed\n"));
-            return 0;
-        }
-#else
-        err = filldir(opaque, d_name, strlen(d_name), dir->f_pos, fake_ino, d_type);
-        if (err)
-        {
-            LogFunc(("filldir returned error %d\n", err));
-            /* Rely on the fact that filldir returns error
-               only when it runs out of space in opaque */
-            return 0;
-        }
-#endif
-
-        dir->f_pos += 1;
+                if (!dir_emit(ctx, d_name, strlen(d_name), fake_ino, d_type)) {
+                        LogFunc(("dir_emit failed\n"));
+                        return 0;
+                }
+#else
+                err =
+                    filldir(opaque, d_name, strlen(d_name), dir->f_pos,
+                            fake_ino, d_type);
+                if (err) {
+                        LogFunc(("filldir returned error %d\n", err));
+                        /* Rely on the fact that filldir returns error
+                           only when it runs out of space in opaque */
+                        return 0;
+                }
+#endif
+
+                dir->f_pos += 1;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-        ctx->pos += 1;
-#endif
-    }
-
-    BUG();
-}
-
-struct file_operations sf_dir_fops =
-{
-    .open    = sf_dir_open,
+                ctx->pos += 1;
+#endif
+        }
+
+        BUG();
+}
+
+struct file_operations sf_dir_fops = {
+        .open = sf_dir_open,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)
-    .iterate = sf_dir_iterate,
-#else
-    .readdir = sf_dir_read,
-#endif
-    .release = sf_dir_release,
-    .read    = generic_read_dir
+        .iterate = sf_dir_iterate,
+#else
+        .readdir = sf_dir_read,
+#endif
+        .release = sf_dir_release,
+        .read = generic_read_dir
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
-  , .llseek  = generic_file_llseek
+            ,.llseek = generic_file_llseek
 #endif
 };
-
 
 /* iops */
@@ -361 +356 @@
 static struct dentry *sf_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
-                               )
-{
-    int err;
-    struct sf_inode_info *sf_i, *sf_new_i;
-    struct sf_glob_info *sf_g;
-    SHFLSTRING *path;
-    struct inode *inode;
-    ino_t ino;
-    SHFLFSOBJINFO fsinfo;
-
-    TRACE();
-    sf_g = GET_GLOB_INFO(parent->i_sb);
-    sf_i = GET_INODE_INFO(parent);
-
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
-
-    err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
-    if (err)
-        goto fail0;
-
-    err = sf_stat(__func__, sf_g, path, &fsinfo, 1);
-    if (err)
-    {
-        if (err == -ENOENT)
-        {
-            /* -ENOENT: add NULL inode to dentry so it later can be
-               created via call to create/mkdir/open */
-            kfree(path);
-            inode = NULL;
-        }
-        else
-            goto fail1;
-    }
-    else
-    {
-        sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL);
-        if (!sf_new_i)
-        {
-            LogRelFunc(("could not allocate memory for new inode info\n"));
-            err = -ENOMEM;
-            goto fail1;
-        }
-        sf_new_i->handle = SHFL_HANDLE_NIL;
-        sf_new_i->force_reread = 0;
-
-        ino = iunique(parent->i_sb, 1);
+                                , struct nameidata *nd
+#endif
+    )
+{
+        int err;
+        struct sf_inode_info *sf_i, *sf_new_i;
+        struct sf_glob_info *sf_g;
+        SHFLSTRING *path;
+        struct inode *inode;
+        ino_t ino;
+        SHFLFSOBJINFO fsinfo;
+
+        TRACE();
+        sf_g = GET_GLOB_INFO(parent->i_sb);
+        sf_i = GET_INODE_INFO(parent);
+
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
+
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+        if (err)
+                goto fail0;
+
+        err = sf_stat(__func__, sf_g, path, &fsinfo, 1);
+        if (err) {
+                if (err == -ENOENT) {
+                        /* -ENOENT: add NULL inode to dentry so it later can be
+                           created via call to create/mkdir/open */
+                        kfree(path);
+                        inode = NULL;
+                } else
+                        goto fail1;
+        } else {
+                sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL);
+                if (!sf_new_i) {
+                        LogRelFunc(("could not allocate memory for new inode info\n"));
+                        err = -ENOMEM;
+                        goto fail1;
+                }
+                sf_new_i->handle = SHFL_HANDLE_NIL;
+                sf_new_i->force_reread = 0;
+
+                ino = iunique(parent->i_sb, 1);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-        inode = iget_locked(parent->i_sb, ino);
-#else
-        inode = iget(parent->i_sb, ino);
-#endif
-        if (!inode)
-        {
-            LogFunc(("iget failed\n"));
-            err = -ENOMEM;          /* XXX: ??? */
-            goto fail2;
-        }
-
-        SET_INODE_INFO(inode, sf_new_i);
-        sf_init_inode(sf_g, inode, &fsinfo);
-        sf_new_i->path = path;
+                inode = iget_locked(parent->i_sb, ino);
+#else
+                inode = iget(parent->i_sb, ino);
+#endif
+                if (!inode) {
+                        LogFunc(("iget failed\n"));
+                        err = -ENOMEM;  /* XXX: ??? */
+                        goto fail2;
+                }
+
+                SET_INODE_INFO(inode, sf_new_i);
+                sf_init_inode(sf_g, inode, &fsinfo);
+                sf_new_i->path = path;
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-        unlock_new_inode(inode);
-#endif
-    }
-
-    sf_i->force_restat = 0;
-    dentry->d_time = jiffies;
+                unlock_new_inode(inode);
+#endif
+        }
+
+        sf_i->force_restat = 0;
+        dentry->d_time = jiffies;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
-    d_set_d_op(dentry, &sf_dentry_ops);
-#else
-    dentry->d_op = &sf_dentry_ops;
-#endif
-    d_add(dentry, inode);
-    return NULL;
-
-fail2:
-    kfree(sf_new_i);
-
-fail1:
-    kfree(path);
-
-fail0:
-    return ERR_PTR(err);
+        d_set_d_op(dentry, &sf_dentry_ops);
+#else
+        dentry->d_op = &sf_dentry_ops;
+#endif
+        d_add(dentry, inode);
+        return NULL;
+
+ fail2:
+        kfree(sf_new_i);
+
+ fail1:
+        kfree(path);
+
+ fail0:
+        return ERR_PTR(err);
 }
 
@@ -466 +454 @@
  */
 static int sf_instantiate(struct inode *parent, struct dentry *dentry,
-                          SHFLSTRING *path, PSHFLFSOBJINFO info, SHFLHANDLE handle)
-{
-    int err;
-    ino_t ino;
-    struct inode *inode;
-    struct sf_inode_info *sf_new_i;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
-
-    TRACE();
-    BUG_ON(!sf_g);
-
-    sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL);
-    if (!sf_new_i)
-    {
-        LogRelFunc(("could not allocate inode info.\n"));
-        err = -ENOMEM;
-        goto fail0;
-    }
-
-    ino = iunique(parent->i_sb, 1);
+                          SHFLSTRING * path, PSHFLFSOBJINFO info,
+                          SHFLHANDLE handle)
+{
+        int err;
+        ino_t ino;
+        struct inode *inode;
+        struct sf_inode_info *sf_new_i;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
+
+        TRACE();
+        BUG_ON(!sf_g);
+
+        sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL);
+        if (!sf_new_i) {
+                LogRelFunc(("could not allocate inode info.\n"));
+                err = -ENOMEM;
+                goto fail0;
+        }
+
+        ino = iunique(parent->i_sb, 1);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-    inode = iget_locked(parent->i_sb, ino);
-#else
-    inode = iget(parent->i_sb, ino);
-#endif
-    if (!inode)
-    {
-        LogFunc(("iget failed\n"));
-        err = -ENOMEM;
-        goto fail1;
-    }
-
-    sf_init_inode(sf_g, inode, info);
-    sf_new_i->path = path;
-    SET_INODE_INFO(inode, sf_new_i);
-    sf_new_i->force_restat = 1;
-    sf_new_i->force_reread = 0;
-
-    d_instantiate(dentry, inode);
+        inode = iget_locked(parent->i_sb, ino);
+#else
+        inode = iget(parent->i_sb, ino);
+#endif
+        if (!inode) {
+                LogFunc(("iget failed\n"));
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        sf_init_inode(sf_g, inode, info);
+        sf_new_i->path = path;
+        SET_INODE_INFO(inode, sf_new_i);
+        sf_new_i->force_restat = 1;
+        sf_new_i->force_reread = 0;
+
+        d_instantiate(dentry, inode);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-    unlock_new_inode(inode);
-#endif
-
-    /* Store this handle if we leave the handle open. */
-    sf_new_i->handle = handle;
-    return 0;
-
-fail1:
-    kfree(sf_new_i);
-
-fail0:
-    return err;
+        unlock_new_inode(inode);
+#endif
+
+        /* Store this handle if we leave the handle open. */
+        sf_new_i->handle = handle;
+        return 0;
+
+ fail1:
+        kfree(sf_new_i);
+
+ fail0:
+        return err;
 
 }
@@ -532 +519 @@
  */
 static int sf_create_aux(struct inode *parent, struct dentry *dentry,
-                         umode_t mode, int fDirectory)
-{
-    int rc, err;
-    SHFLCREATEPARMS params;
-    SHFLSTRING *path;
-    struct sf_inode_info *sf_i = GET_INODE_INFO(parent);
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
-
-    TRACE();
-    BUG_ON(!sf_i);
-    BUG_ON(!sf_g);
-
-    err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
-    if (err)
-        goto fail0;
-
-    RT_ZERO(params);
-    params.Handle = SHFL_HANDLE_NIL;
-    params.CreateFlags = 0
-                       | SHFL_CF_ACT_CREATE_IF_NEW
-                       | SHFL_CF_ACT_FAIL_IF_EXISTS
-                       | SHFL_CF_ACCESS_READWRITE
-                       | (fDirectory ? SHFL_CF_DIRECTORY : 0)
-                       ;
-    params.Info.Attr.fMode = 0
-                           | (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE)
-                           | (mode & S_IRWXUGO)
-                           ;
-    params.Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
-
-    LogFunc(("sf_create_aux: calling VbglR0SfCreate, folder %s, flags %#x\n",
-              path->String.utf8, params.CreateFlags));
-    rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, &params);
-    if (RT_FAILURE(rc))
-    {
-        if (rc == VERR_WRITE_PROTECT)
-        {
-            err = -EROFS;
-            goto fail1;
-        }
-        err = -EPROTO;
-        LogFunc(("(%d): VbglR0SfCreate(%s) failed rc=%Rrc\n",
-                    fDirectory, sf_i->path->String.utf8, rc));
-        goto fail1;
-    }
-
-    if (params.Result != SHFL_FILE_CREATED)
-    {
-        err = -EPERM;
-        LogFunc(("(%d): could not create file %s result=%d\n",
-                    fDirectory, sf_i->path->String.utf8, params.Result));
-        goto fail1;
-    }
-
-    err = sf_instantiate(parent, dentry, path, &params.Info,
-                         fDirectory ? SHFL_HANDLE_NIL : params.Handle);
-    if (err)
-    {
-        LogFunc(("(%d): could not instantiate dentry for %s err=%d\n",
-                    fDirectory, sf_i->path->String.utf8, err));
-        goto fail2;
-    }
-
-    /*
-     * 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
-     * the handle in between. Does not apply to directories. True?
-     */
-    if (fDirectory)
-    {
-        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE(rc))
-            LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n", fDirectory, rc));
-    }
-
-    sf_i->force_restat = 1;
-    return 0;
-
-fail2:
-    rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-    if (RT_FAILURE(rc))
-        LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n", fDirectory, rc));
-
-fail1:
-    kfree(path);
-
-fail0:
-    return err;
+                         umode_t mode, int fDirectory)
+{
+        int rc, err;
+        SHFLCREATEPARMS params;
+        SHFLSTRING *path;
+        struct sf_inode_info *sf_i = GET_INODE_INFO(parent);
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
+
+        TRACE();
+        BUG_ON(!sf_i);
+        BUG_ON(!sf_g);
+
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+        if (err)
+                goto fail0;
+
+        RT_ZERO(params);
+        params.Handle = SHFL_HANDLE_NIL;
+        params.CreateFlags = 0
+            | SHFL_CF_ACT_CREATE_IF_NEW
+            | SHFL_CF_ACT_FAIL_IF_EXISTS
+            | SHFL_CF_ACCESS_READWRITE | (fDirectory ? SHFL_CF_DIRECTORY : 0);
+        params.Info.Attr.fMode = 0
+            | (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE)
+            | (mode & S_IRWXUGO);
+        params.Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
+
+        LogFunc(("sf_create_aux: calling VbglR0SfCreate, folder %s, flags %#x\n", path->String.utf8, params.CreateFlags));
+        rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, &params);
+        if (RT_FAILURE(rc)) {
+                if (rc == VERR_WRITE_PROTECT) {
+                        err = -EROFS;
+                        goto fail1;
+                }
+                err = -EPROTO;
+                LogFunc(("(%d): VbglR0SfCreate(%s) failed rc=%Rrc\n",
+                         fDirectory, sf_i->path->String.utf8, rc));
+                goto fail1;
+        }
+
+        if (params.Result != SHFL_FILE_CREATED) {
+                err = -EPERM;
+                LogFunc(("(%d): could not create file %s result=%d\n",
+                         fDirectory, sf_i->path->String.utf8, params.Result));
+                goto fail1;
+        }
+
+        err = sf_instantiate(parent, dentry, path, &params.Info,
+                             fDirectory ? SHFL_HANDLE_NIL : params.Handle);
+        if (err) {
+                LogFunc(("(%d): could not instantiate dentry for %s err=%d\n",
+                         fDirectory, sf_i->path->String.utf8, err));
+                goto fail2;
+        }
+
+        /*
+         * 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
+         * the handle in between. Does not apply to directories. True?
+         */
+        if (fDirectory) {
+                rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc))
+                        LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n",
+                                 fDirectory, rc));
+        }
+
+        sf_i->force_restat = 1;
+        return 0;
+
+ fail2:
+        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc))
+                LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n", fDirectory,
+                         rc));
+
+ fail1:
+        kfree(path);
+
+ fail0:
+        return err;
 }
 
@@ -632 +612 @@
  */
 #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 sf_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 sf_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 sf_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)
 #endif
 {
-    TRACE();
-    return sf_create_aux(parent, dentry, mode, 0);
+        TRACE();
+        return sf_create_aux(parent, dentry, mode, 0);
 }
 
@@ -659 +642 @@
 #endif
 {
-    TRACE();
-    return sf_create_aux(parent, dentry, mode, 1);
+        TRACE();
+        return sf_create_aux(parent, dentry, mode, 1);
 }
 
@@ -671 +654 @@
  * @returns 0 on success, Linux error code otherwise
  */
-static int sf_unlink_aux(struct inode *parent, struct dentry *dentry, int fDirectory)
-{
-    int rc, err;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
-    struct sf_inode_info *sf_i = GET_INODE_INFO(parent);
-    SHFLSTRING *path;
-    uint32_t fFlags;
-
-    TRACE();
-    BUG_ON(!sf_g);
-
-    err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
-    if (err)
-        goto fail0;
-
-    fFlags = fDirectory ? SHFL_REMOVE_DIR : SHFL_REMOVE_FILE;
-    if (   dentry->d_inode
-        && ((dentry->d_inode->i_mode & S_IFLNK) == S_IFLNK))
-        fFlags |= SHFL_REMOVE_SYMLINK;
-    rc = VbglR0SfRemove(&client_handle, &sf_g->map, path, fFlags);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("(%d): VbglR0SfRemove(%s) failed rc=%Rrc\n", fDirectory, path->String.utf8, rc));
-        err = -RTErrConvertToErrno(rc);
-        goto fail1;
-    }
-
-    /* directory access/change time changed */
-    sf_i->force_restat = 1;
-    /* directory content changed */
-    sf_i->force_reread = 1;
-
-    err = 0;
-
-fail1:
-    kfree(path);
-
-fail0:
-    return err;
+static int sf_unlink_aux(struct inode *parent, struct dentry *dentry,
+                         int fDirectory)
+{
+        int rc, err;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(parent);
+        SHFLSTRING *path;
+        uint32_t fFlags;
+
+        TRACE();
+        BUG_ON(!sf_g);
+
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+        if (err)
+                goto fail0;
+
+        fFlags = fDirectory ? SHFL_REMOVE_DIR : SHFL_REMOVE_FILE;
+        if (dentry->d_inode && ((dentry->d_inode->i_mode & S_IFLNK) == S_IFLNK))
+                fFlags |= SHFL_REMOVE_SYMLINK;
+        rc = VbglR0SfRemove(&client_handle, &sf_g->map, path, fFlags);
+        if (RT_FAILURE(rc)) {
+                LogFunc(("(%d): VbglR0SfRemove(%s) failed rc=%Rrc\n",
+                         fDirectory, path->String.utf8, rc));
+                err = -RTErrConvertToErrno(rc);
+                goto fail1;
+        }
+
+        /* directory access/change time changed */
+        sf_i->force_restat = 1;
+        /* directory content changed */
+        sf_i->force_reread = 1;
+
+        err = 0;
+
+ fail1:
+        kfree(path);
+
+ fail0:
+        return err;
 }
 
@@ -721 +704 @@
 static int sf_unlink(struct inode *parent, struct dentry *dentry)
 {
-    TRACE();
-    return sf_unlink_aux(parent, dentry, 0);
+        TRACE();
+        return sf_unlink_aux(parent, dentry, 0);
 }
 
@@ -734 +717 @@
 static int sf_rmdir(struct inode *parent, struct dentry *dentry)
 {
-    TRACE();
-    return sf_unlink_aux(parent, dentry, 1);
+        TRACE();
+        return sf_unlink_aux(parent, dentry, 1);
 }
 
@@ -749 +732 @@
  */
 static int sf_rename(struct inode *old_parent, struct dentry *old_dentry,
-                     struct inode *new_parent, struct dentry *new_dentry
+                     struct inode *new_parent, struct dentry *new_dentry
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
-                     , unsigned flags
-#endif
-                     )
-{
-    int err = 0, rc = VINF_SUCCESS;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(old_parent->i_sb);
-
-    TRACE();
+                     , unsigned flags
+#endif
+    )
+{
+        int err = 0, rc = VINF_SUCCESS;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(old_parent->i_sb);
+
+        TRACE();
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
-    if (flags)
-    {
-        LogFunc(("rename with flags=%x\n", flags));
-        return -EINVAL;
-    }
-#endif
-
-    if (sf_g != GET_GLOB_INFO(new_parent->i_sb))
-    {
-        LogFunc(("rename with different roots\n"));
-        err = -EINVAL;
-    }
-    else
-    {
-        struct sf_inode_info *sf_old_i = GET_INODE_INFO(old_parent);
-        struct sf_inode_info *sf_new_i = GET_INODE_INFO(new_parent);
-        /* As we save the relative path inside the inode structure, we need to change
-           this if the rename is successful. */
-        struct sf_inode_info *sf_file_i = GET_INODE_INFO(old_dentry->d_inode);
-        SHFLSTRING *old_path;
-        SHFLSTRING *new_path;
-
-        BUG_ON(!sf_old_i);
-        BUG_ON(!sf_new_i);
-        BUG_ON(!sf_file_i);
-
-        old_path = sf_file_i->path;
-        err = sf_path_from_dentry(__func__, sf_g, sf_new_i,
-                                  new_dentry, &new_path);
-        if (err)
-            LogFunc(("failed to create new path\n"));
-        else
-        {
-            int fDir = ((old_dentry->d_inode->i_mode & S_IFDIR) != 0);
-
-            rc = VbglR0SfRename(&client_handle, &sf_g->map, old_path,
-                                new_path, fDir ? 0 : SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
-            if (RT_SUCCESS(rc))
-            {
-                kfree(old_path);
-                sf_new_i->force_restat = 1;
-                sf_old_i->force_restat = 1; /* XXX: needed? */
-                /* Set the new relative path in the inode. */
-                sf_file_i->path = new_path;
-            }
-            else
-            {
-                LogFunc(("VbglR0SfRename failed rc=%Rrc\n", rc));
-                err = -RTErrConvertToErrno(rc);
-                kfree(new_path);
-            }
-        }
-    }
-    return err;
+        if (flags) {
+                LogFunc(("rename with flags=%x\n", flags));
+                return -EINVAL;
+        }
+#endif
+
+        if (sf_g != GET_GLOB_INFO(new_parent->i_sb)) {
+                LogFunc(("rename with different roots\n"));
+                err = -EINVAL;
+        } else {
+                struct sf_inode_info *sf_old_i = GET_INODE_INFO(old_parent);
+                struct sf_inode_info *sf_new_i = GET_INODE_INFO(new_parent);
+                /* As we save the relative path inside the inode structure, we need to change
+                   this if the rename is successful. */
+                struct sf_inode_info *sf_file_i =
+                    GET_INODE_INFO(old_dentry->d_inode);
+                SHFLSTRING *old_path;
+                SHFLSTRING *new_path;
+
+                BUG_ON(!sf_old_i);
+                BUG_ON(!sf_new_i);
+                BUG_ON(!sf_file_i);
+
+                old_path = sf_file_i->path;
+                err = sf_path_from_dentry(__func__, sf_g, sf_new_i,
+                                          new_dentry, &new_path);
+                if (err)
+                        LogFunc(("failed to create new path\n"));
+                else {
+                        int fDir =
+                            ((old_dentry->d_inode->i_mode & S_IFDIR) != 0);
+
+                        rc = VbglR0SfRename(&client_handle, &sf_g->map,
+                                            old_path, new_path,
+                                            fDir ? 0 : SHFL_RENAME_FILE |
+                                            SHFL_RENAME_REPLACE_IF_EXISTS);
+                        if (RT_SUCCESS(rc)) {
+                                kfree(old_path);
+                                sf_new_i->force_restat = 1;
+                                sf_old_i->force_restat = 1;     /* XXX: needed? */
+                                /* Set the new relative path in the inode. */
+                                sf_file_i->path = new_path;
+                        } else {
+                                LogFunc(("VbglR0SfRename failed rc=%Rrc\n",
+                                         rc));
+                                err = -RTErrConvertToErrno(rc);
+                                kfree(new_path);
+                        }
+                }
+        }
+        return err;
 }
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-static int sf_symlink(struct inode *parent, struct dentry *dentry, const char *symname)
-{
-    int err;
-    int rc;
-    struct sf_inode_info *sf_i;
-    struct sf_glob_info *sf_g;
-    SHFLSTRING *path, *ssymname;
-    SHFLFSOBJINFO info;
-    int symname_len = strlen(symname) + 1;
-
-    TRACE();
-    sf_g = GET_GLOB_INFO(parent->i_sb);
-    sf_i = GET_INODE_INFO(parent);
-
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
-
-    err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
-    if (err)
-        goto fail0;
-
-    ssymname = kmalloc(offsetof(SHFLSTRING, String.utf8) + symname_len, GFP_KERNEL);
-    if (!ssymname)
-    {
-        LogRelFunc(("kmalloc failed, caller=sf_symlink\n"));
-        err = -ENOMEM;
-        goto fail1;
-    }
-
-    ssymname->u16Length = symname_len - 1;
-    ssymname->u16Size = symname_len;
-    memcpy(ssymname->String.utf8, symname, symname_len);
-
-    rc = VbglR0SfSymlink(&client_handle, &sf_g->map, path, ssymname, &info);
-    kfree(ssymname);
-
-    if (RT_FAILURE(rc))
-    {
-        if (rc == VERR_WRITE_PROTECT)
-        {
-            err = -EROFS;
-            goto fail1;
-        }
-        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);
-    if (err)
-    {
-        LogFunc(("could not instantiate dentry for %s err=%d\n",
-                 sf_i->path->String.utf8, err));
-        goto fail1;
-    }
-
-    sf_i->force_restat = 1;
-    return 0;
-
-fail1:
-    kfree(path);
-fail0:
-    return err;
-}
-#endif
-
-struct inode_operations sf_dir_iops =
-{
-    .lookup     = sf_lookup,
-    .create     = sf_create,
-    .mkdir      = sf_mkdir,
-    .rmdir      = sf_rmdir,
-    .unlink     = sf_unlink,
-    .rename     = sf_rename,
+static int sf_symlink(struct inode *parent, struct dentry *dentry,
+                      const char *symname)
+{
+        int err;
+        int rc;
+        struct sf_inode_info *sf_i;
+        struct sf_glob_info *sf_g;
+        SHFLSTRING *path, *ssymname;
+        SHFLFSOBJINFO info;
+        int symname_len = strlen(symname) + 1;
+
+        TRACE();
+        sf_g = GET_GLOB_INFO(parent->i_sb);
+        sf_i = GET_INODE_INFO(parent);
+
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
+
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
+        if (err)
+                goto fail0;
+
+        ssymname =
+            kmalloc(offsetof(SHFLSTRING, String.utf8) + symname_len,
+                    GFP_KERNEL);
+        if (!ssymname) {
+                LogRelFunc(("kmalloc failed, caller=sf_symlink\n"));
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        ssymname->u16Length = symname_len - 1;
+        ssymname->u16Size = symname_len;
+        memcpy(ssymname->String.utf8, symname, symname_len);
+
+        rc = VbglR0SfSymlink(&client_handle, &sf_g->map, path, ssymname, &info);
+        kfree(ssymname);
+
+        if (RT_FAILURE(rc)) {
+                if (rc == VERR_WRITE_PROTECT) {
+                        err = -EROFS;
+                        goto fail1;
+                }
+                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);
+        if (err) {
+                LogFunc(("could not instantiate dentry for %s err=%d\n",
+                         sf_i->path->String.utf8, err));
+                goto fail1;
+        }
+
+        sf_i->force_restat = 1;
+        return 0;
+
+ fail1:
+        kfree(path);
+ fail0:
+        return err;
+}
+#endif
+
+struct inode_operations sf_dir_iops = {
+        .lookup = sf_lookup,
+        .create = sf_create,
+        .mkdir = sf_mkdir,
+        .rmdir = sf_rmdir,
+        .unlink = sf_unlink,
+        .rename = sf_rename,
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-    .revalidate = sf_inode_revalidate
-#else
-    .getattr    = sf_getattr,
-    .setattr    = sf_setattr,
-    .symlink    = sf_symlink
+        .revalidate = sf_inode_revalidate
+#else
+        .getattr = sf_getattr,
+        .setattr = sf_setattr,
+        .symlink = sf_symlink
 #endif
 };

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

@@ -21 +21 @@
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 
-# if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+#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)
-#  else
+#else
 static void *sf_follow_link(struct dentry *dentry, struct nameidata *nd)
-#  endif
+#endif
 {
-    struct inode *inode = dentry->d_inode;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    int error = -ENOMEM;
-    char *path = (char*)get_zeroed_page(GFP_KERNEL);
-    int rc;
+        struct inode *inode = dentry->d_inode;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        int error = -ENOMEM;
+        char *path = (char *)get_zeroed_page(GFP_KERNEL);
+        int rc;
 
-    if (path)
-    {
-        error = 0;
-        rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path, PATH_MAX, path);
-        if (RT_FAILURE(rc))
-        {
-            LogFunc(("VbglR0SfReadLink failed, caller=%s, rc=%Rrc\n", __func__, rc));
-            free_page((unsigned long)path);
-            error = -EPROTO;
-        }
-    }
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
-    return error ? ERR_PTR(error) : (*cookie = path);
-#  else
-    nd_set_link(nd, error ? ERR_PTR(error) : path);
-    return NULL;
-#  endif
+        if (path) {
+                error = 0;
+                rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path,
+                                      PATH_MAX, path);
+                if (RT_FAILURE(rc)) {
+                        LogFunc(("VbglR0SfReadLink failed, caller=%s, rc=%Rrc\n", __func__, rc));
+                        free_page((unsigned long)path);
+                        error = -EPROTO;
+                }
+        }
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+        return error ? ERR_PTR(error) : (*cookie = path);
+#else
+        nd_set_link(nd, error ? ERR_PTR(error) : path);
+        return NULL;
+#endif
 }
 
-#  if LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)
-static void sf_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)
+static void sf_put_link(struct dentry *dentry, struct nameidata *nd,
+                        void *cookie)
 {
-    char *page = nd_get_link(nd);
-    if (!IS_ERR(page))
-        free_page((unsigned long)page);
+        char *page = nd_get_link(nd);
+        if (!IS_ERR(page))
+                free_page((unsigned long)page);
 }
-#  endif
+#endif
 
-# else /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) */
+#else                           /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) */
 static const char *sf_get_link(struct dentry *dentry, struct inode *inode,
-                               struct delayed_call *done)
+                               struct delayed_call *done)
 {
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    char *path;
-    int rc;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        char *path;
+        int rc;
 
-    if (!dentry)
-        return ERR_PTR(-ECHILD);
-    path = kzalloc(PAGE_SIZE, GFP_KERNEL);
-    if (!path)
-        return ERR_PTR(-ENOMEM);
-    rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path, PATH_MAX, path);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfReadLink failed, caller=%s, rc=%Rrc\n", __func__, rc));
-        kfree(path);
-        return ERR_PTR(-EPROTO);
-    }
-    set_delayed_call(done, kfree_link, path);
-    return path;
+        if (!dentry)
+                return ERR_PTR(-ECHILD);
+        path = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!path)
+                return ERR_PTR(-ENOMEM);
+        rc = VbglR0SfReadLink(&client_handle, &sf_g->map, sf_i->path, PATH_MAX,
+                              path);
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfReadLink failed, caller=%s, rc=%Rrc\n",
+                         __func__, rc));
+                kfree(path);
+                return ERR_PTR(-EPROTO);
+        }
+        set_delayed_call(done, kfree_link, path);
+        return path;
 }
-# endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0) */
+#endif                          /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0) */
 
-struct inode_operations sf_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
-# elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
-    .follow_link    = sf_follow_link,
-    .put_link       = free_page_put_link,
-# else
-    .follow_link    = sf_follow_link,
-    .put_link       = sf_put_link
-# endif
+struct inode_operations sf_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
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+        .follow_link = sf_follow_link,
+        .put_link = free_page_put_link,
+#else
+        .follow_link = sf_follow_link,
+        .put_link = sf_put_link
+#endif
 };
 
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) */
+#endif                          /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) */

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

@@ -22 +22 @@
 #include "vfsmod.h"
 
-static void *alloc_bounce_buffer(size_t *tmp_sizep, PRTCCPHYS physp, size_t
-                                 xfer_size, const char *caller)
-{
-    size_t tmp_size;
-    void *tmp;
-
-    /* try for big first. */
-    tmp_size = RT_ALIGN_Z(xfer_size, PAGE_SIZE);
-    if (tmp_size > 16U*_1K)
-        tmp_size = 16U*_1K;
-    tmp = kmalloc(tmp_size, GFP_KERNEL);
-    if (!tmp)
-    {
-        /* fall back on a page sized buffer. */
-        tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!tmp)
-        {
-            LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size));
-            return NULL;
-        }
-        tmp_size = PAGE_SIZE;
-    }
-
-    *tmp_sizep = tmp_size;
-    *physp = virt_to_phys(tmp);
-    return tmp;
+static void *alloc_bounce_buffer(size_t * tmp_sizep, PRTCCPHYS physp, size_t
+                                 xfer_size, const char *caller)
+{
+        size_t tmp_size;
+        void *tmp;
+
+        /* try for big first. */
+        tmp_size = RT_ALIGN_Z(xfer_size, PAGE_SIZE);
+        if (tmp_size > 16U * _1K)
+                tmp_size = 16U * _1K;
+        tmp = kmalloc(tmp_size, GFP_KERNEL);
+        if (!tmp) {
+                /* fall back on a page sized buffer. */
+                tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
+                if (!tmp) {
+                        LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size));
+                        return NULL;
+                }
+                tmp_size = PAGE_SIZE;
+        }
+
+        *tmp_sizep = tmp_size;
+        *physp = virt_to_phys(tmp);
+        return tmp;
 }
 
 static void free_bounce_buffer(void *tmp)
 {
-    kfree (tmp);
-}
-
+        kfree(tmp);
+}
 
 /* fops */
 static int sf_reg_read_aux(const char *caller, struct sf_glob_info *sf_g,
-                           struct sf_reg_info *sf_r, void *buf,
-                           uint32_t *nread, uint64_t pos)
+                           struct sf_reg_info *sf_r, void *buf,
+                           uint32_t * nread, uint64_t pos)
 {
     /** @todo bird: yes, kmap() and kmalloc() input only. Since the buffer is
      *        contiguous in physical memory (kmalloc or single page), we should
      *        use a physical address here to speed things up. */
-    int rc = VbglR0SfRead(&client_handle, &sf_g->map, sf_r->handle,
-                          pos, nread, buf, false /* already locked? */);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfRead failed. caller=%s, rc=%Rrc\n", caller, rc));
-        return -EPROTO;
-    }
-    return 0;
+        int rc = VbglR0SfRead(&client_handle, &sf_g->map, sf_r->handle,
+                              pos, nread, buf, false /* already locked? */ );
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfRead failed. caller=%s, rc=%Rrc\n", caller,
+                         rc));
+                return -EPROTO;
+        }
+        return 0;
 }
 
 static int sf_reg_write_aux(const char *caller, struct sf_glob_info *sf_g,
-                            struct sf_reg_info *sf_r, void *buf,
-                            uint32_t *nwritten, uint64_t pos)
+                            struct sf_reg_info *sf_r, void *buf,
+                            uint32_t * nwritten, uint64_t pos)
 {
     /** @todo bird: yes, kmap() and kmalloc() input only. Since the buffer is
      *        contiguous in physical memory (kmalloc or single page), we should
      *        use a physical address here to speed things up. */
-    int rc = VbglR0SfWrite(&client_handle, &sf_g->map, sf_r->handle,
-                           pos, nwritten, buf, false /* already locked? */);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfWrite failed. caller=%s, rc=%Rrc\n",
-                    caller, rc));
-        return -EPROTO;
-    }
-    return 0;
+        int rc = VbglR0SfWrite(&client_handle, &sf_g->map, sf_r->handle,
+                               pos, nwritten, buf,
+                               false /* already locked? */ );
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfWrite failed. caller=%s, rc=%Rrc\n",
+                         caller, rc));
+                return -EPROTO;
+        }
+        return 0;
 }
 
@@ -97 +94 @@
 void free_pipebuf(struct page *kpage)
 {
-    kunmap(kpage);
-    __free_pages(kpage, 0);
+        kunmap(kpage);
+        __free_pages(kpage, 0);
 }
 
 void *sf_pipe_buf_map(struct pipe_inode_info *pipe,
-                struct pipe_buffer *pipe_buf, int atomic)
-{
-    return 0;
+                      struct pipe_buffer *pipe_buf, int atomic)
+{
+        return 0;
 }
 
@@ -111 +108 @@
 }
 
-void sf_pipe_buf_unmap(struct pipe_inode_info *pipe,  struct pipe_buffer *pipe_buf, void *map_data)
+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) {
-    return 0;
+                      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);
+                                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)
-{
-    return 0;
+                        struct pipe_buffer *pipe_buf)
+{
+        return 0;
 }
 
 static struct pipe_buf_operations sf_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,
+        .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,
 };
 
@@ -151 +150 @@
 
 ssize_t
-sf_splice_read(struct file *in, loff_t *poffset,
-                 struct pipe_inode_info *pipe, size_t len,
-                 unsigned int flags)
-{
-    size_t bytes_remaining = len;
-    loff_t orig_offset = *poffset;
-    loff_t offset = orig_offset;
-    struct inode *inode = GET_F_DENTRY(in)->d_inode;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = in->private_data;
-    ssize_t retval;
-    struct page *kpage = 0;
-    size_t nsent = 0;
-
-    TRACE();
-    if (!S_ISREG(inode->i_mode))
-    {
-        LogFunc(("read from non regular file %d\n", inode->i_mode));
-        return -EINVAL;
-    }
-    if (!len) {
-        return 0;
-    }
-
-    LOCK_PIPE(pipe);
-
-    uint32_t req_size = 0;
-    while (bytes_remaining > 0)
-    {
-        kpage = alloc_page(GFP_KERNEL);
-        if (unlikely(kpage == NULL))
-        {
-            UNLOCK_PIPE(pipe);
-            return -ENOMEM;
-        }
-        req_size = 0;
-        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);
-            if (retval < 0)
-                goto err;
-            if (nread == 0)
-                break;
-            chunk += nread;
-            offset += nread;
-            nread = req_size - chunk;
-        }
-        if (!pipe->readers)
-        {
-            send_sig(SIGPIPE, current, 0);
-            retval = -EPIPE;
-            goto err;
-        }
-        if (pipe->nrbufs < PIPE_BUFFERS)
-        {
-            struct pipe_buffer *pipebuf =
-                pipe->bufs + ((pipe->curbuf + pipe->nrbufs) & (PIPE_BUFFERS - 1));
-            pipebuf->page = kpage;
-            pipebuf->ops = &sf_pipe_buf_ops;
-            pipebuf->len = req_size;
-            pipebuf->offset = 0;
-            pipebuf->private = 0;
-            pipebuf->flags = 0;
-            pipe->nrbufs++;
-            nsent += req_size;
-            bytes_remaining -= req_size;
-            if (signal_pending(current))
-                break;
-        }
-        else /* pipe full */
-        {
-            if (flags & SPLICE_F_NONBLOCK) {
-                retval = -EAGAIN;
-                goto err;
-            }
-            free_pipebuf(kpage);
-            break;
-        }
-    }
-    UNLOCK_PIPE(pipe);
-    if (!nsent && signal_pending(current))
-        return -ERESTARTSYS;
-    *poffset += nsent;
-    return offset - orig_offset;
-
-err:
-    UNLOCK_PIPE(pipe);
-    free_pipebuf(kpage);
-    return retval;
+sf_splice_read(struct file *in, loff_t * poffset,
+               struct pipe_inode_info *pipe, size_t len, unsigned int flags)
+{
+        size_t bytes_remaining = len;
+        loff_t orig_offset = *poffset;
+        loff_t offset = orig_offset;
+        struct inode *inode = GET_F_DENTRY(in)->d_inode;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = in->private_data;
+        ssize_t retval;
+        struct page *kpage = 0;
+        size_t nsent = 0;
+
+        TRACE();
+        if (!S_ISREG(inode->i_mode)) {
+                LogFunc(("read from non regular file %d\n", inode->i_mode));
+                return -EINVAL;
+        }
+        if (!len) {
+                return 0;
+        }
+
+        LOCK_PIPE(pipe);
+
+        uint32_t req_size = 0;
+        while (bytes_remaining > 0) {
+                kpage = alloc_page(GFP_KERNEL);
+                if (unlikely(kpage == NULL)) {
+                        UNLOCK_PIPE(pipe);
+                        return -ENOMEM;
+                }
+                req_size = 0;
+                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);
+                        if (retval < 0)
+                                goto err;
+                        if (nread == 0)
+                                break;
+                        chunk += nread;
+                        offset += nread;
+                        nread = req_size - chunk;
+                }
+                if (!pipe->readers) {
+                        send_sig(SIGPIPE, current, 0);
+                        retval = -EPIPE;
+                        goto err;
+                }
+                if (pipe->nrbufs < PIPE_BUFFERS) {
+                        struct pipe_buffer *pipebuf =
+                            pipe->bufs +
+                            ((pipe->curbuf + pipe->nrbufs) & (PIPE_BUFFERS -
+                                                              1));
+                        pipebuf->page = kpage;
+                        pipebuf->ops = &sf_pipe_buf_ops;
+                        pipebuf->len = req_size;
+                        pipebuf->offset = 0;
+                        pipebuf->private = 0;
+                        pipebuf->flags = 0;
+                        pipe->nrbufs++;
+                        nsent += req_size;
+                        bytes_remaining -= req_size;
+                        if (signal_pending(current))
+                                break;
+                } else {        /* pipe full */
+
+                        if (flags & SPLICE_F_NONBLOCK) {
+                                retval = -EAGAIN;
+                                goto err;
+                        }
+                        free_pipebuf(kpage);
+                        break;
+                }
+        }
+        UNLOCK_PIPE(pipe);
+        if (!nsent && signal_pending(current))
+                return -ERESTARTSYS;
+        *poffset += nsent;
+        return offset - orig_offset;
+
+ err:
+        UNLOCK_PIPE(pipe);
+        free_pipebuf(kpage);
+        return retval;
 }
 
@@ -256 +252 @@
  * @returns the number of read bytes on success, Linux error code otherwise
  */
-static ssize_t sf_reg_read(struct file *file, char *buf, size_t size, loff_t *off)
-{
-    int err;
-    void *tmp;
-    RTCCPHYS tmp_phys;
-    size_t tmp_size;
-    size_t left = size;
-    ssize_t total_bytes_read = 0;
-    struct inode *inode = GET_F_DENTRY(file)->d_inode;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = file->private_data;
-    loff_t pos = *off;
-
-    TRACE();
-    if (!S_ISREG(inode->i_mode))
-    {
-        LogFunc(("read from non regular file %d\n", inode->i_mode));
-        return -EINVAL;
-    }
+static ssize_t sf_reg_read(struct file *file, char *buf, size_t size,
+                           loff_t * off)
+{
+        int err;
+        void *tmp;
+        RTCCPHYS tmp_phys;
+        size_t tmp_size;
+        size_t left = size;
+        ssize_t total_bytes_read = 0;
+        struct inode *inode = GET_F_DENTRY(file)->d_inode;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = file->private_data;
+        loff_t pos = *off;
+
+        TRACE();
+        if (!S_ISREG(inode->i_mode)) {
+                LogFunc(("read from non regular file %d\n", inode->i_mode));
+                return -EINVAL;
+        }
 
     /** XXX Check read permission according to inode->i_mode! */
 
-    if (!size)
-        return 0;
-
-    tmp = alloc_bounce_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
-    if (!tmp)
-        return -ENOMEM;
-
-    while (left)
-    {
-        uint32_t to_read, nread;
-
-        to_read = tmp_size;
-        if (to_read > left)
-            to_read = (uint32_t) left;
-
-        nread = to_read;
-
-        err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos);
-        if (err)
-            goto fail;
-
-        if (copy_to_user(buf, tmp, nread))
-        {
-            err = -EFAULT;
-            goto fail;
-        }
-
-        pos  += nread;
-        left -= nread;
-        buf  += nread;
-        total_bytes_read += nread;
-        if (nread != to_read)
-            break;
-    }
-
-    *off += total_bytes_read;
-    free_bounce_buffer(tmp);
-    return total_bytes_read;
-
-fail:
-    free_bounce_buffer(tmp);
-    return err;
+        if (!size)
+                return 0;
+
+        tmp =
+            alloc_bounce_buffer(&tmp_size, &tmp_phys, size,
+                                __PRETTY_FUNCTION__);
+        if (!tmp)
+                return -ENOMEM;
+
+        while (left) {
+                uint32_t to_read, nread;
+
+                to_read = tmp_size;
+                if (to_read > left)
+                        to_read = (uint32_t) left;
+
+                nread = to_read;
+
+                err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos);
+                if (err)
+                        goto fail;
+
+                if (copy_to_user(buf, tmp, nread)) {
+                        err = -EFAULT;
+                        goto fail;
+                }
+
+                pos += nread;
+                left -= nread;
+                buf += nread;
+                total_bytes_read += nread;
+                if (nread != to_read)
+                        break;
+        }
+
+        *off += total_bytes_read;
+        free_bounce_buffer(tmp);
+        return total_bytes_read;
+
+ fail:
+        free_bounce_buffer(tmp);
+        return err;
 }
 
@@ -331 +327 @@
  * @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)
-{
-    int err;
-    void *tmp;
-    RTCCPHYS tmp_phys;
-    size_t tmp_size;
-    size_t left = size;
-    ssize_t total_bytes_written = 0;
-    struct inode *inode = GET_F_DENTRY(file)->d_inode;
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = file->private_data;
-    loff_t pos;
-
-    TRACE();
-    BUG_ON(!sf_i);
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_r);
-
-    if (!S_ISREG(inode->i_mode))
-    {
-        LogFunc(("write to non regular file %d\n",  inode->i_mode));
-        return -EINVAL;
-    }
-
-    pos = *off;
-    if (file->f_flags & O_APPEND)
-    {
-        pos = inode->i_size;
-        *off = pos;
-    }
+static ssize_t sf_reg_write(struct file *file, const char *buf, size_t size,
+                            loff_t * off)
+{
+        int err;
+        void *tmp;
+        RTCCPHYS tmp_phys;
+        size_t tmp_size;
+        size_t left = size;
+        ssize_t total_bytes_written = 0;
+        struct inode *inode = GET_F_DENTRY(file)->d_inode;
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = file->private_data;
+        loff_t pos;
+
+        TRACE();
+        BUG_ON(!sf_i);
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_r);
+
+        if (!S_ISREG(inode->i_mode)) {
+                LogFunc(("write to non regular file %d\n", inode->i_mode));
+                return -EINVAL;
+        }
+
+        pos = *off;
+        if (file->f_flags & O_APPEND) {
+                pos = inode->i_size;
+                *off = pos;
+        }
 
     /** XXX Check write permission according to inode->i_mode! */
 
-    if (!size)
-        return 0;
-
-    tmp = alloc_bounce_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
-    if (!tmp)
-        return -ENOMEM;
-
-    while (left)
-    {
-        uint32_t to_write, nwritten;
-
-        to_write = tmp_size;
-        if (to_write > left)
-            to_write = (uint32_t) left;
-
-        nwritten = to_write;
-
-        if (copy_from_user(tmp, buf, to_write))
-        {
-            err = -EFAULT;
-            goto fail;
-        }
-
-        err = VbglR0SfWritePhysCont(&client_handle, &sf_g->map, sf_r->handle,
-                                    pos, &nwritten, tmp_phys);
-        err = RT_FAILURE(err) ? -EPROTO : 0;
-        if (err)
-            goto fail;
-
-        pos  += nwritten;
-        left -= nwritten;
-        buf  += nwritten;
-        total_bytes_written += nwritten;
-        if (nwritten != to_write)
-            break;
-    }
-
-    *off += total_bytes_written;
-    if (*off > inode->i_size)
-        inode->i_size = *off;
-
-    sf_i->force_restat = 1;
-    free_bounce_buffer(tmp);
-    return total_bytes_written;
-
-fail:
-    free_bounce_buffer(tmp);
-    return err;
+        if (!size)
+                return 0;
+
+        tmp =
+            alloc_bounce_buffer(&tmp_size, &tmp_phys, size,
+                                __PRETTY_FUNCTION__);
+        if (!tmp)
+                return -ENOMEM;
+
+        while (left) {
+                uint32_t to_write, nwritten;
+
+                to_write = tmp_size;
+                if (to_write > left)
+                        to_write = (uint32_t) left;
+
+                nwritten = to_write;
+
+                if (copy_from_user(tmp, buf, to_write)) {
+                        err = -EFAULT;
+                        goto fail;
+                }
+
+                err =
+                    VbglR0SfWritePhysCont(&client_handle, &sf_g->map,
+                                          sf_r->handle, pos, &nwritten,
+                                          tmp_phys);
+                err = RT_FAILURE(err) ? -EPROTO : 0;
+                if (err)
+                        goto fail;
+
+                pos += nwritten;
+                left -= nwritten;
+                buf += nwritten;
+                total_bytes_written += nwritten;
+                if (nwritten != to_write)
+                        break;
+        }
+
+        *off += total_bytes_written;
+        if (*off > inode->i_size)
+                inode->i_size = *off;
+
+        sf_i->force_restat = 1;
+        free_bounce_buffer(tmp);
+        return total_bytes_written;
+
+ fail:
+        free_bounce_buffer(tmp);
+        return err;
 }
 
@@ -424 +421 @@
 static int sf_reg_open(struct inode *inode, struct file *file)
 {
-    int rc, rc_linux = 0;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    struct sf_reg_info *sf_r;
-    SHFLCREATEPARMS params;
-
-    TRACE();
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
-
-    LogFunc(("open %s\n", sf_i->path->String.utf8));
-
-    sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
-    if (!sf_r)
-    {
-        LogRelFunc(("could not allocate reg info\n"));
-        return -ENOMEM;
-    }
-
-    /* Already open? */
-    if (sf_i->handle != SHFL_HANDLE_NIL)
-    {
-        /*
-         * This inode was created with sf_create_aux(). Check the CreateFlags:
-         * O_CREAT, O_TRUNC: inherent true (file was just created). Not sure
-         * about the access flags (SHFL_CF_ACCESS_*).
-         */
-        sf_i->force_restat = 1;
-        sf_r->handle = sf_i->handle;
-        sf_i->handle = SHFL_HANDLE_NIL;
-        sf_i->file = file;
-        file->private_data = sf_r;
-        return 0;
-    }
-
-    RT_ZERO(params);
-    params.Handle = SHFL_HANDLE_NIL;
-    /* We check the value of params.Handle afterwards to find out if
-     * the call succeeded or failed, as the API does not seem to cleanly
-     * distinguish error and informational messages.
-     *
-     * Furthermore, we must set params.Handle to SHFL_HANDLE_NIL to
-     * make the shared folders host service use our fMode parameter */
-
-    if (file->f_flags & O_CREAT)
-    {
-        LogFunc(("O_CREAT set\n"));
-        params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
-        /* We ignore O_EXCL, as the Linux kernel seems to call create
-           beforehand itself, so O_EXCL should always fail. */
-        if (file->f_flags & O_TRUNC)
-        {
-            LogFunc(("O_TRUNC set\n"));
-            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-        }
-        else
-            params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
-    }
-    else
-    {
-        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
-        if (file->f_flags & O_TRUNC)
-        {
-            LogFunc(("O_TRUNC set\n"));
-            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-        }
-    }
-
-    switch (file->f_flags & O_ACCMODE)
-    {
-        case O_RDONLY:
-            params.CreateFlags |= SHFL_CF_ACCESS_READ;
-            break;
-
-        case O_WRONLY:
-            params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
-            break;
-
-        case O_RDWR:
-            params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
-            break;
-
-        default:
-            BUG ();
-    }
-
-    if (file->f_flags & O_APPEND)
-    {
-        LogFunc(("O_APPEND set\n"));
-        params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
-    }
-
-    params.Info.Attr.fMode = inode->i_mode;
-    LogFunc(("sf_reg_open: calling VbglR0SfCreate, file %s, flags=%#x, %#x\n",
-              sf_i->path->String.utf8 , file->f_flags, params.CreateFlags));
-    rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfCreate failed flags=%d,%#x rc=%Rrc\n",
-                  file->f_flags, params.CreateFlags, rc));
-        kfree(sf_r);
-        return -RTErrConvertToErrno(rc);
-    }
-
-    if (SHFL_HANDLE_NIL == params.Handle)
-    {
-        switch (params.Result)
-        {
-            case SHFL_PATH_NOT_FOUND:
-            case SHFL_FILE_NOT_FOUND:
-                rc_linux = -ENOENT;
-                break;
-            case SHFL_FILE_EXISTS:
-                rc_linux = -EEXIST;
-                break;
-            default:
-                break;
-        }
-    }
-
-    sf_i->force_restat = 1;
-    sf_r->handle = params.Handle;
-    sf_i->file = file;
-    file->private_data = sf_r;
-    return rc_linux;
+        int rc, rc_linux = 0;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        struct sf_reg_info *sf_r;
+        SHFLCREATEPARMS params;
+
+        TRACE();
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
+
+        LogFunc(("open %s\n", sf_i->path->String.utf8));
+
+        sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
+        if (!sf_r) {
+                LogRelFunc(("could not allocate reg info\n"));
+                return -ENOMEM;
+        }
+
+        /* Already open? */
+        if (sf_i->handle != SHFL_HANDLE_NIL) {
+                /*
+                 * This inode was created with sf_create_aux(). Check the CreateFlags:
+                 * O_CREAT, O_TRUNC: inherent true (file was just created). Not sure
+                 * about the access flags (SHFL_CF_ACCESS_*).
+                 */
+                sf_i->force_restat = 1;
+                sf_r->handle = sf_i->handle;
+                sf_i->handle = SHFL_HANDLE_NIL;
+                sf_i->file = file;
+                file->private_data = sf_r;
+                return 0;
+        }
+
+        RT_ZERO(params);
+        params.Handle = SHFL_HANDLE_NIL;
+        /* We check the value of params.Handle afterwards to find out if
+         * the call succeeded or failed, as the API does not seem to cleanly
+         * distinguish error and informational messages.
+         *
+         * Furthermore, we must set params.Handle to SHFL_HANDLE_NIL to
+         * make the shared folders host service use our fMode parameter */
+
+        if (file->f_flags & O_CREAT) {
+                LogFunc(("O_CREAT set\n"));
+                params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
+                /* We ignore O_EXCL, as the Linux kernel seems to call create
+                   beforehand itself, so O_EXCL should always fail. */
+                if (file->f_flags & O_TRUNC) {
+                        LogFunc(("O_TRUNC set\n"));
+                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+                } else
+                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+        } else {
+                params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
+                if (file->f_flags & O_TRUNC) {
+                        LogFunc(("O_TRUNC set\n"));
+                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+                }
+        }
+
+        switch (file->f_flags & O_ACCMODE) {
+        case O_RDONLY:
+                params.CreateFlags |= SHFL_CF_ACCESS_READ;
+                break;
+
+        case O_WRONLY:
+                params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
+                break;
+
+        case O_RDWR:
+                params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
+                break;
+
+        default:
+                BUG();
+        }
+
+        if (file->f_flags & O_APPEND) {
+                LogFunc(("O_APPEND set\n"));
+                params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
+        }
+
+        params.Info.Attr.fMode = inode->i_mode;
+        LogFunc(("sf_reg_open: calling VbglR0SfCreate, file %s, flags=%#x, %#x\n", sf_i->path->String.utf8, file->f_flags, params.CreateFlags));
+        rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfCreate failed flags=%d,%#x rc=%Rrc\n",
+                         file->f_flags, params.CreateFlags, rc));
+                kfree(sf_r);
+                return -RTErrConvertToErrno(rc);
+        }
+
+        if (SHFL_HANDLE_NIL == params.Handle) {
+                switch (params.Result) {
+                case SHFL_PATH_NOT_FOUND:
+                case SHFL_FILE_NOT_FOUND:
+                        rc_linux = -ENOENT;
+                        break;
+                case SHFL_FILE_EXISTS:
+                        rc_linux = -EEXIST;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        sf_i->force_restat = 1;
+        sf_r->handle = params.Handle;
+        sf_i->file = file;
+        file->private_data = sf_r;
+        return rc_linux;
 }
 
@@ -560 +543 @@
 static int sf_reg_release(struct inode *inode, struct file *file)
 {
-    int rc;
-    struct sf_reg_info *sf_r;
-    struct sf_glob_info *sf_g;
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-
-    TRACE();
-    sf_g = GET_GLOB_INFO(inode->i_sb);
-    sf_r = file->private_data;
-
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_r);
+        int rc;
+        struct sf_reg_info *sf_r;
+        struct sf_glob_info *sf_g;
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+
+        TRACE();
+        sf_g = GET_GLOB_INFO(inode->i_sb);
+        sf_r = file->private_data;
+
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_r);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-    /* See the smbfs source (file.c). mmap in particular can cause data to be
-     * written to the file after it is closed, which we can't cope with.  We
-     * copy and paste the body of filemap_write_and_wait() here as it was not
-     * defined before 2.6.6 and not exported until quite a bit later. */
-    /* filemap_write_and_wait(inode->i_mapping); */
-    if (   inode->i_mapping->nrpages
-        && filemap_fdatawrite(inode->i_mapping) != -EIO)
-        filemap_fdatawait(inode->i_mapping);
-#endif
-    rc = VbglR0SfClose(&client_handle, &sf_g->map, sf_r->handle);
-    if (RT_FAILURE(rc))
-        LogFunc(("VbglR0SfClose failed rc=%Rrc\n", rc));
-
-    kfree(sf_r);
-    sf_i->file = NULL;
-    sf_i->handle = SHFL_HANDLE_NIL;
-    file->private_data = NULL;
-    return 0;
+        /* See the smbfs source (file.c). mmap in particular can cause data to be
+         * written to the file after it is closed, which we can't cope with.  We
+         * copy and paste the body of filemap_write_and_wait() here as it was not
+         * defined before 2.6.6 and not exported until quite a bit later. */
+        /* filemap_write_and_wait(inode->i_mapping); */
+        if (inode->i_mapping->nrpages
+            && filemap_fdatawrite(inode->i_mapping) != -EIO)
+                filemap_fdatawait(inode->i_mapping);
+#endif
+        rc = VbglR0SfClose(&client_handle, &sf_g->map, sf_r->handle);
+        if (RT_FAILURE(rc))
+                LogFunc(("VbglR0SfClose failed rc=%Rrc\n", rc));
+
+        kfree(sf_r);
+        sf_i->file = NULL;
+        sf_i->handle = SHFL_HANDLE_NIL;
+        file->private_data = NULL;
+        return 0;
 }
 
@@ -598 +581 @@
 static int sf_reg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-static struct page *sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int *type)
-# define SET_TYPE(t) *type = (t)
-#else /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) */
-static struct page *sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int unused)
-# define SET_TYPE(t)
-#endif
-{
-    struct page *page;
-    char *buf;
-    loff_t off;
-    uint32_t nread = PAGE_SIZE;
-    int err;
+static struct page *sf_reg_nopage(struct vm_area_struct *vma,
+                                  unsigned long vaddr, int *type)
+#define SET_TYPE(t) *type = (t)
+#else                           /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) */
+static struct page *sf_reg_nopage(struct vm_area_struct *vma,
+                                  unsigned long vaddr, int unused)
+#define SET_TYPE(t)
+#endif
+{
+        struct page *page;
+        char *buf;
+        loff_t off;
+        uint32_t nread = PAGE_SIZE;
+        int err;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
-    struct vm_area_struct *vma = vmf->vma;
-#endif
-    struct file *file = vma->vm_file;
-    struct inode *inode = GET_F_DENTRY(file)->d_inode;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = file->private_data;
-
-    TRACE();
+        struct vm_area_struct *vma = vmf->vma;
+#endif
+        struct file *file = vma->vm_file;
+        struct inode *inode = GET_F_DENTRY(file)->d_inode;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = file->private_data;
+
+        TRACE();
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-    if (vmf->pgoff > vma->vm_end)
-        return VM_FAULT_SIGBUS;
-#else
-    if (vaddr > vma->vm_end)
-    {
-        SET_TYPE(VM_FAULT_SIGBUS);
-        return NOPAGE_SIGBUS;
-    }
-#endif
-
-    /* Don't use GFP_HIGHUSER as long as sf_reg_read_aux() calls VbglR0SfRead()
-     * which works on virtual addresses. On Linux cannot reliably determine the
-     * physical address for high memory, see rtR0MemObjNativeLockKernel(). */
-    page = alloc_page(GFP_USER);
-    if (!page) {
-        LogRelFunc(("failed to allocate page\n"));
+        if (vmf->pgoff > vma->vm_end)
+                return VM_FAULT_SIGBUS;
+#else
+        if (vaddr > vma->vm_end) {
+                SET_TYPE(VM_FAULT_SIGBUS);
+                return NOPAGE_SIGBUS;
+        }
+#endif
+
+        /* Don't use GFP_HIGHUSER as long as sf_reg_read_aux() calls VbglR0SfRead()
+         * which works on virtual addresses. On Linux cannot reliably determine the
+         * physical address for high memory, see rtR0MemObjNativeLockKernel(). */
+        page = alloc_page(GFP_USER);
+        if (!page) {
+                LogRelFunc(("failed to allocate page\n"));
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-        return VM_FAULT_OOM;
-#else
-        SET_TYPE(VM_FAULT_OOM);
-        return NOPAGE_OOM;
-#endif
-    }
-
-    buf = kmap(page);
+                return VM_FAULT_OOM;
+#else
+                SET_TYPE(VM_FAULT_OOM);
+                return NOPAGE_OOM;
+#endif
+        }
+
+        buf = kmap(page);
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-    off = (vmf->pgoff << PAGE_SHIFT);
-#else
-    off = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
-#endif
-    err = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
-    if (err)
-    {
-        kunmap(page);
-        put_page(page);
+        off = (vmf->pgoff << PAGE_SHIFT);
+#else
+        off = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
+#endif
+        err = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
+        if (err) {
+                kunmap(page);
+                put_page(page);
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-        return VM_FAULT_SIGBUS;
-#else
-        SET_TYPE(VM_FAULT_SIGBUS);
-        return NOPAGE_SIGBUS;
-#endif
-    }
-
-    BUG_ON (nread > PAGE_SIZE);
-    if (!nread)
-    {
+                return VM_FAULT_SIGBUS;
+#else
+                SET_TYPE(VM_FAULT_SIGBUS);
+                return NOPAGE_SIGBUS;
+#endif
+        }
+
+        BUG_ON(nread > PAGE_SIZE);
+        if (!nread) {
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-        clear_user_page(page_address(page), vmf->pgoff, page);
+                clear_user_page(page_address(page), vmf->pgoff, page);
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-        clear_user_page(page_address(page), vaddr, page);
-#else
-        clear_user_page(page_address(page), vaddr);
-#endif
-    }
-    else
-        memset(buf + nread, 0, PAGE_SIZE - nread);
-
-    flush_dcache_page(page);
-    kunmap(page);
+                clear_user_page(page_address(page), vaddr, page);
+#else
+                clear_user_page(page_address(page), vaddr);
+#endif
+        } else
+                memset(buf + nread, 0, PAGE_SIZE - nread);
+
+        flush_dcache_page(page);
+        kunmap(page);
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-    vmf->page = page;
-    return 0;
-#else
-    SET_TYPE(VM_FAULT_MAJOR);
-    return page;
-#endif
-}
-
-static struct vm_operations_struct sf_vma_ops =
-{
+        vmf->page = page;
+        return 0;
+#else
+        SET_TYPE(VM_FAULT_MAJOR);
+        return page;
+#endif
+}
+
+static struct vm_operations_struct sf_vma_ops = {
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
-    .fault = sf_reg_fault
-#else
-    .nopage = sf_reg_nopage
+        .fault = sf_reg_fault
+#else
+        .nopage = sf_reg_nopage
 #endif
 };
@@ -699 +679 @@
 static int sf_reg_mmap(struct file *file, struct vm_area_struct *vma)
 {
-    TRACE();
-    if (vma->vm_flags & VM_SHARED)
-    {
-        LogFunc(("shared mmapping not available\n"));
-        return -EINVAL;
-    }
-
-    vma->vm_ops = &sf_vma_ops;
-    return 0;
-}
-
-struct file_operations sf_reg_fops =
-{
-    .read        = sf_reg_read,
-    .open        = sf_reg_open,
-    .write       = sf_reg_write,
-    .release     = sf_reg_release,
-    .mmap        = sf_reg_mmap,
+        TRACE();
+        if (vma->vm_flags & VM_SHARED) {
+                LogFunc(("shared mmapping not available\n"));
+                return -EINVAL;
+        }
+
+        vma->vm_ops = &sf_vma_ops;
+        return 0;
+}
+
+struct file_operations sf_reg_fops = {
+        .read = sf_reg_read,
+        .open = sf_reg_open,
+        .write = sf_reg_write,
+        .release = sf_reg_release,
+        .mmap = sf_reg_mmap,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 /** @todo This code is known to cause caching of data which should not be
  * cached.  Investigate. */
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
-    .splice_read = sf_splice_read,
-#  else
-    .sendfile    = generic_file_sendfile,
-#  endif
-    .aio_read    = generic_file_aio_read,
-    .aio_write   = generic_file_aio_write,
-# endif
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
-    .fsync       = noop_fsync,
-# else
-    .fsync       = simple_sync_file,
-# endif
-    .llseek      = generic_file_llseek,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
+        .splice_read = sf_splice_read,
+#else
+        .sendfile = generic_file_sendfile,
+#endif
+        .aio_read = generic_file_aio_read,
+        .aio_write = generic_file_aio_write,
+#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
+        .fsync = noop_fsync,
+#else
+        .fsync = simple_sync_file,
+#endif
+        .llseek = generic_file_llseek,
 #endif
 };
 
-
-struct inode_operations sf_reg_iops =
-{
+struct inode_operations sf_reg_iops = {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-    .revalidate = sf_inode_revalidate
-#else
-    .getattr    = sf_getattr,
-    .setattr    = sf_setattr
+        .revalidate = sf_inode_revalidate
+#else
+        .getattr = sf_getattr,
+        .setattr = sf_setattr
 #endif
 };
-
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 static int sf_readpage(struct file *file, struct page *page)
 {
-    struct inode *inode = GET_F_DENTRY(file)->d_inode;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = file->private_data;
-    uint32_t nread = PAGE_SIZE;
-    char *buf;
-    loff_t off = ((loff_t)page->index) << PAGE_SHIFT;
-    int ret;
-
-    TRACE();
-
-    buf = kmap(page);
-    ret = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
-    if (ret)
-    {
-        kunmap(page);
-        if (PageLocked(page))
-            unlock_page(page);
-        return ret;
-    }
-    BUG_ON(nread > PAGE_SIZE);
-    memset(&buf[nread], 0, PAGE_SIZE - nread);
-    flush_dcache_page(page);
-    kunmap(page);
-    SetPageUptodate(page);
-    unlock_page(page);
-    return 0;
-}
-
-static int
-sf_writepage(struct page *page, struct writeback_control *wbc)
-{
-    struct address_space *mapping = page->mapping;
-    struct inode *inode = mapping->host;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
-    struct file *file = sf_i->file;
-    struct sf_reg_info *sf_r = file->private_data;
-    char *buf;
-    uint32_t nwritten = PAGE_SIZE;
-    int end_index = inode->i_size >> PAGE_SHIFT;
-    loff_t off = ((loff_t) page->index) << PAGE_SHIFT;
-    int err;
-
-    TRACE();
-
-    if (page->index >= end_index)
-        nwritten = inode->i_size & (PAGE_SIZE-1);
-
-    buf = kmap(page);
-
-    err = sf_reg_write_aux(__func__, sf_g, sf_r, buf, &nwritten, off);
-    if (err < 0)
-    {
-        ClearPageUptodate(page);
-        goto out;
-    }
-
-    if (off > inode->i_size)
-        inode->i_size = off;
-
-    if (PageError(page))
-        ClearPageError(page);
-    err = 0;
-
-out:
-    kunmap(page);
-
-    unlock_page(page);
-    return err;
-}
-
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
+        struct inode *inode = GET_F_DENTRY(file)->d_inode;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = file->private_data;
+        uint32_t nread = PAGE_SIZE;
+        char *buf;
+        loff_t off = ((loff_t) page->index) << PAGE_SHIFT;
+        int ret;
+
+        TRACE();
+
+        buf = kmap(page);
+        ret = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
+        if (ret) {
+                kunmap(page);
+                if (PageLocked(page))
+                        unlock_page(page);
+                return ret;
+        }
+        BUG_ON(nread > PAGE_SIZE);
+        memset(&buf[nread], 0, PAGE_SIZE - nread);
+        flush_dcache_page(page);
+        kunmap(page);
+        SetPageUptodate(page);
+        unlock_page(page);
+        return 0;
+}
+
+static int sf_writepage(struct page *page, struct writeback_control *wbc)
+{
+        struct address_space *mapping = page->mapping;
+        struct inode *inode = mapping->host;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+        struct file *file = sf_i->file;
+        struct sf_reg_info *sf_r = file->private_data;
+        char *buf;
+        uint32_t nwritten = PAGE_SIZE;
+        int end_index = inode->i_size >> PAGE_SHIFT;
+        loff_t off = ((loff_t) page->index) << PAGE_SHIFT;
+        int err;
+
+        TRACE();
+
+        if (page->index >= end_index)
+                nwritten = inode->i_size & (PAGE_SIZE - 1);
+
+        buf = kmap(page);
+
+        err = sf_reg_write_aux(__func__, sf_g, sf_r, buf, &nwritten, off);
+        if (err < 0) {
+                ClearPageUptodate(page);
+                goto out;
+        }
+
+        if (off > inode->i_size)
+                inode->i_size = off;
+
+        if (PageError(page))
+                ClearPageError(page);
+        err = 0;
+
+ out:
+        kunmap(page);
+
+        unlock_page(page);
+        return err;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
 int sf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
-                   unsigned len, unsigned flags, struct page **pagep, void **fsdata)
-{
-    TRACE();
-
-    return simple_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+                   unsigned len, unsigned flags, struct page **pagep,
+                   void **fsdata)
+{
+        TRACE();
+
+        return simple_write_begin(file, mapping, pos, len, flags, pagep,
+                                  fsdata);
 }
 
 int sf_write_end(struct file *file, struct address_space *mapping, loff_t pos,
-                 unsigned len, unsigned copied, struct page *page, void *fsdata)
-{
-    struct inode *inode = mapping->host;
-    struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
-    struct sf_reg_info *sf_r = file->private_data;
-    void *buf;
-    unsigned from = pos & (PAGE_SIZE - 1);
-    uint32_t nwritten = len;
-    int err;
-
-    TRACE();
-
-    buf = kmap(page);
-    err = sf_reg_write_aux(__func__, sf_g, sf_r, buf+from, &nwritten, pos);
-    kunmap(page);
-
-    if (!PageUptodate(page) && err == PAGE_SIZE)
-        SetPageUptodate(page);
-
-    if (err >= 0) {
-        pos += nwritten;
-        if (pos > inode->i_size)
-            inode->i_size = pos;
-    }
-
-    unlock_page(page);
+                 unsigned len, unsigned copied, struct page *page, void *fsdata)
+{
+        struct inode *inode = mapping->host;
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
+        struct sf_reg_info *sf_r = file->private_data;
+        void *buf;
+        unsigned from = pos & (PAGE_SIZE - 1);
+        uint32_t nwritten = len;
+        int err;
+
+        TRACE();
+
+        buf = kmap(page);
+        err =
+            sf_reg_write_aux(__func__, sf_g, sf_r, buf + from, &nwritten, pos);
+        kunmap(page);
+
+        if (!PageUptodate(page) && err == PAGE_SIZE)
+                SetPageUptodate(page);
+
+        if (err >= 0) {
+                pos += nwritten;
+                if (pos > inode->i_size)
+                        inode->i_size = pos;
+        }
+
+        unlock_page(page);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 6, 0)
-    put_page(page);
-#else
-    page_cache_release(page);
-#endif
-
-    return nwritten;
-}
-
-# endif /* KERNEL_VERSION >= 2.6.24 */
-
-struct address_space_operations sf_reg_aops =
-{
-    .readpage      = sf_readpage,
-    .writepage     = sf_writepage,
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
-    .write_begin   = sf_write_begin,
-    .write_end     = sf_write_end,
-# else
-    .prepare_write = simple_prepare_write,
-    .commit_write  = simple_commit_write,
-# endif
+        put_page(page);
+#else
+        page_cache_release(page);
+#endif
+
+        return nwritten;
+}
+
+#endif                          /* KERNEL_VERSION >= 2.6.24 */
+
+struct address_space_operations sf_reg_aops = {
+        .readpage = sf_readpage,
+        .writepage = sf_writepage,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
+        .write_begin = sf_write_begin,
+        .write_end = sf_write_end,
+#else
+        .prepare_write = simple_prepare_write,
+        .commit_write = simple_commit_write,
+#endif
 };
 #endif

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

@@ -37 +37 @@
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-static void sf_ftime_from_timespec(time_t *time, RTTIMESPEC *ts)
-{
-    int64_t t = RTTimeSpecGetNano(ts);
-
-    do_div(t, 1000000000);
-    *time = t;
-}
-
-static void sf_timespec_from_ftime(RTTIMESPEC *ts, time_t *time)
-{
-    int64_t t = 1000000000 * *time;
-    RTTimeSpecSetNano(ts, t);
-}
-#else /* >= 2.6.0 */
-static void sf_ftime_from_timespec(struct timespec *tv, RTTIMESPEC *ts)
-{
-    int64_t t = RTTimeSpecGetNano(ts);
-    int64_t nsec;
-
-    nsec = do_div(t, 1000000000);
-    tv->tv_sec = t;
-    tv->tv_nsec = nsec;
-}
-
-static void sf_timespec_from_ftime(RTTIMESPEC *ts, struct timespec *tv)
-{
-    int64_t t = (int64_t)tv->tv_nsec + (int64_t)tv->tv_sec * 1000000000;
-    RTTimeSpecSetNano(ts, t);
-}
-#endif /* >= 2.6.0 */
+static void sf_ftime_from_timespec(time_t * time, RTTIMESPEC * ts)
+{
+        int64_t t = RTTimeSpecGetNano(ts);
+
+        do_div(t, 1000000000);
+        *time = t;
+}
+
+static void sf_timespec_from_ftime(RTTIMESPEC * ts, time_t * time)
+{
+        int64_t t = 1000000000 * *time;
+        RTTimeSpecSetNano(ts, t);
+}
+#else                           /* >= 2.6.0 */
+static void sf_ftime_from_timespec(struct timespec *tv, RTTIMESPEC * ts)
+{
+        int64_t t = RTTimeSpecGetNano(ts);
+        int64_t nsec;
+
+        nsec = do_div(t, 1000000000);
+        tv->tv_sec = t;
+        tv->tv_nsec = nsec;
+}
+
+static void sf_timespec_from_ftime(RTTIMESPEC * ts, struct timespec *tv)
+{
+        int64_t t = (int64_t) tv->tv_nsec + (int64_t) tv->tv_sec * 1000000000;
+        RTTimeSpecSetNano(ts, t);
+}
+#endif                          /* >= 2.6.0 */
 
 /* set [inode] attributes based on [info], uid/gid based on [sf_g] */
 void sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
-                   PSHFLFSOBJINFO info)
-{
-    PSHFLFSOBJATTR attr;
-    int mode;
-
-    TRACE();
-
-    attr = &info->Attr;
+                   PSHFLFSOBJINFO info)
+{
+        PSHFLFSOBJATTR attr;
+        int mode;
+
+        TRACE();
+
+        attr = &info->Attr;
 
 #define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0;
-    mode  = mode_set(IRUSR);
-    mode |= mode_set(IWUSR);
-    mode |= mode_set(IXUSR);
-
-    mode |= mode_set(IRGRP);
-    mode |= mode_set(IWGRP);
-    mode |= mode_set(IXGRP);
-
-    mode |= mode_set(IROTH);
-    mode |= mode_set(IWOTH);
-    mode |= mode_set(IXOTH);
+        mode = mode_set(IRUSR);
+        mode |= mode_set(IWUSR);
+        mode |= mode_set(IXUSR);
+
+        mode |= mode_set(IRGRP);
+        mode |= mode_set(IWGRP);
+        mode |= mode_set(IXGRP);
+
+        mode |= mode_set(IROTH);
+        mode |= mode_set(IWOTH);
+        mode |= mode_set(IXOTH);
 
 #undef mode_set
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    inode->i_mapping->a_ops = &sf_reg_aops;
-# if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
-    /* XXX Was this ever necessary? */
-    inode->i_mapping->backing_dev_info = &sf_g->bdi;
-# endif
-#endif
-
-    if (RTFS_IS_DIRECTORY(attr->fMode))
-    {
-        inode->i_mode  = sf_g->dmode != ~0 ? (sf_g->dmode & 0777) : mode;
-        inode->i_mode &= ~sf_g->dmask;
-        inode->i_mode |= S_IFDIR;
-        inode->i_op    = &sf_dir_iops;
-        inode->i_fop   = &sf_dir_fops;
-        /* XXX: this probably should be set to the number of entries
-           in the directory plus two (. ..) */
+        inode->i_mapping->a_ops = &sf_reg_aops;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
+        /* XXX Was this ever necessary? */
+        inode->i_mapping->backing_dev_info = &sf_g->bdi;
+#endif
+#endif
+
+        if (RTFS_IS_DIRECTORY(attr->fMode)) {
+                inode->i_mode = sf_g->dmode != ~0 ? (sf_g->dmode & 0777) : mode;
+                inode->i_mode &= ~sf_g->dmask;
+                inode->i_mode |= S_IFDIR;
+                inode->i_op = &sf_dir_iops;
+                inode->i_fop = &sf_dir_fops;
+                /* XXX: this probably should be set to the number of entries
+                   in the directory plus two (. ..) */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
-        set_nlink(inode, 1);
-#else
-        inode->i_nlink = 1;
-#endif
-    }
+                set_nlink(inode, 1);
+#else
+                inode->i_nlink = 1;
+#endif
+        }
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    else if (RTFS_IS_SYMLINK(attr->fMode))
-    {
-        inode->i_mode  = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
-        inode->i_mode &= ~sf_g->fmask;
-        inode->i_mode |= S_IFLNK;
-        inode->i_op    = &sf_lnk_iops;
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
-        set_nlink(inode, 1);
-# else
-        inode->i_nlink = 1;
-# endif
-    }
-#endif
-    else
-    {
-        inode->i_mode  = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
-        inode->i_mode &= ~sf_g->fmask;
-        inode->i_mode |= S_IFREG;
-        inode->i_op    = &sf_reg_iops;
-        inode->i_fop   = &sf_reg_fops;
+        else if (RTFS_IS_SYMLINK(attr->fMode)) {
+                inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777) : mode;
+                inode->i_mode &= ~sf_g->fmask;
+                inode->i_mode |= S_IFLNK;
+                inode->i_op = &sf_lnk_iops;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
-        set_nlink(inode, 1);
-#else
-        inode->i_nlink = 1;
-#endif
-    }
+                set_nlink(inode, 1);
+#else
+                inode->i_nlink = 1;
+#endif
+        }
+#endif
+        else {
+                inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777) : mode;
+                inode->i_mode &= ~sf_g->fmask;
+                inode->i_mode |= S_IFREG;
+                inode->i_op = &sf_reg_iops;
+                inode->i_fop = &sf_reg_fops;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
+                set_nlink(inode, 1);
+#else
+                inode->i_nlink = 1;
+#endif
+        }
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
-    inode->i_uid = make_kuid(current_user_ns(), sf_g->uid);
-    inode->i_gid = make_kgid(current_user_ns(), sf_g->gid);
-#else
-    inode->i_uid = sf_g->uid;
-    inode->i_gid = sf_g->gid;
-#endif
-
-    inode->i_size = info->cbObject;
+        inode->i_uid = make_kuid(current_user_ns(), sf_g->uid);
+        inode->i_gid = make_kgid(current_user_ns(), sf_g->gid);
+#else
+        inode->i_uid = sf_g->uid;
+        inode->i_gid = sf_g->gid;
+#endif
+
+        inode->i_size = info->cbObject;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6)
-    inode->i_blksize = 4096;
+        inode->i_blksize = 4096;
 #endif
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11)
-    inode->i_blkbits = 12;
-#endif
-    /* i_blocks always in units of 512 bytes! */
-    inode->i_blocks = (info->cbAllocated + 511) / 512;
-
-    sf_ftime_from_timespec(&inode->i_atime, &info->AccessTime);
-    sf_ftime_from_timespec(&inode->i_ctime, &info->ChangeTime);
-    sf_ftime_from_timespec(&inode->i_mtime, &info->ModificationTime);
+        inode->i_blkbits = 12;
+#endif
+        /* i_blocks always in units of 512 bytes! */
+        inode->i_blocks = (info->cbAllocated + 511) / 512;
+
+        sf_ftime_from_timespec(&inode->i_atime, &info->AccessTime);
+        sf_ftime_from_timespec(&inode->i_ctime, &info->ChangeTime);
+        sf_ftime_from_timespec(&inode->i_mtime, &info->ModificationTime);
 }
 
 int sf_stat(const char *caller, struct sf_glob_info *sf_g,
-            SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
-{
-    int rc;
-    SHFLCREATEPARMS params;
-    NOREF(caller);
-
-    TRACE();
-
-    RT_ZERO(params);
-    params.Handle = SHFL_HANDLE_NIL;
-    params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
-    LogFunc(("sf_stat: calling VbglR0SfCreate, file %s, flags %#x\n",
-             path->String.utf8, params.CreateFlags));
-    rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, &params);
-    if (rc == VERR_INVALID_NAME)
-    {
-        /* this can happen for names like 'foo*' on a Windows host */
-        return -ENOENT;
-    }
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfCreate(%s) failed.  caller=%s, rc=%Rrc\n",
-                    path->String.utf8, rc, caller));
-        return -EPROTO;
-    }
-    if (params.Result != SHFL_FILE_EXISTS)
-    {
-        if (!ok_to_fail)
-            LogFunc(("VbglR0SfCreate(%s) file does not exist.  caller=%s, result=%d\n",
-                        path->String.utf8, params.Result, caller));
-        return -ENOENT;
-    }
-
-    *result = params.Info;
-    return 0;
+            SHFLSTRING * path, PSHFLFSOBJINFO result, int ok_to_fail)
+{
+        int rc;
+        SHFLCREATEPARMS params;
+        NOREF(caller);
+
+        TRACE();
+
+        RT_ZERO(params);
+        params.Handle = SHFL_HANDLE_NIL;
+        params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
+        LogFunc(("sf_stat: calling VbglR0SfCreate, file %s, flags %#x\n",
+                 path->String.utf8, params.CreateFlags));
+        rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, &params);
+        if (rc == VERR_INVALID_NAME) {
+                /* this can happen for names like 'foo*' on a Windows host */
+                return -ENOENT;
+        }
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfCreate(%s) failed.  caller=%s, rc=%Rrc\n",
+                         path->String.utf8, rc, caller));
+                return -EPROTO;
+        }
+        if (params.Result != SHFL_FILE_EXISTS) {
+                if (!ok_to_fail)
+                        LogFunc(("VbglR0SfCreate(%s) file does not exist.  caller=%s, result=%d\n", path->String.utf8, params.Result, caller));
+                return -ENOENT;
+        }
+
+        *result = params.Info;
+        return 0;
 }
 
@@ -214 +207 @@
 int sf_inode_revalidate(struct dentry *dentry)
 {
-    int err;
-    struct sf_glob_info *sf_g;
-    struct sf_inode_info *sf_i;
-    SHFLFSOBJINFO info;
-
-    TRACE();
-    if (!dentry || !dentry->d_inode)
-    {
-        LogFunc(("no dentry(%p) or inode(%p)\n", dentry, dentry->d_inode));
-        return -EINVAL;
-    }
-
-    sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
-    sf_i = GET_INODE_INFO(dentry->d_inode);
+        int err;
+        struct sf_glob_info *sf_g;
+        struct sf_inode_info *sf_i;
+        SHFLFSOBJINFO info;
+
+        TRACE();
+        if (!dentry || !dentry->d_inode) {
+                LogFunc(("no dentry(%p) or inode(%p)\n", dentry,
+                         dentry->d_inode));
+                return -EINVAL;
+        }
+
+        sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
+        sf_i = GET_INODE_INFO(dentry->d_inode);
 
 #if 0
-    printk("%s called by %p:%p\n",
-            sf_i->path->String.utf8,
-            __builtin_return_address (0),
-            __builtin_return_address (1));
-#endif
-
-    BUG_ON(!sf_g);
-    BUG_ON(!sf_i);
-
-    if (!sf_i->force_restat)
-    {
-        if (jiffies - dentry->d_time < sf_g->ttl)
-            return 0;
-    }
-
-    err = sf_stat(__func__, sf_g, sf_i->path, &info, 1);
-    if (err)
-        return err;
-
-    dentry->d_time = jiffies;
-    sf_init_inode(sf_g, dentry->d_inode, &info);
-    return 0;
+        printk("%s called by %p:%p\n",
+               sf_i->path->String.utf8,
+               __builtin_return_address(0), __builtin_return_address(1));
+#endif
+
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
+
+        if (!sf_i->force_restat) {
+                if (jiffies - dentry->d_time < sf_g->ttl)
+                        return 0;
+        }
+
+        err = sf_stat(__func__, sf_g, sf_i->path, &info, 1);
+        if (err)
+                return err;
+
+        dentry->d_time = jiffies;
+        sf_init_inode(sf_g, dentry->d_inode, &info);
+        return 0;
 }
 
@@ -266 +257 @@
 #endif
 {
-    TRACE();
+        TRACE();
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
-    if (flags & LOOKUP_RCU)
-        return -ECHILD;
+        if (flags & LOOKUP_RCU)
+                return -ECHILD;
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
-    /* see Documentation/filesystems/vfs.txt */
-    if (nd && nd->flags & LOOKUP_RCU)
-        return -ECHILD;
-#endif
-
-    if (sf_inode_revalidate(dentry))
-        return 0;
-
-    return 1;
+        /* see Documentation/filesystems/vfs.txt */
+        if (nd && nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+#endif
+
+        if (sf_inode_revalidate(dentry))
+                return 0;
+
+        return 1;
 }
 
@@ -288 +279 @@
    [generic_fillattr] */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-# 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)
-# else
+#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)
+#else
 int sf_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
-# endif
-{
-    int err;
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
-    struct dentry *dentry = path->dentry;
-# endif
-
-    TRACE();
-    err = sf_inode_revalidate(dentry);
-    if (err)
-        return err;
-
-    generic_fillattr(dentry->d_inode, kstat);
-    return 0;
+#endif
+{
+        int err;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
+        struct dentry *dentry = path->dentry;
+#endif
+
+        TRACE();
+        err = sf_inode_revalidate(dentry);
+        if (err)
+                return err;
+
+        generic_fillattr(dentry->d_inode, kstat);
+        return 0;
 }
 
 int sf_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-    struct sf_glob_info *sf_g;
-    struct sf_inode_info *sf_i;
-    SHFLCREATEPARMS params;
-    SHFLFSOBJINFO info;
-    uint32_t cbBuffer;
-    int rc, err;
-
-    TRACE();
-
-    sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
-    sf_i = GET_INODE_INFO(dentry->d_inode);
-    err  = 0;
-
-    RT_ZERO(params);
-    params.Handle = SHFL_HANDLE_NIL;
-    params.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
-                       | SHFL_CF_ACT_FAIL_IF_NEW
-                       | SHFL_CF_ACCESS_ATTR_WRITE;
-
-    /* this is at least required for Posix hosts */
-    if (iattr->ia_valid & ATTR_SIZE)
-        params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
-
-    rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
-    if (RT_FAILURE(rc))
-    {
-        LogFunc(("VbglR0SfCreate(%s) failed rc=%Rrc\n",
-                 sf_i->path->String.utf8, rc));
-        err = -RTErrConvertToErrno(rc);
-        goto fail2;
-    }
-    if (params.Result != SHFL_FILE_EXISTS)
-    {
-        LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
-        err = -ENOENT;
-        goto fail1;
-    }
-
-    /* Setting the file size and setting the other attributes has to be
-     * handled separately, see implementation of vbsfSetFSInfo() in
-     * vbsf.cpp */
-    if (iattr->ia_valid & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME))
-    {
+        struct sf_glob_info *sf_g;
+        struct sf_inode_info *sf_i;
+        SHFLCREATEPARMS params;
+        SHFLFSOBJINFO info;
+        uint32_t cbBuffer;
+        int rc, err;
+
+        TRACE();
+
+        sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
+        sf_i = GET_INODE_INFO(dentry->d_inode);
+        err = 0;
+
+        RT_ZERO(params);
+        params.Handle = SHFL_HANDLE_NIL;
+        params.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
+            | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_ATTR_WRITE;
+
+        /* this is at least required for Posix hosts */
+        if (iattr->ia_valid & ATTR_SIZE)
+                params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
+
+        rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+        if (RT_FAILURE(rc)) {
+                LogFunc(("VbglR0SfCreate(%s) failed rc=%Rrc\n",
+                         sf_i->path->String.utf8, rc));
+                err = -RTErrConvertToErrno(rc);
+                goto fail2;
+        }
+        if (params.Result != SHFL_FILE_EXISTS) {
+                LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
+                err = -ENOENT;
+                goto fail1;
+        }
+
+        /* Setting the file size and setting the other attributes has to be
+         * handled separately, see implementation of vbsfSetFSInfo() in
+         * 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(info);
-        if (iattr->ia_valid & ATTR_MODE)
-        {
-            info.Attr.fMode  = mode_set(IRUSR);
-            info.Attr.fMode |= mode_set(IWUSR);
-            info.Attr.fMode |= mode_set(IXUSR);
-            info.Attr.fMode |= mode_set(IRGRP);
-            info.Attr.fMode |= mode_set(IWGRP);
-            info.Attr.fMode |= mode_set(IXGRP);
-            info.Attr.fMode |= mode_set(IROTH);
-            info.Attr.fMode |= mode_set(IWOTH);
-            info.Attr.fMode |= mode_set(IXOTH);
-
-            if (iattr->ia_mode & S_IFDIR)
-                info.Attr.fMode |= RTFS_TYPE_DIRECTORY;
-            else
-                info.Attr.fMode |= RTFS_TYPE_FILE;
-        }
-
-        if (iattr->ia_valid & ATTR_ATIME)
-            sf_timespec_from_ftime(&info.AccessTime, &iattr->ia_atime);
-        if (iattr->ia_valid & ATTR_MTIME)
-            sf_timespec_from_ftime(&info.ModificationTime, &iattr->ia_mtime);
-        /* ignore ctime (inode change time) as it can't be set from userland anyway */
-
-        cbBuffer = sizeof(info);
-        rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, params.Handle,
-                            SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer,
-                            (PSHFLDIRINFO)&info);
-        if (RT_FAILURE(rc))
-        {
-            LogFunc(("VbglR0SfFsInfo(%s, FILE) failed rc=%Rrc\n",
-                        sf_i->path->String.utf8, rc));
-            err = -RTErrConvertToErrno(rc);
-            goto fail1;
-        }
-    }
-
-    if (iattr->ia_valid & ATTR_SIZE)
-    {
-        RT_ZERO(info);
-        info.cbObject = iattr->ia_size;
-        cbBuffer = sizeof(info);
-        rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, params.Handle,
-                            SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer,
-                            (PSHFLDIRINFO)&info);
-        if (RT_FAILURE(rc))
-        {
-            LogFunc(("VbglR0SfFsInfo(%s, SIZE) failed rc=%Rrc\n",
-                        sf_i->path->String.utf8, rc));
-            err = -RTErrConvertToErrno(rc);
-            goto fail1;
-        }
-    }
-
-    rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-    if (RT_FAILURE(rc))
-        LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
-
-    return sf_inode_revalidate(dentry);
-
-fail1:
-    rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
-    if (RT_FAILURE(rc))
-        LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n", sf_i->path->String.utf8, rc));
-
-fail2:
-    return err;
-}
-#endif /* >= 2.6.0 */
+                RT_ZERO(info);
+                if (iattr->ia_valid & ATTR_MODE) {
+                        info.Attr.fMode = mode_set(IRUSR);
+                        info.Attr.fMode |= mode_set(IWUSR);
+                        info.Attr.fMode |= mode_set(IXUSR);
+                        info.Attr.fMode |= mode_set(IRGRP);
+                        info.Attr.fMode |= mode_set(IWGRP);
+                        info.Attr.fMode |= mode_set(IXGRP);
+                        info.Attr.fMode |= mode_set(IROTH);
+                        info.Attr.fMode |= mode_set(IWOTH);
+                        info.Attr.fMode |= mode_set(IXOTH);
+
+                        if (iattr->ia_mode & S_IFDIR)
+                                info.Attr.fMode |= RTFS_TYPE_DIRECTORY;
+                        else
+                                info.Attr.fMode |= RTFS_TYPE_FILE;
+                }
+
+                if (iattr->ia_valid & ATTR_ATIME)
+                        sf_timespec_from_ftime(&info.AccessTime,
+                                               &iattr->ia_atime);
+                if (iattr->ia_valid & ATTR_MTIME)
+                        sf_timespec_from_ftime(&info.ModificationTime,
+                                               &iattr->ia_mtime);
+                /* ignore ctime (inode change time) as it can't be set from userland anyway */
+
+                cbBuffer = sizeof(info);
+                rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, params.Handle,
+                                    SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer,
+                                    (PSHFLDIRINFO) & info);
+                if (RT_FAILURE(rc)) {
+                        LogFunc(("VbglR0SfFsInfo(%s, FILE) failed rc=%Rrc\n",
+                                 sf_i->path->String.utf8, rc));
+                        err = -RTErrConvertToErrno(rc);
+                        goto fail1;
+                }
+        }
+
+        if (iattr->ia_valid & ATTR_SIZE) {
+                RT_ZERO(info);
+                info.cbObject = iattr->ia_size;
+                cbBuffer = sizeof(info);
+                rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, params.Handle,
+                                    SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer,
+                                    (PSHFLDIRINFO) & info);
+                if (RT_FAILURE(rc)) {
+                        LogFunc(("VbglR0SfFsInfo(%s, SIZE) failed rc=%Rrc\n",
+                                 sf_i->path->String.utf8, rc));
+                        err = -RTErrConvertToErrno(rc);
+                        goto fail1;
+                }
+        }
+
+        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc))
+                LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n",
+                         sf_i->path->String.utf8, rc));
+
+        return sf_inode_revalidate(dentry);
+
+ fail1:
+        rc = VbglR0SfClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc))
+                LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n",
+                         sf_i->path->String.utf8, rc));
+
+ fail2:
+        return err;
+}
+#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)
-{
-    size_t path_len, shflstring_len;
-    SHFLSTRING *tmp;
-    uint16_t p_len;
-    uint8_t *p_name;
-    int fRoot = 0;
-
-    TRACE();
-    p_len = sf_i->path->u16Length;
-    p_name = sf_i->path->String.utf8;
-
-    if (p_len == 1 && *p_name == '/')
-    {
-        path_len = d_len + 1;
-        fRoot = 1;
-    }
-    else
-    {
-        /* lengths of constituents plus terminating zero plus slash  */
-        path_len = p_len + d_len + 2;
-        if (path_len > 0xffff)
-        {
-            LogFunc(("path too long.  caller=%s, path_len=%zu\n", caller, path_len));
-            return -ENAMETOOLONG;
-        }
-    }
-
-    shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len;
-    tmp = kmalloc(shflstring_len, GFP_KERNEL);
-    if (!tmp)
-    {
-        LogRelFunc(("kmalloc failed, caller=%s\n", caller));
-        return -ENOMEM;
-    }
-    tmp->u16Length = path_len - 1;
-    tmp->u16Size = path_len;
-
-    if (fRoot)
-        memcpy(&tmp->String.utf8[0], d_name, d_len + 1);
-    else
-    {
-        memcpy(&tmp->String.utf8[0], p_name, p_len);
-        tmp->String.utf8[p_len] = '/';
-        memcpy(&tmp->String.utf8[p_len + 1], d_name, d_len);
-        tmp->String.utf8[p_len + 1 + d_len] = '\0';
-    }
-
-    *result = tmp;
-    return 0;
+                        const char *d_name, size_t d_len, SHFLSTRING ** result)
+{
+        size_t path_len, shflstring_len;
+        SHFLSTRING *tmp;
+        uint16_t p_len;
+        uint8_t *p_name;
+        int fRoot = 0;
+
+        TRACE();
+        p_len = sf_i->path->u16Length;
+        p_name = sf_i->path->String.utf8;
+
+        if (p_len == 1 && *p_name == '/') {
+                path_len = d_len + 1;
+                fRoot = 1;
+        } else {
+                /* lengths of constituents plus terminating zero plus slash  */
+                path_len = p_len + d_len + 2;
+                if (path_len > 0xffff) {
+                        LogFunc(("path too long.  caller=%s, path_len=%zu\n",
+                                 caller, path_len));
+                        return -ENAMETOOLONG;
+                }
+        }
+
+        shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len;
+        tmp = kmalloc(shflstring_len, GFP_KERNEL);
+        if (!tmp) {
+                LogRelFunc(("kmalloc failed, caller=%s\n", caller));
+                return -ENOMEM;
+        }
+        tmp->u16Length = path_len - 1;
+        tmp->u16Size = path_len;
+
+        if (fRoot)
+                memcpy(&tmp->String.utf8[0], d_name, d_len + 1);
+        else {
+                memcpy(&tmp->String.utf8[0], p_name, p_len);
+                tmp->String.utf8[p_len] = '/';
+                memcpy(&tmp->String.utf8[p_len + 1], d_name, d_len);
+                tmp->String.utf8[p_len + 1 + d_len] = '\0';
+        }
+
+        *result = tmp;
+        return 0;
 }
 
@@ -485 +468 @@
  */
 int sf_path_from_dentry(const char *caller, struct sf_glob_info *sf_g,
-                        struct sf_inode_info *sf_i, struct dentry *dentry,
-                        SHFLSTRING **result)
-{
-    int err;
-    const char *d_name;
-    size_t d_len;
-    const char *name;
-    size_t len = 0;
-
-    TRACE();
-    d_name = dentry->d_name.name;
-    d_len = dentry->d_name.len;
-
-    if (sf_g->nls)
-    {
-        size_t in_len, i, out_bound_len;
-        const char *in;
-        char *out;
-
-        in = d_name;
-        in_len = d_len;
-
-        out_bound_len = PATH_MAX;
-        out = kmalloc(out_bound_len, GFP_KERNEL);
-        name = out;
-
-        for (i = 0; i < d_len; ++i)
-        {
-            /* We renamed the linux kernel wchar_t type to linux_wchar_t in
-               the-linux-kernel.h, as it conflicts with the C++ type of that name. */
-            linux_wchar_t uni;
-            int nb;
-
-            nb = sf_g->nls->char2uni(in, in_len, &uni);
-            if (nb < 0)
-            {
-                LogFunc(("nls->char2uni failed %x %d\n",
-                            *in, in_len));
-                err = -EINVAL;
-                goto fail1;
-            }
-            in_len -= nb;
-            in += nb;
+                        struct sf_inode_info *sf_i, struct dentry *dentry,
+                        SHFLSTRING ** result)
+{
+        int err;
+        const char *d_name;
+        size_t d_len;
+        const char *name;
+        size_t len = 0;
+
+        TRACE();
+        d_name = dentry->d_name.name;
+        d_len = dentry->d_name.len;
+
+        if (sf_g->nls) {
+                size_t in_len, i, out_bound_len;
+                const char *in;
+                char *out;
+
+                in = d_name;
+                in_len = d_len;
+
+                out_bound_len = PATH_MAX;
+                out = kmalloc(out_bound_len, GFP_KERNEL);
+                name = out;
+
+                for (i = 0; i < d_len; ++i) {
+                        /* We renamed the linux kernel wchar_t type to linux_wchar_t in
+                           the-linux-kernel.h, as it conflicts with the C++ type of that name. */
+                        linux_wchar_t uni;
+                        int nb;
+
+                        nb = sf_g->nls->char2uni(in, in_len, &uni);
+                        if (nb < 0) {
+                                LogFunc(("nls->char2uni failed %x %d\n",
+                                         *in, in_len));
+                                err = -EINVAL;
+                                goto fail1;
+                        }
+                        in_len -= nb;
+                        in += nb;
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
-            nb = utf32_to_utf8(uni, out, out_bound_len);
-#else
-            nb = utf8_wctomb(out, uni, out_bound_len);
-#endif
-            if (nb < 0)
-            {
-                LogFunc(("nls->uni2char failed %x %d\n",
-                            uni, out_bound_len));
-                err = -EINVAL;
-                goto fail1;
-            }
-            out_bound_len -= nb;
-            out += nb;
-            len += nb;
-        }
-        if (len >= PATH_MAX - 1)
-        {
-            err = -ENAMETOOLONG;
-            goto fail1;
-        }
-
-        LogFunc(("result(%d) = %.*s\n", len, len, name));
-        *out = 0;
-    }
-    else
-    {
-        name = d_name;
-        len = d_len;
-    }
-
-    err = sf_make_path(caller, sf_i, name, len, result);
-    if (name != d_name)
-        kfree(name);
-
-    return err;
-
-fail1:
-    kfree(name);
-    return err;
+                        nb = utf32_to_utf8(uni, out, out_bound_len);
+#else
+                        nb = utf8_wctomb(out, uni, out_bound_len);
+#endif
+                        if (nb < 0) {
+                                LogFunc(("nls->uni2char failed %x %d\n",
+                                         uni, out_bound_len));
+                                err = -EINVAL;
+                                goto fail1;
+                        }
+                        out_bound_len -= nb;
+                        out += nb;
+                        len += nb;
+                }
+                if (len >= PATH_MAX - 1) {
+                        err = -ENAMETOOLONG;
+                        goto fail1;
+                }
+
+                LogFunc(("result(%d) = %.*s\n", len, len, name));
+                *out = 0;
+        } else {
+                name = d_name;
+                len = d_len;
+        }
+
+        err = sf_make_path(caller, sf_i, name, len, result);
+        if (name != d_name)
+                kfree(name);
+
+        return err;
+
+ fail1:
+        kfree(name);
+        return err;
 }
 
 int sf_nlscpy(struct sf_glob_info *sf_g,
-              char *name, size_t name_bound_len,
-              const unsigned char *utf8_name, size_t utf8_len)
-{
-    if (sf_g->nls)
-    {
-        const char *in;
-        char *out;
-        size_t out_len;
-        size_t out_bound_len;
-        size_t in_bound_len;
-
-        in = utf8_name;
-        in_bound_len = utf8_len;
-
-        out = name;
-        out_len = 0;
-        out_bound_len = name_bound_len;
-
-        while (in_bound_len)
-        {
-            int nb;
+              char *name, size_t name_bound_len,
+              const unsigned char *utf8_name, size_t utf8_len)
+{
+        if (sf_g->nls) {
+                const char *in;
+                char *out;
+                size_t out_len;
+                size_t out_bound_len;
+                size_t in_bound_len;
+
+                in = utf8_name;
+                in_bound_len = utf8_len;
+
+                out = name;
+                out_len = 0;
+                out_bound_len = name_bound_len;
+
+                while (in_bound_len) {
+                        int nb;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
-            unicode_t uni;
-
-            nb = utf8_to_utf32(in, in_bound_len, &uni);
-#else
-            linux_wchar_t uni;
-
-            nb = utf8_mbtowc(&uni, in, in_bound_len);
-#endif
-            if (nb < 0)
-            {
-                LogFunc(("utf8_mbtowc failed(%s) %x:%d\n",
-                            (const char *) utf8_name, *in, in_bound_len));
-                return -EINVAL;
-            }
-            in += nb;
-            in_bound_len -= nb;
-
-            nb = sf_g->nls->uni2char(uni, out, out_bound_len);
-            if (nb < 0)
-            {
-                LogFunc(("nls->uni2char failed(%s) %x:%d\n",
-                            utf8_name, uni, out_bound_len));
-                return nb;
-            }
-            out += nb;
-            out_bound_len -= nb;
-            out_len += nb;
-        }
-
-        *out = 0;
-    }
-    else
-    {
-        if (utf8_len + 1 > name_bound_len)
-            return -ENAMETOOLONG;
-
-        memcpy(name, utf8_name, utf8_len + 1);
-    }
-    return 0;
+                        unicode_t uni;
+
+                        nb = utf8_to_utf32(in, in_bound_len, &uni);
+#else
+                        linux_wchar_t uni;
+
+                        nb = utf8_mbtowc(&uni, in, in_bound_len);
+#endif
+                        if (nb < 0) {
+                                LogFunc(("utf8_mbtowc failed(%s) %x:%d\n",
+                                         (const char *)utf8_name, *in,
+                                         in_bound_len));
+                                return -EINVAL;
+                        }
+                        in += nb;
+                        in_bound_len -= nb;
+
+                        nb = sf_g->nls->uni2char(uni, out, out_bound_len);
+                        if (nb < 0) {
+                                LogFunc(("nls->uni2char failed(%s) %x:%d\n",
+                                         utf8_name, uni, out_bound_len));
+                                return nb;
+                        }
+                        out += nb;
+                        out_bound_len -= nb;
+                        out_len += nb;
+                }
+
+                *out = 0;
+        } else {
+                if (utf8_len + 1 > name_bound_len)
+                        return -ENAMETOOLONG;
+
+                memcpy(name, utf8_name, utf8_len + 1);
+        }
+        return 0;
 }
 
 static struct sf_dir_buf *sf_dir_buf_alloc(void)
 {
-    struct sf_dir_buf *b;
-
-    TRACE();
-    b = kmalloc(sizeof(*b), GFP_KERNEL);
-    if (!b)
-    {
-        LogRelFunc(("could not alloc directory buffer\n"));
-        return NULL;
-    }
-
+        struct sf_dir_buf *b;
+
+        TRACE();
+        b = kmalloc(sizeof(*b), GFP_KERNEL);
+        if (!b) {
+                LogRelFunc(("could not alloc directory buffer\n"));
+                return NULL;
+        }
 #ifdef USE_VMALLOC
-    b->buf = vmalloc(DIR_BUFFER_SIZE);
-#else
-    b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
-#endif
-    if (!b->buf)
-    {
-        kfree(b);
-        LogRelFunc(("could not alloc directory buffer storage\n"));
-        return NULL;
-    }
-
-    INIT_LIST_HEAD(&b->head);
-    b->cEntries = 0;
-    b->cbUsed   = 0;
-    b->cbFree   = DIR_BUFFER_SIZE;
-    return b;
+        b->buf = vmalloc(DIR_BUFFER_SIZE);
+#else
+        b->buf = kmalloc(DIR_BUFFER_SIZE, GFP_KERNEL);
+#endif
+        if (!b->buf) {
+                kfree(b);
+                LogRelFunc(("could not alloc directory buffer storage\n"));
+                return NULL;
+        }
+
+        INIT_LIST_HEAD(&b->head);
+        b->cEntries = 0;
+        b->cbUsed = 0;
+        b->cbFree = DIR_BUFFER_SIZE;
+        return b;
 }
 
 static void sf_dir_buf_free(struct sf_dir_buf *b)
 {
-    BUG_ON(!b || !b->buf);
-
-    TRACE();
-    list_del(&b->head);
+        BUG_ON(!b || !b->buf);
+
+        TRACE();
+        list_del(&b->head);
 #ifdef USE_VMALLOC
-    vfree(b->buf);
-#else
-    kfree(b->buf);
-#endif
-    kfree(b);
+        vfree(b->buf);
+#else
+        kfree(b->buf);
+#endif
+        kfree(b);
 }
 
@@ -685 +653 @@
 void sf_dir_info_free(struct sf_dir_info *p)
 {
-    struct list_head *list, *pos, *tmp;
-
-    TRACE();
-    list = &p->info_list;
-    list_for_each_safe(pos, tmp, list)
-    {
-        struct sf_dir_buf *b;
-
-        b = list_entry(pos, struct sf_dir_buf, head);
-        sf_dir_buf_free(b);
-    }
-    kfree(p);
+        struct list_head *list, *pos, *tmp;
+
+        TRACE();
+        list = &p->info_list;
+        list_for_each_safe(pos, tmp, list) {
+                struct sf_dir_buf *b;
+
+                b = list_entry(pos, struct sf_dir_buf, head);
+                sf_dir_buf_free(b);
+        }
+        kfree(p);
 }
 
@@ -704 +671 @@
 void sf_dir_info_empty(struct sf_dir_info *p)
 {
-    struct list_head *list, *pos, *tmp;
-    TRACE();
-    list = &p->info_list;
-    list_for_each_safe(pos, tmp, list)
-    {
-        struct sf_dir_buf *b;
-        b = list_entry(pos, struct sf_dir_buf, head);
-        b->cEntries = 0;
-        b->cbUsed   = 0;
-        b->cbFree = DIR_BUFFER_SIZE;
-    }
+        struct list_head *list, *pos, *tmp;
+        TRACE();
+        list = &p->info_list;
+        list_for_each_safe(pos, tmp, list) {
+                struct sf_dir_buf *b;
+                b = list_entry(pos, struct sf_dir_buf, head);
+                b->cEntries = 0;
+                b->cbUsed = 0;
+                b->cbFree = DIR_BUFFER_SIZE;
+        }
 }
 
@@ -722 +688 @@
 struct sf_dir_info *sf_dir_info_alloc(void)
 {
-    struct sf_dir_info *p;
-
-    TRACE();
-    p = kmalloc(sizeof(*p), GFP_KERNEL);
-    if (!p)
-    {
-        LogRelFunc(("could not alloc directory info\n"));
-        return NULL;
-    }
-
-    INIT_LIST_HEAD(&p->info_list);
-    return p;
+        struct sf_dir_info *p;
+
+        TRACE();
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (!p) {
+                LogRelFunc(("could not alloc directory info\n"));
+                return NULL;
+        }
+
+        INIT_LIST_HEAD(&p->info_list);
+        return p;
 }
 
@@ -741 +706 @@
 static struct sf_dir_buf *sf_get_empty_dir_buf(struct sf_dir_info *sf_d)
 {
-    struct list_head *list, *pos;
-
-    list = &sf_d->info_list;
-    list_for_each(pos, list)
-    {
-        struct sf_dir_buf *b;
-
-        b = list_entry(pos, struct sf_dir_buf, head);
-        if (!b)
-            return NULL;
-        else
-        {
-            if (b->cbUsed == 0)
-                return b;
-        }
-    }
-
-    return NULL;
+        struct list_head *list, *pos;
+
+        list = &sf_d->info_list;
+        list_for_each(pos, list) {
+                struct sf_dir_buf *b;
+
+                b = list_entry(pos, struct sf_dir_buf, head);
+                if (!b)
+                        return NULL;
+                else {
+                        if (b->cbUsed == 0)
+                                return b;
+                }
+        }
+
+        return NULL;
 }
 
 int sf_dir_read_all(struct sf_glob_info *sf_g, struct sf_inode_info *sf_i,
-                    struct sf_dir_info *sf_d, SHFLHANDLE handle)
-{
-    int err;
-    SHFLSTRING *mask;
-    struct sf_dir_buf *b;
-
-    TRACE();
-    err = sf_make_path(__func__, sf_i, "*", 1, &mask);
-    if (err)
-        goto fail0;
-
-    for (;;)
-    {
-        int rc;
-        void *buf;
-        uint32_t cbSize;
-        uint32_t cEntries;
-
-        b = sf_get_empty_dir_buf(sf_d);
-        if (!b)
-        {
-            b = sf_dir_buf_alloc();
-            if (!b)
-            {
-                err = -ENOMEM;
-                LogRelFunc(("could not alloc directory buffer\n"));
-                goto fail1;
-            }
-            list_add(&b->head, &sf_d->info_list);
-        }
-
-        buf = b->buf;
-        cbSize = b->cbFree;
-
-        rc = VbglR0SfDirInfo(&client_handle, &sf_g->map, handle, mask,
-                             0, 0, &cbSize, buf, &cEntries);
-        switch (rc)
-        {
-            case VINF_SUCCESS:
-                RT_FALL_THRU();
-            case VERR_NO_MORE_FILES:
-                break;
-            case VERR_NO_TRANSLATION:
-                LogFunc(("host could not translate entry\n"));
-                /* XXX */
-                break;
-            default:
-                err = -RTErrConvertToErrno(rc);
-                LogFunc(("VbglR0SfDirInfo failed rc=%Rrc\n", rc));
-                goto fail1;
-        }
-
-        b->cEntries += cEntries;
-        b->cbFree   -= cbSize;
-        b->cbUsed   += cbSize;
-
-        if (RT_FAILURE(rc))
-            break;
-    }
-    err = 0;
-
-fail1:
-    kfree(mask);
-
-fail0:
-    return err;
-}
-
-int sf_get_volume_info(struct super_block *sb, STRUCT_STATFS *stat)
-{
-    struct sf_glob_info *sf_g;
-    SHFLVOLINFO SHFLVolumeInfo;
-    uint32_t cbBuffer;
-    int rc;
-
-    sf_g = GET_GLOB_INFO(sb);
-    cbBuffer = sizeof(SHFLVolumeInfo);
-    rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
-                        &cbBuffer, (PSHFLDIRINFO)&SHFLVolumeInfo);
-    if (RT_FAILURE(rc))
-        return -RTErrConvertToErrno(rc);
-
-    stat->f_type        = NFS_SUPER_MAGIC; /* XXX vboxsf type? */
-    stat->f_bsize       = SHFLVolumeInfo.ulBytesPerAllocationUnit;
-    stat->f_blocks      = SHFLVolumeInfo.ullTotalAllocationBytes
-                        / SHFLVolumeInfo.ulBytesPerAllocationUnit;
-    stat->f_bfree       = SHFLVolumeInfo.ullAvailableAllocationBytes
-                        / SHFLVolumeInfo.ulBytesPerAllocationUnit;
-    stat->f_bavail      = SHFLVolumeInfo.ullAvailableAllocationBytes
-                        / SHFLVolumeInfo.ulBytesPerAllocationUnit;
-    stat->f_files       = 1000;
-    stat->f_ffree       = 1000; /* don't return 0 here since the guest may think
-                                 * that it is not possible to create any more files */
-    stat->f_fsid.val[0] = 0;
-    stat->f_fsid.val[1] = 0;
-    stat->f_namelen     = 255;
-    return 0;
-}
-
-struct dentry_operations sf_dentry_ops =
-{
-    .d_revalidate = sf_dentry_revalidate
+                    struct sf_dir_info *sf_d, SHFLHANDLE handle)
+{
+        int err;
+        SHFLSTRING *mask;
+        struct sf_dir_buf *b;
+
+        TRACE();
+        err = sf_make_path(__func__, sf_i, "*", 1, &mask);
+        if (err)
+                goto fail0;
+
+        for (;;) {
+                int rc;
+                void *buf;
+                uint32_t cbSize;
+                uint32_t cEntries;
+
+                b = sf_get_empty_dir_buf(sf_d);
+                if (!b) {
+                        b = sf_dir_buf_alloc();
+                        if (!b) {
+                                err = -ENOMEM;
+                                LogRelFunc(("could not alloc directory buffer\n"));
+                                goto fail1;
+                        }
+                        list_add(&b->head, &sf_d->info_list);
+                }
+
+                buf = b->buf;
+                cbSize = b->cbFree;
+
+                rc = VbglR0SfDirInfo(&client_handle, &sf_g->map, handle, mask,
+                                     0, 0, &cbSize, buf, &cEntries);
+                switch (rc) {
+                case VINF_SUCCESS:
+                        RT_FALL_THRU();
+                case VERR_NO_MORE_FILES:
+                        break;
+                case VERR_NO_TRANSLATION:
+                        LogFunc(("host could not translate entry\n"));
+                        /* XXX */
+                        break;
+                default:
+                        err = -RTErrConvertToErrno(rc);
+                        LogFunc(("VbglR0SfDirInfo failed rc=%Rrc\n", rc));
+                        goto fail1;
+                }
+
+                b->cEntries += cEntries;
+                b->cbFree -= cbSize;
+                b->cbUsed += cbSize;
+
+                if (RT_FAILURE(rc))
+                        break;
+        }
+        err = 0;
+
+ fail1:
+        kfree(mask);
+
+ fail0:
+        return err;
+}
+
+int sf_get_volume_info(struct super_block *sb, STRUCT_STATFS * stat)
+{
+        struct sf_glob_info *sf_g;
+        SHFLVOLINFO SHFLVolumeInfo;
+        uint32_t cbBuffer;
+        int rc;
+
+        sf_g = GET_GLOB_INFO(sb);
+        cbBuffer = sizeof(SHFLVolumeInfo);
+        rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, 0,
+                            SHFL_INFO_GET | SHFL_INFO_VOLUME, &cbBuffer,
+                            (PSHFLDIRINFO) & SHFLVolumeInfo);
+        if (RT_FAILURE(rc))
+                return -RTErrConvertToErrno(rc);
+
+        stat->f_type = NFS_SUPER_MAGIC; /* XXX vboxsf type? */
+        stat->f_bsize = SHFLVolumeInfo.ulBytesPerAllocationUnit;
+        stat->f_blocks = SHFLVolumeInfo.ullTotalAllocationBytes
+            / SHFLVolumeInfo.ulBytesPerAllocationUnit;
+        stat->f_bfree = SHFLVolumeInfo.ullAvailableAllocationBytes
+            / SHFLVolumeInfo.ulBytesPerAllocationUnit;
+        stat->f_bavail = SHFLVolumeInfo.ullAvailableAllocationBytes
+            / SHFLVolumeInfo.ulBytesPerAllocationUnit;
+        stat->f_files = 1000;
+        stat->f_ffree = 1000;   /* don't return 0 here since the guest may think
+                                 * that it is not possible to create any more files */
+        stat->f_fsid.val[0] = 0;
+        stat->f_fsid.val[1] = 0;
+        stat->f_namelen = 255;
+        return 0;
+}
+
+struct dentry_operations sf_dentry_ops = {
+        .d_revalidate = sf_dentry_revalidate
 };
 
 int sf_init_backing_dev(struct sf_glob_info *sf_g)
 {
-    int rc = 0;
+        int rc = 0;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
-    /* Each new shared folder map gets a new uint64_t identifier,
-     * allocated in sequence.  We ASSUME the sequence will not wrap. */
-    static uint64_t s_u64Sequence = 0;
-    uint64_t u64CurrentSequence = ASMAtomicIncU64(&s_u64Sequence);
-
-    sf_g->bdi.ra_pages = 0; /* No readahead */
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
-    sf_g->bdi.capabilities  = BDI_CAP_MAP_DIRECT    /* MAP_SHARED */
-                            | BDI_CAP_MAP_COPY      /* MAP_PRIVATE */
-                            | BDI_CAP_READ_MAP      /* can be mapped for reading */
-                            | BDI_CAP_WRITE_MAP     /* can be mapped for writing */
-                            | BDI_CAP_EXEC_MAP;     /* can be mapped for execution */
-# endif /* >= 2.6.12 */
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
-    rc = bdi_init(&sf_g->bdi);
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
-    if (!rc)
-        rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%llu",
-                          (unsigned long long)u64CurrentSequence);
-#  endif /* >= 2.6.26 */
-# endif /* >= 2.6.24 */
-#endif /* >= 2.6.0 && <= 3.19.0 */
-    return rc;
+        /* Each new shared folder map gets a new uint64_t identifier,
+         * allocated in sequence.  We ASSUME the sequence will not wrap. */
+        static uint64_t s_u64Sequence = 0;
+        uint64_t u64CurrentSequence = ASMAtomicIncU64(&s_u64Sequence);
+
+        sf_g->bdi.ra_pages = 0; /* No readahead */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
+        sf_g->bdi.capabilities = BDI_CAP_MAP_DIRECT     /* MAP_SHARED */
+            | BDI_CAP_MAP_COPY  /* MAP_PRIVATE */
+            | BDI_CAP_READ_MAP  /* can be mapped for reading */
+            | BDI_CAP_WRITE_MAP /* can be mapped for writing */
+            | BDI_CAP_EXEC_MAP; /* can be mapped for execution */
+#endif                          /* >= 2.6.12 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
+        rc = bdi_init(&sf_g->bdi);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
+        if (!rc)
+                rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%llu",
+                                  (unsigned long long)u64CurrentSequence);
+#endif                          /* >= 2.6.26 */
+#endif                          /* >= 2.6.24 */
+#endif                          /* >= 2.6.0 && <= 3.19.0 */
+        return rc;
 }
 
@@ -898 +857 @@
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) && LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)
-    bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */
-#endif
-}
+        bdi_destroy(&sf_g->bdi);        /* includes bdi_unregister() */
+#endif
+}

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

@@ -26 +26 @@
 #define VBSF_MOUNT_SIGNATURE_BYTE_2 '\375'
 
-struct vbsf_mount_info_new
-{
-    /*
-     * The old version of the mount_info struct started with a
-     * char name[MAX_HOST_NAME] field, where name cannot be '\0'.
-     * So the new version of the mount_info struct starts with a
-     * nullchar field which is always 0 so that we can detect and
-     * reject the old structure being passed.
-     */
-    char nullchar;
-    char signature[3];          /* signature */
-    int  length;                /* length of the whole structure */
-    char name[MAX_HOST_NAME];   /* share name */
-    char nls_name[MAX_NLS_NAME];/* name of an I/O charset */
-    int  uid;                   /* user ID for all entries, default 0=root */
-    int  gid;                   /* group ID for all entries, default 0=root */
-    int  ttl;                   /* time to live */
-    int  dmode;                 /* mode for directories if != 0xffffffff */
-    int  fmode;                 /* mode for regular files if != 0xffffffff */
-    int  dmask;                 /* umask applied to directories */
-    int  fmask;                 /* umask applied to regular files */
+struct vbsf_mount_info_new {
+        /*
+         * The old version of the mount_info struct started with a
+         * char name[MAX_HOST_NAME] field, where name cannot be '\0'.
+         * So the new version of the mount_info struct starts with a
+         * nullchar field which is always 0 so that we can detect and
+         * reject the old structure being passed.
+         */
+        char nullchar;
+        char signature[3];      /* signature */
+        int length;             /* length of the whole structure */
+        char name[MAX_HOST_NAME];       /* share name */
+        char nls_name[MAX_NLS_NAME];    /* name of an I/O charset */
+        int uid;                /* user ID for all entries, default 0=root */
+        int gid;                /* group ID for all entries, default 0=root */
+        int ttl;                /* time to live */
+        int dmode;              /* mode for directories if != 0xffffffff */
+        int fmode;              /* mode for regular files if != 0xffffffff */
+        int dmask;              /* umask applied to directories */
+        int fmask;              /* umask applied to regular files */
 };
 
-struct vbsf_mount_opts
-{
-    int  uid;
-    int  gid;
-    int  ttl;
-    int  dmode;
-    int  fmode;
-    int  dmask;
-    int  fmask;
-    int  ronly;
-    int  sloppy;
-    int  noexec;
-    int  nodev;
-    int  nosuid;
-    int  remount;
-    char nls_name[MAX_NLS_NAME];
-    char *convertcp;
+struct vbsf_mount_opts {
+        int uid;
+        int gid;
+        int ttl;
+        int dmode;
+        int fmode;
+        int dmask;
+        int fmask;
+        int ronly;
+        int sloppy;
+        int noexec;
+        int nodev;
+        int nosuid;
+        int remount;
+        char nls_name[MAX_NLS_NAME];
+        char *convertcp;
 };
 
 /** Completes the mount operation by adding the new mount point to mtab if required. */
 int vbsfmount_complete(const char *host_name, const char *mount_point,
-                       unsigned long flags, struct vbsf_mount_opts *opts);
+                       unsigned long flags, struct vbsf_mount_opts *opts);
 
-#endif /* vbsfmount.h */
+#endif                          /* vbsfmount.h */

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

@@ -52 +52 @@
 
 /* allocate global info, try to map host share */
-static int sf_glob_alloc(struct vbsf_mount_info_new *info, struct sf_glob_info **sf_gp)
-{
-    int err, rc;
-    SHFLSTRING *str_name;
-    size_t name_len, str_len;
-    struct sf_glob_info *sf_g;
-
-    TRACE();
-    sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL);
-    if (!sf_g)
-    {
-        err = -ENOMEM;
-        LogRelFunc(("could not allocate memory for global info\n"));
-        goto fail0;
-    }
-
-    RT_ZERO(*sf_g);
-
-    if (   info->nullchar     != '\0'
-        || info->signature[0] != VBSF_MOUNT_SIGNATURE_BYTE_0
-        || info->signature[1] != VBSF_MOUNT_SIGNATURE_BYTE_1
-        || info->signature[2] != VBSF_MOUNT_SIGNATURE_BYTE_2)
-    {
-        err = -EINVAL;
-        goto fail1;
-    }
-
-    info->name[sizeof(info->name) - 1] = 0;
-    info->nls_name[sizeof(info->nls_name) - 1] = 0;
-
-    name_len = strlen(info->name);
-    str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
-    str_name = kmalloc(str_len, GFP_KERNEL);
-    if (!str_name)
-    {
-        err = -ENOMEM;
-        LogRelFunc(("could not allocate memory for host name\n"));
-        goto fail1;
-    }
-
-    str_name->u16Length = name_len;
-    str_name->u16Size = name_len + 1;
-    memcpy(str_name->String.utf8, info->name, name_len + 1);
+static int sf_glob_alloc(struct vbsf_mount_info_new *info,
+                         struct sf_glob_info **sf_gp)
+{
+        int err, rc;
+        SHFLSTRING *str_name;
+        size_t name_len, str_len;
+        struct sf_glob_info *sf_g;
+
+        TRACE();
+        sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL);
+        if (!sf_g) {
+                err = -ENOMEM;
+                LogRelFunc(("could not allocate memory for global info\n"));
+                goto fail0;
+        }
+
+        RT_ZERO(*sf_g);
+
+        if (info->nullchar != '\0'
+            || info->signature[0] != VBSF_MOUNT_SIGNATURE_BYTE_0
+            || info->signature[1] != VBSF_MOUNT_SIGNATURE_BYTE_1
+            || info->signature[2] != VBSF_MOUNT_SIGNATURE_BYTE_2) {
+                err = -EINVAL;
+                goto fail1;
+        }
+
+        info->name[sizeof(info->name) - 1] = 0;
+        info->nls_name[sizeof(info->nls_name) - 1] = 0;
+
+        name_len = strlen(info->name);
+        str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
+        str_name = kmalloc(str_len, GFP_KERNEL);
+        if (!str_name) {
+                err = -ENOMEM;
+                LogRelFunc(("could not allocate memory for host name\n"));
+                goto fail1;
+        }
+
+        str_name->u16Length = name_len;
+        str_name->u16Size = name_len + 1;
+        memcpy(str_name->String.utf8, info->name, name_len + 1);
 
 #define _IS_UTF8(_str) \
@@ -101 +99 @@
     (strcmp(_str, "") == 0)
 
-    /* Check if NLS charset is valid and not points to UTF8 table */
-    if (info->nls_name[0])
-    {
-        if (_IS_UTF8(info->nls_name))
-            sf_g->nls = NULL;
-        else
-        {
-            sf_g->nls = load_nls(info->nls_name);
-            if (!sf_g->nls)
-            {
-                err = -EINVAL;
-                LogFunc(("failed to load nls %s\n", info->nls_name));
-                kfree(str_name);
-                goto fail1;
-            }
-        }
-    }
-    else
-    {
+        /* Check if NLS charset is valid and not points to UTF8 table */
+        if (info->nls_name[0]) {
+                if (_IS_UTF8(info->nls_name))
+                        sf_g->nls = NULL;
+                else {
+                        sf_g->nls = load_nls(info->nls_name);
+                        if (!sf_g->nls) {
+                                err = -EINVAL;
+                                LogFunc(("failed to load nls %s\n",
+                                         info->nls_name));
+                                kfree(str_name);
+                                goto fail1;
+                        }
+                }
+        } else {
 #ifdef CONFIG_NLS_DEFAULT
-        /* If no NLS charset specified, try to load the default
-         * one if it's not points to UTF8. */
-        if (!_IS_UTF8(CONFIG_NLS_DEFAULT) && !_IS_EMPTY(CONFIG_NLS_DEFAULT))
-            sf_g->nls = load_nls_default();
-        else
-            sf_g->nls = NULL;
-#else
-        sf_g->nls = NULL;
+                /* If no NLS charset specified, try to load the default
+                 * one if it's not points to UTF8. */
+                if (!_IS_UTF8(CONFIG_NLS_DEFAULT)
+                    && !_IS_EMPTY(CONFIG_NLS_DEFAULT))
+                        sf_g->nls = load_nls_default();
+                else
+                        sf_g->nls = NULL;
+#else
+                sf_g->nls = NULL;
 #endif
 
 #undef _IS_UTF8
 #undef _IS_EMPTY
-    }
-
-    rc = VbglR0SfMapFolder(&client_handle, str_name, &sf_g->map);
-    kfree(str_name);
-
-    if (RT_FAILURE(rc))
-    {
-        err = -EPROTO;
-        LogFunc(("VbglR0SfMapFolder failed rc=%d\n", rc));
-        goto fail2;
-    }
-
-    sf_g->ttl = info->ttl;
-    sf_g->uid = info->uid;
-    sf_g->gid = info->gid;
-
-    if ((unsigned)info->length >= sizeof(struct vbsf_mount_info_new))
-    {
-        /* new fields */
-        sf_g->dmode = info->dmode;
-        sf_g->fmode = info->fmode;
-        sf_g->dmask = info->dmask;
-        sf_g->fmask = info->fmask;
-    }
-    else
-    {
-        sf_g->dmode = ~0;
-        sf_g->fmode = ~0;
-    }
-
-    *sf_gp = sf_g;
-    return 0;
-
-fail2:
-    if (sf_g->nls)
-        unload_nls(sf_g->nls);
-
-fail1:
-    kfree(sf_g);
-
-fail0:
-    return err;
+        }
+
+        rc = VbglR0SfMapFolder(&client_handle, str_name, &sf_g->map);
+        kfree(str_name);
+
+        if (RT_FAILURE(rc)) {
+                err = -EPROTO;
+                LogFunc(("VbglR0SfMapFolder failed rc=%d\n", rc));
+                goto fail2;
+        }
+
+        sf_g->ttl = info->ttl;
+        sf_g->uid = info->uid;
+        sf_g->gid = info->gid;
+
+        if ((unsigned)info->length >= sizeof(struct vbsf_mount_info_new)) {
+                /* new fields */
+                sf_g->dmode = info->dmode;
+                sf_g->fmode = info->fmode;
+                sf_g->dmask = info->dmask;
+                sf_g->fmask = info->fmask;
+        } else {
+                sf_g->dmode = ~0;
+                sf_g->fmode = ~0;
+        }
+
+        *sf_gp = sf_g;
+        return 0;
+
+ fail2:
+        if (sf_g->nls)
+                unload_nls(sf_g->nls);
+
+ fail1:
+        kfree(sf_g);
+
+ fail0:
+        return err;
 }
 
 /* unmap the share and free global info [sf_g] */
-static void
-sf_glob_free(struct sf_glob_info *sf_g)
-{
-    int rc;
-
-    TRACE();
-    rc = VbglR0SfUnmapFolder(&client_handle, &sf_g->map);
-    if (RT_FAILURE(rc))
-        LogFunc(("VbglR0SfUnmapFolder failed rc=%d\n", rc));
-
-    if (sf_g->nls)
-        unload_nls(sf_g->nls);
-
-    kfree(sf_g);
+static void sf_glob_free(struct sf_glob_info *sf_g)
+{
+        int rc;
+
+        TRACE();
+        rc = VbglR0SfUnmapFolder(&client_handle, &sf_g->map);
+        if (RT_FAILURE(rc))
+                LogFunc(("VbglR0SfUnmapFolder failed rc=%d\n", rc));
+
+        if (sf_g->nls)
+                unload_nls(sf_g->nls);
+
+        kfree(sf_g);
 }
 
@@ -207 +197 @@
 static int sf_read_super_aux(struct super_block *sb, void *data, int flags)
 {
-    int err;
-    struct dentry *droot;
-    struct inode *iroot;
-    struct sf_inode_info *sf_i;
-    struct sf_glob_info *sf_g;
-    SHFLFSOBJINFO fsinfo;
-    struct vbsf_mount_info_new *info;
-    bool fInodePut = true;
-
-    TRACE();
-    if (!data)
-    {
-        LogFunc(("no mount info specified\n"));
-        return -EINVAL;
-    }
-
-    info = data;
-
-    if (flags & MS_REMOUNT)
-    {
-        LogFunc(("remounting is not supported\n"));
-        return -ENOSYS;
-    }
-
-    err = sf_glob_alloc(info, &sf_g);
-    if (err)
-        goto fail0;
-
-    sf_i = kmalloc(sizeof (*sf_i), GFP_KERNEL);
-    if (!sf_i)
-    {
-        err = -ENOMEM;
-        LogRelFunc(("could not allocate memory for root inode info\n"));
-        goto fail1;
-    }
-
-    sf_i->handle = SHFL_HANDLE_NIL;
-    sf_i->path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL);
-    if (!sf_i->path)
-    {
-        err = -ENOMEM;
-        LogRelFunc(("could not allocate memory for root inode path\n"));
-        goto fail2;
-    }
-
-    sf_i->path->u16Length = 1;
-    sf_i->path->u16Size = 2;
-    sf_i->path->String.utf8[0] = '/';
-    sf_i->path->String.utf8[1] = 0;
-    sf_i->force_reread = 0;
-
-    err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
-    if (err)
-    {
-        LogFunc(("could not stat root of share\n"));
-        goto fail3;
-    }
-
-    sb->s_magic = 0xface;
-    sb->s_blocksize = 1024;
+        int err;
+        struct dentry *droot;
+        struct inode *iroot;
+        struct sf_inode_info *sf_i;
+        struct sf_glob_info *sf_g;
+        SHFLFSOBJINFO fsinfo;
+        struct vbsf_mount_info_new *info;
+        bool fInodePut = true;
+
+        TRACE();
+        if (!data) {
+                LogFunc(("no mount info specified\n"));
+                return -EINVAL;
+        }
+
+        info = data;
+
+        if (flags & MS_REMOUNT) {
+                LogFunc(("remounting is not supported\n"));
+                return -ENOSYS;
+        }
+
+        err = sf_glob_alloc(info, &sf_g);
+        if (err)
+                goto fail0;
+
+        sf_i = kmalloc(sizeof(*sf_i), GFP_KERNEL);
+        if (!sf_i) {
+                err = -ENOMEM;
+                LogRelFunc(("could not allocate memory for root inode info\n"));
+                goto fail1;
+        }
+
+        sf_i->handle = SHFL_HANDLE_NIL;
+        sf_i->path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL);
+        if (!sf_i->path) {
+                err = -ENOMEM;
+                LogRelFunc(("could not allocate memory for root inode path\n"));
+                goto fail2;
+        }
+
+        sf_i->path->u16Length = 1;
+        sf_i->path->u16Size = 2;
+        sf_i->path->String.utf8[0] = '/';
+        sf_i->path->String.utf8[1] = 0;
+        sf_i->force_reread = 0;
+
+        err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+        if (err) {
+                LogFunc(("could not stat root of share\n"));
+                goto fail3;
+        }
+
+        sb->s_magic = 0xface;
+        sb->s_blocksize = 1024;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 3)
-    /* Required for seek/sendfile.
-     *
-     * Must by less than or equal to INT64_MAX despite the fact that the
-     * declaration of this variable is unsigned long long. See determination
-     * of 'loff_t max' in fs/read_write.c / do_sendfile(). I don't know the
-     * correct limit but MAX_LFS_FILESIZE (8TB-1 on 32-bit boxes) takes the
-     * page cache into account and is the suggested limit. */
-# if defined MAX_LFS_FILESIZE
-    sb->s_maxbytes = MAX_LFS_FILESIZE;
-# else
-    sb->s_maxbytes = 0x7fffffffffffffffULL;
-# endif
-#endif
-    sb->s_op = &sf_super_ops;
+        /* Required for seek/sendfile.
+         *
+         * Must by less than or equal to INT64_MAX despite the fact that the
+         * declaration of this variable is unsigned long long. See determination
+         * of 'loff_t max' in fs/read_write.c / do_sendfile(). I don't know the
+         * correct limit but MAX_LFS_FILESIZE (8TB-1 on 32-bit boxes) takes the
+         * page cache into account and is the suggested limit. */
+#if defined MAX_LFS_FILESIZE
+        sb->s_maxbytes = MAX_LFS_FILESIZE;
+#else
+        sb->s_maxbytes = 0x7fffffffffffffffULL;
+#endif
+#endif
+        sb->s_op = &sf_super_ops;
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-    iroot = iget_locked(sb, 0);
-#else
-    iroot = iget(sb, 0);
-#endif
-    if (!iroot)
-    {
-        err = -ENOMEM;  /* XXX */
-        LogFunc(("could not get root inode\n"));
-        goto fail3;
-    }
-
-    if (sf_init_backing_dev(sf_g))
-    {
-        err = -EINVAL;
-        LogFunc(("could not init bdi\n"));
+        iroot = iget_locked(sb, 0);
+#else
+        iroot = iget(sb, 0);
+#endif
+        if (!iroot) {
+                err = -ENOMEM;  /* XXX */
+                LogFunc(("could not get root inode\n"));
+                goto fail3;
+        }
+
+        if (sf_init_backing_dev(sf_g)) {
+                err = -EINVAL;
+                LogFunc(("could not init bdi\n"));
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-        unlock_new_inode(iroot);
-#endif
-        goto fail4;
-    }
-
-    sf_init_inode(sf_g, iroot, &fsinfo);
-    SET_INODE_INFO(iroot, sf_i);
+                unlock_new_inode(iroot);
+#endif
+                goto fail4;
+        }
+
+        sf_init_inode(sf_g, iroot, &fsinfo);
+        SET_INODE_INFO(iroot, sf_i);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
-    unlock_new_inode(iroot);
+        unlock_new_inode(iroot);
 #endif
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
-    droot = d_make_root(iroot);
-#else
-    droot = d_alloc_root(iroot);
-#endif
-    if (!droot)
-    {
-        err = -ENOMEM;  /* XXX */
-        LogFunc(("d_alloc_root failed\n"));
+        droot = d_make_root(iroot);
+#else
+        droot = d_alloc_root(iroot);
+#endif
+        if (!droot) {
+                err = -ENOMEM;  /* XXX */
+                LogFunc(("d_alloc_root failed\n"));
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
-        fInodePut = false;
-#endif
-        goto fail5;
-    }
-
-    sb->s_root = droot;
-    SET_GLOB_INFO(sb, sf_g);
-    return 0;
-
-fail5:
-    sf_done_backing_dev(sf_g);
-
-fail4:
-    if (fInodePut)
-        iput(iroot);
-
-fail3:
-    kfree(sf_i->path);
-
-fail2:
-    kfree(sf_i);
-
-fail1:
-    sf_glob_free(sf_g);
-
-fail0:
-    return err;
+                fInodePut = false;
+#endif
+                goto fail5;
+        }
+
+        sb->s_root = droot;
+        SET_GLOB_INFO(sb, sf_g);
+        return 0;
+
+ fail5:
+        sf_done_backing_dev(sf_g);
+
+ fail4:
+        if (fInodePut)
+                iput(iroot);
+
+ fail3:
+        kfree(sf_i->path);
+
+ fail2:
+        kfree(sf_i);
+
+ fail1:
+        sf_glob_free(sf_g);
+
+ fail0:
+        return err;
 }
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-static struct super_block *
-sf_read_super_24(struct super_block *sb, void *data, int flags)
-{
-    int err;
-
-    TRACE();
-    err = sf_read_super_aux(sb, data, flags);
-    if (err)
-        return NULL;
-
-    return sb;
+static struct super_block *sf_read_super_24(struct super_block *sb, void *data,
+                                            int flags)
+{
+        int err;
+
+        TRACE();
+        err = sf_read_super_aux(sb, data, flags);
+        if (err)
+                return NULL;
+
+        return sb;
 }
 #endif
@@ -371 +353 @@
 static void sf_clear_inode(struct inode *inode)
 {
-    struct sf_inode_info *sf_i;
-
-    TRACE();
-    sf_i = GET_INODE_INFO(inode);
-    if (!sf_i)
-        return;
-
-    BUG_ON(!sf_i->path);
-    kfree(sf_i->path);
-    kfree(sf_i);
-    SET_INODE_INFO(inode, NULL);
+        struct sf_inode_info *sf_i;
+
+        TRACE();
+        sf_i = GET_INODE_INFO(inode);
+        if (!sf_i)
+                return;
+
+        BUG_ON(!sf_i->path);
+        kfree(sf_i->path);
+        kfree(sf_i);
+        SET_INODE_INFO(inode, NULL);
 }
 #else
 static void sf_evict_inode(struct inode *inode)
 {
-    struct sf_inode_info *sf_i;
-
-    TRACE();
-    truncate_inode_pages(&inode->i_data, 0);
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
-    clear_inode(inode);
-# else
-    end_writeback(inode);
-# endif
-
-    sf_i = GET_INODE_INFO(inode);
-    if (!sf_i)
-        return;
-
-    BUG_ON(!sf_i->path);
-    kfree(sf_i->path);
-    kfree(sf_i);
-    SET_INODE_INFO(inode, NULL);
+        struct sf_inode_info *sf_i;
+
+        TRACE();
+        truncate_inode_pages(&inode->i_data, 0);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
+        clear_inode(inode);
+#else
+        end_writeback(inode);
+#endif
+
+        sf_i = GET_INODE_INFO(inode);
+        if (!sf_i)
+                return;
+
+        BUG_ON(!sf_i->path);
+        kfree(sf_i->path);
+        kfree(sf_i);
+        SET_INODE_INFO(inode, NULL);
 }
 #endif
@@ -421 +403 @@
 static void sf_put_super(struct super_block *sb)
 {
-    struct sf_glob_info *sf_g;
-
-    sf_g = GET_GLOB_INFO(sb);
-    BUG_ON(!sf_g);
-    sf_done_backing_dev(sf_g);
-    sf_glob_free(sf_g);
+        struct sf_glob_info *sf_g;
+
+        sf_g = GET_GLOB_INFO(sb);
+        BUG_ON(!sf_g);
+        sf_done_backing_dev(sf_g);
+        sf_glob_free(sf_g);
 }
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-static int sf_statfs(struct super_block *sb, STRUCT_STATFS *stat)
-{
-    return sf_get_volume_info(sb, stat);
-}
-#else
-static int sf_statfs(struct dentry *dentry, STRUCT_STATFS *stat)
-{
-    struct super_block *sb = dentry->d_inode->i_sb;
-    return sf_get_volume_info(sb, stat);
+static int sf_statfs(struct super_block *sb, STRUCT_STATFS * stat)
+{
+        return sf_get_volume_info(sb, stat);
+}
+#else
+static int sf_statfs(struct dentry *dentry, STRUCT_STATFS * stat)
+{
+        struct super_block *sb = dentry->d_inode->i_sb;
+        return sf_get_volume_info(sb, stat);
 }
 #endif
@@ -445 +427 @@
 {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 23)
-    struct sf_glob_info *sf_g;
-    struct sf_inode_info *sf_i;
-    struct inode *iroot;
-    SHFLFSOBJINFO fsinfo;
-    int err;
-
-    sf_g = GET_GLOB_INFO(sb);
-    BUG_ON(!sf_g);
-    if (data && data[0] != 0)
-    {
-        struct vbsf_mount_info_new *info =
-            (struct vbsf_mount_info_new *)data;
-        if (   info->signature[0] == VBSF_MOUNT_SIGNATURE_BYTE_0
-            && info->signature[1] == VBSF_MOUNT_SIGNATURE_BYTE_1
-            && info->signature[2] == VBSF_MOUNT_SIGNATURE_BYTE_2)
-        {
-            sf_g->uid = info->uid;
-            sf_g->gid = info->gid;
-            sf_g->ttl = info->ttl;
-            sf_g->dmode = info->dmode;
-            sf_g->fmode = info->fmode;
-            sf_g->dmask = info->dmask;
-            sf_g->fmask = info->fmask;
-        }
-    }
-
-    iroot = ilookup(sb, 0);
-    if (!iroot)
-        return -ENOSYS;
-
-    sf_i = GET_INODE_INFO(iroot);
-    err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
-    BUG_ON(err != 0);
-    sf_init_inode(sf_g, iroot, &fsinfo);
-    /*unlock_new_inode(iroot);*/
-    return 0;
-#else
-    return -ENOSYS;
-#endif
-}
-
-static struct super_operations sf_super_ops =
-{
+        struct sf_glob_info *sf_g;
+        struct sf_inode_info *sf_i;
+        struct inode *iroot;
+        SHFLFSOBJINFO fsinfo;
+        int err;
+
+        sf_g = GET_GLOB_INFO(sb);
+        BUG_ON(!sf_g);
+        if (data && data[0] != 0) {
+                struct vbsf_mount_info_new *info =
+                    (struct vbsf_mount_info_new *)data;
+                if (info->signature[0] == VBSF_MOUNT_SIGNATURE_BYTE_0
+                    && info->signature[1] == VBSF_MOUNT_SIGNATURE_BYTE_1
+                    && info->signature[2] == VBSF_MOUNT_SIGNATURE_BYTE_2) {
+                        sf_g->uid = info->uid;
+                        sf_g->gid = info->gid;
+                        sf_g->ttl = info->ttl;
+                        sf_g->dmode = info->dmode;
+                        sf_g->fmode = info->fmode;
+                        sf_g->dmask = info->dmask;
+                        sf_g->fmask = info->fmask;
+                }
+        }
+
+        iroot = ilookup(sb, 0);
+        if (!iroot)
+                return -ENOSYS;
+
+        sf_i = GET_INODE_INFO(iroot);
+        err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
+        BUG_ON(err != 0);
+        sf_init_inode(sf_g, iroot, &fsinfo);
+        /*unlock_new_inode(iroot); */
+        return 0;
+#else
+        return -ENOSYS;
+#endif
+}
+
+static struct super_operations sf_super_ops = {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
-    .clear_inode = sf_clear_inode,
-#else
-    .evict_inode = sf_evict_inode,
+        .clear_inode = sf_clear_inode,
+#else
+        .evict_inode = sf_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
+        .read_inode = sf_read_inode,
+#endif
+        .put_super = sf_put_super,
+        .statfs = sf_statfs,
+        .remount_fs = sf_remount_fs
 };
 
@@ -504 +483 @@
 static DECLARE_FSTYPE(vboxsf_fs_type, "vboxsf", sf_read_super_24, 0);
 #else
-static int
-sf_read_super_26(struct super_block *sb, void *data, int flags)
-{
-    int err;
-
-    TRACE();
-    err = sf_read_super_aux(sb, data, flags);
-    if (err)
-        printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
-
-    return err;
-}
-
-# 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);
-}
-# elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
+static int sf_read_super_26(struct super_block *sb, void *data, int flags)
+{
+        int err;
+
+        TRACE();
+        err = sf_read_super_aux(sb, data, flags);
+        if (err)
+                printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
+
+        return err;
+}
+
+#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);
+}
+#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);
-}
-# else
+                     const char *dev_name, void *data, struct vfsmount *mnt)
+{
+        TRACE();
+        return get_sb_nodev(fs_type, flags, data, sf_read_super_26, mnt);
+}
+#else
 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);
-}
-# endif
-
-static struct file_system_type vboxsf_fs_type =
-{
-    .owner   = THIS_MODULE,
-    .name    = "vboxsf",
-# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
-    .get_sb  = sf_get_sb,
-# else
-    .mount   = sf_mount,
-# endif
-    .kill_sb = kill_anon_super
+                               const char *dev_name, void *data)
+{
+        TRACE();
+        return mount_nodev(fs_type, flags, data, sf_read_super_26);
+}
+#endif
+
+static struct file_system_type vboxsf_fs_type = {
+        .owner = THIS_MODULE,
+        .name = "vboxsf",
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
+        .get_sb = sf_get_sb,
+#else
+        .mount = sf_mount,
+#endif
+        .kill_sb = kill_anon_super
 };
 #endif
@@ -556 +534 @@
 static int follow_symlinks = 0;
 module_param(follow_symlinks, int, 0);
-MODULE_PARM_DESC(follow_symlinks, "Let host resolve symlinks rather than showing them");
+MODULE_PARM_DESC(follow_symlinks,
+                 "Let host resolve symlinks rather than showing them");
 #endif
 
@@ -562 +541 @@
 static int __init init(void)
 {
-    int rcVBox;
-    int rcRet = 0;
-    int err;
-
-    TRACE();
-
-    if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE)
-    {
-        printk(KERN_ERR
-                "Mount information structure is too large %lu\n"
-                "Must be less than or equal to %lu\n",
-                (unsigned long)sizeof (struct vbsf_mount_info_new),
-                (unsigned long)PAGE_SIZE);
-        return -EINVAL;
-    }
-
-    err = register_filesystem(&vboxsf_fs_type);
-    if (err)
-    {
-        LogFunc(("register_filesystem err=%d\n", err));
-        return err;
-    }
-
-    rcVBox = VbglR0HGCMInit();
-    if (RT_FAILURE(rcVBox))
-    {
-        LogRelFunc(("VbglR0HGCMInit failed, rc=%d\n", rcVBox));
-        rcRet = -EPROTO;
-        goto fail0;
-    }
-
-    rcVBox = VbglR0SfConnect(&client_handle);
-    if (RT_FAILURE(rcVBox))
-    {
-        LogRelFunc(("VbglR0SfConnect failed, rc=%d\n", rcVBox));
-        rcRet = -EPROTO;
-        goto fail1;
-    }
-
-    rcVBox = VbglR0SfSetUtf8(&client_handle);
-    if (RT_FAILURE(rcVBox))
-    {
-        LogRelFunc(("VbglR0SfSetUtf8 failed, rc=%d\n", rcVBox));
-        rcRet = -EPROTO;
-        goto fail2;
-    }
-
+        int rcVBox;
+        int rcRet = 0;
+        int err;
+
+        TRACE();
+
+        if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE) {
+                printk(KERN_ERR
+                       "Mount information structure is too large %lu\n"
+                       "Must be less than or equal to %lu\n",
+                       (unsigned long)sizeof(struct vbsf_mount_info_new),
+                       (unsigned long)PAGE_SIZE);
+                return -EINVAL;
+        }
+
+        err = register_filesystem(&vboxsf_fs_type);
+        if (err) {
+                LogFunc(("register_filesystem err=%d\n", err));
+                return err;
+        }
+
+        rcVBox = VbglR0HGCMInit();
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("VbglR0HGCMInit failed, rc=%d\n", rcVBox));
+                rcRet = -EPROTO;
+                goto fail0;
+        }
+
+        rcVBox = VbglR0SfConnect(&client_handle);
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("VbglR0SfConnect failed, rc=%d\n", rcVBox));
+                rcRet = -EPROTO;
+                goto fail1;
+        }
+
+        rcVBox = VbglR0SfSetUtf8(&client_handle);
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("VbglR0SfSetUtf8 failed, rc=%d\n", rcVBox));
+                rcRet = -EPROTO;
+                goto fail2;
+        }
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    if (!follow_symlinks)
-    {
-        rcVBox = VbglR0SfSetSymlinks(&client_handle);
-        if (RT_FAILURE(rcVBox))
-        {
-            printk(KERN_WARNING
-                     "vboxsf: Host unable to show symlinks, rc=%d\n",
-                     rcVBox);
-        }
-    }
-#endif
-
-    printk(KERN_DEBUG
-            "vboxsf: Successfully loaded version " VBOX_VERSION_STRING
-            " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
-
-    return 0;
-
-fail2:
-    VbglR0SfDisconnect(&client_handle);
-
-fail1:
-    VbglR0HGCMTerminate();
-
-fail0:
-    unregister_filesystem(&vboxsf_fs_type);
-    return rcRet;
+        if (!follow_symlinks) {
+                rcVBox = VbglR0SfSetSymlinks(&client_handle);
+                if (RT_FAILURE(rcVBox)) {
+                        printk(KERN_WARNING
+                               "vboxsf: Host unable to show symlinks, rc=%d\n",
+                               rcVBox);
+                }
+        }
+#endif
+
+        printk(KERN_DEBUG
+               "vboxsf: Successfully loaded version " VBOX_VERSION_STRING
+               " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
+
+        return 0;
+
+ fail2:
+        VbglR0SfDisconnect(&client_handle);
+
+ fail1:
+        VbglR0HGCMTerminate();
+
+ fail0:
+        unregister_filesystem(&vboxsf_fs_type);
+        return rcRet;
 }
 
 static void __exit fini(void)
 {
-    TRACE();
-
-    VbglR0SfDisconnect(&client_handle);
-    VbglR0HGCMTerminate();
-    unregister_filesystem(&vboxsf_fs_type);
+        TRACE();
+
+        VbglR0SfDisconnect(&client_handle);
+        VbglR0HGCMTerminate();
+        unregister_filesystem(&vboxsf_fs_type);
 }
 

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

@@ -23 +23 @@
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-# include <linux/backing-dev.h>
+#include <linux/backing-dev.h>
 #endif
 
@@ -32 +32 @@
 
 /* per-shared folder information */
-struct sf_glob_info
-{
-    VBGLSFMAP map;
-    struct nls_table *nls;
-    int ttl;
-    int uid;
-    int gid;
-    int dmode;
-    int fmode;
-    int dmask;
-    int fmask;
+struct sf_glob_info {
+        VBGLSFMAP map;
+        struct nls_table *nls;
+        int ttl;
+        int uid;
+        int gid;
+        int dmode;
+        int fmode;
+        int dmask;
+        int fmask;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
-    struct backing_dev_info bdi;
+        struct backing_dev_info bdi;
 #endif
 };
 
 /* per-inode information */
-struct sf_inode_info
-{
-    /* which file */
-    SHFLSTRING *path;
-    /* some information was changed, update data on next revalidate */
-    int force_restat;
-    /* directory content changed, update the whole directory on next sf_getdent */
-    int force_reread;
-    /* file structure, only valid between open() and release() */
-    struct file *file;
-    /* handle valid if a file was created with sf_create_aux until it will
-     * be opened with sf_reg_open() */
-    SHFLHANDLE handle;
+struct sf_inode_info {
+        /* which file */
+        SHFLSTRING *path;
+        /* some information was changed, update data on next revalidate */
+        int force_restat;
+        /* directory content changed, update the whole directory on next sf_getdent */
+        int force_reread;
+        /* file structure, only valid between open() and release() */
+        struct file *file;
+        /* handle valid if a file was created with sf_create_aux until it will
+         * be opened with sf_reg_open() */
+        SHFLHANDLE handle;
 };
 
-struct sf_dir_info
-{
-    struct list_head info_list;
+struct sf_dir_info {
+        struct list_head info_list;
 };
 
-struct sf_dir_buf
-{
-    size_t cEntries;
-    size_t cbFree;
-    size_t cbUsed;
-    void   *buf;
-    struct list_head head;
+struct sf_dir_buf {
+        size_t cEntries;
+        size_t cbFree;
+        size_t cbUsed;
+        void *buf;
+        struct list_head head;
 };
 
-struct sf_reg_info
-{
-    SHFLHANDLE handle;
+struct sf_reg_info {
+        SHFLHANDLE handle;
 };
 
@@ -87 +82 @@
 
 /* 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 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_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
-                          PSHFLFSOBJINFO info);
-extern int  sf_stat(const char *caller, struct sf_glob_info *sf_g,
-                    SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail);
-extern int  sf_inode_revalidate(struct dentry *dentry);
+                          PSHFLFSOBJINFO info);
+extern int sf_stat(const char *caller, struct sf_glob_info *sf_g,
+                   SHFLSTRING * path, PSHFLFSOBJINFO result, int ok_to_fail);
+extern int sf_inode_revalidate(struct dentry *dentry);
 #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);
-# else
-extern int  sf_getattr(struct vfsmount *mnt, struct dentry *dentry,
-                       struct kstat *kstat);
+#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);
+#else
+extern int sf_getattr(struct vfsmount *mnt, struct dentry *dentry,
+                      struct kstat *kstat);
 #endif
-extern int  sf_setattr(struct dentry *dentry, struct iattr *iattr);
+extern int sf_setattr(struct dentry *dentry, struct iattr *iattr);
 #endif
-extern int  sf_path_from_dentry(const char *caller, struct sf_glob_info *sf_g,
-                                struct sf_inode_info *sf_i, struct dentry *dentry,
-                                SHFLSTRING **result);
-extern int  sf_nlscpy(struct sf_glob_info *sf_g,
-                      char *name, size_t name_bound_len,
-                      const unsigned char *utf8_name, size_t utf8_len);
+extern int sf_path_from_dentry(const char *caller, struct sf_glob_info *sf_g,
+                               struct sf_inode_info *sf_i,
+                               struct dentry *dentry, SHFLSTRING ** result);
+extern int sf_nlscpy(struct sf_glob_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 sf_glob_info *sf_g, struct sf_inode_info *sf_i,
-                            struct sf_dir_info *sf_d, SHFLHANDLE handle);
-extern int  sf_init_backing_dev(struct sf_glob_info *sf_g);
+extern int sf_dir_read_all(struct sf_glob_info *sf_g,
+                           struct sf_inode_info *sf_i, struct sf_dir_info *sf_d,
+                           SHFLHANDLE handle);
+extern int sf_init_backing_dev(struct sf_glob_info *sf_g);
 extern void sf_done_backing_dev(struct sf_glob_info *sf_g);
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-# define STRUCT_STATFS  struct statfs
+#define STRUCT_STATFS  struct statfs
 #else
-# define STRUCT_STATFS  struct kstatfs
+#define STRUCT_STATFS  struct kstatfs
 #endif
-int sf_get_volume_info(struct super_block *sb,STRUCT_STATFS *stat);
+int sf_get_volume_info(struct super_block *sb, STRUCT_STATFS * stat);
 
 #ifdef __cplusplus
-# define CMC_API __attribute__ ((cdecl, regparm (0)))
+#define CMC_API __attribute__ ((cdecl, regparm (0)))
 #else
-# define CMC_API __attribute__ ((regparm (0)))
+#define CMC_API __attribute__ ((regparm (0)))
 #endif
 
@@ -142 +138 @@
    pointers of arbitrary type */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-# define GET_GLOB_INFO(sb)       ((struct sf_glob_info *) (sb)->u.generic_sbp)
-# define SET_GLOB_INFO(sb, sf_g) (sb)->u.generic_sbp = sf_g
+#define GET_GLOB_INFO(sb)       ((struct sf_glob_info *) (sb)->u.generic_sbp)
+#define SET_GLOB_INFO(sb, sf_g) (sb)->u.generic_sbp = sf_g
 #else
-# define GET_GLOB_INFO(sb)       ((struct sf_glob_info *) (sb)->s_fs_info)
-# define SET_GLOB_INFO(sb, sf_g) (sb)->s_fs_info = sf_g
+#define GET_GLOB_INFO(sb)       ((struct sf_glob_info *) (sb)->s_fs_info)
+#define SET_GLOB_INFO(sb, sf_g) (sb)->s_fs_info = sf_g
 #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
+#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
+#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)
+#define GET_F_DENTRY(f)        (f->f_path.dentry)
 #else
-# define GET_F_DENTRY(f)        (f->f_dentry)
+#define GET_F_DENTRY(f)        (f->f_dentry)
 #endif
 
 #endif
-