Index: /trunk/src/VBox/Additions/linux/sharedfolders/dirops.c
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/dirops.c	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/dirops.c	(revision 30153)
@@ -20,16 +20,16 @@
 
 static int
-sf_dir_open (struct inode *inode, struct file *file)
+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_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);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
         SHFLCREATEPARMS params;
 
-        TRACE ();
-        BUG_ON (!sf_g);
-        BUG_ON (!sf_i);
+        TRACE();
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_i);
 
         if (file->private_data) {
@@ -41,5 +41,5 @@
         RT_ZERO(params);
 
-        sf_d = sf_dir_info_alloc ();
+        sf_d = sf_dir_info_alloc();
 
         if (!sf_d) {
@@ -58,9 +58,9 @@
         LogFunc(("sf_dir_open: calling vboxCallCreate, folder %s, flags %#x\n",
                  sf_i->path->String.utf8, params.CreateFlags));
-        rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n",
                          sf_i->path->String.utf8, rc));
-                sf_dir_info_free (sf_d);
+                sf_dir_info_free(sf_d);
                 return -EPERM;
         }
@@ -68,22 +68,22 @@
         if (params.Result != SHFL_FILE_EXISTS) {
                 LogFunc(("directory %s does not exist\n", sf_i->path->String.utf8));
-                sf_dir_info_free (sf_d);
+                sf_dir_info_free(sf_d);
                 return -ENOENT;
         }
 
-        err = sf_dir_read_all (sf_g, sf_i, sf_d, params.Handle);
+        err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
         if (err) {
-                rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-                if (RT_FAILURE (rc)) {
+                rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc)) {
                         LogFunc(("vboxCallClose(%s) after err=%d failed rc=%Rrc\n",
                                  sf_i->path->String.utf8, err, rc));
                 }
-                sf_dir_info_free (sf_d);
+                sf_dir_info_free(sf_d);
                 return err;
         }
 
 
-        rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
                           sf_i->path->String.utf8, rc));
@@ -98,13 +98,13 @@
    directory and deallocate our own internal buffers */
 static int
-sf_dir_release (struct inode *inode, struct file *file)
-{
-        struct sf_inode_info *sf_i = GET_INODE_INFO (inode);
-
-        TRACE ();
-        BUG_ON (!sf_i);
+sf_dir_release(struct inode *inode, struct file *file)
+{
+        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
+
+        TRACE();
+        BUG_ON(!sf_i);
 
         if (file->private_data) {
-                sf_dir_info_free (file->private_data);
+                sf_dir_info_free(file->private_data);
         }
         return 0;
@@ -117,5 +117,5 @@
    -errno  some form of error*/
 static int
-sf_getdent (struct file *dir, char d_name[NAME_MAX])
+sf_getdent(struct file *dir, char d_name[NAME_MAX])
 {
         loff_t cur;
@@ -126,16 +126,16 @@
         struct list_head *pos, *list;
 
-        TRACE ();
-
-        sf_g = GET_GLOB_INFO (dir->f_dentry->d_inode->i_sb);
+        TRACE();
+
+        sf_g = GET_GLOB_INFO(dir->f_dentry->d_inode->i_sb);
         sf_d = dir->private_data;
 
-        BUG_ON (!sf_g);
-        BUG_ON (!sf_d);
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_d);
 
         inode = dir->f_dentry->d_inode;
         sf_i = GET_INODE_INFO(inode);
 
-        BUG_ON (!sf_i);
+        BUG_ON(!sf_i);
 
         if (sf_i->force_reread)
@@ -156,6 +156,6 @@
                 LogFunc(("sf_getdent: calling vboxCallCreate, folder %s, flags %#x\n",
                             sf_i->path->String.utf8, params.CreateFlags));
-                rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
-                if (RT_FAILURE (rc)) {
+                rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+                if (RT_FAILURE(rc)) {
                     LogRel(("open failed %d\n", rc));
                     LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n",
@@ -167,12 +167,12 @@
                     LogRel(("not exist %x\n", params.Result));
                     LogFunc(("directory %s does not exist\n", sf_i->path->String.utf8));
-                    sf_dir_info_free (sf_d);
+                    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 = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-                if (RT_FAILURE (rc)) {
+                sf_dir_info_empty(sf_d);
+                err = sf_dir_read_all(sf_g, sf_i, sf_d, params.Handle);
+                rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc)) {
                     LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
                              sf_i->path->String.utf8, rc));
@@ -185,5 +185,5 @@
         cur = 0;
         list = &sf_d->info_list;
-        list_for_each (pos, list) {
+        list_for_each(pos, list) {
                 struct sf_dir_buf *b;
                 SHFLDIRINFO *info;
@@ -192,5 +192,5 @@
                 char *name_ptr;
 
-                b = list_entry (pos, struct sf_dir_buf, head);
+                b = list_entry(pos, struct sf_dir_buf, head);
                 if (dir->f_pos >= cur + b->nb_entries) {
                         cur += b->nb_entries;
@@ -201,5 +201,5 @@
                         size_t size;
 
-                        size = offsetof (SHFLDIRINFO, name.String) + info->name.u16Size;
+                        size = offsetof(SHFLDIRINFO, name.String) + info->name.u16Size;
                         info = (SHFLDIRINFO *) ((uintptr_t) info + size);
                 }
@@ -208,5 +208,5 @@
                 name_len = info->name.u16Length;
 
-                return sf_nlscpy (sf_g, d_name, NAME_MAX, name_ptr, name_len);
+                return sf_nlscpy(sf_g, d_name, NAME_MAX, name_ptr, name_len);
         }
         return 1;
@@ -237,5 +237,5 @@
 sf_dir_read (struct file *dir, void *opaque, filldir_t filldir)
 {
-        TRACE ();
+        TRACE();
         for (;;) {
                 int err;
@@ -244,5 +244,5 @@
                 char d_name[NAME_MAX];
 
-                err = sf_getdent (dir, d_name);
+                err = sf_getdent(dir, d_name);
                 switch (err) {
                         case 1:
@@ -269,5 +269,5 @@
                 }
 
-                err = filldir (opaque, d_name, strlen (d_name),
+                err = filldir(opaque, d_name, strlen(d_name),
                                dir->f_pos, fake_ino, DT_UNKNOWN);
                 if (err) {
@@ -281,5 +281,5 @@
         }
 
-        BUG ();
+        BUG();
 }
 
@@ -302,6 +302,6 @@
    returned in case of succes and "negative" pointer on error */
 static struct dentry *
-sf_lookup (struct inode *parent, struct dentry *dentry
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+sf_lookup(struct inode *parent, struct dentry *dentry
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
            , struct nameidata *nd
 #endif
@@ -316,17 +316,17 @@
         RTFSOBJINFO 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);
+        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);
+        err = sf_stat(__func__, sf_g, path, &fsinfo, 1);
         if (err) {
                 if (err == -ENOENT) {
@@ -338,5 +338,5 @@
         }
         else {
-                sf_new_i = kmalloc (sizeof (*sf_new_i), GFP_KERNEL);
+                sf_new_i = kmalloc(sizeof(*sf_new_i), GFP_KERNEL);
                 if (!sf_new_i) {
                         LogRelFunc(("could not allocate memory for new inode info\n"));
@@ -346,9 +346,9 @@
                 sf_new_i->handle = SHFL_HANDLE_NIL;
 
-                ino = iunique (parent->i_sb, 1);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 25)
-                inode = iget_locked (parent->i_sb, ino);
+                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);
+                inode = iget(parent->i_sb, ino);
 #endif
                 if (!inode) {
@@ -358,9 +358,9 @@
                 }
 
-                SET_INODE_INFO (inode, sf_new_i);
-                sf_init_inode (sf_g, inode, &fsinfo);
+                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)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
                 unlock_new_inode(inode);
 #endif
@@ -370,13 +370,13 @@
         dentry->d_time = jiffies;
         dentry->d_op = &sf_dentry_ops;
-        d_add (dentry, inode);
+        d_add(dentry, inode);
         return NULL;
 
  fail2:
-        kfree (sf_new_i);
+        kfree(sf_new_i);
  fail1:
-        kfree (path);
+        kfree(path);
  fail0:
-        return ERR_PTR (err);
+        return ERR_PTR(err);
 }
 
@@ -385,5 +385,5 @@
    dentry */
 static int
-sf_instantiate (const char *caller, struct inode *parent,
+sf_instantiate(const char *caller, struct inode *parent,
                 struct dentry *dentry, SHFLSTRING *path,
                 RTFSOBJINFO *info, SHFLHANDLE handle)
@@ -393,10 +393,10 @@
         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);
+        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.  caller=%s\n", caller));
@@ -405,9 +405,9 @@
         }
 
-        ino = iunique (parent->i_sb, 1);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 25)
-        inode = iget_locked (parent->i_sb, ino);
+        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);
+        inode = iget(parent->i_sb, ino);
 #endif
         if (!inode) {
@@ -417,7 +417,7 @@
         }
 
-        sf_init_inode (sf_g, inode, info);
+        sf_init_inode(sf_g, inode, info);
         sf_new_i->path = path;
-        SET_INODE_INFO (inode, sf_new_i);
+        SET_INODE_INFO(inode, sf_new_i);
 
         dentry->d_time = jiffies;
@@ -425,7 +425,7 @@
         sf_new_i->force_restat = 1;
 
-        d_instantiate (dentry, inode);
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 25)
+        d_instantiate(dentry, inode);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
         unlock_new_inode(inode);
 #endif
@@ -436,5 +436,5 @@
 
  fail1:
-        kfree (sf_new_i);
+        kfree(sf_new_i);
  fail0:
         return err;
@@ -443,18 +443,18 @@
 
 static int
-sf_create_aux (struct inode *parent, struct dentry *dentry, int mode, int fDirectory)
+sf_create_aux(struct inode *parent, struct dentry *dentry, int 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);
+        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);
 
 #if 0
-        printk ("create_aux %s/%s\n", sf_i->path->String.utf8,
+        printk("create_aux %s/%s\n", sf_i->path->String.utf8,
                 dentry->d_name.name);
 #endif
@@ -466,18 +466,18 @@
 
         params.CreateFlags = 0
-                | SHFL_CF_ACT_CREATE_IF_NEW
-                | SHFL_CF_ACT_FAIL_IF_EXISTS
-                | SHFL_CF_ACCESS_READWRITE
-                | (fDirectory ? SHFL_CF_DIRECTORY : 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)
-                ;
+                               | (fDirectory ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE)
+                               | (mode & S_IRWXUGO)
+                               ;
 
         params.Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
 
-        err = sf_path_from_dentry (__func__, sf_g, sf_i, dentry, &path);
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
         if (err) {
                 goto fail0;
@@ -486,6 +486,6 @@
         LogFunc(("sf_create_aux: calling vboxCallCreate, folder %s, flags %#x\n",
                  path->String.utf8, params.CreateFlags));
-        rc = vboxCallCreate (&client_handle, &sf_g->map, path, &params);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallCreate(&client_handle, &sf_g->map, path, &params);
+        if (RT_FAILURE(rc)) {
                 if (rc == VERR_WRITE_PROTECT) {
                         err = -EROFS;
@@ -505,5 +505,5 @@
         }
 
-        err = sf_instantiate (__func__, parent, dentry, path, &params.Info,
+        err = sf_instantiate(__func__, parent, dentry, path, &params.Info,
                              fDirectory ? SHFL_HANDLE_NIL : params.Handle);
         if (err) {
@@ -520,6 +520,6 @@
         if (fDirectory)
         {
-                rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-                if (RT_FAILURE (rc)) {
+                rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+                if (RT_FAILURE(rc)) {
                         LogFunc(("(%d): vboxCallClose failed rc=%Rrc\n", fDirectory, rc));
                 }
@@ -530,54 +530,54 @@
 
  fail1:
-        rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("(%d): vboxCallClose failed rc=%Rrc\n", fDirectory, rc));
         }
 
  fail0:
-        kfree (path);
+        kfree(path);
         return err;
 }
 
 static int
-sf_create (struct inode *parent, struct dentry *dentry, int mode
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+sf_create(struct inode *parent, struct dentry *dentry, int mode
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
            , struct nameidata *nd
 #endif
         )
 {
-        TRACE ();
-        return sf_create_aux (parent, dentry, mode, 0);
-}
-
-static int
-sf_mkdir (struct inode *parent, struct dentry *dentry, int mode)
-{
-        TRACE ();
-        return sf_create_aux (parent, dentry, mode, 1);
-}
-
-static int
-sf_unlink_aux (struct inode *parent, struct dentry *dentry, int fDirectory)
+        TRACE();
+        return sf_create_aux(parent, dentry, mode, 0);
+}
+
+static int
+sf_mkdir(struct inode *parent, struct dentry *dentry, int mode)
+{
+        TRACE();
+        return sf_create_aux(parent, dentry, mode, 1);
+}
+
+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);
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
+        struct sf_inode_info *sf_i = GET_INODE_INFO(parent);
         SHFLSTRING *path;
 
-        TRACE ();
-        BUG_ON (!sf_g);
-
-        err = sf_path_from_dentry (__func__, sf_g, sf_i, dentry, &path);
+        TRACE();
+        BUG_ON(!sf_g);
+
+        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
         if (err) {
                 goto fail0;
         }
 
-        rc = vboxCallRemove (&client_handle, &sf_g->map, path,
+        rc = vboxCallRemove(&client_handle, &sf_g->map, path,
                              fDirectory ? SHFL_REMOVE_DIR : SHFL_REMOVE_FILE);
-        if (RT_FAILURE (rc)) {
+        if (RT_FAILURE(rc)) {
                 LogFunc(("(%d): vboxCallRemove(%s) failed rc=%Rrc\n", fDirectory,
                          path->String.utf8, rc));
-                         err = -RTErrConvertToErrno (rc);
+                         err = -RTErrConvertToErrno(rc);
                 goto fail1;
         }
@@ -587,9 +587,9 @@
         /* directory content changed */
         sf_i->force_reread = 1;
-        kfree (path);
+        kfree(path);
         return 0;
 
  fail1:
-        kfree (path);
+        kfree(path);
  fail0:
         return err;
@@ -597,44 +597,44 @@
 
 static int
-sf_unlink (struct inode *parent, struct dentry *dentry)
-{
-        TRACE ();
-        return sf_unlink_aux (parent, dentry, 0);
-}
-
-static int
-sf_rmdir (struct inode *parent, struct dentry *dentry)
-{
-        TRACE ();
-        return sf_unlink_aux (parent, dentry, 1);
-}
-
-static int
-sf_rename (struct inode *old_parent, struct dentry *old_dentry,
+sf_unlink(struct inode *parent, struct dentry *dentry)
+{
+        TRACE();
+        return sf_unlink_aux(parent, dentry, 0);
+}
+
+static int
+sf_rmdir(struct inode *parent, struct dentry *dentry)
+{
+        TRACE();
+        return sf_unlink_aux(parent, dentry, 1);
+}
+
+static int
+sf_rename(struct inode *old_parent, struct dentry *old_dentry,
            struct inode *new_parent, struct dentry *new_dentry)
 {
         int err = 0, rc = VINF_SUCCESS;
-        struct sf_glob_info *sf_g = GET_GLOB_INFO (old_parent->i_sb);
-
-        TRACE ();
-
-        if (sf_g != GET_GLOB_INFO (new_parent->i_sb)) {
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(old_parent->i_sb);
+
+        TRACE();
+
+        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);
+                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);
+                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);
+                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,
+                err = sf_path_from_dentry(__func__, sf_g, sf_new_i,
                                           new_dentry, &new_path);
                 if (err) {
@@ -643,8 +643,8 @@
                         int is_dir = ((old_dentry->d_inode->i_mode & S_IFDIR) != 0);
 
-                        rc = vboxCallRename (&client_handle, &sf_g->map, old_path,
+                        rc = vboxCallRename(&client_handle, &sf_g->map, old_path,
                                              new_path, is_dir ? 0 : SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
                         if (RT_SUCCESS(rc)) {
-                                kfree (old_path);
+                                kfree(old_path);
                                 sf_new_i->force_restat = 1;
                                 sf_old_i->force_restat = 1; /* XXX: needed? */
@@ -653,8 +653,8 @@
                         } else {
                                 LogFunc(("vboxCallRename failed rc=%Rrc\n", rc));
-                                err = -RTErrConvertToErrno (rc);
+                                err = -RTErrConvertToErrno(rc);
                         }
                         if (0 != err)
-                                kfree (new_path);
+                                kfree(new_path);
                 }
         }
@@ -669,5 +669,5 @@
         .unlink     = sf_unlink,
         .rename     = sf_rename,
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
         .revalidate = sf_inode_revalidate
 #else
Index: /trunk/src/VBox/Additions/linux/sharedfolders/mount.vboxsf.c
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/mount.vboxsf.c	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/mount.vboxsf.c	(revision 30153)
@@ -74,44 +74,44 @@
 
 static void PANIC_ATTR
-panic (const char *fmt, ...)
+panic(const char *fmt, ...)
 {
     va_list ap;
 
-    va_start (ap, fmt);
-    vfprintf (stderr, fmt, ap);
-    va_end (ap);
-    exit (EXIT_FAILURE);
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    exit(EXIT_FAILURE);
 }
 
 static void PANIC_ATTR
-panic_err (const char *fmt, ...)
+panic_err(const char *fmt, ...)
 {
     va_list ap;
     int errno_code = errno;
 
-    va_start (ap, fmt);
-    vfprintf (stderr, fmt, ap);
-    va_end (ap);
-    fprintf (stderr, ": %s\n", strerror (errno_code));
-    exit (EXIT_FAILURE);
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fprintf(stderr, ": %s\n", strerror(errno_code));
+    exit(EXIT_FAILURE);
 }
 
 static int
-safe_atoi (const char *s, size_t size, int base)
+safe_atoi(const char *s, size_t size, int base)
 {
     char *endptr;
-    long long int val = strtoll (s, &endptr, base);
+    long long int val = strtoll(s, &endptr, base);
 
     if (val < INT_MIN || val > INT_MAX || endptr < s + size)
     {
         errno = ERANGE;
-        panic_err ("could not convert %.*s to integer, result = %d",
+        panic_err("could not convert %.*s to integer, result = %d",
                    (int)size, s, (int) val);
     }
-    return (int) val;
+    return (int)val;
 }
 
 static void
-process_mount_opts (const char *s, struct opts *opts)
+process_mount_opts(const char *s, struct opts *opts)
 {
     const char *next = s;
@@ -180,8 +180,8 @@
 
         s = next;
-        next = strchr (s, ',');
+        next = strchr(s, ',');
         if (!next)
         {
-            len = strlen (s);
+            len = strlen(s);
         }
         else
@@ -220,5 +220,5 @@
                     if (!(val && *val))
                     {
-                        panic ("%.*s requires an argument (i.e. %.*s=<arg>)\n",
+                        panic("%.*s requires an argument (i.e. %.*s=<arg>)\n",
                                (int)len, s, (int)len, s);
                     }
@@ -256,43 +256,43 @@
                 case HOUID:
                     /** @todo convert string to id. */
-                    opts->uid = safe_atoi (val, val_len, 10);
+                    opts->uid = safe_atoi(val, val_len, 10);
                     break;
                 case HOGID:
                     /** @todo convert string to id. */
-                    opts->gid = safe_atoi (val, val_len, 10);
+                    opts->gid = safe_atoi(val, val_len, 10);
                     break;
                 case HOTTL:
-                    opts->ttl = safe_atoi (val, val_len, 10);
+                    opts->ttl = safe_atoi(val, val_len, 10);
                     break;
                 case HODMODE:
-                    opts->dmode = safe_atoi (val, val_len, 8);
+                    opts->dmode = safe_atoi(val, val_len, 8);
                     break;
                 case HOFMODE:
-                    opts->fmode = safe_atoi (val, val_len, 8);
+                    opts->fmode = safe_atoi(val, val_len, 8);
                     break;
                 case HOUMASK:
-                    opts->dmask = opts->fmask = safe_atoi (val, val_len, 8);
+                    opts->dmask = opts->fmask = safe_atoi(val, val_len, 8);
                     break;
                 case HODMASK:
-                    opts->dmask = safe_atoi (val, val_len, 8);
+                    opts->dmask = safe_atoi(val, val_len, 8);
                     break;
                 case HOFMASK:
-                    opts->fmask = safe_atoi (val, val_len, 8);
+                    opts->fmask = safe_atoi(val, val_len, 8);
                     break;
                 case HOIOCHARSET:
-                    if (val_len + 1 > sizeof (opts->nls_name))
+                    if (val_len + 1 > sizeof(opts->nls_name))
                     {
-                        panic ("iocharset name too long\n");
+                        panic("iocharset name too long\n");
                     }
-                    memcpy (opts->nls_name, val, val_len);
+                    memcpy(opts->nls_name, val, val_len);
                     opts->nls_name[val_len] = 0;
                     break;
                 case HOCONVERTCP:
-                    opts->convertcp = malloc (val_len + 1);
+                    opts->convertcp = malloc(val_len + 1);
                     if (!opts->convertcp)
                     {
-                        panic_err ("could not allocate memory");
+                        panic_err("could not allocate memory");
                     }
-                    memcpy (opts->convertcp, val, val_len);
+                    memcpy(opts->convertcp, val, val_len);
                     opts->convertcp[val_len] = 0;
                     break;
@@ -308,14 +308,14 @@
         if (!handler->name)
         {
-            fprintf (stderr, "unknown mount option `%.*s'\n", (int)len, s);
-            fprintf (stderr, "valid options:\n");
+            fprintf(stderr, "unknown mount option `%.*s'\n", (int)len, s);
+            fprintf(stderr, "valid options:\n");
 
             for (handler = handlers; handler->name; ++handler)
             {
                 if (handler->desc)
-                    fprintf (stderr, "  %-10s%s %s\n", handler->name,
+                    fprintf(stderr, "  %-10s%s %s\n", handler->name,
                          handler->has_arg ? "=<arg>" : "", handler->desc);
             }
-            exit (EXIT_FAILURE);
+            exit(EXIT_FAILURE);
         }
     }
@@ -323,5 +323,5 @@
 
 static void
-complete (char *host_name, char *mount_point,
+complete(char *host_name, char *mount_point,
           unsigned long flags, struct opts *opts)
 {
@@ -331,24 +331,24 @@
     struct mntent e;
 
-    m = open_memstream (&buf, &size);
+    m = open_memstream(&buf, &size);
     if (!m)
-        panic_err ("could not update mount table (failed to create memstream)");
+        panic_err("could not update mount table (failed to create memstream)");
 
     if (opts->uid)
-        fprintf (m, "uid=%d,", opts->uid);
+        fprintf(m, "uid=%d,", opts->uid);
     if (opts->gid)
-        fprintf (m, "gid=%d,", opts->gid);
+        fprintf(m, "gid=%d,", opts->gid);
     if (opts->ttl)
-        fprintf (m, "ttl=%d,", opts->ttl);
+        fprintf(m, "ttl=%d,", opts->ttl);
     if (*opts->nls_name)
-        fprintf (m, "iocharset=%s,", opts->nls_name);
+        fprintf(m, "iocharset=%s,", opts->nls_name);
     if (flags & MS_NOSUID)
-        fprintf (m, "%s,", MNTOPT_NOSUID);
+        fprintf(m, "%s,", MNTOPT_NOSUID);
     if (flags & MS_RDONLY)
-        fprintf (m, "%s,", MNTOPT_RO);
+        fprintf(m, "%s,", MNTOPT_RO);
     else
-        fprintf (m, "%s,", MNTOPT_RW);
-
-    fclose (m);
+        fprintf(m, "%s,", MNTOPT_RW);
+
+    fclose(m);
 
     if (size > 0)
@@ -357,7 +357,7 @@
         buf = "defaults";
 
-    f = setmntent (MOUNTED, "a+");
+    f = setmntent(MOUNTED, "a+");
     if (!f)
-        panic_err ("could not open mount table for update");
+        panic_err("could not open mount table for update");
 
     e.mnt_fsname = host_name;
@@ -368,36 +368,36 @@
     e.mnt_passno = 0;
 
-    if (addmntent (f, &e))
+    if (addmntent(f, &e))
     {
         if (size > 0)
         {
-            memset (buf, 0, size);
-            free (buf);
-        }
-        panic_err ("could not add an entry to the mount table");
-    }
-
-    endmntent (f);
+            memset(buf, 0, size);
+            free(buf);
+        }
+        panic_err("could not add an entry to the mount table");
+    }
+
+    endmntent(f);
 
     if (size > 0)
     {
-        memset (buf, 0, size);
-        free (buf);
+        memset(buf, 0, size);
+        free(buf);
     }
 }
 
 static void
-convertcp (char *in_codeset, char *host_name, struct vbsf_mount_info_new *info)
+convertcp(char *in_codeset, char *host_name, struct vbsf_mount_info_new *info)
 {
     char *i = host_name;
     char *o = info->name;
-    size_t ib = strlen (host_name);
-    size_t ob = sizeof (info->name) - 1;
+    size_t ib = strlen(host_name);
+    size_t ob = sizeof(info->name) - 1;
     iconv_t cd;
 
-    cd = iconv_open ("UTF-8", in_codeset);
+    cd = iconv_open("UTF-8", in_codeset);
     if (cd == (iconv_t) -1)
     {
-        panic_err ("could not convert share name, iconv_open `%s' failed",
+        panic_err("could not convert share name, iconv_open `%s' failed",
                    in_codeset);
     }
@@ -405,9 +405,9 @@
     while (ib)
     {
-        size_t c = iconv (cd, &i, &ib, &o, &ob);
+        size_t c = iconv(cd, &i, &ib, &o, &ob);
         if (c == (size_t) -1)
         {
-            panic_err ("could not convert share name(%s) at %d",
-                       host_name, (int)(strlen (host_name) - ib));
+            panic_err("could not convert share name(%s) at %d",
+                      host_name, (int)(strlen (host_name) - ib));
         }
     }
@@ -485,6 +485,6 @@
     mntinf.length       = sizeof(mntinf);
 
-    if (getuid ())
-        panic ("Only root can mount shared folders from the host.\n");
+    if (getuid())
+        panic("Only root can mount shared folders from the host.\n");
 
     if (!argv[0])
@@ -495,10 +495,10 @@
     CT_ASSERT(sizeof(gid_t) == sizeof(int));
 
-    while ((c = getopt (argc, argv, "rwno:h")) != -1)
+    while ((c = getopt(argc, argv, "rwno:h")) != -1)
     {
         switch (c)
         {
             default:
-                fprintf (stderr, "unknown option `%c:%#x'\n", c, c);
+                fprintf(stderr, "unknown option `%c:%#x'\n", c, c);
             case '?':
             case 'h':
@@ -513,5 +513,5 @@
 
             case 'o':
-                process_mount_opts (optarg, &opts);
+                process_mount_opts(optarg, &opts);
                 break;
 
@@ -529,17 +529,17 @@
 
     if (opts.convertcp)
-        convertcp (opts.convertcp, host_name, &mntinf);
+        convertcp(opts.convertcp, host_name, &mntinf);
     else
     {
-        if (strlen (host_name) > MAX_HOST_NAME - 1)
-            panic ("host name is too big\n");
-
-        strcpy (mntinf.name, host_name);
-    }
-
-    if (strlen (opts.nls_name) > MAX_NLS_NAME - 1)
-        panic ("%s: the character set name for I/O is too long.\n", argv[0]);
-
-    strcpy (mntinf.nls_name, opts.nls_name);
+        if (strlen(host_name) > MAX_HOST_NAME - 1)
+            panic("host name is too big\n");
+
+        strcpy(mntinf.name, host_name);
+    }
+
+    if (strlen(opts.nls_name) > MAX_NLS_NAME - 1)
+        panic("%s: the character set name for I/O is too long.\n", argv[0]);
+
+    strcpy(mntinf.nls_name, opts.nls_name);
 
     if (opts.ronly)
@@ -558,5 +558,5 @@
     mntinf.fmask = opts.fmask;
 
-    err = mount (NULL, mount_point, "vboxsf", flags, &mntinf);
+    err = mount(NULL, mount_point, "vboxsf", flags, &mntinf);
     if (err == -1 && errno == EPROTO)
     {
@@ -573,7 +573,7 @@
                 ++cchCWD;
             /* We checked before that we have enough space */
-            strcpy (mntinf.name, host_name + cchCWD);
-        }
-        err = mount (NULL, mount_point, "vboxsf", flags, &mntinf);
+            strcpy(mntinf.name, host_name + cchCWD);
+        }
+        err = mount(NULL, mount_point, "vboxsf", flags, &mntinf);
     }
     if (err == -1 && errno == EPROTO)
@@ -587,12 +587,12 @@
         mntinf_old.gid = mntinf.gid;
         mntinf_old.ttl = mntinf.ttl;
-        err = mount (NULL, mount_point, "vboxsf", flags, &mntinf_old);
+        err = mount(NULL, mount_point, "vboxsf", flags, &mntinf_old);
     }
     if (err)
-        panic_err ("%s: mounting failed with the error", argv[0]);
+        panic_err("%s: mounting failed with the error", argv[0]);
 
     if (!nomtab)
-        complete (host_name, mount_point, flags, &opts);
-
-    exit (EXIT_SUCCESS);
-}
+        complete(host_name, mount_point, flags, &opts);
+
+    exit(EXIT_SUCCESS);
+}
Index: /trunk/src/VBox/Additions/linux/sharedfolders/regops.c
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/regops.c	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/regops.c	(revision 30153)
@@ -24,5 +24,5 @@
 
 
-static void *alloc_bounch_buffer (size_t *tmp_sizep, PRTCCPHYS physp, size_t xfer_size, const char *caller)
+static void *alloc_bounch_buffer(size_t *tmp_sizep, PRTCCPHYS physp, size_t xfer_size, const char *caller)
 {
     size_t tmp_size;
@@ -33,9 +33,9 @@
     if (tmp_size > 16U*_1K)
         tmp_size = 16U*_1K;
-    tmp = kmalloc (tmp_size, GFP_KERNEL);
+    tmp = kmalloc(tmp_size, GFP_KERNEL);
     if (!tmp) {
 
         /* fall back on a page sized buffer. */
-        tmp = kmalloc (PAGE_SIZE, GFP_KERNEL);
+        tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
         if (!tmp) {
             LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size));
@@ -50,5 +50,5 @@
 }
 
-static void free_bounch_buffer (void *tmp)
+static void free_bounch_buffer(void *tmp)
 {
     kfree (tmp);
@@ -58,14 +58,14 @@
 /* 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)
+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)
 {
         /** @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 = vboxCallRead (&client_handle, &sf_g->map, sf_r->handle,
-                               pos, nread, buf, false /* already locked? */);
-        if (RT_FAILURE (rc)) {
+        int rc = vboxCallRead(&client_handle, &sf_g->map, sf_r->handle,
+                              pos, nread, buf, false /* already locked? */);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallRead failed. caller=%s, rc=%Rrc\n",
                          caller, rc));
@@ -76,5 +76,5 @@
 
 static int
-sf_reg_write_aux (const char *caller, struct sf_glob_info *sf_g,
+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)
@@ -83,7 +83,7 @@
          *        contiguous in physical memory (kmalloc or single page), we should
          *        use a physical address here to speed things up. */
-        int rc = vboxCallWrite (&client_handle, &sf_g->map, sf_r->handle,
+        int rc = vboxCallWrite(&client_handle, &sf_g->map, sf_r->handle,
                                 pos, nwritten, buf, false /* already locked? */);
-        if (RT_FAILURE (rc)) {
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallWrite failed. caller=%s, rc=%Rrc\n",
                          caller, rc));
@@ -94,5 +94,5 @@
 
 static ssize_t
-sf_reg_read (struct file *file, char *buf, size_t size, loff_t *off)
+sf_reg_read(struct file *file, char *buf, size_t size, loff_t *off)
 {
         int err;
@@ -103,10 +103,10 @@
         ssize_t total_bytes_read = 0;
         struct inode *inode = file->f_dentry->d_inode;
-        struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
+        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)) {
+        TRACE();
+        if (!S_ISREG(inode->i_mode)) {
                 LogFunc(("read from non regular file %d\n", inode->i_mode));
                 return -EINVAL;
@@ -119,5 +119,5 @@
         }
 
-        tmp = alloc_bounch_buffer (&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
+        tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
         if (!tmp)
             return -ENOMEM;
@@ -132,9 +132,9 @@
                 nread = to_read;
 
-                err = sf_reg_read_aux (__func__, sf_g, sf_r, tmp, &nread, pos);
+                err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos);
                 if (err)
                         goto fail;
 
-                if (copy_to_user (buf, tmp, nread)) {
+                if (copy_to_user(buf, tmp, nread)) {
                         err = -EFAULT;
                         goto fail;
@@ -151,14 +151,14 @@
 
         *off += total_bytes_read;
-        free_bounch_buffer (tmp);
+        free_bounch_buffer(tmp);
         return total_bytes_read;
 
  fail:
-        free_bounch_buffer (tmp);
+        free_bounch_buffer(tmp);
         return err;
 }
 
 static ssize_t
-sf_reg_write (struct file *file, const char *buf, size_t size, loff_t *off)
+sf_reg_write(struct file *file, const char *buf, size_t size, loff_t *off)
 {
         int err;
@@ -169,15 +169,15 @@
         ssize_t total_bytes_written = 0;
         struct inode *inode = file->f_dentry->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_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)) {
+        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;
@@ -196,5 +196,5 @@
                 return 0;
 
-        tmp = alloc_bounch_buffer (&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
+        tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
         if (!tmp)
                 return -ENOMEM;
@@ -209,5 +209,5 @@
                 nwritten = to_write;
 
-                if (copy_from_user (tmp, buf, to_write)) {
+                if (copy_from_user(tmp, buf, to_write)) {
                         err = -EFAULT;
                         goto fail;
@@ -216,10 +216,10 @@
 #if 1
                 if (VbglR0CanUsePhysPageList()) {
-                    err = VbglR0SfWritePhysCont (&client_handle, &sf_g->map, sf_r->handle,
-                                                 pos, &nwritten, tmp_phys);
+                    err = VbglR0SfWritePhysCont(&client_handle, &sf_g->map, sf_r->handle,
+                                                pos, &nwritten, tmp_phys);
                     err = RT_FAILURE(err) ? -EPROTO : 0;
                 } else
 #endif
-                    err = sf_reg_write_aux (__func__, sf_g, sf_r, tmp, &nwritten, pos);
+                    err = sf_reg_write_aux(__func__, sf_g, sf_r, tmp, &nwritten, pos);
                 if (err)
                         goto fail;
@@ -238,28 +238,28 @@
 
         sf_i->force_restat = 1;
-        free_bounch_buffer (tmp);
+        free_bounch_buffer(tmp);
         return total_bytes_written;
 
  fail:
-        free_bounch_buffer (tmp);
+        free_bounch_buffer(tmp);
         return err;
 }
 
 static int
-sf_reg_open (struct inode *inode, struct file *file)
+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_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);
+        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);
+        sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
         if (!sf_r) {
                 LogRelFunc(("could not allocate reg info\n"));
@@ -342,10 +342,10 @@
         LogFunc(("sf_reg_open: calling vboxCallCreate, file %s, flags=%#x, %#x\n",
                  sf_i->path->String.utf8 , file->f_flags, params.CreateFlags));
-        rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
-
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallCreate failed flags=%d,%#x rc=%Rrc\n",
                          file->f_flags, params.CreateFlags, rc));
-                kfree (sf_r);
+                kfree(sf_r);
                 return -RTErrConvertToErrno(rc);
         }
@@ -373,24 +373,24 @@
 
 static int
-sf_reg_release (struct inode *inode, struct file *file)
+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);
+        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);
-
-        rc = vboxCallClose (&client_handle, &sf_g->map, sf_r->handle);
-        if (RT_FAILURE (rc)) {
+        BUG_ON(!sf_g);
+        BUG_ON(!sf_r);
+
+        rc = vboxCallClose(&client_handle, &sf_g->map, sf_r->handle);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallClose failed rc=%Rrc\n", rc));
         }
 
-        kfree (sf_r);
+        kfree(sf_r);
         sf_i->file = NULL;
         sf_i->handle = SHFL_HANDLE_NIL;
@@ -399,14 +399,14 @@
 }
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
 static int
 sf_reg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+#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)
+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)
+sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int unused)
 # define SET_TYPE(t)
 #endif
@@ -419,43 +419,43 @@
         struct file *file = vma->vm_file;
         struct inode *inode = file->f_dentry->d_inode;
-        struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
+        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)
+        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);
+                SET_TYPE(VM_FAULT_SIGBUS);
                 return NOPAGE_SIGBUS;
         }
 #endif
 
-        page = alloc_page (GFP_HIGHUSER);
+        page = alloc_page(GFP_HIGHUSER);
         if (!page) {
                 LogRelFunc(("failed to allocate page\n"));
-#if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
                 return VM_FAULT_OOM;
 #else
-                SET_TYPE (VM_FAULT_OOM);
+                SET_TYPE(VM_FAULT_OOM);
                 return NOPAGE_OOM;
 #endif
         }
 
-        buf = kmap (page);
-#if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
+        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);
+        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)
+                kunmap(page);
+                put_page(page);
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
                 return VM_FAULT_SIGBUS;
 #else
-                SET_TYPE (VM_FAULT_SIGBUS);
+                SET_TYPE(VM_FAULT_SIGBUS);
                 return NOPAGE_SIGBUS;
 #endif
@@ -464,23 +464,23 @@
         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);
-#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);
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
+                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);
-#if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
+                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);
+        SET_TYPE(VM_FAULT_MAJOR);
         return page;
 #endif
@@ -488,5 +488,5 @@
 
 static struct vm_operations_struct sf_vma_ops = {
-#if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
         .fault = sf_reg_fault
 #else
@@ -496,7 +496,7 @@
 
 static int
-sf_reg_mmap (struct file *file, struct vm_area_struct *vma)
-{
-        TRACE ();
+sf_reg_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        TRACE();
         if (vma->vm_flags & VM_SHARED) {
                 LogFunc(("shared mmapping not available\n"));
@@ -514,6 +514,6 @@
         .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, 23)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
+# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
         .splice_read = generic_file_splice_read,
 # else
@@ -522,5 +522,5 @@
         .aio_read    = generic_file_aio_read,
         .aio_write   = generic_file_aio_write,
-# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 35)
+# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
         .fsync       = noop_fsync,
 # else
@@ -533,5 +533,5 @@
 
 struct inode_operations sf_reg_iops = {
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
         .revalidate = sf_inode_revalidate
 #else
@@ -542,10 +542,10 @@
 
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 static int
 sf_readpage(struct file *file, struct page *page)
 {
         struct inode *inode = file->f_dentry->d_inode;
-        struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
+        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;
@@ -554,18 +554,18 @@
         int ret;
 
-        TRACE ();
+        TRACE();
 
         buf = kmap(page);
-        ret = sf_reg_read_aux (__func__, sf_g, sf_r, buf, &nread, off);
+        ret = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
         if (ret) {
-            kunmap (page);
+            kunmap(page);
             if (PageLocked(page))
                 unlock_page(page);
             return ret;
         }
-        BUG_ON (nread > PAGE_SIZE);
+        BUG_ON(nread > PAGE_SIZE);
         memset(&buf[nread], 0, PAGE_SIZE - nread);
-        flush_dcache_page (page);
-        kunmap (page);
+        flush_dcache_page(page);
+        kunmap(page);
         SetPageUptodate(page);
             unlock_page(page);
@@ -578,6 +578,6 @@
         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 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;
@@ -588,5 +588,5 @@
         int err;
 
-        TRACE ();
+        TRACE();
 
         if (page->index >= end_index)
@@ -595,5 +595,5 @@
         buf = kmap(page);
 
-        err = sf_reg_write_aux (__func__, sf_g, sf_r, buf, &nwritten, off);
+        err = sf_reg_write_aux(__func__, sf_g, sf_r, buf, &nwritten, off);
         if (err < 0) {
                 ClearPageUptodate(page);
@@ -614,10 +614,10 @@
 }
 
-# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
+# 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 ();
+        TRACE();
 
         return simple_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
@@ -629,5 +629,5 @@
 {
         struct inode *inode = mapping->host;
-        struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
+        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
         struct sf_reg_info *sf_r = file->private_data;
         void *buf;
@@ -636,8 +636,8 @@
         int err;
 
-        TRACE ();
+        TRACE();
 
         buf = kmap(page);
-        err = sf_reg_write_aux (__func__, sf_g, sf_r, buf+from, &nwritten, pos);
+        err = sf_reg_write_aux(__func__, sf_g, sf_r, buf+from, &nwritten, pos);
         kunmap(page);
 
@@ -662,5 +662,5 @@
         .readpage      = sf_readpage,
         .writepage     = sf_writepage,
-# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
+# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
         .write_begin   = sf_write_begin,
         .write_end     = sf_write_end,
Index: /trunk/src/VBox/Additions/linux/sharedfolders/utils.c
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/utils.c	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/utils.c	(revision 30153)
@@ -35,28 +35,28 @@
  */
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
+#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);
+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)
+sf_timespec_from_ftime(RTTIMESPEC *ts, time_t *time)
 {
         int64_t t = 1000000000 * *time;
-        RTTimeSpecSetNano (ts, t);
+        RTTimeSpecSetNano(ts, t);
 }
 #else /* >= 2.6.0 */
 static void
-sf_ftime_from_timespec (struct timespec *tv, RTTIMESPEC *ts)
-{
-        int64_t t = RTTimeSpecGetNano (ts);
+sf_ftime_from_timespec(struct timespec *tv, RTTIMESPEC *ts)
+{
+        int64_t t = RTTimeSpecGetNano(ts);
         int64_t nsec;
 
-        nsec = do_div (t, 1000000000);
+        nsec = do_div(t, 1000000000);
         tv->tv_sec = t;
         tv->tv_nsec = nsec;
@@ -64,8 +64,8 @@
 
 static void
-sf_timespec_from_ftime (RTTIMESPEC *ts, struct timespec *tv)
+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);
+        RTTimeSpecSetNano(ts, t);
 }
 #endif /* >= 2.6.0 */
@@ -73,5 +73,5 @@
 /* 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,
+sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
                RTFSOBJINFO *info)
 {
@@ -80,27 +80,27 @@
         int mode;
 
-        TRACE ();
+        TRACE();
 
         attr = &info->Attr;
-        is_dir = RTFS_IS_DIRECTORY (attr->fMode);
+        is_dir = RTFS_IS_DIRECTORY(attr->fMode);
 
 #define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0;
-        mode = mode_set (ISUID);
-        mode |= mode_set (ISGID);
-
-        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(ISUID);
+        mode |= mode_set(ISGID);
+
+        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)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
         inode->i_mapping->a_ops = &sf_reg_aops;
         inode->i_mapping->backing_dev_info = &sf_g->bdi;
@@ -129,8 +129,8 @@
         inode->i_gid = sf_g->gid;
         inode->i_size = info->cbObject;
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 19) && !defined(KERNEL_FC6)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6)
         inode->i_blksize = 4096;
 #endif
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 11)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11)
         inode->i_blkbits = 12;
 #endif
@@ -138,17 +138,17 @@
         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);
+        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, RTFSOBJINFO *result, int ok_to_fail)
+sf_stat(const char *caller, struct sf_glob_info *sf_g,
+        SHFLSTRING *path, RTFSOBJINFO *result, int ok_to_fail)
 {
         int rc;
         SHFLCREATEPARMS params;
 
-        TRACE ();
+        TRACE();
 
         RT_ZERO(params);
@@ -156,6 +156,6 @@
         LogFunc(("sf_stat: calling vboxCallCreate, file %s, flags %#x\n",
                  path->String.utf8, params.CreateFlags));
-        rc = vboxCallCreate (&client_handle, &sf_g->map, path, &params);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallCreate(&client_handle, &sf_g->map, path, &params);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallCreate(%s) failed.  caller=%s, rc=%Rrc\n",
                          path->String.utf8, rc, caller));
@@ -182,5 +182,5 @@
    update inode attributes */
 int
-sf_inode_revalidate (struct dentry *dentry)
+sf_inode_revalidate(struct dentry *dentry)
 {
         int err;
@@ -189,5 +189,5 @@
         RTFSOBJINFO info;
 
-        TRACE ();
+        TRACE();
         if (!dentry || !dentry->d_inode) {
                 LogFunc(("no dentry(%p) or inode(%p)\n", dentry, dentry->d_inode));
@@ -195,16 +195,16 @@
         }
 
-        sf_g = GET_GLOB_INFO (dentry->d_inode->i_sb);
-        sf_i = GET_INODE_INFO (dentry->d_inode);
+        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);
+        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) {
@@ -214,5 +214,5 @@
         }
 
-        err = sf_stat (__func__, sf_g, sf_i->path, &info, 1);
+        err = sf_stat(__func__, sf_g, sf_i->path, &info, 1);
         if (err) {
                 return err;
@@ -220,5 +220,5 @@
 
         dentry->d_time = jiffies;
-        sf_init_inode (sf_g, dentry->d_inode, &info);
+        sf_init_inode(sf_g, dentry->d_inode, &info);
         return 0;
 }
@@ -228,12 +228,12 @@
    [sf_inode_revalidate] */
 static int
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
-sf_dentry_revalidate (struct dentry *dentry, int flags)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
+sf_dentry_revalidate(struct dentry *dentry, int flags)
 #else
-sf_dentry_revalidate (struct dentry *dentry, struct nameidata *nd)
-#endif
-{
-        TRACE ();
-        if (sf_inode_revalidate (dentry)) {
+sf_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
+#endif
+{
+        TRACE();
+        if (sf_inode_revalidate(dentry)) {
                 return 0;
         }
@@ -245,22 +245,22 @@
    has inode at all) from these new attributes we derive [kstat] via
    [generic_fillattr] */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 int
-sf_getattr (struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
+sf_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
 {
         int err;
 
-        TRACE ();
-        err = sf_inode_revalidate (dentry);
+        TRACE();
+        err = sf_inode_revalidate(dentry);
         if (err) {
                 return err;
         }
 
-        generic_fillattr (dentry->d_inode, kstat);
+        generic_fillattr(dentry->d_inode, kstat);
         return 0;
 }
 
 int
-sf_setattr (struct dentry *dentry, struct iattr *iattr)
+sf_setattr(struct dentry *dentry, struct iattr *iattr)
 {
         struct sf_glob_info *sf_g;
@@ -271,8 +271,8 @@
         int rc, err;
 
-        TRACE ();
-
-        sf_g = GET_GLOB_INFO (dentry->d_inode->i_sb);
-        sf_i = GET_INODE_INFO (dentry->d_inode);
+        TRACE();
+
+        sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
+        sf_i = GET_INODE_INFO(dentry->d_inode);
         err  = 0;
 
@@ -287,6 +287,6 @@
             params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
 
-        rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n",
                         sf_i->path->String.utf8, rc));
@@ -310,15 +310,15 @@
             if (iattr->ia_valid & ATTR_MODE)
             {
-                info.Attr.fMode  = mode_set (ISUID);
-                info.Attr.fMode |= mode_set (ISGID);
-                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);
+                info.Attr.fMode  = mode_set(ISUID);
+                info.Attr.fMode |= mode_set(ISGID);
+                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)
@@ -329,7 +329,7 @@
 
             if (iattr->ia_valid & ATTR_ATIME)
-                sf_timespec_from_ftime (&info.AccessTime, &iattr->ia_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);
+                sf_timespec_from_ftime(&info.ModificationTime, &iattr->ia_mtime);
             /* ignore ctime (inode change time) as it can't be set from userland anyway */
 
@@ -338,5 +338,5 @@
                                 SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer,
                                 (PSHFLDIRINFO)&info);
-            if (RT_FAILURE (rc)) {
+            if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallFSInfo(%s, FILE) failed rc=%Rrc\n",
                         sf_i->path->String.utf8, rc));
@@ -354,5 +354,5 @@
                                 SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer,
                                 (PSHFLDIRINFO)&info);
-            if (RT_FAILURE (rc)) {
+            if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallFSInfo(%s, SIZE) failed rc=%Rrc\n",
                         sf_i->path->String.utf8, rc));
@@ -362,6 +362,6 @@
         }
 
-        rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE (rc))
+        rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc))
         {
                 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
@@ -369,9 +369,9 @@
         }
 
-        return sf_inode_revalidate (dentry);
+        return sf_inode_revalidate(dentry);
 
 fail1:
-        rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
-        if (RT_FAILURE (rc))
+        rc = vboxCallClose(&client_handle, &sf_g->map, params.Handle);
+        if (RT_FAILURE(rc))
         {
                 LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
@@ -384,5 +384,5 @@
 
 static int
-sf_make_path (const char *caller, struct sf_inode_info *sf_i,
+sf_make_path(const char *caller, struct sf_inode_info *sf_i,
               const char *d_name, size_t d_len, SHFLSTRING **result)
 {
@@ -394,5 +394,5 @@
         int is_root = 0;
 
-        TRACE ();
+        TRACE();
         p_len = sf_i->path->u16Length;
         p_name = sf_i->path->String.utf8;
@@ -411,6 +411,6 @@
         }
 
-        shflstring_len = offsetof (SHFLSTRING, String.utf8) + path_len;
-        tmp = kmalloc (shflstring_len, GFP_KERNEL);
+        shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len;
+        tmp = kmalloc(shflstring_len, GFP_KERNEL);
         if (!tmp) {
                 LogRelFunc(("kmalloc failed, caller=%s\n", caller));
@@ -421,11 +421,11 @@
 
         if (is_root) {
-                memcpy (tmp->String.utf8, d_name, d_len + 1);
+                memcpy(tmp->String.utf8, d_name, d_len + 1);
         }
         else {
                 dst = tmp->String.utf8;
-                memcpy (dst, p_name, p_len);
+                memcpy(dst, p_name, p_len);
                 dst += p_len; *dst++ = '/';
-                memcpy (dst, d_name, d_len);
+                memcpy(dst, d_name, d_len);
                 dst[d_len] = 0;
         }
@@ -439,5 +439,5 @@
    [sf_make_path] which will allocate SHFLSTRING and fill it in */
 int
-sf_path_from_dentry (const char *caller, struct sf_glob_info *sf_g,
+sf_path_from_dentry(const char *caller, struct sf_glob_info *sf_g,
                      struct sf_inode_info *sf_i, struct dentry *dentry,
                      SHFLSTRING **result)
@@ -449,5 +449,5 @@
         size_t len = 0;
 
-        TRACE ();
+        TRACE();
         d_name = dentry->d_name.name;
         d_len = dentry->d_name.len;
@@ -462,5 +462,5 @@
 
                 out_bound_len = PATH_MAX;
-                out = kmalloc (out_bound_len, GFP_KERNEL);
+                out = kmalloc(out_bound_len, GFP_KERNEL);
                 name = out;
 
@@ -471,5 +471,5 @@
                         int nb;
 
-                        nb = sf_g->nls->char2uni (in, in_len, &uni);
+                        nb = sf_g->nls->char2uni(in, in_len, &uni);
                         if (nb < 0) {
                                 LogFunc(("nls->char2uni failed %x %d\n",
@@ -481,8 +481,8 @@
                         in += nb;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 31)
-                        nb = utf32_to_utf8 (uni, out, out_bound_len);
+#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);
+                        nb = utf8_wctomb(out, uni, out_bound_len);
 #endif
                         if (nb < 0) {
@@ -509,17 +509,17 @@
         }
 
-        err = sf_make_path (caller, sf_i, name, len, result);
+        err = sf_make_path(caller, sf_i, name, len, result);
         if (name != d_name) {
-                kfree (name);
+                kfree(name);
         }
         return err;
 
  fail1:
-        kfree (name);
+        kfree(name);
         return err;
 }
 
 int
-sf_nlscpy (struct sf_glob_info *sf_g,
+sf_nlscpy(struct sf_glob_info *sf_g,
            char *name, size_t name_bound_len,
            const unsigned char *utf8_name, size_t utf8_len)
@@ -543,8 +543,8 @@
                         wchar_t uni;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 31)
-                        nb = utf8_to_utf32 (in, in_bound_len, &uni);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
+                        nb = utf8_to_utf32(in, in_bound_len, &uni);
 #else
-                        nb = utf8_mbtowc (&uni, in, in_bound_len);
+                        nb = utf8_mbtowc(&uni, in, in_bound_len);
 #endif
                         if (nb < 0) {
@@ -556,5 +556,5 @@
                         in_bound_len -= nb;
 
-                        nb = sf_g->nls->uni2char (uni, out, out_bound_len);
+                        nb = sf_g->nls->uni2char(uni, out, out_bound_len);
                         if (nb < 0) {
                                 LogFunc(("nls->uni2char failed(%s) %x:%d\n",
@@ -575,5 +575,5 @@
                 }
                 else {
-                        memcpy (name, utf8_name, utf8_len + 1);
+                        memcpy(name, utf8_name, utf8_len + 1);
                 }
                 return 0;
@@ -582,10 +582,10 @@
 
 static struct sf_dir_buf *
-sf_dir_buf_alloc (void)
+sf_dir_buf_alloc(void)
 {
         struct sf_dir_buf *b;
 
-        TRACE ();
-        b = kmalloc (sizeof (*b), GFP_KERNEL);
+        TRACE();
+        b = kmalloc(sizeof(*b), GFP_KERNEL);
         if (!b) {
                 LogRelFunc(("could not alloc directory buffer\n"));
@@ -594,15 +594,15 @@
 
 #ifdef USE_VMALLOC
-        b->buf = vmalloc (16384);
+        b->buf = vmalloc(16384);
 #else
-        b->buf = kmalloc (16384, GFP_KERNEL);
+        b->buf = kmalloc(16384, GFP_KERNEL);
 #endif
         if (!b->buf) {
-                kfree (b);
+                kfree(b);
                 LogRelFunc(("could not alloc directory buffer storage\n"));
                 return NULL;
         }
 
-        INIT_LIST_HEAD (&b->head);
+        INIT_LIST_HEAD(&b->head);
         b->nb_entries = 0;
         b->used_bytes = 0;
@@ -612,32 +612,32 @@
 
 static void
-sf_dir_buf_free (struct sf_dir_buf *b)
-{
-        BUG_ON (!b || !b->buf);
-
-        TRACE ();
-        list_del (&b->head);
+sf_dir_buf_free(struct sf_dir_buf *b)
+{
+        BUG_ON(!b || !b->buf);
+
+        TRACE();
+        list_del(&b->head);
 #ifdef USE_VMALLOC
-        vfree (b->buf);
+        vfree(b->buf);
 #else
-        kfree (b->buf);
-#endif
-        kfree (b);
+        kfree(b->buf);
+#endif
+        kfree(b);
 }
 
 void
-sf_dir_info_free (struct sf_dir_info *p)
+sf_dir_info_free(struct sf_dir_info *p)
 {
         struct list_head *list, *pos, *tmp;
 
-        TRACE ();
+        TRACE();
         list = &p->info_list;
-        list_for_each_safe (pos, tmp, 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);
+                b = list_entry(pos, struct sf_dir_buf, head);
+                sf_dir_buf_free(b);
+        }
+        kfree(p);
 }
 
@@ -646,9 +646,9 @@
 {
         struct list_head *list, *pos, *tmp;
-        TRACE ();
+        TRACE();
         list = &p->info_list;
-        list_for_each_safe (pos, tmp, list) {
+        list_for_each_safe(pos, tmp, list) {
                 struct sf_dir_buf *b;
-                b = list_entry (pos, struct sf_dir_buf, head);
+                b = list_entry(pos, struct sf_dir_buf, head);
                 b->nb_entries = 0;
                 b->used_bytes = 0;
@@ -658,10 +658,10 @@
 
 struct sf_dir_info *
-sf_dir_info_alloc (void)
+sf_dir_info_alloc(void)
 {
         struct sf_dir_info *p;
 
-        TRACE ();
-        p = kmalloc (sizeof (*p), GFP_KERNEL);
+        TRACE();
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
         if (!p) {
                 LogRelFunc(("could not alloc directory info\n"));
@@ -669,18 +669,18 @@
         }
 
-        INIT_LIST_HEAD (&p->info_list);
+        INIT_LIST_HEAD(&p->info_list);
         return p;
 }
 
 static struct sf_dir_buf *
-sf_get_empty_dir_buf (struct sf_dir_info *sf_d)
+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) {
+        list_for_each(pos, list) {
                 struct sf_dir_buf *b;
 
-                b = list_entry (pos, struct sf_dir_buf, head);
+                b = list_entry(pos, struct sf_dir_buf, head);
                 if (!b) {
                         return NULL;
@@ -697,5 +697,5 @@
 
 int
-sf_dir_read_all (struct sf_glob_info *sf_g, struct sf_inode_info *sf_i,
+sf_dir_read_all(struct sf_glob_info *sf_g, struct sf_inode_info *sf_i,
                  struct sf_dir_info *sf_d, SHFLHANDLE handle)
 {
@@ -704,6 +704,6 @@
         struct sf_dir_buf *b;
 
-        TRACE ();
-        err = sf_make_path (__func__, sf_i, "*", 1, &mask);
+        TRACE();
+        err = sf_make_path(__func__, sf_i, "*", 1, &mask);
         if (err) {
                 goto fail0;
@@ -716,7 +716,7 @@
                 uint32_t nb_ents;
 
-                b = sf_get_empty_dir_buf (sf_d);
+                b = sf_get_empty_dir_buf(sf_d);
                 if (!b) {
-                        b = sf_dir_buf_alloc ();
+                        b = sf_dir_buf_alloc();
                         if (!b) {
                                 err = -ENOMEM;
@@ -724,5 +724,5 @@
                                 goto fail1;
                         }
-                        list_add (&b->head, &sf_d->info_list);
+                        list_add(&b->head, &sf_d->info_list);
                 }
 
@@ -730,15 +730,6 @@
                 buf_size = b->free_bytes;
 
-                rc = vboxCallDirInfo (
-                        &client_handle,
-                        &sf_g->map,
-                        handle,
-                        mask,
-                        0,
-                        0,
-                        &buf_size,
-                        buf,
-                        &nb_ents
-                        );
+                rc = vboxCallDirInfo(&client_handle, &sf_g->map, handle, mask,
+                                     0, 0, &buf_size, buf, &nb_ents);
                 switch (rc) {
                         case VINF_SUCCESS:
@@ -753,5 +744,5 @@
 
                         default:
-                                err = -RTErrConvertToErrno (rc);
+                                err = -RTErrConvertToErrno(rc);
                                 LogFunc(("vboxCallDirInfo failed rc=%Rrc\n", rc));
                                 goto fail1;
@@ -762,5 +753,5 @@
                 b->used_bytes += buf_size;
 
-                if (RT_FAILURE (rc))
+                if (RT_FAILURE(rc))
                         break;
         }
@@ -768,5 +759,5 @@
 
  fail1:
-        kfree (mask);
+        kfree(mask);
  fail0:
         return err;
@@ -780,5 +771,5 @@
         int rc;
 
-        sf_g = GET_GLOB_INFO (sb);
+        sf_g = GET_GLOB_INFO(sb);
         cbBuffer = sizeof(SHFLVolumeInfo);
         rc = vboxCallFSInfo(&client_handle, &sf_g->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
@@ -812,7 +803,7 @@
     int rc = 0;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
     sf_g->bdi.ra_pages = 0; /* No readahead */
-# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 12)
+# 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 */
@@ -821,7 +812,7 @@
                             | BDI_CAP_EXEC_MAP;     /* can be mapped for execution */
 # endif /* >= 2.6.12 */
-# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
+# 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 LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
     if (!rc)
         rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%s", name);
@@ -834,5 +825,5 @@
 void sf_done_backing_dev(struct sf_glob_info *sf_g)
 {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
     bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */
 #endif
Index: /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c	(revision 30153)
@@ -43,7 +43,7 @@
 // #define wchar_t linux_wchar_t
 
-MODULE_DESCRIPTION (VBOX_PRODUCT " VFS Module for Host File System Access");
-MODULE_AUTHOR (VBOX_VENDOR);
-MODULE_LICENSE ("GPL");
+MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access");
+MODULE_AUTHOR(VBOX_VENDOR);
+MODULE_LICENSE("GPL");
 #ifdef MODULE_VERSION
 MODULE_VERSION(VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")");
@@ -62,5 +62,5 @@
 /* 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)
+sf_glob_alloc(struct vbsf_mount_info_new *info, struct sf_glob_info **sf_gp)
 {
         int err, rc;
@@ -69,6 +69,6 @@
         struct sf_glob_info *sf_g;
 
-        TRACE ();
-        sf_g = kmalloc (sizeof (*sf_g), GFP_KERNEL);
+        TRACE();
+        sf_g = kmalloc(sizeof(*sf_g), GFP_KERNEL);
         if (!sf_g) {
                 err = -ENOMEM;
@@ -99,8 +99,8 @@
         }
 
-        info->name[sizeof (info->name) - 1] = 0;
-        info->nls_name[sizeof (info->nls_name) - 1] = 0;
-
-        name_len = strlen (info->name);
+        info->name[sizeof(info->name) - 1] = 0;
+        info->nls_name[sizeof(info->nls_name) - 1] = 0;
+
+        name_len = strlen(info->name);
         if (name_len > 0xfffe) {
                 err = -ENAMETOOLONG;
@@ -109,6 +109,6 @@
         }
 
-        str_len = offsetof (SHFLSTRING, String.utf8) + name_len + 1;
-        str_name = kmalloc (str_len, GFP_KERNEL);
+        str_len = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
+        str_name = kmalloc(str_len, GFP_KERNEL);
         if (!str_name) {
                 err = -ENOMEM;
@@ -119,8 +119,8 @@
         str_name->u16Length = name_len;
         str_name->u16Size = name_len + 1;
-        memcpy (str_name->String.utf8, info->name, name_len + 1);
-
-        if (info->nls_name[0] && strcmp (info->nls_name, "utf8")) {
-                sf_g->nls = load_nls (info->nls_name);
+        memcpy(str_name->String.utf8, info->name, name_len + 1);
+
+        if (info->nls_name[0] && strcmp(info->nls_name, "utf8")) {
+                sf_g->nls = load_nls(info->nls_name);
                 if (!sf_g->nls) {
                         err = -EINVAL;
@@ -133,8 +133,8 @@
         }
 
-        rc = vboxCallMapFolder (&client_handle, str_name, &sf_g->map);
-        kfree (str_name);
-
-        if (RT_FAILURE (rc)) {
+        rc = vboxCallMapFolder(&client_handle, str_name, &sf_g->map);
+        kfree(str_name);
+
+        if (RT_FAILURE(rc)) {
                 err = -EPROTO;
                 LogFunc(("vboxCallMapFolder failed rc=%d\n", rc));
@@ -165,8 +165,8 @@
  fail2:
         if (sf_g->nls) {
-                unload_nls (sf_g->nls);
+                unload_nls(sf_g->nls);
         }
  fail1:
-        kfree (sf_g);
+        kfree(sf_g);
  fail0:
         return err;
@@ -175,18 +175,18 @@
 /* unmap the share and free global info [sf_g] */
 static void
-sf_glob_free (struct sf_glob_info *sf_g)
+sf_glob_free(struct sf_glob_info *sf_g)
 {
         int rc;
 
-        TRACE ();
-        rc = vboxCallUnmapFolder (&client_handle, &sf_g->map);
-        if (RT_FAILURE (rc)) {
+        TRACE();
+        rc = vboxCallUnmapFolder(&client_handle, &sf_g->map);
+        if (RT_FAILURE(rc)) {
                 LogFunc(("vboxCallUnmapFolder failed rc=%d\n", rc));
         }
 
         if (sf_g->nls) {
-                unload_nls (sf_g->nls);
-        }
-        kfree (sf_g);
+                unload_nls(sf_g->nls);
+        }
+        kfree(sf_g);
 }
 
@@ -201,5 +201,5 @@
    should respect [flags] */
 static int
-sf_read_super_aux (struct super_block *sb, void *data, int flags)
+sf_read_super_aux(struct super_block *sb, void *data, int flags)
 {
         int err;
@@ -211,5 +211,5 @@
         struct vbsf_mount_info_new *info;
 
-        TRACE ();
+        TRACE();
         if (!data) {
                 LogFunc(("no mount info specified\n"));
@@ -224,21 +224,21 @@
         }
 
-        err = sf_glob_alloc (info, &sf_g);
+        err = sf_glob_alloc(info, &sf_g);
         if (err) {
                 goto fail0;
         }
 
-        sf_i = kmalloc (sizeof (*sf_i), GFP_KERNEL);
+        sf_i = kmalloc(sizeof (*sf_i), GFP_KERNEL);
         if (!sf_i) {
                 err = -ENOMEM;
-                LogRelFunc (("could not allocate memory for root inode info\n"));
+                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);
+        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"));
+                LogRelFunc(("could not allocate memory for root inode path\n"));
                 goto fail2;
         }
@@ -249,5 +249,5 @@
         sf_i->path->String.utf8[1] = 0;
 
-        err = sf_stat (__func__, sf_g, sf_i->path, &fsinfo, 0);
+        err = sf_stat(__func__, sf_g, sf_i->path, &fsinfo, 0);
         if (err) {
                 LogFunc(("could not stat root of share\n"));
@@ -257,5 +257,5 @@
         sb->s_magic = 0xface;
         sb->s_blocksize = 1024;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 3)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 3)
         /* Required for seek/sendfile.
          *
@@ -273,8 +273,8 @@
         sb->s_op = &sf_super_ops;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 25)
-        iroot = iget_locked (sb, 0);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 25)
+        iroot = iget_locked(sb, 0);
 #else
-        iroot = iget (sb, 0);
+        iroot = iget(sb, 0);
 #endif
         if (!iroot) {
@@ -290,12 +290,12 @@
         }
 
-        sf_init_inode (sf_g, iroot, &fsinfo);
-        SET_INODE_INFO (iroot, sf_i);
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 25)
+        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);
 #endif
 
-        droot = d_alloc_root (iroot);
+        droot = d_alloc_root(iroot);
         if (!droot) {
                 err = -ENOMEM;  /* XXX */
@@ -305,5 +305,5 @@
 
         sb->s_root = droot;
-        SET_GLOB_INFO (sb, sf_g);
+        SET_GLOB_INFO(sb, sf_g);
         return 0;
 
@@ -311,23 +311,23 @@
         sf_done_backing_dev(sf_g);
  fail4:
-        iput (iroot);
+        iput(iroot);
  fail3:
-        kfree (sf_i->path);
+        kfree(sf_i->path);
  fail2:
-        kfree (sf_i);
+        kfree(sf_i);
  fail1:
-        sf_glob_free (sf_g);
+        sf_glob_free(sf_g);
  fail0:
         return err;
 }
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
+#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)
+sf_read_super_24(struct super_block *sb, void *data, int flags)
 {
         int err;
 
-        TRACE ();
-        err = sf_read_super_aux (sb, data, flags);
+        TRACE();
+        err = sf_read_super_aux(sb, data, flags);
         if (err) {
                 return NULL;
@@ -341,18 +341,18 @@
    resources associated with this [inode] must be cleared here */
 static void
-sf_clear_inode (struct inode *inode)
+sf_clear_inode(struct inode *inode)
 {
         struct sf_inode_info *sf_i;
 
-        TRACE ();
-        sf_i = GET_INODE_INFO (inode);
+        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);
+        BUG_ON(!sf_i->path);
+        kfree(sf_i->path);
+        kfree(sf_i);
+        SET_INODE_INFO(inode, NULL);
 }
 
@@ -361,7 +361,7 @@
    hence we can't do anything here, and let lookup/whatever with the
    job to properly fill then [inode] */
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 25)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
 static void
-sf_read_inode (struct inode *inode)
+sf_read_inode(struct inode *inode)
 {
 }
@@ -371,17 +371,17 @@
    the folder and free [sf_g] */
 static void
-sf_put_super (struct super_block *sb)
+sf_put_super(struct super_block *sb)
 {
         struct sf_glob_info *sf_g;
 
-        sf_g = GET_GLOB_INFO (sb);
-        BUG_ON (!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)
+        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);
@@ -389,5 +389,5 @@
 #else
 static int
-sf_statfs (struct dentry *dentry, STRUCT_STATFS *stat)
+sf_statfs(struct dentry *dentry, STRUCT_STATFS *stat)
 {
         struct super_block *sb = dentry->d_inode->i_sb;
@@ -397,7 +397,7 @@
 
 static int
-sf_remount_fs (struct super_block *sb, int *flags, char *data)
-{
-        TRACE ();
+sf_remount_fs(struct super_block *sb, int *flags, char *data)
+{
+        TRACE();
         return -ENOSYS;
 }
@@ -405,5 +405,5 @@
 static struct super_operations sf_super_ops = {
         .clear_inode = sf_clear_inode,
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 25)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
         .read_inode  = sf_read_inode,
 #endif
@@ -413,35 +413,35 @@
 };
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
-static DECLARE_FSTYPE (vboxsf_fs_type, "vboxsf", sf_read_super_24, 0);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
+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)
+sf_read_super_26(struct super_block *sb, void *data, int flags)
 {
         int err;
 
-        TRACE ();
-        err = sf_read_super_aux (sb, data, flags);
+        TRACE();
+        err = sf_read_super_aux(sb, data, flags);
         if (err) {
-                printk (KERN_DEBUG "sf_read_super_aux err=%d\n", err);
+                printk(KERN_DEBUG "sf_read_super_aux err=%d\n", err);
         }
         return err;
 }
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 18)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
 static struct super_block *
-sf_get_sb (struct file_system_type *fs_type, int flags,
+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);
+        TRACE();
+        return get_sb_nodev(fs_type, flags, data, sf_read_super_26);
 }
 #else
 static int
-sf_get_sb (struct file_system_type *fs_type, int flags,
+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);
+        TRACE();
+        return get_sb_nodev(fs_type, flags, data, sf_read_super_26, mnt);
 }
 #endif
@@ -457,5 +457,5 @@
 /* Module initialization/finalization handlers */
 static int __init
-init (void)
+init(void)
 {
         int rcVBox;
@@ -463,16 +463,16 @@
         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);
+        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);
+        err = register_filesystem(&vboxsf_fs_type);
         if (err) {
                 LogFunc(("register_filesystem err=%d\n", err));
@@ -480,21 +480,21 @@
         }
 
-        rcVBox = vboxInit ();
-        if (RT_FAILURE (rcVBox)) {
-                LogRelFunc (("vboxInit failed, rc=%d\n", rcVBox));
+        rcVBox = vboxInit();
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("vboxInit failed, rc=%d\n", rcVBox));
                 rcRet = -EPROTO;
                 goto fail0;
         }
 
-        rcVBox = vboxConnect (&client_handle);
-        if (RT_FAILURE (rcVBox)) {
-                LogRelFunc (("vboxConnect failed, rc=%d\n", rcVBox));
+        rcVBox = vboxConnect(&client_handle);
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("vboxConnect failed, rc=%d\n", rcVBox));
                 rcRet = -EPROTO;
                 goto fail1;
         }
 
-        rcVBox = vboxCallSetUtf8 (&client_handle);
-        if (RT_FAILURE (rcVBox)) {
-                LogRelFunc (("vboxCallSetUtf8 failed, rc=%d\n", rcVBox));
+        rcVBox = vboxCallSetUtf8(&client_handle);
+        if (RT_FAILURE(rcVBox)) {
+                LogRelFunc(("vboxCallSetUtf8 failed, rc=%d\n", rcVBox));
                 rcRet = -EPROTO;
                 goto fail2;
@@ -508,44 +508,27 @@
 
  fail2:
-        vboxDisconnect (&client_handle);
+        vboxDisconnect(&client_handle);
  fail1:
-        vboxUninit ();
+        vboxUninit();
  fail0:
-        unregister_filesystem (&vboxsf_fs_type);
+        unregister_filesystem(&vboxsf_fs_type);
         return rcRet;
 }
 
 static void __exit
-fini (void)
-{
-        TRACE ();
-
-        vboxDisconnect (&client_handle);
-        vboxUninit ();
-        unregister_filesystem (&vboxsf_fs_type);
-}
-
-module_init (init);
-module_exit (fini);
+fini(void)
+{
+        TRACE();
+
+        vboxDisconnect(&client_handle);
+        vboxUninit();
+        unregister_filesystem(&vboxsf_fs_type);
+}
+
+module_init(init);
+module_exit(fini);
 
 /* C++ hack */
 int __gxx_personality_v0 = 0xdeadbeef;
-
-#if 0
-/* long long hacks (as far as i can see, gcc emits the refs to those
-   symbols, notwithstanding the fact that those aren't referenced
-   anywhere in the module) */
-void __divdi3 (void)
-{
-        elog ("called from %p\n", __builtin_return_address (0));
-        BUG ();
-}
-
-void __moddi3 (void)
-{
-        elog ("called from %p\n", __builtin_return_address (0));
-        BUG ();
-}
-#endif /* 0 */
 
 /*
Index: /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h
===================================================================
--- /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h	(revision 30152)
+++ /trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h	(revision 30153)
@@ -88,7 +88,6 @@
 extern struct address_space_operations sf_reg_aops;
 
-extern void
-sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
-              RTFSOBJINFO *info);
+extern void sf_init_inode(struct sf_glob_info *sf_g, struct inode *inode,
+                          RTFSOBJINFO *info);
 extern int sf_stat(const char *caller, struct sf_glob_info *sf_g,
                    SHFLSTRING *path, RTFSOBJINFO *result, int ok_to_fail);
@@ -114,7 +113,7 @@
 
 #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);
@@ -126,24 +125,24 @@
 #endif
 
-#define TRACE() LogFunc (("tracepoint\n"))
+#define TRACE() LogFunc(("tracepoint\n"))
 
 /* Following casts are here to prevent assignment of void * to
    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
 
